1 /* Everything about breakpoints, for GDB.
3 Copyright (C) 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
4 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
5 2008, 2009, 2010, 2011 Free Software Foundation, Inc.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
23 #include "arch-utils.h"
28 #include "breakpoint.h"
29 #include "tracepoint.h"
31 #include "expression.h"
37 #include "gdbthread.h"
40 #include "gdb_string.h"
42 #include "filenames.h"
48 #include "completer.h"
51 #include "cli/cli-script.h"
52 #include "gdb_assert.h"
57 #include "exceptions.h"
64 #include "xml-syscall.h"
65 #include "parser-defs.h"
66 #include "cli/cli-utils.h"
68 /* readline include files */
69 #include "readline/readline.h"
70 #include "readline/history.h"
72 /* readline defines this. */
75 #include "mi/mi-common.h"
76 #include "python/python.h"
78 /* Arguments to pass as context to some catch command handlers. */
79 #define CATCH_PERMANENT ((void *) (uintptr_t) 0)
80 #define CATCH_TEMPORARY ((void *) (uintptr_t) 1)
82 /* Prototypes for local functions. */
84 static void enable_delete_command (char *, int);
86 static void enable_once_command (char *, int);
88 static void disable_command (char *, int);
90 static void enable_command (char *, int);
92 static void map_breakpoint_numbers (char *, void (*) (struct breakpoint *,
96 static void ignore_command (char *, int);
98 static int breakpoint_re_set_one (void *);
100 static void clear_command (char *, int);
102 static void catch_command (char *, int);
104 static int can_use_hardware_watchpoint (struct value *, int);
106 static void break_command_1 (char *, int, int);
108 static void mention (struct breakpoint *);
110 /* This function is used in gdbtk sources and thus can not be made
112 struct breakpoint *set_raw_breakpoint (struct gdbarch *gdbarch,
113 struct symtab_and_line,
116 static void breakpoint_adjustment_warning (CORE_ADDR, CORE_ADDR, int, int);
118 static CORE_ADDR adjust_breakpoint_address (struct gdbarch *gdbarch,
122 static void describe_other_breakpoints (struct gdbarch *,
123 struct program_space *, CORE_ADDR,
124 struct obj_section *, int);
126 static int breakpoint_address_match (struct address_space *aspace1,
128 struct address_space *aspace2,
131 static int watchpoint_locations_match (struct bp_location *loc1,
132 struct bp_location *loc2);
134 static void breakpoints_info (char *, int);
136 static void watchpoints_info (char *, int);
138 static int breakpoint_1 (char *, int,
139 int (*) (const struct breakpoint *));
141 static int breakpoint_cond_eval (void *);
143 static void cleanup_executing_breakpoints (void *);
145 static void commands_command (char *, int);
147 static void condition_command (char *, int);
156 static int remove_breakpoint (struct bp_location *, insertion_state_t);
157 static int remove_breakpoint_1 (struct bp_location *, insertion_state_t);
159 static enum print_stop_action print_it_typical (bpstat);
161 static enum print_stop_action print_bp_stop_message (bpstat bs);
163 static int watchpoint_check (void *);
165 static void maintenance_info_breakpoints (char *, int);
167 static int hw_breakpoint_used_count (void);
169 static int hw_watchpoint_used_count (enum bptype, int *);
171 static void hbreak_command (char *, int);
173 static void thbreak_command (char *, int);
175 static void do_enable_breakpoint (struct breakpoint *, enum bpdisp);
177 static void stop_command (char *arg, int from_tty);
179 static void stopin_command (char *arg, int from_tty);
181 static void stopat_command (char *arg, int from_tty);
183 static char *ep_parse_optional_if_clause (char **arg);
185 static void catch_exception_command_1 (enum exception_event_kind ex_event,
186 char *arg, int tempflag, int from_tty);
188 static void tcatch_command (char *arg, int from_tty);
190 static void detach_single_step_breakpoints (void);
192 static int single_step_breakpoint_inserted_here_p (struct address_space *,
195 static void free_bp_location (struct bp_location *loc);
196 static void incref_bp_location (struct bp_location *loc);
197 static void decref_bp_location (struct bp_location **loc);
199 static struct bp_location *allocate_bp_location (struct breakpoint *bpt);
201 static void update_global_location_list (int);
203 static void update_global_location_list_nothrow (int);
205 static int is_hardware_watchpoint (const struct breakpoint *bpt);
207 static int is_watchpoint (const struct breakpoint *bpt);
209 static void insert_breakpoint_locations (void);
211 static int syscall_catchpoint_p (struct breakpoint *b);
213 static void tracepoints_info (char *, int);
215 static void delete_trace_command (char *, int);
217 static void enable_trace_command (char *, int);
219 static void disable_trace_command (char *, int);
221 static void trace_pass_command (char *, int);
223 /* Assuming we're creating a static tracepoint, does S look like a
224 static tracepoint marker spec ("-m MARKER_ID")? */
225 #define is_marker_spec(s) \
226 (s != NULL && strncmp (s, "-m", 2) == 0 && ((s)[2] == ' ' || (s)[2] == '\t'))
228 /* A reference-counted struct command_line. This lets multiple
229 breakpoints share a single command list. */
230 struct counted_command_line
232 /* The reference count. */
235 /* The command list. */
236 struct command_line *commands;
239 struct command_line *
240 breakpoint_commands (struct breakpoint *b)
242 return b->commands ? b->commands->commands : NULL;
245 /* Flag indicating that a command has proceeded the inferior past the
246 current breakpoint. */
248 static int breakpoint_proceeded;
251 bpdisp_text (enum bpdisp disp)
253 /* NOTE: the following values are a part of MI protocol and
254 represent values of 'disp' field returned when inferior stops at
256 static const char * const bpdisps[] = {"del", "dstp", "dis", "keep"};
258 return bpdisps[(int) disp];
261 /* Prototypes for exported functions. */
262 /* If FALSE, gdb will not use hardware support for watchpoints, even
263 if such is available. */
264 static int can_use_hw_watchpoints;
267 show_can_use_hw_watchpoints (struct ui_file *file, int from_tty,
268 struct cmd_list_element *c,
271 fprintf_filtered (file,
272 _("Debugger's willingness to use "
273 "watchpoint hardware is %s.\n"),
277 /* If AUTO_BOOLEAN_FALSE, gdb will not attempt to create pending breakpoints.
278 If AUTO_BOOLEAN_TRUE, gdb will automatically create pending breakpoints
279 for unrecognized breakpoint locations.
280 If AUTO_BOOLEAN_AUTO, gdb will query when breakpoints are unrecognized. */
281 static enum auto_boolean pending_break_support;
283 show_pending_break_support (struct ui_file *file, int from_tty,
284 struct cmd_list_element *c,
287 fprintf_filtered (file,
288 _("Debugger's behavior regarding "
289 "pending breakpoints is %s.\n"),
293 /* If 1, gdb will automatically use hardware breakpoints for breakpoints
294 set with "break" but falling in read-only memory.
295 If 0, gdb will warn about such breakpoints, but won't automatically
296 use hardware breakpoints. */
297 static int automatic_hardware_breakpoints;
299 show_automatic_hardware_breakpoints (struct ui_file *file, int from_tty,
300 struct cmd_list_element *c,
303 fprintf_filtered (file,
304 _("Automatic usage of hardware breakpoints is %s.\n"),
308 /* If on, gdb will keep breakpoints inserted even as inferior is
309 stopped, and immediately insert any new breakpoints. If off, gdb
310 will insert breakpoints into inferior only when resuming it, and
311 will remove breakpoints upon stop. If auto, GDB will behave as ON
312 if in non-stop mode, and as OFF if all-stop mode.*/
314 static const char always_inserted_auto[] = "auto";
315 static const char always_inserted_on[] = "on";
316 static const char always_inserted_off[] = "off";
317 static const char *always_inserted_enums[] = {
318 always_inserted_auto,
323 static const char *always_inserted_mode = always_inserted_auto;
325 show_always_inserted_mode (struct ui_file *file, int from_tty,
326 struct cmd_list_element *c, const char *value)
328 if (always_inserted_mode == always_inserted_auto)
329 fprintf_filtered (file,
330 _("Always inserted breakpoint "
331 "mode is %s (currently %s).\n"),
333 breakpoints_always_inserted_mode () ? "on" : "off");
335 fprintf_filtered (file, _("Always inserted breakpoint mode is %s.\n"),
340 breakpoints_always_inserted_mode (void)
342 return (always_inserted_mode == always_inserted_on
343 || (always_inserted_mode == always_inserted_auto && non_stop));
346 void _initialize_breakpoint (void);
348 /* Are we executing breakpoint commands? */
349 static int executing_breakpoint_commands;
351 /* Are overlay event breakpoints enabled? */
352 static int overlay_events_enabled;
354 /* See description in breakpoint.h. */
355 int target_exact_watchpoints = 0;
357 /* Walk the following statement or block through all breakpoints.
358 ALL_BREAKPOINTS_SAFE does so even if the statment deletes the
359 current breakpoint. */
361 #define ALL_BREAKPOINTS(B) for (B = breakpoint_chain; B; B = B->next)
363 #define ALL_BREAKPOINTS_SAFE(B,TMP) \
364 for (B = breakpoint_chain; \
365 B ? (TMP=B->next, 1): 0; \
368 /* Similar iterator for the low-level breakpoints. SAFE variant is
369 not provided so update_global_location_list must not be called
370 while executing the block of ALL_BP_LOCATIONS. */
372 #define ALL_BP_LOCATIONS(B,BP_TMP) \
373 for (BP_TMP = bp_location; \
374 BP_TMP < bp_location + bp_location_count && (B = *BP_TMP); \
377 /* Iterator for tracepoints only. */
379 #define ALL_TRACEPOINTS(B) \
380 for (B = breakpoint_chain; B; B = B->next) \
381 if (is_tracepoint (B))
383 /* Chains of all breakpoints defined. */
385 struct breakpoint *breakpoint_chain;
387 /* Array is sorted by bp_location_compare - primarily by the ADDRESS. */
389 static struct bp_location **bp_location;
391 /* Number of elements of BP_LOCATION. */
393 static unsigned bp_location_count;
395 /* Maximum alignment offset between bp_target_info.PLACED_ADDRESS and
396 ADDRESS for the current elements of BP_LOCATION which get a valid
397 result from bp_location_has_shadow. You can use it for roughly
398 limiting the subrange of BP_LOCATION to scan for shadow bytes for
399 an address you need to read. */
401 static CORE_ADDR bp_location_placed_address_before_address_max;
403 /* Maximum offset plus alignment between bp_target_info.PLACED_ADDRESS
404 + bp_target_info.SHADOW_LEN and ADDRESS for the current elements of
405 BP_LOCATION which get a valid result from bp_location_has_shadow.
406 You can use it for roughly limiting the subrange of BP_LOCATION to
407 scan for shadow bytes for an address you need to read. */
409 static CORE_ADDR bp_location_shadow_len_after_address_max;
411 /* The locations that no longer correspond to any breakpoint, unlinked
412 from bp_location array, but for which a hit may still be reported
414 VEC(bp_location_p) *moribund_locations = NULL;
416 /* Number of last breakpoint made. */
418 static int breakpoint_count;
420 /* The value of `breakpoint_count' before the last command that
421 created breakpoints. If the last (break-like) command created more
422 than one breakpoint, then the difference between BREAKPOINT_COUNT
423 and PREV_BREAKPOINT_COUNT is more than one. */
424 static int prev_breakpoint_count;
426 /* Number of last tracepoint made. */
428 static int tracepoint_count;
430 static struct cmd_list_element *breakpoint_set_cmdlist;
431 static struct cmd_list_element *breakpoint_show_cmdlist;
432 struct cmd_list_element *save_cmdlist;
434 /* Return whether a breakpoint is an active enabled breakpoint. */
436 breakpoint_enabled (struct breakpoint *b)
438 return (b->enable_state == bp_enabled);
441 /* Set breakpoint count to NUM. */
444 set_breakpoint_count (int num)
446 prev_breakpoint_count = breakpoint_count;
447 breakpoint_count = num;
448 set_internalvar_integer (lookup_internalvar ("bpnum"), num);
451 /* Used by `start_rbreak_breakpoints' below, to record the current
452 breakpoint count before "rbreak" creates any breakpoint. */
453 static int rbreak_start_breakpoint_count;
455 /* Called at the start an "rbreak" command to record the first
459 start_rbreak_breakpoints (void)
461 rbreak_start_breakpoint_count = breakpoint_count;
464 /* Called at the end of an "rbreak" command to record the last
468 end_rbreak_breakpoints (void)
470 prev_breakpoint_count = rbreak_start_breakpoint_count;
473 /* Used in run_command to zero the hit count when a new run starts. */
476 clear_breakpoint_hit_counts (void)
478 struct breakpoint *b;
484 /* Allocate a new counted_command_line with reference count of 1.
485 The new structure owns COMMANDS. */
487 static struct counted_command_line *
488 alloc_counted_command_line (struct command_line *commands)
490 struct counted_command_line *result
491 = xmalloc (sizeof (struct counted_command_line));
494 result->commands = commands;
498 /* Increment reference count. This does nothing if CMD is NULL. */
501 incref_counted_command_line (struct counted_command_line *cmd)
507 /* Decrement reference count. If the reference count reaches 0,
508 destroy the counted_command_line. Sets *CMDP to NULL. This does
509 nothing if *CMDP is NULL. */
512 decref_counted_command_line (struct counted_command_line **cmdp)
516 if (--(*cmdp)->refc == 0)
518 free_command_lines (&(*cmdp)->commands);
525 /* A cleanup function that calls decref_counted_command_line. */
528 do_cleanup_counted_command_line (void *arg)
530 decref_counted_command_line (arg);
533 /* Create a cleanup that calls decref_counted_command_line on the
536 static struct cleanup *
537 make_cleanup_decref_counted_command_line (struct counted_command_line **cmdp)
539 return make_cleanup (do_cleanup_counted_command_line, cmdp);
542 /* Default address, symtab and line to put a breakpoint at
543 for "break" command with no arg.
544 If default_breakpoint_valid is zero, the other three are
545 not valid, and "break" with no arg is an error.
547 This set by print_stack_frame, which calls set_default_breakpoint. */
549 int default_breakpoint_valid;
550 CORE_ADDR default_breakpoint_address;
551 struct symtab *default_breakpoint_symtab;
552 int default_breakpoint_line;
553 struct program_space *default_breakpoint_pspace;
556 /* Return the breakpoint with the specified number, or NULL
557 if the number does not refer to an existing breakpoint. */
560 get_breakpoint (int num)
562 struct breakpoint *b;
565 if (b->number == num)
574 set_breakpoint_condition (struct breakpoint *b, char *exp,
577 struct bp_location *loc = b->loc;
579 for (; loc; loc = loc->next)
584 xfree (b->cond_string);
585 b->cond_string = NULL;
592 printf_filtered (_("Breakpoint %d now unconditional.\n"), b->number);
598 /* I don't know if it matters whether this is the string the user
599 typed in or the decompiled expression. */
600 b->cond_string = xstrdup (arg);
601 b->condition_not_parsed = 0;
603 if (is_watchpoint (b))
605 innermost_block = NULL;
607 b->cond_exp = parse_exp_1 (&arg, 0, 0);
609 error (_("Junk at end of expression"));
610 b->cond_exp_valid_block = innermost_block;
614 for (loc = b->loc; loc; loc = loc->next)
618 parse_exp_1 (&arg, block_for_pc (loc->address), 0);
620 error (_("Junk at end of expression"));
624 breakpoints_changed ();
625 observer_notify_breakpoint_modified (b->number);
628 /* condition N EXP -- set break condition of breakpoint N to EXP. */
631 condition_command (char *arg, int from_tty)
633 struct breakpoint *b;
638 error_no_arg (_("breakpoint number"));
641 bnum = get_number (&p);
643 error (_("Bad breakpoint argument: '%s'"), arg);
646 if (b->number == bnum)
648 /* Check if this breakpoint has a Python object assigned to
649 it, and if it has a definition of the "stop"
650 method. This method and conditions entered into GDB from
651 the CLI are mutually exclusive. */
653 && gdbpy_breakpoint_has_py_cond (b->py_bp_object))
654 error (_("Cannot set a condition where a Python 'stop' "
655 "method has been defined in the breakpoint."));
656 set_breakpoint_condition (b, p, from_tty);
660 error (_("No breakpoint number %d."), bnum);
663 /* Check that COMMAND do not contain commands that are suitable
664 only for tracepoints and not suitable for ordinary breakpoints.
665 Throw if any such commands is found. */
668 check_no_tracepoint_commands (struct command_line *commands)
670 struct command_line *c;
672 for (c = commands; c; c = c->next)
676 if (c->control_type == while_stepping_control)
677 error (_("The 'while-stepping' command can "
678 "only be used for tracepoints"));
680 for (i = 0; i < c->body_count; ++i)
681 check_no_tracepoint_commands ((c->body_list)[i]);
683 /* Not that command parsing removes leading whitespace and comment
684 lines and also empty lines. So, we only need to check for
686 if (strstr (c->line, "collect ") == c->line)
687 error (_("The 'collect' command can only be used for tracepoints"));
689 if (strstr (c->line, "teval ") == c->line)
690 error (_("The 'teval' command can only be used for tracepoints"));
694 /* Encapsulate tests for different types of tracepoints. */
697 is_tracepoint (const struct breakpoint *b)
699 return (b->type == bp_tracepoint
700 || b->type == bp_fast_tracepoint
701 || b->type == bp_static_tracepoint);
704 /* A helper function that validsates that COMMANDS are valid for a
705 breakpoint. This function will throw an exception if a problem is
709 validate_commands_for_breakpoint (struct breakpoint *b,
710 struct command_line *commands)
712 if (is_tracepoint (b))
714 /* We need to verify that each top-level element of commands is
715 valid for tracepoints, that there's at most one
716 while-stepping element, and that while-stepping's body has
717 valid tracing commands excluding nested while-stepping. */
718 struct command_line *c;
719 struct command_line *while_stepping = 0;
720 for (c = commands; c; c = c->next)
722 if (c->control_type == while_stepping_control)
724 if (b->type == bp_fast_tracepoint)
725 error (_("The 'while-stepping' command "
726 "cannot be used for fast tracepoint"));
727 else if (b->type == bp_static_tracepoint)
728 error (_("The 'while-stepping' command "
729 "cannot be used for static tracepoint"));
732 error (_("The 'while-stepping' command "
733 "can be used only once"));
740 struct command_line *c2;
742 gdb_assert (while_stepping->body_count == 1);
743 c2 = while_stepping->body_list[0];
744 for (; c2; c2 = c2->next)
746 if (c2->control_type == while_stepping_control)
747 error (_("The 'while-stepping' command cannot be nested"));
753 check_no_tracepoint_commands (commands);
757 /* Return a vector of all the static tracepoints set at ADDR. The
758 caller is responsible for releasing the vector. */
761 static_tracepoints_here (CORE_ADDR addr)
763 struct breakpoint *b;
764 VEC(breakpoint_p) *found = 0;
765 struct bp_location *loc;
768 if (b->type == bp_static_tracepoint)
770 for (loc = b->loc; loc; loc = loc->next)
771 if (loc->address == addr)
772 VEC_safe_push(breakpoint_p, found, b);
778 /* Set the command list of B to COMMANDS. If breakpoint is tracepoint,
779 validate that only allowed commands are included. */
782 breakpoint_set_commands (struct breakpoint *b,
783 struct command_line *commands)
785 validate_commands_for_breakpoint (b, commands);
787 decref_counted_command_line (&b->commands);
788 b->commands = alloc_counted_command_line (commands);
789 breakpoints_changed ();
790 observer_notify_breakpoint_modified (b->number);
793 /* Set the internal `silent' flag on the breakpoint. Note that this
794 is not the same as the "silent" that may appear in the breakpoint's
798 breakpoint_set_silent (struct breakpoint *b, int silent)
800 int old_silent = b->silent;
803 if (old_silent != silent)
804 observer_notify_breakpoint_modified (b->number);
807 /* Set the thread for this breakpoint. If THREAD is -1, make the
808 breakpoint work for any thread. */
811 breakpoint_set_thread (struct breakpoint *b, int thread)
813 int old_thread = b->thread;
816 if (old_thread != thread)
817 observer_notify_breakpoint_modified (b->number);
820 /* Set the task for this breakpoint. If TASK is 0, make the
821 breakpoint work for any task. */
824 breakpoint_set_task (struct breakpoint *b, int task)
826 int old_task = b->task;
829 if (old_task != task)
830 observer_notify_breakpoint_modified (b->number);
834 check_tracepoint_command (char *line, void *closure)
836 struct breakpoint *b = closure;
838 validate_actionline (&line, b);
841 /* A structure used to pass information through
842 map_breakpoint_numbers. */
846 /* True if the command was typed at a tty. */
849 /* The breakpoint range spec. */
852 /* Non-NULL if the body of the commands are being read from this
853 already-parsed command. */
854 struct command_line *control;
856 /* The command lines read from the user, or NULL if they have not
858 struct counted_command_line *cmd;
861 /* A callback for map_breakpoint_numbers that sets the commands for
865 do_map_commands_command (struct breakpoint *b, void *data)
867 struct commands_info *info = data;
869 if (info->cmd == NULL)
871 struct command_line *l;
873 if (info->control != NULL)
874 l = copy_command_lines (info->control->body_list[0]);
877 struct cleanup *old_chain;
880 str = xstrprintf (_("Type commands for breakpoint(s) "
881 "%s, one per line."),
884 old_chain = make_cleanup (xfree, str);
886 l = read_command_lines (str,
889 ? check_tracepoint_command : 0),
892 do_cleanups (old_chain);
895 info->cmd = alloc_counted_command_line (l);
898 /* If a breakpoint was on the list more than once, we don't need to
900 if (b->commands != info->cmd)
902 validate_commands_for_breakpoint (b, info->cmd->commands);
903 incref_counted_command_line (info->cmd);
904 decref_counted_command_line (&b->commands);
905 b->commands = info->cmd;
906 breakpoints_changed ();
907 observer_notify_breakpoint_modified (b->number);
912 commands_command_1 (char *arg, int from_tty,
913 struct command_line *control)
915 struct cleanup *cleanups;
916 struct commands_info info;
918 info.from_tty = from_tty;
919 info.control = control;
921 /* If we read command lines from the user, then `info' will hold an
922 extra reference to the commands that we must clean up. */
923 cleanups = make_cleanup_decref_counted_command_line (&info.cmd);
925 if (arg == NULL || !*arg)
927 if (breakpoint_count - prev_breakpoint_count > 1)
928 arg = xstrprintf ("%d-%d", prev_breakpoint_count + 1,
930 else if (breakpoint_count > 0)
931 arg = xstrprintf ("%d", breakpoint_count);
934 /* So that we don't try to free the incoming non-NULL
935 argument in the cleanup below. Mapping breakpoint
936 numbers will fail in this case. */
941 /* The command loop has some static state, so we need to preserve
946 make_cleanup (xfree, arg);
950 map_breakpoint_numbers (arg, do_map_commands_command, &info);
952 if (info.cmd == NULL)
953 error (_("No breakpoints specified."));
955 do_cleanups (cleanups);
959 commands_command (char *arg, int from_tty)
961 commands_command_1 (arg, from_tty, NULL);
964 /* Like commands_command, but instead of reading the commands from
965 input stream, takes them from an already parsed command structure.
967 This is used by cli-script.c to DTRT with breakpoint commands
968 that are part of if and while bodies. */
969 enum command_control_type
970 commands_from_control_command (char *arg, struct command_line *cmd)
972 commands_command_1 (arg, 0, cmd);
973 return simple_control;
976 /* Return non-zero if BL->TARGET_INFO contains valid information. */
979 bp_location_has_shadow (struct bp_location *bl)
981 if (bl->loc_type != bp_loc_software_breakpoint)
985 if (bl->target_info.shadow_len == 0)
986 /* bp isn't valid, or doesn't shadow memory. */
991 /* Update BUF, which is LEN bytes read from the target address MEMADDR,
992 by replacing any memory breakpoints with their shadowed contents.
994 The range of shadowed area by each bp_location is:
995 bl->address - bp_location_placed_address_before_address_max
996 up to bl->address + bp_location_shadow_len_after_address_max
997 The range we were requested to resolve shadows for is:
998 memaddr ... memaddr + len
999 Thus the safe cutoff boundaries for performance optimization are
1000 memaddr + len <= (bl->address
1001 - bp_location_placed_address_before_address_max)
1003 bl->address + bp_location_shadow_len_after_address_max <= memaddr */
1006 breakpoint_restore_shadows (gdb_byte *buf, ULONGEST memaddr, LONGEST len)
1008 /* Left boundary, right boundary and median element of our binary
1010 unsigned bc_l, bc_r, bc;
1012 /* Find BC_L which is a leftmost element which may affect BUF
1013 content. It is safe to report lower value but a failure to
1014 report higher one. */
1017 bc_r = bp_location_count;
1018 while (bc_l + 1 < bc_r)
1020 struct bp_location *bl;
1022 bc = (bc_l + bc_r) / 2;
1023 bl = bp_location[bc];
1025 /* Check first BL->ADDRESS will not overflow due to the added
1026 constant. Then advance the left boundary only if we are sure
1027 the BC element can in no way affect the BUF content (MEMADDR
1028 to MEMADDR + LEN range).
1030 Use the BP_LOCATION_SHADOW_LEN_AFTER_ADDRESS_MAX safety
1031 offset so that we cannot miss a breakpoint with its shadow
1032 range tail still reaching MEMADDR. */
1034 if ((bl->address + bp_location_shadow_len_after_address_max
1036 && (bl->address + bp_location_shadow_len_after_address_max
1043 /* Due to the binary search above, we need to make sure we pick the
1044 first location that's at BC_L's address. E.g., if there are
1045 multiple locations at the same address, BC_L may end up pointing
1046 at a duplicate location, and miss the "master"/"inserted"
1047 location. Say, given locations L1, L2 and L3 at addresses A and
1050 L1@A, L2@A, L3@B, ...
1052 BC_L could end up pointing at location L2, while the "master"
1053 location could be L1. Since the `loc->inserted' flag is only set
1054 on "master" locations, we'd forget to restore the shadow of L1
1057 && bp_location[bc_l]->address == bp_location[bc_l - 1]->address)
1060 /* Now do full processing of the found relevant range of elements. */
1062 for (bc = bc_l; bc < bp_location_count; bc++)
1064 struct bp_location *bl = bp_location[bc];
1065 CORE_ADDR bp_addr = 0;
1069 /* bp_location array has BL->OWNER always non-NULL. */
1070 if (bl->owner->type == bp_none)
1071 warning (_("reading through apparently deleted breakpoint #%d?"),
1074 /* Performance optimization: any futher element can no longer affect BUF
1077 if (bl->address >= bp_location_placed_address_before_address_max
1078 && memaddr + len <= (bl->address
1079 - bp_location_placed_address_before_address_max))
1082 if (!bp_location_has_shadow (bl))
1084 if (!breakpoint_address_match (bl->target_info.placed_address_space, 0,
1085 current_program_space->aspace, 0))
1088 /* Addresses and length of the part of the breakpoint that
1090 bp_addr = bl->target_info.placed_address;
1091 bp_size = bl->target_info.shadow_len;
1093 if (bp_addr + bp_size <= memaddr)
1094 /* The breakpoint is entirely before the chunk of memory we
1098 if (bp_addr >= memaddr + len)
1099 /* The breakpoint is entirely after the chunk of memory we are
1103 /* Offset within shadow_contents. */
1104 if (bp_addr < memaddr)
1106 /* Only copy the second part of the breakpoint. */
1107 bp_size -= memaddr - bp_addr;
1108 bptoffset = memaddr - bp_addr;
1112 if (bp_addr + bp_size > memaddr + len)
1114 /* Only copy the first part of the breakpoint. */
1115 bp_size -= (bp_addr + bp_size) - (memaddr + len);
1118 memcpy (buf + bp_addr - memaddr,
1119 bl->target_info.shadow_contents + bptoffset, bp_size);
1124 /* Return true if BPT is of any hardware watchpoint kind. */
1127 is_hardware_watchpoint (const struct breakpoint *bpt)
1129 return (bpt->type == bp_hardware_watchpoint
1130 || bpt->type == bp_read_watchpoint
1131 || bpt->type == bp_access_watchpoint);
1134 /* Return true if BPT is of any watchpoint kind, hardware or
1138 is_watchpoint (const struct breakpoint *bpt)
1140 return (is_hardware_watchpoint (bpt)
1141 || bpt->type == bp_watchpoint);
1144 /* Assuming that B is a watchpoint: returns true if the current thread
1145 and its running state are safe to evaluate or update watchpoint B.
1146 Watchpoints on local expressions need to be evaluated in the
1147 context of the thread that was current when the watchpoint was
1148 created, and, that thread needs to be stopped to be able to select
1149 the correct frame context. Watchpoints on global expressions can
1150 be evaluated on any thread, and in any state. It is presently left
1151 to the target allowing memory accesses when threads are
1155 watchpoint_in_thread_scope (struct breakpoint *b)
1157 return (ptid_equal (b->watchpoint_thread, null_ptid)
1158 || (ptid_equal (inferior_ptid, b->watchpoint_thread)
1159 && !is_executing (inferior_ptid)));
1162 /* Set watchpoint B to disp_del_at_next_stop, even including its possible
1163 associated bp_watchpoint_scope breakpoint. */
1166 watchpoint_del_at_next_stop (struct breakpoint *b)
1168 gdb_assert (is_watchpoint (b));
1170 if (b->related_breakpoint != b)
1172 gdb_assert (b->related_breakpoint->type == bp_watchpoint_scope);
1173 gdb_assert (b->related_breakpoint->related_breakpoint == b);
1174 b->related_breakpoint->disposition = disp_del_at_next_stop;
1175 b->related_breakpoint->related_breakpoint = b->related_breakpoint;
1176 b->related_breakpoint = b;
1178 b->disposition = disp_del_at_next_stop;
1181 /* Assuming that B is a watchpoint:
1182 - Reparse watchpoint expression, if REPARSE is non-zero
1183 - Evaluate expression and store the result in B->val
1184 - Evaluate the condition if there is one, and store the result
1186 - Update the list of values that must be watched in B->loc.
1188 If the watchpoint disposition is disp_del_at_next_stop, then do
1189 nothing. If this is local watchpoint that is out of scope, delete
1192 Even with `set breakpoint always-inserted on' the watchpoints are
1193 removed + inserted on each stop here. Normal breakpoints must
1194 never be removed because they might be missed by a running thread
1195 when debugging in non-stop mode. On the other hand, hardware
1196 watchpoints (is_hardware_watchpoint; processed here) are specific
1197 to each LWP since they are stored in each LWP's hardware debug
1198 registers. Therefore, such LWP must be stopped first in order to
1199 be able to modify its hardware watchpoints.
1201 Hardware watchpoints must be reset exactly once after being
1202 presented to the user. It cannot be done sooner, because it would
1203 reset the data used to present the watchpoint hit to the user. And
1204 it must not be done later because it could display the same single
1205 watchpoint hit during multiple GDB stops. Note that the latter is
1206 relevant only to the hardware watchpoint types bp_read_watchpoint
1207 and bp_access_watchpoint. False hit by bp_hardware_watchpoint is
1208 not user-visible - its hit is suppressed if the memory content has
1211 The following constraints influence the location where we can reset
1212 hardware watchpoints:
1214 * target_stopped_by_watchpoint and target_stopped_data_address are
1215 called several times when GDB stops.
1218 * Multiple hardware watchpoints can be hit at the same time,
1219 causing GDB to stop. GDB only presents one hardware watchpoint
1220 hit at a time as the reason for stopping, and all the other hits
1221 are presented later, one after the other, each time the user
1222 requests the execution to be resumed. Execution is not resumed
1223 for the threads still having pending hit event stored in
1224 LWP_INFO->STATUS. While the watchpoint is already removed from
1225 the inferior on the first stop the thread hit event is kept being
1226 reported from its cached value by linux_nat_stopped_data_address
1227 until the real thread resume happens after the watchpoint gets
1228 presented and thus its LWP_INFO->STATUS gets reset.
1230 Therefore the hardware watchpoint hit can get safely reset on the
1231 watchpoint removal from inferior. */
1234 update_watchpoint (struct breakpoint *b, int reparse)
1236 int within_current_scope;
1237 struct frame_id saved_frame_id;
1240 gdb_assert (is_watchpoint (b));
1242 /* If this is a local watchpoint, we only want to check if the
1243 watchpoint frame is in scope if the current thread is the thread
1244 that was used to create the watchpoint. */
1245 if (!watchpoint_in_thread_scope (b))
1248 if (b->disposition == disp_del_at_next_stop)
1253 /* Determine if the watchpoint is within scope. */
1254 if (b->exp_valid_block == NULL)
1255 within_current_scope = 1;
1258 struct frame_info *fi = get_current_frame ();
1259 struct gdbarch *frame_arch = get_frame_arch (fi);
1260 CORE_ADDR frame_pc = get_frame_pc (fi);
1262 /* If we're in a function epilogue, unwinding may not work
1263 properly, so do not attempt to recreate locations at this
1264 point. See similar comments in watchpoint_check. */
1265 if (gdbarch_in_function_epilogue_p (frame_arch, frame_pc))
1268 /* Save the current frame's ID so we can restore it after
1269 evaluating the watchpoint expression on its own frame. */
1270 /* FIXME drow/2003-09-09: It would be nice if evaluate_expression
1271 took a frame parameter, so that we didn't have to change the
1274 saved_frame_id = get_frame_id (get_selected_frame (NULL));
1276 fi = frame_find_by_id (b->watchpoint_frame);
1277 within_current_scope = (fi != NULL);
1278 if (within_current_scope)
1282 /* We don't free locations. They are stored in the bp_location array
1283 and update_global_location_list will eventually delete them and
1284 remove breakpoints if needed. */
1287 if (within_current_scope && reparse)
1296 s = b->exp_string_reparse ? b->exp_string_reparse : b->exp_string;
1297 b->exp = parse_exp_1 (&s, b->exp_valid_block, 0);
1298 /* If the meaning of expression itself changed, the old value is
1299 no longer relevant. We don't want to report a watchpoint hit
1300 to the user when the old value and the new value may actually
1301 be completely different objects. */
1302 value_free (b->val);
1306 /* Note that unlike with breakpoints, the watchpoint's condition
1307 expression is stored in the breakpoint object, not in the
1308 locations (re)created below. */
1309 if (b->cond_string != NULL)
1311 if (b->cond_exp != NULL)
1313 xfree (b->cond_exp);
1318 b->cond_exp = parse_exp_1 (&s, b->cond_exp_valid_block, 0);
1322 /* If we failed to parse the expression, for example because
1323 it refers to a global variable in a not-yet-loaded shared library,
1324 don't try to insert watchpoint. We don't automatically delete
1325 such watchpoint, though, since failure to parse expression
1326 is different from out-of-scope watchpoint. */
1327 if ( !target_has_execution)
1329 /* Without execution, memory can't change. No use to try and
1330 set watchpoint locations. The watchpoint will be reset when
1331 the target gains execution, through breakpoint_re_set. */
1333 else if (within_current_scope && b->exp)
1336 struct value *val_chain, *v, *result, *next;
1337 struct program_space *frame_pspace;
1339 fetch_subexp_value (b->exp, &pc, &v, &result, &val_chain);
1341 /* Avoid setting b->val if it's already set. The meaning of
1342 b->val is 'the last value' user saw, and we should update
1343 it only if we reported that last value to user. As it
1344 happens, the code that reports it updates b->val directly. */
1351 frame_pspace = get_frame_program_space (get_selected_frame (NULL));
1353 /* Look at each value on the value chain. */
1354 for (v = val_chain; v; v = value_next (v))
1356 /* If it's a memory location, and GDB actually needed
1357 its contents to evaluate the expression, then we
1358 must watch it. If the first value returned is
1359 still lazy, that means an error occurred reading it;
1360 watch it anyway in case it becomes readable. */
1361 if (VALUE_LVAL (v) == lval_memory
1362 && (v == val_chain || ! value_lazy (v)))
1364 struct type *vtype = check_typedef (value_type (v));
1366 /* We only watch structs and arrays if user asked
1367 for it explicitly, never if they just happen to
1368 appear in the middle of some value chain. */
1370 || (TYPE_CODE (vtype) != TYPE_CODE_STRUCT
1371 && TYPE_CODE (vtype) != TYPE_CODE_ARRAY))
1375 struct bp_location *loc, **tmp;
1377 addr = value_address (v);
1378 len = TYPE_LENGTH (value_type (v));
1380 if (b->type == bp_read_watchpoint)
1382 else if (b->type == bp_access_watchpoint)
1385 loc = allocate_bp_location (b);
1386 for (tmp = &(b->loc); *tmp != NULL; tmp = &((*tmp)->next))
1389 loc->gdbarch = get_type_arch (value_type (v));
1391 loc->pspace = frame_pspace;
1392 loc->address = addr;
1394 loc->watchpoint_type = type;
1399 /* Change the type of breakpoint between hardware assisted or
1400 an ordinary watchpoint depending on the hardware support
1401 and free hardware slots. REPARSE is set when the inferior
1403 if ((b->type == bp_watchpoint || b->type == bp_hardware_watchpoint)
1407 enum bp_loc_type loc_type;
1408 struct bp_location *bl;
1410 reg_cnt = can_use_hardware_watchpoint (val_chain, b->exact);
1414 int i, target_resources_ok, other_type_used;
1415 enum enable_state orig_enable_state;
1417 /* We need to determine how many resources are already
1418 used for all other hardware watchpoints plus this one
1419 to see if we still have enough resources to also fit
1420 this watchpoint in as well. To guarantee the
1421 hw_watchpoint_used_count call below counts this
1422 watchpoint, make sure that it is marked as a hardware
1424 b->type = bp_hardware_watchpoint;
1426 /* hw_watchpoint_used_count ignores disabled watchpoints,
1427 and b might be disabled if we're being called from
1428 do_enable_breakpoint. */
1429 orig_enable_state = b->enable_state;
1430 b->enable_state = bp_enabled;
1432 i = hw_watchpoint_used_count (bp_hardware_watchpoint,
1435 b->enable_state = orig_enable_state;
1437 target_resources_ok = target_can_use_hardware_watchpoint
1438 (bp_hardware_watchpoint, i, other_type_used);
1439 if (target_resources_ok <= 0)
1440 b->type = bp_watchpoint;
1443 b->type = bp_watchpoint;
1445 loc_type = (b->type == bp_watchpoint? bp_loc_other
1446 : bp_loc_hardware_watchpoint);
1447 for (bl = b->loc; bl; bl = bl->next)
1448 bl->loc_type = loc_type;
1451 for (v = val_chain; v; v = next)
1453 next = value_next (v);
1458 /* If a software watchpoint is not watching any memory, then the
1459 above left it without any location set up. But,
1460 bpstat_stop_status requires a location to be able to report
1461 stops, so make sure there's at least a dummy one. */
1462 if (b->type == bp_watchpoint && b->loc == NULL)
1464 b->loc = allocate_bp_location (b);
1465 b->loc->pspace = frame_pspace;
1466 b->loc->address = -1;
1467 b->loc->length = -1;
1468 b->loc->watchpoint_type = -1;
1471 else if (!within_current_scope)
1473 printf_filtered (_("\
1474 Watchpoint %d deleted because the program has left the block\n\
1475 in which its expression is valid.\n"),
1477 watchpoint_del_at_next_stop (b);
1480 /* Restore the selected frame. */
1482 select_frame (frame_find_by_id (saved_frame_id));
1486 /* Returns 1 iff breakpoint location should be
1487 inserted in the inferior. */
1489 should_be_inserted (struct bp_location *bl)
1491 if (bl->owner == NULL || !breakpoint_enabled (bl->owner))
1494 if (bl->owner->disposition == disp_del_at_next_stop)
1497 if (!bl->enabled || bl->shlib_disabled || bl->duplicate)
1500 /* This is set for example, when we're attached to the parent of a
1501 vfork, and have detached from the child. The child is running
1502 free, and we expect it to do an exec or exit, at which point the
1503 OS makes the parent schedulable again (and the target reports
1504 that the vfork is done). Until the child is done with the shared
1505 memory region, do not insert breakpoints in the parent, otherwise
1506 the child could still trip on the parent's breakpoints. Since
1507 the parent is blocked anyway, it won't miss any breakpoint. */
1508 if (bl->pspace->breakpoints_not_allowed)
1511 /* Tracepoints are inserted by the target at a time of its choosing,
1513 if (is_tracepoint (bl->owner))
1519 /* Insert a low-level "breakpoint" of some type. BL is the breakpoint
1520 location. Any error messages are printed to TMP_ERROR_STREAM; and
1521 DISABLED_BREAKS, and HW_BREAKPOINT_ERROR are used to report problems.
1523 NOTE drow/2003-09-09: This routine could be broken down to an
1524 object-style method for each breakpoint or catchpoint type. */
1526 insert_bp_location (struct bp_location *bl,
1527 struct ui_file *tmp_error_stream,
1528 int *disabled_breaks,
1529 int *hw_breakpoint_error)
1533 if (!should_be_inserted (bl) || bl->inserted)
1536 /* Initialize the target-specific information. */
1537 memset (&bl->target_info, 0, sizeof (bl->target_info));
1538 bl->target_info.placed_address = bl->address;
1539 bl->target_info.placed_address_space = bl->pspace->aspace;
1541 if (bl->loc_type == bp_loc_software_breakpoint
1542 || bl->loc_type == bp_loc_hardware_breakpoint)
1544 if (bl->owner->type != bp_hardware_breakpoint)
1546 /* If the explicitly specified breakpoint type
1547 is not hardware breakpoint, check the memory map to see
1548 if the breakpoint address is in read only memory or not.
1550 Two important cases are:
1551 - location type is not hardware breakpoint, memory
1552 is readonly. We change the type of the location to
1553 hardware breakpoint.
1554 - location type is hardware breakpoint, memory is
1555 read-write. This means we've previously made the
1556 location hardware one, but then the memory map changed,
1559 When breakpoints are removed, remove_breakpoints will use
1560 location types we've just set here, the only possible
1561 problem is that memory map has changed during running
1562 program, but it's not going to work anyway with current
1564 struct mem_region *mr
1565 = lookup_mem_region (bl->target_info.placed_address);
1569 if (automatic_hardware_breakpoints)
1571 enum bp_loc_type new_type;
1573 if (mr->attrib.mode != MEM_RW)
1574 new_type = bp_loc_hardware_breakpoint;
1576 new_type = bp_loc_software_breakpoint;
1578 if (new_type != bl->loc_type)
1580 static int said = 0;
1582 bl->loc_type = new_type;
1585 fprintf_filtered (gdb_stdout,
1586 _("Note: automatically using "
1587 "hardware breakpoints for "
1588 "read-only addresses.\n"));
1593 else if (bl->loc_type == bp_loc_software_breakpoint
1594 && mr->attrib.mode != MEM_RW)
1595 warning (_("cannot set software breakpoint "
1596 "at readonly address %s"),
1597 paddress (bl->gdbarch, bl->address));
1601 /* First check to see if we have to handle an overlay. */
1602 if (overlay_debugging == ovly_off
1603 || bl->section == NULL
1604 || !(section_is_overlay (bl->section)))
1606 /* No overlay handling: just set the breakpoint. */
1608 if (bl->loc_type == bp_loc_hardware_breakpoint)
1609 val = target_insert_hw_breakpoint (bl->gdbarch,
1612 val = target_insert_breakpoint (bl->gdbarch,
1617 /* This breakpoint is in an overlay section.
1618 Shall we set a breakpoint at the LMA? */
1619 if (!overlay_events_enabled)
1621 /* Yes -- overlay event support is not active,
1622 so we must try to set a breakpoint at the LMA.
1623 This will not work for a hardware breakpoint. */
1624 if (bl->loc_type == bp_loc_hardware_breakpoint)
1625 warning (_("hardware breakpoint %d not supported in overlay!"),
1629 CORE_ADDR addr = overlay_unmapped_address (bl->address,
1631 /* Set a software (trap) breakpoint at the LMA. */
1632 bl->overlay_target_info = bl->target_info;
1633 bl->overlay_target_info.placed_address = addr;
1634 val = target_insert_breakpoint (bl->gdbarch,
1635 &bl->overlay_target_info);
1637 fprintf_unfiltered (tmp_error_stream,
1638 "Overlay breakpoint %d "
1639 "failed: in ROM?\n",
1643 /* Shall we set a breakpoint at the VMA? */
1644 if (section_is_mapped (bl->section))
1646 /* Yes. This overlay section is mapped into memory. */
1647 if (bl->loc_type == bp_loc_hardware_breakpoint)
1648 val = target_insert_hw_breakpoint (bl->gdbarch,
1651 val = target_insert_breakpoint (bl->gdbarch,
1656 /* No. This breakpoint will not be inserted.
1657 No error, but do not mark the bp as 'inserted'. */
1664 /* Can't set the breakpoint. */
1665 if (solib_name_from_address (bl->pspace, bl->address))
1667 /* See also: disable_breakpoints_in_shlibs. */
1669 bl->shlib_disabled = 1;
1670 if (!*disabled_breaks)
1672 fprintf_unfiltered (tmp_error_stream,
1673 "Cannot insert breakpoint %d.\n",
1675 fprintf_unfiltered (tmp_error_stream,
1676 "Temporarily disabling shared "
1677 "library breakpoints:\n");
1679 *disabled_breaks = 1;
1680 fprintf_unfiltered (tmp_error_stream,
1681 "breakpoint #%d\n", bl->owner->number);
1685 if (bl->loc_type == bp_loc_hardware_breakpoint)
1687 *hw_breakpoint_error = 1;
1688 fprintf_unfiltered (tmp_error_stream,
1689 "Cannot insert hardware "
1695 fprintf_unfiltered (tmp_error_stream,
1696 "Cannot insert breakpoint %d.\n",
1698 fprintf_filtered (tmp_error_stream,
1699 "Error accessing memory address ");
1700 fputs_filtered (paddress (bl->gdbarch, bl->address),
1702 fprintf_filtered (tmp_error_stream, ": %s.\n",
1703 safe_strerror (val));
1714 else if (bl->loc_type == bp_loc_hardware_watchpoint
1715 /* NOTE drow/2003-09-08: This state only exists for removing
1716 watchpoints. It's not clear that it's necessary... */
1717 && bl->owner->disposition != disp_del_at_next_stop)
1719 gdb_assert (bl->owner->ops != NULL
1720 && bl->owner->ops->insert_location != NULL);
1722 val = bl->owner->ops->insert_location (bl);
1724 /* If trying to set a read-watchpoint, and it turns out it's not
1725 supported, try emulating one with an access watchpoint. */
1726 if (val == 1 && bl->watchpoint_type == hw_read)
1728 struct bp_location *loc, **loc_temp;
1730 /* But don't try to insert it, if there's already another
1731 hw_access location that would be considered a duplicate
1733 ALL_BP_LOCATIONS (loc, loc_temp)
1735 && loc->watchpoint_type == hw_access
1736 && watchpoint_locations_match (bl, loc))
1740 bl->target_info = loc->target_info;
1741 bl->watchpoint_type = hw_access;
1748 bl->watchpoint_type = hw_access;
1749 val = bl->owner->ops->insert_location (bl);
1752 /* Back to the original value. */
1753 bl->watchpoint_type = hw_read;
1757 bl->inserted = (val == 0);
1760 else if (bl->owner->type == bp_catchpoint)
1762 gdb_assert (bl->owner->ops != NULL
1763 && bl->owner->ops->insert_location != NULL);
1765 val = bl->owner->ops->insert_location (bl);
1768 bl->owner->enable_state = bp_disabled;
1772 Error inserting catchpoint %d: Your system does not support this type\n\
1773 of catchpoint."), bl->owner->number);
1775 warning (_("Error inserting catchpoint %d."), bl->owner->number);
1778 bl->inserted = (val == 0);
1780 /* We've already printed an error message if there was a problem
1781 inserting this catchpoint, and we've disabled the catchpoint,
1782 so just return success. */
1789 /* This function is called when program space PSPACE is about to be
1790 deleted. It takes care of updating breakpoints to not reference
1794 breakpoint_program_space_exit (struct program_space *pspace)
1796 struct breakpoint *b, *b_temp;
1797 struct bp_location *loc, **loc_temp;
1799 /* Remove any breakpoint that was set through this program space. */
1800 ALL_BREAKPOINTS_SAFE (b, b_temp)
1802 if (b->pspace == pspace)
1803 delete_breakpoint (b);
1806 /* Breakpoints set through other program spaces could have locations
1807 bound to PSPACE as well. Remove those. */
1808 ALL_BP_LOCATIONS (loc, loc_temp)
1810 struct bp_location *tmp;
1812 if (loc->pspace == pspace)
1814 /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always non-NULL. */
1815 if (loc->owner->loc == loc)
1816 loc->owner->loc = loc->next;
1818 for (tmp = loc->owner->loc; tmp->next != NULL; tmp = tmp->next)
1819 if (tmp->next == loc)
1821 tmp->next = loc->next;
1827 /* Now update the global location list to permanently delete the
1828 removed locations above. */
1829 update_global_location_list (0);
1832 /* Make sure all breakpoints are inserted in inferior.
1833 Throws exception on any error.
1834 A breakpoint that is already inserted won't be inserted
1835 again, so calling this function twice is safe. */
1837 insert_breakpoints (void)
1839 struct breakpoint *bpt;
1841 ALL_BREAKPOINTS (bpt)
1842 if (is_hardware_watchpoint (bpt))
1843 update_watchpoint (bpt, 0 /* don't reparse. */);
1845 update_global_location_list (1);
1847 /* update_global_location_list does not insert breakpoints when
1848 always_inserted_mode is not enabled. Explicitly insert them
1850 if (!breakpoints_always_inserted_mode ())
1851 insert_breakpoint_locations ();
1854 /* insert_breakpoints is used when starting or continuing the program.
1855 remove_breakpoints is used when the program stops.
1856 Both return zero if successful,
1857 or an `errno' value if could not write the inferior. */
1860 insert_breakpoint_locations (void)
1862 struct breakpoint *bpt;
1863 struct bp_location *bl, **blp_tmp;
1866 int disabled_breaks = 0;
1867 int hw_breakpoint_error = 0;
1869 struct ui_file *tmp_error_stream = mem_fileopen ();
1870 struct cleanup *cleanups = make_cleanup_ui_file_delete (tmp_error_stream);
1872 /* Explicitly mark the warning -- this will only be printed if
1873 there was an error. */
1874 fprintf_unfiltered (tmp_error_stream, "Warning:\n");
1876 save_current_space_and_thread ();
1878 ALL_BP_LOCATIONS (bl, blp_tmp)
1880 if (!should_be_inserted (bl) || bl->inserted)
1883 /* There is no point inserting thread-specific breakpoints if
1884 the thread no longer exists. ALL_BP_LOCATIONS bp_location
1885 has BL->OWNER always non-NULL. */
1886 if (bl->owner->thread != -1
1887 && !valid_thread_id (bl->owner->thread))
1890 switch_to_program_space_and_thread (bl->pspace);
1892 /* For targets that support global breakpoints, there's no need
1893 to select an inferior to insert breakpoint to. In fact, even
1894 if we aren't attached to any process yet, we should still
1895 insert breakpoints. */
1896 if (!gdbarch_has_global_breakpoints (target_gdbarch)
1897 && ptid_equal (inferior_ptid, null_ptid))
1900 val = insert_bp_location (bl, tmp_error_stream, &disabled_breaks,
1901 &hw_breakpoint_error);
1906 /* If we failed to insert all locations of a watchpoint, remove
1907 them, as half-inserted watchpoint is of limited use. */
1908 ALL_BREAKPOINTS (bpt)
1910 int some_failed = 0;
1911 struct bp_location *loc;
1913 if (!is_hardware_watchpoint (bpt))
1916 if (!breakpoint_enabled (bpt))
1919 if (bpt->disposition == disp_del_at_next_stop)
1922 for (loc = bpt->loc; loc; loc = loc->next)
1923 if (!loc->inserted && should_be_inserted (loc))
1930 for (loc = bpt->loc; loc; loc = loc->next)
1932 remove_breakpoint (loc, mark_uninserted);
1934 hw_breakpoint_error = 1;
1935 fprintf_unfiltered (tmp_error_stream,
1936 "Could not insert hardware watchpoint %d.\n",
1944 /* If a hardware breakpoint or watchpoint was inserted, add a
1945 message about possibly exhausted resources. */
1946 if (hw_breakpoint_error)
1948 fprintf_unfiltered (tmp_error_stream,
1949 "Could not insert hardware breakpoints:\n\
1950 You may have requested too many hardware breakpoints/watchpoints.\n");
1952 target_terminal_ours_for_output ();
1953 error_stream (tmp_error_stream);
1956 do_cleanups (cleanups);
1960 remove_breakpoints (void)
1962 struct bp_location *bl, **blp_tmp;
1965 ALL_BP_LOCATIONS (bl, blp_tmp)
1968 val |= remove_breakpoint (bl, mark_uninserted);
1973 /* Remove breakpoints of process PID. */
1976 remove_breakpoints_pid (int pid)
1978 struct bp_location *bl, **blp_tmp;
1980 struct inferior *inf = find_inferior_pid (pid);
1982 ALL_BP_LOCATIONS (bl, blp_tmp)
1984 if (bl->pspace != inf->pspace)
1989 val = remove_breakpoint (bl, mark_uninserted);
1998 remove_hw_watchpoints (void)
2000 struct bp_location *bl, **blp_tmp;
2003 ALL_BP_LOCATIONS (bl, blp_tmp)
2005 if (bl->inserted && bl->loc_type == bp_loc_hardware_watchpoint)
2006 val |= remove_breakpoint (bl, mark_uninserted);
2012 reattach_breakpoints (int pid)
2014 struct cleanup *old_chain;
2015 struct bp_location *bl, **blp_tmp;
2017 struct ui_file *tmp_error_stream;
2018 int dummy1 = 0, dummy2 = 0;
2019 struct inferior *inf;
2020 struct thread_info *tp;
2022 tp = any_live_thread_of_process (pid);
2026 inf = find_inferior_pid (pid);
2027 old_chain = save_inferior_ptid ();
2029 inferior_ptid = tp->ptid;
2031 tmp_error_stream = mem_fileopen ();
2032 make_cleanup_ui_file_delete (tmp_error_stream);
2034 ALL_BP_LOCATIONS (bl, blp_tmp)
2036 if (bl->pspace != inf->pspace)
2042 val = insert_bp_location (bl, tmp_error_stream, &dummy1, &dummy2);
2045 do_cleanups (old_chain);
2050 do_cleanups (old_chain);
2054 static int internal_breakpoint_number = -1;
2056 /* Set the breakpoint number of B, depending on the value of INTERNAL.
2057 If INTERNAL is non-zero, the breakpoint number will be populated
2058 from internal_breakpoint_number and that variable decremented.
2059 Otherwis the breakpoint number will be populated from
2060 breakpoint_count and that value incremented. Internal breakpoints
2061 do not set the internal var bpnum. */
2063 set_breakpoint_number (int internal, struct breakpoint *b)
2066 b->number = internal_breakpoint_number--;
2069 set_breakpoint_count (breakpoint_count + 1);
2070 b->number = breakpoint_count;
2074 static struct breakpoint *
2075 create_internal_breakpoint (struct gdbarch *gdbarch,
2076 CORE_ADDR address, enum bptype type)
2078 struct symtab_and_line sal;
2079 struct breakpoint *b;
2081 init_sal (&sal); /* Initialize to zeroes. */
2084 sal.section = find_pc_overlay (sal.pc);
2085 sal.pspace = current_program_space;
2087 b = set_raw_breakpoint (gdbarch, sal, type);
2088 b->number = internal_breakpoint_number--;
2089 b->disposition = disp_donttouch;
2094 static const char *const longjmp_names[] =
2096 "longjmp", "_longjmp", "siglongjmp", "_siglongjmp"
2098 #define NUM_LONGJMP_NAMES ARRAY_SIZE(longjmp_names)
2100 /* Per-objfile data private to breakpoint.c. */
2101 struct breakpoint_objfile_data
2103 /* Minimal symbol for "_ovly_debug_event" (if any). */
2104 struct minimal_symbol *overlay_msym;
2106 /* Minimal symbol(s) for "longjmp", "siglongjmp", etc. (if any). */
2107 struct minimal_symbol *longjmp_msym[NUM_LONGJMP_NAMES];
2109 /* Minimal symbol for "std::terminate()" (if any). */
2110 struct minimal_symbol *terminate_msym;
2112 /* Minimal symbol for "_Unwind_DebugHook" (if any). */
2113 struct minimal_symbol *exception_msym;
2116 static const struct objfile_data *breakpoint_objfile_key;
2118 /* Minimal symbol not found sentinel. */
2119 static struct minimal_symbol msym_not_found;
2121 /* Returns TRUE if MSYM point to the "not found" sentinel. */
2124 msym_not_found_p (const struct minimal_symbol *msym)
2126 return msym == &msym_not_found;
2129 /* Return per-objfile data needed by breakpoint.c.
2130 Allocate the data if necessary. */
2132 static struct breakpoint_objfile_data *
2133 get_breakpoint_objfile_data (struct objfile *objfile)
2135 struct breakpoint_objfile_data *bp_objfile_data;
2137 bp_objfile_data = objfile_data (objfile, breakpoint_objfile_key);
2138 if (bp_objfile_data == NULL)
2140 bp_objfile_data = obstack_alloc (&objfile->objfile_obstack,
2141 sizeof (*bp_objfile_data));
2143 memset (bp_objfile_data, 0, sizeof (*bp_objfile_data));
2144 set_objfile_data (objfile, breakpoint_objfile_key, bp_objfile_data);
2146 return bp_objfile_data;
2150 create_overlay_event_breakpoint (void)
2152 struct objfile *objfile;
2153 const char *const func_name = "_ovly_debug_event";
2155 ALL_OBJFILES (objfile)
2157 struct breakpoint *b;
2158 struct breakpoint_objfile_data *bp_objfile_data;
2161 bp_objfile_data = get_breakpoint_objfile_data (objfile);
2163 if (msym_not_found_p (bp_objfile_data->overlay_msym))
2166 if (bp_objfile_data->overlay_msym == NULL)
2168 struct minimal_symbol *m;
2170 m = lookup_minimal_symbol_text (func_name, objfile);
2173 /* Avoid future lookups in this objfile. */
2174 bp_objfile_data->overlay_msym = &msym_not_found;
2177 bp_objfile_data->overlay_msym = m;
2180 addr = SYMBOL_VALUE_ADDRESS (bp_objfile_data->overlay_msym);
2181 b = create_internal_breakpoint (get_objfile_arch (objfile), addr,
2183 b->addr_string = xstrdup (func_name);
2185 if (overlay_debugging == ovly_auto)
2187 b->enable_state = bp_enabled;
2188 overlay_events_enabled = 1;
2192 b->enable_state = bp_disabled;
2193 overlay_events_enabled = 0;
2196 update_global_location_list (1);
2200 create_longjmp_master_breakpoint (void)
2202 struct program_space *pspace;
2203 struct cleanup *old_chain;
2205 old_chain = save_current_program_space ();
2207 ALL_PSPACES (pspace)
2209 struct objfile *objfile;
2211 set_current_program_space (pspace);
2213 ALL_OBJFILES (objfile)
2216 struct gdbarch *gdbarch;
2217 struct breakpoint_objfile_data *bp_objfile_data;
2219 gdbarch = get_objfile_arch (objfile);
2220 if (!gdbarch_get_longjmp_target_p (gdbarch))
2223 bp_objfile_data = get_breakpoint_objfile_data (objfile);
2225 for (i = 0; i < NUM_LONGJMP_NAMES; i++)
2227 struct breakpoint *b;
2228 const char *func_name;
2231 if (msym_not_found_p (bp_objfile_data->longjmp_msym[i]))
2234 func_name = longjmp_names[i];
2235 if (bp_objfile_data->longjmp_msym[i] == NULL)
2237 struct minimal_symbol *m;
2239 m = lookup_minimal_symbol_text (func_name, objfile);
2242 /* Prevent future lookups in this objfile. */
2243 bp_objfile_data->longjmp_msym[i] = &msym_not_found;
2246 bp_objfile_data->longjmp_msym[i] = m;
2249 addr = SYMBOL_VALUE_ADDRESS (bp_objfile_data->longjmp_msym[i]);
2250 b = create_internal_breakpoint (gdbarch, addr, bp_longjmp_master);
2251 b->addr_string = xstrdup (func_name);
2252 b->enable_state = bp_disabled;
2256 update_global_location_list (1);
2258 do_cleanups (old_chain);
2261 /* Create a master std::terminate breakpoint. */
2263 create_std_terminate_master_breakpoint (void)
2265 struct program_space *pspace;
2266 struct cleanup *old_chain;
2267 const char *const func_name = "std::terminate()";
2269 old_chain = save_current_program_space ();
2271 ALL_PSPACES (pspace)
2273 struct objfile *objfile;
2276 set_current_program_space (pspace);
2278 ALL_OBJFILES (objfile)
2280 struct breakpoint *b;
2281 struct breakpoint_objfile_data *bp_objfile_data;
2283 bp_objfile_data = get_breakpoint_objfile_data (objfile);
2285 if (msym_not_found_p (bp_objfile_data->terminate_msym))
2288 if (bp_objfile_data->terminate_msym == NULL)
2290 struct minimal_symbol *m;
2292 m = lookup_minimal_symbol (func_name, NULL, objfile);
2293 if (m == NULL || (MSYMBOL_TYPE (m) != mst_text
2294 && MSYMBOL_TYPE (m) != mst_file_text))
2296 /* Prevent future lookups in this objfile. */
2297 bp_objfile_data->terminate_msym = &msym_not_found;
2300 bp_objfile_data->terminate_msym = m;
2303 addr = SYMBOL_VALUE_ADDRESS (bp_objfile_data->terminate_msym);
2304 b = create_internal_breakpoint (get_objfile_arch (objfile), addr,
2305 bp_std_terminate_master);
2306 b->addr_string = xstrdup (func_name);
2307 b->enable_state = bp_disabled;
2311 update_global_location_list (1);
2313 do_cleanups (old_chain);
2316 /* Install a master breakpoint on the unwinder's debug hook. */
2319 create_exception_master_breakpoint (void)
2321 struct objfile *objfile;
2322 const char *const func_name = "_Unwind_DebugHook";
2324 ALL_OBJFILES (objfile)
2326 struct breakpoint *b;
2327 struct gdbarch *gdbarch;
2328 struct breakpoint_objfile_data *bp_objfile_data;
2331 bp_objfile_data = get_breakpoint_objfile_data (objfile);
2333 if (msym_not_found_p (bp_objfile_data->exception_msym))
2336 gdbarch = get_objfile_arch (objfile);
2338 if (bp_objfile_data->exception_msym == NULL)
2340 struct minimal_symbol *debug_hook;
2342 debug_hook = lookup_minimal_symbol (func_name, NULL, objfile);
2343 if (debug_hook == NULL)
2345 bp_objfile_data->exception_msym = &msym_not_found;
2349 bp_objfile_data->exception_msym = debug_hook;
2352 addr = SYMBOL_VALUE_ADDRESS (bp_objfile_data->exception_msym);
2353 addr = gdbarch_convert_from_func_ptr_addr (gdbarch, addr,
2355 b = create_internal_breakpoint (gdbarch, addr, bp_exception_master);
2356 b->addr_string = xstrdup (func_name);
2357 b->enable_state = bp_disabled;
2360 update_global_location_list (1);
2364 update_breakpoints_after_exec (void)
2366 struct breakpoint *b, *b_tmp;
2367 struct bp_location *bploc, **bplocp_tmp;
2369 /* We're about to delete breakpoints from GDB's lists. If the
2370 INSERTED flag is true, GDB will try to lift the breakpoints by
2371 writing the breakpoints' "shadow contents" back into memory. The
2372 "shadow contents" are NOT valid after an exec, so GDB should not
2373 do that. Instead, the target is responsible from marking
2374 breakpoints out as soon as it detects an exec. We don't do that
2375 here instead, because there may be other attempts to delete
2376 breakpoints after detecting an exec and before reaching here. */
2377 ALL_BP_LOCATIONS (bploc, bplocp_tmp)
2378 if (bploc->pspace == current_program_space)
2379 gdb_assert (!bploc->inserted);
2381 ALL_BREAKPOINTS_SAFE (b, b_tmp)
2383 if (b->pspace != current_program_space)
2386 /* Solib breakpoints must be explicitly reset after an exec(). */
2387 if (b->type == bp_shlib_event)
2389 delete_breakpoint (b);
2393 /* JIT breakpoints must be explicitly reset after an exec(). */
2394 if (b->type == bp_jit_event)
2396 delete_breakpoint (b);
2400 /* Thread event breakpoints must be set anew after an exec(),
2401 as must overlay event and longjmp master breakpoints. */
2402 if (b->type == bp_thread_event || b->type == bp_overlay_event
2403 || b->type == bp_longjmp_master || b->type == bp_std_terminate_master
2404 || b->type == bp_exception_master)
2406 delete_breakpoint (b);
2410 /* Step-resume breakpoints are meaningless after an exec(). */
2411 if (b->type == bp_step_resume)
2413 delete_breakpoint (b);
2417 /* Longjmp and longjmp-resume breakpoints are also meaningless
2419 if (b->type == bp_longjmp || b->type == bp_longjmp_resume
2420 || b->type == bp_exception || b->type == bp_exception_resume)
2422 delete_breakpoint (b);
2426 if (b->type == bp_catchpoint)
2428 /* For now, none of the bp_catchpoint breakpoints need to
2429 do anything at this point. In the future, if some of
2430 the catchpoints need to something, we will need to add
2431 a new method, and call this method from here. */
2435 /* bp_finish is a special case. The only way we ought to be able
2436 to see one of these when an exec() has happened, is if the user
2437 caught a vfork, and then said "finish". Ordinarily a finish just
2438 carries them to the call-site of the current callee, by setting
2439 a temporary bp there and resuming. But in this case, the finish
2440 will carry them entirely through the vfork & exec.
2442 We don't want to allow a bp_finish to remain inserted now. But
2443 we can't safely delete it, 'cause finish_command has a handle to
2444 the bp on a bpstat, and will later want to delete it. There's a
2445 chance (and I've seen it happen) that if we delete the bp_finish
2446 here, that its storage will get reused by the time finish_command
2447 gets 'round to deleting the "use to be a bp_finish" breakpoint.
2448 We really must allow finish_command to delete a bp_finish.
2450 In the absense of a general solution for the "how do we know
2451 it's safe to delete something others may have handles to?"
2452 problem, what we'll do here is just uninsert the bp_finish, and
2453 let finish_command delete it.
2455 (We know the bp_finish is "doomed" in the sense that it's
2456 momentary, and will be deleted as soon as finish_command sees
2457 the inferior stopped. So it doesn't matter that the bp's
2458 address is probably bogus in the new a.out, unlike e.g., the
2459 solib breakpoints.) */
2461 if (b->type == bp_finish)
2466 /* Without a symbolic address, we have little hope of the
2467 pre-exec() address meaning the same thing in the post-exec()
2469 if (b->addr_string == NULL)
2471 delete_breakpoint (b);
2475 /* FIXME what about longjmp breakpoints? Re-create them here? */
2476 create_overlay_event_breakpoint ();
2477 create_longjmp_master_breakpoint ();
2478 create_std_terminate_master_breakpoint ();
2479 create_exception_master_breakpoint ();
2483 detach_breakpoints (int pid)
2485 struct bp_location *bl, **blp_tmp;
2487 struct cleanup *old_chain = save_inferior_ptid ();
2488 struct inferior *inf = current_inferior ();
2490 if (pid == PIDGET (inferior_ptid))
2491 error (_("Cannot detach breakpoints of inferior_ptid"));
2493 /* Set inferior_ptid; remove_breakpoint_1 uses this global. */
2494 inferior_ptid = pid_to_ptid (pid);
2495 ALL_BP_LOCATIONS (bl, blp_tmp)
2497 if (bl->pspace != inf->pspace)
2501 val |= remove_breakpoint_1 (bl, mark_inserted);
2504 /* Detach single-step breakpoints as well. */
2505 detach_single_step_breakpoints ();
2507 do_cleanups (old_chain);
2511 /* Remove the breakpoint location BL from the current address space.
2512 Note that this is used to detach breakpoints from a child fork.
2513 When we get here, the child isn't in the inferior list, and neither
2514 do we have objects to represent its address space --- we should
2515 *not* look at bl->pspace->aspace here. */
2518 remove_breakpoint_1 (struct bp_location *bl, insertion_state_t is)
2522 /* BL is never in moribund_locations by our callers. */
2523 gdb_assert (bl->owner != NULL);
2525 if (bl->owner->enable_state == bp_permanent)
2526 /* Permanent breakpoints cannot be inserted or removed. */
2529 /* The type of none suggests that owner is actually deleted.
2530 This should not ever happen. */
2531 gdb_assert (bl->owner->type != bp_none);
2533 if (bl->loc_type == bp_loc_software_breakpoint
2534 || bl->loc_type == bp_loc_hardware_breakpoint)
2536 /* "Normal" instruction breakpoint: either the standard
2537 trap-instruction bp (bp_breakpoint), or a
2538 bp_hardware_breakpoint. */
2540 /* First check to see if we have to handle an overlay. */
2541 if (overlay_debugging == ovly_off
2542 || bl->section == NULL
2543 || !(section_is_overlay (bl->section)))
2545 /* No overlay handling: just remove the breakpoint. */
2547 if (bl->loc_type == bp_loc_hardware_breakpoint)
2548 val = target_remove_hw_breakpoint (bl->gdbarch, &bl->target_info);
2550 val = target_remove_breakpoint (bl->gdbarch, &bl->target_info);
2554 /* This breakpoint is in an overlay section.
2555 Did we set a breakpoint at the LMA? */
2556 if (!overlay_events_enabled)
2558 /* Yes -- overlay event support is not active, so we
2559 should have set a breakpoint at the LMA. Remove it.
2561 /* Ignore any failures: if the LMA is in ROM, we will
2562 have already warned when we failed to insert it. */
2563 if (bl->loc_type == bp_loc_hardware_breakpoint)
2564 target_remove_hw_breakpoint (bl->gdbarch,
2565 &bl->overlay_target_info);
2567 target_remove_breakpoint (bl->gdbarch,
2568 &bl->overlay_target_info);
2570 /* Did we set a breakpoint at the VMA?
2571 If so, we will have marked the breakpoint 'inserted'. */
2574 /* Yes -- remove it. Previously we did not bother to
2575 remove the breakpoint if the section had been
2576 unmapped, but let's not rely on that being safe. We
2577 don't know what the overlay manager might do. */
2578 if (bl->loc_type == bp_loc_hardware_breakpoint)
2579 val = target_remove_hw_breakpoint (bl->gdbarch,
2582 /* However, we should remove *software* breakpoints only
2583 if the section is still mapped, or else we overwrite
2584 wrong code with the saved shadow contents. */
2585 else if (section_is_mapped (bl->section))
2586 val = target_remove_breakpoint (bl->gdbarch,
2593 /* No -- not inserted, so no need to remove. No error. */
2598 /* In some cases, we might not be able to remove a breakpoint
2599 in a shared library that has already been removed, but we
2600 have not yet processed the shlib unload event. */
2601 if (val && solib_name_from_address (bl->pspace, bl->address))
2606 bl->inserted = (is == mark_inserted);
2608 else if (bl->loc_type == bp_loc_hardware_watchpoint)
2610 gdb_assert (bl->owner->ops != NULL
2611 && bl->owner->ops->remove_location != NULL);
2613 bl->inserted = (is == mark_inserted);
2614 bl->owner->ops->remove_location (bl);
2616 /* Failure to remove any of the hardware watchpoints comes here. */
2617 if ((is == mark_uninserted) && (bl->inserted))
2618 warning (_("Could not remove hardware watchpoint %d."),
2621 else if (bl->owner->type == bp_catchpoint
2622 && breakpoint_enabled (bl->owner)
2625 gdb_assert (bl->owner->ops != NULL
2626 && bl->owner->ops->remove_location != NULL);
2628 val = bl->owner->ops->remove_location (bl);
2632 bl->inserted = (is == mark_inserted);
2639 remove_breakpoint (struct bp_location *bl, insertion_state_t is)
2642 struct cleanup *old_chain;
2644 /* BL is never in moribund_locations by our callers. */
2645 gdb_assert (bl->owner != NULL);
2647 if (bl->owner->enable_state == bp_permanent)
2648 /* Permanent breakpoints cannot be inserted or removed. */
2651 /* The type of none suggests that owner is actually deleted.
2652 This should not ever happen. */
2653 gdb_assert (bl->owner->type != bp_none);
2655 old_chain = save_current_space_and_thread ();
2657 switch_to_program_space_and_thread (bl->pspace);
2659 ret = remove_breakpoint_1 (bl, is);
2661 do_cleanups (old_chain);
2665 /* Clear the "inserted" flag in all breakpoints. */
2668 mark_breakpoints_out (void)
2670 struct bp_location *bl, **blp_tmp;
2672 ALL_BP_LOCATIONS (bl, blp_tmp)
2673 if (bl->pspace == current_program_space)
2677 /* Clear the "inserted" flag in all breakpoints and delete any
2678 breakpoints which should go away between runs of the program.
2680 Plus other such housekeeping that has to be done for breakpoints
2683 Note: this function gets called at the end of a run (by
2684 generic_mourn_inferior) and when a run begins (by
2685 init_wait_for_inferior). */
2690 breakpoint_init_inferior (enum inf_context context)
2692 struct breakpoint *b, *b_tmp;
2693 struct bp_location *bl, **blp_tmp;
2695 struct program_space *pspace = current_program_space;
2697 /* If breakpoint locations are shared across processes, then there's
2699 if (gdbarch_has_global_breakpoints (target_gdbarch))
2702 ALL_BP_LOCATIONS (bl, blp_tmp)
2704 /* ALL_BP_LOCATIONS bp_location has BL->OWNER always non-NULL. */
2705 if (bl->pspace == pspace
2706 && bl->owner->enable_state != bp_permanent)
2710 ALL_BREAKPOINTS_SAFE (b, b_tmp)
2712 if (b->loc && b->loc->pspace != pspace)
2719 /* If the call dummy breakpoint is at the entry point it will
2720 cause problems when the inferior is rerun, so we better get
2723 case bp_watchpoint_scope:
2725 /* Also get rid of scope breakpoints. */
2727 case bp_shlib_event:
2729 /* Also remove solib event breakpoints. Their addresses may
2730 have changed since the last time we ran the program.
2731 Actually we may now be debugging against different target;
2732 and so the solib backend that installed this breakpoint may
2733 not be used in by the target. E.g.,
2735 (gdb) file prog-linux
2736 (gdb) run # native linux target
2739 (gdb) file prog-win.exe
2740 (gdb) tar rem :9999 # remote Windows gdbserver.
2743 delete_breakpoint (b);
2747 case bp_hardware_watchpoint:
2748 case bp_read_watchpoint:
2749 case bp_access_watchpoint:
2751 /* Likewise for watchpoints on local expressions. */
2752 if (b->exp_valid_block != NULL)
2753 delete_breakpoint (b);
2754 else if (context == inf_starting)
2756 /* Reset val field to force reread of starting value in
2757 insert_breakpoints. */
2759 value_free (b->val);
2769 /* Get rid of the moribund locations. */
2770 for (ix = 0; VEC_iterate (bp_location_p, moribund_locations, ix, bl); ++ix)
2771 decref_bp_location (&bl);
2772 VEC_free (bp_location_p, moribund_locations);
2775 /* These functions concern about actual breakpoints inserted in the
2776 target --- to e.g. check if we need to do decr_pc adjustment or if
2777 we need to hop over the bkpt --- so we check for address space
2778 match, not program space. */
2780 /* breakpoint_here_p (PC) returns non-zero if an enabled breakpoint
2781 exists at PC. It returns ordinary_breakpoint_here if it's an
2782 ordinary breakpoint, or permanent_breakpoint_here if it's a
2783 permanent breakpoint.
2784 - When continuing from a location with an ordinary breakpoint, we
2785 actually single step once before calling insert_breakpoints.
2786 - When continuing from a localion with a permanent breakpoint, we
2787 need to use the `SKIP_PERMANENT_BREAKPOINT' macro, provided by
2788 the target, to advance the PC past the breakpoint. */
2790 enum breakpoint_here
2791 breakpoint_here_p (struct address_space *aspace, CORE_ADDR pc)
2793 struct bp_location *bl, **blp_tmp;
2794 int any_breakpoint_here = 0;
2796 ALL_BP_LOCATIONS (bl, blp_tmp)
2798 if (bl->loc_type != bp_loc_software_breakpoint
2799 && bl->loc_type != bp_loc_hardware_breakpoint)
2802 /* ALL_BP_LOCATIONS bp_location has bl->OWNER always non-NULL. */
2803 if ((breakpoint_enabled (bl->owner)
2804 || bl->owner->enable_state == bp_permanent)
2805 && breakpoint_address_match (bl->pspace->aspace, bl->address,
2808 if (overlay_debugging
2809 && section_is_overlay (bl->section)
2810 && !section_is_mapped (bl->section))
2811 continue; /* unmapped overlay -- can't be a match */
2812 else if (bl->owner->enable_state == bp_permanent)
2813 return permanent_breakpoint_here;
2815 any_breakpoint_here = 1;
2819 return any_breakpoint_here ? ordinary_breakpoint_here : 0;
2822 /* Return true if there's a moribund breakpoint at PC. */
2825 moribund_breakpoint_here_p (struct address_space *aspace, CORE_ADDR pc)
2827 struct bp_location *loc;
2830 for (ix = 0; VEC_iterate (bp_location_p, moribund_locations, ix, loc); ++ix)
2831 if (breakpoint_address_match (loc->pspace->aspace, loc->address,
2838 /* Returns non-zero if there's a breakpoint inserted at PC, which is
2839 inserted using regular breakpoint_chain / bp_location array
2840 mechanism. This does not check for single-step breakpoints, which
2841 are inserted and removed using direct target manipulation. */
2844 regular_breakpoint_inserted_here_p (struct address_space *aspace,
2847 struct bp_location *bl, **blp_tmp;
2849 ALL_BP_LOCATIONS (bl, blp_tmp)
2851 if (bl->loc_type != bp_loc_software_breakpoint
2852 && bl->loc_type != bp_loc_hardware_breakpoint)
2856 && breakpoint_address_match (bl->pspace->aspace, bl->address,
2859 if (overlay_debugging
2860 && section_is_overlay (bl->section)
2861 && !section_is_mapped (bl->section))
2862 continue; /* unmapped overlay -- can't be a match */
2870 /* Returns non-zero iff there's either regular breakpoint
2871 or a single step breakpoint inserted at PC. */
2874 breakpoint_inserted_here_p (struct address_space *aspace, CORE_ADDR pc)
2876 if (regular_breakpoint_inserted_here_p (aspace, pc))
2879 if (single_step_breakpoint_inserted_here_p (aspace, pc))
2885 /* This function returns non-zero iff there is a software breakpoint
2889 software_breakpoint_inserted_here_p (struct address_space *aspace,
2892 struct bp_location *bl, **blp_tmp;
2894 ALL_BP_LOCATIONS (bl, blp_tmp)
2896 if (bl->loc_type != bp_loc_software_breakpoint)
2900 && breakpoint_address_match (bl->pspace->aspace, bl->address,
2903 if (overlay_debugging
2904 && section_is_overlay (bl->section)
2905 && !section_is_mapped (bl->section))
2906 continue; /* unmapped overlay -- can't be a match */
2912 /* Also check for software single-step breakpoints. */
2913 if (single_step_breakpoint_inserted_here_p (aspace, pc))
2920 hardware_watchpoint_inserted_in_range (struct address_space *aspace,
2921 CORE_ADDR addr, ULONGEST len)
2923 struct breakpoint *bpt;
2925 ALL_BREAKPOINTS (bpt)
2927 struct bp_location *loc;
2929 if (bpt->type != bp_hardware_watchpoint
2930 && bpt->type != bp_access_watchpoint)
2933 if (!breakpoint_enabled (bpt))
2936 for (loc = bpt->loc; loc; loc = loc->next)
2937 if (loc->pspace->aspace == aspace && loc->inserted)
2941 /* Check for intersection. */
2942 l = max (loc->address, addr);
2943 h = min (loc->address + loc->length, addr + len);
2951 /* breakpoint_thread_match (PC, PTID) returns true if the breakpoint at
2952 PC is valid for process/thread PTID. */
2955 breakpoint_thread_match (struct address_space *aspace, CORE_ADDR pc,
2958 struct bp_location *bl, **blp_tmp;
2959 /* The thread and task IDs associated to PTID, computed lazily. */
2963 ALL_BP_LOCATIONS (bl, blp_tmp)
2965 if (bl->loc_type != bp_loc_software_breakpoint
2966 && bl->loc_type != bp_loc_hardware_breakpoint)
2969 /* ALL_BP_LOCATIONS bp_location has bl->OWNER always non-NULL. */
2970 if (!breakpoint_enabled (bl->owner)
2971 && bl->owner->enable_state != bp_permanent)
2974 if (!breakpoint_address_match (bl->pspace->aspace, bl->address,
2978 if (bl->owner->thread != -1)
2980 /* This is a thread-specific breakpoint. Check that ptid
2981 matches that thread. If thread hasn't been computed yet,
2982 it is now time to do so. */
2984 thread = pid_to_thread_id (ptid);
2985 if (bl->owner->thread != thread)
2989 if (bl->owner->task != 0)
2991 /* This is a task-specific breakpoint. Check that ptid
2992 matches that task. If task hasn't been computed yet,
2993 it is now time to do so. */
2995 task = ada_get_task_number (ptid);
2996 if (bl->owner->task != task)
3000 if (overlay_debugging
3001 && section_is_overlay (bl->section)
3002 && !section_is_mapped (bl->section))
3003 continue; /* unmapped overlay -- can't be a match */
3012 /* bpstat stuff. External routines' interfaces are documented
3016 ep_is_catchpoint (struct breakpoint *ep)
3018 return (ep->type == bp_catchpoint);
3021 /* Frees any storage that is part of a bpstat. Does not walk the
3025 bpstat_free (bpstat bs)
3027 if (bs->old_val != NULL)
3028 value_free (bs->old_val);
3029 decref_counted_command_line (&bs->commands);
3030 decref_bp_location (&bs->bp_location_at);
3034 /* Clear a bpstat so that it says we are not at any breakpoint.
3035 Also free any storage that is part of a bpstat. */
3038 bpstat_clear (bpstat *bsp)
3055 /* Return a copy of a bpstat. Like "bs1 = bs2" but all storage that
3056 is part of the bpstat is copied as well. */
3059 bpstat_copy (bpstat bs)
3063 bpstat retval = NULL;
3068 for (; bs != NULL; bs = bs->next)
3070 tmp = (bpstat) xmalloc (sizeof (*tmp));
3071 memcpy (tmp, bs, sizeof (*tmp));
3072 incref_counted_command_line (tmp->commands);
3073 incref_bp_location (tmp->bp_location_at);
3074 if (bs->old_val != NULL)
3076 tmp->old_val = value_copy (bs->old_val);
3077 release_value (tmp->old_val);
3081 /* This is the first thing in the chain. */
3091 /* Find the bpstat associated with this breakpoint. */
3094 bpstat_find_breakpoint (bpstat bsp, struct breakpoint *breakpoint)
3099 for (; bsp != NULL; bsp = bsp->next)
3101 if (bsp->breakpoint_at == breakpoint)
3107 /* Put in *NUM the breakpoint number of the first breakpoint we are
3108 stopped at. *BSP upon return is a bpstat which points to the
3109 remaining breakpoints stopped at (but which is not guaranteed to be
3110 good for anything but further calls to bpstat_num).
3112 Return 0 if passed a bpstat which does not indicate any breakpoints.
3113 Return -1 if stopped at a breakpoint that has been deleted since
3115 Return 1 otherwise. */
3118 bpstat_num (bpstat *bsp, int *num)
3120 struct breakpoint *b;
3123 return 0; /* No more breakpoint values */
3125 /* We assume we'll never have several bpstats that correspond to a
3126 single breakpoint -- otherwise, this function might return the
3127 same number more than once and this will look ugly. */
3128 b = (*bsp)->breakpoint_at;
3129 *bsp = (*bsp)->next;
3131 return -1; /* breakpoint that's been deleted since */
3133 *num = b->number; /* We have its number */
3137 /* Modify BS so that the actions will not be performed. */
3140 bpstat_clear_actions (bpstat bs)
3142 for (; bs != NULL; bs = bs->next)
3144 decref_counted_command_line (&bs->commands);
3145 bs->commands_left = NULL;
3146 if (bs->old_val != NULL)
3148 value_free (bs->old_val);
3154 /* Called when a command is about to proceed the inferior. */
3157 breakpoint_about_to_proceed (void)
3159 if (!ptid_equal (inferior_ptid, null_ptid))
3161 struct thread_info *tp = inferior_thread ();
3163 /* Allow inferior function calls in breakpoint commands to not
3164 interrupt the command list. When the call finishes
3165 successfully, the inferior will be standing at the same
3166 breakpoint as if nothing happened. */
3167 if (tp->control.in_infcall)
3171 breakpoint_proceeded = 1;
3174 /* Stub for cleaning up our state if we error-out of a breakpoint
3177 cleanup_executing_breakpoints (void *ignore)
3179 executing_breakpoint_commands = 0;
3182 /* Execute all the commands associated with all the breakpoints at
3183 this location. Any of these commands could cause the process to
3184 proceed beyond this point, etc. We look out for such changes by
3185 checking the global "breakpoint_proceeded" after each command.
3187 Returns true if a breakpoint command resumed the inferior. In that
3188 case, it is the caller's responsibility to recall it again with the
3189 bpstat of the current thread. */
3192 bpstat_do_actions_1 (bpstat *bsp)
3195 struct cleanup *old_chain;
3198 /* Avoid endless recursion if a `source' command is contained
3200 if (executing_breakpoint_commands)
3203 executing_breakpoint_commands = 1;
3204 old_chain = make_cleanup (cleanup_executing_breakpoints, 0);
3206 /* This pointer will iterate over the list of bpstat's. */
3209 breakpoint_proceeded = 0;
3210 for (; bs != NULL; bs = bs->next)
3212 struct counted_command_line *ccmd;
3213 struct command_line *cmd;
3214 struct cleanup *this_cmd_tree_chain;
3216 /* Take ownership of the BSP's command tree, if it has one.
3218 The command tree could legitimately contain commands like
3219 'step' and 'next', which call clear_proceed_status, which
3220 frees stop_bpstat's command tree. To make sure this doesn't
3221 free the tree we're executing out from under us, we need to
3222 take ownership of the tree ourselves. Since a given bpstat's
3223 commands are only executed once, we don't need to copy it; we
3224 can clear the pointer in the bpstat, and make sure we free
3225 the tree when we're done. */
3226 ccmd = bs->commands;
3227 bs->commands = NULL;
3229 = make_cleanup_decref_counted_command_line (&ccmd);
3230 cmd = bs->commands_left;
3231 bs->commands_left = NULL;
3235 execute_control_command (cmd);
3237 if (breakpoint_proceeded)
3243 /* We can free this command tree now. */
3244 do_cleanups (this_cmd_tree_chain);
3246 if (breakpoint_proceeded)
3248 if (target_can_async_p ())
3249 /* If we are in async mode, then the target might be still
3250 running, not stopped at any breakpoint, so nothing for
3251 us to do here -- just return to the event loop. */
3254 /* In sync mode, when execute_control_command returns
3255 we're already standing on the next breakpoint.
3256 Breakpoint commands for that stop were not run, since
3257 execute_command does not run breakpoint commands --
3258 only command_line_handler does, but that one is not
3259 involved in execution of breakpoint commands. So, we
3260 can now execute breakpoint commands. It should be
3261 noted that making execute_command do bpstat actions is
3262 not an option -- in this case we'll have recursive
3263 invocation of bpstat for each breakpoint with a
3264 command, and can easily blow up GDB stack. Instead, we
3265 return true, which will trigger the caller to recall us
3266 with the new stop_bpstat. */
3271 do_cleanups (old_chain);
3276 bpstat_do_actions (void)
3278 /* Do any commands attached to breakpoint we are stopped at. */
3279 while (!ptid_equal (inferior_ptid, null_ptid)
3280 && target_has_execution
3281 && !is_exited (inferior_ptid)
3282 && !is_executing (inferior_ptid))
3283 /* Since in sync mode, bpstat_do_actions may resume the inferior,
3284 and only return when it is stopped at the next breakpoint, we
3285 keep doing breakpoint actions until it returns false to
3286 indicate the inferior was not resumed. */
3287 if (!bpstat_do_actions_1 (&inferior_thread ()->control.stop_bpstat))
3291 /* Print out the (old or new) value associated with a watchpoint. */
3294 watchpoint_value_print (struct value *val, struct ui_file *stream)
3297 fprintf_unfiltered (stream, _("<unreadable>"));
3300 struct value_print_options opts;
3301 get_user_print_options (&opts);
3302 value_print (val, stream, &opts);
3306 /* This is the normal print function for a bpstat. In the future,
3307 much of this logic could (should?) be moved to bpstat_stop_status,
3308 by having it set different print_it values.
3310 Current scheme: When we stop, bpstat_print() is called. It loops
3311 through the bpstat list of things causing this stop, calling the
3312 print_bp_stop_message function on each one. The behavior of the
3313 print_bp_stop_message function depends on the print_it field of
3314 bpstat. If such field so indicates, call this function here.
3316 Return values from this routine (ultimately used by bpstat_print()
3317 and normal_stop() to decide what to do):
3318 PRINT_NOTHING: Means we already printed all we needed to print,
3319 don't print anything else.
3320 PRINT_SRC_ONLY: Means we printed something, and we do *not* desire
3321 that something to be followed by a location.
3322 PRINT_SCR_AND_LOC: Means we printed something, and we *do* desire
3323 that something to be followed by a location.
3324 PRINT_UNKNOWN: Means we printed nothing or we need to do some more
3327 static enum print_stop_action
3328 print_it_typical (bpstat bs)
3330 struct cleanup *old_chain;
3331 struct breakpoint *b;
3332 const struct bp_location *bl;
3333 struct ui_stream *stb;
3335 enum print_stop_action result;
3337 gdb_assert (bs->bp_location_at != NULL);
3339 bl = bs->bp_location_at;
3340 b = bs->breakpoint_at;
3342 stb = ui_out_stream_new (uiout);
3343 old_chain = make_cleanup_ui_out_stream_delete (stb);
3348 case bp_hardware_breakpoint:
3349 bp_temp = b->disposition == disp_del;
3350 if (bl->address != bl->requested_address)
3351 breakpoint_adjustment_warning (bl->requested_address,
3354 annotate_breakpoint (b->number);
3356 ui_out_text (uiout, "\nTemporary breakpoint ");
3358 ui_out_text (uiout, "\nBreakpoint ");
3359 if (ui_out_is_mi_like_p (uiout))
3361 ui_out_field_string (uiout, "reason",
3362 async_reason_lookup (EXEC_ASYNC_BREAKPOINT_HIT));
3363 ui_out_field_string (uiout, "disp", bpdisp_text (b->disposition));
3365 ui_out_field_int (uiout, "bkptno", b->number);
3366 ui_out_text (uiout, ", ");
3367 result = PRINT_SRC_AND_LOC;
3370 case bp_shlib_event:
3371 /* Did we stop because the user set the stop_on_solib_events
3372 variable? (If so, we report this as a generic, "Stopped due
3373 to shlib event" message.) */
3374 printf_filtered (_("Stopped due to shared library event\n"));
3375 result = PRINT_NOTHING;
3378 case bp_thread_event:
3379 /* Not sure how we will get here.
3380 GDB should not stop for these breakpoints. */
3381 printf_filtered (_("Thread Event Breakpoint: gdb should not stop!\n"));
3382 result = PRINT_NOTHING;
3385 case bp_overlay_event:
3386 /* By analogy with the thread event, GDB should not stop for these. */
3387 printf_filtered (_("Overlay Event Breakpoint: gdb should not stop!\n"));
3388 result = PRINT_NOTHING;
3391 case bp_longjmp_master:
3392 /* These should never be enabled. */
3393 printf_filtered (_("Longjmp Master Breakpoint: gdb should not stop!\n"));
3394 result = PRINT_NOTHING;
3397 case bp_std_terminate_master:
3398 /* These should never be enabled. */
3399 printf_filtered (_("std::terminate Master Breakpoint: "
3400 "gdb should not stop!\n"));
3401 result = PRINT_NOTHING;
3404 case bp_exception_master:
3405 /* These should never be enabled. */
3406 printf_filtered (_("Exception Master Breakpoint: "
3407 "gdb should not stop!\n"));
3408 result = PRINT_NOTHING;
3412 case bp_hardware_watchpoint:
3413 annotate_watchpoint (b->number);
3414 if (ui_out_is_mi_like_p (uiout))
3417 async_reason_lookup (EXEC_ASYNC_WATCHPOINT_TRIGGER));
3419 make_cleanup_ui_out_tuple_begin_end (uiout, "value");
3420 ui_out_text (uiout, "\nOld value = ");
3421 watchpoint_value_print (bs->old_val, stb->stream);
3422 ui_out_field_stream (uiout, "old", stb);
3423 ui_out_text (uiout, "\nNew value = ");
3424 watchpoint_value_print (b->val, stb->stream);
3425 ui_out_field_stream (uiout, "new", stb);
3426 ui_out_text (uiout, "\n");
3427 /* More than one watchpoint may have been triggered. */
3428 result = PRINT_UNKNOWN;
3431 case bp_read_watchpoint:
3432 if (ui_out_is_mi_like_p (uiout))
3435 async_reason_lookup (EXEC_ASYNC_READ_WATCHPOINT_TRIGGER));
3437 make_cleanup_ui_out_tuple_begin_end (uiout, "value");
3438 ui_out_text (uiout, "\nValue = ");
3439 watchpoint_value_print (b->val, stb->stream);
3440 ui_out_field_stream (uiout, "value", stb);
3441 ui_out_text (uiout, "\n");
3442 result = PRINT_UNKNOWN;
3445 case bp_access_watchpoint:
3446 if (bs->old_val != NULL)
3448 annotate_watchpoint (b->number);
3449 if (ui_out_is_mi_like_p (uiout))
3452 async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER));
3454 make_cleanup_ui_out_tuple_begin_end (uiout, "value");
3455 ui_out_text (uiout, "\nOld value = ");
3456 watchpoint_value_print (bs->old_val, stb->stream);
3457 ui_out_field_stream (uiout, "old", stb);
3458 ui_out_text (uiout, "\nNew value = ");
3463 if (ui_out_is_mi_like_p (uiout))
3466 async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER));
3467 make_cleanup_ui_out_tuple_begin_end (uiout, "value");
3468 ui_out_text (uiout, "\nValue = ");
3470 watchpoint_value_print (b->val, stb->stream);
3471 ui_out_field_stream (uiout, "new", stb);
3472 ui_out_text (uiout, "\n");
3473 result = PRINT_UNKNOWN;
3476 /* Fall through, we don't deal with these types of breakpoints
3480 if (ui_out_is_mi_like_p (uiout))
3483 async_reason_lookup (EXEC_ASYNC_FUNCTION_FINISHED));
3484 result = PRINT_UNKNOWN;
3488 if (ui_out_is_mi_like_p (uiout))
3491 async_reason_lookup (EXEC_ASYNC_LOCATION_REACHED));
3492 result = PRINT_UNKNOWN;
3497 case bp_longjmp_resume:
3499 case bp_exception_resume:
3500 case bp_step_resume:
3501 case bp_watchpoint_scope:
3503 case bp_std_terminate:
3505 case bp_fast_tracepoint:
3507 case bp_gnu_ifunc_resolver:
3508 case bp_gnu_ifunc_resolver_return:
3510 result = PRINT_UNKNOWN;
3514 do_cleanups (old_chain);
3518 /* Generic routine for printing messages indicating why we
3519 stopped. The behavior of this function depends on the value
3520 'print_it' in the bpstat structure. Under some circumstances we
3521 may decide not to print anything here and delegate the task to
3524 static enum print_stop_action
3525 print_bp_stop_message (bpstat bs)
3527 switch (bs->print_it)
3530 /* Nothing should be printed for this bpstat entry. */
3531 return PRINT_UNKNOWN;
3535 /* We still want to print the frame, but we already printed the
3536 relevant messages. */
3537 return PRINT_SRC_AND_LOC;
3540 case print_it_normal:
3542 struct breakpoint *b = bs->breakpoint_at;
3544 /* bs->breakpoint_at can be NULL if it was a momentary breakpoint
3545 which has since been deleted. */
3547 return PRINT_UNKNOWN;
3549 /* Normal case. Call the breakpoint's print_it method, or
3550 print_it_typical. */
3551 if (b->ops != NULL && b->ops->print_it != NULL)
3552 return b->ops->print_it (b);
3554 return print_it_typical (bs);
3559 internal_error (__FILE__, __LINE__,
3560 _("print_bp_stop_message: unrecognized enum value"));
3565 /* Print a message indicating what happened. This is called from
3566 normal_stop(). The input to this routine is the head of the bpstat
3567 list - a list of the eventpoints that caused this stop. This
3568 routine calls the generic print routine for printing a message
3569 about reasons for stopping. This will print (for example) the
3570 "Breakpoint n," part of the output. The return value of this
3573 PRINT_UNKNOWN: Means we printed nothing.
3574 PRINT_SRC_AND_LOC: Means we printed something, and expect subsequent
3575 code to print the location. An example is
3576 "Breakpoint 1, " which should be followed by
3578 PRINT_SRC_ONLY: Means we printed something, but there is no need
3579 to also print the location part of the message.
3580 An example is the catch/throw messages, which
3581 don't require a location appended to the end.
3582 PRINT_NOTHING: We have done some printing and we don't need any
3583 further info to be printed. */
3585 enum print_stop_action
3586 bpstat_print (bpstat bs)
3590 /* Maybe another breakpoint in the chain caused us to stop.
3591 (Currently all watchpoints go on the bpstat whether hit or not.
3592 That probably could (should) be changed, provided care is taken
3593 with respect to bpstat_explains_signal). */
3594 for (; bs; bs = bs->next)
3596 val = print_bp_stop_message (bs);
3597 if (val == PRINT_SRC_ONLY
3598 || val == PRINT_SRC_AND_LOC
3599 || val == PRINT_NOTHING)
3603 /* We reached the end of the chain, or we got a null BS to start
3604 with and nothing was printed. */
3605 return PRINT_UNKNOWN;
3608 /* Evaluate the expression EXP and return 1 if value is zero. This is
3609 used inside a catch_errors to evaluate the breakpoint condition.
3610 The argument is a "struct expression *" that has been cast to a
3611 "char *" to make it pass through catch_errors. */
3614 breakpoint_cond_eval (void *exp)
3616 struct value *mark = value_mark ();
3617 int i = !value_true (evaluate_expression ((struct expression *) exp));
3619 value_free_to_mark (mark);
3623 /* Allocate a new bpstat. Link it to the FIFO list by BS_LINK_POINTER. */
3626 bpstat_alloc (struct bp_location *bl, bpstat **bs_link_pointer)
3630 bs = (bpstat) xmalloc (sizeof (*bs));
3632 **bs_link_pointer = bs;
3633 *bs_link_pointer = &bs->next;
3634 bs->breakpoint_at = bl->owner;
3635 bs->bp_location_at = bl;
3636 incref_bp_location (bl);
3637 /* If the condition is false, etc., don't do the commands. */
3638 bs->commands = NULL;
3639 bs->commands_left = NULL;
3641 bs->print_it = print_it_normal;
3645 /* The target has stopped with waitstatus WS. Check if any hardware
3646 watchpoints have triggered, according to the target. */
3649 watchpoints_triggered (struct target_waitstatus *ws)
3651 int stopped_by_watchpoint = target_stopped_by_watchpoint ();
3653 struct breakpoint *b;
3655 if (!stopped_by_watchpoint)
3657 /* We were not stopped by a watchpoint. Mark all watchpoints
3658 as not triggered. */
3660 if (is_hardware_watchpoint (b))
3661 b->watchpoint_triggered = watch_triggered_no;
3666 if (!target_stopped_data_address (¤t_target, &addr))
3668 /* We were stopped by a watchpoint, but we don't know where.
3669 Mark all watchpoints as unknown. */
3671 if (is_hardware_watchpoint (b))
3672 b->watchpoint_triggered = watch_triggered_unknown;
3674 return stopped_by_watchpoint;
3677 /* The target could report the data address. Mark watchpoints
3678 affected by this data address as triggered, and all others as not
3682 if (is_hardware_watchpoint (b))
3684 struct bp_location *loc;
3686 b->watchpoint_triggered = watch_triggered_no;
3687 for (loc = b->loc; loc; loc = loc->next)
3688 /* Exact match not required. Within range is
3690 if (target_watchpoint_addr_within_range (¤t_target,
3694 b->watchpoint_triggered = watch_triggered_yes;
3702 /* Possible return values for watchpoint_check (this can't be an enum
3703 because of check_errors). */
3704 /* The watchpoint has been deleted. */
3705 #define WP_DELETED 1
3706 /* The value has changed. */
3707 #define WP_VALUE_CHANGED 2
3708 /* The value has not changed. */
3709 #define WP_VALUE_NOT_CHANGED 3
3710 /* Ignore this watchpoint, no matter if the value changed or not. */
3713 #define BP_TEMPFLAG 1
3714 #define BP_HARDWAREFLAG 2
3716 /* Evaluate watchpoint condition expression and check if its value
3719 P should be a pointer to struct bpstat, but is defined as a void *
3720 in order for this function to be usable with catch_errors. */
3723 watchpoint_check (void *p)
3725 bpstat bs = (bpstat) p;
3726 struct breakpoint *b;
3727 struct frame_info *fr;
3728 int within_current_scope;
3730 /* BS is built from an existing struct breakpoint. */
3731 gdb_assert (bs->breakpoint_at != NULL);
3732 b = bs->breakpoint_at;
3734 gdb_assert (is_watchpoint (b));
3736 /* If this is a local watchpoint, we only want to check if the
3737 watchpoint frame is in scope if the current thread is the thread
3738 that was used to create the watchpoint. */
3739 if (!watchpoint_in_thread_scope (b))
3742 if (b->exp_valid_block == NULL)
3743 within_current_scope = 1;
3746 struct frame_info *frame = get_current_frame ();
3747 struct gdbarch *frame_arch = get_frame_arch (frame);
3748 CORE_ADDR frame_pc = get_frame_pc (frame);
3750 /* in_function_epilogue_p() returns a non-zero value if we're
3751 still in the function but the stack frame has already been
3752 invalidated. Since we can't rely on the values of local
3753 variables after the stack has been destroyed, we are treating
3754 the watchpoint in that state as `not changed' without further
3755 checking. Don't mark watchpoints as changed if the current
3756 frame is in an epilogue - even if they are in some other
3757 frame, our view of the stack is likely to be wrong and
3758 frame_find_by_id could error out. */
3759 if (gdbarch_in_function_epilogue_p (frame_arch, frame_pc))
3762 fr = frame_find_by_id (b->watchpoint_frame);
3763 within_current_scope = (fr != NULL);
3765 /* If we've gotten confused in the unwinder, we might have
3766 returned a frame that can't describe this variable. */
3767 if (within_current_scope)
3769 struct symbol *function;
3771 function = get_frame_function (fr);
3772 if (function == NULL
3773 || !contained_in (b->exp_valid_block,
3774 SYMBOL_BLOCK_VALUE (function)))
3775 within_current_scope = 0;
3778 if (within_current_scope)
3779 /* If we end up stopping, the current frame will get selected
3780 in normal_stop. So this call to select_frame won't affect
3785 if (within_current_scope)
3787 /* We use value_{,free_to_}mark because it could be a *long*
3788 time before we return to the command level and call
3789 free_all_values. We can't call free_all_values because we
3790 might be in the middle of evaluating a function call. */
3793 struct value *mark = value_mark ();
3794 struct value *new_val;
3796 fetch_subexp_value (b->exp, &pc, &new_val, NULL, NULL);
3798 /* We use value_equal_contents instead of value_equal because
3799 the latter coerces an array to a pointer, thus comparing just
3800 the address of the array instead of its contents. This is
3801 not what we want. */
3802 if ((b->val != NULL) != (new_val != NULL)
3803 || (b->val != NULL && !value_equal_contents (b->val, new_val)))
3805 if (new_val != NULL)
3807 release_value (new_val);
3808 value_free_to_mark (mark);
3810 bs->old_val = b->val;
3813 return WP_VALUE_CHANGED;
3817 /* Nothing changed. */
3818 value_free_to_mark (mark);
3819 return WP_VALUE_NOT_CHANGED;
3824 /* This seems like the only logical thing to do because
3825 if we temporarily ignored the watchpoint, then when
3826 we reenter the block in which it is valid it contains
3827 garbage (in the case of a function, it may have two
3828 garbage values, one before and one after the prologue).
3829 So we can't even detect the first assignment to it and
3830 watch after that (since the garbage may or may not equal
3831 the first value assigned). */
3832 /* We print all the stop information in print_it_typical(), but
3833 in this case, by the time we call print_it_typical() this bp
3834 will be deleted already. So we have no choice but print the
3835 information here. */
3836 if (ui_out_is_mi_like_p (uiout))
3838 (uiout, "reason", async_reason_lookup (EXEC_ASYNC_WATCHPOINT_SCOPE));
3839 ui_out_text (uiout, "\nWatchpoint ");
3840 ui_out_field_int (uiout, "wpnum", b->number);
3842 " deleted because the program has left the block in\n\
3843 which its expression is valid.\n");
3845 watchpoint_del_at_next_stop (b);
3851 /* Return true if it looks like target has stopped due to hitting
3852 breakpoint location BL. This function does not check if we
3853 should stop, only if BL explains the stop. */
3855 bpstat_check_location (const struct bp_location *bl,
3856 struct address_space *aspace, CORE_ADDR bp_addr)
3858 struct breakpoint *b = bl->owner;
3860 /* BL is from existing struct breakpoint. */
3861 gdb_assert (b != NULL);
3863 /* By definition, the inferior does not report stops at
3865 if (is_tracepoint (b))
3868 if (!is_watchpoint (b)
3869 && b->type != bp_hardware_breakpoint
3870 && b->type != bp_catchpoint) /* a non-watchpoint bp */
3872 if (!breakpoint_address_match (bl->pspace->aspace, bl->address,
3875 if (overlay_debugging /* unmapped overlay section */
3876 && section_is_overlay (bl->section)
3877 && !section_is_mapped (bl->section))
3881 /* Continuable hardware watchpoints are treated as non-existent if the
3882 reason we stopped wasn't a hardware watchpoint (we didn't stop on
3883 some data address). Otherwise gdb won't stop on a break instruction
3884 in the code (not from a breakpoint) when a hardware watchpoint has
3885 been defined. Also skip watchpoints which we know did not trigger
3886 (did not match the data address). */
3888 if (is_hardware_watchpoint (b)
3889 && b->watchpoint_triggered == watch_triggered_no)
3892 if (b->type == bp_hardware_breakpoint)
3894 if (bl->address != bp_addr)
3896 if (overlay_debugging /* unmapped overlay section */
3897 && section_is_overlay (bl->section)
3898 && !section_is_mapped (bl->section))
3902 if (b->type == bp_catchpoint)
3904 gdb_assert (b->ops != NULL && b->ops->breakpoint_hit != NULL);
3905 if (!b->ops->breakpoint_hit (b))
3912 /* If BS refers to a watchpoint, determine if the watched values
3913 has actually changed, and we should stop. If not, set BS->stop
3916 bpstat_check_watchpoint (bpstat bs)
3918 const struct bp_location *bl;
3919 struct breakpoint *b;
3921 /* BS is built for existing struct breakpoint. */
3922 bl = bs->bp_location_at;
3923 gdb_assert (bl != NULL);
3924 b = bs->breakpoint_at;
3925 gdb_assert (b != NULL);
3927 if (is_watchpoint (b))
3929 int must_check_value = 0;
3931 if (b->type == bp_watchpoint)
3932 /* For a software watchpoint, we must always check the
3934 must_check_value = 1;
3935 else if (b->watchpoint_triggered == watch_triggered_yes)
3936 /* We have a hardware watchpoint (read, write, or access)
3937 and the target earlier reported an address watched by
3939 must_check_value = 1;
3940 else if (b->watchpoint_triggered == watch_triggered_unknown
3941 && b->type == bp_hardware_watchpoint)
3942 /* We were stopped by a hardware watchpoint, but the target could
3943 not report the data address. We must check the watchpoint's
3944 value. Access and read watchpoints are out of luck; without
3945 a data address, we can't figure it out. */
3946 must_check_value = 1;
3948 if (must_check_value)
3951 = xstrprintf ("Error evaluating expression for watchpoint %d\n",
3953 struct cleanup *cleanups = make_cleanup (xfree, message);
3954 int e = catch_errors (watchpoint_check, bs, message,
3956 do_cleanups (cleanups);
3960 /* We've already printed what needs to be printed. */
3961 bs->print_it = print_it_done;
3965 bs->print_it = print_it_noop;
3968 case WP_VALUE_CHANGED:
3969 if (b->type == bp_read_watchpoint)
3971 /* There are two cases to consider here:
3973 1. We're watching the triggered memory for reads.
3974 In that case, trust the target, and always report
3975 the watchpoint hit to the user. Even though
3976 reads don't cause value changes, the value may
3977 have changed since the last time it was read, and
3978 since we're not trapping writes, we will not see
3979 those, and as such we should ignore our notion of
3982 2. We're watching the triggered memory for both
3983 reads and writes. There are two ways this may
3986 2.1. This is a target that can't break on data
3987 reads only, but can break on accesses (reads or
3988 writes), such as e.g., x86. We detect this case
3989 at the time we try to insert read watchpoints.
3991 2.2. Otherwise, the target supports read
3992 watchpoints, but, the user set an access or write
3993 watchpoint watching the same memory as this read
3996 If we're watching memory writes as well as reads,
3997 ignore watchpoint hits when we find that the
3998 value hasn't changed, as reads don't cause
3999 changes. This still gives false positives when
4000 the program writes the same value to memory as
4001 what there was already in memory (we will confuse
4002 it for a read), but it's much better than
4005 int other_write_watchpoint = 0;
4007 if (bl->watchpoint_type == hw_read)
4009 struct breakpoint *other_b;
4011 ALL_BREAKPOINTS (other_b)
4012 if ((other_b->type == bp_hardware_watchpoint
4013 || other_b->type == bp_access_watchpoint)
4014 && (other_b->watchpoint_triggered
4015 == watch_triggered_yes))
4017 other_write_watchpoint = 1;
4022 if (other_write_watchpoint
4023 || bl->watchpoint_type == hw_access)
4025 /* We're watching the same memory for writes,
4026 and the value changed since the last time we
4027 updated it, so this trap must be for a write.
4029 bs->print_it = print_it_noop;
4034 case WP_VALUE_NOT_CHANGED:
4035 if (b->type == bp_hardware_watchpoint
4036 || b->type == bp_watchpoint)
4038 /* Don't stop: write watchpoints shouldn't fire if
4039 the value hasn't changed. */
4040 bs->print_it = print_it_noop;
4048 /* Error from catch_errors. */
4049 printf_filtered (_("Watchpoint %d deleted.\n"), b->number);
4050 watchpoint_del_at_next_stop (b);
4051 /* We've already printed what needs to be printed. */
4052 bs->print_it = print_it_done;
4056 else /* must_check_value == 0 */
4058 /* This is a case where some watchpoint(s) triggered, but
4059 not at the address of this watchpoint, or else no
4060 watchpoint triggered after all. So don't print
4061 anything for this watchpoint. */
4062 bs->print_it = print_it_noop;
4069 /* Check conditions (condition proper, frame, thread and ignore count)
4070 of breakpoint referred to by BS. If we should not stop for this
4071 breakpoint, set BS->stop to 0. */
4074 bpstat_check_breakpoint_conditions (bpstat bs, ptid_t ptid)
4076 int thread_id = pid_to_thread_id (ptid);
4077 const struct bp_location *bl;
4078 struct breakpoint *b;
4080 /* BS is built for existing struct breakpoint. */
4081 bl = bs->bp_location_at;
4082 gdb_assert (bl != NULL);
4083 b = bs->breakpoint_at;
4084 gdb_assert (b != NULL);
4086 if (frame_id_p (b->frame_id)
4087 && !frame_id_eq (b->frame_id, get_stack_frame_id (get_current_frame ())))
4091 int value_is_zero = 0;
4092 struct expression *cond;
4094 /* Evaluate Python breakpoints that have a "stop"
4095 method implemented. */
4096 if (b->py_bp_object)
4097 bs->stop = gdbpy_should_stop (b->py_bp_object);
4099 if (is_watchpoint (b))
4104 if (cond && b->disposition != disp_del_at_next_stop)
4106 int within_current_scope = 1;
4108 /* We use value_mark and value_free_to_mark because it could
4109 be a long time before we return to the command level and
4110 call free_all_values. We can't call free_all_values
4111 because we might be in the middle of evaluating a
4113 struct value *mark = value_mark ();
4115 /* Need to select the frame, with all that implies so that
4116 the conditions will have the right context. Because we
4117 use the frame, we will not see an inlined function's
4118 variables when we arrive at a breakpoint at the start
4119 of the inlined function; the current frame will be the
4121 if (!is_watchpoint (b) || b->cond_exp_valid_block == NULL)
4122 select_frame (get_current_frame ());
4125 struct frame_info *frame;
4127 /* For local watchpoint expressions, which particular
4128 instance of a local is being watched matters, so we
4129 keep track of the frame to evaluate the expression
4130 in. To evaluate the condition however, it doesn't
4131 really matter which instantiation of the function
4132 where the condition makes sense triggers the
4133 watchpoint. This allows an expression like "watch
4134 global if q > 10" set in `func', catch writes to
4135 global on all threads that call `func', or catch
4136 writes on all recursive calls of `func' by a single
4137 thread. We simply always evaluate the condition in
4138 the innermost frame that's executing where it makes
4139 sense to evaluate the condition. It seems
4141 frame = block_innermost_frame (b->cond_exp_valid_block);
4143 select_frame (frame);
4145 within_current_scope = 0;
4147 if (within_current_scope)
4149 = catch_errors (breakpoint_cond_eval, cond,
4150 "Error in testing breakpoint condition:\n",
4154 warning (_("Watchpoint condition cannot be tested "
4155 "in the current scope"));
4156 /* If we failed to set the right context for this
4157 watchpoint, unconditionally report it. */
4160 /* FIXME-someday, should give breakpoint #. */
4161 value_free_to_mark (mark);
4164 if (cond && value_is_zero)
4168 else if (b->thread != -1 && b->thread != thread_id)
4172 else if (b->ignore_count > 0)
4175 annotate_ignore_count_change ();
4177 /* Increase the hit count even though we don't stop. */
4184 /* Get a bpstat associated with having just stopped at address
4185 BP_ADDR in thread PTID.
4187 Determine whether we stopped at a breakpoint, etc, or whether we
4188 don't understand this stop. Result is a chain of bpstat's such
4191 if we don't understand the stop, the result is a null pointer.
4193 if we understand why we stopped, the result is not null.
4195 Each element of the chain refers to a particular breakpoint or
4196 watchpoint at which we have stopped. (We may have stopped for
4197 several reasons concurrently.)
4199 Each element of the chain has valid next, breakpoint_at,
4200 commands, FIXME??? fields. */
4203 bpstat_stop_status (struct address_space *aspace,
4204 CORE_ADDR bp_addr, ptid_t ptid)
4206 struct breakpoint *b = NULL;
4207 struct bp_location *bl;
4208 struct bp_location *loc;
4209 /* First item of allocated bpstat's. */
4210 bpstat bs_head = NULL, *bs_link = &bs_head;
4211 /* Pointer to the last thing in the chain currently. */
4214 int need_remove_insert;
4217 /* First, build the bpstat chain with locations that explain a
4218 target stop, while being careful to not set the target running,
4219 as that may invalidate locations (in particular watchpoint
4220 locations are recreated). Resuming will happen here with
4221 breakpoint conditions or watchpoint expressions that include
4222 inferior function calls. */
4226 if (!breakpoint_enabled (b) && b->enable_state != bp_permanent)
4229 for (bl = b->loc; bl != NULL; bl = bl->next)
4231 /* For hardware watchpoints, we look only at the first
4232 location. The watchpoint_check function will work on the
4233 entire expression, not the individual locations. For
4234 read watchpoints, the watchpoints_triggered function has
4235 checked all locations already. */
4236 if (b->type == bp_hardware_watchpoint && bl != b->loc)
4239 if (bl->shlib_disabled)
4242 if (!bpstat_check_location (bl, aspace, bp_addr))
4245 /* Come here if it's a watchpoint, or if the break address
4248 bs = bpstat_alloc (bl, &bs_link); /* Alloc a bpstat to
4251 /* Assume we stop. Should we find a watchpoint that is not
4252 actually triggered, or if the condition of the breakpoint
4253 evaluates as false, we'll reset 'stop' to 0. */
4257 /* If this is a scope breakpoint, mark the associated
4258 watchpoint as triggered so that we will handle the
4259 out-of-scope event. We'll get to the watchpoint next
4261 if (b->type == bp_watchpoint_scope && b->related_breakpoint != b)
4262 b->related_breakpoint->watchpoint_triggered = watch_triggered_yes;
4266 for (ix = 0; VEC_iterate (bp_location_p, moribund_locations, ix, loc); ++ix)
4268 if (breakpoint_address_match (loc->pspace->aspace, loc->address,
4271 bs = bpstat_alloc (loc, &bs_link);
4272 /* For hits of moribund locations, we should just proceed. */
4275 bs->print_it = print_it_noop;
4279 /* Now go through the locations that caused the target to stop, and
4280 check whether we're interested in reporting this stop to higher
4281 layers, or whether we should resume the target transparently. */
4285 for (bs = bs_head; bs != NULL; bs = bs->next)
4290 bpstat_check_watchpoint (bs);
4294 b = bs->breakpoint_at;
4296 if (b->type == bp_thread_event || b->type == bp_overlay_event
4297 || b->type == bp_longjmp_master
4298 || b->type == bp_std_terminate_master
4299 || b->type == bp_exception_master)
4300 /* We do not stop for these. */
4303 bpstat_check_breakpoint_conditions (bs, ptid);
4309 /* We will stop here. */
4310 if (b->disposition == disp_disable)
4312 if (b->enable_state != bp_permanent)
4313 b->enable_state = bp_disabled;
4318 bs->commands = b->commands;
4319 incref_counted_command_line (bs->commands);
4320 bs->commands_left = bs->commands ? bs->commands->commands : NULL;
4321 if (bs->commands_left
4322 && (strcmp ("silent", bs->commands_left->line) == 0
4325 bs->commands_left->line) == 0)))
4327 bs->commands_left = bs->commands_left->next;
4332 /* Print nothing for this entry if we dont stop or dont print. */
4333 if (bs->stop == 0 || bs->print == 0)
4334 bs->print_it = print_it_noop;
4337 /* If we aren't stopping, the value of some hardware watchpoint may
4338 not have changed, but the intermediate memory locations we are
4339 watching may have. Don't bother if we're stopping; this will get
4341 need_remove_insert = 0;
4342 if (! bpstat_causes_stop (bs_head))
4343 for (bs = bs_head; bs != NULL; bs = bs->next)
4345 && bs->breakpoint_at
4346 && is_hardware_watchpoint (bs->breakpoint_at))
4348 update_watchpoint (bs->breakpoint_at, 0 /* don't reparse. */);
4349 need_remove_insert = 1;
4352 if (need_remove_insert)
4353 update_global_location_list (1);
4354 else if (removed_any)
4355 update_global_location_list (0);
4361 handle_jit_event (void)
4363 struct frame_info *frame;
4364 struct gdbarch *gdbarch;
4366 /* Switch terminal for any messages produced by
4367 breakpoint_re_set. */
4368 target_terminal_ours_for_output ();
4370 frame = get_current_frame ();
4371 gdbarch = get_frame_arch (frame);
4373 jit_event_handler (gdbarch);
4375 target_terminal_inferior ();
4378 /* Prepare WHAT final decision for infrun. */
4380 /* Decide what infrun needs to do with this bpstat. */
4383 bpstat_what (bpstat bs_head)
4385 struct bpstat_what retval;
4386 /* We need to defer calling `solib_add', as adding new symbols
4387 resets breakpoints, which in turn deletes breakpoint locations,
4388 and hence may clear unprocessed entries in the BS chain. */
4389 int shlib_event = 0;
4393 retval.main_action = BPSTAT_WHAT_KEEP_CHECKING;
4394 retval.call_dummy = STOP_NONE;
4395 retval.is_longjmp = 0;
4397 for (bs = bs_head; bs != NULL; bs = bs->next)
4399 /* Extract this BS's action. After processing each BS, we check
4400 if its action overrides all we've seem so far. */
4401 enum bpstat_what_main_action this_action = BPSTAT_WHAT_KEEP_CHECKING;
4404 if (bs->breakpoint_at == NULL)
4406 /* I suspect this can happen if it was a momentary
4407 breakpoint which has since been deleted. */
4410 else if (bs->breakpoint_at == NULL)
4413 bptype = bs->breakpoint_at->type;
4420 case bp_hardware_breakpoint:
4426 this_action = BPSTAT_WHAT_STOP_NOISY;
4428 this_action = BPSTAT_WHAT_STOP_SILENT;
4431 this_action = BPSTAT_WHAT_SINGLE;
4434 case bp_hardware_watchpoint:
4435 case bp_read_watchpoint:
4436 case bp_access_watchpoint:
4440 this_action = BPSTAT_WHAT_STOP_NOISY;
4442 this_action = BPSTAT_WHAT_STOP_SILENT;
4446 /* There was a watchpoint, but we're not stopping.
4447 This requires no further action. */
4452 this_action = BPSTAT_WHAT_SET_LONGJMP_RESUME;
4453 retval.is_longjmp = bptype == bp_longjmp;
4455 case bp_longjmp_resume:
4456 case bp_exception_resume:
4457 this_action = BPSTAT_WHAT_CLEAR_LONGJMP_RESUME;
4458 retval.is_longjmp = bptype == bp_longjmp_resume;
4460 case bp_step_resume:
4462 this_action = BPSTAT_WHAT_STEP_RESUME;
4465 /* It is for the wrong frame. */
4466 this_action = BPSTAT_WHAT_SINGLE;
4469 case bp_watchpoint_scope:
4470 case bp_thread_event:
4471 case bp_overlay_event:
4472 case bp_longjmp_master:
4473 case bp_std_terminate_master:
4474 case bp_exception_master:
4475 this_action = BPSTAT_WHAT_SINGLE;
4481 this_action = BPSTAT_WHAT_STOP_NOISY;
4483 this_action = BPSTAT_WHAT_STOP_SILENT;
4487 /* There was a catchpoint, but we're not stopping.
4488 This requires no further action. */
4491 case bp_shlib_event:
4494 /* If requested, stop when the dynamic linker notifies GDB
4495 of events. This allows the user to get control and place
4496 breakpoints in initializer routines for dynamically
4497 loaded objects (among other things). */
4498 if (stop_on_solib_events)
4499 this_action = BPSTAT_WHAT_STOP_NOISY;
4501 this_action = BPSTAT_WHAT_SINGLE;
4505 this_action = BPSTAT_WHAT_SINGLE;
4508 /* Make sure the action is stop (silent or noisy),
4509 so infrun.c pops the dummy frame. */
4510 retval.call_dummy = STOP_STACK_DUMMY;
4511 this_action = BPSTAT_WHAT_STOP_SILENT;
4513 case bp_std_terminate:
4514 /* Make sure the action is stop (silent or noisy),
4515 so infrun.c pops the dummy frame. */
4516 retval.call_dummy = STOP_STD_TERMINATE;
4517 this_action = BPSTAT_WHAT_STOP_SILENT;
4520 case bp_fast_tracepoint:
4521 case bp_static_tracepoint:
4522 /* Tracepoint hits should not be reported back to GDB, and
4523 if one got through somehow, it should have been filtered
4525 internal_error (__FILE__, __LINE__,
4526 _("bpstat_what: tracepoint encountered"));
4528 case bp_gnu_ifunc_resolver:
4529 /* Step over it (and insert bp_gnu_ifunc_resolver_return). */
4530 this_action = BPSTAT_WHAT_SINGLE;
4532 case bp_gnu_ifunc_resolver_return:
4533 /* The breakpoint will be removed, execution will restart from the
4534 PC of the former breakpoint. */
4535 this_action = BPSTAT_WHAT_KEEP_CHECKING;
4538 internal_error (__FILE__, __LINE__,
4539 _("bpstat_what: unhandled bptype %d"), (int) bptype);
4542 retval.main_action = max (retval.main_action, this_action);
4545 /* These operations may affect the bs->breakpoint_at state so they are
4546 delayed after MAIN_ACTION is decided above. */
4551 fprintf_unfiltered (gdb_stdlog, "bpstat_what: bp_shlib_event\n");
4553 /* Check for any newly added shared libraries if we're supposed
4554 to be adding them automatically. */
4556 /* Switch terminal for any messages produced by
4557 breakpoint_re_set. */
4558 target_terminal_ours_for_output ();
4561 SOLIB_ADD (NULL, 0, ¤t_target, auto_solib_add);
4563 solib_add (NULL, 0, ¤t_target, auto_solib_add);
4566 target_terminal_inferior ();
4572 fprintf_unfiltered (gdb_stdlog, "bpstat_what: bp_jit_event\n");
4574 handle_jit_event ();
4577 for (bs = bs_head; bs != NULL; bs = bs->next)
4579 struct breakpoint *b = bs->breakpoint_at;
4585 case bp_gnu_ifunc_resolver:
4586 gnu_ifunc_resolver_stop (b);
4588 case bp_gnu_ifunc_resolver_return:
4589 gnu_ifunc_resolver_return_stop (b);
4597 /* Nonzero if we should step constantly (e.g. watchpoints on machines
4598 without hardware support). This isn't related to a specific bpstat,
4599 just to things like whether watchpoints are set. */
4602 bpstat_should_step (void)
4604 struct breakpoint *b;
4607 if (breakpoint_enabled (b) && b->type == bp_watchpoint && b->loc != NULL)
4613 bpstat_causes_stop (bpstat bs)
4615 for (; bs != NULL; bs = bs->next)
4624 /* Compute a string of spaces suitable to indent the next line
4625 so it starts at the position corresponding to the table column
4626 named COL_NAME in the currently active table of UIOUT. */
4629 wrap_indent_at_field (struct ui_out *uiout, const char *col_name)
4631 static char wrap_indent[80];
4632 int i, total_width, width, align;
4636 for (i = 1; ui_out_query_field (uiout, i, &width, &align, &text); i++)
4638 if (strcmp (text, col_name) == 0)
4640 gdb_assert (total_width < sizeof wrap_indent);
4641 memset (wrap_indent, ' ', total_width);
4642 wrap_indent[total_width] = 0;
4647 total_width += width + 1;
4653 /* Print the LOC location out of the list of B->LOC locations. */
4656 print_breakpoint_location (struct breakpoint *b,
4657 struct bp_location *loc)
4659 struct cleanup *old_chain = save_current_program_space ();
4661 if (loc != NULL && loc->shlib_disabled)
4665 set_current_program_space (loc->pspace);
4667 if (b->display_canonical)
4668 ui_out_field_string (uiout, "what", b->addr_string);
4669 else if (b->source_file && loc)
4672 = find_pc_sect_function (loc->address, loc->section);
4675 ui_out_text (uiout, "in ");
4676 ui_out_field_string (uiout, "func",
4677 SYMBOL_PRINT_NAME (sym));
4678 ui_out_text (uiout, " ");
4679 ui_out_wrap_hint (uiout, wrap_indent_at_field (uiout, "what"));
4680 ui_out_text (uiout, "at ");
4682 ui_out_field_string (uiout, "file", b->source_file);
4683 ui_out_text (uiout, ":");
4685 if (ui_out_is_mi_like_p (uiout))
4687 struct symtab_and_line sal = find_pc_line (loc->address, 0);
4688 char *fullname = symtab_to_fullname (sal.symtab);
4691 ui_out_field_string (uiout, "fullname", fullname);
4694 ui_out_field_int (uiout, "line", b->line_number);
4698 struct ui_stream *stb = ui_out_stream_new (uiout);
4699 struct cleanup *stb_chain = make_cleanup_ui_out_stream_delete (stb);
4701 print_address_symbolic (loc->gdbarch, loc->address, stb->stream,
4703 ui_out_field_stream (uiout, "at", stb);
4705 do_cleanups (stb_chain);
4708 ui_out_field_string (uiout, "pending", b->addr_string);
4710 do_cleanups (old_chain);
4714 bptype_string (enum bptype type)
4716 struct ep_type_description
4721 static struct ep_type_description bptypes[] =
4723 {bp_none, "?deleted?"},
4724 {bp_breakpoint, "breakpoint"},
4725 {bp_hardware_breakpoint, "hw breakpoint"},
4726 {bp_until, "until"},
4727 {bp_finish, "finish"},
4728 {bp_watchpoint, "watchpoint"},
4729 {bp_hardware_watchpoint, "hw watchpoint"},
4730 {bp_read_watchpoint, "read watchpoint"},
4731 {bp_access_watchpoint, "acc watchpoint"},
4732 {bp_longjmp, "longjmp"},
4733 {bp_longjmp_resume, "longjmp resume"},
4734 {bp_exception, "exception"},
4735 {bp_exception_resume, "exception resume"},
4736 {bp_step_resume, "step resume"},
4737 {bp_watchpoint_scope, "watchpoint scope"},
4738 {bp_call_dummy, "call dummy"},
4739 {bp_std_terminate, "std::terminate"},
4740 {bp_shlib_event, "shlib events"},
4741 {bp_thread_event, "thread events"},
4742 {bp_overlay_event, "overlay events"},
4743 {bp_longjmp_master, "longjmp master"},
4744 {bp_std_terminate_master, "std::terminate master"},
4745 {bp_exception_master, "exception master"},
4746 {bp_catchpoint, "catchpoint"},
4747 {bp_tracepoint, "tracepoint"},
4748 {bp_fast_tracepoint, "fast tracepoint"},
4749 {bp_static_tracepoint, "static tracepoint"},
4750 {bp_jit_event, "jit events"},
4751 {bp_gnu_ifunc_resolver, "STT_GNU_IFUNC resolver"},
4752 {bp_gnu_ifunc_resolver_return, "STT_GNU_IFUNC resolver return"},
4755 if (((int) type >= (sizeof (bptypes) / sizeof (bptypes[0])))
4756 || ((int) type != bptypes[(int) type].type))
4757 internal_error (__FILE__, __LINE__,
4758 _("bptypes table does not describe type #%d."),
4761 return bptypes[(int) type].description;
4764 /* Print B to gdb_stdout. */
4767 print_one_breakpoint_location (struct breakpoint *b,
4768 struct bp_location *loc,
4770 struct bp_location **last_loc,
4773 struct command_line *l;
4774 static char bpenables[] = "nynny";
4775 struct cleanup *bkpt_chain;
4777 int header_of_multiple = 0;
4778 int part_of_multiple = (loc != NULL);
4779 struct value_print_options opts;
4781 get_user_print_options (&opts);
4783 gdb_assert (!loc || loc_number != 0);
4784 /* See comment in print_one_breakpoint concerning treatment of
4785 breakpoints with single disabled location. */
4788 && (b->loc->next != NULL || !b->loc->enabled)))
4789 header_of_multiple = 1;
4794 bkpt_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "bkpt");
4798 if (part_of_multiple)
4801 formatted = xstrprintf ("%d.%d", b->number, loc_number);
4802 ui_out_field_string (uiout, "number", formatted);
4807 ui_out_field_int (uiout, "number", b->number);
4812 if (part_of_multiple)
4813 ui_out_field_skip (uiout, "type");
4815 ui_out_field_string (uiout, "type", bptype_string (b->type));
4819 if (part_of_multiple)
4820 ui_out_field_skip (uiout, "disp");
4822 ui_out_field_string (uiout, "disp", bpdisp_text (b->disposition));
4827 if (part_of_multiple)
4828 ui_out_field_string (uiout, "enabled", loc->enabled ? "y" : "n");
4830 ui_out_field_fmt (uiout, "enabled", "%c",
4831 bpenables[(int) b->enable_state]);
4832 ui_out_spaces (uiout, 2);
4836 if (b->ops != NULL && b->ops->print_one != NULL)
4838 /* Although the print_one can possibly print all locations,
4839 calling it here is not likely to get any nice result. So,
4840 make sure there's just one location. */
4841 gdb_assert (b->loc == NULL || b->loc->next == NULL);
4842 b->ops->print_one (b, last_loc);
4848 internal_error (__FILE__, __LINE__,
4849 _("print_one_breakpoint: bp_none encountered\n"));
4853 case bp_hardware_watchpoint:
4854 case bp_read_watchpoint:
4855 case bp_access_watchpoint:
4856 /* Field 4, the address, is omitted (which makes the columns
4857 not line up too nicely with the headers, but the effect
4858 is relatively readable). */
4859 if (opts.addressprint)
4860 ui_out_field_skip (uiout, "addr");
4862 ui_out_field_string (uiout, "what", b->exp_string);
4866 case bp_hardware_breakpoint:
4870 case bp_longjmp_resume:
4872 case bp_exception_resume:
4873 case bp_step_resume:
4874 case bp_watchpoint_scope:
4876 case bp_std_terminate:
4877 case bp_shlib_event:
4878 case bp_thread_event:
4879 case bp_overlay_event:
4880 case bp_longjmp_master:
4881 case bp_std_terminate_master:
4882 case bp_exception_master:
4884 case bp_fast_tracepoint:
4885 case bp_static_tracepoint:
4887 case bp_gnu_ifunc_resolver:
4888 case bp_gnu_ifunc_resolver_return:
4889 if (opts.addressprint)
4892 if (header_of_multiple)
4893 ui_out_field_string (uiout, "addr", "<MULTIPLE>");
4894 else if (b->loc == NULL || loc->shlib_disabled)
4895 ui_out_field_string (uiout, "addr", "<PENDING>");
4897 ui_out_field_core_addr (uiout, "addr",
4898 loc->gdbarch, loc->address);
4901 if (!header_of_multiple)
4902 print_breakpoint_location (b, loc);
4909 /* For backward compatibility, don't display inferiors unless there
4912 && !header_of_multiple
4914 || (!gdbarch_has_global_breakpoints (target_gdbarch)
4915 && (number_of_program_spaces () > 1
4916 || number_of_inferiors () > 1)
4917 /* LOC is for existing B, it cannot be in
4918 moribund_locations and thus having NULL OWNER. */
4919 && loc->owner->type != bp_catchpoint)))
4921 struct inferior *inf;
4924 for (inf = inferior_list; inf != NULL; inf = inf->next)
4926 if (inf->pspace == loc->pspace)
4931 ui_out_text (uiout, " inf ");
4934 ui_out_text (uiout, ", ");
4935 ui_out_text (uiout, plongest (inf->num));
4940 if (!part_of_multiple)
4942 if (b->thread != -1)
4944 /* FIXME: This seems to be redundant and lost here; see the
4945 "stop only in" line a little further down. */
4946 ui_out_text (uiout, " thread ");
4947 ui_out_field_int (uiout, "thread", b->thread);
4949 else if (b->task != 0)
4951 ui_out_text (uiout, " task ");
4952 ui_out_field_int (uiout, "task", b->task);
4956 ui_out_text (uiout, "\n");
4958 if (!part_of_multiple && b->static_trace_marker_id)
4960 gdb_assert (b->type == bp_static_tracepoint);
4962 ui_out_text (uiout, "\tmarker id is ");
4963 ui_out_field_string (uiout, "static-tracepoint-marker-string-id",
4964 b->static_trace_marker_id);
4965 ui_out_text (uiout, "\n");
4968 if (part_of_multiple && frame_id_p (b->frame_id))
4971 ui_out_text (uiout, "\tstop only in stack frame at ");
4972 /* FIXME: cagney/2002-12-01: Shouldn't be poeking around inside
4974 ui_out_field_core_addr (uiout, "frame",
4975 b->gdbarch, b->frame_id.stack_addr);
4976 ui_out_text (uiout, "\n");
4979 if (!part_of_multiple && b->cond_string && !ada_exception_catchpoint_p (b))
4981 /* We do not print the condition for Ada exception catchpoints
4982 because the condition is an internal implementation detail
4983 that we do not want to expose to the user. */
4985 if (is_tracepoint (b))
4986 ui_out_text (uiout, "\ttrace only if ");
4988 ui_out_text (uiout, "\tstop only if ");
4989 ui_out_field_string (uiout, "cond", b->cond_string);
4990 ui_out_text (uiout, "\n");
4993 if (!part_of_multiple && b->thread != -1)
4995 /* FIXME should make an annotation for this. */
4996 ui_out_text (uiout, "\tstop only in thread ");
4997 ui_out_field_int (uiout, "thread", b->thread);
4998 ui_out_text (uiout, "\n");
5001 if (!part_of_multiple && b->hit_count)
5003 /* FIXME should make an annotation for this. */
5004 if (ep_is_catchpoint (b))
5005 ui_out_text (uiout, "\tcatchpoint");
5007 ui_out_text (uiout, "\tbreakpoint");
5008 ui_out_text (uiout, " already hit ");
5009 ui_out_field_int (uiout, "times", b->hit_count);
5010 if (b->hit_count == 1)
5011 ui_out_text (uiout, " time\n");
5013 ui_out_text (uiout, " times\n");
5016 /* Output the count also if it is zero, but only if this is mi.
5017 FIXME: Should have a better test for this. */
5018 if (ui_out_is_mi_like_p (uiout))
5019 if (!part_of_multiple && b->hit_count == 0)
5020 ui_out_field_int (uiout, "times", b->hit_count);
5022 if (!part_of_multiple && b->ignore_count)
5025 ui_out_text (uiout, "\tignore next ");
5026 ui_out_field_int (uiout, "ignore", b->ignore_count);
5027 ui_out_text (uiout, " hits\n");
5030 l = b->commands ? b->commands->commands : NULL;
5031 if (!part_of_multiple && l)
5033 struct cleanup *script_chain;
5036 script_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "script");
5037 print_command_lines (uiout, l, 4);
5038 do_cleanups (script_chain);
5041 if (!part_of_multiple && b->pass_count)
5043 annotate_field (10);
5044 ui_out_text (uiout, "\tpass count ");
5045 ui_out_field_int (uiout, "pass", b->pass_count);
5046 ui_out_text (uiout, " \n");
5049 if (ui_out_is_mi_like_p (uiout) && !part_of_multiple)
5052 ui_out_field_string (uiout, "original-location", b->addr_string);
5053 else if (b->exp_string)
5054 ui_out_field_string (uiout, "original-location", b->exp_string);
5057 do_cleanups (bkpt_chain);
5061 print_one_breakpoint (struct breakpoint *b,
5062 struct bp_location **last_loc,
5065 print_one_breakpoint_location (b, NULL, 0, last_loc, allflag);
5067 /* If this breakpoint has custom print function,
5068 it's already printed. Otherwise, print individual
5069 locations, if any. */
5070 if (b->ops == NULL || b->ops->print_one == NULL)
5072 /* If breakpoint has a single location that is disabled, we
5073 print it as if it had several locations, since otherwise it's
5074 hard to represent "breakpoint enabled, location disabled"
5077 Note that while hardware watchpoints have several locations
5078 internally, that's not a property exposed to user. */
5080 && !is_hardware_watchpoint (b)
5081 && (b->loc->next || !b->loc->enabled)
5082 && !ui_out_is_mi_like_p (uiout))
5084 struct bp_location *loc;
5086 for (loc = b->loc; loc; loc = loc->next, ++n)
5087 print_one_breakpoint_location (b, loc, n, last_loc, allflag);
5093 breakpoint_address_bits (struct breakpoint *b)
5095 int print_address_bits = 0;
5096 struct bp_location *loc;
5098 for (loc = b->loc; loc; loc = loc->next)
5102 /* Software watchpoints that aren't watching memory don't have
5103 an address to print. */
5104 if (b->type == bp_watchpoint && loc->watchpoint_type == -1)
5107 addr_bit = gdbarch_addr_bit (loc->gdbarch);
5108 if (addr_bit > print_address_bits)
5109 print_address_bits = addr_bit;
5112 return print_address_bits;
5115 struct captured_breakpoint_query_args
5121 do_captured_breakpoint_query (struct ui_out *uiout, void *data)
5123 struct captured_breakpoint_query_args *args = data;
5124 struct breakpoint *b;
5125 struct bp_location *dummy_loc = NULL;
5129 if (args->bnum == b->number)
5131 print_one_breakpoint (b, &dummy_loc, 0);
5139 gdb_breakpoint_query (struct ui_out *uiout, int bnum,
5140 char **error_message)
5142 struct captured_breakpoint_query_args args;
5145 /* For the moment we don't trust print_one_breakpoint() to not throw
5147 if (catch_exceptions_with_msg (uiout, do_captured_breakpoint_query, &args,
5148 error_message, RETURN_MASK_ALL) < 0)
5154 /* Return non-zero if B is user settable (breakpoints, watchpoints,
5155 catchpoints, et.al.). */
5158 user_settable_breakpoint (const struct breakpoint *b)
5160 return (b->type == bp_breakpoint
5161 || b->type == bp_catchpoint
5162 || b->type == bp_hardware_breakpoint
5163 || is_tracepoint (b)
5164 || is_watchpoint (b)
5165 || b->type == bp_gnu_ifunc_resolver);
5168 /* Return true if this breakpoint was set by the user, false if it is
5169 internal or momentary. */
5172 user_breakpoint_p (struct breakpoint *b)
5174 return user_settable_breakpoint (b) && b->number > 0;
5177 /* Print information on user settable breakpoint (watchpoint, etc)
5178 number BNUM. If BNUM is -1 print all user-settable breakpoints.
5179 If ALLFLAG is non-zero, include non-user-settable breakpoints. If
5180 FILTER is non-NULL, call it on each breakpoint and only include the
5181 ones for which it returns non-zero. Return the total number of
5182 breakpoints listed. */
5185 breakpoint_1 (char *args, int allflag,
5186 int (*filter) (const struct breakpoint *))
5188 struct breakpoint *b;
5189 struct bp_location *last_loc = NULL;
5190 int nr_printable_breakpoints;
5191 struct cleanup *bkpttbl_chain;
5192 struct value_print_options opts;
5193 int print_address_bits = 0;
5194 int print_type_col_width = 14;
5196 get_user_print_options (&opts);
5198 /* Compute the number of rows in the table, as well as the size
5199 required for address fields. */
5200 nr_printable_breakpoints = 0;
5203 /* If we have a filter, only list the breakpoints it accepts. */
5204 if (filter && !filter (b))
5207 /* If we have an "args" string, it is a list of breakpoints to
5208 accept. Skip the others. */
5209 if (args != NULL && *args != '\0')
5211 if (allflag && parse_and_eval_long (args) != b->number)
5213 if (!allflag && !number_is_in_list (args, b->number))
5217 if (allflag || user_breakpoint_p (b))
5219 int addr_bit, type_len;
5221 addr_bit = breakpoint_address_bits (b);
5222 if (addr_bit > print_address_bits)
5223 print_address_bits = addr_bit;
5225 type_len = strlen (bptype_string (b->type));
5226 if (type_len > print_type_col_width)
5227 print_type_col_width = type_len;
5229 nr_printable_breakpoints++;
5233 if (opts.addressprint)
5235 = make_cleanup_ui_out_table_begin_end (uiout, 6,
5236 nr_printable_breakpoints,
5240 = make_cleanup_ui_out_table_begin_end (uiout, 5,
5241 nr_printable_breakpoints,
5244 if (nr_printable_breakpoints > 0)
5245 annotate_breakpoints_headers ();
5246 if (nr_printable_breakpoints > 0)
5248 ui_out_table_header (uiout, 7, ui_left, "number", "Num"); /* 1 */
5249 if (nr_printable_breakpoints > 0)
5251 ui_out_table_header (uiout, print_type_col_width, ui_left,
5252 "type", "Type"); /* 2 */
5253 if (nr_printable_breakpoints > 0)
5255 ui_out_table_header (uiout, 4, ui_left, "disp", "Disp"); /* 3 */
5256 if (nr_printable_breakpoints > 0)
5258 ui_out_table_header (uiout, 3, ui_left, "enabled", "Enb"); /* 4 */
5259 if (opts.addressprint)
5261 if (nr_printable_breakpoints > 0)
5263 if (print_address_bits <= 32)
5264 ui_out_table_header (uiout, 10, ui_left,
5265 "addr", "Address"); /* 5 */
5267 ui_out_table_header (uiout, 18, ui_left,
5268 "addr", "Address"); /* 5 */
5270 if (nr_printable_breakpoints > 0)
5272 ui_out_table_header (uiout, 40, ui_noalign, "what", "What"); /* 6 */
5273 ui_out_table_body (uiout);
5274 if (nr_printable_breakpoints > 0)
5275 annotate_breakpoints_table ();
5280 /* If we have a filter, only list the breakpoints it accepts. */
5281 if (filter && !filter (b))
5284 /* If we have an "args" string, it is a list of breakpoints to
5285 accept. Skip the others. */
5287 if (args != NULL && *args != '\0')
5289 if (allflag) /* maintenance info breakpoint */
5291 if (parse_and_eval_long (args) != b->number)
5294 else /* all others */
5296 if (!number_is_in_list (args, b->number))
5300 /* We only print out user settable breakpoints unless the
5302 if (allflag || user_breakpoint_p (b))
5303 print_one_breakpoint (b, &last_loc, allflag);
5306 do_cleanups (bkpttbl_chain);
5308 if (nr_printable_breakpoints == 0)
5310 /* If there's a filter, let the caller decide how to report
5314 if (args == NULL || *args == '\0')
5315 ui_out_message (uiout, 0, "No breakpoints or watchpoints.\n");
5317 ui_out_message (uiout, 0,
5318 "No breakpoint or watchpoint matching '%s'.\n",
5324 if (last_loc && !server_command)
5325 set_next_address (last_loc->gdbarch, last_loc->address);
5328 /* FIXME? Should this be moved up so that it is only called when
5329 there have been breakpoints? */
5330 annotate_breakpoints_table_end ();
5332 return nr_printable_breakpoints;
5335 /* Display the value of default-collect in a way that is generally
5336 compatible with the breakpoint list. */
5339 default_collect_info (void)
5341 /* If it has no value (which is frequently the case), say nothing; a
5342 message like "No default-collect." gets in user's face when it's
5344 if (!*default_collect)
5347 /* The following phrase lines up nicely with per-tracepoint collect
5349 ui_out_text (uiout, "default collect ");
5350 ui_out_field_string (uiout, "default-collect", default_collect);
5351 ui_out_text (uiout, " \n");
5355 breakpoints_info (char *args, int from_tty)
5357 breakpoint_1 (args, 0, NULL);
5359 default_collect_info ();
5363 watchpoints_info (char *args, int from_tty)
5365 int num_printed = breakpoint_1 (args, 0, is_watchpoint);
5367 if (num_printed == 0)
5369 if (args == NULL || *args == '\0')
5370 ui_out_message (uiout, 0, "No watchpoints.\n");
5372 ui_out_message (uiout, 0, "No watchpoint matching '%s'.\n", args);
5377 maintenance_info_breakpoints (char *args, int from_tty)
5379 breakpoint_1 (args, 1, NULL);
5381 default_collect_info ();
5385 breakpoint_has_pc (struct breakpoint *b,
5386 struct program_space *pspace,
5387 CORE_ADDR pc, struct obj_section *section)
5389 struct bp_location *bl = b->loc;
5391 for (; bl; bl = bl->next)
5393 if (bl->pspace == pspace
5394 && bl->address == pc
5395 && (!overlay_debugging || bl->section == section))
5401 /* Print a message describing any breakpoints set at PC. This
5402 concerns with logical breakpoints, so we match program spaces, not
5406 describe_other_breakpoints (struct gdbarch *gdbarch,
5407 struct program_space *pspace, CORE_ADDR pc,
5408 struct obj_section *section, int thread)
5411 struct breakpoint *b;
5414 others += breakpoint_has_pc (b, pspace, pc, section);
5418 printf_filtered (_("Note: breakpoint "));
5419 else /* if (others == ???) */
5420 printf_filtered (_("Note: breakpoints "));
5422 if (breakpoint_has_pc (b, pspace, pc, section))
5425 printf_filtered ("%d", b->number);
5426 if (b->thread == -1 && thread != -1)
5427 printf_filtered (" (all threads)");
5428 else if (b->thread != -1)
5429 printf_filtered (" (thread %d)", b->thread);
5430 printf_filtered ("%s%s ",
5431 ((b->enable_state == bp_disabled
5432 || b->enable_state == bp_call_disabled
5433 || b->enable_state == bp_startup_disabled)
5435 : b->enable_state == bp_permanent
5439 : ((others == 1) ? " and" : ""));
5441 printf_filtered (_("also set at pc "));
5442 fputs_filtered (paddress (gdbarch, pc), gdb_stdout);
5443 printf_filtered (".\n");
5447 /* Set the default place to put a breakpoint
5448 for the `break' command with no arguments. */
5451 set_default_breakpoint (int valid, struct program_space *pspace,
5452 CORE_ADDR addr, struct symtab *symtab,
5455 default_breakpoint_valid = valid;
5456 default_breakpoint_pspace = pspace;
5457 default_breakpoint_address = addr;
5458 default_breakpoint_symtab = symtab;
5459 default_breakpoint_line = line;
5462 /* Return true iff it is meaningful to use the address member of
5463 BPT. For some breakpoint types, the address member is irrelevant
5464 and it makes no sense to attempt to compare it to other addresses
5465 (or use it for any other purpose either).
5467 More specifically, each of the following breakpoint types will
5468 always have a zero valued address and we don't want to mark
5469 breakpoints of any of these types to be a duplicate of an actual
5470 breakpoint at address zero:
5478 breakpoint_address_is_meaningful (struct breakpoint *bpt)
5480 enum bptype type = bpt->type;
5482 return (type != bp_watchpoint && type != bp_catchpoint);
5485 /* Assuming LOC1 and LOC2's owners are hardware watchpoints, returns
5486 true if LOC1 and LOC2 represent the same watchpoint location. */
5489 watchpoint_locations_match (struct bp_location *loc1,
5490 struct bp_location *loc2)
5492 /* Both of them must not be in moribund_locations. */
5493 gdb_assert (loc1->owner != NULL);
5494 gdb_assert (loc2->owner != NULL);
5496 /* If the target can evaluate the condition expression in hardware,
5497 then we we need to insert both watchpoints even if they are at
5498 the same place. Otherwise the watchpoint will only trigger when
5499 the condition of whichever watchpoint was inserted evaluates to
5500 true, not giving a chance for GDB to check the condition of the
5501 other watchpoint. */
5502 if ((loc1->owner->cond_exp
5503 && target_can_accel_watchpoint_condition (loc1->address,
5505 loc1->watchpoint_type,
5506 loc1->owner->cond_exp))
5507 || (loc2->owner->cond_exp
5508 && target_can_accel_watchpoint_condition (loc2->address,
5510 loc2->watchpoint_type,
5511 loc2->owner->cond_exp)))
5514 /* Note that this checks the owner's type, not the location's. In
5515 case the target does not support read watchpoints, but does
5516 support access watchpoints, we'll have bp_read_watchpoint
5517 watchpoints with hw_access locations. Those should be considered
5518 duplicates of hw_read locations. The hw_read locations will
5519 become hw_access locations later. */
5520 return (loc1->owner->type == loc2->owner->type
5521 && loc1->pspace->aspace == loc2->pspace->aspace
5522 && loc1->address == loc2->address
5523 && loc1->length == loc2->length);
5526 /* Returns true if {ASPACE1,ADDR1} and {ASPACE2,ADDR2} represent the
5527 same breakpoint location. In most targets, this can only be true
5528 if ASPACE1 matches ASPACE2. On targets that have global
5529 breakpoints, the address space doesn't really matter. */
5532 breakpoint_address_match (struct address_space *aspace1, CORE_ADDR addr1,
5533 struct address_space *aspace2, CORE_ADDR addr2)
5535 return ((gdbarch_has_global_breakpoints (target_gdbarch)
5536 || aspace1 == aspace2)
5540 /* Assuming LOC1 and LOC2's types' have meaningful target addresses
5541 (breakpoint_address_is_meaningful), returns true if LOC1 and LOC2
5542 represent the same location. */
5545 breakpoint_locations_match (struct bp_location *loc1,
5546 struct bp_location *loc2)
5548 int hw_point1, hw_point2;
5550 /* Both of them must not be in moribund_locations. */
5551 gdb_assert (loc1->owner != NULL);
5552 gdb_assert (loc2->owner != NULL);
5554 hw_point1 = is_hardware_watchpoint (loc1->owner);
5555 hw_point2 = is_hardware_watchpoint (loc2->owner);
5557 if (hw_point1 != hw_point2)
5560 return watchpoint_locations_match (loc1, loc2);
5562 return breakpoint_address_match (loc1->pspace->aspace, loc1->address,
5563 loc2->pspace->aspace, loc2->address);
5567 breakpoint_adjustment_warning (CORE_ADDR from_addr, CORE_ADDR to_addr,
5568 int bnum, int have_bnum)
5570 /* The longest string possibly returned by hex_string_custom
5571 is 50 chars. These must be at least that big for safety. */
5575 strcpy (astr1, hex_string_custom ((unsigned long) from_addr, 8));
5576 strcpy (astr2, hex_string_custom ((unsigned long) to_addr, 8));
5578 warning (_("Breakpoint %d address previously adjusted from %s to %s."),
5579 bnum, astr1, astr2);
5581 warning (_("Breakpoint address adjusted from %s to %s."), astr1, astr2);
5584 /* Adjust a breakpoint's address to account for architectural
5585 constraints on breakpoint placement. Return the adjusted address.
5586 Note: Very few targets require this kind of adjustment. For most
5587 targets, this function is simply the identity function. */
5590 adjust_breakpoint_address (struct gdbarch *gdbarch,
5591 CORE_ADDR bpaddr, enum bptype bptype)
5593 if (!gdbarch_adjust_breakpoint_address_p (gdbarch))
5595 /* Very few targets need any kind of breakpoint adjustment. */
5598 else if (bptype == bp_watchpoint
5599 || bptype == bp_hardware_watchpoint
5600 || bptype == bp_read_watchpoint
5601 || bptype == bp_access_watchpoint
5602 || bptype == bp_catchpoint)
5604 /* Watchpoints and the various bp_catch_* eventpoints should not
5605 have their addresses modified. */
5610 CORE_ADDR adjusted_bpaddr;
5612 /* Some targets have architectural constraints on the placement
5613 of breakpoint instructions. Obtain the adjusted address. */
5614 adjusted_bpaddr = gdbarch_adjust_breakpoint_address (gdbarch, bpaddr);
5616 /* An adjusted breakpoint address can significantly alter
5617 a user's expectations. Print a warning if an adjustment
5619 if (adjusted_bpaddr != bpaddr)
5620 breakpoint_adjustment_warning (bpaddr, adjusted_bpaddr, 0, 0);
5622 return adjusted_bpaddr;
5626 /* Allocate a struct bp_location. */
5628 static struct bp_location *
5629 allocate_bp_location (struct breakpoint *bpt)
5631 struct bp_location *loc;
5633 loc = xmalloc (sizeof (struct bp_location));
5634 memset (loc, 0, sizeof (*loc));
5638 loc->shlib_disabled = 0;
5647 case bp_longjmp_resume:
5649 case bp_exception_resume:
5650 case bp_step_resume:
5651 case bp_watchpoint_scope:
5653 case bp_std_terminate:
5654 case bp_shlib_event:
5655 case bp_thread_event:
5656 case bp_overlay_event:
5658 case bp_longjmp_master:
5659 case bp_std_terminate_master:
5660 case bp_exception_master:
5661 case bp_gnu_ifunc_resolver:
5662 case bp_gnu_ifunc_resolver_return:
5663 loc->loc_type = bp_loc_software_breakpoint;
5665 case bp_hardware_breakpoint:
5666 loc->loc_type = bp_loc_hardware_breakpoint;
5668 case bp_hardware_watchpoint:
5669 case bp_read_watchpoint:
5670 case bp_access_watchpoint:
5671 loc->loc_type = bp_loc_hardware_watchpoint;
5676 case bp_fast_tracepoint:
5677 case bp_static_tracepoint:
5678 loc->loc_type = bp_loc_other;
5681 internal_error (__FILE__, __LINE__, _("unknown breakpoint type"));
5689 free_bp_location (struct bp_location *loc)
5694 if (loc->function_name)
5695 xfree (loc->function_name);
5700 /* Increment reference count. */
5703 incref_bp_location (struct bp_location *bl)
5708 /* Decrement reference count. If the reference count reaches 0,
5709 destroy the bp_location. Sets *BLP to NULL. */
5712 decref_bp_location (struct bp_location **blp)
5714 gdb_assert ((*blp)->refc > 0);
5716 if (--(*blp)->refc == 0)
5717 free_bp_location (*blp);
5721 /* Helper to set_raw_breakpoint below. Creates a breakpoint that has
5722 type BPTYPE and has no locations as yet. */
5723 /* This function is used in gdbtk sources and thus can not be made
5726 static struct breakpoint *
5727 set_raw_breakpoint_without_location (struct gdbarch *gdbarch,
5730 struct breakpoint *b, *b1;
5732 b = (struct breakpoint *) xmalloc (sizeof (struct breakpoint));
5733 memset (b, 0, sizeof (*b));
5736 b->gdbarch = gdbarch;
5737 b->language = current_language->la_language;
5738 b->input_radix = input_radix;
5740 b->enable_state = bp_enabled;
5743 b->ignore_count = 0;
5745 b->frame_id = null_frame_id;
5746 b->forked_inferior_pid = null_ptid;
5747 b->exec_pathname = NULL;
5748 b->syscalls_to_be_caught = NULL;
5750 b->condition_not_parsed = 0;
5751 b->py_bp_object = NULL;
5752 b->related_breakpoint = b;
5754 /* Add this breakpoint to the end of the chain so that a list of
5755 breakpoints will come out in order of increasing numbers. */
5757 b1 = breakpoint_chain;
5759 breakpoint_chain = b;
5769 /* Initialize loc->function_name. EXPLICIT_LOC says no indirect function
5770 resolutions should be made as the user specified the location explicitly
5774 set_breakpoint_location_function (struct bp_location *loc, int explicit_loc)
5776 gdb_assert (loc->owner != NULL);
5778 if (loc->owner->type == bp_breakpoint
5779 || loc->owner->type == bp_hardware_breakpoint
5780 || is_tracepoint (loc->owner))
5784 find_pc_partial_function_gnu_ifunc (loc->address, &loc->function_name,
5785 NULL, NULL, &is_gnu_ifunc);
5787 if (is_gnu_ifunc && !explicit_loc)
5789 struct breakpoint *b = loc->owner;
5791 gdb_assert (loc->pspace == current_program_space);
5792 if (gnu_ifunc_resolve_name (loc->function_name,
5793 &loc->requested_address))
5795 /* Recalculate ADDRESS based on new REQUESTED_ADDRESS. */
5796 loc->address = adjust_breakpoint_address (loc->gdbarch,
5797 loc->requested_address,
5800 else if (b->type == bp_breakpoint && b->loc == loc
5801 && loc->next == NULL && b->related_breakpoint == b)
5803 /* Create only the whole new breakpoint of this type but do not
5804 mess more complicated breakpoints with multiple locations. */
5805 b->type = bp_gnu_ifunc_resolver;
5809 if (loc->function_name)
5810 loc->function_name = xstrdup (loc->function_name);
5814 /* Attempt to determine architecture of location identified by SAL. */
5815 static struct gdbarch *
5816 get_sal_arch (struct symtab_and_line sal)
5819 return get_objfile_arch (sal.section->objfile);
5821 return get_objfile_arch (sal.symtab->objfile);
5826 /* set_raw_breakpoint is a low level routine for allocating and
5827 partially initializing a breakpoint of type BPTYPE. The newly
5828 created breakpoint's address, section, source file name, and line
5829 number are provided by SAL. The newly created and partially
5830 initialized breakpoint is added to the breakpoint chain and
5831 is also returned as the value of this function.
5833 It is expected that the caller will complete the initialization of
5834 the newly created breakpoint struct as well as output any status
5835 information regarding the creation of a new breakpoint. In
5836 particular, set_raw_breakpoint does NOT set the breakpoint
5837 number! Care should be taken to not allow an error to occur
5838 prior to completing the initialization of the breakpoint. If this
5839 should happen, a bogus breakpoint will be left on the chain. */
5842 set_raw_breakpoint (struct gdbarch *gdbarch,
5843 struct symtab_and_line sal, enum bptype bptype)
5845 struct breakpoint *b = set_raw_breakpoint_without_location (gdbarch,
5847 CORE_ADDR adjusted_address;
5848 struct gdbarch *loc_gdbarch;
5850 loc_gdbarch = get_sal_arch (sal);
5852 loc_gdbarch = b->gdbarch;
5854 if (bptype != bp_catchpoint)
5855 gdb_assert (sal.pspace != NULL);
5857 /* Adjust the breakpoint's address prior to allocating a location.
5858 Once we call allocate_bp_location(), that mostly uninitialized
5859 location will be placed on the location chain. Adjustment of the
5860 breakpoint may cause target_read_memory() to be called and we do
5861 not want its scan of the location chain to find a breakpoint and
5862 location that's only been partially initialized. */
5863 adjusted_address = adjust_breakpoint_address (loc_gdbarch,
5866 b->loc = allocate_bp_location (b);
5867 b->loc->gdbarch = loc_gdbarch;
5868 b->loc->requested_address = sal.pc;
5869 b->loc->address = adjusted_address;
5870 b->loc->pspace = sal.pspace;
5872 /* Store the program space that was used to set the breakpoint, for
5873 breakpoint resetting. */
5874 b->pspace = sal.pspace;
5876 if (sal.symtab == NULL)
5877 b->source_file = NULL;
5879 b->source_file = xstrdup (sal.symtab->filename);
5880 b->loc->section = sal.section;
5881 b->line_number = sal.line;
5883 set_breakpoint_location_function (b->loc,
5884 sal.explicit_pc || sal.explicit_line);
5886 breakpoints_changed ();
5892 /* Note that the breakpoint object B describes a permanent breakpoint
5893 instruction, hard-wired into the inferior's code. */
5895 make_breakpoint_permanent (struct breakpoint *b)
5897 struct bp_location *bl;
5899 b->enable_state = bp_permanent;
5901 /* By definition, permanent breakpoints are already present in the
5902 code. Mark all locations as inserted. For now,
5903 make_breakpoint_permanent is called in just one place, so it's
5904 hard to say if it's reasonable to have permanent breakpoint with
5905 multiple locations or not, but it's easy to implmement. */
5906 for (bl = b->loc; bl; bl = bl->next)
5910 /* Call this routine when stepping and nexting to enable a breakpoint
5911 if we do a longjmp() or 'throw' in TP. FRAME is the frame which
5912 initiated the operation. */
5915 set_longjmp_breakpoint (struct thread_info *tp, struct frame_id frame)
5917 struct breakpoint *b, *b_tmp;
5918 int thread = tp->num;
5920 /* To avoid having to rescan all objfile symbols at every step,
5921 we maintain a list of continually-inserted but always disabled
5922 longjmp "master" breakpoints. Here, we simply create momentary
5923 clones of those and enable them for the requested thread. */
5924 ALL_BREAKPOINTS_SAFE (b, b_tmp)
5925 if (b->pspace == current_program_space
5926 && (b->type == bp_longjmp_master
5927 || b->type == bp_exception_master))
5929 struct breakpoint *clone = clone_momentary_breakpoint (b);
5931 clone->type = b->type == bp_longjmp_master ? bp_longjmp : bp_exception;
5932 clone->thread = thread;
5935 tp->initiating_frame = frame;
5938 /* Delete all longjmp breakpoints from THREAD. */
5940 delete_longjmp_breakpoint (int thread)
5942 struct breakpoint *b, *b_tmp;
5944 ALL_BREAKPOINTS_SAFE (b, b_tmp)
5945 if (b->type == bp_longjmp || b->type == bp_exception)
5947 if (b->thread == thread)
5948 delete_breakpoint (b);
5953 enable_overlay_breakpoints (void)
5955 struct breakpoint *b;
5958 if (b->type == bp_overlay_event)
5960 b->enable_state = bp_enabled;
5961 update_global_location_list (1);
5962 overlay_events_enabled = 1;
5967 disable_overlay_breakpoints (void)
5969 struct breakpoint *b;
5972 if (b->type == bp_overlay_event)
5974 b->enable_state = bp_disabled;
5975 update_global_location_list (0);
5976 overlay_events_enabled = 0;
5980 /* Set an active std::terminate breakpoint for each std::terminate
5981 master breakpoint. */
5983 set_std_terminate_breakpoint (void)
5985 struct breakpoint *b, *b_tmp;
5987 ALL_BREAKPOINTS_SAFE (b, b_tmp)
5988 if (b->pspace == current_program_space
5989 && b->type == bp_std_terminate_master)
5991 struct breakpoint *clone = clone_momentary_breakpoint (b);
5992 clone->type = bp_std_terminate;
5996 /* Delete all the std::terminate breakpoints. */
5998 delete_std_terminate_breakpoint (void)
6000 struct breakpoint *b, *b_tmp;
6002 ALL_BREAKPOINTS_SAFE (b, b_tmp)
6003 if (b->type == bp_std_terminate)
6004 delete_breakpoint (b);
6008 create_thread_event_breakpoint (struct gdbarch *gdbarch, CORE_ADDR address)
6010 struct breakpoint *b;
6012 b = create_internal_breakpoint (gdbarch, address, bp_thread_event);
6014 b->enable_state = bp_enabled;
6015 /* addr_string has to be used or breakpoint_re_set will delete me. */
6017 = xstrprintf ("*%s", paddress (b->loc->gdbarch, b->loc->address));
6019 update_global_location_list_nothrow (1);
6025 remove_thread_event_breakpoints (void)
6027 struct breakpoint *b, *b_tmp;
6029 ALL_BREAKPOINTS_SAFE (b, b_tmp)
6030 if (b->type == bp_thread_event
6031 && b->loc->pspace == current_program_space)
6032 delete_breakpoint (b);
6035 struct captured_parse_breakpoint_args
6038 struct symtabs_and_lines *sals_p;
6039 struct linespec_result *canonical_p;
6043 struct lang_and_radix
6049 /* Create a breakpoint for JIT code registration and unregistration. */
6052 create_jit_event_breakpoint (struct gdbarch *gdbarch, CORE_ADDR address)
6054 struct breakpoint *b;
6056 b = create_internal_breakpoint (gdbarch, address, bp_jit_event);
6057 update_global_location_list_nothrow (1);
6061 /* Remove JIT code registration and unregistration breakpoint(s). */
6064 remove_jit_event_breakpoints (void)
6066 struct breakpoint *b, *b_tmp;
6068 ALL_BREAKPOINTS_SAFE (b, b_tmp)
6069 if (b->type == bp_jit_event
6070 && b->loc->pspace == current_program_space)
6071 delete_breakpoint (b);
6075 remove_solib_event_breakpoints (void)
6077 struct breakpoint *b, *b_tmp;
6079 ALL_BREAKPOINTS_SAFE (b, b_tmp)
6080 if (b->type == bp_shlib_event
6081 && b->loc->pspace == current_program_space)
6082 delete_breakpoint (b);
6086 create_solib_event_breakpoint (struct gdbarch *gdbarch, CORE_ADDR address)
6088 struct breakpoint *b;
6090 b = create_internal_breakpoint (gdbarch, address, bp_shlib_event);
6091 update_global_location_list_nothrow (1);
6095 /* Disable any breakpoints that are on code in shared libraries. Only
6096 apply to enabled breakpoints, disabled ones can just stay disabled. */
6099 disable_breakpoints_in_shlibs (void)
6101 struct bp_location *loc, **locp_tmp;
6103 ALL_BP_LOCATIONS (loc, locp_tmp)
6105 /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always non-NULL. */
6106 struct breakpoint *b = loc->owner;
6108 /* We apply the check to all breakpoints, including disabled for
6109 those with loc->duplicate set. This is so that when breakpoint
6110 becomes enabled, or the duplicate is removed, gdb will try to
6111 insert all breakpoints. If we don't set shlib_disabled here,
6112 we'll try to insert those breakpoints and fail. */
6113 if (((b->type == bp_breakpoint)
6114 || (b->type == bp_jit_event)
6115 || (b->type == bp_hardware_breakpoint)
6116 || (is_tracepoint (b)))
6117 && loc->pspace == current_program_space
6118 && !loc->shlib_disabled
6120 && PC_SOLIB (loc->address)
6122 && solib_name_from_address (loc->pspace, loc->address)
6126 loc->shlib_disabled = 1;
6131 /* Disable any breakpoints that are in in an unloaded shared library.
6132 Only apply to enabled breakpoints, disabled ones can just stay
6136 disable_breakpoints_in_unloaded_shlib (struct so_list *solib)
6138 struct bp_location *loc, **locp_tmp;
6139 int disabled_shlib_breaks = 0;
6141 /* SunOS a.out shared libraries are always mapped, so do not
6142 disable breakpoints; they will only be reported as unloaded
6143 through clear_solib when GDB discards its shared library
6144 list. See clear_solib for more information. */
6145 if (exec_bfd != NULL
6146 && bfd_get_flavour (exec_bfd) == bfd_target_aout_flavour)
6149 ALL_BP_LOCATIONS (loc, locp_tmp)
6151 /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always non-NULL. */
6152 struct breakpoint *b = loc->owner;
6154 if ((loc->loc_type == bp_loc_hardware_breakpoint
6155 || loc->loc_type == bp_loc_software_breakpoint)
6156 && solib->pspace == loc->pspace
6157 && !loc->shlib_disabled
6158 && (b->type == bp_breakpoint
6159 || b->type == bp_jit_event
6160 || b->type == bp_hardware_breakpoint)
6161 && solib_contains_address_p (solib, loc->address))
6163 loc->shlib_disabled = 1;
6164 /* At this point, we cannot rely on remove_breakpoint
6165 succeeding so we must mark the breakpoint as not inserted
6166 to prevent future errors occurring in remove_breakpoints. */
6168 if (!disabled_shlib_breaks)
6170 target_terminal_ours_for_output ();
6171 warning (_("Temporarily disabling breakpoints "
6172 "for unloaded shared library \"%s\""),
6175 disabled_shlib_breaks = 1;
6180 /* FORK & VFORK catchpoints. */
6182 /* Implement the "insert" breakpoint_ops method for fork
6186 insert_catch_fork (struct bp_location *bl)
6188 return target_insert_fork_catchpoint (PIDGET (inferior_ptid));
6191 /* Implement the "remove" breakpoint_ops method for fork
6195 remove_catch_fork (struct bp_location *bl)
6197 return target_remove_fork_catchpoint (PIDGET (inferior_ptid));
6200 /* Implement the "breakpoint_hit" breakpoint_ops method for fork
6204 breakpoint_hit_catch_fork (struct breakpoint *b)
6206 return inferior_has_forked (inferior_ptid, &b->forked_inferior_pid);
6209 /* Implement the "print_it" breakpoint_ops method for fork
6212 static enum print_stop_action
6213 print_it_catch_fork (struct breakpoint *b)
6215 annotate_catchpoint (b->number);
6216 printf_filtered (_("\nCatchpoint %d (forked process %d), "),
6217 b->number, ptid_get_pid (b->forked_inferior_pid));
6218 return PRINT_SRC_AND_LOC;
6221 /* Implement the "print_one" breakpoint_ops method for fork
6225 print_one_catch_fork (struct breakpoint *b, struct bp_location **last_loc)
6227 struct value_print_options opts;
6229 get_user_print_options (&opts);
6231 /* Field 4, the address, is omitted (which makes the columns not
6232 line up too nicely with the headers, but the effect is relatively
6234 if (opts.addressprint)
6235 ui_out_field_skip (uiout, "addr");
6237 ui_out_text (uiout, "fork");
6238 if (!ptid_equal (b->forked_inferior_pid, null_ptid))
6240 ui_out_text (uiout, ", process ");
6241 ui_out_field_int (uiout, "what",
6242 ptid_get_pid (b->forked_inferior_pid));
6243 ui_out_spaces (uiout, 1);
6247 /* Implement the "print_mention" breakpoint_ops method for fork
6251 print_mention_catch_fork (struct breakpoint *b)
6253 printf_filtered (_("Catchpoint %d (fork)"), b->number);
6256 /* Implement the "print_recreate" breakpoint_ops method for fork
6260 print_recreate_catch_fork (struct breakpoint *b, struct ui_file *fp)
6262 fprintf_unfiltered (fp, "catch fork");
6265 /* The breakpoint_ops structure to be used in fork catchpoints. */
6267 static struct breakpoint_ops catch_fork_breakpoint_ops =
6271 breakpoint_hit_catch_fork,
6272 NULL, /* resources_needed */
6273 print_it_catch_fork,
6274 print_one_catch_fork,
6275 print_mention_catch_fork,
6276 print_recreate_catch_fork
6279 /* Implement the "insert" breakpoint_ops method for vfork
6283 insert_catch_vfork (struct bp_location *bl)
6285 return target_insert_vfork_catchpoint (PIDGET (inferior_ptid));
6288 /* Implement the "remove" breakpoint_ops method for vfork
6292 remove_catch_vfork (struct bp_location *bl)
6294 return target_remove_vfork_catchpoint (PIDGET (inferior_ptid));
6297 /* Implement the "breakpoint_hit" breakpoint_ops method for vfork
6301 breakpoint_hit_catch_vfork (struct breakpoint *b)
6303 return inferior_has_vforked (inferior_ptid, &b->forked_inferior_pid);
6306 /* Implement the "print_it" breakpoint_ops method for vfork
6309 static enum print_stop_action
6310 print_it_catch_vfork (struct breakpoint *b)
6312 annotate_catchpoint (b->number);
6313 printf_filtered (_("\nCatchpoint %d (vforked process %d), "),
6314 b->number, ptid_get_pid (b->forked_inferior_pid));
6315 return PRINT_SRC_AND_LOC;
6318 /* Implement the "print_one" breakpoint_ops method for vfork
6322 print_one_catch_vfork (struct breakpoint *b, struct bp_location **last_loc)
6324 struct value_print_options opts;
6326 get_user_print_options (&opts);
6327 /* Field 4, the address, is omitted (which makes the columns not
6328 line up too nicely with the headers, but the effect is relatively
6330 if (opts.addressprint)
6331 ui_out_field_skip (uiout, "addr");
6333 ui_out_text (uiout, "vfork");
6334 if (!ptid_equal (b->forked_inferior_pid, null_ptid))
6336 ui_out_text (uiout, ", process ");
6337 ui_out_field_int (uiout, "what",
6338 ptid_get_pid (b->forked_inferior_pid));
6339 ui_out_spaces (uiout, 1);
6343 /* Implement the "print_mention" breakpoint_ops method for vfork
6347 print_mention_catch_vfork (struct breakpoint *b)
6349 printf_filtered (_("Catchpoint %d (vfork)"), b->number);
6352 /* Implement the "print_recreate" breakpoint_ops method for vfork
6356 print_recreate_catch_vfork (struct breakpoint *b, struct ui_file *fp)
6358 fprintf_unfiltered (fp, "catch vfork");
6361 /* The breakpoint_ops structure to be used in vfork catchpoints. */
6363 static struct breakpoint_ops catch_vfork_breakpoint_ops =
6367 breakpoint_hit_catch_vfork,
6368 NULL, /* resources_needed */
6369 print_it_catch_vfork,
6370 print_one_catch_vfork,
6371 print_mention_catch_vfork,
6372 print_recreate_catch_vfork
6375 /* Implement the "insert" breakpoint_ops method for syscall
6379 insert_catch_syscall (struct bp_location *bl)
6381 struct inferior *inf = current_inferior ();
6383 ++inf->total_syscalls_count;
6384 if (!bl->owner->syscalls_to_be_caught)
6385 ++inf->any_syscall_count;
6391 VEC_iterate (int, bl->owner->syscalls_to_be_caught, i, iter);
6396 if (iter >= VEC_length (int, inf->syscalls_counts))
6398 int old_size = VEC_length (int, inf->syscalls_counts);
6399 uintptr_t vec_addr_offset
6400 = old_size * ((uintptr_t) sizeof (int));
6402 VEC_safe_grow (int, inf->syscalls_counts, iter + 1);
6403 vec_addr = (uintptr_t) VEC_address (int, inf->syscalls_counts) +
6405 memset ((void *) vec_addr, 0,
6406 (iter + 1 - old_size) * sizeof (int));
6408 elem = VEC_index (int, inf->syscalls_counts, iter);
6409 VEC_replace (int, inf->syscalls_counts, iter, ++elem);
6413 return target_set_syscall_catchpoint (PIDGET (inferior_ptid),
6414 inf->total_syscalls_count != 0,
6415 inf->any_syscall_count,
6416 VEC_length (int, inf->syscalls_counts),
6417 VEC_address (int, inf->syscalls_counts));
6420 /* Implement the "remove" breakpoint_ops method for syscall
6424 remove_catch_syscall (struct bp_location *bl)
6426 struct inferior *inf = current_inferior ();
6428 --inf->total_syscalls_count;
6429 if (!bl->owner->syscalls_to_be_caught)
6430 --inf->any_syscall_count;
6436 VEC_iterate (int, bl->owner->syscalls_to_be_caught, i, iter);
6440 if (iter >= VEC_length (int, inf->syscalls_counts))
6441 /* Shouldn't happen. */
6443 elem = VEC_index (int, inf->syscalls_counts, iter);
6444 VEC_replace (int, inf->syscalls_counts, iter, --elem);
6448 return target_set_syscall_catchpoint (PIDGET (inferior_ptid),
6449 inf->total_syscalls_count != 0,
6450 inf->any_syscall_count,
6451 VEC_length (int, inf->syscalls_counts),
6453 inf->syscalls_counts));
6456 /* Implement the "breakpoint_hit" breakpoint_ops method for syscall
6460 breakpoint_hit_catch_syscall (struct breakpoint *b)
6462 /* We must check if we are catching specific syscalls in this
6463 breakpoint. If we are, then we must guarantee that the called
6464 syscall is the same syscall we are catching. */
6465 int syscall_number = 0;
6467 if (!inferior_has_called_syscall (inferior_ptid, &syscall_number))
6470 /* Now, checking if the syscall is the same. */
6471 if (b->syscalls_to_be_caught)
6476 VEC_iterate (int, b->syscalls_to_be_caught, i, iter);
6478 if (syscall_number == iter)
6488 /* Implement the "print_it" breakpoint_ops method for syscall
6491 static enum print_stop_action
6492 print_it_catch_syscall (struct breakpoint *b)
6494 /* These are needed because we want to know in which state a
6495 syscall is. It can be in the TARGET_WAITKIND_SYSCALL_ENTRY
6496 or TARGET_WAITKIND_SYSCALL_RETURN, and depending on it we
6497 must print "called syscall" or "returned from syscall". */
6499 struct target_waitstatus last;
6501 struct cleanup *old_chain;
6504 get_last_target_status (&ptid, &last);
6506 get_syscall_by_number (last.value.syscall_number, &s);
6508 annotate_catchpoint (b->number);
6511 syscall_id = xstrprintf ("%d", last.value.syscall_number);
6513 syscall_id = xstrprintf ("'%s'", s.name);
6515 old_chain = make_cleanup (xfree, syscall_id);
6517 if (last.kind == TARGET_WAITKIND_SYSCALL_ENTRY)
6518 printf_filtered (_("\nCatchpoint %d (call to syscall %s), "),
6519 b->number, syscall_id);
6520 else if (last.kind == TARGET_WAITKIND_SYSCALL_RETURN)
6521 printf_filtered (_("\nCatchpoint %d (returned from syscall %s), "),
6522 b->number, syscall_id);
6524 do_cleanups (old_chain);
6526 return PRINT_SRC_AND_LOC;
6529 /* Implement the "print_one" breakpoint_ops method for syscall
6533 print_one_catch_syscall (struct breakpoint *b,
6534 struct bp_location **last_loc)
6536 struct value_print_options opts;
6538 get_user_print_options (&opts);
6539 /* Field 4, the address, is omitted (which makes the columns not
6540 line up too nicely with the headers, but the effect is relatively
6542 if (opts.addressprint)
6543 ui_out_field_skip (uiout, "addr");
6546 if (b->syscalls_to_be_caught
6547 && VEC_length (int, b->syscalls_to_be_caught) > 1)
6548 ui_out_text (uiout, "syscalls \"");
6550 ui_out_text (uiout, "syscall \"");
6552 if (b->syscalls_to_be_caught)
6555 char *text = xstrprintf ("%s", "");
6558 VEC_iterate (int, b->syscalls_to_be_caught, i, iter);
6563 get_syscall_by_number (iter, &s);
6566 text = xstrprintf ("%s%s, ", text, s.name);
6568 text = xstrprintf ("%s%d, ", text, iter);
6570 /* We have to xfree the last 'text' (now stored at 'x')
6571 because xstrprintf dinamically allocates new space for it
6575 /* Remove the last comma. */
6576 text[strlen (text) - 2] = '\0';
6577 ui_out_field_string (uiout, "what", text);
6580 ui_out_field_string (uiout, "what", "<any syscall>");
6581 ui_out_text (uiout, "\" ");
6584 /* Implement the "print_mention" breakpoint_ops method for syscall
6588 print_mention_catch_syscall (struct breakpoint *b)
6590 if (b->syscalls_to_be_caught)
6594 if (VEC_length (int, b->syscalls_to_be_caught) > 1)
6595 printf_filtered (_("Catchpoint %d (syscalls"), b->number);
6597 printf_filtered (_("Catchpoint %d (syscall"), b->number);
6600 VEC_iterate (int, b->syscalls_to_be_caught, i, iter);
6604 get_syscall_by_number (iter, &s);
6607 printf_filtered (" '%s' [%d]", s.name, s.number);
6609 printf_filtered (" %d", s.number);
6611 printf_filtered (")");
6614 printf_filtered (_("Catchpoint %d (any syscall)"),
6618 /* Implement the "print_recreate" breakpoint_ops method for syscall
6622 print_recreate_catch_syscall (struct breakpoint *b, struct ui_file *fp)
6624 fprintf_unfiltered (fp, "catch syscall");
6626 if (b->syscalls_to_be_caught)
6631 VEC_iterate (int, b->syscalls_to_be_caught, i, iter);
6636 get_syscall_by_number (iter, &s);
6638 fprintf_unfiltered (fp, " %s", s.name);
6640 fprintf_unfiltered (fp, " %d", s.number);
6645 /* The breakpoint_ops structure to be used in syscall catchpoints. */
6647 static struct breakpoint_ops catch_syscall_breakpoint_ops =
6649 insert_catch_syscall,
6650 remove_catch_syscall,
6651 breakpoint_hit_catch_syscall,
6652 NULL, /* resources_needed */
6653 print_it_catch_syscall,
6654 print_one_catch_syscall,
6655 print_mention_catch_syscall,
6656 print_recreate_catch_syscall
6659 /* Returns non-zero if 'b' is a syscall catchpoint. */
6662 syscall_catchpoint_p (struct breakpoint *b)
6664 return (b->ops == &catch_syscall_breakpoint_ops);
6667 /* Create a new breakpoint of the bp_catchpoint kind and return it,
6668 but does NOT mention it nor update the global location list.
6669 This is useful if you need to fill more fields in the
6670 struct breakpoint before calling mention.
6672 If TEMPFLAG is non-zero, then make the breakpoint temporary.
6673 If COND_STRING is not NULL, then store it in the breakpoint.
6674 OPS, if not NULL, is the breakpoint_ops structure associated
6675 to the catchpoint. */
6677 static struct breakpoint *
6678 create_catchpoint_without_mention (struct gdbarch *gdbarch, int tempflag,
6680 struct breakpoint_ops *ops)
6682 struct symtab_and_line sal;
6683 struct breakpoint *b;
6686 sal.pspace = current_program_space;
6688 b = set_raw_breakpoint (gdbarch, sal, bp_catchpoint);
6689 set_breakpoint_count (breakpoint_count + 1);
6690 b->number = breakpoint_count;
6692 b->cond_string = (cond_string == NULL) ? NULL : xstrdup (cond_string);
6694 b->addr_string = NULL;
6695 b->enable_state = bp_enabled;
6696 b->disposition = tempflag ? disp_del : disp_donttouch;
6702 /* Create a new breakpoint of the bp_catchpoint kind and return it.
6704 If TEMPFLAG is non-zero, then make the breakpoint temporary.
6705 If COND_STRING is not NULL, then store it in the breakpoint.
6706 OPS, if not NULL, is the breakpoint_ops structure associated
6707 to the catchpoint. */
6709 static struct breakpoint *
6710 create_catchpoint (struct gdbarch *gdbarch, int tempflag,
6711 char *cond_string, struct breakpoint_ops *ops)
6713 struct breakpoint *b =
6714 create_catchpoint_without_mention (gdbarch, tempflag, cond_string, ops);
6717 update_global_location_list (1);
6723 create_fork_vfork_event_catchpoint (struct gdbarch *gdbarch,
6724 int tempflag, char *cond_string,
6725 struct breakpoint_ops *ops)
6727 struct breakpoint *b
6728 = create_catchpoint (gdbarch, tempflag, cond_string, ops);
6730 /* FIXME: We should put this information in a breakpoint private data
6732 b->forked_inferior_pid = null_ptid;
6735 /* Exec catchpoints. */
6738 insert_catch_exec (struct bp_location *bl)
6740 return target_insert_exec_catchpoint (PIDGET (inferior_ptid));
6744 remove_catch_exec (struct bp_location *bl)
6746 return target_remove_exec_catchpoint (PIDGET (inferior_ptid));
6750 breakpoint_hit_catch_exec (struct breakpoint *b)
6752 return inferior_has_execd (inferior_ptid, &b->exec_pathname);
6755 static enum print_stop_action
6756 print_it_catch_exec (struct breakpoint *b)
6758 annotate_catchpoint (b->number);
6759 printf_filtered (_("\nCatchpoint %d (exec'd %s), "), b->number,
6761 return PRINT_SRC_AND_LOC;
6765 print_one_catch_exec (struct breakpoint *b, struct bp_location **last_loc)
6767 struct value_print_options opts;
6769 get_user_print_options (&opts);
6771 /* Field 4, the address, is omitted (which makes the columns
6772 not line up too nicely with the headers, but the effect
6773 is relatively readable). */
6774 if (opts.addressprint)
6775 ui_out_field_skip (uiout, "addr");
6777 ui_out_text (uiout, "exec");
6778 if (b->exec_pathname != NULL)
6780 ui_out_text (uiout, ", program \"");
6781 ui_out_field_string (uiout, "what", b->exec_pathname);
6782 ui_out_text (uiout, "\" ");
6787 print_mention_catch_exec (struct breakpoint *b)
6789 printf_filtered (_("Catchpoint %d (exec)"), b->number);
6792 /* Implement the "print_recreate" breakpoint_ops method for exec
6796 print_recreate_catch_exec (struct breakpoint *b, struct ui_file *fp)
6798 fprintf_unfiltered (fp, "catch exec");
6801 static struct breakpoint_ops catch_exec_breakpoint_ops =
6805 breakpoint_hit_catch_exec,
6806 NULL, /* resources_needed */
6807 print_it_catch_exec,
6808 print_one_catch_exec,
6809 print_mention_catch_exec,
6810 print_recreate_catch_exec
6814 create_syscall_event_catchpoint (int tempflag, VEC(int) *filter,
6815 struct breakpoint_ops *ops)
6817 struct gdbarch *gdbarch = get_current_arch ();
6818 struct breakpoint *b =
6819 create_catchpoint_without_mention (gdbarch, tempflag, NULL, ops);
6821 b->syscalls_to_be_caught = filter;
6823 /* Now, we have to mention the breakpoint and update the global
6826 update_global_location_list (1);
6830 hw_breakpoint_used_count (void)
6832 struct breakpoint *b;
6837 if (b->type == bp_hardware_breakpoint && breakpoint_enabled (b))
6845 hw_watchpoint_used_count (enum bptype type, int *other_type_used)
6848 struct breakpoint *b;
6849 struct bp_location *bl;
6851 *other_type_used = 0;
6854 if (!breakpoint_enabled (b))
6857 if (b->type == type)
6858 for (bl = b->loc; bl; bl = bl->next)
6860 /* Special types of hardware watchpoints may use more than
6862 if (b->ops && b->ops->resources_needed)
6863 i += b->ops->resources_needed (bl);
6867 else if (is_hardware_watchpoint (b))
6868 *other_type_used = 1;
6875 disable_watchpoints_before_interactive_call_start (void)
6877 struct breakpoint *b;
6881 if (is_watchpoint (b) && breakpoint_enabled (b))
6883 b->enable_state = bp_call_disabled;
6884 update_global_location_list (0);
6890 enable_watchpoints_after_interactive_call_stop (void)
6892 struct breakpoint *b;
6896 if (is_watchpoint (b) && b->enable_state == bp_call_disabled)
6898 b->enable_state = bp_enabled;
6899 update_global_location_list (1);
6905 disable_breakpoints_before_startup (void)
6907 struct breakpoint *b;
6912 if (b->pspace != current_program_space)
6915 if ((b->type == bp_breakpoint
6916 || b->type == bp_hardware_breakpoint)
6917 && breakpoint_enabled (b))
6919 b->enable_state = bp_startup_disabled;
6925 update_global_location_list (0);
6927 current_program_space->executing_startup = 1;
6931 enable_breakpoints_after_startup (void)
6933 struct breakpoint *b;
6936 current_program_space->executing_startup = 0;
6940 if (b->pspace != current_program_space)
6943 if ((b->type == bp_breakpoint
6944 || b->type == bp_hardware_breakpoint)
6945 && b->enable_state == bp_startup_disabled)
6947 b->enable_state = bp_enabled;
6953 breakpoint_re_set ();
6957 /* Set a breakpoint that will evaporate an end of command
6958 at address specified by SAL.
6959 Restrict it to frame FRAME if FRAME is nonzero. */
6962 set_momentary_breakpoint (struct gdbarch *gdbarch, struct symtab_and_line sal,
6963 struct frame_id frame_id, enum bptype type)
6965 struct breakpoint *b;
6967 /* If FRAME_ID is valid, it should be a real frame, not an inlined
6969 gdb_assert (!frame_id_inlined_p (frame_id));
6971 b = set_raw_breakpoint (gdbarch, sal, type);
6972 b->enable_state = bp_enabled;
6973 b->disposition = disp_donttouch;
6974 b->frame_id = frame_id;
6976 /* If we're debugging a multi-threaded program, then we want
6977 momentary breakpoints to be active in only a single thread of
6979 if (in_thread_list (inferior_ptid))
6980 b->thread = pid_to_thread_id (inferior_ptid);
6982 update_global_location_list_nothrow (1);
6987 /* Make a deep copy of momentary breakpoint ORIG. Returns NULL if
6991 clone_momentary_breakpoint (struct breakpoint *orig)
6993 struct breakpoint *copy;
6995 /* If there's nothing to clone, then return nothing. */
6999 copy = set_raw_breakpoint_without_location (orig->gdbarch, orig->type);
7000 copy->loc = allocate_bp_location (copy);
7001 set_breakpoint_location_function (copy->loc, 1);
7003 copy->loc->gdbarch = orig->loc->gdbarch;
7004 copy->loc->requested_address = orig->loc->requested_address;
7005 copy->loc->address = orig->loc->address;
7006 copy->loc->section = orig->loc->section;
7007 copy->loc->pspace = orig->loc->pspace;
7009 if (orig->source_file == NULL)
7010 copy->source_file = NULL;
7012 copy->source_file = xstrdup (orig->source_file);
7014 copy->line_number = orig->line_number;
7015 copy->frame_id = orig->frame_id;
7016 copy->thread = orig->thread;
7017 copy->pspace = orig->pspace;
7019 copy->enable_state = bp_enabled;
7020 copy->disposition = disp_donttouch;
7021 copy->number = internal_breakpoint_number--;
7023 update_global_location_list_nothrow (0);
7028 set_momentary_breakpoint_at_pc (struct gdbarch *gdbarch, CORE_ADDR pc,
7031 struct symtab_and_line sal;
7033 sal = find_pc_line (pc, 0);
7035 sal.section = find_pc_overlay (pc);
7036 sal.explicit_pc = 1;
7038 return set_momentary_breakpoint (gdbarch, sal, null_frame_id, type);
7042 /* Tell the user we have just set a breakpoint B. */
7045 mention (struct breakpoint *b)
7048 struct cleanup *ui_out_chain;
7049 struct value_print_options opts;
7051 get_user_print_options (&opts);
7053 /* FIXME: This is misplaced; mention() is called by things (like
7054 hitting a watchpoint) other than breakpoint creation. It should
7055 be possible to clean this up and at the same time replace the
7056 random calls to breakpoint_changed with this hook. */
7057 observer_notify_breakpoint_created (b->number);
7059 if (b->ops != NULL && b->ops->print_mention != NULL)
7060 b->ops->print_mention (b);
7065 printf_filtered (_("(apparently deleted?) Eventpoint %d: "),
7069 ui_out_text (uiout, "Watchpoint ");
7070 ui_out_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "wpt");
7071 ui_out_field_int (uiout, "number", b->number);
7072 ui_out_text (uiout, ": ");
7073 ui_out_field_string (uiout, "exp", b->exp_string);
7074 do_cleanups (ui_out_chain);
7076 case bp_hardware_watchpoint:
7077 ui_out_text (uiout, "Hardware watchpoint ");
7078 ui_out_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "wpt");
7079 ui_out_field_int (uiout, "number", b->number);
7080 ui_out_text (uiout, ": ");
7081 ui_out_field_string (uiout, "exp", b->exp_string);
7082 do_cleanups (ui_out_chain);
7084 case bp_read_watchpoint:
7085 ui_out_text (uiout, "Hardware read watchpoint ");
7086 ui_out_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "hw-rwpt");
7087 ui_out_field_int (uiout, "number", b->number);
7088 ui_out_text (uiout, ": ");
7089 ui_out_field_string (uiout, "exp", b->exp_string);
7090 do_cleanups (ui_out_chain);
7092 case bp_access_watchpoint:
7093 ui_out_text (uiout, "Hardware access (read/write) watchpoint ");
7094 ui_out_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "hw-awpt");
7095 ui_out_field_int (uiout, "number", b->number);
7096 ui_out_text (uiout, ": ");
7097 ui_out_field_string (uiout, "exp", b->exp_string);
7098 do_cleanups (ui_out_chain);
7101 case bp_gnu_ifunc_resolver:
7102 if (ui_out_is_mi_like_p (uiout))
7107 if (b->disposition == disp_del)
7108 printf_filtered (_("Temporary breakpoint"));
7110 printf_filtered (_("Breakpoint"));
7111 printf_filtered (_(" %d"), b->number);
7112 if (b->type == bp_gnu_ifunc_resolver)
7113 printf_filtered (_(" at gnu-indirect-function resolver"));
7116 case bp_hardware_breakpoint:
7117 if (ui_out_is_mi_like_p (uiout))
7122 printf_filtered (_("Hardware assisted breakpoint %d"), b->number);
7126 if (ui_out_is_mi_like_p (uiout))
7131 printf_filtered (_("Tracepoint"));
7132 printf_filtered (_(" %d"), b->number);
7135 case bp_fast_tracepoint:
7136 if (ui_out_is_mi_like_p (uiout))
7141 printf_filtered (_("Fast tracepoint"));
7142 printf_filtered (_(" %d"), b->number);
7145 case bp_static_tracepoint:
7146 if (ui_out_is_mi_like_p (uiout))
7151 printf_filtered (_("Static tracepoint"));
7152 printf_filtered (_(" %d"), b->number);
7159 case bp_longjmp_resume:
7161 case bp_exception_resume:
7162 case bp_step_resume:
7164 case bp_std_terminate:
7165 case bp_watchpoint_scope:
7166 case bp_shlib_event:
7167 case bp_thread_event:
7168 case bp_overlay_event:
7170 case bp_longjmp_master:
7171 case bp_std_terminate_master:
7172 case bp_exception_master:
7173 case bp_gnu_ifunc_resolver_return:
7179 /* i18n: cagney/2005-02-11: Below needs to be merged into a
7183 printf_filtered (_(" (%s) pending."), b->addr_string);
7187 if (opts.addressprint || b->source_file == NULL)
7189 printf_filtered (" at ");
7190 fputs_filtered (paddress (b->loc->gdbarch, b->loc->address),
7194 printf_filtered (": file %s, line %d.",
7195 b->source_file, b->line_number);
7199 struct bp_location *loc = b->loc;
7201 for (; loc; loc = loc->next)
7203 printf_filtered (" (%d locations)", n);
7208 if (ui_out_is_mi_like_p (uiout))
7210 printf_filtered ("\n");
7214 static struct bp_location *
7215 add_location_to_breakpoint (struct breakpoint *b,
7216 const struct symtab_and_line *sal)
7218 struct bp_location *loc, **tmp;
7220 loc = allocate_bp_location (b);
7221 for (tmp = &(b->loc); *tmp != NULL; tmp = &((*tmp)->next))
7224 loc->gdbarch = get_sal_arch (*sal);
7226 loc->gdbarch = b->gdbarch;
7227 loc->requested_address = sal->pc;
7228 loc->address = adjust_breakpoint_address (loc->gdbarch,
7229 loc->requested_address, b->type);
7230 loc->pspace = sal->pspace;
7231 gdb_assert (loc->pspace != NULL);
7232 loc->section = sal->section;
7234 set_breakpoint_location_function (loc,
7235 sal->explicit_pc || sal->explicit_line);
7240 /* Return 1 if LOC is pointing to a permanent breakpoint,
7241 return 0 otherwise. */
7244 bp_loc_is_permanent (struct bp_location *loc)
7248 const gdb_byte *brk;
7249 gdb_byte *target_mem;
7250 struct cleanup *cleanup;
7253 gdb_assert (loc != NULL);
7255 addr = loc->address;
7256 brk = gdbarch_breakpoint_from_pc (loc->gdbarch, &addr, &len);
7258 /* Software breakpoints unsupported? */
7262 target_mem = alloca (len);
7264 /* Enable the automatic memory restoration from breakpoints while
7265 we read the memory. Otherwise we could say about our temporary
7266 breakpoints they are permanent. */
7267 cleanup = save_current_space_and_thread ();
7269 switch_to_program_space_and_thread (loc->pspace);
7270 make_show_memory_breakpoints_cleanup (0);
7272 if (target_read_memory (loc->address, target_mem, len) == 0
7273 && memcmp (target_mem, brk, len) == 0)
7276 do_cleanups (cleanup);
7283 /* Create a breakpoint with SAL as location. Use ADDR_STRING
7284 as textual description of the location, and COND_STRING
7285 as condition expression. */
7288 create_breakpoint_sal (struct gdbarch *gdbarch,
7289 struct symtabs_and_lines sals, char *addr_string,
7291 enum bptype type, enum bpdisp disposition,
7292 int thread, int task, int ignore_count,
7293 struct breakpoint_ops *ops, int from_tty,
7294 int enabled, int internal, int display_canonical)
7296 struct breakpoint *b = NULL;
7299 if (type == bp_hardware_breakpoint)
7301 int i = hw_breakpoint_used_count ();
7302 int target_resources_ok =
7303 target_can_use_hardware_watchpoint (bp_hardware_breakpoint,
7305 if (target_resources_ok == 0)
7306 error (_("No hardware breakpoint support in the target."));
7307 else if (target_resources_ok < 0)
7308 error (_("Hardware breakpoints used exceeds limit."));
7311 gdb_assert (sals.nelts > 0);
7313 for (i = 0; i < sals.nelts; ++i)
7315 struct symtab_and_line sal = sals.sals[i];
7316 struct bp_location *loc;
7320 struct gdbarch *loc_gdbarch = get_sal_arch (sal);
7322 loc_gdbarch = gdbarch;
7324 describe_other_breakpoints (loc_gdbarch,
7325 sal.pspace, sal.pc, sal.section, thread);
7330 b = set_raw_breakpoint (gdbarch, sal, type);
7331 set_breakpoint_number (internal, b);
7335 b->cond_string = cond_string;
7336 b->ignore_count = ignore_count;
7337 b->enable_state = enabled ? bp_enabled : bp_disabled;
7338 b->disposition = disposition;
7339 b->pspace = sals.sals[0].pspace;
7341 if (type == bp_static_tracepoint)
7343 struct static_tracepoint_marker marker;
7345 if (is_marker_spec (addr_string))
7347 /* We already know the marker exists, otherwise, we
7348 wouldn't see a sal for it. */
7349 char *p = &addr_string[3];
7354 p = skip_spaces (p);
7356 endp = skip_to_space (p);
7358 marker_str = savestring (p, endp - p);
7359 b->static_trace_marker_id = marker_str;
7361 printf_filtered (_("Probed static tracepoint "
7363 b->static_trace_marker_id);
7365 else if (target_static_tracepoint_marker_at (sal.pc, &marker))
7367 b->static_trace_marker_id = xstrdup (marker.str_id);
7368 release_static_tracepoint_marker (&marker);
7370 printf_filtered (_("Probed static tracepoint "
7372 b->static_trace_marker_id);
7375 warning (_("Couldn't determine the static "
7376 "tracepoint marker to probe"));
7379 if (enabled && b->pspace->executing_startup
7380 && (b->type == bp_breakpoint
7381 || b->type == bp_hardware_breakpoint))
7382 b->enable_state = bp_startup_disabled;
7388 loc = add_location_to_breakpoint (b, &sal);
7391 if (bp_loc_is_permanent (loc))
7392 make_breakpoint_permanent (b);
7396 char *arg = b->cond_string;
7397 loc->cond = parse_exp_1 (&arg, block_for_pc (loc->address), 0);
7399 error (_("Garbage %s follows condition"), arg);
7403 b->display_canonical = display_canonical;
7405 b->addr_string = addr_string;
7407 /* addr_string has to be used or breakpoint_re_set will delete
7410 = xstrprintf ("*%s", paddress (b->loc->gdbarch, b->loc->address));
7414 /* Do not mention breakpoints with a negative number, but do
7415 notify observers. */
7416 observer_notify_breakpoint_created (b->number);
7421 /* Remove element at INDEX_TO_REMOVE from SAL, shifting other
7422 elements to fill the void space. */
7424 remove_sal (struct symtabs_and_lines *sal, int index_to_remove)
7426 int i = index_to_remove+1;
7427 int last_index = sal->nelts-1;
7429 for (;i <= last_index; ++i)
7430 sal->sals[i-1] = sal->sals[i];
7435 /* If appropriate, obtains all sals that correspond to the same file
7436 and line as SAL, in all program spaces. Users debugging with IDEs,
7437 will want to set a breakpoint at foo.c:line, and not really care
7438 about program spaces. This is done only if SAL does not have
7439 explicit PC and has line and file information. If we got just a
7440 single expanded sal, return the original.
7442 Otherwise, if SAL.explicit_line is not set, filter out all sals for
7443 which the name of enclosing function is different from SAL. This
7444 makes sure that if we have breakpoint originally set in template
7445 instantiation, say foo<int>(), we won't expand SAL to locations at
7446 the same line in all existing instantiations of 'foo'. */
7448 static struct symtabs_and_lines
7449 expand_line_sal_maybe (struct symtab_and_line sal)
7451 struct symtabs_and_lines expanded;
7452 CORE_ADDR original_pc = sal.pc;
7453 char *original_function = NULL;
7456 struct cleanup *old_chain;
7458 /* If we have explicit pc, don't expand.
7459 If we have no line number, we can't expand. */
7460 if (sal.explicit_pc || sal.line == 0 || sal.symtab == NULL)
7463 expanded.sals = xmalloc (sizeof (struct symtab_and_line));
7464 expanded.sals[0] = sal;
7470 old_chain = save_current_space_and_thread ();
7472 switch_to_program_space_and_thread (sal.pspace);
7474 find_pc_partial_function (original_pc, &original_function, NULL, NULL);
7476 /* Note that expand_line_sal visits *all* program spaces. */
7477 expanded = expand_line_sal (sal);
7479 if (expanded.nelts == 1)
7481 /* We had one sal, we got one sal. Return that sal, adjusting it
7482 past the function prologue if necessary. */
7483 xfree (expanded.sals);
7485 expanded.sals = xmalloc (sizeof (struct symtab_and_line));
7486 sal.pc = original_pc;
7487 expanded.sals[0] = sal;
7488 skip_prologue_sal (&expanded.sals[0]);
7489 do_cleanups (old_chain);
7493 if (!sal.explicit_line)
7495 CORE_ADDR func_addr, func_end;
7496 for (i = 0; i < expanded.nelts; ++i)
7498 CORE_ADDR pc = expanded.sals[i].pc;
7499 char *this_function;
7501 /* We need to switch threads as well since we're about to
7503 switch_to_program_space_and_thread (expanded.sals[i].pspace);
7505 if (find_pc_partial_function (pc, &this_function,
7506 &func_addr, &func_end))
7509 && strcmp (this_function, original_function) != 0)
7511 remove_sal (&expanded, i);
7518 /* Skip the function prologue if necessary. */
7519 for (i = 0; i < expanded.nelts; ++i)
7520 skip_prologue_sal (&expanded.sals[i]);
7522 do_cleanups (old_chain);
7524 if (expanded.nelts <= 1)
7526 /* This is un ugly workaround. If we get zero expanded sals
7527 then something is really wrong. Fix that by returning the
7530 xfree (expanded.sals);
7532 expanded.sals = xmalloc (sizeof (struct symtab_and_line));
7533 sal.pc = original_pc;
7534 expanded.sals[0] = sal;
7541 for (i = 0; i < expanded.nelts; ++i)
7542 if (expanded.sals[i].pc == original_pc)
7553 /* Add SALS.nelts breakpoints to the breakpoint table. For each
7554 SALS.sal[i] breakpoint, include the corresponding ADDR_STRING[i]
7555 value. COND_STRING, if not NULL, specified the condition to be
7556 used for all breakpoints. Essentially the only case where
7557 SALS.nelts is not 1 is when we set a breakpoint on an overloaded
7558 function. In that case, it's still not possible to specify
7559 separate conditions for different overloaded functions, so
7560 we take just a single condition string.
7562 NOTE: If the function succeeds, the caller is expected to cleanup
7563 the arrays ADDR_STRING, COND_STRING, and SALS (but not the
7564 array contents). If the function fails (error() is called), the
7565 caller is expected to cleanups both the ADDR_STRING, COND_STRING,
7566 COND and SALS arrays and each of those arrays contents. */
7569 create_breakpoints_sal (struct gdbarch *gdbarch,
7570 struct symtabs_and_lines sals,
7571 struct linespec_result *canonical,
7573 enum bptype type, enum bpdisp disposition,
7574 int thread, int task, int ignore_count,
7575 struct breakpoint_ops *ops, int from_tty,
7576 int enabled, int internal)
7580 for (i = 0; i < sals.nelts; ++i)
7582 struct symtabs_and_lines expanded =
7583 expand_line_sal_maybe (sals.sals[i]);
7585 create_breakpoint_sal (gdbarch, expanded, canonical->canonical[i],
7586 cond_string, type, disposition,
7587 thread, task, ignore_count, ops,
7588 from_tty, enabled, internal,
7589 canonical->special_display);
7593 /* Parse ADDRESS which is assumed to be a SAL specification possibly
7594 followed by conditionals. On return, SALS contains an array of SAL
7595 addresses found. ADDR_STRING contains a vector of (canonical)
7596 address strings. ADDRESS points to the end of the SAL.
7598 The array and the line spec strings are allocated on the heap, it is
7599 the caller's responsibility to free them. */
7602 parse_breakpoint_sals (char **address,
7603 struct symtabs_and_lines *sals,
7604 struct linespec_result *canonical,
7607 char *addr_start = *address;
7609 /* If no arg given, or if first arg is 'if ', use the default
7611 if ((*address) == NULL
7612 || (strncmp ((*address), "if", 2) == 0 && isspace ((*address)[2])))
7614 if (default_breakpoint_valid)
7616 struct symtab_and_line sal;
7618 init_sal (&sal); /* Initialize to zeroes. */
7619 sals->sals = (struct symtab_and_line *)
7620 xmalloc (sizeof (struct symtab_and_line));
7621 sal.pc = default_breakpoint_address;
7622 sal.line = default_breakpoint_line;
7623 sal.symtab = default_breakpoint_symtab;
7624 sal.pspace = default_breakpoint_pspace;
7625 sal.section = find_pc_overlay (sal.pc);
7627 /* "break" without arguments is equivalent to "break *PC"
7628 where PC is the default_breakpoint_address. So make sure
7629 to set sal.explicit_pc to prevent GDB from trying to
7630 expand the list of sals to include all other instances
7631 with the same symtab and line. */
7632 sal.explicit_pc = 1;
7634 sals->sals[0] = sal;
7638 error (_("No default breakpoint address now."));
7642 /* Force almost all breakpoints to be in terms of the
7643 current_source_symtab (which is decode_line_1's default).
7644 This should produce the results we want almost all of the
7645 time while leaving default_breakpoint_* alone.
7647 ObjC: However, don't match an Objective-C method name which
7648 may have a '+' or '-' succeeded by a '[' */
7650 struct symtab_and_line cursal = get_current_source_symtab_and_line ();
7652 if (default_breakpoint_valid
7654 || ((strchr ("+-", (*address)[0]) != NULL)
7655 && ((*address)[1] != '['))))
7656 *sals = decode_line_1 (address, 1, default_breakpoint_symtab,
7657 default_breakpoint_line, canonical,
7660 *sals = decode_line_1 (address, 1, (struct symtab *) NULL, 0,
7661 canonical, not_found_ptr);
7663 /* For any SAL that didn't have a canonical string, fill one in. */
7664 if (sals->nelts > 0 && canonical->canonical == NULL)
7665 canonical->canonical = xcalloc (sals->nelts, sizeof (char **));
7666 if (addr_start != (*address))
7670 for (i = 0; i < sals->nelts; i++)
7672 /* Add the string if not present. */
7673 if (canonical->canonical[i] == NULL)
7674 canonical->canonical[i] = savestring (addr_start,
7675 (*address) - addr_start);
7681 /* Convert each SAL into a real PC. Verify that the PC can be
7682 inserted as a breakpoint. If it can't throw an error. */
7685 breakpoint_sals_to_pc (struct symtabs_and_lines *sals)
7689 for (i = 0; i < sals->nelts; i++)
7690 resolve_sal_pc (&sals->sals[i]);
7693 /* Fast tracepoints may have restrictions on valid locations. For
7694 instance, a fast tracepoint using a jump instead of a trap will
7695 likely have to overwrite more bytes than a trap would, and so can
7696 only be placed where the instruction is longer than the jump, or a
7697 multi-instruction sequence does not have a jump into the middle of
7701 check_fast_tracepoint_sals (struct gdbarch *gdbarch,
7702 struct symtabs_and_lines *sals)
7705 struct symtab_and_line *sal;
7707 struct cleanup *old_chain;
7709 for (i = 0; i < sals->nelts; i++)
7711 sal = &sals->sals[i];
7713 rslt = gdbarch_fast_tracepoint_valid_at (gdbarch, sal->pc,
7715 old_chain = make_cleanup (xfree, msg);
7718 error (_("May not have a fast tracepoint at 0x%s%s"),
7719 paddress (gdbarch, sal->pc), (msg ? msg : ""));
7721 do_cleanups (old_chain);
7726 do_captured_parse_breakpoint (struct ui_out *ui, void *data)
7728 struct captured_parse_breakpoint_args *args = data;
7730 parse_breakpoint_sals (args->arg_p, args->sals_p, args->canonical_p,
7731 args->not_found_ptr);
7734 /* Given TOK, a string specification of condition and thread, as
7735 accepted by the 'break' command, extract the condition
7736 string and thread number and set *COND_STRING and *THREAD.
7737 PC identifies the context at which the condition should be parsed.
7738 If no condition is found, *COND_STRING is set to NULL.
7739 If no thread is found, *THREAD is set to -1. */
7741 find_condition_and_thread (char *tok, CORE_ADDR pc,
7742 char **cond_string, int *thread, int *task)
7744 *cond_string = NULL;
7750 char *cond_start = NULL;
7751 char *cond_end = NULL;
7753 tok = skip_spaces (tok);
7755 end_tok = skip_to_space (tok);
7757 toklen = end_tok - tok;
7759 if (toklen >= 1 && strncmp (tok, "if", toklen) == 0)
7761 struct expression *expr;
7763 tok = cond_start = end_tok + 1;
7764 expr = parse_exp_1 (&tok, block_for_pc (pc), 0);
7767 *cond_string = savestring (cond_start,
7768 cond_end - cond_start);
7770 else if (toklen >= 1 && strncmp (tok, "thread", toklen) == 0)
7776 *thread = strtol (tok, &tok, 0);
7778 error (_("Junk after thread keyword."));
7779 if (!valid_thread_id (*thread))
7780 error (_("Unknown thread %d."), *thread);
7782 else if (toklen >= 1 && strncmp (tok, "task", toklen) == 0)
7788 *task = strtol (tok, &tok, 0);
7790 error (_("Junk after task keyword."));
7791 if (!valid_task_id (*task))
7792 error (_("Unknown task %d."), *task);
7795 error (_("Junk at end of arguments."));
7799 /* Decode a static tracepoint marker spec. */
7801 static struct symtabs_and_lines
7802 decode_static_tracepoint_spec (char **arg_p)
7804 VEC(static_tracepoint_marker_p) *markers = NULL;
7805 struct symtabs_and_lines sals;
7806 struct symtab_and_line sal;
7808 struct cleanup *old_chain;
7809 char *p = &(*arg_p)[3];
7814 p = skip_spaces (p);
7816 endp = skip_to_space (p);
7818 marker_str = savestring (p, endp - p);
7819 old_chain = make_cleanup (xfree, marker_str);
7821 markers = target_static_tracepoint_markers_by_strid (marker_str);
7822 if (VEC_empty(static_tracepoint_marker_p, markers))
7823 error (_("No known static tracepoint marker named %s"), marker_str);
7825 sals.nelts = VEC_length(static_tracepoint_marker_p, markers);
7826 sals.sals = xmalloc (sizeof *sals.sals * sals.nelts);
7828 for (i = 0; i < sals.nelts; i++)
7830 struct static_tracepoint_marker *marker;
7832 marker = VEC_index (static_tracepoint_marker_p, markers, i);
7834 init_sal (&sals.sals[i]);
7836 sals.sals[i] = find_pc_line (marker->address, 0);
7837 sals.sals[i].pc = marker->address;
7839 release_static_tracepoint_marker (marker);
7842 do_cleanups (old_chain);
7848 /* Set a breakpoint. This function is shared between CLI and MI
7849 functions for setting a breakpoint. This function has two major
7850 modes of operations, selected by the PARSE_CONDITION_AND_THREAD
7851 parameter. If non-zero, the function will parse arg, extracting
7852 breakpoint location, address and thread. Otherwise, ARG is just
7853 the location of breakpoint, with condition and thread specified by
7854 the COND_STRING and THREAD parameters. If INTERNAL is non-zero,
7855 the breakpoint number will be allocated from the internal
7856 breakpoint count. Returns true if any breakpoint was created;
7860 create_breakpoint (struct gdbarch *gdbarch,
7861 char *arg, char *cond_string, int thread,
7862 int parse_condition_and_thread,
7863 int tempflag, enum bptype type_wanted,
7865 enum auto_boolean pending_break_support,
7866 struct breakpoint_ops *ops,
7867 int from_tty, int enabled, int internal)
7869 struct gdb_exception e;
7870 struct symtabs_and_lines sals;
7871 struct symtab_and_line pending_sal;
7873 char *addr_start = arg;
7874 struct linespec_result canonical;
7875 struct cleanup *old_chain;
7876 struct cleanup *bkpt_chain = NULL;
7877 struct captured_parse_breakpoint_args parse_args;
7882 int prev_bkpt_count = breakpoint_count;
7886 init_linespec_result (&canonical);
7888 parse_args.arg_p = &arg;
7889 parse_args.sals_p = &sals;
7890 parse_args.canonical_p = &canonical;
7891 parse_args.not_found_ptr = ¬_found;
7893 if (type_wanted == bp_static_tracepoint && is_marker_spec (arg))
7897 sals = decode_static_tracepoint_spec (&arg);
7899 copy_arg = savestring (addr_start, arg - addr_start);
7900 canonical.canonical = xcalloc (sals.nelts, sizeof (char **));
7901 for (i = 0; i < sals.nelts; i++)
7902 canonical.canonical[i] = xstrdup (copy_arg);
7906 e = catch_exception (uiout, do_captured_parse_breakpoint,
7907 &parse_args, RETURN_MASK_ALL);
7909 /* If caller is interested in rc value from parse, set value. */
7913 throw_exception (e);
7917 case NOT_FOUND_ERROR:
7919 /* If pending breakpoint support is turned off, throw
7922 if (pending_break_support == AUTO_BOOLEAN_FALSE)
7923 throw_exception (e);
7925 exception_print (gdb_stderr, e);
7927 /* If pending breakpoint support is auto query and the user
7928 selects no, then simply return the error code. */
7929 if (pending_break_support == AUTO_BOOLEAN_AUTO
7930 && !nquery (_("Make breakpoint pending on "
7931 "future shared library load? ")))
7934 /* At this point, either the user was queried about setting
7935 a pending breakpoint and selected yes, or pending
7936 breakpoint behavior is on and thus a pending breakpoint
7937 is defaulted on behalf of the user. */
7938 copy_arg = xstrdup (addr_start);
7939 canonical.canonical = ©_arg;
7941 sals.sals = &pending_sal;
7946 throw_exception (e);
7956 /* Create a chain of things that always need to be cleaned up. */
7957 old_chain = make_cleanup (null_cleanup, 0);
7961 /* Make sure that all storage allocated to SALS gets freed. */
7962 make_cleanup (xfree, sals.sals);
7964 /* Cleanup the canonical array but not its contents. */
7965 make_cleanup (xfree, canonical.canonical);
7968 /* ----------------------------- SNIP -----------------------------
7969 Anything added to the cleanup chain beyond this point is assumed
7970 to be part of a breakpoint. If the breakpoint create succeeds
7971 then the memory is not reclaimed. */
7972 bkpt_chain = make_cleanup (null_cleanup, 0);
7974 /* Mark the contents of the canonical for cleanup. These go on
7975 the bkpt_chain and only occur if the breakpoint create fails. */
7976 for (i = 0; i < sals.nelts; i++)
7978 if (canonical.canonical[i] != NULL)
7979 make_cleanup (xfree, canonical.canonical[i]);
7982 /* Resolve all line numbers to PC's and verify that the addresses
7983 are ok for the target. */
7985 breakpoint_sals_to_pc (&sals);
7987 /* Fast tracepoints may have additional restrictions on location. */
7988 if (type_wanted == bp_fast_tracepoint)
7989 check_fast_tracepoint_sals (gdbarch, &sals);
7991 /* Verify that condition can be parsed, before setting any
7992 breakpoints. Allocate a separate condition expression for each
7996 if (parse_condition_and_thread)
7998 /* Here we only parse 'arg' to separate condition
7999 from thread number, so parsing in context of first
8000 sal is OK. When setting the breakpoint we'll
8001 re-parse it in context of each sal. */
8004 find_condition_and_thread (arg, sals.sals[0].pc, &cond_string,
8007 make_cleanup (xfree, cond_string);
8011 /* Create a private copy of condition string. */
8014 cond_string = xstrdup (cond_string);
8015 make_cleanup (xfree, cond_string);
8019 /* If the user is creating a static tracepoint by marker id
8020 (strace -m MARKER_ID), then store the sals index, so that
8021 breakpoint_re_set can try to match up which of the newly
8022 found markers corresponds to this one, and, don't try to
8023 expand multiple locations for each sal, given than SALS
8024 already should contain all sals for MARKER_ID. */
8025 if (type_wanted == bp_static_tracepoint
8026 && is_marker_spec (canonical.canonical[0]))
8030 for (i = 0; i < sals.nelts; ++i)
8032 struct symtabs_and_lines expanded;
8033 struct breakpoint *tp;
8034 struct cleanup *old_chain;
8037 expanded.sals = xmalloc (sizeof (struct symtab_and_line));
8038 expanded.sals[0] = sals.sals[i];
8039 old_chain = make_cleanup (xfree, expanded.sals);
8041 create_breakpoint_sal (gdbarch, expanded, canonical.canonical[i],
8042 cond_string, type_wanted,
8043 tempflag ? disp_del : disp_donttouch,
8044 thread, task, ignore_count, ops,
8045 from_tty, enabled, internal,
8046 canonical.special_display);
8048 do_cleanups (old_chain);
8050 /* Get the tracepoint we just created. */
8052 tp = get_breakpoint (internal_breakpoint_number);
8054 tp = get_breakpoint (breakpoint_count);
8055 gdb_assert (tp != NULL);
8057 /* Given that its possible to have multiple markers with
8058 the same string id, if the user is creating a static
8059 tracepoint by marker id ("strace -m MARKER_ID"), then
8060 store the sals index, so that breakpoint_re_set can
8061 try to match up which of the newly found markers
8062 corresponds to this one */
8063 tp->static_trace_marker_id_idx = i;
8067 create_breakpoints_sal (gdbarch, sals, &canonical, cond_string,
8069 tempflag ? disp_del : disp_donttouch,
8070 thread, task, ignore_count, ops, from_tty,
8075 struct breakpoint *b;
8077 make_cleanup (xfree, copy_arg);
8079 b = set_raw_breakpoint_without_location (gdbarch, type_wanted);
8080 set_breakpoint_number (internal, b);
8082 b->addr_string = canonical.canonical[0];
8083 b->cond_string = NULL;
8084 b->ignore_count = ignore_count;
8085 b->disposition = tempflag ? disp_del : disp_donttouch;
8086 b->condition_not_parsed = 1;
8088 b->enable_state = enabled ? bp_enabled : bp_disabled;
8089 b->pspace = current_program_space;
8090 b->py_bp_object = NULL;
8092 if (enabled && b->pspace->executing_startup
8093 && (b->type == bp_breakpoint
8094 || b->type == bp_hardware_breakpoint))
8095 b->enable_state = bp_startup_disabled;
8098 /* Do not mention breakpoints with a negative number,
8099 but do notify observers. */
8100 observer_notify_breakpoint_created (b->number);
8107 warning (_("Multiple breakpoints were set.\nUse the "
8108 "\"delete\" command to delete unwanted breakpoints."));
8109 prev_breakpoint_count = prev_bkpt_count;
8112 /* That's it. Discard the cleanups for data inserted into the
8114 discard_cleanups (bkpt_chain);
8115 /* But cleanup everything else. */
8116 do_cleanups (old_chain);
8118 /* error call may happen here - have BKPT_CHAIN already discarded. */
8119 update_global_location_list (1);
8124 /* Set a breakpoint.
8125 ARG is a string describing breakpoint address,
8126 condition, and thread.
8127 FLAG specifies if a breakpoint is hardware on,
8128 and if breakpoint is temporary, using BP_HARDWARE_FLAG
8132 break_command_1 (char *arg, int flag, int from_tty)
8134 int tempflag = flag & BP_TEMPFLAG;
8135 enum bptype type_wanted = (flag & BP_HARDWAREFLAG
8136 ? bp_hardware_breakpoint
8139 create_breakpoint (get_current_arch (),
8141 NULL, 0, 1 /* parse arg */,
8142 tempflag, type_wanted,
8143 0 /* Ignore count */,
8144 pending_break_support,
8145 NULL /* breakpoint_ops */,
8152 /* Helper function for break_command_1 and disassemble_command. */
8155 resolve_sal_pc (struct symtab_and_line *sal)
8159 if (sal->pc == 0 && sal->symtab != NULL)
8161 if (!find_line_pc (sal->symtab, sal->line, &pc))
8162 error (_("No line %d in file \"%s\"."),
8163 sal->line, sal->symtab->filename);
8166 /* If this SAL corresponds to a breakpoint inserted using a line
8167 number, then skip the function prologue if necessary. */
8168 if (sal->explicit_line)
8169 skip_prologue_sal (sal);
8172 if (sal->section == 0 && sal->symtab != NULL)
8174 struct blockvector *bv;
8178 bv = blockvector_for_pc_sect (sal->pc, 0, &b, sal->symtab);
8181 sym = block_linkage_function (b);
8184 fixup_symbol_section (sym, sal->symtab->objfile);
8185 sal->section = SYMBOL_OBJ_SECTION (sym);
8189 /* It really is worthwhile to have the section, so we'll
8190 just have to look harder. This case can be executed
8191 if we have line numbers but no functions (as can
8192 happen in assembly source). */
8194 struct minimal_symbol *msym;
8195 struct cleanup *old_chain = save_current_space_and_thread ();
8197 switch_to_program_space_and_thread (sal->pspace);
8199 msym = lookup_minimal_symbol_by_pc (sal->pc);
8201 sal->section = SYMBOL_OBJ_SECTION (msym);
8203 do_cleanups (old_chain);
8210 break_command (char *arg, int from_tty)
8212 break_command_1 (arg, 0, from_tty);
8216 tbreak_command (char *arg, int from_tty)
8218 break_command_1 (arg, BP_TEMPFLAG, from_tty);
8222 hbreak_command (char *arg, int from_tty)
8224 break_command_1 (arg, BP_HARDWAREFLAG, from_tty);
8228 thbreak_command (char *arg, int from_tty)
8230 break_command_1 (arg, (BP_TEMPFLAG | BP_HARDWAREFLAG), from_tty);
8234 stop_command (char *arg, int from_tty)
8236 printf_filtered (_("Specify the type of breakpoint to set.\n\
8237 Usage: stop in <function | address>\n\
8238 stop at <line>\n"));
8242 stopin_command (char *arg, int from_tty)
8246 if (arg == (char *) NULL)
8248 else if (*arg != '*')
8253 /* Look for a ':'. If this is a line number specification, then
8254 say it is bad, otherwise, it should be an address or
8255 function/method name. */
8256 while (*argptr && !hasColon)
8258 hasColon = (*argptr == ':');
8263 badInput = (*argptr != ':'); /* Not a class::method */
8265 badInput = isdigit (*arg); /* a simple line number */
8269 printf_filtered (_("Usage: stop in <function | address>\n"));
8271 break_command_1 (arg, 0, from_tty);
8275 stopat_command (char *arg, int from_tty)
8279 if (arg == (char *) NULL || *arg == '*') /* no line number */
8286 /* Look for a ':'. If there is a '::' then get out, otherwise
8287 it is probably a line number. */
8288 while (*argptr && !hasColon)
8290 hasColon = (*argptr == ':');
8295 badInput = (*argptr == ':'); /* we have class::method */
8297 badInput = !isdigit (*arg); /* not a line number */
8301 printf_filtered (_("Usage: stop at <line>\n"));
8303 break_command_1 (arg, 0, from_tty);
8306 /* Return non-zero if EXP is verified as constant. Returned zero
8307 means EXP is variable. Also the constant detection may fail for
8308 some constant expressions and in such case still falsely return
8311 watchpoint_exp_is_const (const struct expression *exp)
8319 /* We are only interested in the descriptor of each element. */
8320 operator_length (exp, i, &oplenp, &argsp);
8323 switch (exp->elts[i].opcode)
8333 case BINOP_LOGICAL_AND:
8334 case BINOP_LOGICAL_OR:
8335 case BINOP_BITWISE_AND:
8336 case BINOP_BITWISE_IOR:
8337 case BINOP_BITWISE_XOR:
8339 case BINOP_NOTEQUAL:
8355 case TERNOP_SLICE_COUNT:
8367 case OP_OBJC_NSSTRING:
8370 case UNOP_LOGICAL_NOT:
8371 case UNOP_COMPLEMENT:
8374 /* Unary, binary and ternary operators: We have to check
8375 their operands. If they are constant, then so is the
8376 result of that operation. For instance, if A and B are
8377 determined to be constants, then so is "A + B".
8379 UNOP_IND is one exception to the rule above, because the
8380 value of *ADDR is not necessarily a constant, even when
8385 /* Check whether the associated symbol is a constant.
8387 We use SYMBOL_CLASS rather than TYPE_CONST because it's
8388 possible that a buggy compiler could mark a variable as
8389 constant even when it is not, and TYPE_CONST would return
8390 true in this case, while SYMBOL_CLASS wouldn't.
8392 We also have to check for function symbols because they
8393 are always constant. */
8395 struct symbol *s = exp->elts[i + 2].symbol;
8397 if (SYMBOL_CLASS (s) != LOC_BLOCK
8398 && SYMBOL_CLASS (s) != LOC_CONST
8399 && SYMBOL_CLASS (s) != LOC_CONST_BYTES)
8404 /* The default action is to return 0 because we are using
8405 the optimistic approach here: If we don't know something,
8406 then it is not a constant. */
8415 /* Implement the "insert" breakpoint_ops method for hardware watchpoints. */
8418 insert_watchpoint (struct bp_location *bl)
8420 int length = bl->owner->exact? 1 : bl->length;
8422 return target_insert_watchpoint (bl->address, length, bl->watchpoint_type,
8423 bl->owner->cond_exp);
8426 /* Implement the "remove" breakpoint_ops method for hardware watchpoints. */
8429 remove_watchpoint (struct bp_location *bl)
8431 int length = bl->owner->exact? 1 : bl->length;
8433 return target_remove_watchpoint (bl->address, length, bl->watchpoint_type,
8434 bl->owner->cond_exp);
8437 /* Implement the "resources_needed" breakpoint_ops method for
8438 hardware watchpoints. */
8441 resources_needed_watchpoint (const struct bp_location *bl)
8443 int length = bl->owner->exact? 1 : bl->length;
8445 return target_region_ok_for_hw_watchpoint (bl->address, length);
8448 /* The breakpoint_ops structure to be used in hardware watchpoints. */
8450 static struct breakpoint_ops watchpoint_breakpoint_ops =
8454 NULL, /* breakpoint_hit */
8455 resources_needed_watchpoint,
8456 NULL, /* print_it */
8457 NULL, /* print_one */
8458 NULL, /* print_mention */
8459 NULL /* print_recreate */
8462 /* accessflag: hw_write: watch write,
8463 hw_read: watch read,
8464 hw_access: watch access (read or write) */
8466 watch_command_1 (char *arg, int accessflag, int from_tty,
8467 int just_location, int internal)
8469 struct breakpoint *b, *scope_breakpoint = NULL;
8470 struct expression *exp;
8471 struct block *exp_valid_block = NULL, *cond_exp_valid_block = NULL;
8472 struct value *val, *mark, *result;
8473 struct frame_info *frame;
8474 char *exp_start = NULL;
8475 char *exp_end = NULL;
8476 char *tok, *id_tok_start, *end_tok;
8478 char *cond_start = NULL;
8479 char *cond_end = NULL;
8480 int i, other_type_used, target_resources_ok = 0;
8481 enum bptype bp_type;
8486 /* Make sure that we actually have parameters to parse. */
8487 if (arg != NULL && arg[0] != '\0')
8489 toklen = strlen (arg); /* Size of argument list. */
8491 /* Points tok to the end of the argument list. */
8492 tok = arg + toklen - 1;
8494 /* Go backwards in the parameters list. Skip the last
8495 parameter. If we're expecting a 'thread <thread_num>'
8496 parameter, this should be the thread identifier. */
8497 while (tok > arg && (*tok == ' ' || *tok == '\t'))
8499 while (tok > arg && (*tok != ' ' && *tok != '\t'))
8502 /* Points end_tok to the beginning of the last token. */
8503 id_tok_start = tok + 1;
8505 /* Go backwards in the parameters list. Skip one more
8506 parameter. If we're expecting a 'thread <thread_num>'
8507 parameter, we should reach a "thread" token. */
8508 while (tok > arg && (*tok == ' ' || *tok == '\t'))
8513 while (tok > arg && (*tok != ' ' && *tok != '\t'))
8516 /* Move the pointer forward to skip the whitespace and
8517 calculate the length of the token. */
8519 toklen = end_tok - tok;
8521 if (toklen >= 1 && strncmp (tok, "thread", toklen) == 0)
8523 /* At this point we've found a "thread" token, which means
8524 the user is trying to set a watchpoint that triggers
8525 only in a specific thread. */
8528 /* Extract the thread ID from the next token. */
8529 thread = strtol (id_tok_start, &endp, 0);
8531 /* Check if the user provided a valid numeric value for the
8533 if (*endp != ' ' && *endp != '\t' && *endp != '\0')
8534 error (_("Invalid thread ID specification %s."), id_tok_start);
8536 /* Check if the thread actually exists. */
8537 if (!valid_thread_id (thread))
8538 error (_("Unknown thread %d."), thread);
8540 /* Truncate the string and get rid of the thread <thread_num>
8541 parameter before the parameter list is parsed by the
8542 evaluate_expression() function. */
8547 /* Parse the rest of the arguments. */
8548 innermost_block = NULL;
8550 exp = parse_exp_1 (&arg, 0, 0);
8552 /* Remove trailing whitespace from the expression before saving it.
8553 This makes the eventual display of the expression string a bit
8555 while (exp_end > exp_start && (exp_end[-1] == ' ' || exp_end[-1] == '\t'))
8558 /* Checking if the expression is not constant. */
8559 if (watchpoint_exp_is_const (exp))
8563 len = exp_end - exp_start;
8564 while (len > 0 && isspace (exp_start[len - 1]))
8566 error (_("Cannot watch constant value `%.*s'."), len, exp_start);
8569 exp_valid_block = innermost_block;
8570 mark = value_mark ();
8571 fetch_subexp_value (exp, &pc, &val, &result, NULL);
8575 exp_valid_block = NULL;
8576 val = value_addr (result);
8577 release_value (val);
8578 value_free_to_mark (mark);
8580 else if (val != NULL)
8581 release_value (val);
8583 tok = skip_spaces (arg);
8584 end_tok = skip_to_space (tok);
8586 toklen = end_tok - tok;
8587 if (toklen >= 1 && strncmp (tok, "if", toklen) == 0)
8589 struct expression *cond;
8591 innermost_block = NULL;
8592 tok = cond_start = end_tok + 1;
8593 cond = parse_exp_1 (&tok, 0, 0);
8595 /* The watchpoint expression may not be local, but the condition
8596 may still be. E.g.: `watch global if local > 0'. */
8597 cond_exp_valid_block = innermost_block;
8603 error (_("Junk at end of command."));
8605 if (accessflag == hw_read)
8606 bp_type = bp_read_watchpoint;
8607 else if (accessflag == hw_access)
8608 bp_type = bp_access_watchpoint;
8610 bp_type = bp_hardware_watchpoint;
8612 reg_cnt = can_use_hardware_watchpoint (val, target_exact_watchpoints);
8613 if (reg_cnt == 0 && bp_type != bp_hardware_watchpoint)
8614 error (_("Expression cannot be implemented with read/access watchpoint."));
8617 i = hw_watchpoint_used_count (bp_type, &other_type_used);
8618 target_resources_ok =
8619 target_can_use_hardware_watchpoint (bp_type, i + reg_cnt,
8621 if (target_resources_ok == 0 && bp_type != bp_hardware_watchpoint)
8622 error (_("Target does not support this type of hardware watchpoint."));
8624 if (target_resources_ok < 0 && bp_type != bp_hardware_watchpoint)
8625 error (_("Target can only support one kind "
8626 "of HW watchpoint at a time."));
8629 /* Change the type of breakpoint to an ordinary watchpoint if a
8630 hardware watchpoint could not be set. */
8631 if (!reg_cnt || target_resources_ok <= 0)
8632 bp_type = bp_watchpoint;
8634 frame = block_innermost_frame (exp_valid_block);
8636 /* If the expression is "local", then set up a "watchpoint scope"
8637 breakpoint at the point where we've left the scope of the watchpoint
8638 expression. Create the scope breakpoint before the watchpoint, so
8639 that we will encounter it first in bpstat_stop_status. */
8640 if (exp_valid_block && frame)
8642 if (frame_id_p (frame_unwind_caller_id (frame)))
8645 = create_internal_breakpoint (frame_unwind_caller_arch (frame),
8646 frame_unwind_caller_pc (frame),
8647 bp_watchpoint_scope);
8649 scope_breakpoint->enable_state = bp_enabled;
8651 /* Automatically delete the breakpoint when it hits. */
8652 scope_breakpoint->disposition = disp_del;
8654 /* Only break in the proper frame (help with recursion). */
8655 scope_breakpoint->frame_id = frame_unwind_caller_id (frame);
8657 /* Set the address at which we will stop. */
8658 scope_breakpoint->loc->gdbarch
8659 = frame_unwind_caller_arch (frame);
8660 scope_breakpoint->loc->requested_address
8661 = frame_unwind_caller_pc (frame);
8662 scope_breakpoint->loc->address
8663 = adjust_breakpoint_address (scope_breakpoint->loc->gdbarch,
8664 scope_breakpoint->loc->requested_address,
8665 scope_breakpoint->type);
8669 /* Now set up the breakpoint. */
8670 b = set_raw_breakpoint_without_location (NULL, bp_type);
8671 set_breakpoint_number (internal, b);
8673 b->disposition = disp_donttouch;
8675 b->exp_valid_block = exp_valid_block;
8676 b->cond_exp_valid_block = cond_exp_valid_block;
8679 struct type *t = value_type (val);
8680 CORE_ADDR addr = value_as_address (val);
8683 t = check_typedef (TYPE_TARGET_TYPE (check_typedef (t)));
8684 name = type_to_string (t);
8686 b->exp_string_reparse = xstrprintf ("* (%s *) %s", name,
8687 core_addr_to_string (addr));
8690 b->exp_string = xstrprintf ("-location: %.*s",
8691 (int) (exp_end - exp_start), exp_start);
8693 /* The above expression is in C. */
8694 b->language = language_c;
8697 b->exp_string = savestring (exp_start, exp_end - exp_start);
8700 b->ops = &watchpoint_breakpoint_ops;
8702 /* Use an exact watchpoint when there's only one memory region to be
8703 watched, and only one debug register is needed to watch it. */
8704 b->exact = target_exact_watchpoints && reg_cnt == 1;
8707 b->cond_string = savestring (cond_start, cond_end - cond_start);
8713 b->watchpoint_frame = get_frame_id (frame);
8714 b->watchpoint_thread = inferior_ptid;
8718 b->watchpoint_frame = null_frame_id;
8719 b->watchpoint_thread = null_ptid;
8722 if (scope_breakpoint != NULL)
8724 /* The scope breakpoint is related to the watchpoint. We will
8725 need to act on them together. */
8726 b->related_breakpoint = scope_breakpoint;
8727 scope_breakpoint->related_breakpoint = b;
8731 value_free_to_mark (mark);
8733 /* Finally update the new watchpoint. This creates the locations
8734 that should be inserted. */
8735 update_watchpoint (b, 1);
8737 /* Do not mention breakpoints with a negative number, but do
8738 notify observers. */
8739 observer_notify_breakpoint_created (b->number);
8742 update_global_location_list (1);
8745 /* Return count of debug registers needed to watch the given expression.
8746 If EXACT_WATCHPOINTS is 1, then consider that only the address of
8747 the start of the watched region will be monitored (i.e., all accesses
8748 will be aligned). This uses less debug registers on some targets.
8750 If the watchpoint cannot be handled in hardware return zero. */
8753 can_use_hardware_watchpoint (struct value *v, int exact_watchpoints)
8755 int found_memory_cnt = 0;
8756 struct value *head = v;
8758 /* Did the user specifically forbid us to use hardware watchpoints? */
8759 if (!can_use_hw_watchpoints)
8762 /* Make sure that the value of the expression depends only upon
8763 memory contents, and values computed from them within GDB. If we
8764 find any register references or function calls, we can't use a
8765 hardware watchpoint.
8767 The idea here is that evaluating an expression generates a series
8768 of values, one holding the value of every subexpression. (The
8769 expression a*b+c has five subexpressions: a, b, a*b, c, and
8770 a*b+c.) GDB's values hold almost enough information to establish
8771 the criteria given above --- they identify memory lvalues,
8772 register lvalues, computed values, etcetera. So we can evaluate
8773 the expression, and then scan the chain of values that leaves
8774 behind to decide whether we can detect any possible change to the
8775 expression's final value using only hardware watchpoints.
8777 However, I don't think that the values returned by inferior
8778 function calls are special in any way. So this function may not
8779 notice that an expression involving an inferior function call
8780 can't be watched with hardware watchpoints. FIXME. */
8781 for (; v; v = value_next (v))
8783 if (VALUE_LVAL (v) == lval_memory)
8785 if (v != head && value_lazy (v))
8786 /* A lazy memory lvalue in the chain is one that GDB never
8787 needed to fetch; we either just used its address (e.g.,
8788 `a' in `a.b') or we never needed it at all (e.g., `a'
8789 in `a,b'). This doesn't apply to HEAD; if that is
8790 lazy then it was not readable, but watch it anyway. */
8794 /* Ahh, memory we actually used! Check if we can cover
8795 it with hardware watchpoints. */
8796 struct type *vtype = check_typedef (value_type (v));
8798 /* We only watch structs and arrays if user asked for it
8799 explicitly, never if they just happen to appear in a
8800 middle of some value chain. */
8802 || (TYPE_CODE (vtype) != TYPE_CODE_STRUCT
8803 && TYPE_CODE (vtype) != TYPE_CODE_ARRAY))
8805 CORE_ADDR vaddr = value_address (v);
8809 len = (exact_watchpoints
8810 && is_scalar_type_recursive (vtype))?
8811 1 : TYPE_LENGTH (value_type (v));
8813 num_regs = target_region_ok_for_hw_watchpoint (vaddr, len);
8817 found_memory_cnt += num_regs;
8821 else if (VALUE_LVAL (v) != not_lval
8822 && deprecated_value_modifiable (v) == 0)
8823 return 0; /* These are values from the history (e.g., $1). */
8824 else if (VALUE_LVAL (v) == lval_register)
8825 return 0; /* Cannot watch a register with a HW watchpoint. */
8828 /* The expression itself looks suitable for using a hardware
8829 watchpoint, but give the target machine a chance to reject it. */
8830 return found_memory_cnt;
8834 watch_command_wrapper (char *arg, int from_tty, int internal)
8836 watch_command_1 (arg, hw_write, from_tty, 0, internal);
8839 /* A helper function that looks for an argument at the start of a
8840 string. The argument must also either be at the end of the string,
8841 or be followed by whitespace. Returns 1 if it finds the argument,
8842 0 otherwise. If the argument is found, it updates *STR. */
8845 check_for_argument (char **str, char *arg, int arg_len)
8847 if (strncmp (*str, arg, arg_len) == 0
8848 && ((*str)[arg_len] == '\0' || isspace ((*str)[arg_len])))
8856 /* A helper function that looks for the "-location" argument and then
8857 calls watch_command_1. */
8860 watch_maybe_just_location (char *arg, int accessflag, int from_tty)
8862 int just_location = 0;
8865 && (check_for_argument (&arg, "-location", sizeof ("-location") - 1)
8866 || check_for_argument (&arg, "-l", sizeof ("-l") - 1)))
8868 arg = skip_spaces (arg);
8872 watch_command_1 (arg, accessflag, from_tty, just_location, 0);
8876 watch_command (char *arg, int from_tty)
8878 watch_maybe_just_location (arg, hw_write, from_tty);
8882 rwatch_command_wrapper (char *arg, int from_tty, int internal)
8884 watch_command_1 (arg, hw_read, from_tty, 0, internal);
8888 rwatch_command (char *arg, int from_tty)
8890 watch_maybe_just_location (arg, hw_read, from_tty);
8894 awatch_command_wrapper (char *arg, int from_tty, int internal)
8896 watch_command_1 (arg, hw_access, from_tty, 0, internal);
8900 awatch_command (char *arg, int from_tty)
8902 watch_maybe_just_location (arg, hw_access, from_tty);
8906 /* Helper routines for the until_command routine in infcmd.c. Here
8907 because it uses the mechanisms of breakpoints. */
8909 struct until_break_command_continuation_args
8911 struct breakpoint *breakpoint;
8912 struct breakpoint *breakpoint2;
8916 /* This function is called by fetch_inferior_event via the
8917 cmd_continuation pointer, to complete the until command. It takes
8918 care of cleaning up the temporary breakpoints set up by the until
8921 until_break_command_continuation (void *arg)
8923 struct until_break_command_continuation_args *a = arg;
8925 delete_breakpoint (a->breakpoint);
8927 delete_breakpoint (a->breakpoint2);
8928 delete_longjmp_breakpoint (a->thread_num);
8932 until_break_command (char *arg, int from_tty, int anywhere)
8934 struct symtabs_and_lines sals;
8935 struct symtab_and_line sal;
8936 struct frame_info *frame = get_selected_frame (NULL);
8937 struct breakpoint *breakpoint;
8938 struct breakpoint *breakpoint2 = NULL;
8939 struct cleanup *old_chain;
8941 struct thread_info *tp;
8943 clear_proceed_status ();
8945 /* Set a breakpoint where the user wants it and at return from
8948 if (default_breakpoint_valid)
8949 sals = decode_line_1 (&arg, 1, default_breakpoint_symtab,
8950 default_breakpoint_line, NULL, NULL);
8952 sals = decode_line_1 (&arg, 1, (struct symtab *) NULL, 0, NULL, NULL);
8954 if (sals.nelts != 1)
8955 error (_("Couldn't get information on specified line."));
8958 xfree (sals.sals); /* malloc'd, so freed. */
8961 error (_("Junk at end of arguments."));
8963 resolve_sal_pc (&sal);
8966 /* If the user told us to continue until a specified location,
8967 we don't specify a frame at which we need to stop. */
8968 breakpoint = set_momentary_breakpoint (get_frame_arch (frame), sal,
8969 null_frame_id, bp_until);
8971 /* Otherwise, specify the selected frame, because we want to stop
8972 only at the very same frame. */
8973 breakpoint = set_momentary_breakpoint (get_frame_arch (frame), sal,
8974 get_stack_frame_id (frame),
8977 old_chain = make_cleanup_delete_breakpoint (breakpoint);
8979 tp = inferior_thread ();
8982 /* Keep within the current frame, or in frames called by the current
8985 if (frame_id_p (frame_unwind_caller_id (frame)))
8987 sal = find_pc_line (frame_unwind_caller_pc (frame), 0);
8988 sal.pc = frame_unwind_caller_pc (frame);
8989 breakpoint2 = set_momentary_breakpoint (frame_unwind_caller_arch (frame),
8991 frame_unwind_caller_id (frame),
8993 make_cleanup_delete_breakpoint (breakpoint2);
8995 set_longjmp_breakpoint (tp, frame_unwind_caller_id (frame));
8996 make_cleanup (delete_longjmp_breakpoint_cleanup, &thread);
8999 proceed (-1, TARGET_SIGNAL_DEFAULT, 0);
9001 /* If we are running asynchronously, and proceed call above has
9002 actually managed to start the target, arrange for breakpoints to
9003 be deleted when the target stops. Otherwise, we're already
9004 stopped and delete breakpoints via cleanup chain. */
9006 if (target_can_async_p () && is_running (inferior_ptid))
9008 struct until_break_command_continuation_args *args;
9009 args = xmalloc (sizeof (*args));
9011 args->breakpoint = breakpoint;
9012 args->breakpoint2 = breakpoint2;
9013 args->thread_num = thread;
9015 discard_cleanups (old_chain);
9016 add_continuation (inferior_thread (),
9017 until_break_command_continuation, args,
9021 do_cleanups (old_chain);
9024 /* This function attempts to parse an optional "if <cond>" clause
9025 from the arg string. If one is not found, it returns NULL.
9027 Else, it returns a pointer to the condition string. (It does not
9028 attempt to evaluate the string against a particular block.) And,
9029 it updates arg to point to the first character following the parsed
9030 if clause in the arg string. */
9033 ep_parse_optional_if_clause (char **arg)
9037 if (((*arg)[0] != 'i') || ((*arg)[1] != 'f') || !isspace ((*arg)[2]))
9040 /* Skip the "if" keyword. */
9043 /* Skip any extra leading whitespace, and record the start of the
9044 condition string. */
9045 *arg = skip_spaces (*arg);
9048 /* Assume that the condition occupies the remainder of the arg
9050 (*arg) += strlen (cond_string);
9055 /* Commands to deal with catching events, such as signals, exceptions,
9056 process start/exit, etc. */
9060 catch_fork_temporary, catch_vfork_temporary,
9061 catch_fork_permanent, catch_vfork_permanent
9066 catch_fork_command_1 (char *arg, int from_tty,
9067 struct cmd_list_element *command)
9069 struct gdbarch *gdbarch = get_current_arch ();
9070 char *cond_string = NULL;
9071 catch_fork_kind fork_kind;
9074 fork_kind = (catch_fork_kind) (uintptr_t) get_cmd_context (command);
9075 tempflag = (fork_kind == catch_fork_temporary
9076 || fork_kind == catch_vfork_temporary);
9080 arg = skip_spaces (arg);
9082 /* The allowed syntax is:
9084 catch [v]fork if <cond>
9086 First, check if there's an if clause. */
9087 cond_string = ep_parse_optional_if_clause (&arg);
9089 if ((*arg != '\0') && !isspace (*arg))
9090 error (_("Junk at end of arguments."));
9092 /* If this target supports it, create a fork or vfork catchpoint
9093 and enable reporting of such events. */
9096 case catch_fork_temporary:
9097 case catch_fork_permanent:
9098 create_fork_vfork_event_catchpoint (gdbarch, tempflag, cond_string,
9099 &catch_fork_breakpoint_ops);
9101 case catch_vfork_temporary:
9102 case catch_vfork_permanent:
9103 create_fork_vfork_event_catchpoint (gdbarch, tempflag, cond_string,
9104 &catch_vfork_breakpoint_ops);
9107 error (_("unsupported or unknown fork kind; cannot catch it"));
9113 catch_exec_command_1 (char *arg, int from_tty,
9114 struct cmd_list_element *command)
9116 struct gdbarch *gdbarch = get_current_arch ();
9118 char *cond_string = NULL;
9120 tempflag = get_cmd_context (command) == CATCH_TEMPORARY;
9124 arg = skip_spaces (arg);
9126 /* The allowed syntax is:
9128 catch exec if <cond>
9130 First, check if there's an if clause. */
9131 cond_string = ep_parse_optional_if_clause (&arg);
9133 if ((*arg != '\0') && !isspace (*arg))
9134 error (_("Junk at end of arguments."));
9136 /* If this target supports it, create an exec catchpoint
9137 and enable reporting of such events. */
9138 create_catchpoint (gdbarch, tempflag, cond_string,
9139 &catch_exec_breakpoint_ops);
9142 static enum print_stop_action
9143 print_exception_catchpoint (struct breakpoint *b)
9145 int bp_temp, bp_throw;
9147 annotate_catchpoint (b->number);
9149 bp_throw = strstr (b->addr_string, "throw") != NULL;
9150 if (b->loc->address != b->loc->requested_address)
9151 breakpoint_adjustment_warning (b->loc->requested_address,
9154 bp_temp = b->disposition == disp_del;
9156 bp_temp ? "Temporary catchpoint "
9158 if (!ui_out_is_mi_like_p (uiout))
9159 ui_out_field_int (uiout, "bkptno", b->number);
9161 bp_throw ? " (exception thrown), "
9162 : " (exception caught), ");
9163 if (ui_out_is_mi_like_p (uiout))
9165 ui_out_field_string (uiout, "reason",
9166 async_reason_lookup (EXEC_ASYNC_BREAKPOINT_HIT));
9167 ui_out_field_string (uiout, "disp", bpdisp_text (b->disposition));
9168 ui_out_field_int (uiout, "bkptno", b->number);
9170 return PRINT_SRC_AND_LOC;
9174 print_one_exception_catchpoint (struct breakpoint *b,
9175 struct bp_location **last_loc)
9177 struct value_print_options opts;
9179 get_user_print_options (&opts);
9180 if (opts.addressprint)
9183 if (b->loc == NULL || b->loc->shlib_disabled)
9184 ui_out_field_string (uiout, "addr", "<PENDING>");
9186 ui_out_field_core_addr (uiout, "addr",
9187 b->loc->gdbarch, b->loc->address);
9192 if (strstr (b->addr_string, "throw") != NULL)
9193 ui_out_field_string (uiout, "what", "exception throw");
9195 ui_out_field_string (uiout, "what", "exception catch");
9199 print_mention_exception_catchpoint (struct breakpoint *b)
9204 bp_temp = b->disposition == disp_del;
9205 bp_throw = strstr (b->addr_string, "throw") != NULL;
9206 ui_out_text (uiout, bp_temp ? _("Temporary catchpoint ")
9207 : _("Catchpoint "));
9208 ui_out_field_int (uiout, "bkptno", b->number);
9209 ui_out_text (uiout, bp_throw ? _(" (throw)")
9213 /* Implement the "print_recreate" breakpoint_ops method for throw and
9214 catch catchpoints. */
9217 print_recreate_exception_catchpoint (struct breakpoint *b,
9223 bp_temp = b->disposition == disp_del;
9224 bp_throw = strstr (b->addr_string, "throw") != NULL;
9225 fprintf_unfiltered (fp, bp_temp ? "tcatch " : "catch ");
9226 fprintf_unfiltered (fp, bp_throw ? "throw" : "catch");
9229 static struct breakpoint_ops gnu_v3_exception_catchpoint_ops = {
9232 NULL, /* breakpoint_hit */
9233 NULL, /* resources_needed */
9234 print_exception_catchpoint,
9235 print_one_exception_catchpoint,
9236 print_mention_exception_catchpoint,
9237 print_recreate_exception_catchpoint
9241 handle_gnu_v3_exceptions (int tempflag, char *cond_string,
9242 enum exception_event_kind ex_event, int from_tty)
9244 char *trigger_func_name;
9246 if (ex_event == EX_EVENT_CATCH)
9247 trigger_func_name = "__cxa_begin_catch";
9249 trigger_func_name = "__cxa_throw";
9251 create_breakpoint (get_current_arch (),
9252 trigger_func_name, cond_string, -1,
9253 0 /* condition and thread are valid. */,
9254 tempflag, bp_breakpoint,
9256 AUTO_BOOLEAN_TRUE /* pending */,
9257 &gnu_v3_exception_catchpoint_ops, from_tty,
9264 /* Deal with "catch catch" and "catch throw" commands. */
9267 catch_exception_command_1 (enum exception_event_kind ex_event, char *arg,
9268 int tempflag, int from_tty)
9270 char *cond_string = NULL;
9274 arg = skip_spaces (arg);
9276 cond_string = ep_parse_optional_if_clause (&arg);
9278 if ((*arg != '\0') && !isspace (*arg))
9279 error (_("Junk at end of arguments."));
9281 if (ex_event != EX_EVENT_THROW
9282 && ex_event != EX_EVENT_CATCH)
9283 error (_("Unsupported or unknown exception event; cannot catch it"));
9285 if (handle_gnu_v3_exceptions (tempflag, cond_string, ex_event, from_tty))
9288 warning (_("Unsupported with this platform/compiler combination."));
9291 /* Implementation of "catch catch" command. */
9294 catch_catch_command (char *arg, int from_tty, struct cmd_list_element *command)
9296 int tempflag = get_cmd_context (command) == CATCH_TEMPORARY;
9298 catch_exception_command_1 (EX_EVENT_CATCH, arg, tempflag, from_tty);
9301 /* Implementation of "catch throw" command. */
9304 catch_throw_command (char *arg, int from_tty, struct cmd_list_element *command)
9306 int tempflag = get_cmd_context (command) == CATCH_TEMPORARY;
9308 catch_exception_command_1 (EX_EVENT_THROW, arg, tempflag, from_tty);
9311 /* Create a breakpoint struct for Ada exception catchpoints. */
9314 create_ada_exception_breakpoint (struct gdbarch *gdbarch,
9315 struct symtab_and_line sal,
9319 struct expression *cond,
9320 struct breakpoint_ops *ops,
9324 struct breakpoint *b;
9328 struct gdbarch *loc_gdbarch = get_sal_arch (sal);
9330 loc_gdbarch = gdbarch;
9332 describe_other_breakpoints (loc_gdbarch,
9333 sal.pspace, sal.pc, sal.section, -1);
9334 /* FIXME: brobecker/2006-12-28: Actually, re-implement a special
9335 version for exception catchpoints, because two catchpoints
9336 used for different exception names will use the same address.
9337 In this case, a "breakpoint ... also set at..." warning is
9338 unproductive. Besides, the warning phrasing is also a bit
9339 inapropriate, we should use the word catchpoint, and tell
9340 the user what type of catchpoint it is. The above is good
9341 enough for now, though. */
9344 b = set_raw_breakpoint (gdbarch, sal, bp_breakpoint);
9345 set_breakpoint_count (breakpoint_count + 1);
9347 b->enable_state = bp_enabled;
9348 b->disposition = tempflag ? disp_del : disp_donttouch;
9349 b->number = breakpoint_count;
9350 b->ignore_count = 0;
9351 b->loc->cond = cond;
9352 b->addr_string = addr_string;
9353 b->language = language_ada;
9354 b->cond_string = cond_string;
9355 b->exp_string = exp_string;
9360 update_global_location_list (1);
9363 /* Implement the "catch exception" command. */
9366 catch_ada_exception_command (char *arg, int from_tty,
9367 struct cmd_list_element *command)
9369 struct gdbarch *gdbarch = get_current_arch ();
9371 struct symtab_and_line sal;
9372 char *addr_string = NULL;
9373 char *exp_string = NULL;
9374 char *cond_string = NULL;
9375 struct expression *cond = NULL;
9376 struct breakpoint_ops *ops = NULL;
9378 tempflag = get_cmd_context (command) == CATCH_TEMPORARY;
9382 sal = ada_decode_exception_location (arg, &addr_string, &exp_string,
9383 &cond_string, &cond, &ops);
9384 create_ada_exception_breakpoint (gdbarch, sal, addr_string, exp_string,
9385 cond_string, cond, ops, tempflag,
9389 /* Cleanup function for a syscall filter list. */
9391 clean_up_filters (void *arg)
9393 VEC(int) *iter = *(VEC(int) **) arg;
9394 VEC_free (int, iter);
9397 /* Splits the argument using space as delimiter. Returns an xmalloc'd
9398 filter list, or NULL if no filtering is required. */
9400 catch_syscall_split_args (char *arg)
9402 VEC(int) *result = NULL;
9403 struct cleanup *cleanup = make_cleanup (clean_up_filters, &result);
9405 while (*arg != '\0')
9407 int i, syscall_number;
9412 /* Skip whitespace. */
9413 while (isspace (*arg))
9416 for (i = 0; i < 127 && arg[i] && !isspace (arg[i]); ++i)
9417 cur_name[i] = arg[i];
9421 /* Check if the user provided a syscall name or a number. */
9422 syscall_number = (int) strtol (cur_name, &endptr, 0);
9423 if (*endptr == '\0')
9424 get_syscall_by_number (syscall_number, &s);
9427 /* We have a name. Let's check if it's valid and convert it
9429 get_syscall_by_name (cur_name, &s);
9431 if (s.number == UNKNOWN_SYSCALL)
9432 /* Here we have to issue an error instead of a warning,
9433 because GDB cannot do anything useful if there's no
9434 syscall number to be caught. */
9435 error (_("Unknown syscall name '%s'."), cur_name);
9438 /* Ok, it's valid. */
9439 VEC_safe_push (int, result, s.number);
9442 discard_cleanups (cleanup);
9446 /* Implement the "catch syscall" command. */
9449 catch_syscall_command_1 (char *arg, int from_tty,
9450 struct cmd_list_element *command)
9455 struct gdbarch *gdbarch = get_current_arch ();
9457 /* Checking if the feature if supported. */
9458 if (gdbarch_get_syscall_number_p (gdbarch) == 0)
9459 error (_("The feature 'catch syscall' is not supported on \
9460 this architecture yet."));
9462 tempflag = get_cmd_context (command) == CATCH_TEMPORARY;
9464 arg = skip_spaces (arg);
9466 /* We need to do this first "dummy" translation in order
9467 to get the syscall XML file loaded or, most important,
9468 to display a warning to the user if there's no XML file
9469 for his/her architecture. */
9470 get_syscall_by_number (0, &s);
9472 /* The allowed syntax is:
9474 catch syscall <name | number> [<name | number> ... <name | number>]
9476 Let's check if there's a syscall name. */
9479 filter = catch_syscall_split_args (arg);
9483 create_syscall_event_catchpoint (tempflag, filter,
9484 &catch_syscall_breakpoint_ops);
9487 /* Implement the "catch assert" command. */
9490 catch_assert_command (char *arg, int from_tty,
9491 struct cmd_list_element *command)
9493 struct gdbarch *gdbarch = get_current_arch ();
9495 struct symtab_and_line sal;
9496 char *addr_string = NULL;
9497 struct breakpoint_ops *ops = NULL;
9499 tempflag = get_cmd_context (command) == CATCH_TEMPORARY;
9503 sal = ada_decode_assert_location (arg, &addr_string, &ops);
9504 create_ada_exception_breakpoint (gdbarch, sal, addr_string, NULL, NULL, NULL,
9505 ops, tempflag, from_tty);
9509 catch_command (char *arg, int from_tty)
9511 error (_("Catch requires an event name."));
9516 tcatch_command (char *arg, int from_tty)
9518 error (_("Catch requires an event name."));
9521 /* Delete breakpoints by address or line. */
9524 clear_command (char *arg, int from_tty)
9526 struct breakpoint *b;
9527 VEC(breakpoint_p) *found = 0;
9530 struct symtabs_and_lines sals;
9531 struct symtab_and_line sal;
9536 sals = decode_line_spec (arg, 1);
9541 sals.sals = (struct symtab_and_line *)
9542 xmalloc (sizeof (struct symtab_and_line));
9543 make_cleanup (xfree, sals.sals);
9544 init_sal (&sal); /* Initialize to zeroes. */
9545 sal.line = default_breakpoint_line;
9546 sal.symtab = default_breakpoint_symtab;
9547 sal.pc = default_breakpoint_address;
9548 sal.pspace = default_breakpoint_pspace;
9549 if (sal.symtab == 0)
9550 error (_("No source file specified."));
9558 /* We don't call resolve_sal_pc here. That's not as bad as it
9559 seems, because all existing breakpoints typically have both
9560 file/line and pc set. So, if clear is given file/line, we can
9561 match this to existing breakpoint without obtaining pc at all.
9563 We only support clearing given the address explicitly
9564 present in breakpoint table. Say, we've set breakpoint
9565 at file:line. There were several PC values for that file:line,
9566 due to optimization, all in one block.
9568 We've picked one PC value. If "clear" is issued with another
9569 PC corresponding to the same file:line, the breakpoint won't
9570 be cleared. We probably can still clear the breakpoint, but
9571 since the other PC value is never presented to user, user
9572 can only find it by guessing, and it does not seem important
9575 /* For each line spec given, delete bps which correspond to it. Do
9576 it in two passes, solely to preserve the current behavior that
9577 from_tty is forced true if we delete more than one
9581 for (i = 0; i < sals.nelts; i++)
9583 /* If exact pc given, clear bpts at that pc.
9584 If line given (pc == 0), clear all bpts on specified line.
9585 If defaulting, clear all bpts on default line
9588 defaulting sal.pc != 0 tests to do
9593 1 0 <can't happen> */
9597 /* Find all matching breakpoints and add them to 'found'. */
9601 /* Are we going to delete b? */
9602 if (b->type != bp_none && !is_watchpoint (b))
9604 struct bp_location *loc = b->loc;
9605 for (; loc; loc = loc->next)
9607 int pc_match = sal.pc
9608 && (loc->pspace == sal.pspace)
9609 && (loc->address == sal.pc)
9610 && (!section_is_overlay (loc->section)
9611 || loc->section == sal.section);
9612 int line_match = ((default_match || (0 == sal.pc))
9613 && b->source_file != NULL
9614 && sal.symtab != NULL
9615 && sal.pspace == loc->pspace
9616 && filename_cmp (b->source_file,
9617 sal.symtab->filename) == 0
9618 && b->line_number == sal.line);
9619 if (pc_match || line_match)
9628 VEC_safe_push(breakpoint_p, found, b);
9631 /* Now go thru the 'found' chain and delete them. */
9632 if (VEC_empty(breakpoint_p, found))
9635 error (_("No breakpoint at %s."), arg);
9637 error (_("No breakpoint at this line."));
9640 if (VEC_length(breakpoint_p, found) > 1)
9641 from_tty = 1; /* Always report if deleted more than one. */
9644 if (VEC_length(breakpoint_p, found) == 1)
9645 printf_unfiltered (_("Deleted breakpoint "));
9647 printf_unfiltered (_("Deleted breakpoints "));
9649 breakpoints_changed ();
9651 for (ix = 0; VEC_iterate(breakpoint_p, found, ix, b); ix++)
9654 printf_unfiltered ("%d ", b->number);
9655 delete_breakpoint (b);
9658 putchar_unfiltered ('\n');
9661 /* Delete breakpoint in BS if they are `delete' breakpoints and
9662 all breakpoints that are marked for deletion, whether hit or not.
9663 This is called after any breakpoint is hit, or after errors. */
9666 breakpoint_auto_delete (bpstat bs)
9668 struct breakpoint *b, *b_tmp;
9670 for (; bs; bs = bs->next)
9671 if (bs->breakpoint_at
9672 && bs->breakpoint_at->disposition == disp_del
9674 delete_breakpoint (bs->breakpoint_at);
9676 ALL_BREAKPOINTS_SAFE (b, b_tmp)
9678 if (b->disposition == disp_del_at_next_stop)
9679 delete_breakpoint (b);
9683 /* A comparison function for bp_location AP and BP being interfaced to
9684 qsort. Sort elements primarily by their ADDRESS (no matter what
9685 does breakpoint_address_is_meaningful say for its OWNER),
9686 secondarily by ordering first bp_permanent OWNERed elements and
9687 terciarily just ensuring the array is sorted stable way despite
9688 qsort being an instable algorithm. */
9691 bp_location_compare (const void *ap, const void *bp)
9693 struct bp_location *a = *(void **) ap;
9694 struct bp_location *b = *(void **) bp;
9695 /* A and B come from existing breakpoints having non-NULL OWNER. */
9696 int a_perm = a->owner->enable_state == bp_permanent;
9697 int b_perm = b->owner->enable_state == bp_permanent;
9699 if (a->address != b->address)
9700 return (a->address > b->address) - (a->address < b->address);
9702 /* Sort permanent breakpoints first. */
9703 if (a_perm != b_perm)
9704 return (a_perm < b_perm) - (a_perm > b_perm);
9706 /* Make the user-visible order stable across GDB runs. Locations of
9707 the same breakpoint can be sorted in arbitrary order. */
9709 if (a->owner->number != b->owner->number)
9710 return (a->owner->number > b->owner->number)
9711 - (a->owner->number < b->owner->number);
9713 return (a > b) - (a < b);
9716 /* Set bp_location_placed_address_before_address_max and
9717 bp_location_shadow_len_after_address_max according to the current
9718 content of the bp_location array. */
9721 bp_location_target_extensions_update (void)
9723 struct bp_location *bl, **blp_tmp;
9725 bp_location_placed_address_before_address_max = 0;
9726 bp_location_shadow_len_after_address_max = 0;
9728 ALL_BP_LOCATIONS (bl, blp_tmp)
9730 CORE_ADDR start, end, addr;
9732 if (!bp_location_has_shadow (bl))
9735 start = bl->target_info.placed_address;
9736 end = start + bl->target_info.shadow_len;
9738 gdb_assert (bl->address >= start);
9739 addr = bl->address - start;
9740 if (addr > bp_location_placed_address_before_address_max)
9741 bp_location_placed_address_before_address_max = addr;
9743 /* Zero SHADOW_LEN would not pass bp_location_has_shadow. */
9745 gdb_assert (bl->address < end);
9746 addr = end - bl->address;
9747 if (addr > bp_location_shadow_len_after_address_max)
9748 bp_location_shadow_len_after_address_max = addr;
9752 /* If SHOULD_INSERT is false, do not insert any breakpoint locations
9753 into the inferior, only remove already-inserted locations that no
9754 longer should be inserted. Functions that delete a breakpoint or
9755 breakpoints should pass false, so that deleting a breakpoint
9756 doesn't have the side effect of inserting the locations of other
9757 breakpoints that are marked not-inserted, but should_be_inserted
9758 returns true on them.
9760 This behaviour is useful is situations close to tear-down -- e.g.,
9761 after an exec, while the target still has execution, but breakpoint
9762 shadows of the previous executable image should *NOT* be restored
9763 to the new image; or before detaching, where the target still has
9764 execution and wants to delete breakpoints from GDB's lists, and all
9765 breakpoints had already been removed from the inferior. */
9768 update_global_location_list (int should_insert)
9770 struct breakpoint *b;
9771 struct bp_location **locp, *loc;
9772 struct cleanup *cleanups;
9774 /* Used in the duplicates detection below. When iterating over all
9775 bp_locations, points to the first bp_location of a given address.
9776 Breakpoints and watchpoints of different types are never
9777 duplicates of each other. Keep one pointer for each type of
9778 breakpoint/watchpoint, so we only need to loop over all locations
9780 struct bp_location *bp_loc_first; /* breakpoint */
9781 struct bp_location *wp_loc_first; /* hardware watchpoint */
9782 struct bp_location *awp_loc_first; /* access watchpoint */
9783 struct bp_location *rwp_loc_first; /* read watchpoint */
9785 /* Saved former bp_location array which we compare against the newly
9786 built bp_location from the current state of ALL_BREAKPOINTS. */
9787 struct bp_location **old_location, **old_locp;
9788 unsigned old_location_count;
9790 old_location = bp_location;
9791 old_location_count = bp_location_count;
9793 bp_location_count = 0;
9794 cleanups = make_cleanup (xfree, old_location);
9797 for (loc = b->loc; loc; loc = loc->next)
9798 bp_location_count++;
9800 bp_location = xmalloc (sizeof (*bp_location) * bp_location_count);
9803 for (loc = b->loc; loc; loc = loc->next)
9805 qsort (bp_location, bp_location_count, sizeof (*bp_location),
9806 bp_location_compare);
9808 bp_location_target_extensions_update ();
9810 /* Identify bp_location instances that are no longer present in the
9811 new list, and therefore should be freed. Note that it's not
9812 necessary that those locations should be removed from inferior --
9813 if there's another location at the same address (previously
9814 marked as duplicate), we don't need to remove/insert the
9817 LOCP is kept in sync with OLD_LOCP, each pointing to the current
9818 and former bp_location array state respectively. */
9821 for (old_locp = old_location; old_locp < old_location + old_location_count;
9824 struct bp_location *old_loc = *old_locp;
9825 struct bp_location **loc2p;
9827 /* Tells if 'old_loc' is found amoung the new locations. If
9828 not, we have to free it. */
9829 int found_object = 0;
9830 /* Tells if the location should remain inserted in the target. */
9831 int keep_in_target = 0;
9834 /* Skip LOCP entries which will definitely never be needed.
9835 Stop either at or being the one matching OLD_LOC. */
9836 while (locp < bp_location + bp_location_count
9837 && (*locp)->address < old_loc->address)
9841 (loc2p < bp_location + bp_location_count
9842 && (*loc2p)->address == old_loc->address);
9845 if (*loc2p == old_loc)
9852 /* If this location is no longer present, and inserted, look if
9853 there's maybe a new location at the same address. If so,
9854 mark that one inserted, and don't remove this one. This is
9855 needed so that we don't have a time window where a breakpoint
9856 at certain location is not inserted. */
9858 if (old_loc->inserted)
9860 /* If the location is inserted now, we might have to remove
9863 if (found_object && should_be_inserted (old_loc))
9865 /* The location is still present in the location list,
9866 and still should be inserted. Don't do anything. */
9871 /* The location is either no longer present, or got
9872 disabled. See if there's another location at the
9873 same address, in which case we don't need to remove
9874 this one from the target. */
9876 /* OLD_LOC comes from existing struct breakpoint. */
9877 if (breakpoint_address_is_meaningful (old_loc->owner))
9880 (loc2p < bp_location + bp_location_count
9881 && (*loc2p)->address == old_loc->address);
9884 struct bp_location *loc2 = *loc2p;
9886 if (breakpoint_locations_match (loc2, old_loc))
9888 /* For the sake of should_be_inserted.
9889 Duplicates check below will fix up this
9891 loc2->duplicate = 0;
9893 /* Read watchpoint locations are switched to
9894 access watchpoints, if the former are not
9895 supported, but the latter are. */
9896 if (is_hardware_watchpoint (old_loc->owner))
9898 gdb_assert (is_hardware_watchpoint (loc2->owner));
9899 loc2->watchpoint_type = old_loc->watchpoint_type;
9902 if (loc2 != old_loc && should_be_inserted (loc2))
9905 loc2->target_info = old_loc->target_info;
9914 if (!keep_in_target)
9916 if (remove_breakpoint (old_loc, mark_uninserted))
9918 /* This is just about all we can do. We could keep
9919 this location on the global list, and try to
9920 remove it next time, but there's no particular
9921 reason why we will succeed next time.
9923 Note that at this point, old_loc->owner is still
9924 valid, as delete_breakpoint frees the breakpoint
9925 only after calling us. */
9926 printf_filtered (_("warning: Error removing "
9928 old_loc->owner->number);
9936 if (removed && non_stop
9937 && breakpoint_address_is_meaningful (old_loc->owner)
9938 && !is_hardware_watchpoint (old_loc->owner))
9940 /* This location was removed from the target. In
9941 non-stop mode, a race condition is possible where
9942 we've removed a breakpoint, but stop events for that
9943 breakpoint are already queued and will arrive later.
9944 We apply an heuristic to be able to distinguish such
9945 SIGTRAPs from other random SIGTRAPs: we keep this
9946 breakpoint location for a bit, and will retire it
9947 after we see some number of events. The theory here
9948 is that reporting of events should, "on the average",
9949 be fair, so after a while we'll see events from all
9950 threads that have anything of interest, and no longer
9951 need to keep this breakpoint location around. We
9952 don't hold locations forever so to reduce chances of
9953 mistaking a non-breakpoint SIGTRAP for a breakpoint
9956 The heuristic failing can be disastrous on
9957 decr_pc_after_break targets.
9959 On decr_pc_after_break targets, like e.g., x86-linux,
9960 if we fail to recognize a late breakpoint SIGTRAP,
9961 because events_till_retirement has reached 0 too
9962 soon, we'll fail to do the PC adjustment, and report
9963 a random SIGTRAP to the user. When the user resumes
9964 the inferior, it will most likely immediately crash
9965 with SIGILL/SIGBUS/SIGSEGV, or worse, get silently
9966 corrupted, because of being resumed e.g., in the
9967 middle of a multi-byte instruction, or skipped a
9968 one-byte instruction. This was actually seen happen
9969 on native x86-linux, and should be less rare on
9970 targets that do not support new thread events, like
9971 remote, due to the heuristic depending on
9974 Mistaking a random SIGTRAP for a breakpoint trap
9975 causes similar symptoms (PC adjustment applied when
9976 it shouldn't), but then again, playing with SIGTRAPs
9977 behind the debugger's back is asking for trouble.
9979 Since hardware watchpoint traps are always
9980 distinguishable from other traps, so we don't need to
9981 apply keep hardware watchpoint moribund locations
9982 around. We simply always ignore hardware watchpoint
9983 traps we can no longer explain. */
9985 old_loc->events_till_retirement = 3 * (thread_count () + 1);
9986 old_loc->owner = NULL;
9988 VEC_safe_push (bp_location_p, moribund_locations, old_loc);
9992 old_loc->owner = NULL;
9993 decref_bp_location (&old_loc);
9998 /* Rescan breakpoints at the same address and section, marking the
9999 first one as "first" and any others as "duplicates". This is so
10000 that the bpt instruction is only inserted once. If we have a
10001 permanent breakpoint at the same place as BPT, make that one the
10002 official one, and the rest as duplicates. Permanent breakpoints
10003 are sorted first for the same address.
10005 Do the same for hardware watchpoints, but also considering the
10006 watchpoint's type (regular/access/read) and length. */
10008 bp_loc_first = NULL;
10009 wp_loc_first = NULL;
10010 awp_loc_first = NULL;
10011 rwp_loc_first = NULL;
10012 ALL_BP_LOCATIONS (loc, locp)
10014 /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always
10016 struct breakpoint *b = loc->owner;
10017 struct bp_location **loc_first_p;
10019 if (b->enable_state == bp_disabled
10020 || b->enable_state == bp_call_disabled
10021 || b->enable_state == bp_startup_disabled
10023 || loc->shlib_disabled
10024 || !breakpoint_address_is_meaningful (b)
10025 || is_tracepoint (b))
10028 /* Permanent breakpoint should always be inserted. */
10029 if (b->enable_state == bp_permanent && ! loc->inserted)
10030 internal_error (__FILE__, __LINE__,
10031 _("allegedly permanent breakpoint is not "
10032 "actually inserted"));
10034 if (b->type == bp_hardware_watchpoint)
10035 loc_first_p = &wp_loc_first;
10036 else if (b->type == bp_read_watchpoint)
10037 loc_first_p = &rwp_loc_first;
10038 else if (b->type == bp_access_watchpoint)
10039 loc_first_p = &awp_loc_first;
10041 loc_first_p = &bp_loc_first;
10043 if (*loc_first_p == NULL
10044 || (overlay_debugging && loc->section != (*loc_first_p)->section)
10045 || !breakpoint_locations_match (loc, *loc_first_p))
10047 *loc_first_p = loc;
10048 loc->duplicate = 0;
10052 loc->duplicate = 1;
10054 if ((*loc_first_p)->owner->enable_state == bp_permanent && loc->inserted
10055 && b->enable_state != bp_permanent)
10056 internal_error (__FILE__, __LINE__,
10057 _("another breakpoint was inserted on top of "
10058 "a permanent breakpoint"));
10061 if (breakpoints_always_inserted_mode () && should_insert
10062 && (have_live_inferiors ()
10063 || (gdbarch_has_global_breakpoints (target_gdbarch))))
10064 insert_breakpoint_locations ();
10066 do_cleanups (cleanups);
10070 breakpoint_retire_moribund (void)
10072 struct bp_location *loc;
10075 for (ix = 0; VEC_iterate (bp_location_p, moribund_locations, ix, loc); ++ix)
10076 if (--(loc->events_till_retirement) == 0)
10078 decref_bp_location (&loc);
10079 VEC_unordered_remove (bp_location_p, moribund_locations, ix);
10085 update_global_location_list_nothrow (int inserting)
10087 struct gdb_exception e;
10089 TRY_CATCH (e, RETURN_MASK_ERROR)
10090 update_global_location_list (inserting);
10093 /* Clear BKP from a BPS. */
10096 bpstat_remove_bp_location (bpstat bps, struct breakpoint *bpt)
10100 for (bs = bps; bs; bs = bs->next)
10101 if (bs->breakpoint_at == bpt)
10103 bs->breakpoint_at = NULL;
10104 bs->old_val = NULL;
10105 /* bs->commands will be freed later. */
10109 /* Callback for iterate_over_threads. */
10111 bpstat_remove_breakpoint_callback (struct thread_info *th, void *data)
10113 struct breakpoint *bpt = data;
10115 bpstat_remove_bp_location (th->control.stop_bpstat, bpt);
10119 /* Delete a breakpoint and clean up all traces of it in the data
10123 delete_breakpoint (struct breakpoint *bpt)
10125 struct breakpoint *b;
10127 gdb_assert (bpt != NULL);
10129 /* Has this bp already been deleted? This can happen because
10130 multiple lists can hold pointers to bp's. bpstat lists are
10133 One example of this happening is a watchpoint's scope bp. When
10134 the scope bp triggers, we notice that the watchpoint is out of
10135 scope, and delete it. We also delete its scope bp. But the
10136 scope bp is marked "auto-deleting", and is already on a bpstat.
10137 That bpstat is then checked for auto-deleting bp's, which are
10140 A real solution to this problem might involve reference counts in
10141 bp's, and/or giving them pointers back to their referencing
10142 bpstat's, and teaching delete_breakpoint to only free a bp's
10143 storage when no more references were extent. A cheaper bandaid
10145 if (bpt->type == bp_none)
10148 /* At least avoid this stale reference until the reference counting
10149 of breakpoints gets resolved. */
10150 if (bpt->related_breakpoint != bpt)
10152 struct breakpoint *related;
10154 if (bpt->type == bp_watchpoint_scope)
10155 watchpoint_del_at_next_stop (bpt->related_breakpoint);
10156 else if (bpt->related_breakpoint->type == bp_watchpoint_scope)
10157 watchpoint_del_at_next_stop (bpt);
10159 /* Unlink bpt from the bpt->related_breakpoint ring. */
10160 for (related = bpt; related->related_breakpoint != bpt;
10161 related = related->related_breakpoint);
10162 related->related_breakpoint = bpt->related_breakpoint;
10163 bpt->related_breakpoint = bpt;
10166 observer_notify_breakpoint_deleted (bpt->number);
10168 if (breakpoint_chain == bpt)
10169 breakpoint_chain = bpt->next;
10171 ALL_BREAKPOINTS (b)
10172 if (b->next == bpt)
10174 b->next = bpt->next;
10178 decref_counted_command_line (&bpt->commands);
10179 xfree (bpt->cond_string);
10180 xfree (bpt->cond_exp);
10181 xfree (bpt->addr_string);
10183 xfree (bpt->exp_string);
10184 xfree (bpt->exp_string_reparse);
10185 value_free (bpt->val);
10186 xfree (bpt->source_file);
10187 xfree (bpt->exec_pathname);
10188 clean_up_filters (&bpt->syscalls_to_be_caught);
10191 /* Be sure no bpstat's are pointing at the breakpoint after it's
10193 /* FIXME, how can we find all bpstat's? We just check stop_bpstat
10194 in all threeds for now. Note that we cannot just remove bpstats
10195 pointing at bpt from the stop_bpstat list entirely, as breakpoint
10196 commands are associated with the bpstat; if we remove it here,
10197 then the later call to bpstat_do_actions (&stop_bpstat); in
10198 event-top.c won't do anything, and temporary breakpoints with
10199 commands won't work. */
10201 iterate_over_threads (bpstat_remove_breakpoint_callback, bpt);
10203 /* Now that breakpoint is removed from breakpoint list, update the
10204 global location list. This will remove locations that used to
10205 belong to this breakpoint. Do this before freeing the breakpoint
10206 itself, since remove_breakpoint looks at location's owner. It
10207 might be better design to have location completely
10208 self-contained, but it's not the case now. */
10209 update_global_location_list (0);
10212 /* On the chance that someone will soon try again to delete this
10213 same bp, we mark it as deleted before freeing its storage. */
10214 bpt->type = bp_none;
10220 do_delete_breakpoint_cleanup (void *b)
10222 delete_breakpoint (b);
10226 make_cleanup_delete_breakpoint (struct breakpoint *b)
10228 return make_cleanup (do_delete_breakpoint_cleanup, b);
10231 /* A callback for map_breakpoint_numbers that calls
10232 delete_breakpoint. */
10235 do_delete_breakpoint (struct breakpoint *b, void *ignore)
10237 delete_breakpoint (b);
10241 delete_command (char *arg, int from_tty)
10243 struct breakpoint *b, *b_tmp;
10249 int breaks_to_delete = 0;
10251 /* Delete all breakpoints if no argument.
10252 Do not delete internal or call-dummy breakpoints, these have
10253 to be deleted with an explicit breakpoint number argument. */
10254 ALL_BREAKPOINTS (b)
10256 if (b->type != bp_call_dummy
10257 && b->type != bp_std_terminate
10258 && b->type != bp_shlib_event
10259 && b->type != bp_jit_event
10260 && b->type != bp_thread_event
10261 && b->type != bp_overlay_event
10262 && b->type != bp_longjmp_master
10263 && b->type != bp_std_terminate_master
10264 && b->type != bp_exception_master
10267 breaks_to_delete = 1;
10272 /* Ask user only if there are some breakpoints to delete. */
10274 || (breaks_to_delete && query (_("Delete all breakpoints? "))))
10276 ALL_BREAKPOINTS_SAFE (b, b_tmp)
10278 if (b->type != bp_call_dummy
10279 && b->type != bp_std_terminate
10280 && b->type != bp_shlib_event
10281 && b->type != bp_thread_event
10282 && b->type != bp_jit_event
10283 && b->type != bp_overlay_event
10284 && b->type != bp_longjmp_master
10285 && b->type != bp_std_terminate_master
10286 && b->type != bp_exception_master
10288 delete_breakpoint (b);
10293 map_breakpoint_numbers (arg, do_delete_breakpoint, NULL);
10297 all_locations_are_pending (struct bp_location *loc)
10299 for (; loc; loc = loc->next)
10300 if (!loc->shlib_disabled)
10305 /* Subroutine of update_breakpoint_locations to simplify it.
10306 Return non-zero if multiple fns in list LOC have the same name.
10307 Null names are ignored. */
10310 ambiguous_names_p (struct bp_location *loc)
10312 struct bp_location *l;
10313 htab_t htab = htab_create_alloc (13, htab_hash_string,
10314 (int (*) (const void *,
10315 const void *)) streq,
10316 NULL, xcalloc, xfree);
10318 for (l = loc; l != NULL; l = l->next)
10321 const char *name = l->function_name;
10323 /* Allow for some names to be NULL, ignore them. */
10327 slot = (const char **) htab_find_slot (htab, (const void *) name,
10329 /* NOTE: We can assume slot != NULL here because xcalloc never
10333 htab_delete (htab);
10339 htab_delete (htab);
10343 /* When symbols change, it probably means the sources changed as well,
10344 and it might mean the static tracepoint markers are no longer at
10345 the same address or line numbers they used to be at last we
10346 checked. Losing your static tracepoints whenever you rebuild is
10347 undesirable. This function tries to resync/rematch gdb static
10348 tracepoints with the markers on the target, for static tracepoints
10349 that have not been set by marker id. Static tracepoint that have
10350 been set by marker id are reset by marker id in breakpoint_re_set.
10353 1) For a tracepoint set at a specific address, look for a marker at
10354 the old PC. If one is found there, assume to be the same marker.
10355 If the name / string id of the marker found is different from the
10356 previous known name, assume that means the user renamed the marker
10357 in the sources, and output a warning.
10359 2) For a tracepoint set at a given line number, look for a marker
10360 at the new address of the old line number. If one is found there,
10361 assume to be the same marker. If the name / string id of the
10362 marker found is different from the previous known name, assume that
10363 means the user renamed the marker in the sources, and output a
10366 3) If a marker is no longer found at the same address or line, it
10367 may mean the marker no longer exists. But it may also just mean
10368 the code changed a bit. Maybe the user added a few lines of code
10369 that made the marker move up or down (in line number terms). Ask
10370 the target for info about the marker with the string id as we knew
10371 it. If found, update line number and address in the matching
10372 static tracepoint. This will get confused if there's more than one
10373 marker with the same ID (possible in UST, although unadvised
10374 precisely because it confuses tools). */
10376 static struct symtab_and_line
10377 update_static_tracepoint (struct breakpoint *b, struct symtab_and_line sal)
10379 struct static_tracepoint_marker marker;
10385 find_line_pc (sal.symtab, sal.line, &pc);
10387 if (target_static_tracepoint_marker_at (pc, &marker))
10389 if (strcmp (b->static_trace_marker_id, marker.str_id) != 0)
10390 warning (_("static tracepoint %d changed probed marker from %s to %s"),
10392 b->static_trace_marker_id, marker.str_id);
10394 xfree (b->static_trace_marker_id);
10395 b->static_trace_marker_id = xstrdup (marker.str_id);
10396 release_static_tracepoint_marker (&marker);
10401 /* Old marker wasn't found on target at lineno. Try looking it up
10403 if (!sal.explicit_pc
10405 && sal.symtab != NULL
10406 && b->static_trace_marker_id != NULL)
10408 VEC(static_tracepoint_marker_p) *markers;
10411 = target_static_tracepoint_markers_by_strid (b->static_trace_marker_id);
10413 if (!VEC_empty(static_tracepoint_marker_p, markers))
10415 struct symtab_and_line sal;
10416 struct symbol *sym;
10417 struct static_tracepoint_marker *marker;
10419 marker = VEC_index (static_tracepoint_marker_p, markers, 0);
10421 xfree (b->static_trace_marker_id);
10422 b->static_trace_marker_id = xstrdup (marker->str_id);
10424 warning (_("marker for static tracepoint %d (%s) not "
10425 "found at previous line number"),
10426 b->number, b->static_trace_marker_id);
10430 sal.pc = marker->address;
10432 sal = find_pc_line (marker->address, 0);
10433 sym = find_pc_sect_function (marker->address, NULL);
10434 ui_out_text (uiout, "Now in ");
10437 ui_out_field_string (uiout, "func",
10438 SYMBOL_PRINT_NAME (sym));
10439 ui_out_text (uiout, " at ");
10441 ui_out_field_string (uiout, "file", sal.symtab->filename);
10442 ui_out_text (uiout, ":");
10444 if (ui_out_is_mi_like_p (uiout))
10446 char *fullname = symtab_to_fullname (sal.symtab);
10449 ui_out_field_string (uiout, "fullname", fullname);
10452 ui_out_field_int (uiout, "line", sal.line);
10453 ui_out_text (uiout, "\n");
10455 b->line_number = sal.line;
10457 xfree (b->source_file);
10459 b->source_file = xstrdup (sal.symtab->filename);
10461 b->source_file = NULL;
10463 xfree (b->addr_string);
10464 b->addr_string = xstrprintf ("%s:%d",
10465 sal.symtab->filename, b->line_number);
10467 /* Might be nice to check if function changed, and warn if
10470 release_static_tracepoint_marker (marker);
10477 update_breakpoint_locations (struct breakpoint *b,
10478 struct symtabs_and_lines sals)
10482 struct bp_location *existing_locations = b->loc;
10484 /* If there's no new locations, and all existing locations are
10485 pending, don't do anything. This optimizes the common case where
10486 all locations are in the same shared library, that was unloaded.
10487 We'd like to retain the location, so that when the library is
10488 loaded again, we don't loose the enabled/disabled status of the
10489 individual locations. */
10490 if (all_locations_are_pending (existing_locations) && sals.nelts == 0)
10495 for (i = 0; i < sals.nelts; ++i)
10497 struct bp_location *new_loc =
10498 add_location_to_breakpoint (b, &(sals.sals[i]));
10500 /* Reparse conditions, they might contain references to the
10502 if (b->cond_string != NULL)
10504 struct gdb_exception e;
10506 s = b->cond_string;
10507 TRY_CATCH (e, RETURN_MASK_ERROR)
10509 new_loc->cond = parse_exp_1 (&s, block_for_pc (sals.sals[i].pc),
10514 warning (_("failed to reevaluate condition "
10515 "for breakpoint %d: %s"),
10516 b->number, e.message);
10517 new_loc->enabled = 0;
10521 if (b->source_file != NULL)
10522 xfree (b->source_file);
10523 if (sals.sals[i].symtab == NULL)
10524 b->source_file = NULL;
10526 b->source_file = xstrdup (sals.sals[i].symtab->filename);
10528 if (b->line_number == 0)
10529 b->line_number = sals.sals[i].line;
10532 /* Update locations of permanent breakpoints. */
10533 if (b->enable_state == bp_permanent)
10534 make_breakpoint_permanent (b);
10536 /* If possible, carry over 'disable' status from existing
10539 struct bp_location *e = existing_locations;
10540 /* If there are multiple breakpoints with the same function name,
10541 e.g. for inline functions, comparing function names won't work.
10542 Instead compare pc addresses; this is just a heuristic as things
10543 may have moved, but in practice it gives the correct answer
10544 often enough until a better solution is found. */
10545 int have_ambiguous_names = ambiguous_names_p (b->loc);
10547 for (; e; e = e->next)
10549 if (!e->enabled && e->function_name)
10551 struct bp_location *l = b->loc;
10552 if (have_ambiguous_names)
10554 for (; l; l = l->next)
10555 if (breakpoint_address_match (e->pspace->aspace, e->address,
10556 l->pspace->aspace, l->address))
10564 for (; l; l = l->next)
10565 if (l->function_name
10566 && strcmp (e->function_name, l->function_name) == 0)
10576 update_global_location_list (1);
10579 /* Find the SaL locations corresponding to the given ADDR_STRING.
10580 On return, FOUND will be 1 if any SaL was found, zero otherwise. */
10582 static struct symtabs_and_lines
10583 addr_string_to_sals (struct breakpoint *b, char *addr_string, int *found)
10586 int marker_spec, not_found;
10587 struct symtabs_and_lines sals = {0};
10588 struct gdb_exception e;
10591 marker_spec = b->type == bp_static_tracepoint && is_marker_spec (s);
10593 TRY_CATCH (e, RETURN_MASK_ERROR)
10597 sals = decode_static_tracepoint_spec (&s);
10598 if (sals.nelts > b->static_trace_marker_id_idx)
10600 sals.sals[0] = sals.sals[b->static_trace_marker_id_idx];
10604 error (_("marker %s not found"), b->static_trace_marker_id);
10607 sals = decode_line_1 (&s, 1, (struct symtab *) NULL, 0,
10612 int not_found_and_ok = 0;
10613 /* For pending breakpoints, it's expected that parsing will
10614 fail until the right shared library is loaded. User has
10615 already told to create pending breakpoints and don't need
10616 extra messages. If breakpoint is in bp_shlib_disabled
10617 state, then user already saw the message about that
10618 breakpoint being disabled, and don't want to see more
10621 && (b->condition_not_parsed
10622 || (b->loc && b->loc->shlib_disabled)
10623 || b->enable_state == bp_disabled))
10624 not_found_and_ok = 1;
10626 if (!not_found_and_ok)
10628 /* We surely don't want to warn about the same breakpoint
10629 10 times. One solution, implemented here, is disable
10630 the breakpoint on error. Another solution would be to
10631 have separate 'warning emitted' flag. Since this
10632 happens only when a binary has changed, I don't know
10633 which approach is better. */
10634 b->enable_state = bp_disabled;
10635 throw_exception (e);
10641 gdb_assert (sals.nelts == 1);
10643 resolve_sal_pc (&sals.sals[0]);
10644 if (b->condition_not_parsed && s && s[0])
10646 char *cond_string = 0;
10650 find_condition_and_thread (s, sals.sals[0].pc,
10651 &cond_string, &thread, &task);
10653 b->cond_string = cond_string;
10654 b->thread = thread;
10656 b->condition_not_parsed = 0;
10659 if (b->type == bp_static_tracepoint && !marker_spec)
10660 sals.sals[0] = update_static_tracepoint (b, sals.sals[0]);
10663 *found = !not_found;
10668 /* Reevaluate a hardware or software breakpoint and recreate its locations.
10669 This is necessary after symbols are read (e.g., an executable or DSO
10670 was loaded, or the inferior just started). */
10673 re_set_breakpoint (struct breakpoint *b)
10676 struct symtabs_and_lines sals;
10677 struct symtabs_and_lines expanded = {0};
10678 struct cleanup *cleanups = make_cleanup (null_cleanup, NULL);
10680 input_radix = b->input_radix;
10681 save_current_space_and_thread ();
10682 switch_to_program_space_and_thread (b->pspace);
10683 set_language (b->language);
10685 sals = addr_string_to_sals (b, b->addr_string, &found);
10688 make_cleanup (xfree, sals.sals);
10689 expanded = expand_line_sal_maybe (sals.sals[0]);
10692 update_breakpoint_locations (b, expanded);
10693 do_cleanups (cleanups);
10696 /* Reset a breakpoint given it's struct breakpoint * BINT.
10697 The value we return ends up being the return value from catch_errors.
10698 Unused in this case. */
10701 breakpoint_re_set_one (void *bint)
10703 /* Get past catch_errs. */
10704 struct breakpoint *b = (struct breakpoint *) bint;
10709 warning (_("attempted to reset apparently deleted breakpoint #%d?"),
10712 case bp_breakpoint:
10713 case bp_hardware_breakpoint:
10714 case bp_tracepoint:
10715 case bp_fast_tracepoint:
10716 case bp_static_tracepoint:
10717 case bp_gnu_ifunc_resolver:
10718 /* Do not attempt to re-set breakpoints disabled during startup. */
10719 if (b->enable_state == bp_startup_disabled)
10722 if (b->addr_string == NULL)
10724 /* Anything without a string can't be re-set. */
10725 delete_breakpoint (b);
10729 re_set_breakpoint (b);
10732 case bp_watchpoint:
10733 case bp_hardware_watchpoint:
10734 case bp_read_watchpoint:
10735 case bp_access_watchpoint:
10736 /* Watchpoint can be either on expression using entirely global
10737 variables, or it can be on local variables.
10739 Watchpoints of the first kind are never auto-deleted, and
10740 even persist across program restarts. Since they can use
10741 variables from shared libraries, we need to reparse
10742 expression as libraries are loaded and unloaded.
10744 Watchpoints on local variables can also change meaning as
10745 result of solib event. For example, if a watchpoint uses
10746 both a local and a global variables in expression, it's a
10747 local watchpoint, but unloading of a shared library will make
10748 the expression invalid. This is not a very common use case,
10749 but we still re-evaluate expression, to avoid surprises to
10752 Note that for local watchpoints, we re-evaluate it only if
10753 watchpoints frame id is still valid. If it's not, it means
10754 the watchpoint is out of scope and will be deleted soon. In
10755 fact, I'm not sure we'll ever be called in this case.
10757 If a local watchpoint's frame id is still valid, then
10758 b->exp_valid_block is likewise valid, and we can safely use it.
10760 Don't do anything about disabled watchpoints, since they will
10761 be reevaluated again when enabled. */
10762 update_watchpoint (b, 1 /* reparse */);
10764 /* We needn't really do anything to reset these, since the mask
10765 that requests them is unaffected by e.g., new libraries being
10767 case bp_catchpoint:
10771 printf_filtered (_("Deleting unknown breakpoint type %d\n"), b->type);
10773 /* Delete overlay event and longjmp master breakpoints; they will be
10774 reset later by breakpoint_re_set. */
10775 case bp_overlay_event:
10776 case bp_longjmp_master:
10777 case bp_std_terminate_master:
10778 case bp_exception_master:
10779 delete_breakpoint (b);
10782 /* This breakpoint is special, it's set up when the inferior
10783 starts and we really don't want to touch it. */
10784 case bp_shlib_event:
10786 /* Like bp_shlib_event, this breakpoint type is special.
10787 Once it is set up, we do not want to touch it. */
10788 case bp_thread_event:
10790 /* Keep temporary breakpoints, which can be encountered when we
10791 step over a dlopen call and SOLIB_ADD is resetting the
10792 breakpoints. Otherwise these should have been blown away via
10793 the cleanup chain or by breakpoint_init_inferior when we
10794 rerun the executable. */
10797 case bp_watchpoint_scope:
10798 case bp_call_dummy:
10799 case bp_std_terminate:
10800 case bp_step_resume:
10802 case bp_longjmp_resume:
10804 case bp_exception_resume:
10806 case bp_gnu_ifunc_resolver_return:
10813 /* Re-set all breakpoints after symbols have been re-loaded. */
10815 breakpoint_re_set (void)
10817 struct breakpoint *b, *b_tmp;
10818 enum language save_language;
10819 int save_input_radix;
10820 struct cleanup *old_chain;
10822 save_language = current_language->la_language;
10823 save_input_radix = input_radix;
10824 old_chain = save_current_program_space ();
10826 ALL_BREAKPOINTS_SAFE (b, b_tmp)
10828 /* Format possible error msg. */
10829 char *message = xstrprintf ("Error in re-setting breakpoint %d: ",
10831 struct cleanup *cleanups = make_cleanup (xfree, message);
10832 catch_errors (breakpoint_re_set_one, b, message, RETURN_MASK_ALL);
10833 do_cleanups (cleanups);
10835 set_language (save_language);
10836 input_radix = save_input_radix;
10838 jit_breakpoint_re_set ();
10840 do_cleanups (old_chain);
10842 create_overlay_event_breakpoint ();
10843 create_longjmp_master_breakpoint ();
10844 create_std_terminate_master_breakpoint ();
10845 create_exception_master_breakpoint ();
10848 /* Reset the thread number of this breakpoint:
10850 - If the breakpoint is for all threads, leave it as-is.
10851 - Else, reset it to the current thread for inferior_ptid. */
10853 breakpoint_re_set_thread (struct breakpoint *b)
10855 if (b->thread != -1)
10857 if (in_thread_list (inferior_ptid))
10858 b->thread = pid_to_thread_id (inferior_ptid);
10860 /* We're being called after following a fork. The new fork is
10861 selected as current, and unless this was a vfork will have a
10862 different program space from the original thread. Reset that
10864 b->loc->pspace = current_program_space;
10868 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
10869 If from_tty is nonzero, it prints a message to that effect,
10870 which ends with a period (no newline). */
10873 set_ignore_count (int bptnum, int count, int from_tty)
10875 struct breakpoint *b;
10880 ALL_BREAKPOINTS (b)
10881 if (b->number == bptnum)
10883 if (is_tracepoint (b))
10885 if (from_tty && count != 0)
10886 printf_filtered (_("Ignore count ignored for tracepoint %d."),
10891 b->ignore_count = count;
10895 printf_filtered (_("Will stop next time "
10896 "breakpoint %d is reached."),
10898 else if (count == 1)
10899 printf_filtered (_("Will ignore next crossing of breakpoint %d."),
10902 printf_filtered (_("Will ignore next %d "
10903 "crossings of breakpoint %d."),
10906 breakpoints_changed ();
10907 observer_notify_breakpoint_modified (b->number);
10911 error (_("No breakpoint number %d."), bptnum);
10914 /* Command to set ignore-count of breakpoint N to COUNT. */
10917 ignore_command (char *args, int from_tty)
10923 error_no_arg (_("a breakpoint number"));
10925 num = get_number (&p);
10927 error (_("bad breakpoint number: '%s'"), args);
10929 error (_("Second argument (specified ignore-count) is missing."));
10931 set_ignore_count (num,
10932 longest_to_int (value_as_long (parse_and_eval (p))),
10935 printf_filtered ("\n");
10938 /* Call FUNCTION on each of the breakpoints
10939 whose numbers are given in ARGS. */
10942 map_breakpoint_numbers (char *args, void (*function) (struct breakpoint *,
10947 struct breakpoint *b, *tmp;
10949 struct get_number_or_range_state state;
10952 error_no_arg (_("one or more breakpoint numbers"));
10954 init_number_or_range (&state, args);
10956 while (!state.finished)
10958 char *p = state.string;
10962 num = get_number_or_range (&state);
10965 warning (_("bad breakpoint number at or near '%s'"), p);
10969 ALL_BREAKPOINTS_SAFE (b, tmp)
10970 if (b->number == num)
10972 struct breakpoint *related_breakpoint;
10975 related_breakpoint = b;
10978 struct breakpoint *next_related_b;
10980 /* FUNCTION can be also delete_breakpoint. */
10981 next_related_b = related_breakpoint->related_breakpoint;
10982 function (related_breakpoint, data);
10984 /* For delete_breakpoint of the last entry of the ring we
10985 were traversing we would never get back to B. */
10986 if (next_related_b == related_breakpoint)
10988 related_breakpoint = next_related_b;
10990 while (related_breakpoint != b);
10994 printf_unfiltered (_("No breakpoint number %d.\n"), num);
10999 static struct bp_location *
11000 find_location_by_number (char *number)
11002 char *dot = strchr (number, '.');
11006 struct breakpoint *b;
11007 struct bp_location *loc;
11012 bp_num = get_number (&p1);
11014 error (_("Bad breakpoint number '%s'"), number);
11016 ALL_BREAKPOINTS (b)
11017 if (b->number == bp_num)
11022 if (!b || b->number != bp_num)
11023 error (_("Bad breakpoint number '%s'"), number);
11026 loc_num = get_number (&p1);
11028 error (_("Bad breakpoint location number '%s'"), number);
11032 for (;loc_num && loc; --loc_num, loc = loc->next)
11035 error (_("Bad breakpoint location number '%s'"), dot+1);
11041 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
11042 If from_tty is nonzero, it prints a message to that effect,
11043 which ends with a period (no newline). */
11046 disable_breakpoint (struct breakpoint *bpt)
11048 /* Never disable a watchpoint scope breakpoint; we want to
11049 hit them when we leave scope so we can delete both the
11050 watchpoint and its scope breakpoint at that time. */
11051 if (bpt->type == bp_watchpoint_scope)
11054 /* You can't disable permanent breakpoints. */
11055 if (bpt->enable_state == bp_permanent)
11058 bpt->enable_state = bp_disabled;
11060 update_global_location_list (0);
11062 observer_notify_breakpoint_modified (bpt->number);
11065 /* A callback for map_breakpoint_numbers that calls
11066 disable_breakpoint. */
11069 do_map_disable_breakpoint (struct breakpoint *b, void *ignore)
11071 disable_breakpoint (b);
11075 disable_command (char *args, int from_tty)
11077 struct breakpoint *bpt;
11080 ALL_BREAKPOINTS (bpt)
11084 warning (_("attempted to disable apparently deleted breakpoint #%d?"),
11087 case bp_breakpoint:
11088 case bp_tracepoint:
11089 case bp_fast_tracepoint:
11090 case bp_static_tracepoint:
11091 case bp_catchpoint:
11092 case bp_hardware_breakpoint:
11093 case bp_watchpoint:
11094 case bp_hardware_watchpoint:
11095 case bp_read_watchpoint:
11096 case bp_access_watchpoint:
11097 disable_breakpoint (bpt);
11102 else if (strchr (args, '.'))
11104 struct bp_location *loc = find_location_by_number (args);
11107 update_global_location_list (0);
11110 map_breakpoint_numbers (args, do_map_disable_breakpoint, NULL);
11114 do_enable_breakpoint (struct breakpoint *bpt, enum bpdisp disposition)
11116 int target_resources_ok;
11118 if (bpt->type == bp_hardware_breakpoint)
11121 i = hw_breakpoint_used_count ();
11122 target_resources_ok =
11123 target_can_use_hardware_watchpoint (bp_hardware_breakpoint,
11125 if (target_resources_ok == 0)
11126 error (_("No hardware breakpoint support in the target."));
11127 else if (target_resources_ok < 0)
11128 error (_("Hardware breakpoints used exceeds limit."));
11131 if (is_watchpoint (bpt))
11133 struct gdb_exception e;
11135 TRY_CATCH (e, RETURN_MASK_ALL)
11137 update_watchpoint (bpt, 1 /* reparse */);
11141 exception_fprintf (gdb_stderr, e, _("Cannot enable watchpoint %d: "),
11147 if (bpt->enable_state != bp_permanent)
11148 bpt->enable_state = bp_enabled;
11149 bpt->disposition = disposition;
11150 update_global_location_list (1);
11151 breakpoints_changed ();
11153 observer_notify_breakpoint_modified (bpt->number);
11158 enable_breakpoint (struct breakpoint *bpt)
11160 do_enable_breakpoint (bpt, bpt->disposition);
11163 /* A callback for map_breakpoint_numbers that calls
11164 enable_breakpoint. */
11167 do_map_enable_breakpoint (struct breakpoint *b, void *ignore)
11169 enable_breakpoint (b);
11172 /* The enable command enables the specified breakpoints (or all defined
11173 breakpoints) so they once again become (or continue to be) effective
11174 in stopping the inferior. */
11177 enable_command (char *args, int from_tty)
11179 struct breakpoint *bpt;
11182 ALL_BREAKPOINTS (bpt)
11186 warning (_("attempted to enable apparently deleted breakpoint #%d?"),
11189 case bp_breakpoint:
11190 case bp_tracepoint:
11191 case bp_fast_tracepoint:
11192 case bp_static_tracepoint:
11193 case bp_catchpoint:
11194 case bp_hardware_breakpoint:
11195 case bp_watchpoint:
11196 case bp_hardware_watchpoint:
11197 case bp_read_watchpoint:
11198 case bp_access_watchpoint:
11199 enable_breakpoint (bpt);
11204 else if (strchr (args, '.'))
11206 struct bp_location *loc = find_location_by_number (args);
11209 update_global_location_list (1);
11212 map_breakpoint_numbers (args, do_map_enable_breakpoint, NULL);
11216 enable_once_breakpoint (struct breakpoint *bpt, void *ignore)
11218 do_enable_breakpoint (bpt, disp_disable);
11222 enable_once_command (char *args, int from_tty)
11224 map_breakpoint_numbers (args, enable_once_breakpoint, NULL);
11228 enable_delete_breakpoint (struct breakpoint *bpt, void *ignore)
11230 do_enable_breakpoint (bpt, disp_del);
11234 enable_delete_command (char *args, int from_tty)
11236 map_breakpoint_numbers (args, enable_delete_breakpoint, NULL);
11240 set_breakpoint_cmd (char *args, int from_tty)
11245 show_breakpoint_cmd (char *args, int from_tty)
11249 /* Invalidate last known value of any hardware watchpoint if
11250 the memory which that value represents has been written to by
11254 invalidate_bp_value_on_memory_change (CORE_ADDR addr, int len,
11255 const bfd_byte *data)
11257 struct breakpoint *bp;
11259 ALL_BREAKPOINTS (bp)
11260 if (bp->enable_state == bp_enabled
11261 && bp->type == bp_hardware_watchpoint
11262 && bp->val_valid && bp->val)
11264 struct bp_location *loc;
11266 for (loc = bp->loc; loc != NULL; loc = loc->next)
11267 if (loc->loc_type == bp_loc_hardware_watchpoint
11268 && loc->address + loc->length > addr
11269 && addr + len > loc->address)
11271 value_free (bp->val);
11278 /* Use default_breakpoint_'s, or nothing if they aren't valid. */
11280 struct symtabs_and_lines
11281 decode_line_spec_1 (char *string, int funfirstline)
11283 struct symtabs_and_lines sals;
11286 error (_("Empty line specification."));
11287 if (default_breakpoint_valid)
11288 sals = decode_line_1 (&string, funfirstline,
11289 default_breakpoint_symtab,
11290 default_breakpoint_line,
11293 sals = decode_line_1 (&string, funfirstline,
11294 (struct symtab *) NULL, 0, NULL, NULL);
11296 error (_("Junk at end of line specification: %s"), string);
11300 /* Create and insert a raw software breakpoint at PC. Return an
11301 identifier, which should be used to remove the breakpoint later.
11302 In general, places which call this should be using something on the
11303 breakpoint chain instead; this function should be eliminated
11307 deprecated_insert_raw_breakpoint (struct gdbarch *gdbarch,
11308 struct address_space *aspace, CORE_ADDR pc)
11310 struct bp_target_info *bp_tgt;
11312 bp_tgt = XZALLOC (struct bp_target_info);
11314 bp_tgt->placed_address_space = aspace;
11315 bp_tgt->placed_address = pc;
11317 if (target_insert_breakpoint (gdbarch, bp_tgt) != 0)
11319 /* Could not insert the breakpoint. */
11327 /* Remove a breakpoint BP inserted by
11328 deprecated_insert_raw_breakpoint. */
11331 deprecated_remove_raw_breakpoint (struct gdbarch *gdbarch, void *bp)
11333 struct bp_target_info *bp_tgt = bp;
11336 ret = target_remove_breakpoint (gdbarch, bp_tgt);
11342 /* One (or perhaps two) breakpoints used for software single
11345 static void *single_step_breakpoints[2];
11346 static struct gdbarch *single_step_gdbarch[2];
11348 /* Create and insert a breakpoint for software single step. */
11351 insert_single_step_breakpoint (struct gdbarch *gdbarch,
11352 struct address_space *aspace,
11357 if (single_step_breakpoints[0] == NULL)
11359 bpt_p = &single_step_breakpoints[0];
11360 single_step_gdbarch[0] = gdbarch;
11364 gdb_assert (single_step_breakpoints[1] == NULL);
11365 bpt_p = &single_step_breakpoints[1];
11366 single_step_gdbarch[1] = gdbarch;
11369 /* NOTE drow/2006-04-11: A future improvement to this function would
11370 be to only create the breakpoints once, and actually put them on
11371 the breakpoint chain. That would let us use set_raw_breakpoint.
11372 We could adjust the addresses each time they were needed. Doing
11373 this requires corresponding changes elsewhere where single step
11374 breakpoints are handled, however. So, for now, we use this. */
11376 *bpt_p = deprecated_insert_raw_breakpoint (gdbarch, aspace, next_pc);
11377 if (*bpt_p == NULL)
11378 error (_("Could not insert single-step breakpoint at %s"),
11379 paddress (gdbarch, next_pc));
11382 /* Check if the breakpoints used for software single stepping
11383 were inserted or not. */
11386 single_step_breakpoints_inserted (void)
11388 return (single_step_breakpoints[0] != NULL
11389 || single_step_breakpoints[1] != NULL);
11392 /* Remove and delete any breakpoints used for software single step. */
11395 remove_single_step_breakpoints (void)
11397 gdb_assert (single_step_breakpoints[0] != NULL);
11399 /* See insert_single_step_breakpoint for more about this deprecated
11401 deprecated_remove_raw_breakpoint (single_step_gdbarch[0],
11402 single_step_breakpoints[0]);
11403 single_step_gdbarch[0] = NULL;
11404 single_step_breakpoints[0] = NULL;
11406 if (single_step_breakpoints[1] != NULL)
11408 deprecated_remove_raw_breakpoint (single_step_gdbarch[1],
11409 single_step_breakpoints[1]);
11410 single_step_gdbarch[1] = NULL;
11411 single_step_breakpoints[1] = NULL;
11415 /* Delete software single step breakpoints without removing them from
11416 the inferior. This is intended to be used if the inferior's address
11417 space where they were inserted is already gone, e.g. after exit or
11421 cancel_single_step_breakpoints (void)
11425 for (i = 0; i < 2; i++)
11426 if (single_step_breakpoints[i])
11428 xfree (single_step_breakpoints[i]);
11429 single_step_breakpoints[i] = NULL;
11430 single_step_gdbarch[i] = NULL;
11434 /* Detach software single-step breakpoints from INFERIOR_PTID without
11438 detach_single_step_breakpoints (void)
11442 for (i = 0; i < 2; i++)
11443 if (single_step_breakpoints[i])
11444 target_remove_breakpoint (single_step_gdbarch[i],
11445 single_step_breakpoints[i]);
11448 /* Check whether a software single-step breakpoint is inserted at
11452 single_step_breakpoint_inserted_here_p (struct address_space *aspace,
11457 for (i = 0; i < 2; i++)
11459 struct bp_target_info *bp_tgt = single_step_breakpoints[i];
11461 && breakpoint_address_match (bp_tgt->placed_address_space,
11462 bp_tgt->placed_address,
11470 /* Returns 0 if 'bp' is NOT a syscall catchpoint,
11471 non-zero otherwise. */
11473 is_syscall_catchpoint_enabled (struct breakpoint *bp)
11475 if (syscall_catchpoint_p (bp)
11476 && bp->enable_state != bp_disabled
11477 && bp->enable_state != bp_call_disabled)
11484 catch_syscall_enabled (void)
11486 struct inferior *inf = current_inferior ();
11488 return inf->total_syscalls_count != 0;
11492 catching_syscall_number (int syscall_number)
11494 struct breakpoint *bp;
11496 ALL_BREAKPOINTS (bp)
11497 if (is_syscall_catchpoint_enabled (bp))
11499 if (bp->syscalls_to_be_caught)
11503 VEC_iterate (int, bp->syscalls_to_be_caught, i, iter);
11505 if (syscall_number == iter)
11515 /* Complete syscall names. Used by "catch syscall". */
11517 catch_syscall_completer (struct cmd_list_element *cmd,
11518 char *text, char *word)
11520 const char **list = get_syscall_names ();
11522 = (list == NULL) ? NULL : complete_on_enum (list, text, word);
11528 /* Tracepoint-specific operations. */
11530 /* Set tracepoint count to NUM. */
11532 set_tracepoint_count (int num)
11534 tracepoint_count = num;
11535 set_internalvar_integer (lookup_internalvar ("tpnum"), num);
11539 trace_command (char *arg, int from_tty)
11541 if (create_breakpoint (get_current_arch (),
11543 NULL, 0, 1 /* parse arg */,
11545 bp_tracepoint /* type_wanted */,
11546 0 /* Ignore count */,
11547 pending_break_support,
11552 set_tracepoint_count (breakpoint_count);
11556 ftrace_command (char *arg, int from_tty)
11558 if (create_breakpoint (get_current_arch (),
11560 NULL, 0, 1 /* parse arg */,
11562 bp_fast_tracepoint /* type_wanted */,
11563 0 /* Ignore count */,
11564 pending_break_support,
11569 set_tracepoint_count (breakpoint_count);
11572 /* strace command implementation. Creates a static tracepoint. */
11575 strace_command (char *arg, int from_tty)
11577 if (create_breakpoint (get_current_arch (),
11579 NULL, 0, 1 /* parse arg */,
11581 bp_static_tracepoint /* type_wanted */,
11582 0 /* Ignore count */,
11583 pending_break_support,
11588 set_tracepoint_count (breakpoint_count);
11591 /* Set up a fake reader function that gets command lines from a linked
11592 list that was acquired during tracepoint uploading. */
11594 static struct uploaded_tp *this_utp;
11595 static int next_cmd;
11598 read_uploaded_action (void)
11602 VEC_iterate (char_ptr, this_utp->cmd_strings, next_cmd, rslt);
11609 /* Given information about a tracepoint as recorded on a target (which
11610 can be either a live system or a trace file), attempt to create an
11611 equivalent GDB tracepoint. This is not a reliable process, since
11612 the target does not necessarily have all the information used when
11613 the tracepoint was originally defined. */
11615 struct breakpoint *
11616 create_tracepoint_from_upload (struct uploaded_tp *utp)
11618 char *addr_str, small_buf[100];
11619 struct breakpoint *tp;
11621 if (utp->at_string)
11622 addr_str = utp->at_string;
11625 /* In the absence of a source location, fall back to raw
11626 address. Since there is no way to confirm that the address
11627 means the same thing as when the trace was started, warn the
11629 warning (_("Uploaded tracepoint %d has no "
11630 "source location, using raw address"),
11632 sprintf (small_buf, "*%s", hex_string (utp->addr));
11633 addr_str = small_buf;
11636 /* There's not much we can do with a sequence of bytecodes. */
11637 if (utp->cond && !utp->cond_string)
11638 warning (_("Uploaded tracepoint %d condition "
11639 "has no source form, ignoring it"),
11642 if (!create_breakpoint (get_current_arch (),
11644 utp->cond_string, -1, 0 /* parse cond/thread */,
11646 utp->type /* type_wanted */,
11647 0 /* Ignore count */,
11648 pending_break_support,
11651 utp->enabled /* enabled */,
11655 set_tracepoint_count (breakpoint_count);
11657 /* Get the tracepoint we just created. */
11658 tp = get_tracepoint (tracepoint_count);
11659 gdb_assert (tp != NULL);
11663 sprintf (small_buf, "%d %d", utp->pass, tp->number);
11665 trace_pass_command (small_buf, 0);
11668 /* If we have uploaded versions of the original commands, set up a
11669 special-purpose "reader" function and call the usual command line
11670 reader, then pass the result to the breakpoint command-setting
11672 if (!VEC_empty (char_ptr, utp->cmd_strings))
11674 struct command_line *cmd_list;
11679 cmd_list = read_command_lines_1 (read_uploaded_action, 1, NULL, NULL);
11681 breakpoint_set_commands (tp, cmd_list);
11683 else if (!VEC_empty (char_ptr, utp->actions)
11684 || !VEC_empty (char_ptr, utp->step_actions))
11685 warning (_("Uploaded tracepoint %d actions "
11686 "have no source form, ignoring them"),
11692 /* Print information on tracepoint number TPNUM_EXP, or all if
11696 tracepoints_info (char *args, int from_tty)
11700 num_printed = breakpoint_1 (args, 0, is_tracepoint);
11702 if (num_printed == 0)
11704 if (args == NULL || *args == '\0')
11705 ui_out_message (uiout, 0, "No tracepoints.\n");
11707 ui_out_message (uiout, 0, "No tracepoint matching '%s'.\n", args);
11710 default_collect_info ();
11713 /* The 'enable trace' command enables tracepoints.
11714 Not supported by all targets. */
11716 enable_trace_command (char *args, int from_tty)
11718 enable_command (args, from_tty);
11721 /* The 'disable trace' command disables tracepoints.
11722 Not supported by all targets. */
11724 disable_trace_command (char *args, int from_tty)
11726 disable_command (args, from_tty);
11729 /* Remove a tracepoint (or all if no argument). */
11731 delete_trace_command (char *arg, int from_tty)
11733 struct breakpoint *b, *b_tmp;
11739 int breaks_to_delete = 0;
11741 /* Delete all breakpoints if no argument.
11742 Do not delete internal or call-dummy breakpoints, these
11743 have to be deleted with an explicit breakpoint number
11745 ALL_TRACEPOINTS (b)
11747 if (b->number >= 0)
11749 breaks_to_delete = 1;
11754 /* Ask user only if there are some breakpoints to delete. */
11756 || (breaks_to_delete && query (_("Delete all tracepoints? "))))
11758 ALL_BREAKPOINTS_SAFE (b, b_tmp)
11760 if (is_tracepoint (b)
11762 delete_breakpoint (b);
11767 map_breakpoint_numbers (arg, do_delete_breakpoint, NULL);
11770 /* Helper function for trace_pass_command. */
11773 trace_pass_set_count (struct breakpoint *bp, int count, int from_tty)
11775 bp->pass_count = count;
11776 observer_notify_tracepoint_modified (bp->number);
11778 printf_filtered (_("Setting tracepoint %d's passcount to %d\n"),
11779 bp->number, count);
11782 /* Set passcount for tracepoint.
11784 First command argument is passcount, second is tracepoint number.
11785 If tracepoint number omitted, apply to most recently defined.
11786 Also accepts special argument "all". */
11789 trace_pass_command (char *args, int from_tty)
11791 struct breakpoint *t1;
11792 unsigned int count;
11794 if (args == 0 || *args == 0)
11795 error (_("passcount command requires an "
11796 "argument (count + optional TP num)"));
11798 count = strtoul (args, &args, 10); /* Count comes first, then TP num. */
11800 while (*args && isspace ((int) *args))
11803 if (*args && strncasecmp (args, "all", 3) == 0)
11805 args += 3; /* Skip special argument "all". */
11807 error (_("Junk at end of arguments."));
11809 ALL_TRACEPOINTS (t1)
11811 trace_pass_set_count (t1, count, from_tty);
11814 else if (*args == '\0')
11816 t1 = get_tracepoint_by_number (&args, NULL, 1);
11818 trace_pass_set_count (t1, count, from_tty);
11822 struct get_number_or_range_state state;
11824 init_number_or_range (&state, args);
11825 while (!state.finished)
11827 t1 = get_tracepoint_by_number (&args, &state, 1);
11829 trace_pass_set_count (t1, count, from_tty);
11834 struct breakpoint *
11835 get_tracepoint (int num)
11837 struct breakpoint *t;
11839 ALL_TRACEPOINTS (t)
11840 if (t->number == num)
11846 /* Find the tracepoint with the given target-side number (which may be
11847 different from the tracepoint number after disconnecting and
11850 struct breakpoint *
11851 get_tracepoint_by_number_on_target (int num)
11853 struct breakpoint *t;
11855 ALL_TRACEPOINTS (t)
11856 if (t->number_on_target == num)
11862 /* Utility: parse a tracepoint number and look it up in the list.
11863 If STATE is not NULL, use, get_number_or_range_state and ignore ARG.
11864 If OPTIONAL_P is true, then if the argument is missing, the most
11865 recent tracepoint (tracepoint_count) is returned. */
11866 struct breakpoint *
11867 get_tracepoint_by_number (char **arg,
11868 struct get_number_or_range_state *state,
11871 extern int tracepoint_count;
11872 struct breakpoint *t;
11874 char *instring = arg == NULL ? NULL : *arg;
11878 gdb_assert (!state->finished);
11879 tpnum = get_number_or_range (state);
11881 else if (arg == NULL || *arg == NULL || ! **arg)
11884 tpnum = tracepoint_count;
11886 error_no_arg (_("tracepoint number"));
11889 tpnum = get_number (arg);
11893 if (instring && *instring)
11894 printf_filtered (_("bad tracepoint number at or near '%s'\n"),
11897 printf_filtered (_("Tracepoint argument missing "
11898 "and no previous tracepoint\n"));
11902 ALL_TRACEPOINTS (t)
11903 if (t->number == tpnum)
11908 printf_unfiltered ("No tracepoint number %d.\n", tpnum);
11912 /* Save information on user settable breakpoints (watchpoints, etc) to
11913 a new script file named FILENAME. If FILTER is non-NULL, call it
11914 on each breakpoint and only include the ones for which it returns
11918 save_breakpoints (char *filename, int from_tty,
11919 int (*filter) (const struct breakpoint *))
11921 struct breakpoint *tp;
11924 struct cleanup *cleanup;
11925 struct ui_file *fp;
11926 int extra_trace_bits = 0;
11928 if (filename == 0 || *filename == 0)
11929 error (_("Argument required (file name in which to save)"));
11931 /* See if we have anything to save. */
11932 ALL_BREAKPOINTS (tp)
11934 /* Skip internal and momentary breakpoints. */
11935 if (!user_breakpoint_p (tp))
11938 /* If we have a filter, only save the breakpoints it accepts. */
11939 if (filter && !filter (tp))
11944 if (is_tracepoint (tp))
11946 extra_trace_bits = 1;
11948 /* We can stop searching. */
11955 warning (_("Nothing to save."));
11959 pathname = tilde_expand (filename);
11960 cleanup = make_cleanup (xfree, pathname);
11961 fp = gdb_fopen (pathname, "w");
11963 error (_("Unable to open file '%s' for saving (%s)"),
11964 filename, safe_strerror (errno));
11965 make_cleanup_ui_file_delete (fp);
11967 if (extra_trace_bits)
11968 save_trace_state_variables (fp);
11970 ALL_BREAKPOINTS (tp)
11972 /* Skip internal and momentary breakpoints. */
11973 if (!user_breakpoint_p (tp))
11976 /* If we have a filter, only save the breakpoints it accepts. */
11977 if (filter && !filter (tp))
11980 if (tp->ops != NULL)
11981 (tp->ops->print_recreate) (tp, fp);
11984 if (tp->type == bp_fast_tracepoint)
11985 fprintf_unfiltered (fp, "ftrace");
11986 if (tp->type == bp_static_tracepoint)
11987 fprintf_unfiltered (fp, "strace");
11988 else if (tp->type == bp_tracepoint)
11989 fprintf_unfiltered (fp, "trace");
11990 else if (tp->type == bp_breakpoint && tp->disposition == disp_del)
11991 fprintf_unfiltered (fp, "tbreak");
11992 else if (tp->type == bp_breakpoint)
11993 fprintf_unfiltered (fp, "break");
11994 else if (tp->type == bp_hardware_breakpoint
11995 && tp->disposition == disp_del)
11996 fprintf_unfiltered (fp, "thbreak");
11997 else if (tp->type == bp_hardware_breakpoint)
11998 fprintf_unfiltered (fp, "hbreak");
11999 else if (tp->type == bp_watchpoint)
12000 fprintf_unfiltered (fp, "watch");
12001 else if (tp->type == bp_hardware_watchpoint)
12002 fprintf_unfiltered (fp, "watch");
12003 else if (tp->type == bp_read_watchpoint)
12004 fprintf_unfiltered (fp, "rwatch");
12005 else if (tp->type == bp_access_watchpoint)
12006 fprintf_unfiltered (fp, "awatch");
12008 internal_error (__FILE__, __LINE__,
12009 _("unhandled breakpoint type %d"), (int) tp->type);
12011 if (tp->exp_string)
12012 fprintf_unfiltered (fp, " %s", tp->exp_string);
12013 else if (tp->addr_string)
12014 fprintf_unfiltered (fp, " %s", tp->addr_string);
12019 sprintf_vma (tmp, tp->loc->address);
12020 fprintf_unfiltered (fp, " *0x%s", tmp);
12024 if (tp->thread != -1)
12025 fprintf_unfiltered (fp, " thread %d", tp->thread);
12028 fprintf_unfiltered (fp, " task %d", tp->task);
12030 fprintf_unfiltered (fp, "\n");
12032 /* Note, we can't rely on tp->number for anything, as we can't
12033 assume the recreated breakpoint numbers will match. Use $bpnum
12036 if (tp->cond_string)
12037 fprintf_unfiltered (fp, " condition $bpnum %s\n", tp->cond_string);
12039 if (tp->ignore_count)
12040 fprintf_unfiltered (fp, " ignore $bpnum %d\n", tp->ignore_count);
12042 if (tp->pass_count)
12043 fprintf_unfiltered (fp, " passcount %d\n", tp->pass_count);
12047 volatile struct gdb_exception ex;
12049 fprintf_unfiltered (fp, " commands\n");
12051 ui_out_redirect (uiout, fp);
12052 TRY_CATCH (ex, RETURN_MASK_ALL)
12054 print_command_lines (uiout, tp->commands->commands, 2);
12056 ui_out_redirect (uiout, NULL);
12059 throw_exception (ex);
12061 fprintf_unfiltered (fp, " end\n");
12064 if (tp->enable_state == bp_disabled)
12065 fprintf_unfiltered (fp, "disable\n");
12067 /* If this is a multi-location breakpoint, check if the locations
12068 should be individually disabled. Watchpoint locations are
12069 special, and not user visible. */
12070 if (!is_watchpoint (tp) && tp->loc && tp->loc->next)
12072 struct bp_location *loc;
12075 for (loc = tp->loc; loc != NULL; loc = loc->next, n++)
12077 fprintf_unfiltered (fp, "disable $bpnum.%d\n", n);
12081 if (extra_trace_bits && *default_collect)
12082 fprintf_unfiltered (fp, "set default-collect %s\n", default_collect);
12084 do_cleanups (cleanup);
12086 printf_filtered (_("Saved to file '%s'.\n"), filename);
12089 /* The `save breakpoints' command. */
12092 save_breakpoints_command (char *args, int from_tty)
12094 save_breakpoints (args, from_tty, NULL);
12097 /* The `save tracepoints' command. */
12100 save_tracepoints_command (char *args, int from_tty)
12102 save_breakpoints (args, from_tty, is_tracepoint);
12105 /* Create a vector of all tracepoints. */
12107 VEC(breakpoint_p) *
12108 all_tracepoints (void)
12110 VEC(breakpoint_p) *tp_vec = 0;
12111 struct breakpoint *tp;
12113 ALL_TRACEPOINTS (tp)
12115 VEC_safe_push (breakpoint_p, tp_vec, tp);
12122 /* This help string is used for the break, hbreak, tbreak and thbreak
12123 commands. It is defined as a macro to prevent duplication.
12124 COMMAND should be a string constant containing the name of the
12126 #define BREAK_ARGS_HELP(command) \
12127 command" [LOCATION] [thread THREADNUM] [if CONDITION]\n\
12128 LOCATION may be a line number, function name, or \"*\" and an address.\n\
12129 If a line number is specified, break at start of code for that line.\n\
12130 If a function is specified, break at start of code for that function.\n\
12131 If an address is specified, break at that exact address.\n\
12132 With no LOCATION, uses current execution address of the selected\n\
12133 stack frame. This is useful for breaking on return to a stack frame.\n\
12135 THREADNUM is the number from \"info threads\".\n\
12136 CONDITION is a boolean expression.\n\
12138 Multiple breakpoints at one place are permitted, and useful if their\n\
12139 conditions are different.\n\
12141 Do \"help breakpoints\" for info on other commands dealing with breakpoints."
12143 /* List of subcommands for "catch". */
12144 static struct cmd_list_element *catch_cmdlist;
12146 /* List of subcommands for "tcatch". */
12147 static struct cmd_list_element *tcatch_cmdlist;
12149 /* Like add_cmd, but add the command to both the "catch" and "tcatch"
12150 lists, and pass some additional user data to the command function. */
12152 add_catch_command (char *name, char *docstring,
12153 void (*sfunc) (char *args, int from_tty,
12154 struct cmd_list_element *command),
12155 char **(*completer) (struct cmd_list_element *cmd,
12156 char *text, char *word),
12157 void *user_data_catch,
12158 void *user_data_tcatch)
12160 struct cmd_list_element *command;
12162 command = add_cmd (name, class_breakpoint, NULL, docstring,
12164 set_cmd_sfunc (command, sfunc);
12165 set_cmd_context (command, user_data_catch);
12166 set_cmd_completer (command, completer);
12168 command = add_cmd (name, class_breakpoint, NULL, docstring,
12170 set_cmd_sfunc (command, sfunc);
12171 set_cmd_context (command, user_data_tcatch);
12172 set_cmd_completer (command, completer);
12176 clear_syscall_counts (struct inferior *inf)
12178 inf->total_syscalls_count = 0;
12179 inf->any_syscall_count = 0;
12180 VEC_free (int, inf->syscalls_counts);
12184 save_command (char *arg, int from_tty)
12186 printf_unfiltered (_("\"save\" must be followed by "
12187 "the name of a save subcommand.\n"));
12188 help_list (save_cmdlist, "save ", -1, gdb_stdout);
12191 struct breakpoint *
12192 iterate_over_breakpoints (int (*callback) (struct breakpoint *, void *),
12195 struct breakpoint *b, *b_tmp;
12197 ALL_BREAKPOINTS_SAFE (b, b_tmp)
12199 if ((*callback) (b, data))
12207 _initialize_breakpoint (void)
12209 struct cmd_list_element *c;
12211 observer_attach_solib_unloaded (disable_breakpoints_in_unloaded_shlib);
12212 observer_attach_inferior_exit (clear_syscall_counts);
12213 observer_attach_memory_changed (invalidate_bp_value_on_memory_change);
12215 breakpoint_objfile_key = register_objfile_data ();
12217 breakpoint_chain = 0;
12218 /* Don't bother to call set_breakpoint_count. $bpnum isn't useful
12219 before a breakpoint is set. */
12220 breakpoint_count = 0;
12222 tracepoint_count = 0;
12224 add_com ("ignore", class_breakpoint, ignore_command, _("\
12225 Set ignore-count of breakpoint number N to COUNT.\n\
12226 Usage is `ignore N COUNT'."));
12228 add_com_alias ("bc", "ignore", class_breakpoint, 1);
12230 add_com ("commands", class_breakpoint, commands_command, _("\
12231 Set commands to be executed when a breakpoint is hit.\n\
12232 Give breakpoint number as argument after \"commands\".\n\
12233 With no argument, the targeted breakpoint is the last one set.\n\
12234 The commands themselves follow starting on the next line.\n\
12235 Type a line containing \"end\" to indicate the end of them.\n\
12236 Give \"silent\" as the first line to make the breakpoint silent;\n\
12237 then no output is printed when it is hit, except what the commands print."));
12239 add_com ("condition", class_breakpoint, condition_command, _("\
12240 Specify breakpoint number N to break only if COND is true.\n\
12241 Usage is `condition N COND', where N is an integer and COND is an\n\
12242 expression to be evaluated whenever breakpoint N is reached."));
12244 c = add_com ("tbreak", class_breakpoint, tbreak_command, _("\
12245 Set a temporary breakpoint.\n\
12246 Like \"break\" except the breakpoint is only temporary,\n\
12247 so it will be deleted when hit. Equivalent to \"break\" followed\n\
12248 by using \"enable delete\" on the breakpoint number.\n\
12250 BREAK_ARGS_HELP ("tbreak")));
12251 set_cmd_completer (c, location_completer);
12253 c = add_com ("hbreak", class_breakpoint, hbreak_command, _("\
12254 Set a hardware assisted breakpoint.\n\
12255 Like \"break\" except the breakpoint requires hardware support,\n\
12256 some target hardware may not have this support.\n\
12258 BREAK_ARGS_HELP ("hbreak")));
12259 set_cmd_completer (c, location_completer);
12261 c = add_com ("thbreak", class_breakpoint, thbreak_command, _("\
12262 Set a temporary hardware assisted breakpoint.\n\
12263 Like \"hbreak\" except the breakpoint is only temporary,\n\
12264 so it will be deleted when hit.\n\
12266 BREAK_ARGS_HELP ("thbreak")));
12267 set_cmd_completer (c, location_completer);
12269 add_prefix_cmd ("enable", class_breakpoint, enable_command, _("\
12270 Enable some breakpoints.\n\
12271 Give breakpoint numbers (separated by spaces) as arguments.\n\
12272 With no subcommand, breakpoints are enabled until you command otherwise.\n\
12273 This is used to cancel the effect of the \"disable\" command.\n\
12274 With a subcommand you can enable temporarily."),
12275 &enablelist, "enable ", 1, &cmdlist);
12277 add_com ("ab", class_breakpoint, enable_command, _("\
12278 Enable some breakpoints.\n\
12279 Give breakpoint numbers (separated by spaces) as arguments.\n\
12280 With no subcommand, breakpoints are enabled until you command otherwise.\n\
12281 This is used to cancel the effect of the \"disable\" command.\n\
12282 With a subcommand you can enable temporarily."));
12284 add_com_alias ("en", "enable", class_breakpoint, 1);
12286 add_prefix_cmd ("breakpoints", class_breakpoint, enable_command, _("\
12287 Enable some breakpoints.\n\
12288 Give breakpoint numbers (separated by spaces) as arguments.\n\
12289 This is used to cancel the effect of the \"disable\" command.\n\
12290 May be abbreviated to simply \"enable\".\n"),
12291 &enablebreaklist, "enable breakpoints ", 1, &enablelist);
12293 add_cmd ("once", no_class, enable_once_command, _("\
12294 Enable breakpoints for one hit. Give breakpoint numbers.\n\
12295 If a breakpoint is hit while enabled in this fashion, it becomes disabled."),
12298 add_cmd ("delete", no_class, enable_delete_command, _("\
12299 Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
12300 If a breakpoint is hit while enabled in this fashion, it is deleted."),
12303 add_cmd ("delete", no_class, enable_delete_command, _("\
12304 Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
12305 If a breakpoint is hit while enabled in this fashion, it is deleted."),
12308 add_cmd ("once", no_class, enable_once_command, _("\
12309 Enable breakpoints for one hit. Give breakpoint numbers.\n\
12310 If a breakpoint is hit while enabled in this fashion, it becomes disabled."),
12313 add_prefix_cmd ("disable", class_breakpoint, disable_command, _("\
12314 Disable some breakpoints.\n\
12315 Arguments are breakpoint numbers with spaces in between.\n\
12316 To disable all breakpoints, give no argument.\n\
12317 A disabled breakpoint is not forgotten, but has no effect until reenabled."),
12318 &disablelist, "disable ", 1, &cmdlist);
12319 add_com_alias ("dis", "disable", class_breakpoint, 1);
12320 add_com_alias ("disa", "disable", class_breakpoint, 1);
12322 add_com ("sb", class_breakpoint, disable_command, _("\
12323 Disable some breakpoints.\n\
12324 Arguments are breakpoint numbers with spaces in between.\n\
12325 To disable all breakpoints, give no argument.\n\
12326 A disabled breakpoint is not forgotten, but has no effect until reenabled."));
12328 add_cmd ("breakpoints", class_alias, disable_command, _("\
12329 Disable some breakpoints.\n\
12330 Arguments are breakpoint numbers with spaces in between.\n\
12331 To disable all breakpoints, give no argument.\n\
12332 A disabled breakpoint is not forgotten, but has no effect until reenabled.\n\
12333 This command may be abbreviated \"disable\"."),
12336 add_prefix_cmd ("delete", class_breakpoint, delete_command, _("\
12337 Delete some breakpoints or auto-display expressions.\n\
12338 Arguments are breakpoint numbers with spaces in between.\n\
12339 To delete all breakpoints, give no argument.\n\
12341 Also a prefix command for deletion of other GDB objects.\n\
12342 The \"unset\" command is also an alias for \"delete\"."),
12343 &deletelist, "delete ", 1, &cmdlist);
12344 add_com_alias ("d", "delete", class_breakpoint, 1);
12345 add_com_alias ("del", "delete", class_breakpoint, 1);
12347 add_com ("db", class_breakpoint, delete_command, _("\
12348 Delete some breakpoints.\n\
12349 Arguments are breakpoint numbers with spaces in between.\n\
12350 To delete all breakpoints, give no argument.\n"));
12352 add_cmd ("breakpoints", class_alias, delete_command, _("\
12353 Delete some breakpoints or auto-display expressions.\n\
12354 Arguments are breakpoint numbers with spaces in between.\n\
12355 To delete all breakpoints, give no argument.\n\
12356 This command may be abbreviated \"delete\"."),
12359 add_com ("clear", class_breakpoint, clear_command, _("\
12360 Clear breakpoint at specified line or function.\n\
12361 Argument may be line number, function name, or \"*\" and an address.\n\
12362 If line number is specified, all breakpoints in that line are cleared.\n\
12363 If function is specified, breakpoints at beginning of function are cleared.\n\
12364 If an address is specified, breakpoints at that address are cleared.\n\
12366 With no argument, clears all breakpoints in the line that the selected frame\n\
12367 is executing in.\n\
12369 See also the \"delete\" command which clears breakpoints by number."));
12370 add_com_alias ("cl", "clear", class_breakpoint, 1);
12372 c = add_com ("break", class_breakpoint, break_command, _("\
12373 Set breakpoint at specified line or function.\n"
12374 BREAK_ARGS_HELP ("break")));
12375 set_cmd_completer (c, location_completer);
12377 add_com_alias ("b", "break", class_run, 1);
12378 add_com_alias ("br", "break", class_run, 1);
12379 add_com_alias ("bre", "break", class_run, 1);
12380 add_com_alias ("brea", "break", class_run, 1);
12383 add_com_alias ("ba", "break", class_breakpoint, 1);
12387 add_abbrev_prefix_cmd ("stop", class_breakpoint, stop_command, _("\
12388 Break in function/address or break at a line in the current file."),
12389 &stoplist, "stop ", 1, &cmdlist);
12390 add_cmd ("in", class_breakpoint, stopin_command,
12391 _("Break in function or address."), &stoplist);
12392 add_cmd ("at", class_breakpoint, stopat_command,
12393 _("Break at a line in the current file."), &stoplist);
12394 add_com ("status", class_info, breakpoints_info, _("\
12395 Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
12396 The \"Type\" column indicates one of:\n\
12397 \tbreakpoint - normal breakpoint\n\
12398 \twatchpoint - watchpoint\n\
12399 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
12400 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
12401 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
12402 address and file/line number respectively.\n\
12404 Convenience variable \"$_\" and default examine address for \"x\"\n\
12405 are set to the address of the last breakpoint listed unless the command\n\
12406 is prefixed with \"server \".\n\n\
12407 Convenience variable \"$bpnum\" contains the number of the last\n\
12408 breakpoint set."));
12411 add_info ("breakpoints", breakpoints_info, _("\
12412 Status of specified breakpoints (all user-settable breakpoints if no argument).\n\
12413 The \"Type\" column indicates one of:\n\
12414 \tbreakpoint - normal breakpoint\n\
12415 \twatchpoint - watchpoint\n\
12416 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
12417 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
12418 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
12419 address and file/line number respectively.\n\
12421 Convenience variable \"$_\" and default examine address for \"x\"\n\
12422 are set to the address of the last breakpoint listed unless the command\n\
12423 is prefixed with \"server \".\n\n\
12424 Convenience variable \"$bpnum\" contains the number of the last\n\
12425 breakpoint set."));
12427 add_info_alias ("b", "breakpoints", 1);
12430 add_com ("lb", class_breakpoint, breakpoints_info, _("\
12431 Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
12432 The \"Type\" column indicates one of:\n\
12433 \tbreakpoint - normal breakpoint\n\
12434 \twatchpoint - watchpoint\n\
12435 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
12436 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
12437 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
12438 address and file/line number respectively.\n\
12440 Convenience variable \"$_\" and default examine address for \"x\"\n\
12441 are set to the address of the last breakpoint listed unless the command\n\
12442 is prefixed with \"server \".\n\n\
12443 Convenience variable \"$bpnum\" contains the number of the last\n\
12444 breakpoint set."));
12446 add_cmd ("breakpoints", class_maintenance, maintenance_info_breakpoints, _("\
12447 Status of all breakpoints, or breakpoint number NUMBER.\n\
12448 The \"Type\" column indicates one of:\n\
12449 \tbreakpoint - normal breakpoint\n\
12450 \twatchpoint - watchpoint\n\
12451 \tlongjmp - internal breakpoint used to step through longjmp()\n\
12452 \tlongjmp resume - internal breakpoint at the target of longjmp()\n\
12453 \tuntil - internal breakpoint used by the \"until\" command\n\
12454 \tfinish - internal breakpoint used by the \"finish\" command\n\
12455 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
12456 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
12457 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
12458 address and file/line number respectively.\n\
12460 Convenience variable \"$_\" and default examine address for \"x\"\n\
12461 are set to the address of the last breakpoint listed unless the command\n\
12462 is prefixed with \"server \".\n\n\
12463 Convenience variable \"$bpnum\" contains the number of the last\n\
12465 &maintenanceinfolist);
12467 add_prefix_cmd ("catch", class_breakpoint, catch_command, _("\
12468 Set catchpoints to catch events."),
12469 &catch_cmdlist, "catch ",
12470 0/*allow-unknown*/, &cmdlist);
12472 add_prefix_cmd ("tcatch", class_breakpoint, tcatch_command, _("\
12473 Set temporary catchpoints to catch events."),
12474 &tcatch_cmdlist, "tcatch ",
12475 0/*allow-unknown*/, &cmdlist);
12477 /* Add catch and tcatch sub-commands. */
12478 add_catch_command ("catch", _("\
12479 Catch an exception, when caught.\n\
12480 With an argument, catch only exceptions with the given name."),
12481 catch_catch_command,
12485 add_catch_command ("throw", _("\
12486 Catch an exception, when thrown.\n\
12487 With an argument, catch only exceptions with the given name."),
12488 catch_throw_command,
12492 add_catch_command ("fork", _("Catch calls to fork."),
12493 catch_fork_command_1,
12495 (void *) (uintptr_t) catch_fork_permanent,
12496 (void *) (uintptr_t) catch_fork_temporary);
12497 add_catch_command ("vfork", _("Catch calls to vfork."),
12498 catch_fork_command_1,
12500 (void *) (uintptr_t) catch_vfork_permanent,
12501 (void *) (uintptr_t) catch_vfork_temporary);
12502 add_catch_command ("exec", _("Catch calls to exec."),
12503 catch_exec_command_1,
12507 add_catch_command ("syscall", _("\
12508 Catch system calls by their names and/or numbers.\n\
12509 Arguments say which system calls to catch. If no arguments\n\
12510 are given, every system call will be caught.\n\
12511 Arguments, if given, should be one or more system call names\n\
12512 (if your system supports that), or system call numbers."),
12513 catch_syscall_command_1,
12514 catch_syscall_completer,
12517 add_catch_command ("exception", _("\
12518 Catch Ada exceptions, when raised.\n\
12519 With an argument, catch only exceptions with the given name."),
12520 catch_ada_exception_command,
12524 add_catch_command ("assert", _("\
12525 Catch failed Ada assertions, when raised.\n\
12526 With an argument, catch only exceptions with the given name."),
12527 catch_assert_command,
12532 c = add_com ("watch", class_breakpoint, watch_command, _("\
12533 Set a watchpoint for an expression.\n\
12534 Usage: watch [-l|-location] EXPRESSION\n\
12535 A watchpoint stops execution of your program whenever the value of\n\
12536 an expression changes.\n\
12537 If -l or -location is given, this evaluates EXPRESSION and watches\n\
12538 the memory to which it refers."));
12539 set_cmd_completer (c, expression_completer);
12541 c = add_com ("rwatch", class_breakpoint, rwatch_command, _("\
12542 Set a read watchpoint for an expression.\n\
12543 Usage: rwatch [-l|-location] EXPRESSION\n\
12544 A watchpoint stops execution of your program whenever the value of\n\
12545 an expression is read.\n\
12546 If -l or -location is given, this evaluates EXPRESSION and watches\n\
12547 the memory to which it refers."));
12548 set_cmd_completer (c, expression_completer);
12550 c = add_com ("awatch", class_breakpoint, awatch_command, _("\
12551 Set a watchpoint for an expression.\n\
12552 Usage: awatch [-l|-location] EXPRESSION\n\
12553 A watchpoint stops execution of your program whenever the value of\n\
12554 an expression is either read or written.\n\
12555 If -l or -location is given, this evaluates EXPRESSION and watches\n\
12556 the memory to which it refers."));
12557 set_cmd_completer (c, expression_completer);
12559 add_info ("watchpoints", watchpoints_info, _("\
12560 Status of specified watchpoints (all watchpoints if no argument)."));
12562 /* XXX: cagney/2005-02-23: This should be a boolean, and should
12563 respond to changes - contrary to the description. */
12564 add_setshow_zinteger_cmd ("can-use-hw-watchpoints", class_support,
12565 &can_use_hw_watchpoints, _("\
12566 Set debugger's willingness to use watchpoint hardware."), _("\
12567 Show debugger's willingness to use watchpoint hardware."), _("\
12568 If zero, gdb will not use hardware for new watchpoints, even if\n\
12569 such is available. (However, any hardware watchpoints that were\n\
12570 created before setting this to nonzero, will continue to use watchpoint\n\
12573 show_can_use_hw_watchpoints,
12574 &setlist, &showlist);
12576 can_use_hw_watchpoints = 1;
12578 /* Tracepoint manipulation commands. */
12580 c = add_com ("trace", class_breakpoint, trace_command, _("\
12581 Set a tracepoint at specified line or function.\n\
12583 BREAK_ARGS_HELP ("trace") "\n\
12584 Do \"help tracepoints\" for info on other tracepoint commands."));
12585 set_cmd_completer (c, location_completer);
12587 add_com_alias ("tp", "trace", class_alias, 0);
12588 add_com_alias ("tr", "trace", class_alias, 1);
12589 add_com_alias ("tra", "trace", class_alias, 1);
12590 add_com_alias ("trac", "trace", class_alias, 1);
12592 c = add_com ("ftrace", class_breakpoint, ftrace_command, _("\
12593 Set a fast tracepoint at specified line or function.\n\
12595 BREAK_ARGS_HELP ("ftrace") "\n\
12596 Do \"help tracepoints\" for info on other tracepoint commands."));
12597 set_cmd_completer (c, location_completer);
12599 c = add_com ("strace", class_breakpoint, strace_command, _("\
12600 Set a static tracepoint at specified line, function or marker.\n\
12602 strace [LOCATION] [if CONDITION]\n\
12603 LOCATION may be a line number, function name, \"*\" and an address,\n\
12604 or -m MARKER_ID.\n\
12605 If a line number is specified, probe the marker at start of code\n\
12606 for that line. If a function is specified, probe the marker at start\n\
12607 of code for that function. If an address is specified, probe the marker\n\
12608 at that exact address. If a marker id is specified, probe the marker\n\
12609 with that name. With no LOCATION, uses current execution address of\n\
12610 the selected stack frame.\n\
12611 Static tracepoints accept an extra collect action -- ``collect $_sdata''.\n\
12612 This collects arbitrary user data passed in the probe point call to the\n\
12613 tracing library. You can inspect it when analyzing the trace buffer,\n\
12614 by printing the $_sdata variable like any other convenience variable.\n\
12616 CONDITION is a boolean expression.\n\
12618 Multiple tracepoints at one place are permitted, and useful if their\n\
12619 conditions are different.\n\
12621 Do \"help breakpoints\" for info on other commands dealing with breakpoints.\n\
12622 Do \"help tracepoints\" for info on other tracepoint commands."));
12623 set_cmd_completer (c, location_completer);
12625 add_info ("tracepoints", tracepoints_info, _("\
12626 Status of specified tracepoints (all tracepoints if no argument).\n\
12627 Convenience variable \"$tpnum\" contains the number of the\n\
12628 last tracepoint set."));
12630 add_info_alias ("tp", "tracepoints", 1);
12632 add_cmd ("tracepoints", class_trace, delete_trace_command, _("\
12633 Delete specified tracepoints.\n\
12634 Arguments are tracepoint numbers, separated by spaces.\n\
12635 No argument means delete all tracepoints."),
12638 c = add_cmd ("tracepoints", class_trace, disable_trace_command, _("\
12639 Disable specified tracepoints.\n\
12640 Arguments are tracepoint numbers, separated by spaces.\n\
12641 No argument means disable all tracepoints."),
12643 deprecate_cmd (c, "disable");
12645 c = add_cmd ("tracepoints", class_trace, enable_trace_command, _("\
12646 Enable specified tracepoints.\n\
12647 Arguments are tracepoint numbers, separated by spaces.\n\
12648 No argument means enable all tracepoints."),
12650 deprecate_cmd (c, "enable");
12652 add_com ("passcount", class_trace, trace_pass_command, _("\
12653 Set the passcount for a tracepoint.\n\
12654 The trace will end when the tracepoint has been passed 'count' times.\n\
12655 Usage: passcount COUNT TPNUM, where TPNUM may also be \"all\";\n\
12656 if TPNUM is omitted, passcount refers to the last tracepoint defined."));
12658 add_prefix_cmd ("save", class_breakpoint, save_command,
12659 _("Save breakpoint definitions as a script."),
12660 &save_cmdlist, "save ",
12661 0/*allow-unknown*/, &cmdlist);
12663 c = add_cmd ("breakpoints", class_breakpoint, save_breakpoints_command, _("\
12664 Save current breakpoint definitions as a script.\n\
12665 This includes all types of breakpoints (breakpoints, watchpoints,\n\
12666 catchpoints, tracepoints). Use the 'source' command in another debug\n\
12667 session to restore them."),
12669 set_cmd_completer (c, filename_completer);
12671 c = add_cmd ("tracepoints", class_trace, save_tracepoints_command, _("\
12672 Save current tracepoint definitions as a script.\n\
12673 Use the 'source' command in another debug session to restore them."),
12675 set_cmd_completer (c, filename_completer);
12677 c = add_com_alias ("save-tracepoints", "save tracepoints", class_trace, 0);
12678 deprecate_cmd (c, "save tracepoints");
12680 add_prefix_cmd ("breakpoint", class_maintenance, set_breakpoint_cmd, _("\
12681 Breakpoint specific settings\n\
12682 Configure various breakpoint-specific variables such as\n\
12683 pending breakpoint behavior"),
12684 &breakpoint_set_cmdlist, "set breakpoint ",
12685 0/*allow-unknown*/, &setlist);
12686 add_prefix_cmd ("breakpoint", class_maintenance, show_breakpoint_cmd, _("\
12687 Breakpoint specific settings\n\
12688 Configure various breakpoint-specific variables such as\n\
12689 pending breakpoint behavior"),
12690 &breakpoint_show_cmdlist, "show breakpoint ",
12691 0/*allow-unknown*/, &showlist);
12693 add_setshow_auto_boolean_cmd ("pending", no_class,
12694 &pending_break_support, _("\
12695 Set debugger's behavior regarding pending breakpoints."), _("\
12696 Show debugger's behavior regarding pending breakpoints."), _("\
12697 If on, an unrecognized breakpoint location will cause gdb to create a\n\
12698 pending breakpoint. If off, an unrecognized breakpoint location results in\n\
12699 an error. If auto, an unrecognized breakpoint location results in a\n\
12700 user-query to see if a pending breakpoint should be created."),
12702 show_pending_break_support,
12703 &breakpoint_set_cmdlist,
12704 &breakpoint_show_cmdlist);
12706 pending_break_support = AUTO_BOOLEAN_AUTO;
12708 add_setshow_boolean_cmd ("auto-hw", no_class,
12709 &automatic_hardware_breakpoints, _("\
12710 Set automatic usage of hardware breakpoints."), _("\
12711 Show automatic usage of hardware breakpoints."), _("\
12712 If set, the debugger will automatically use hardware breakpoints for\n\
12713 breakpoints set with \"break\" but falling in read-only memory. If not set,\n\
12714 a warning will be emitted for such breakpoints."),
12716 show_automatic_hardware_breakpoints,
12717 &breakpoint_set_cmdlist,
12718 &breakpoint_show_cmdlist);
12720 add_setshow_enum_cmd ("always-inserted", class_support,
12721 always_inserted_enums, &always_inserted_mode, _("\
12722 Set mode for inserting breakpoints."), _("\
12723 Show mode for inserting breakpoints."), _("\
12724 When this mode is off, breakpoints are inserted in inferior when it is\n\
12725 resumed, and removed when execution stops. When this mode is on,\n\
12726 breakpoints are inserted immediately and removed only when the user\n\
12727 deletes the breakpoint. When this mode is auto (which is the default),\n\
12728 the behaviour depends on the non-stop setting (see help set non-stop).\n\
12729 In this case, if gdb is controlling the inferior in non-stop mode, gdb\n\
12730 behaves as if always-inserted mode is on; if gdb is controlling the\n\
12731 inferior in all-stop mode, gdb behaves as if always-inserted mode is off."),
12733 &show_always_inserted_mode,
12734 &breakpoint_set_cmdlist,
12735 &breakpoint_show_cmdlist);
12737 automatic_hardware_breakpoints = 1;
12739 observer_attach_about_to_proceed (breakpoint_about_to_proceed);