1 /* Everything about breakpoints, for GDB.
3 Copyright (C) 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
4 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
5 2008, 2009, 2010 Free Software Foundation, Inc.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
23 #include "arch-utils.h"
28 #include "breakpoint.h"
29 #include "tracepoint.h"
31 #include "expression.h"
37 #include "gdbthread.h"
40 #include "gdb_string.h"
47 #include "completer.h"
50 #include "cli/cli-script.h"
51 #include "gdb_assert.h"
56 #include "exceptions.h"
63 #include "xml-syscall.h"
65 /* readline include files */
66 #include "readline/readline.h"
67 #include "readline/history.h"
69 /* readline defines this. */
72 #include "mi/mi-common.h"
74 /* Arguments to pass as context to some catch command handlers. */
75 #define CATCH_PERMANENT ((void *) (uintptr_t) 0)
76 #define CATCH_TEMPORARY ((void *) (uintptr_t) 1)
78 /* Prototypes for local functions. */
80 static void enable_delete_command (char *, int);
82 static void enable_delete_breakpoint (struct breakpoint *);
84 static void enable_once_command (char *, int);
86 static void enable_once_breakpoint (struct breakpoint *);
88 static void disable_command (char *, int);
90 static void enable_command (char *, int);
92 static void map_breakpoint_numbers (char *, void (*)(struct breakpoint *));
94 static void ignore_command (char *, int);
96 static int breakpoint_re_set_one (void *);
98 static void clear_command (char *, int);
100 static void catch_command (char *, int);
102 static void watch_command (char *, int);
104 static int can_use_hardware_watchpoint (struct value *);
106 static void break_command_1 (char *, int, int);
108 static void mention (struct breakpoint *);
110 /* This function is used in gdbtk sources and thus can not be made static. */
111 struct breakpoint *set_raw_breakpoint (struct gdbarch *gdbarch,
112 struct symtab_and_line,
115 static void breakpoint_adjustment_warning (CORE_ADDR, CORE_ADDR, int, int);
117 static CORE_ADDR adjust_breakpoint_address (struct gdbarch *gdbarch,
121 static void describe_other_breakpoints (struct gdbarch *,
122 struct program_space *, CORE_ADDR,
123 struct obj_section *, int);
125 static int breakpoint_address_match (struct address_space *aspace1,
127 struct address_space *aspace2,
130 static void breakpoints_info (char *, int);
132 static void breakpoint_1 (int, int);
134 static bpstat bpstat_alloc (const struct bp_location *, bpstat);
136 static int breakpoint_cond_eval (void *);
138 static void cleanup_executing_breakpoints (void *);
140 static void commands_command (char *, int);
142 static void condition_command (char *, int);
144 static int get_number_trailer (char **, int);
146 void set_breakpoint_count (int);
155 static int remove_breakpoint (struct bp_location *, insertion_state_t);
156 static int remove_breakpoint_1 (struct bp_location *, insertion_state_t);
158 static enum print_stop_action print_it_typical (bpstat);
160 static enum print_stop_action print_bp_stop_message (bpstat bs);
162 static int watchpoint_check (void *);
164 static void maintenance_info_breakpoints (char *, int);
166 static int hw_breakpoint_used_count (void);
168 static int hw_watchpoint_used_count (enum bptype, int *);
170 static void hbreak_command (char *, int);
172 static void thbreak_command (char *, int);
174 static void watch_command_1 (char *, int, int);
176 static void rwatch_command (char *, int);
178 static void awatch_command (char *, int);
180 static void do_enable_breakpoint (struct breakpoint *, enum bpdisp);
182 static void stop_command (char *arg, int from_tty);
184 static void stopin_command (char *arg, int from_tty);
186 static void stopat_command (char *arg, int from_tty);
188 static char *ep_parse_optional_if_clause (char **arg);
190 static char *ep_parse_optional_filename (char **arg);
192 static void catch_exception_command_1 (enum exception_event_kind ex_event,
193 char *arg, int tempflag, int from_tty);
195 static void tcatch_command (char *arg, int from_tty);
197 static void ep_skip_leading_whitespace (char **s);
199 static int single_step_breakpoint_inserted_here_p (struct address_space *,
202 static void free_bp_location (struct bp_location *loc);
204 static struct bp_location *allocate_bp_location (struct breakpoint *bpt);
206 static void update_global_location_list (int);
208 static void update_global_location_list_nothrow (int);
210 static int is_hardware_watchpoint (struct breakpoint *bpt);
212 static void insert_breakpoint_locations (void);
214 static int syscall_catchpoint_p (struct breakpoint *b);
216 static void tracepoints_info (char *, int);
218 static void delete_trace_command (char *, int);
220 static void enable_trace_command (char *, int);
222 static void disable_trace_command (char *, int);
224 static void trace_pass_command (char *, int);
226 static void skip_prologue_sal (struct symtab_and_line *sal);
229 /* Flag indicating that a command has proceeded the inferior past the
230 current breakpoint. */
232 static int breakpoint_proceeded;
235 bpdisp_text (enum bpdisp disp)
237 /* NOTE: the following values are a part of MI protocol and represent
238 values of 'disp' field returned when inferior stops at a breakpoint. */
239 static char *bpdisps[] = {"del", "dstp", "dis", "keep"};
240 return bpdisps[(int) disp];
243 /* Prototypes for exported functions. */
244 /* If FALSE, gdb will not use hardware support for watchpoints, even
245 if such is available. */
246 static int can_use_hw_watchpoints;
249 show_can_use_hw_watchpoints (struct ui_file *file, int from_tty,
250 struct cmd_list_element *c,
253 fprintf_filtered (file, _("\
254 Debugger's willingness to use watchpoint hardware is %s.\n"),
258 /* If AUTO_BOOLEAN_FALSE, gdb will not attempt to create pending breakpoints.
259 If AUTO_BOOLEAN_TRUE, gdb will automatically create pending breakpoints
260 for unrecognized breakpoint locations.
261 If AUTO_BOOLEAN_AUTO, gdb will query when breakpoints are unrecognized. */
262 static enum auto_boolean pending_break_support;
264 show_pending_break_support (struct ui_file *file, int from_tty,
265 struct cmd_list_element *c,
268 fprintf_filtered (file, _("\
269 Debugger's behavior regarding pending breakpoints is %s.\n"),
273 /* If 1, gdb will automatically use hardware breakpoints for breakpoints
274 set with "break" but falling in read-only memory.
275 If 0, gdb will warn about such breakpoints, but won't automatically
276 use hardware breakpoints. */
277 static int automatic_hardware_breakpoints;
279 show_automatic_hardware_breakpoints (struct ui_file *file, int from_tty,
280 struct cmd_list_element *c,
283 fprintf_filtered (file, _("\
284 Automatic usage of hardware breakpoints is %s.\n"),
288 /* If on, gdb will keep breakpoints inserted even as inferior is
289 stopped, and immediately insert any new breakpoints. If off, gdb
290 will insert breakpoints into inferior only when resuming it, and
291 will remove breakpoints upon stop. If auto, GDB will behave as ON
292 if in non-stop mode, and as OFF if all-stop mode.*/
294 static const char always_inserted_auto[] = "auto";
295 static const char always_inserted_on[] = "on";
296 static const char always_inserted_off[] = "off";
297 static const char *always_inserted_enums[] = {
298 always_inserted_auto,
303 static const char *always_inserted_mode = always_inserted_auto;
305 show_always_inserted_mode (struct ui_file *file, int from_tty,
306 struct cmd_list_element *c, const char *value)
308 if (always_inserted_mode == always_inserted_auto)
309 fprintf_filtered (file, _("\
310 Always inserted breakpoint mode is %s (currently %s).\n"),
312 breakpoints_always_inserted_mode () ? "on" : "off");
314 fprintf_filtered (file, _("Always inserted breakpoint mode is %s.\n"), value);
318 breakpoints_always_inserted_mode (void)
320 return (always_inserted_mode == always_inserted_on
321 || (always_inserted_mode == always_inserted_auto && non_stop));
324 void _initialize_breakpoint (void);
326 /* Are we executing breakpoint commands? */
327 static int executing_breakpoint_commands;
329 /* Are overlay event breakpoints enabled? */
330 static int overlay_events_enabled;
332 /* Walk the following statement or block through all breakpoints.
333 ALL_BREAKPOINTS_SAFE does so even if the statment deletes the current
336 #define ALL_BREAKPOINTS(B) for (B = breakpoint_chain; B; B = B->next)
338 #define ALL_BREAKPOINTS_SAFE(B,TMP) \
339 for (B = breakpoint_chain; \
340 B ? (TMP=B->next, 1): 0; \
343 /* Similar iterator for the low-level breakpoints. SAFE variant is not
344 provided so update_global_location_list must not be called while executing
345 the block of ALL_BP_LOCATIONS. */
347 #define ALL_BP_LOCATIONS(B,BP_TMP) \
348 for (BP_TMP = bp_location; \
349 BP_TMP < bp_location + bp_location_count && (B = *BP_TMP); \
352 /* Iterator for tracepoints only. */
354 #define ALL_TRACEPOINTS(B) \
355 for (B = breakpoint_chain; B; B = B->next) \
356 if ((B)->type == bp_tracepoint)
358 /* Chains of all breakpoints defined. */
360 struct breakpoint *breakpoint_chain;
362 /* Array is sorted by bp_location_compare - primarily by the ADDRESS. */
364 static struct bp_location **bp_location;
366 /* Number of elements of BP_LOCATION. */
368 static unsigned bp_location_count;
370 /* Maximum alignment offset between bp_target_info.PLACED_ADDRESS and ADDRESS
371 for the current elements of BP_LOCATION which get a valid result from
372 bp_location_has_shadow. You can use it for roughly limiting the subrange of
373 BP_LOCATION to scan for shadow bytes for an address you need to read. */
375 static CORE_ADDR bp_location_placed_address_before_address_max;
377 /* Maximum offset plus alignment between
378 bp_target_info.PLACED_ADDRESS + bp_target_info.SHADOW_LEN and ADDRESS for
379 the current elements of BP_LOCATION which get a valid result from
380 bp_location_has_shadow. You can use it for roughly limiting the subrange of
381 BP_LOCATION to scan for shadow bytes for an address you need to read. */
383 static CORE_ADDR bp_location_shadow_len_after_address_max;
385 /* The locations that no longer correspond to any breakpoint,
386 unlinked from bp_location array, but for which a hit
387 may still be reported by a target. */
388 VEC(bp_location_p) *moribund_locations = NULL;
390 /* Number of last breakpoint made. */
392 int breakpoint_count;
394 /* Number of last tracepoint made. */
396 int tracepoint_count;
398 /* Return whether a breakpoint is an active enabled breakpoint. */
400 breakpoint_enabled (struct breakpoint *b)
402 return (b->enable_state == bp_enabled);
405 /* Set breakpoint count to NUM. */
408 set_breakpoint_count (int num)
410 breakpoint_count = num;
411 set_internalvar_integer (lookup_internalvar ("bpnum"), num);
414 /* Used in run_command to zero the hit count when a new run starts. */
417 clear_breakpoint_hit_counts (void)
419 struct breakpoint *b;
425 /* Default address, symtab and line to put a breakpoint at
426 for "break" command with no arg.
427 if default_breakpoint_valid is zero, the other three are
428 not valid, and "break" with no arg is an error.
430 This set by print_stack_frame, which calls set_default_breakpoint. */
432 int default_breakpoint_valid;
433 CORE_ADDR default_breakpoint_address;
434 struct symtab *default_breakpoint_symtab;
435 int default_breakpoint_line;
436 struct program_space *default_breakpoint_pspace;
439 /* *PP is a string denoting a breakpoint. Get the number of the breakpoint.
440 Advance *PP after the string and any trailing whitespace.
442 Currently the string can either be a number or "$" followed by the name
443 of a convenience variable. Making it an expression wouldn't work well
444 for map_breakpoint_numbers (e.g. "4 + 5 + 6").
446 If the string is a NULL pointer, that denotes the last breakpoint.
448 TRAILER is a character which can be found after the number; most
449 commonly this is `-'. If you don't want a trailer, use \0. */
451 get_number_trailer (char **pp, int trailer)
453 int retval = 0; /* default */
457 /* Empty line means refer to the last breakpoint. */
458 return breakpoint_count;
461 /* Make a copy of the name, so we can null-terminate it
462 to pass to lookup_internalvar(). */
467 while (isalnum (*p) || *p == '_')
469 varname = (char *) alloca (p - start + 1);
470 strncpy (varname, start, p - start);
471 varname[p - start] = '\0';
472 if (get_internalvar_integer (lookup_internalvar (varname), &val))
476 printf_filtered (_("Convenience variable must have integer value.\n"));
484 while (*p >= '0' && *p <= '9')
487 /* There is no number here. (e.g. "cond a == b"). */
489 /* Skip non-numeric token */
490 while (*p && !isspace((int) *p))
492 /* Return zero, which caller must interpret as error. */
498 if (!(isspace (*p) || *p == '\0' || *p == trailer))
500 /* Trailing junk: return 0 and let caller print error msg. */
501 while (!(isspace (*p) || *p == '\0' || *p == trailer))
512 /* Like get_number_trailer, but don't allow a trailer. */
514 get_number (char **pp)
516 return get_number_trailer (pp, '\0');
519 /* Parse a number or a range.
520 * A number will be of the form handled by get_number.
521 * A range will be of the form <number1> - <number2>, and
522 * will represent all the integers between number1 and number2,
525 * While processing a range, this fuction is called iteratively;
526 * At each call it will return the next value in the range.
528 * At the beginning of parsing a range, the char pointer PP will
529 * be advanced past <number1> and left pointing at the '-' token.
530 * Subsequent calls will not advance the pointer until the range
531 * is completed. The call that completes the range will advance
532 * pointer PP past <number2>.
536 get_number_or_range (char **pp)
538 static int last_retval, end_value;
539 static char *end_ptr;
540 static int in_range = 0;
544 /* Default case: pp is pointing either to a solo number,
545 or to the first number of a range. */
546 last_retval = get_number_trailer (pp, '-');
551 /* This is the start of a range (<number1> - <number2>).
552 Skip the '-', parse and remember the second number,
553 and also remember the end of the final token. */
557 while (isspace ((int) *end_ptr))
558 end_ptr++; /* skip white space */
559 end_value = get_number (temp);
560 if (end_value < last_retval)
562 error (_("inverted range"));
564 else if (end_value == last_retval)
566 /* degenerate range (number1 == number2). Advance the
567 token pointer so that the range will be treated as a
576 error (_("negative value"));
579 /* pp points to the '-' that betokens a range. All
580 number-parsing has already been done. Return the next
581 integer value (one greater than the saved previous value).
582 Do not advance the token pointer 'pp' until the end of range
585 if (++last_retval == end_value)
587 /* End of range reached; advance token pointer. */
595 /* Return the breakpoint with the specified number, or NULL
596 if the number does not refer to an existing breakpoint. */
599 get_breakpoint (int num)
601 struct breakpoint *b;
604 if (b->number == num)
611 /* condition N EXP -- set break condition of breakpoint N to EXP. */
614 condition_command (char *arg, int from_tty)
616 struct breakpoint *b;
621 error_no_arg (_("breakpoint number"));
624 bnum = get_number (&p);
626 error (_("Bad breakpoint argument: '%s'"), arg);
629 if (b->number == bnum)
631 struct bp_location *loc = b->loc;
632 for (; loc; loc = loc->next)
640 if (b->cond_string != NULL)
641 xfree (b->cond_string);
645 b->cond_string = NULL;
647 printf_filtered (_("Breakpoint %d now unconditional.\n"), bnum);
652 /* I don't know if it matters whether this is the string the user
653 typed in or the decompiled expression. */
654 b->cond_string = xstrdup (arg);
655 b->condition_not_parsed = 0;
656 for (loc = b->loc; loc; loc = loc->next)
660 parse_exp_1 (&arg, block_for_pc (loc->address), 0);
662 error (_("Junk at end of expression"));
665 breakpoints_changed ();
666 observer_notify_breakpoint_modified (b->number);
670 error (_("No breakpoint number %d."), bnum);
673 /* Set the command list of B to COMMANDS. */
676 breakpoint_set_commands (struct breakpoint *b, struct command_line *commands)
678 free_command_lines (&b->commands);
679 b->commands = commands;
680 breakpoints_changed ();
681 observer_notify_breakpoint_modified (b->number);
685 commands_command (char *arg, int from_tty)
687 struct breakpoint *b;
690 struct command_line *l;
692 /* If we allowed this, we would have problems with when to
693 free the storage, if we change the commands currently
696 if (executing_breakpoint_commands)
697 error (_("Can't use the \"commands\" command among a breakpoint's commands."));
700 bnum = get_number (&p);
703 error (_("Unexpected extra arguments following breakpoint number."));
706 if (b->number == bnum)
708 char *tmpbuf = xstrprintf ("Type commands for when breakpoint %d is hit, one per line.",
710 struct cleanup *cleanups = make_cleanup (xfree, tmpbuf);
711 l = read_command_lines (tmpbuf, from_tty, 1);
712 do_cleanups (cleanups);
713 breakpoint_set_commands (b, l);
716 error (_("No breakpoint number %d."), bnum);
719 /* Like commands_command, but instead of reading the commands from
720 input stream, takes them from an already parsed command structure.
722 This is used by cli-script.c to DTRT with breakpoint commands
723 that are part of if and while bodies. */
724 enum command_control_type
725 commands_from_control_command (char *arg, struct command_line *cmd)
727 struct breakpoint *b;
731 /* If we allowed this, we would have problems with when to
732 free the storage, if we change the commands currently
735 if (executing_breakpoint_commands)
736 error (_("Can't use the \"commands\" command among a breakpoint's commands."));
738 /* An empty string for the breakpoint number means the last
739 breakpoint, but get_number expects a NULL pointer. */
744 bnum = get_number (&p);
747 error (_("Unexpected extra arguments following breakpoint number."));
750 if (b->number == bnum)
752 free_command_lines (&b->commands);
753 if (cmd->body_count != 1)
754 error (_("Invalid \"commands\" block structure."));
755 /* We need to copy the commands because if/while will free the
756 list after it finishes execution. */
757 b->commands = copy_command_lines (cmd->body_list[0]);
758 breakpoints_changed ();
759 observer_notify_breakpoint_modified (b->number);
760 return simple_control;
762 error (_("No breakpoint number %d."), bnum);
765 /* Return non-zero if BL->TARGET_INFO contains valid information. */
768 bp_location_has_shadow (struct bp_location *bl)
770 if (bl->loc_type != bp_loc_software_breakpoint)
774 if (bl->target_info.shadow_len == 0)
775 /* bp isn't valid, or doesn't shadow memory. */
780 /* Update BUF, which is LEN bytes read from the target address MEMADDR,
781 by replacing any memory breakpoints with their shadowed contents.
783 The range of shadowed area by each bp_location is:
784 b->address - bp_location_placed_address_before_address_max
785 up to b->address + bp_location_shadow_len_after_address_max
786 The range we were requested to resolve shadows for is:
787 memaddr ... memaddr + len
788 Thus the safe cutoff boundaries for performance optimization are
789 memaddr + len <= b->address - bp_location_placed_address_before_address_max
791 b->address + bp_location_shadow_len_after_address_max <= memaddr */
794 breakpoint_restore_shadows (gdb_byte *buf, ULONGEST memaddr, LONGEST len)
796 /* Left boundary, right boundary and median element of our binary search. */
797 unsigned bc_l, bc_r, bc;
799 /* Find BC_L which is a leftmost element which may affect BUF content. It is
800 safe to report lower value but a failure to report higher one. */
803 bc_r = bp_location_count;
804 while (bc_l + 1 < bc_r)
806 struct bp_location *b;
808 bc = (bc_l + bc_r) / 2;
811 /* Check first B->ADDRESS will not overflow due to the added constant.
812 Then advance the left boundary only if we are sure the BC element can
813 in no way affect the BUF content (MEMADDR to MEMADDR + LEN range).
815 Use the BP_LOCATION_SHADOW_LEN_AFTER_ADDRESS_MAX safety offset so that
816 we cannot miss a breakpoint with its shadow range tail still reaching
819 if (b->address + bp_location_shadow_len_after_address_max >= b->address
820 && b->address + bp_location_shadow_len_after_address_max <= memaddr)
826 /* Now do full processing of the found relevant range of elements. */
828 for (bc = bc_l; bc < bp_location_count; bc++)
830 struct bp_location *b = bp_location[bc];
831 CORE_ADDR bp_addr = 0;
835 if (b->owner->type == bp_none)
836 warning (_("reading through apparently deleted breakpoint #%d?"),
839 /* Performance optimization: any futher element can no longer affect BUF
842 if (b->address >= bp_location_placed_address_before_address_max
843 && memaddr + len <= b->address
844 - bp_location_placed_address_before_address_max)
847 if (!bp_location_has_shadow (b))
849 if (!breakpoint_address_match (b->target_info.placed_address_space, 0,
850 current_program_space->aspace, 0))
853 /* Addresses and length of the part of the breakpoint that
855 bp_addr = b->target_info.placed_address;
856 bp_size = b->target_info.shadow_len;
858 if (bp_addr + bp_size <= memaddr)
859 /* The breakpoint is entirely before the chunk of memory we
863 if (bp_addr >= memaddr + len)
864 /* The breakpoint is entirely after the chunk of memory we are
868 /* Offset within shadow_contents. */
869 if (bp_addr < memaddr)
871 /* Only copy the second part of the breakpoint. */
872 bp_size -= memaddr - bp_addr;
873 bptoffset = memaddr - bp_addr;
877 if (bp_addr + bp_size > memaddr + len)
879 /* Only copy the first part of the breakpoint. */
880 bp_size -= (bp_addr + bp_size) - (memaddr + len);
883 memcpy (buf + bp_addr - memaddr,
884 b->target_info.shadow_contents + bptoffset, bp_size);
889 /* A wrapper function for inserting catchpoints. */
891 insert_catchpoint (struct ui_out *uo, void *args)
893 struct breakpoint *b = (struct breakpoint *) args;
896 gdb_assert (b->type == bp_catchpoint);
897 gdb_assert (b->ops != NULL && b->ops->insert != NULL);
903 is_hardware_watchpoint (struct breakpoint *bpt)
905 return (bpt->type == bp_hardware_watchpoint
906 || bpt->type == bp_read_watchpoint
907 || bpt->type == bp_access_watchpoint);
910 /* Find the current value of a watchpoint on EXP. Return the value in
911 *VALP and *RESULTP and the chain of intermediate and final values
912 in *VAL_CHAIN. RESULTP and VAL_CHAIN may be NULL if the caller does
915 If a memory error occurs while evaluating the expression, *RESULTP will
916 be set to NULL. *RESULTP may be a lazy value, if the result could
917 not be read from memory. It is used to determine whether a value
918 is user-specified (we should watch the whole value) or intermediate
919 (we should watch only the bit used to locate the final value).
921 If the final value, or any intermediate value, could not be read
922 from memory, *VALP will be set to NULL. *VAL_CHAIN will still be
923 set to any referenced values. *VALP will never be a lazy value.
924 This is the value which we store in struct breakpoint.
926 If VAL_CHAIN is non-NULL, *VAL_CHAIN will be released from the
927 value chain. The caller must free the values individually. If
928 VAL_CHAIN is NULL, all generated values will be left on the value
932 fetch_watchpoint_value (struct expression *exp, struct value **valp,
933 struct value **resultp, struct value **val_chain)
935 struct value *mark, *new_mark, *result;
936 volatile struct gdb_exception ex;
944 /* Evaluate the expression. */
945 mark = value_mark ();
948 TRY_CATCH (ex, RETURN_MASK_ALL)
950 result = evaluate_expression (exp);
954 /* Ignore memory errors, we want watchpoints pointing at
955 inaccessible memory to still be created; otherwise, throw the
956 error to some higher catcher. */
962 throw_exception (ex);
967 new_mark = value_mark ();
968 if (mark == new_mark)
973 /* Make sure it's not lazy, so that after the target stops again we
974 have a non-lazy previous value to compare with. */
976 && (!value_lazy (result) || gdb_value_fetch_lazy (result)))
981 /* Return the chain of intermediate values. We use this to
982 decide which addresses to watch. */
983 *val_chain = new_mark;
984 value_release_to_mark (mark);
988 /* Assuming that B is a watchpoint: returns true if the current thread
989 and its running state are safe to evaluate or update watchpoint B.
990 Watchpoints on local expressions need to be evaluated in the
991 context of the thread that was current when the watchpoint was
992 created, and, that thread needs to be stopped to be able to select
993 the correct frame context. Watchpoints on global expressions can
994 be evaluated on any thread, and in any state. It is presently left
995 to the target allowing memory accesses when threads are
999 watchpoint_in_thread_scope (struct breakpoint *b)
1001 return (ptid_equal (b->watchpoint_thread, null_ptid)
1002 || (ptid_equal (inferior_ptid, b->watchpoint_thread)
1003 && !is_executing (inferior_ptid)));
1006 /* Assuming that B is a watchpoint:
1007 - Reparse watchpoint expression, if REPARSE is non-zero
1008 - Evaluate expression and store the result in B->val
1009 - Evaluate the condition if there is one, and store the result
1011 - Update the list of values that must be watched in B->loc.
1013 If the watchpoint disposition is disp_del_at_next_stop, then do nothing.
1014 If this is local watchpoint that is out of scope, delete it.
1016 Even with `set breakpoint always-inserted on' the watchpoints are removed
1017 + inserted on each stop here. Normal breakpoints must never be removed
1018 because they might be missed by a running thread when debugging in non-stop
1019 mode. On the other hand, hardware watchpoints (is_hardware_watchpoint;
1020 processed here) are specific to each LWP since they are stored in each LWP's
1021 hardware debug registers. Therefore, such LWP must be stopped first in
1022 order to be able to modify its hardware watchpoints.
1024 Hardware watchpoints must be reset exactly once after being presented to the
1025 user. It cannot be done sooner, because it would reset the data used to
1026 present the watchpoint hit to the user. And it must not be done later
1027 because it could display the same single watchpoint hit during multiple GDB
1028 stops. Note that the latter is relevant only to the hardware watchpoint
1029 types bp_read_watchpoint and bp_access_watchpoint. False hit by
1030 bp_hardware_watchpoint is not user-visible - its hit is suppressed if the
1031 memory content has not changed.
1033 The following constraints influence the location where we can reset hardware
1036 * target_stopped_by_watchpoint and target_stopped_data_address are called
1037 several times when GDB stops.
1040 * Multiple hardware watchpoints can be hit at the same time, causing GDB to
1041 stop. GDB only presents one hardware watchpoint hit at a time as the
1042 reason for stopping, and all the other hits are presented later, one after
1043 the other, each time the user requests the execution to be resumed.
1044 Execution is not resumed for the threads still having pending hit event
1045 stored in LWP_INFO->STATUS. While the watchpoint is already removed from
1046 the inferior on the first stop the thread hit event is kept being reported
1047 from its cached value by linux_nat_stopped_data_address until the real
1048 thread resume happens after the watchpoint gets presented and thus its
1049 LWP_INFO->STATUS gets reset.
1051 Therefore the hardware watchpoint hit can get safely reset on the watchpoint
1052 removal from inferior. */
1055 update_watchpoint (struct breakpoint *b, int reparse)
1057 int within_current_scope;
1058 struct frame_id saved_frame_id;
1059 struct bp_location *loc;
1063 /* If this is a local watchpoint, we only want to check if the
1064 watchpoint frame is in scope if the current thread is the thread
1065 that was used to create the watchpoint. */
1066 if (!watchpoint_in_thread_scope (b))
1069 /* We don't free locations. They are stored in bp_location array and
1070 update_global_locations will eventually delete them and remove
1071 breakpoints if needed. */
1074 if (b->disposition == disp_del_at_next_stop)
1079 /* Determine if the watchpoint is within scope. */
1080 if (b->exp_valid_block == NULL)
1081 within_current_scope = 1;
1084 struct frame_info *fi;
1086 /* Save the current frame's ID so we can restore it after
1087 evaluating the watchpoint expression on its own frame. */
1088 /* FIXME drow/2003-09-09: It would be nice if evaluate_expression
1089 took a frame parameter, so that we didn't have to change the
1092 saved_frame_id = get_frame_id (get_selected_frame (NULL));
1094 fi = frame_find_by_id (b->watchpoint_frame);
1095 within_current_scope = (fi != NULL);
1096 if (within_current_scope)
1100 if (within_current_scope && reparse)
1109 b->exp = parse_exp_1 (&s, b->exp_valid_block, 0);
1110 /* If the meaning of expression itself changed, the old value is
1111 no longer relevant. We don't want to report a watchpoint hit
1112 to the user when the old value and the new value may actually
1113 be completely different objects. */
1114 value_free (b->val);
1119 /* If we failed to parse the expression, for example because
1120 it refers to a global variable in a not-yet-loaded shared library,
1121 don't try to insert watchpoint. We don't automatically delete
1122 such watchpoint, though, since failure to parse expression
1123 is different from out-of-scope watchpoint. */
1124 if ( !target_has_execution)
1126 /* Without execution, memory can't change. No use to try and
1127 set watchpoint locations. The watchpoint will be reset when
1128 the target gains execution, through breakpoint_re_set. */
1130 else if (within_current_scope && b->exp)
1132 struct value *val_chain, *v, *result, *next;
1133 struct program_space *frame_pspace;
1135 fetch_watchpoint_value (b->exp, &v, &result, &val_chain);
1137 /* Avoid setting b->val if it's already set. The meaning of
1138 b->val is 'the last value' user saw, and we should update
1139 it only if we reported that last value to user. As it
1140 happens, the code that reports it updates b->val directly. */
1147 /* Change the type of breakpoint between hardware assisted or an
1148 ordinary watchpoint depending on the hardware support and free
1149 hardware slots. REPARSE is set when the inferior is started. */
1150 if ((b->type == bp_watchpoint || b->type == bp_hardware_watchpoint)
1153 int i, mem_cnt, other_type_used;
1155 /* We need to determine how many resources are already used
1156 for all other hardware watchpoints to see if we still have
1157 enough resources to also fit this watchpoint in as well.
1158 To avoid the hw_watchpoint_used_count call below from counting
1159 this watchpoint, make sure that it is marked as a software
1161 b->type = bp_watchpoint;
1162 i = hw_watchpoint_used_count (bp_hardware_watchpoint,
1164 mem_cnt = can_use_hardware_watchpoint (val_chain);
1167 b->type = bp_watchpoint;
1170 int target_resources_ok = target_can_use_hardware_watchpoint
1171 (bp_hardware_watchpoint, i + mem_cnt, other_type_used);
1172 if (target_resources_ok <= 0)
1173 b->type = bp_watchpoint;
1175 b->type = bp_hardware_watchpoint;
1179 frame_pspace = get_frame_program_space (get_selected_frame (NULL));
1181 /* Look at each value on the value chain. */
1182 for (v = val_chain; v; v = next)
1184 /* If it's a memory location, and GDB actually needed
1185 its contents to evaluate the expression, then we
1186 must watch it. If the first value returned is
1187 still lazy, that means an error occurred reading it;
1188 watch it anyway in case it becomes readable. */
1189 if (VALUE_LVAL (v) == lval_memory
1190 && (v == val_chain || ! value_lazy (v)))
1192 struct type *vtype = check_typedef (value_type (v));
1194 /* We only watch structs and arrays if user asked
1195 for it explicitly, never if they just happen to
1196 appear in the middle of some value chain. */
1198 || (TYPE_CODE (vtype) != TYPE_CODE_STRUCT
1199 && TYPE_CODE (vtype) != TYPE_CODE_ARRAY))
1203 struct bp_location *loc, **tmp;
1205 addr = value_address (v);
1206 len = TYPE_LENGTH (value_type (v));
1208 if (b->type == bp_read_watchpoint)
1210 else if (b->type == bp_access_watchpoint)
1213 loc = allocate_bp_location (b);
1214 for (tmp = &(b->loc); *tmp != NULL; tmp = &((*tmp)->next))
1217 loc->gdbarch = get_type_arch (value_type (v));
1219 loc->pspace = frame_pspace;
1220 loc->address = addr;
1222 loc->watchpoint_type = type;
1226 next = value_next (v);
1231 /* We just regenerated the list of breakpoint locations.
1232 The new location does not have its condition field set to anything
1233 and therefore, we must always reparse the cond_string, independently
1234 of the value of the reparse flag. */
1235 if (b->cond_string != NULL)
1237 char *s = b->cond_string;
1238 b->loc->cond = parse_exp_1 (&s, b->exp_valid_block, 0);
1241 else if (!within_current_scope)
1243 printf_filtered (_("\
1244 Watchpoint %d deleted because the program has left the block \n\
1245 in which its expression is valid.\n"),
1247 if (b->related_breakpoint)
1248 b->related_breakpoint->disposition = disp_del_at_next_stop;
1249 b->disposition = disp_del_at_next_stop;
1252 /* Restore the selected frame. */
1254 select_frame (frame_find_by_id (saved_frame_id));
1258 /* Returns 1 iff breakpoint location should be
1259 inserted in the inferior. */
1261 should_be_inserted (struct bp_location *bpt)
1263 if (!breakpoint_enabled (bpt->owner))
1266 if (bpt->owner->disposition == disp_del_at_next_stop)
1269 if (!bpt->enabled || bpt->shlib_disabled || bpt->duplicate)
1272 /* This is set for example, when we're attached to the parent of a
1273 vfork, and have detached from the child. The child is running
1274 free, and we expect it to do an exec or exit, at which point the
1275 OS makes the parent schedulable again (and the target reports
1276 that the vfork is done). Until the child is done with the shared
1277 memory region, do not insert breakpoints in the parent, otherwise
1278 the child could still trip on the parent's breakpoints. Since
1279 the parent is blocked anyway, it won't miss any breakpoint. */
1280 if (bpt->pspace->breakpoints_not_allowed)
1283 /* Tracepoints are inserted by the target at a time of its choosing,
1285 if (bpt->owner->type == bp_tracepoint)
1291 /* Insert a low-level "breakpoint" of some type. BPT is the breakpoint.
1292 Any error messages are printed to TMP_ERROR_STREAM; and DISABLED_BREAKS,
1293 and HW_BREAKPOINT_ERROR are used to report problems.
1295 NOTE drow/2003-09-09: This routine could be broken down to an object-style
1296 method for each breakpoint or catchpoint type. */
1298 insert_bp_location (struct bp_location *bpt,
1299 struct ui_file *tmp_error_stream,
1300 int *disabled_breaks,
1301 int *hw_breakpoint_error)
1305 if (!should_be_inserted (bpt) || bpt->inserted)
1308 /* Initialize the target-specific information. */
1309 memset (&bpt->target_info, 0, sizeof (bpt->target_info));
1310 bpt->target_info.placed_address = bpt->address;
1311 bpt->target_info.placed_address_space = bpt->pspace->aspace;
1313 if (bpt->loc_type == bp_loc_software_breakpoint
1314 || bpt->loc_type == bp_loc_hardware_breakpoint)
1316 if (bpt->owner->type != bp_hardware_breakpoint)
1318 /* If the explicitly specified breakpoint type
1319 is not hardware breakpoint, check the memory map to see
1320 if the breakpoint address is in read only memory or not.
1321 Two important cases are:
1322 - location type is not hardware breakpoint, memory
1323 is readonly. We change the type of the location to
1324 hardware breakpoint.
1325 - location type is hardware breakpoint, memory is read-write.
1326 This means we've previously made the location hardware one, but
1327 then the memory map changed, so we undo.
1329 When breakpoints are removed, remove_breakpoints will
1330 use location types we've just set here, the only possible
1331 problem is that memory map has changed during running program,
1332 but it's not going to work anyway with current gdb. */
1333 struct mem_region *mr
1334 = lookup_mem_region (bpt->target_info.placed_address);
1338 if (automatic_hardware_breakpoints)
1341 enum bp_loc_type new_type;
1343 if (mr->attrib.mode != MEM_RW)
1344 new_type = bp_loc_hardware_breakpoint;
1346 new_type = bp_loc_software_breakpoint;
1348 if (new_type != bpt->loc_type)
1350 static int said = 0;
1351 bpt->loc_type = new_type;
1354 fprintf_filtered (gdb_stdout, _("\
1355 Note: automatically using hardware breakpoints for read-only addresses.\n"));
1360 else if (bpt->loc_type == bp_loc_software_breakpoint
1361 && mr->attrib.mode != MEM_RW)
1362 warning (_("cannot set software breakpoint at readonly address %s"),
1363 paddress (bpt->gdbarch, bpt->address));
1367 /* First check to see if we have to handle an overlay. */
1368 if (overlay_debugging == ovly_off
1369 || bpt->section == NULL
1370 || !(section_is_overlay (bpt->section)))
1372 /* No overlay handling: just set the breakpoint. */
1374 if (bpt->loc_type == bp_loc_hardware_breakpoint)
1375 val = target_insert_hw_breakpoint (bpt->gdbarch,
1378 val = target_insert_breakpoint (bpt->gdbarch,
1383 /* This breakpoint is in an overlay section.
1384 Shall we set a breakpoint at the LMA? */
1385 if (!overlay_events_enabled)
1387 /* Yes -- overlay event support is not active,
1388 so we must try to set a breakpoint at the LMA.
1389 This will not work for a hardware breakpoint. */
1390 if (bpt->loc_type == bp_loc_hardware_breakpoint)
1391 warning (_("hardware breakpoint %d not supported in overlay!"),
1392 bpt->owner->number);
1395 CORE_ADDR addr = overlay_unmapped_address (bpt->address,
1397 /* Set a software (trap) breakpoint at the LMA. */
1398 bpt->overlay_target_info = bpt->target_info;
1399 bpt->overlay_target_info.placed_address = addr;
1400 val = target_insert_breakpoint (bpt->gdbarch,
1401 &bpt->overlay_target_info);
1403 fprintf_unfiltered (tmp_error_stream,
1404 "Overlay breakpoint %d failed: in ROM?\n",
1405 bpt->owner->number);
1408 /* Shall we set a breakpoint at the VMA? */
1409 if (section_is_mapped (bpt->section))
1411 /* Yes. This overlay section is mapped into memory. */
1412 if (bpt->loc_type == bp_loc_hardware_breakpoint)
1413 val = target_insert_hw_breakpoint (bpt->gdbarch,
1416 val = target_insert_breakpoint (bpt->gdbarch,
1421 /* No. This breakpoint will not be inserted.
1422 No error, but do not mark the bp as 'inserted'. */
1429 /* Can't set the breakpoint. */
1430 if (solib_name_from_address (bpt->pspace, bpt->address))
1432 /* See also: disable_breakpoints_in_shlibs. */
1434 bpt->shlib_disabled = 1;
1435 if (!*disabled_breaks)
1437 fprintf_unfiltered (tmp_error_stream,
1438 "Cannot insert breakpoint %d.\n",
1439 bpt->owner->number);
1440 fprintf_unfiltered (tmp_error_stream,
1441 "Temporarily disabling shared library breakpoints:\n");
1443 *disabled_breaks = 1;
1444 fprintf_unfiltered (tmp_error_stream,
1445 "breakpoint #%d\n", bpt->owner->number);
1449 if (bpt->loc_type == bp_loc_hardware_breakpoint)
1451 *hw_breakpoint_error = 1;
1452 fprintf_unfiltered (tmp_error_stream,
1453 "Cannot insert hardware breakpoint %d.\n",
1454 bpt->owner->number);
1458 fprintf_unfiltered (tmp_error_stream,
1459 "Cannot insert breakpoint %d.\n",
1460 bpt->owner->number);
1461 fprintf_filtered (tmp_error_stream,
1462 "Error accessing memory address ");
1463 fputs_filtered (paddress (bpt->gdbarch, bpt->address),
1465 fprintf_filtered (tmp_error_stream, ": %s.\n",
1466 safe_strerror (val));
1477 else if (bpt->loc_type == bp_loc_hardware_watchpoint
1478 /* NOTE drow/2003-09-08: This state only exists for removing
1479 watchpoints. It's not clear that it's necessary... */
1480 && bpt->owner->disposition != disp_del_at_next_stop)
1482 val = target_insert_watchpoint (bpt->address,
1484 bpt->watchpoint_type);
1485 bpt->inserted = (val != -1);
1488 else if (bpt->owner->type == bp_catchpoint)
1490 struct gdb_exception e = catch_exception (uiout, insert_catchpoint,
1491 bpt->owner, RETURN_MASK_ERROR);
1492 exception_fprintf (gdb_stderr, e, "warning: inserting catchpoint %d: ",
1493 bpt->owner->number);
1495 bpt->owner->enable_state = bp_disabled;
1499 /* We've already printed an error message if there was a problem
1500 inserting this catchpoint, and we've disabled the catchpoint,
1501 so just return success. */
1508 /* This function is called when program space PSPACE is about to be
1509 deleted. It takes care of updating breakpoints to not reference
1513 breakpoint_program_space_exit (struct program_space *pspace)
1515 struct breakpoint *b, *b_temp;
1516 struct bp_location *loc, **loc_temp;
1518 /* Remove any breakpoint that was set through this program space. */
1519 ALL_BREAKPOINTS_SAFE (b, b_temp)
1521 if (b->pspace == pspace)
1522 delete_breakpoint (b);
1525 /* Breakpoints set through other program spaces could have locations
1526 bound to PSPACE as well. Remove those. */
1527 ALL_BP_LOCATIONS (loc, loc_temp)
1529 struct bp_location *tmp;
1531 if (loc->pspace == pspace)
1533 if (loc->owner->loc == loc)
1534 loc->owner->loc = loc->next;
1536 for (tmp = loc->owner->loc; tmp->next != NULL; tmp = tmp->next)
1537 if (tmp->next == loc)
1539 tmp->next = loc->next;
1545 /* Now update the global location list to permanently delete the
1546 removed locations above. */
1547 update_global_location_list (0);
1550 /* Make sure all breakpoints are inserted in inferior.
1551 Throws exception on any error.
1552 A breakpoint that is already inserted won't be inserted
1553 again, so calling this function twice is safe. */
1555 insert_breakpoints (void)
1557 struct breakpoint *bpt;
1559 ALL_BREAKPOINTS (bpt)
1560 if (is_hardware_watchpoint (bpt))
1561 update_watchpoint (bpt, 0 /* don't reparse. */);
1563 update_global_location_list (1);
1565 /* update_global_location_list does not insert breakpoints when
1566 always_inserted_mode is not enabled. Explicitly insert them
1568 if (!breakpoints_always_inserted_mode ())
1569 insert_breakpoint_locations ();
1572 /* insert_breakpoints is used when starting or continuing the program.
1573 remove_breakpoints is used when the program stops.
1574 Both return zero if successful,
1575 or an `errno' value if could not write the inferior. */
1578 insert_breakpoint_locations (void)
1580 struct breakpoint *bpt;
1581 struct bp_location *b, **bp_tmp;
1584 int disabled_breaks = 0;
1585 int hw_breakpoint_error = 0;
1587 struct ui_file *tmp_error_stream = mem_fileopen ();
1588 struct cleanup *cleanups = make_cleanup_ui_file_delete (tmp_error_stream);
1590 /* Explicitly mark the warning -- this will only be printed if
1591 there was an error. */
1592 fprintf_unfiltered (tmp_error_stream, "Warning:\n");
1594 save_current_space_and_thread ();
1596 ALL_BP_LOCATIONS (b, bp_tmp)
1598 struct thread_info *tp;
1599 CORE_ADDR last_addr;
1601 if (!should_be_inserted (b) || b->inserted)
1604 /* There is no point inserting thread-specific breakpoints if the
1605 thread no longer exists. */
1606 if (b->owner->thread != -1
1607 && !valid_thread_id (b->owner->thread))
1610 switch_to_program_space_and_thread (b->pspace);
1612 /* For targets that support global breakpoints, there's no need
1613 to select an inferior to insert breakpoint to. In fact, even
1614 if we aren't attached to any process yet, we should still
1615 insert breakpoints. */
1616 if (!gdbarch_has_global_breakpoints (target_gdbarch)
1617 && ptid_equal (inferior_ptid, null_ptid))
1620 val = insert_bp_location (b, tmp_error_stream,
1622 &hw_breakpoint_error);
1627 /* If we failed to insert all locations of a watchpoint,
1628 remove them, as half-inserted watchpoint is of limited use. */
1629 ALL_BREAKPOINTS (bpt)
1631 int some_failed = 0;
1632 struct bp_location *loc;
1634 if (!is_hardware_watchpoint (bpt))
1637 if (!breakpoint_enabled (bpt))
1640 if (bpt->disposition == disp_del_at_next_stop)
1643 for (loc = bpt->loc; loc; loc = loc->next)
1644 if (!loc->inserted && should_be_inserted (loc))
1651 for (loc = bpt->loc; loc; loc = loc->next)
1653 remove_breakpoint (loc, mark_uninserted);
1655 hw_breakpoint_error = 1;
1656 fprintf_unfiltered (tmp_error_stream,
1657 "Could not insert hardware watchpoint %d.\n",
1665 /* If a hardware breakpoint or watchpoint was inserted, add a
1666 message about possibly exhausted resources. */
1667 if (hw_breakpoint_error)
1669 fprintf_unfiltered (tmp_error_stream,
1670 "Could not insert hardware breakpoints:\n\
1671 You may have requested too many hardware breakpoints/watchpoints.\n");
1673 target_terminal_ours_for_output ();
1674 error_stream (tmp_error_stream);
1677 do_cleanups (cleanups);
1681 remove_breakpoints (void)
1683 struct bp_location *b, **bp_tmp;
1686 ALL_BP_LOCATIONS (b, bp_tmp)
1689 val |= remove_breakpoint (b, mark_uninserted);
1694 /* Remove breakpoints of process PID. */
1697 remove_breakpoints_pid (int pid)
1699 struct bp_location *b, **b_tmp;
1701 struct inferior *inf = find_inferior_pid (pid);
1703 ALL_BP_LOCATIONS (b, b_tmp)
1705 if (b->pspace != inf->pspace)
1710 val = remove_breakpoint (b, mark_uninserted);
1719 remove_hw_watchpoints (void)
1721 struct bp_location *b, **bp_tmp;
1724 ALL_BP_LOCATIONS (b, bp_tmp)
1726 if (b->inserted && b->loc_type == bp_loc_hardware_watchpoint)
1727 val |= remove_breakpoint (b, mark_uninserted);
1733 reattach_breakpoints (int pid)
1735 struct cleanup *old_chain;
1736 struct bp_location *b, **bp_tmp;
1738 struct ui_file *tmp_error_stream = mem_fileopen ();
1739 int dummy1 = 0, dummy2 = 0;
1740 struct inferior *inf;
1741 struct thread_info *tp;
1743 tp = any_live_thread_of_process (pid);
1747 inf = find_inferior_pid (pid);
1748 old_chain = save_inferior_ptid ();
1750 inferior_ptid = tp->ptid;
1752 make_cleanup_ui_file_delete (tmp_error_stream);
1754 ALL_BP_LOCATIONS (b, bp_tmp)
1756 if (b->pspace != inf->pspace)
1762 val = insert_bp_location (b, tmp_error_stream,
1766 do_cleanups (old_chain);
1771 do_cleanups (old_chain);
1775 static int internal_breakpoint_number = -1;
1777 static struct breakpoint *
1778 create_internal_breakpoint (struct gdbarch *gdbarch,
1779 CORE_ADDR address, enum bptype type)
1781 struct symtab_and_line sal;
1782 struct breakpoint *b;
1784 init_sal (&sal); /* initialize to zeroes */
1787 sal.section = find_pc_overlay (sal.pc);
1788 sal.pspace = current_program_space;
1790 b = set_raw_breakpoint (gdbarch, sal, type);
1791 b->number = internal_breakpoint_number--;
1792 b->disposition = disp_donttouch;
1798 create_overlay_event_breakpoint (char *func_name)
1800 struct objfile *objfile;
1802 ALL_OBJFILES (objfile)
1804 struct breakpoint *b;
1805 struct minimal_symbol *m;
1807 m = lookup_minimal_symbol_text (func_name, objfile);
1811 b = create_internal_breakpoint (get_objfile_arch (objfile),
1812 SYMBOL_VALUE_ADDRESS (m),
1814 b->addr_string = xstrdup (func_name);
1816 if (overlay_debugging == ovly_auto)
1818 b->enable_state = bp_enabled;
1819 overlay_events_enabled = 1;
1823 b->enable_state = bp_disabled;
1824 overlay_events_enabled = 0;
1827 update_global_location_list (1);
1831 create_longjmp_master_breakpoint (char *func_name)
1833 struct program_space *pspace;
1834 struct objfile *objfile;
1835 struct cleanup *old_chain;
1837 old_chain = save_current_program_space ();
1839 ALL_PSPACES (pspace)
1840 ALL_OBJFILES (objfile)
1842 struct breakpoint *b;
1843 struct minimal_symbol *m;
1845 if (!gdbarch_get_longjmp_target_p (get_objfile_arch (objfile)))
1848 set_current_program_space (pspace);
1850 m = lookup_minimal_symbol_text (func_name, objfile);
1854 b = create_internal_breakpoint (get_objfile_arch (objfile),
1855 SYMBOL_VALUE_ADDRESS (m),
1857 b->addr_string = xstrdup (func_name);
1858 b->enable_state = bp_disabled;
1860 update_global_location_list (1);
1862 do_cleanups (old_chain);
1866 update_breakpoints_after_exec (void)
1868 struct breakpoint *b;
1869 struct breakpoint *temp;
1870 struct bp_location *bploc, **bplocp_tmp;
1872 /* We're about to delete breakpoints from GDB's lists. If the
1873 INSERTED flag is true, GDB will try to lift the breakpoints by
1874 writing the breakpoints' "shadow contents" back into memory. The
1875 "shadow contents" are NOT valid after an exec, so GDB should not
1876 do that. Instead, the target is responsible from marking
1877 breakpoints out as soon as it detects an exec. We don't do that
1878 here instead, because there may be other attempts to delete
1879 breakpoints after detecting an exec and before reaching here. */
1880 ALL_BP_LOCATIONS (bploc, bplocp_tmp)
1881 if (bploc->pspace == current_program_space)
1882 gdb_assert (!bploc->inserted);
1884 ALL_BREAKPOINTS_SAFE (b, temp)
1886 if (b->pspace != current_program_space)
1889 /* Solib breakpoints must be explicitly reset after an exec(). */
1890 if (b->type == bp_shlib_event)
1892 delete_breakpoint (b);
1896 /* JIT breakpoints must be explicitly reset after an exec(). */
1897 if (b->type == bp_jit_event)
1899 delete_breakpoint (b);
1903 /* Thread event breakpoints must be set anew after an exec(),
1904 as must overlay event and longjmp master breakpoints. */
1905 if (b->type == bp_thread_event || b->type == bp_overlay_event
1906 || b->type == bp_longjmp_master)
1908 delete_breakpoint (b);
1912 /* Step-resume breakpoints are meaningless after an exec(). */
1913 if (b->type == bp_step_resume)
1915 delete_breakpoint (b);
1919 /* Longjmp and longjmp-resume breakpoints are also meaningless
1921 if (b->type == bp_longjmp || b->type == bp_longjmp_resume)
1923 delete_breakpoint (b);
1927 if (b->type == bp_catchpoint)
1929 /* For now, none of the bp_catchpoint breakpoints need to
1930 do anything at this point. In the future, if some of
1931 the catchpoints need to something, we will need to add
1932 a new method, and call this method from here. */
1936 /* bp_finish is a special case. The only way we ought to be able
1937 to see one of these when an exec() has happened, is if the user
1938 caught a vfork, and then said "finish". Ordinarily a finish just
1939 carries them to the call-site of the current callee, by setting
1940 a temporary bp there and resuming. But in this case, the finish
1941 will carry them entirely through the vfork & exec.
1943 We don't want to allow a bp_finish to remain inserted now. But
1944 we can't safely delete it, 'cause finish_command has a handle to
1945 the bp on a bpstat, and will later want to delete it. There's a
1946 chance (and I've seen it happen) that if we delete the bp_finish
1947 here, that its storage will get reused by the time finish_command
1948 gets 'round to deleting the "use to be a bp_finish" breakpoint.
1949 We really must allow finish_command to delete a bp_finish.
1951 In the absense of a general solution for the "how do we know
1952 it's safe to delete something others may have handles to?"
1953 problem, what we'll do here is just uninsert the bp_finish, and
1954 let finish_command delete it.
1956 (We know the bp_finish is "doomed" in the sense that it's
1957 momentary, and will be deleted as soon as finish_command sees
1958 the inferior stopped. So it doesn't matter that the bp's
1959 address is probably bogus in the new a.out, unlike e.g., the
1960 solib breakpoints.) */
1962 if (b->type == bp_finish)
1967 /* Without a symbolic address, we have little hope of the
1968 pre-exec() address meaning the same thing in the post-exec()
1970 if (b->addr_string == NULL)
1972 delete_breakpoint (b);
1976 /* FIXME what about longjmp breakpoints? Re-create them here? */
1977 create_overlay_event_breakpoint ("_ovly_debug_event");
1978 create_longjmp_master_breakpoint ("longjmp");
1979 create_longjmp_master_breakpoint ("_longjmp");
1980 create_longjmp_master_breakpoint ("siglongjmp");
1981 create_longjmp_master_breakpoint ("_siglongjmp");
1985 detach_breakpoints (int pid)
1987 struct bp_location *b, **bp_tmp;
1989 struct cleanup *old_chain = save_inferior_ptid ();
1990 struct inferior *inf = current_inferior ();
1992 if (pid == PIDGET (inferior_ptid))
1993 error (_("Cannot detach breakpoints of inferior_ptid"));
1995 /* Set inferior_ptid; remove_breakpoint_1 uses this global. */
1996 inferior_ptid = pid_to_ptid (pid);
1997 ALL_BP_LOCATIONS (b, bp_tmp)
1999 if (b->pspace != inf->pspace)
2003 val |= remove_breakpoint_1 (b, mark_inserted);
2005 do_cleanups (old_chain);
2009 /* Remove the breakpoint location B from the current address space.
2010 Note that this is used to detach breakpoints from a child fork.
2011 When we get here, the child isn't in the inferior list, and neither
2012 do we have objects to represent its address space --- we should
2013 *not* look at b->pspace->aspace here. */
2016 remove_breakpoint_1 (struct bp_location *b, insertion_state_t is)
2019 struct cleanup *old_chain;
2021 if (b->owner->enable_state == bp_permanent)
2022 /* Permanent breakpoints cannot be inserted or removed. */
2025 /* The type of none suggests that owner is actually deleted.
2026 This should not ever happen. */
2027 gdb_assert (b->owner->type != bp_none);
2029 if (b->loc_type == bp_loc_software_breakpoint
2030 || b->loc_type == bp_loc_hardware_breakpoint)
2032 /* "Normal" instruction breakpoint: either the standard
2033 trap-instruction bp (bp_breakpoint), or a
2034 bp_hardware_breakpoint. */
2036 /* First check to see if we have to handle an overlay. */
2037 if (overlay_debugging == ovly_off
2038 || b->section == NULL
2039 || !(section_is_overlay (b->section)))
2041 /* No overlay handling: just remove the breakpoint. */
2043 if (b->loc_type == bp_loc_hardware_breakpoint)
2044 val = target_remove_hw_breakpoint (b->gdbarch, &b->target_info);
2046 val = target_remove_breakpoint (b->gdbarch, &b->target_info);
2050 /* This breakpoint is in an overlay section.
2051 Did we set a breakpoint at the LMA? */
2052 if (!overlay_events_enabled)
2054 /* Yes -- overlay event support is not active, so we
2055 should have set a breakpoint at the LMA. Remove it.
2057 /* Ignore any failures: if the LMA is in ROM, we will
2058 have already warned when we failed to insert it. */
2059 if (b->loc_type == bp_loc_hardware_breakpoint)
2060 target_remove_hw_breakpoint (b->gdbarch,
2061 &b->overlay_target_info);
2063 target_remove_breakpoint (b->gdbarch,
2064 &b->overlay_target_info);
2066 /* Did we set a breakpoint at the VMA?
2067 If so, we will have marked the breakpoint 'inserted'. */
2070 /* Yes -- remove it. Previously we did not bother to
2071 remove the breakpoint if the section had been
2072 unmapped, but let's not rely on that being safe. We
2073 don't know what the overlay manager might do. */
2074 if (b->loc_type == bp_loc_hardware_breakpoint)
2075 val = target_remove_hw_breakpoint (b->gdbarch,
2078 /* However, we should remove *software* breakpoints only
2079 if the section is still mapped, or else we overwrite
2080 wrong code with the saved shadow contents. */
2081 else if (section_is_mapped (b->section))
2082 val = target_remove_breakpoint (b->gdbarch,
2089 /* No -- not inserted, so no need to remove. No error. */
2094 /* In some cases, we might not be able to remove a breakpoint
2095 in a shared library that has already been removed, but we
2096 have not yet processed the shlib unload event. */
2097 if (val && solib_name_from_address (b->pspace, b->address))
2102 b->inserted = (is == mark_inserted);
2104 else if (b->loc_type == bp_loc_hardware_watchpoint)
2109 b->inserted = (is == mark_inserted);
2110 val = target_remove_watchpoint (b->address, b->length,
2111 b->watchpoint_type);
2113 /* Failure to remove any of the hardware watchpoints comes here. */
2114 if ((is == mark_uninserted) && (b->inserted))
2115 warning (_("Could not remove hardware watchpoint %d."),
2118 else if (b->owner->type == bp_catchpoint
2119 && breakpoint_enabled (b->owner)
2122 gdb_assert (b->owner->ops != NULL && b->owner->ops->remove != NULL);
2124 val = b->owner->ops->remove (b->owner);
2127 b->inserted = (is == mark_inserted);
2134 remove_breakpoint (struct bp_location *b, insertion_state_t is)
2137 struct cleanup *old_chain;
2139 if (b->owner->enable_state == bp_permanent)
2140 /* Permanent breakpoints cannot be inserted or removed. */
2143 /* The type of none suggests that owner is actually deleted.
2144 This should not ever happen. */
2145 gdb_assert (b->owner->type != bp_none);
2147 old_chain = save_current_space_and_thread ();
2149 switch_to_program_space_and_thread (b->pspace);
2151 ret = remove_breakpoint_1 (b, is);
2153 do_cleanups (old_chain);
2157 /* Clear the "inserted" flag in all breakpoints. */
2160 mark_breakpoints_out (void)
2162 struct bp_location *bpt, **bptp_tmp;
2164 ALL_BP_LOCATIONS (bpt, bptp_tmp)
2165 if (bpt->pspace == current_program_space)
2169 /* Clear the "inserted" flag in all breakpoints and delete any
2170 breakpoints which should go away between runs of the program.
2172 Plus other such housekeeping that has to be done for breakpoints
2175 Note: this function gets called at the end of a run (by
2176 generic_mourn_inferior) and when a run begins (by
2177 init_wait_for_inferior). */
2182 breakpoint_init_inferior (enum inf_context context)
2184 struct breakpoint *b, *temp;
2185 struct bp_location *bpt, **bptp_tmp;
2187 struct program_space *pspace = current_program_space;
2189 /* If breakpoint locations are shared across processes, then there's
2191 if (gdbarch_has_global_breakpoints (target_gdbarch))
2194 ALL_BP_LOCATIONS (bpt, bptp_tmp)
2196 if (bpt->pspace == pspace
2197 && bpt->owner->enable_state != bp_permanent)
2201 ALL_BREAKPOINTS_SAFE (b, temp)
2203 if (b->loc && b->loc->pspace != pspace)
2209 case bp_watchpoint_scope:
2211 /* If the call dummy breakpoint is at the entry point it will
2212 cause problems when the inferior is rerun, so we better
2215 Also get rid of scope breakpoints. */
2216 delete_breakpoint (b);
2220 case bp_hardware_watchpoint:
2221 case bp_read_watchpoint:
2222 case bp_access_watchpoint:
2224 /* Likewise for watchpoints on local expressions. */
2225 if (b->exp_valid_block != NULL)
2226 delete_breakpoint (b);
2227 else if (context == inf_starting)
2229 /* Reset val field to force reread of starting value
2230 in insert_breakpoints. */
2232 value_free (b->val);
2242 /* Get rid of the moribund locations. */
2243 for (ix = 0; VEC_iterate (bp_location_p, moribund_locations, ix, bpt); ++ix)
2244 free_bp_location (bpt);
2245 VEC_free (bp_location_p, moribund_locations);
2248 /* These functions concern about actual breakpoints inserted in the
2249 target --- to e.g. check if we need to do decr_pc adjustment or if
2250 we need to hop over the bkpt --- so we check for address space
2251 match, not program space. */
2253 /* breakpoint_here_p (PC) returns non-zero if an enabled breakpoint
2254 exists at PC. It returns ordinary_breakpoint_here if it's an
2255 ordinary breakpoint, or permanent_breakpoint_here if it's a
2256 permanent breakpoint.
2257 - When continuing from a location with an ordinary breakpoint, we
2258 actually single step once before calling insert_breakpoints.
2259 - When continuing from a localion with a permanent breakpoint, we
2260 need to use the `SKIP_PERMANENT_BREAKPOINT' macro, provided by
2261 the target, to advance the PC past the breakpoint. */
2263 enum breakpoint_here
2264 breakpoint_here_p (struct address_space *aspace, CORE_ADDR pc)
2266 struct bp_location *bpt, **bptp_tmp;
2267 int any_breakpoint_here = 0;
2269 ALL_BP_LOCATIONS (bpt, bptp_tmp)
2271 if (bpt->loc_type != bp_loc_software_breakpoint
2272 && bpt->loc_type != bp_loc_hardware_breakpoint)
2275 if ((breakpoint_enabled (bpt->owner)
2276 || bpt->owner->enable_state == bp_permanent)
2277 && breakpoint_address_match (bpt->pspace->aspace, bpt->address,
2280 if (overlay_debugging
2281 && section_is_overlay (bpt->section)
2282 && !section_is_mapped (bpt->section))
2283 continue; /* unmapped overlay -- can't be a match */
2284 else if (bpt->owner->enable_state == bp_permanent)
2285 return permanent_breakpoint_here;
2287 any_breakpoint_here = 1;
2291 return any_breakpoint_here ? ordinary_breakpoint_here : 0;
2294 /* Return true if there's a moribund breakpoint at PC. */
2297 moribund_breakpoint_here_p (struct address_space *aspace, CORE_ADDR pc)
2299 struct bp_location *loc;
2302 for (ix = 0; VEC_iterate (bp_location_p, moribund_locations, ix, loc); ++ix)
2303 if (breakpoint_address_match (loc->pspace->aspace, loc->address,
2310 /* Returns non-zero if there's a breakpoint inserted at PC, which is
2311 inserted using regular breakpoint_chain / bp_location array mechanism.
2312 This does not check for single-step breakpoints, which are
2313 inserted and removed using direct target manipulation. */
2316 regular_breakpoint_inserted_here_p (struct address_space *aspace, CORE_ADDR pc)
2318 struct bp_location *bpt, **bptp_tmp;
2320 ALL_BP_LOCATIONS (bpt, bptp_tmp)
2322 if (bpt->loc_type != bp_loc_software_breakpoint
2323 && bpt->loc_type != bp_loc_hardware_breakpoint)
2327 && breakpoint_address_match (bpt->pspace->aspace, bpt->address,
2330 if (overlay_debugging
2331 && section_is_overlay (bpt->section)
2332 && !section_is_mapped (bpt->section))
2333 continue; /* unmapped overlay -- can't be a match */
2341 /* Returns non-zero iff there's either regular breakpoint
2342 or a single step breakpoint inserted at PC. */
2345 breakpoint_inserted_here_p (struct address_space *aspace, CORE_ADDR pc)
2347 if (regular_breakpoint_inserted_here_p (aspace, pc))
2350 if (single_step_breakpoint_inserted_here_p (aspace, pc))
2356 /* This function returns non-zero iff there is a software breakpoint
2360 software_breakpoint_inserted_here_p (struct address_space *aspace, CORE_ADDR pc)
2362 struct bp_location *bpt, **bptp_tmp;
2363 int any_breakpoint_here = 0;
2365 ALL_BP_LOCATIONS (bpt, bptp_tmp)
2367 if (bpt->loc_type != bp_loc_software_breakpoint)
2371 && breakpoint_address_match (bpt->pspace->aspace, bpt->address,
2374 if (overlay_debugging
2375 && section_is_overlay (bpt->section)
2376 && !section_is_mapped (bpt->section))
2377 continue; /* unmapped overlay -- can't be a match */
2383 /* Also check for software single-step breakpoints. */
2384 if (single_step_breakpoint_inserted_here_p (aspace, pc))
2391 hardware_watchpoint_inserted_in_range (struct address_space *aspace,
2392 CORE_ADDR addr, ULONGEST len)
2394 struct breakpoint *bpt;
2396 ALL_BREAKPOINTS (bpt)
2398 struct bp_location *loc;
2400 if (bpt->type != bp_hardware_watchpoint
2401 && bpt->type != bp_access_watchpoint)
2404 if (!breakpoint_enabled (bpt))
2407 for (loc = bpt->loc; loc; loc = loc->next)
2408 if (loc->pspace->aspace == aspace && loc->inserted)
2412 /* Check for intersection. */
2413 l = max (loc->address, addr);
2414 h = min (loc->address + loc->length, addr + len);
2422 /* breakpoint_thread_match (PC, PTID) returns true if the breakpoint at
2423 PC is valid for process/thread PTID. */
2426 breakpoint_thread_match (struct address_space *aspace, CORE_ADDR pc,
2429 struct bp_location *bpt, **bptp_tmp;
2430 /* The thread and task IDs associated to PTID, computed lazily. */
2434 ALL_BP_LOCATIONS (bpt, bptp_tmp)
2436 if (bpt->loc_type != bp_loc_software_breakpoint
2437 && bpt->loc_type != bp_loc_hardware_breakpoint)
2440 if (!breakpoint_enabled (bpt->owner)
2441 && bpt->owner->enable_state != bp_permanent)
2444 if (!breakpoint_address_match (bpt->pspace->aspace, bpt->address,
2448 if (bpt->owner->thread != -1)
2450 /* This is a thread-specific breakpoint. Check that ptid
2451 matches that thread. If thread hasn't been computed yet,
2452 it is now time to do so. */
2454 thread = pid_to_thread_id (ptid);
2455 if (bpt->owner->thread != thread)
2459 if (bpt->owner->task != 0)
2461 /* This is a task-specific breakpoint. Check that ptid
2462 matches that task. If task hasn't been computed yet,
2463 it is now time to do so. */
2465 task = ada_get_task_number (ptid);
2466 if (bpt->owner->task != task)
2470 if (overlay_debugging
2471 && section_is_overlay (bpt->section)
2472 && !section_is_mapped (bpt->section))
2473 continue; /* unmapped overlay -- can't be a match */
2482 /* bpstat stuff. External routines' interfaces are documented
2486 ep_is_catchpoint (struct breakpoint *ep)
2488 return (ep->type == bp_catchpoint);
2492 bpstat_free (bpstat bs)
2494 if (bs->old_val != NULL)
2495 value_free (bs->old_val);
2496 free_command_lines (&bs->commands);
2500 /* Clear a bpstat so that it says we are not at any breakpoint.
2501 Also free any storage that is part of a bpstat. */
2504 bpstat_clear (bpstat *bsp)
2521 /* Return a copy of a bpstat. Like "bs1 = bs2" but all storage that
2522 is part of the bpstat is copied as well. */
2525 bpstat_copy (bpstat bs)
2529 bpstat retval = NULL;
2534 for (; bs != NULL; bs = bs->next)
2536 tmp = (bpstat) xmalloc (sizeof (*tmp));
2537 memcpy (tmp, bs, sizeof (*tmp));
2538 if (bs->commands != NULL)
2539 tmp->commands = copy_command_lines (bs->commands);
2540 if (bs->old_val != NULL)
2542 tmp->old_val = value_copy (bs->old_val);
2543 release_value (tmp->old_val);
2547 /* This is the first thing in the chain. */
2557 /* Find the bpstat associated with this breakpoint */
2560 bpstat_find_breakpoint (bpstat bsp, struct breakpoint *breakpoint)
2565 for (; bsp != NULL; bsp = bsp->next)
2567 if (bsp->breakpoint_at && bsp->breakpoint_at->owner == breakpoint)
2573 /* Find a step_resume breakpoint associated with this bpstat.
2574 (If there are multiple step_resume bp's on the list, this function
2575 will arbitrarily pick one.)
2577 It is an error to use this function if BPSTAT doesn't contain a
2578 step_resume breakpoint.
2580 See wait_for_inferior's use of this function. */
2582 bpstat_find_step_resume_breakpoint (bpstat bsp)
2586 gdb_assert (bsp != NULL);
2588 current_thread = pid_to_thread_id (inferior_ptid);
2590 for (; bsp != NULL; bsp = bsp->next)
2592 if ((bsp->breakpoint_at != NULL)
2593 && (bsp->breakpoint_at->owner->type == bp_step_resume)
2594 && (bsp->breakpoint_at->owner->thread == current_thread
2595 || bsp->breakpoint_at->owner->thread == -1))
2596 return bsp->breakpoint_at->owner;
2599 internal_error (__FILE__, __LINE__, _("No step_resume breakpoint found."));
2603 /* Put in *NUM the breakpoint number of the first breakpoint we are stopped
2604 at. *BSP upon return is a bpstat which points to the remaining
2605 breakpoints stopped at (but which is not guaranteed to be good for
2606 anything but further calls to bpstat_num).
2607 Return 0 if passed a bpstat which does not indicate any breakpoints.
2608 Return -1 if stopped at a breakpoint that has been deleted since
2610 Return 1 otherwise. */
2613 bpstat_num (bpstat *bsp, int *num)
2615 struct breakpoint *b;
2618 return 0; /* No more breakpoint values */
2620 /* We assume we'll never have several bpstats that
2621 correspond to a single breakpoint -- otherwise,
2622 this function might return the same number more
2623 than once and this will look ugly. */
2624 b = (*bsp)->breakpoint_at ? (*bsp)->breakpoint_at->owner : NULL;
2625 *bsp = (*bsp)->next;
2627 return -1; /* breakpoint that's been deleted since */
2629 *num = b->number; /* We have its number */
2633 /* Modify BS so that the actions will not be performed. */
2636 bpstat_clear_actions (bpstat bs)
2638 for (; bs != NULL; bs = bs->next)
2640 free_command_lines (&bs->commands);
2641 if (bs->old_val != NULL)
2643 value_free (bs->old_val);
2649 /* Called when a command is about to proceed the inferior. */
2652 breakpoint_about_to_proceed (void)
2654 if (!ptid_equal (inferior_ptid, null_ptid))
2656 struct thread_info *tp = inferior_thread ();
2658 /* Allow inferior function calls in breakpoint commands to not
2659 interrupt the command list. When the call finishes
2660 successfully, the inferior will be standing at the same
2661 breakpoint as if nothing happened. */
2666 breakpoint_proceeded = 1;
2669 /* Stub for cleaning up our state if we error-out of a breakpoint command */
2671 cleanup_executing_breakpoints (void *ignore)
2673 executing_breakpoint_commands = 0;
2676 /* Execute all the commands associated with all the breakpoints at this
2677 location. Any of these commands could cause the process to proceed
2678 beyond this point, etc. We look out for such changes by checking
2679 the global "breakpoint_proceeded" after each command.
2681 Returns true if a breakpoint command resumed the inferior. In that
2682 case, it is the caller's responsibility to recall it again with the
2683 bpstat of the current thread. */
2686 bpstat_do_actions_1 (bpstat *bsp)
2689 struct cleanup *old_chain;
2692 /* Avoid endless recursion if a `source' command is contained
2694 if (executing_breakpoint_commands)
2697 executing_breakpoint_commands = 1;
2698 old_chain = make_cleanup (cleanup_executing_breakpoints, 0);
2700 /* This pointer will iterate over the list of bpstat's. */
2703 breakpoint_proceeded = 0;
2704 for (; bs != NULL; bs = bs->next)
2706 struct command_line *cmd;
2707 struct cleanup *this_cmd_tree_chain;
2709 /* Take ownership of the BSP's command tree, if it has one.
2711 The command tree could legitimately contain commands like
2712 'step' and 'next', which call clear_proceed_status, which
2713 frees stop_bpstat's command tree. To make sure this doesn't
2714 free the tree we're executing out from under us, we need to
2715 take ownership of the tree ourselves. Since a given bpstat's
2716 commands are only executed once, we don't need to copy it; we
2717 can clear the pointer in the bpstat, and make sure we free
2718 the tree when we're done. */
2721 this_cmd_tree_chain = make_cleanup_free_command_lines (&cmd);
2725 execute_control_command (cmd);
2727 if (breakpoint_proceeded)
2733 /* We can free this command tree now. */
2734 do_cleanups (this_cmd_tree_chain);
2736 if (breakpoint_proceeded)
2738 if (target_can_async_p ())
2739 /* If we are in async mode, then the target might be still
2740 running, not stopped at any breakpoint, so nothing for
2741 us to do here -- just return to the event loop. */
2744 /* In sync mode, when execute_control_command returns
2745 we're already standing on the next breakpoint.
2746 Breakpoint commands for that stop were not run, since
2747 execute_command does not run breakpoint commands --
2748 only command_line_handler does, but that one is not
2749 involved in execution of breakpoint commands. So, we
2750 can now execute breakpoint commands. It should be
2751 noted that making execute_command do bpstat actions is
2752 not an option -- in this case we'll have recursive
2753 invocation of bpstat for each breakpoint with a
2754 command, and can easily blow up GDB stack. Instead, we
2755 return true, which will trigger the caller to recall us
2756 with the new stop_bpstat. */
2761 do_cleanups (old_chain);
2766 bpstat_do_actions (void)
2768 /* Do any commands attached to breakpoint we are stopped at. */
2769 while (!ptid_equal (inferior_ptid, null_ptid)
2770 && target_has_execution
2771 && !is_exited (inferior_ptid)
2772 && !is_executing (inferior_ptid))
2773 /* Since in sync mode, bpstat_do_actions may resume the inferior,
2774 and only return when it is stopped at the next breakpoint, we
2775 keep doing breakpoint actions until it returns false to
2776 indicate the inferior was not resumed. */
2777 if (!bpstat_do_actions_1 (&inferior_thread ()->stop_bpstat))
2781 /* Print out the (old or new) value associated with a watchpoint. */
2784 watchpoint_value_print (struct value *val, struct ui_file *stream)
2787 fprintf_unfiltered (stream, _("<unreadable>"));
2790 struct value_print_options opts;
2791 get_user_print_options (&opts);
2792 value_print (val, stream, &opts);
2796 /* This is the normal print function for a bpstat. In the future,
2797 much of this logic could (should?) be moved to bpstat_stop_status,
2798 by having it set different print_it values.
2800 Current scheme: When we stop, bpstat_print() is called. It loops
2801 through the bpstat list of things causing this stop, calling the
2802 print_bp_stop_message function on each one. The behavior of the
2803 print_bp_stop_message function depends on the print_it field of
2804 bpstat. If such field so indicates, call this function here.
2806 Return values from this routine (ultimately used by bpstat_print()
2807 and normal_stop() to decide what to do):
2808 PRINT_NOTHING: Means we already printed all we needed to print,
2809 don't print anything else.
2810 PRINT_SRC_ONLY: Means we printed something, and we do *not* desire
2811 that something to be followed by a location.
2812 PRINT_SCR_AND_LOC: Means we printed something, and we *do* desire
2813 that something to be followed by a location.
2814 PRINT_UNKNOWN: Means we printed nothing or we need to do some more
2817 static enum print_stop_action
2818 print_it_typical (bpstat bs)
2820 struct cleanup *old_chain;
2821 struct breakpoint *b;
2822 const struct bp_location *bl;
2823 struct ui_stream *stb;
2825 enum print_stop_action result;
2827 /* bs->breakpoint_at can be NULL if it was a momentary breakpoint
2828 which has since been deleted. */
2829 if (bs->breakpoint_at == NULL)
2830 return PRINT_UNKNOWN;
2831 bl = bs->breakpoint_at;
2834 stb = ui_out_stream_new (uiout);
2835 old_chain = make_cleanup_ui_out_stream_delete (stb);
2840 case bp_hardware_breakpoint:
2841 bp_temp = bs->breakpoint_at->owner->disposition == disp_del;
2842 if (bl->address != bl->requested_address)
2843 breakpoint_adjustment_warning (bl->requested_address,
2846 annotate_breakpoint (b->number);
2848 ui_out_text (uiout, "\nTemporary breakpoint ");
2850 ui_out_text (uiout, "\nBreakpoint ");
2851 if (ui_out_is_mi_like_p (uiout))
2853 ui_out_field_string (uiout, "reason",
2854 async_reason_lookup (EXEC_ASYNC_BREAKPOINT_HIT));
2855 ui_out_field_string (uiout, "disp", bpdisp_text (b->disposition));
2857 ui_out_field_int (uiout, "bkptno", b->number);
2858 ui_out_text (uiout, ", ");
2859 result = PRINT_SRC_AND_LOC;
2862 case bp_shlib_event:
2863 /* Did we stop because the user set the stop_on_solib_events
2864 variable? (If so, we report this as a generic, "Stopped due
2865 to shlib event" message.) */
2866 printf_filtered (_("Stopped due to shared library event\n"));
2867 result = PRINT_NOTHING;
2870 case bp_thread_event:
2871 /* Not sure how we will get here.
2872 GDB should not stop for these breakpoints. */
2873 printf_filtered (_("Thread Event Breakpoint: gdb should not stop!\n"));
2874 result = PRINT_NOTHING;
2877 case bp_overlay_event:
2878 /* By analogy with the thread event, GDB should not stop for these. */
2879 printf_filtered (_("Overlay Event Breakpoint: gdb should not stop!\n"));
2880 result = PRINT_NOTHING;
2883 case bp_longjmp_master:
2884 /* These should never be enabled. */
2885 printf_filtered (_("Longjmp Master Breakpoint: gdb should not stop!\n"));
2886 result = PRINT_NOTHING;
2890 case bp_hardware_watchpoint:
2891 annotate_watchpoint (b->number);
2892 if (ui_out_is_mi_like_p (uiout))
2895 async_reason_lookup (EXEC_ASYNC_WATCHPOINT_TRIGGER));
2897 make_cleanup_ui_out_tuple_begin_end (uiout, "value");
2898 ui_out_text (uiout, "\nOld value = ");
2899 watchpoint_value_print (bs->old_val, stb->stream);
2900 ui_out_field_stream (uiout, "old", stb);
2901 ui_out_text (uiout, "\nNew value = ");
2902 watchpoint_value_print (b->val, stb->stream);
2903 ui_out_field_stream (uiout, "new", stb);
2904 ui_out_text (uiout, "\n");
2905 /* More than one watchpoint may have been triggered. */
2906 result = PRINT_UNKNOWN;
2909 case bp_read_watchpoint:
2910 if (ui_out_is_mi_like_p (uiout))
2913 async_reason_lookup (EXEC_ASYNC_READ_WATCHPOINT_TRIGGER));
2915 make_cleanup_ui_out_tuple_begin_end (uiout, "value");
2916 ui_out_text (uiout, "\nValue = ");
2917 watchpoint_value_print (b->val, stb->stream);
2918 ui_out_field_stream (uiout, "value", stb);
2919 ui_out_text (uiout, "\n");
2920 result = PRINT_UNKNOWN;
2923 case bp_access_watchpoint:
2924 if (bs->old_val != NULL)
2926 annotate_watchpoint (b->number);
2927 if (ui_out_is_mi_like_p (uiout))
2930 async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER));
2932 make_cleanup_ui_out_tuple_begin_end (uiout, "value");
2933 ui_out_text (uiout, "\nOld value = ");
2934 watchpoint_value_print (bs->old_val, stb->stream);
2935 ui_out_field_stream (uiout, "old", stb);
2936 ui_out_text (uiout, "\nNew value = ");
2941 if (ui_out_is_mi_like_p (uiout))
2944 async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER));
2945 make_cleanup_ui_out_tuple_begin_end (uiout, "value");
2946 ui_out_text (uiout, "\nValue = ");
2948 watchpoint_value_print (b->val, stb->stream);
2949 ui_out_field_stream (uiout, "new", stb);
2950 ui_out_text (uiout, "\n");
2951 result = PRINT_UNKNOWN;
2954 /* Fall through, we don't deal with these types of breakpoints
2958 if (ui_out_is_mi_like_p (uiout))
2961 async_reason_lookup (EXEC_ASYNC_FUNCTION_FINISHED));
2962 result = PRINT_UNKNOWN;
2966 if (ui_out_is_mi_like_p (uiout))
2969 async_reason_lookup (EXEC_ASYNC_LOCATION_REACHED));
2970 result = PRINT_UNKNOWN;
2975 case bp_longjmp_resume:
2976 case bp_step_resume:
2977 case bp_watchpoint_scope:
2982 result = PRINT_UNKNOWN;
2986 do_cleanups (old_chain);
2990 /* Generic routine for printing messages indicating why we
2991 stopped. The behavior of this function depends on the value
2992 'print_it' in the bpstat structure. Under some circumstances we
2993 may decide not to print anything here and delegate the task to
2996 static enum print_stop_action
2997 print_bp_stop_message (bpstat bs)
2999 switch (bs->print_it)
3002 /* Nothing should be printed for this bpstat entry. */
3003 return PRINT_UNKNOWN;
3007 /* We still want to print the frame, but we already printed the
3008 relevant messages. */
3009 return PRINT_SRC_AND_LOC;
3012 case print_it_normal:
3014 const struct bp_location *bl = bs->breakpoint_at;
3015 struct breakpoint *b = bl ? bl->owner : NULL;
3017 /* Normal case. Call the breakpoint's print_it method, or
3018 print_it_typical. */
3019 /* FIXME: how breakpoint can ever be NULL here? */
3020 if (b != NULL && b->ops != NULL && b->ops->print_it != NULL)
3021 return b->ops->print_it (b);
3023 return print_it_typical (bs);
3028 internal_error (__FILE__, __LINE__,
3029 _("print_bp_stop_message: unrecognized enum value"));
3034 /* Print a message indicating what happened. This is called from
3035 normal_stop(). The input to this routine is the head of the bpstat
3036 list - a list of the eventpoints that caused this stop. This
3037 routine calls the generic print routine for printing a message
3038 about reasons for stopping. This will print (for example) the
3039 "Breakpoint n," part of the output. The return value of this
3042 PRINT_UNKNOWN: Means we printed nothing
3043 PRINT_SRC_AND_LOC: Means we printed something, and expect subsequent
3044 code to print the location. An example is
3045 "Breakpoint 1, " which should be followed by
3047 PRINT_SRC_ONLY: Means we printed something, but there is no need
3048 to also print the location part of the message.
3049 An example is the catch/throw messages, which
3050 don't require a location appended to the end.
3051 PRINT_NOTHING: We have done some printing and we don't need any
3052 further info to be printed.*/
3054 enum print_stop_action
3055 bpstat_print (bpstat bs)
3059 /* Maybe another breakpoint in the chain caused us to stop.
3060 (Currently all watchpoints go on the bpstat whether hit or not.
3061 That probably could (should) be changed, provided care is taken
3062 with respect to bpstat_explains_signal). */
3063 for (; bs; bs = bs->next)
3065 val = print_bp_stop_message (bs);
3066 if (val == PRINT_SRC_ONLY
3067 || val == PRINT_SRC_AND_LOC
3068 || val == PRINT_NOTHING)
3072 /* We reached the end of the chain, or we got a null BS to start
3073 with and nothing was printed. */
3074 return PRINT_UNKNOWN;
3077 /* Evaluate the expression EXP and return 1 if value is zero.
3078 This is used inside a catch_errors to evaluate the breakpoint condition.
3079 The argument is a "struct expression *" that has been cast to char * to
3080 make it pass through catch_errors. */
3083 breakpoint_cond_eval (void *exp)
3085 struct value *mark = value_mark ();
3086 int i = !value_true (evaluate_expression ((struct expression *) exp));
3087 value_free_to_mark (mark);
3091 /* Allocate a new bpstat and chain it to the current one. */
3094 bpstat_alloc (const struct bp_location *bl, bpstat cbs /* Current "bs" value */ )
3098 bs = (bpstat) xmalloc (sizeof (*bs));
3100 bs->breakpoint_at = bl;
3101 /* If the condition is false, etc., don't do the commands. */
3102 bs->commands = NULL;
3104 bs->print_it = print_it_normal;
3108 /* The target has stopped with waitstatus WS. Check if any hardware
3109 watchpoints have triggered, according to the target. */
3112 watchpoints_triggered (struct target_waitstatus *ws)
3114 int stopped_by_watchpoint = target_stopped_by_watchpoint ();
3116 struct breakpoint *b;
3118 if (!stopped_by_watchpoint)
3120 /* We were not stopped by a watchpoint. Mark all watchpoints
3121 as not triggered. */
3123 if (b->type == bp_hardware_watchpoint
3124 || b->type == bp_read_watchpoint
3125 || b->type == bp_access_watchpoint)
3126 b->watchpoint_triggered = watch_triggered_no;
3131 if (!target_stopped_data_address (¤t_target, &addr))
3133 /* We were stopped by a watchpoint, but we don't know where.
3134 Mark all watchpoints as unknown. */
3136 if (b->type == bp_hardware_watchpoint
3137 || b->type == bp_read_watchpoint
3138 || b->type == bp_access_watchpoint)
3139 b->watchpoint_triggered = watch_triggered_unknown;
3141 return stopped_by_watchpoint;
3144 /* The target could report the data address. Mark watchpoints
3145 affected by this data address as triggered, and all others as not
3149 if (b->type == bp_hardware_watchpoint
3150 || b->type == bp_read_watchpoint
3151 || b->type == bp_access_watchpoint)
3153 struct bp_location *loc;
3156 b->watchpoint_triggered = watch_triggered_no;
3157 for (loc = b->loc; loc; loc = loc->next)
3158 /* Exact match not required. Within range is
3160 if (target_watchpoint_addr_within_range (¤t_target,
3164 b->watchpoint_triggered = watch_triggered_yes;
3172 /* Possible return values for watchpoint_check (this can't be an enum
3173 because of check_errors). */
3174 /* The watchpoint has been deleted. */
3175 #define WP_DELETED 1
3176 /* The value has changed. */
3177 #define WP_VALUE_CHANGED 2
3178 /* The value has not changed. */
3179 #define WP_VALUE_NOT_CHANGED 3
3181 #define BP_TEMPFLAG 1
3182 #define BP_HARDWAREFLAG 2
3184 /* Evaluate watchpoint condition expression and check if its value changed.
3186 P should be a pointer to struct bpstat, but is defined as a void *
3187 in order for this function to be usable with catch_errors. */
3190 watchpoint_check (void *p)
3192 bpstat bs = (bpstat) p;
3193 struct breakpoint *b;
3194 struct frame_info *fr;
3195 int within_current_scope;
3197 b = bs->breakpoint_at->owner;
3199 /* If this is a local watchpoint, we only want to check if the
3200 watchpoint frame is in scope if the current thread is the thread
3201 that was used to create the watchpoint. */
3202 if (!watchpoint_in_thread_scope (b))
3203 return WP_VALUE_NOT_CHANGED;
3205 if (b->exp_valid_block == NULL)
3206 within_current_scope = 1;
3209 struct frame_info *frame = get_current_frame ();
3210 struct gdbarch *frame_arch = get_frame_arch (frame);
3211 CORE_ADDR frame_pc = get_frame_pc (frame);
3213 fr = frame_find_by_id (b->watchpoint_frame);
3214 within_current_scope = (fr != NULL);
3216 /* If we've gotten confused in the unwinder, we might have
3217 returned a frame that can't describe this variable. */
3218 if (within_current_scope)
3220 struct symbol *function;
3222 function = get_frame_function (fr);
3223 if (function == NULL
3224 || !contained_in (b->exp_valid_block,
3225 SYMBOL_BLOCK_VALUE (function)))
3226 within_current_scope = 0;
3229 /* in_function_epilogue_p() returns a non-zero value if we're still
3230 in the function but the stack frame has already been invalidated.
3231 Since we can't rely on the values of local variables after the
3232 stack has been destroyed, we are treating the watchpoint in that
3233 state as `not changed' without further checking. Don't mark
3234 watchpoints as changed if the current frame is in an epilogue -
3235 even if they are in some other frame, our view of the stack
3236 is likely to be wrong. */
3237 if (gdbarch_in_function_epilogue_p (frame_arch, frame_pc))
3238 return WP_VALUE_NOT_CHANGED;
3240 if (within_current_scope)
3241 /* If we end up stopping, the current frame will get selected
3242 in normal_stop. So this call to select_frame won't affect
3247 if (within_current_scope)
3249 /* We use value_{,free_to_}mark because it could be a
3250 *long* time before we return to the command level and
3251 call free_all_values. We can't call free_all_values because
3252 we might be in the middle of evaluating a function call. */
3254 struct value *mark = value_mark ();
3255 struct value *new_val;
3257 fetch_watchpoint_value (b->exp, &new_val, NULL, NULL);
3259 /* We use value_equal_contents instead of value_equal because the latter
3260 coerces an array to a pointer, thus comparing just the address of the
3261 array instead of its contents. This is not what we want. */
3262 if ((b->val != NULL) != (new_val != NULL)
3263 || (b->val != NULL && !value_equal_contents (b->val, new_val)))
3265 if (new_val != NULL)
3267 release_value (new_val);
3268 value_free_to_mark (mark);
3270 bs->old_val = b->val;
3273 /* We will stop here */
3274 return WP_VALUE_CHANGED;
3278 /* Nothing changed, don't do anything. */
3279 value_free_to_mark (mark);
3280 /* We won't stop here */
3281 return WP_VALUE_NOT_CHANGED;
3286 /* This seems like the only logical thing to do because
3287 if we temporarily ignored the watchpoint, then when
3288 we reenter the block in which it is valid it contains
3289 garbage (in the case of a function, it may have two
3290 garbage values, one before and one after the prologue).
3291 So we can't even detect the first assignment to it and
3292 watch after that (since the garbage may or may not equal
3293 the first value assigned). */
3294 /* We print all the stop information in print_it_typical(), but
3295 in this case, by the time we call print_it_typical() this bp
3296 will be deleted already. So we have no choice but print the
3297 information here. */
3298 if (ui_out_is_mi_like_p (uiout))
3300 (uiout, "reason", async_reason_lookup (EXEC_ASYNC_WATCHPOINT_SCOPE));
3301 ui_out_text (uiout, "\nWatchpoint ");
3302 ui_out_field_int (uiout, "wpnum", b->number);
3303 ui_out_text (uiout, " deleted because the program has left the block in\n\
3304 which its expression is valid.\n");
3306 if (b->related_breakpoint)
3307 b->related_breakpoint->disposition = disp_del_at_next_stop;
3308 b->disposition = disp_del_at_next_stop;
3314 /* Return true if it looks like target has stopped due to hitting
3315 breakpoint location BL. This function does not check if we
3316 should stop, only if BL explains the stop. */
3318 bpstat_check_location (const struct bp_location *bl,
3319 struct address_space *aspace, CORE_ADDR bp_addr)
3321 struct breakpoint *b = bl->owner;
3323 /* By definition, the inferior does not report stops at
3325 if (b->type == bp_tracepoint)
3328 if (b->type != bp_watchpoint
3329 && b->type != bp_hardware_watchpoint
3330 && b->type != bp_read_watchpoint
3331 && b->type != bp_access_watchpoint
3332 && b->type != bp_hardware_breakpoint
3333 && b->type != bp_catchpoint) /* a non-watchpoint bp */
3335 if (!breakpoint_address_match (bl->pspace->aspace, bl->address,
3338 if (overlay_debugging /* unmapped overlay section */
3339 && section_is_overlay (bl->section)
3340 && !section_is_mapped (bl->section))
3344 /* Continuable hardware watchpoints are treated as non-existent if the
3345 reason we stopped wasn't a hardware watchpoint (we didn't stop on
3346 some data address). Otherwise gdb won't stop on a break instruction
3347 in the code (not from a breakpoint) when a hardware watchpoint has
3348 been defined. Also skip watchpoints which we know did not trigger
3349 (did not match the data address). */
3351 if ((b->type == bp_hardware_watchpoint
3352 || b->type == bp_read_watchpoint
3353 || b->type == bp_access_watchpoint)
3354 && b->watchpoint_triggered == watch_triggered_no)
3357 if (b->type == bp_hardware_breakpoint)
3359 if (bl->address != bp_addr)
3361 if (overlay_debugging /* unmapped overlay section */
3362 && section_is_overlay (bl->section)
3363 && !section_is_mapped (bl->section))
3367 if (b->type == bp_catchpoint)
3369 gdb_assert (b->ops != NULL && b->ops->breakpoint_hit != NULL);
3370 if (!b->ops->breakpoint_hit (b))
3377 /* If BS refers to a watchpoint, determine if the watched values
3378 has actually changed, and we should stop. If not, set BS->stop
3381 bpstat_check_watchpoint (bpstat bs)
3383 const struct bp_location *bl = bs->breakpoint_at;
3384 struct breakpoint *b = bl->owner;
3386 if (b->type == bp_watchpoint
3387 || b->type == bp_read_watchpoint
3388 || b->type == bp_access_watchpoint
3389 || b->type == bp_hardware_watchpoint)
3393 int must_check_value = 0;
3395 if (b->type == bp_watchpoint)
3396 /* For a software watchpoint, we must always check the
3398 must_check_value = 1;
3399 else if (b->watchpoint_triggered == watch_triggered_yes)
3400 /* We have a hardware watchpoint (read, write, or access)
3401 and the target earlier reported an address watched by
3403 must_check_value = 1;
3404 else if (b->watchpoint_triggered == watch_triggered_unknown
3405 && b->type == bp_hardware_watchpoint)
3406 /* We were stopped by a hardware watchpoint, but the target could
3407 not report the data address. We must check the watchpoint's
3408 value. Access and read watchpoints are out of luck; without
3409 a data address, we can't figure it out. */
3410 must_check_value = 1;
3412 if (must_check_value)
3414 char *message = xstrprintf ("Error evaluating expression for watchpoint %d\n",
3416 struct cleanup *cleanups = make_cleanup (xfree, message);
3417 int e = catch_errors (watchpoint_check, bs, message,
3419 do_cleanups (cleanups);
3423 /* We've already printed what needs to be printed. */
3424 bs->print_it = print_it_done;
3427 case WP_VALUE_CHANGED:
3428 if (b->type == bp_read_watchpoint)
3430 /* Don't stop: read watchpoints shouldn't fire if
3431 the value has changed. This is for targets
3432 which cannot set read-only watchpoints. */
3433 bs->print_it = print_it_noop;
3437 case WP_VALUE_NOT_CHANGED:
3438 if (b->type == bp_hardware_watchpoint
3439 || b->type == bp_watchpoint)
3441 /* Don't stop: write watchpoints shouldn't fire if
3442 the value hasn't changed. */
3443 bs->print_it = print_it_noop;
3451 /* Error from catch_errors. */
3452 printf_filtered (_("Watchpoint %d deleted.\n"), b->number);
3453 if (b->related_breakpoint)
3454 b->related_breakpoint->disposition = disp_del_at_next_stop;
3455 b->disposition = disp_del_at_next_stop;
3456 /* We've already printed what needs to be printed. */
3457 bs->print_it = print_it_done;
3461 else /* must_check_value == 0 */
3463 /* This is a case where some watchpoint(s) triggered, but
3464 not at the address of this watchpoint, or else no
3465 watchpoint triggered after all. So don't print
3466 anything for this watchpoint. */
3467 bs->print_it = print_it_noop;
3474 /* Check conditions (condition proper, frame, thread and ignore count)
3475 of breakpoint referred to by BS. If we should not stop for this
3476 breakpoint, set BS->stop to 0. */
3478 bpstat_check_breakpoint_conditions (bpstat bs, ptid_t ptid)
3480 int thread_id = pid_to_thread_id (ptid);
3481 const struct bp_location *bl = bs->breakpoint_at;
3482 struct breakpoint *b = bl->owner;
3484 if (frame_id_p (b->frame_id)
3485 && !frame_id_eq (b->frame_id, get_stack_frame_id (get_current_frame ())))
3489 int value_is_zero = 0;
3491 /* If this is a scope breakpoint, mark the associated
3492 watchpoint as triggered so that we will handle the
3493 out-of-scope event. We'll get to the watchpoint next
3495 if (b->type == bp_watchpoint_scope)
3496 b->related_breakpoint->watchpoint_triggered = watch_triggered_yes;
3498 if (bl->cond && bl->owner->disposition != disp_del_at_next_stop)
3500 /* We use value_mark and value_free_to_mark because it could
3501 be a long time before we return to the command level and
3502 call free_all_values. We can't call free_all_values
3503 because we might be in the middle of evaluating a
3505 struct value *mark = value_mark ();
3507 /* Need to select the frame, with all that implies so that
3508 the conditions will have the right context. Because we
3509 use the frame, we will not see an inlined function's
3510 variables when we arrive at a breakpoint at the start
3511 of the inlined function; the current frame will be the
3513 select_frame (get_current_frame ());
3515 = catch_errors (breakpoint_cond_eval, (bl->cond),
3516 "Error in testing breakpoint condition:\n",
3518 /* FIXME-someday, should give breakpoint # */
3519 value_free_to_mark (mark);
3521 if (bl->cond && value_is_zero)
3525 else if (b->thread != -1 && b->thread != thread_id)
3529 else if (b->ignore_count > 0)
3532 annotate_ignore_count_change ();
3534 /* Increase the hit count even though we don't
3542 /* Get a bpstat associated with having just stopped at address
3543 BP_ADDR in thread PTID.
3545 Determine whether we stopped at a breakpoint, etc, or whether we
3546 don't understand this stop. Result is a chain of bpstat's such that:
3548 if we don't understand the stop, the result is a null pointer.
3550 if we understand why we stopped, the result is not null.
3552 Each element of the chain refers to a particular breakpoint or
3553 watchpoint at which we have stopped. (We may have stopped for
3554 several reasons concurrently.)
3556 Each element of the chain has valid next, breakpoint_at,
3557 commands, FIXME??? fields. */
3560 bpstat_stop_status (struct address_space *aspace,
3561 CORE_ADDR bp_addr, ptid_t ptid)
3563 struct breakpoint *b = NULL;
3564 struct bp_location *bl, **blp_tmp;
3565 struct bp_location *loc;
3566 /* Root of the chain of bpstat's */
3567 struct bpstats root_bs[1];
3568 /* Pointer to the last thing in the chain currently. */
3569 bpstat bs = root_bs;
3571 int need_remove_insert;
3573 /* ALL_BP_LOCATIONS iteration would break across
3574 update_global_location_list possibly executed by
3575 bpstat_check_breakpoint_conditions's inferior call. */
3579 if (!breakpoint_enabled (b) && b->enable_state != bp_permanent)
3582 for (bl = b->loc; bl != NULL; bl = bl->next)
3584 /* For hardware watchpoints, we look only at the first location.
3585 The watchpoint_check function will work on entire expression,
3586 not the individual locations. For read watchopints, the
3587 watchpoints_triggered function have checked all locations
3589 if (b->type == bp_hardware_watchpoint && bl != b->loc)
3592 if (bl->shlib_disabled)
3595 if (!bpstat_check_location (bl, aspace, bp_addr))
3598 /* Come here if it's a watchpoint, or if the break address matches */
3600 bs = bpstat_alloc (bl, bs); /* Alloc a bpstat to explain stop */
3602 /* Assume we stop. Should we find watchpoint that is not actually
3603 triggered, or if condition of breakpoint is false, we'll reset
3608 bpstat_check_watchpoint (bs);
3612 if (b->type == bp_thread_event || b->type == bp_overlay_event
3613 || b->type == bp_longjmp_master)
3614 /* We do not stop for these. */
3617 bpstat_check_breakpoint_conditions (bs, ptid);
3623 /* We will stop here */
3624 if (b->disposition == disp_disable)
3626 if (b->enable_state != bp_permanent)
3627 b->enable_state = bp_disabled;
3628 update_global_location_list (0);
3632 bs->commands = b->commands;
3634 && (strcmp ("silent", bs->commands->line) == 0
3635 || (xdb_commands && strcmp ("Q",
3636 bs->commands->line) == 0)))
3638 bs->commands = bs->commands->next;
3641 bs->commands = copy_command_lines (bs->commands);
3644 /* Print nothing for this entry if we dont stop or dont print. */
3645 if (bs->stop == 0 || bs->print == 0)
3646 bs->print_it = print_it_noop;
3650 for (ix = 0; VEC_iterate (bp_location_p, moribund_locations, ix, loc); ++ix)
3652 if (breakpoint_address_match (loc->pspace->aspace, loc->address,
3655 bs = bpstat_alloc (loc, bs);
3656 /* For hits of moribund locations, we should just proceed. */
3659 bs->print_it = print_it_noop;
3663 bs->next = NULL; /* Terminate the chain */
3664 bs = root_bs->next; /* Re-grab the head of the chain */
3666 /* If we aren't stopping, the value of some hardware watchpoint may
3667 not have changed, but the intermediate memory locations we are
3668 watching may have. Don't bother if we're stopping; this will get
3670 for (bs = root_bs->next; bs != NULL; bs = bs->next)
3674 need_remove_insert = 0;
3676 for (bs = root_bs->next; bs != NULL; bs = bs->next)
3678 && bs->breakpoint_at->owner
3679 && is_hardware_watchpoint (bs->breakpoint_at->owner))
3681 update_watchpoint (bs->breakpoint_at->owner, 0 /* don't reparse. */);
3682 /* Updating watchpoints invalidates bs->breakpoint_at.
3683 Prevent further code from trying to use it. */
3684 bs->breakpoint_at = NULL;
3685 need_remove_insert = 1;
3688 if (need_remove_insert)
3689 update_global_location_list (1);
3691 return root_bs->next;
3694 /* Tell what to do about this bpstat. */
3696 bpstat_what (bpstat bs)
3698 /* Classify each bpstat as one of the following. */
3701 /* This bpstat element has no effect on the main_action. */
3704 /* There was a watchpoint, stop but don't print. */
3707 /* There was a watchpoint, stop and print. */
3710 /* There was a breakpoint but we're not stopping. */
3713 /* There was a breakpoint, stop but don't print. */
3716 /* There was a breakpoint, stop and print. */
3719 /* We hit the longjmp breakpoint. */
3722 /* We hit the longjmp_resume breakpoint. */
3725 /* We hit the step_resume breakpoint. */
3728 /* We hit the shared library event breakpoint. */
3731 /* We hit the jit event breakpoint. */
3734 /* This is just used to count how many enums there are. */
3738 /* Here is the table which drives this routine. So that we can
3739 format it pretty, we define some abbreviations for the
3740 enum bpstat_what codes. */
3741 #define kc BPSTAT_WHAT_KEEP_CHECKING
3742 #define ss BPSTAT_WHAT_STOP_SILENT
3743 #define sn BPSTAT_WHAT_STOP_NOISY
3744 #define sgl BPSTAT_WHAT_SINGLE
3745 #define slr BPSTAT_WHAT_SET_LONGJMP_RESUME
3746 #define clr BPSTAT_WHAT_CLEAR_LONGJMP_RESUME
3747 #define sr BPSTAT_WHAT_STEP_RESUME
3748 #define shl BPSTAT_WHAT_CHECK_SHLIBS
3749 #define jit BPSTAT_WHAT_CHECK_JIT
3751 /* "Can't happen." Might want to print an error message.
3752 abort() is not out of the question, but chances are GDB is just
3753 a bit confused, not unusable. */
3754 #define err BPSTAT_WHAT_STOP_NOISY
3756 /* Given an old action and a class, come up with a new action. */
3757 /* One interesting property of this table is that wp_silent is the same
3758 as bp_silent and wp_noisy is the same as bp_noisy. That is because
3759 after stopping, the check for whether to step over a breakpoint
3760 (BPSTAT_WHAT_SINGLE type stuff) is handled in proceed() without
3761 reference to how we stopped. We retain separate wp_silent and
3762 bp_silent codes in case we want to change that someday.
3764 Another possibly interesting property of this table is that
3765 there's a partial ordering, priority-like, of the actions. Once
3766 you've decided that some action is appropriate, you'll never go
3767 back and decide something of a lower priority is better. The
3770 kc < jit clr sgl shl slr sn sr ss
3771 sgl < jit shl slr sn sr ss
3772 slr < jit err shl sn sr ss
3773 clr < jit err shl sn sr ss
3780 What I think this means is that we don't need a damned table
3781 here. If you just put the rows and columns in the right order,
3782 it'd look awfully regular. We could simply walk the bpstat list
3783 and choose the highest priority action we find, with a little
3784 logic to handle the 'err' cases. */
3786 /* step_resume entries: a step resume breakpoint overrides another
3787 breakpoint of signal handling (see comment in wait_for_inferior
3788 at where we set the step_resume breakpoint). */
3790 static const enum bpstat_what_main_action
3791 table[(int) class_last][(int) BPSTAT_WHAT_LAST] =
3794 /* kc ss sn sgl slr clr sr shl jit */
3795 /* no_effect */ {kc, ss, sn, sgl, slr, clr, sr, shl, jit},
3796 /* wp_silent */ {ss, ss, sn, ss, ss, ss, sr, shl, jit},
3797 /* wp_noisy */ {sn, sn, sn, sn, sn, sn, sr, shl, jit},
3798 /* bp_nostop */ {sgl, ss, sn, sgl, slr, slr, sr, shl, jit},
3799 /* bp_silent */ {ss, ss, sn, ss, ss, ss, sr, shl, jit},
3800 /* bp_noisy */ {sn, sn, sn, sn, sn, sn, sr, shl, jit},
3801 /* long_jump */ {slr, ss, sn, slr, slr, err, sr, shl, jit},
3802 /* long_resume */ {clr, ss, sn, err, err, err, sr, shl, jit},
3803 /* step_resume */ {sr, sr, sr, sr, sr, sr, sr, sr, sr },
3804 /* shlib */ {shl, shl, shl, shl, shl, shl, sr, shl, shl},
3805 /* jit_event */ {jit, jit, jit, jit, jit, jit, sr, jit, jit}
3819 enum bpstat_what_main_action current_action = BPSTAT_WHAT_KEEP_CHECKING;
3820 struct bpstat_what retval;
3822 retval.call_dummy = 0;
3823 for (; bs != NULL; bs = bs->next)
3825 enum class bs_class = no_effect;
3826 if (bs->breakpoint_at == NULL)
3827 /* I suspect this can happen if it was a momentary breakpoint
3828 which has since been deleted. */
3830 if (bs->breakpoint_at->owner == NULL)
3831 bs_class = bp_nostop;
3833 switch (bs->breakpoint_at->owner->type)
3839 case bp_hardware_breakpoint:
3845 bs_class = bp_noisy;
3847 bs_class = bp_silent;
3850 bs_class = bp_nostop;
3853 case bp_hardware_watchpoint:
3854 case bp_read_watchpoint:
3855 case bp_access_watchpoint:
3859 bs_class = wp_noisy;
3861 bs_class = wp_silent;
3864 /* There was a watchpoint, but we're not stopping.
3865 This requires no further action. */
3866 bs_class = no_effect;
3869 bs_class = long_jump;
3871 case bp_longjmp_resume:
3872 bs_class = long_resume;
3874 case bp_step_resume:
3877 bs_class = step_resume;
3880 /* It is for the wrong frame. */
3881 bs_class = bp_nostop;
3883 case bp_watchpoint_scope:
3884 bs_class = bp_nostop;
3886 case bp_shlib_event:
3887 bs_class = shlib_event;
3890 bs_class = jit_event;
3892 case bp_thread_event:
3893 case bp_overlay_event:
3894 case bp_longjmp_master:
3895 bs_class = bp_nostop;
3901 bs_class = bp_noisy;
3903 bs_class = bp_silent;
3906 /* There was a catchpoint, but we're not stopping.
3907 This requires no further action. */
3908 bs_class = no_effect;
3911 /* Make sure the action is stop (silent or noisy),
3912 so infrun.c pops the dummy frame. */
3913 bs_class = bp_silent;
3914 retval.call_dummy = 1;
3917 /* Tracepoint hits should not be reported back to GDB, and
3918 if one got through somehow, it should have been filtered
3920 internal_error (__FILE__, __LINE__,
3921 _("bpstat_what: bp_tracepoint encountered"));
3924 current_action = table[(int) bs_class][(int) current_action];
3926 retval.main_action = current_action;
3930 /* Nonzero if we should step constantly (e.g. watchpoints on machines
3931 without hardware support). This isn't related to a specific bpstat,
3932 just to things like whether watchpoints are set. */
3935 bpstat_should_step (void)
3937 struct breakpoint *b;
3939 if (breakpoint_enabled (b) && b->type == bp_watchpoint && b->loc != NULL)
3945 bpstat_causes_stop (bpstat bs)
3947 for (; bs != NULL; bs = bs->next)
3956 /* Print the LOC location out of the list of B->LOC locations. */
3958 static void print_breakpoint_location (struct breakpoint *b,
3959 struct bp_location *loc,
3961 struct ui_stream *stb)
3963 struct cleanup *old_chain = save_current_program_space ();
3965 if (loc != NULL && loc->shlib_disabled)
3969 set_current_program_space (loc->pspace);
3971 if (b->source_file && loc)
3974 = find_pc_sect_function (loc->address, loc->section);
3977 ui_out_text (uiout, "in ");
3978 ui_out_field_string (uiout, "func",
3979 SYMBOL_PRINT_NAME (sym));
3980 ui_out_wrap_hint (uiout, wrap_indent);
3981 ui_out_text (uiout, " at ");
3983 ui_out_field_string (uiout, "file", b->source_file);
3984 ui_out_text (uiout, ":");
3986 if (ui_out_is_mi_like_p (uiout))
3988 struct symtab_and_line sal = find_pc_line (loc->address, 0);
3989 char *fullname = symtab_to_fullname (sal.symtab);
3992 ui_out_field_string (uiout, "fullname", fullname);
3995 ui_out_field_int (uiout, "line", b->line_number);
3999 print_address_symbolic (loc->gdbarch, loc->address, stb->stream,
4001 ui_out_field_stream (uiout, "at", stb);
4004 ui_out_field_string (uiout, "pending", b->addr_string);
4006 do_cleanups (old_chain);
4009 /* Print B to gdb_stdout. */
4011 print_one_breakpoint_location (struct breakpoint *b,
4012 struct bp_location *loc,
4014 struct bp_location **last_loc,
4015 int print_address_bits,
4018 struct command_line *l;
4020 struct ep_type_description
4025 static struct ep_type_description bptypes[] =
4027 {bp_none, "?deleted?"},
4028 {bp_breakpoint, "breakpoint"},
4029 {bp_hardware_breakpoint, "hw breakpoint"},
4030 {bp_until, "until"},
4031 {bp_finish, "finish"},
4032 {bp_watchpoint, "watchpoint"},
4033 {bp_hardware_watchpoint, "hw watchpoint"},
4034 {bp_read_watchpoint, "read watchpoint"},
4035 {bp_access_watchpoint, "acc watchpoint"},
4036 {bp_longjmp, "longjmp"},
4037 {bp_longjmp_resume, "longjmp resume"},
4038 {bp_step_resume, "step resume"},
4039 {bp_watchpoint_scope, "watchpoint scope"},
4040 {bp_call_dummy, "call dummy"},
4041 {bp_shlib_event, "shlib events"},
4042 {bp_thread_event, "thread events"},
4043 {bp_overlay_event, "overlay events"},
4044 {bp_longjmp_master, "longjmp master"},
4045 {bp_catchpoint, "catchpoint"},
4046 {bp_tracepoint, "tracepoint"},
4047 {bp_jit_event, "jit events"},
4050 static char bpenables[] = "nynny";
4051 char wrap_indent[80];
4052 struct ui_stream *stb = ui_out_stream_new (uiout);
4053 struct cleanup *old_chain = make_cleanup_ui_out_stream_delete (stb);
4054 struct cleanup *bkpt_chain;
4056 int header_of_multiple = 0;
4057 int part_of_multiple = (loc != NULL);
4058 struct value_print_options opts;
4060 get_user_print_options (&opts);
4062 gdb_assert (!loc || loc_number != 0);
4063 /* See comment in print_one_breakpoint concerning
4064 treatment of breakpoints with single disabled
4068 && (b->loc->next != NULL || !b->loc->enabled)))
4069 header_of_multiple = 1;
4074 bkpt_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "bkpt");
4078 if (part_of_multiple)
4081 formatted = xstrprintf ("%d.%d", b->number, loc_number);
4082 ui_out_field_string (uiout, "number", formatted);
4087 ui_out_field_int (uiout, "number", b->number);
4092 if (part_of_multiple)
4093 ui_out_field_skip (uiout, "type");
4096 if (((int) b->type >= (sizeof (bptypes) / sizeof (bptypes[0])))
4097 || ((int) b->type != bptypes[(int) b->type].type))
4098 internal_error (__FILE__, __LINE__,
4099 _("bptypes table does not describe type #%d."),
4101 ui_out_field_string (uiout, "type", bptypes[(int) b->type].description);
4106 if (part_of_multiple)
4107 ui_out_field_skip (uiout, "disp");
4109 ui_out_field_string (uiout, "disp", bpdisp_text (b->disposition));
4114 if (part_of_multiple)
4115 ui_out_field_string (uiout, "enabled", loc->enabled ? "y" : "n");
4117 ui_out_field_fmt (uiout, "enabled", "%c",
4118 bpenables[(int) b->enable_state]);
4119 ui_out_spaces (uiout, 2);
4123 strcpy (wrap_indent, " ");
4124 if (opts.addressprint)
4126 if (print_address_bits <= 32)
4127 strcat (wrap_indent, " ");
4129 strcat (wrap_indent, " ");
4132 if (b->ops != NULL && b->ops->print_one != NULL)
4134 /* Although the print_one can possibly print
4135 all locations, calling it here is not likely
4136 to get any nice result. So, make sure there's
4137 just one location. */
4138 gdb_assert (b->loc == NULL || b->loc->next == NULL);
4139 b->ops->print_one (b, last_loc);
4145 internal_error (__FILE__, __LINE__,
4146 _("print_one_breakpoint: bp_none encountered\n"));
4150 case bp_hardware_watchpoint:
4151 case bp_read_watchpoint:
4152 case bp_access_watchpoint:
4153 /* Field 4, the address, is omitted (which makes the columns
4154 not line up too nicely with the headers, but the effect
4155 is relatively readable). */
4156 if (opts.addressprint)
4157 ui_out_field_skip (uiout, "addr");
4159 ui_out_field_string (uiout, "what", b->exp_string);
4163 case bp_hardware_breakpoint:
4167 case bp_longjmp_resume:
4168 case bp_step_resume:
4169 case bp_watchpoint_scope:
4171 case bp_shlib_event:
4172 case bp_thread_event:
4173 case bp_overlay_event:
4174 case bp_longjmp_master:
4177 if (opts.addressprint)
4180 if (header_of_multiple)
4181 ui_out_field_string (uiout, "addr", "<MULTIPLE>");
4182 else if (b->loc == NULL || loc->shlib_disabled)
4183 ui_out_field_string (uiout, "addr", "<PENDING>");
4185 ui_out_field_core_addr (uiout, "addr",
4186 loc->gdbarch, loc->address);
4189 if (!header_of_multiple)
4190 print_breakpoint_location (b, loc, wrap_indent, stb);
4197 /* For backward compatibility, don't display inferiors unless there
4200 && !header_of_multiple
4202 || (!gdbarch_has_global_breakpoints (target_gdbarch)
4203 && (number_of_program_spaces () > 1
4204 || number_of_inferiors () > 1)
4205 && loc->owner->type != bp_catchpoint)))
4207 struct inferior *inf;
4210 for (inf = inferior_list; inf != NULL; inf = inf->next)
4212 if (inf->pspace == loc->pspace)
4217 ui_out_text (uiout, " inf ");
4220 ui_out_text (uiout, ", ");
4221 ui_out_text (uiout, plongest (inf->num));
4226 if (!part_of_multiple)
4228 if (b->thread != -1)
4230 /* FIXME: This seems to be redundant and lost here; see the
4231 "stop only in" line a little further down. */
4232 ui_out_text (uiout, " thread ");
4233 ui_out_field_int (uiout, "thread", b->thread);
4235 else if (b->task != 0)
4237 ui_out_text (uiout, " task ");
4238 ui_out_field_int (uiout, "task", b->task);
4242 ui_out_text (uiout, "\n");
4244 if (part_of_multiple && frame_id_p (b->frame_id))
4247 ui_out_text (uiout, "\tstop only in stack frame at ");
4248 /* FIXME: cagney/2002-12-01: Shouldn't be poeking around inside
4250 ui_out_field_core_addr (uiout, "frame",
4251 b->gdbarch, b->frame_id.stack_addr);
4252 ui_out_text (uiout, "\n");
4255 if (!part_of_multiple && b->cond_string && !ada_exception_catchpoint_p (b))
4257 /* We do not print the condition for Ada exception catchpoints
4258 because the condition is an internal implementation detail
4259 that we do not want to expose to the user. */
4261 if (b->type == bp_tracepoint)
4262 ui_out_text (uiout, "\ttrace only if ");
4264 ui_out_text (uiout, "\tstop only if ");
4265 ui_out_field_string (uiout, "cond", b->cond_string);
4266 ui_out_text (uiout, "\n");
4269 if (!part_of_multiple && b->thread != -1)
4271 /* FIXME should make an annotation for this */
4272 ui_out_text (uiout, "\tstop only in thread ");
4273 ui_out_field_int (uiout, "thread", b->thread);
4274 ui_out_text (uiout, "\n");
4277 if (!part_of_multiple && b->hit_count)
4279 /* FIXME should make an annotation for this */
4280 if (ep_is_catchpoint (b))
4281 ui_out_text (uiout, "\tcatchpoint");
4283 ui_out_text (uiout, "\tbreakpoint");
4284 ui_out_text (uiout, " already hit ");
4285 ui_out_field_int (uiout, "times", b->hit_count);
4286 if (b->hit_count == 1)
4287 ui_out_text (uiout, " time\n");
4289 ui_out_text (uiout, " times\n");
4292 /* Output the count also if it is zero, but only if this is
4293 mi. FIXME: Should have a better test for this. */
4294 if (ui_out_is_mi_like_p (uiout))
4295 if (!part_of_multiple && b->hit_count == 0)
4296 ui_out_field_int (uiout, "times", b->hit_count);
4298 if (!part_of_multiple && b->ignore_count)
4301 ui_out_text (uiout, "\tignore next ");
4302 ui_out_field_int (uiout, "ignore", b->ignore_count);
4303 ui_out_text (uiout, " hits\n");
4307 if (!part_of_multiple && l)
4309 struct cleanup *script_chain;
4312 script_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "script");
4313 print_command_lines (uiout, l, 4);
4314 do_cleanups (script_chain);
4317 if (!part_of_multiple && b->pass_count)
4319 annotate_field (10);
4320 ui_out_text (uiout, "\tpass count ");
4321 ui_out_field_int (uiout, "pass", b->pass_count);
4322 ui_out_text (uiout, " \n");
4325 if (!part_of_multiple && b->step_count)
4327 annotate_field (11);
4328 ui_out_text (uiout, "\tstep count ");
4329 ui_out_field_int (uiout, "step", b->step_count);
4330 ui_out_text (uiout, " \n");
4333 if (!part_of_multiple && b->actions)
4335 struct action_line *action;
4336 annotate_field (12);
4337 for (action = b->actions; action; action = action->next)
4339 ui_out_text (uiout, " A\t");
4340 ui_out_text (uiout, action->action);
4341 ui_out_text (uiout, "\n");
4345 if (ui_out_is_mi_like_p (uiout) && !part_of_multiple)
4348 ui_out_field_string (uiout, "original-location", b->addr_string);
4349 else if (b->exp_string)
4350 ui_out_field_string (uiout, "original-location", b->exp_string);
4353 do_cleanups (bkpt_chain);
4354 do_cleanups (old_chain);
4358 print_one_breakpoint (struct breakpoint *b,
4359 struct bp_location **last_loc, int print_address_bits,
4362 print_one_breakpoint_location (b, NULL, 0, last_loc,
4363 print_address_bits, allflag);
4365 /* If this breakpoint has custom print function,
4366 it's already printed. Otherwise, print individual
4367 locations, if any. */
4368 if (b->ops == NULL || b->ops->print_one == NULL)
4370 /* If breakpoint has a single location that is
4371 disabled, we print it as if it had
4372 several locations, since otherwise it's hard to
4373 represent "breakpoint enabled, location disabled"
4375 Note that while hardware watchpoints have
4376 several locations internally, that's no a property
4379 && !is_hardware_watchpoint (b)
4380 && (b->loc->next || !b->loc->enabled)
4381 && !ui_out_is_mi_like_p (uiout))
4383 struct bp_location *loc;
4385 for (loc = b->loc; loc; loc = loc->next, ++n)
4386 print_one_breakpoint_location (b, loc, n, last_loc,
4387 print_address_bits, allflag);
4393 breakpoint_address_bits (struct breakpoint *b)
4395 int print_address_bits = 0;
4396 struct bp_location *loc;
4398 for (loc = b->loc; loc; loc = loc->next)
4400 int addr_bit = gdbarch_addr_bit (loc->gdbarch);
4401 if (addr_bit > print_address_bits)
4402 print_address_bits = addr_bit;
4405 return print_address_bits;
4408 struct captured_breakpoint_query_args
4414 do_captured_breakpoint_query (struct ui_out *uiout, void *data)
4416 struct captured_breakpoint_query_args *args = data;
4417 struct breakpoint *b;
4418 struct bp_location *dummy_loc = NULL;
4421 if (args->bnum == b->number)
4423 int print_address_bits = breakpoint_address_bits (b);
4424 print_one_breakpoint (b, &dummy_loc, print_address_bits, 0);
4432 gdb_breakpoint_query (struct ui_out *uiout, int bnum, char **error_message)
4434 struct captured_breakpoint_query_args args;
4436 /* For the moment we don't trust print_one_breakpoint() to not throw
4438 if (catch_exceptions_with_msg (uiout, do_captured_breakpoint_query, &args,
4439 error_message, RETURN_MASK_ALL) < 0)
4445 /* Return non-zero if B is user settable (breakpoints, watchpoints,
4446 catchpoints, et.al.). */
4449 user_settable_breakpoint (const struct breakpoint *b)
4451 return (b->type == bp_breakpoint
4452 || b->type == bp_catchpoint
4453 || b->type == bp_hardware_breakpoint
4454 || b->type == bp_tracepoint
4455 || b->type == bp_watchpoint
4456 || b->type == bp_read_watchpoint
4457 || b->type == bp_access_watchpoint
4458 || b->type == bp_hardware_watchpoint);
4461 /* Print information on user settable breakpoint (watchpoint, etc)
4462 number BNUM. If BNUM is -1 print all user settable breakpoints.
4463 If ALLFLAG is non-zero, include non- user settable breakpoints. */
4466 breakpoint_1 (int bnum, int allflag)
4468 struct breakpoint *b;
4469 struct bp_location *last_loc = NULL;
4470 int nr_printable_breakpoints;
4471 struct cleanup *bkpttbl_chain;
4472 struct value_print_options opts;
4473 int print_address_bits = 0;
4475 get_user_print_options (&opts);
4477 /* Compute the number of rows in the table, as well as the
4478 size required for address fields. */
4479 nr_printable_breakpoints = 0;
4482 || bnum == b->number)
4484 if (allflag || user_settable_breakpoint (b))
4486 int addr_bit = breakpoint_address_bits (b);
4487 if (addr_bit > print_address_bits)
4488 print_address_bits = addr_bit;
4490 nr_printable_breakpoints++;
4494 if (opts.addressprint)
4496 = make_cleanup_ui_out_table_begin_end (uiout, 6, nr_printable_breakpoints,
4500 = make_cleanup_ui_out_table_begin_end (uiout, 5, nr_printable_breakpoints,
4503 if (nr_printable_breakpoints > 0)
4504 annotate_breakpoints_headers ();
4505 if (nr_printable_breakpoints > 0)
4507 ui_out_table_header (uiout, 7, ui_left, "number", "Num"); /* 1 */
4508 if (nr_printable_breakpoints > 0)
4510 ui_out_table_header (uiout, 14, ui_left, "type", "Type"); /* 2 */
4511 if (nr_printable_breakpoints > 0)
4513 ui_out_table_header (uiout, 4, ui_left, "disp", "Disp"); /* 3 */
4514 if (nr_printable_breakpoints > 0)
4516 ui_out_table_header (uiout, 3, ui_left, "enabled", "Enb"); /* 4 */
4517 if (opts.addressprint)
4519 if (nr_printable_breakpoints > 0)
4521 if (print_address_bits <= 32)
4522 ui_out_table_header (uiout, 10, ui_left, "addr", "Address");/* 5 */
4524 ui_out_table_header (uiout, 18, ui_left, "addr", "Address");/* 5 */
4526 if (nr_printable_breakpoints > 0)
4528 ui_out_table_header (uiout, 40, ui_noalign, "what", "What"); /* 6 */
4529 ui_out_table_body (uiout);
4530 if (nr_printable_breakpoints > 0)
4531 annotate_breakpoints_table ();
4535 || bnum == b->number)
4537 /* We only print out user settable breakpoints unless the
4539 if (allflag || user_settable_breakpoint (b))
4540 print_one_breakpoint (b, &last_loc, print_address_bits, allflag);
4543 do_cleanups (bkpttbl_chain);
4545 if (nr_printable_breakpoints == 0)
4548 ui_out_message (uiout, 0, "No breakpoints or watchpoints.\n");
4550 ui_out_message (uiout, 0, "No breakpoint or watchpoint number %d.\n",
4555 if (last_loc && !server_command)
4556 set_next_address (last_loc->gdbarch, last_loc->address);
4559 /* FIXME? Should this be moved up so that it is only called when
4560 there have been breakpoints? */
4561 annotate_breakpoints_table_end ();
4565 breakpoints_info (char *bnum_exp, int from_tty)
4570 bnum = parse_and_eval_long (bnum_exp);
4572 breakpoint_1 (bnum, 0);
4576 maintenance_info_breakpoints (char *bnum_exp, int from_tty)
4581 bnum = parse_and_eval_long (bnum_exp);
4583 breakpoint_1 (bnum, 1);
4587 breakpoint_has_pc (struct breakpoint *b,
4588 struct program_space *pspace,
4589 CORE_ADDR pc, struct obj_section *section)
4591 struct bp_location *bl = b->loc;
4592 for (; bl; bl = bl->next)
4594 if (bl->pspace == pspace
4595 && bl->address == pc
4596 && (!overlay_debugging || bl->section == section))
4602 /* Print a message describing any breakpoints set at PC. This
4603 concerns with logical breakpoints, so we match program spaces, not
4607 describe_other_breakpoints (struct gdbarch *gdbarch,
4608 struct program_space *pspace, CORE_ADDR pc,
4609 struct obj_section *section, int thread)
4612 struct breakpoint *b;
4615 others += breakpoint_has_pc (b, pspace, pc, section);
4619 printf_filtered (_("Note: breakpoint "));
4620 else /* if (others == ???) */
4621 printf_filtered (_("Note: breakpoints "));
4623 if (breakpoint_has_pc (b, pspace, pc, section))
4626 printf_filtered ("%d", b->number);
4627 if (b->thread == -1 && thread != -1)
4628 printf_filtered (" (all threads)");
4629 else if (b->thread != -1)
4630 printf_filtered (" (thread %d)", b->thread);
4631 printf_filtered ("%s%s ",
4632 ((b->enable_state == bp_disabled
4633 || b->enable_state == bp_call_disabled
4634 || b->enable_state == bp_startup_disabled)
4636 : b->enable_state == bp_permanent
4640 : ((others == 1) ? " and" : ""));
4642 printf_filtered (_("also set at pc "));
4643 fputs_filtered (paddress (gdbarch, pc), gdb_stdout);
4644 printf_filtered (".\n");
4648 /* Set the default place to put a breakpoint
4649 for the `break' command with no arguments. */
4652 set_default_breakpoint (int valid, struct program_space *pspace,
4653 CORE_ADDR addr, struct symtab *symtab,
4656 default_breakpoint_valid = valid;
4657 default_breakpoint_pspace = pspace;
4658 default_breakpoint_address = addr;
4659 default_breakpoint_symtab = symtab;
4660 default_breakpoint_line = line;
4663 /* Return true iff it is meaningful to use the address member of
4664 BPT. For some breakpoint types, the address member is irrelevant
4665 and it makes no sense to attempt to compare it to other addresses
4666 (or use it for any other purpose either).
4668 More specifically, each of the following breakpoint types will always
4669 have a zero valued address and we don't want to mark breakpoints of any of
4670 these types to be a duplicate of an actual breakpoint at address zero:
4678 breakpoint_address_is_meaningful (struct breakpoint *bpt)
4680 enum bptype type = bpt->type;
4682 return (type != bp_watchpoint && type != bp_catchpoint);
4685 /* Assuming LOC1 and LOC2's owners are hardware watchpoints, returns
4686 true if LOC1 and LOC2 represent the same watchpoint location. */
4689 watchpoint_locations_match (struct bp_location *loc1, struct bp_location *loc2)
4691 return (loc1->owner->type == loc2->owner->type
4692 && loc1->pspace->aspace == loc2->pspace->aspace
4693 && loc1->address == loc2->address
4694 && loc1->length == loc2->length);
4697 /* Returns true if {ASPACE1,ADDR1} and {ASPACE2,ADDR2} represent the
4698 same breakpoint location. In most targets, this can only be true
4699 if ASPACE1 matches ASPACE2. On targets that have global
4700 breakpoints, the address space doesn't really matter. */
4703 breakpoint_address_match (struct address_space *aspace1, CORE_ADDR addr1,
4704 struct address_space *aspace2, CORE_ADDR addr2)
4706 return ((gdbarch_has_global_breakpoints (target_gdbarch)
4707 || aspace1 == aspace2)
4711 /* Assuming LOC1 and LOC2's types' have meaningful target addresses
4712 (breakpoint_address_is_meaningful), returns true if LOC1 and LOC2
4713 represent the same location. */
4716 breakpoint_locations_match (struct bp_location *loc1, struct bp_location *loc2)
4718 int hw_point1 = is_hardware_watchpoint (loc1->owner);
4719 int hw_point2 = is_hardware_watchpoint (loc2->owner);
4721 if (hw_point1 != hw_point2)
4724 return watchpoint_locations_match (loc1, loc2);
4726 return breakpoint_address_match (loc1->pspace->aspace, loc1->address,
4727 loc2->pspace->aspace, loc2->address);
4731 breakpoint_adjustment_warning (CORE_ADDR from_addr, CORE_ADDR to_addr,
4732 int bnum, int have_bnum)
4737 strcpy (astr1, hex_string_custom ((unsigned long) from_addr, 8));
4738 strcpy (astr2, hex_string_custom ((unsigned long) to_addr, 8));
4740 warning (_("Breakpoint %d address previously adjusted from %s to %s."),
4741 bnum, astr1, astr2);
4743 warning (_("Breakpoint address adjusted from %s to %s."), astr1, astr2);
4746 /* Adjust a breakpoint's address to account for architectural constraints
4747 on breakpoint placement. Return the adjusted address. Note: Very
4748 few targets require this kind of adjustment. For most targets,
4749 this function is simply the identity function. */
4752 adjust_breakpoint_address (struct gdbarch *gdbarch,
4753 CORE_ADDR bpaddr, enum bptype bptype)
4755 if (!gdbarch_adjust_breakpoint_address_p (gdbarch))
4757 /* Very few targets need any kind of breakpoint adjustment. */
4760 else if (bptype == bp_watchpoint
4761 || bptype == bp_hardware_watchpoint
4762 || bptype == bp_read_watchpoint
4763 || bptype == bp_access_watchpoint
4764 || bptype == bp_catchpoint)
4766 /* Watchpoints and the various bp_catch_* eventpoints should not
4767 have their addresses modified. */
4772 CORE_ADDR adjusted_bpaddr;
4774 /* Some targets have architectural constraints on the placement
4775 of breakpoint instructions. Obtain the adjusted address. */
4776 adjusted_bpaddr = gdbarch_adjust_breakpoint_address (gdbarch, bpaddr);
4778 /* An adjusted breakpoint address can significantly alter
4779 a user's expectations. Print a warning if an adjustment
4781 if (adjusted_bpaddr != bpaddr)
4782 breakpoint_adjustment_warning (bpaddr, adjusted_bpaddr, 0, 0);
4784 return adjusted_bpaddr;
4788 /* Allocate a struct bp_location. */
4790 static struct bp_location *
4791 allocate_bp_location (struct breakpoint *bpt)
4793 struct bp_location *loc, *loc_p;
4795 loc = xmalloc (sizeof (struct bp_location));
4796 memset (loc, 0, sizeof (*loc));
4800 loc->shlib_disabled = 0;
4810 case bp_longjmp_resume:
4811 case bp_step_resume:
4812 case bp_watchpoint_scope:
4814 case bp_shlib_event:
4815 case bp_thread_event:
4816 case bp_overlay_event:
4818 case bp_longjmp_master:
4819 loc->loc_type = bp_loc_software_breakpoint;
4821 case bp_hardware_breakpoint:
4822 loc->loc_type = bp_loc_hardware_breakpoint;
4824 case bp_hardware_watchpoint:
4825 case bp_read_watchpoint:
4826 case bp_access_watchpoint:
4827 loc->loc_type = bp_loc_hardware_watchpoint;
4831 loc->loc_type = bp_loc_other;
4834 internal_error (__FILE__, __LINE__, _("unknown breakpoint type"));
4840 static void free_bp_location (struct bp_location *loc)
4845 if (loc->function_name)
4846 xfree (loc->function_name);
4851 /* Helper to set_raw_breakpoint below. Creates a breakpoint
4852 that has type BPTYPE and has no locations as yet. */
4853 /* This function is used in gdbtk sources and thus can not be made static. */
4855 static struct breakpoint *
4856 set_raw_breakpoint_without_location (struct gdbarch *gdbarch,
4859 struct breakpoint *b, *b1;
4861 b = (struct breakpoint *) xmalloc (sizeof (struct breakpoint));
4862 memset (b, 0, sizeof (*b));
4865 b->gdbarch = gdbarch;
4866 b->language = current_language->la_language;
4867 b->input_radix = input_radix;
4869 b->enable_state = bp_enabled;
4872 b->ignore_count = 0;
4874 b->frame_id = null_frame_id;
4875 b->forked_inferior_pid = null_ptid;
4876 b->exec_pathname = NULL;
4877 b->syscalls_to_be_caught = NULL;
4879 b->condition_not_parsed = 0;
4881 /* Add this breakpoint to the end of the chain
4882 so that a list of breakpoints will come out in order
4883 of increasing numbers. */
4885 b1 = breakpoint_chain;
4887 breakpoint_chain = b;
4897 /* Initialize loc->function_name. */
4899 set_breakpoint_location_function (struct bp_location *loc)
4901 if (loc->owner->type == bp_breakpoint
4902 || loc->owner->type == bp_hardware_breakpoint
4903 || loc->owner->type == bp_tracepoint)
4905 find_pc_partial_function (loc->address, &(loc->function_name),
4907 if (loc->function_name)
4908 loc->function_name = xstrdup (loc->function_name);
4912 /* Attempt to determine architecture of location identified by SAL. */
4913 static struct gdbarch *
4914 get_sal_arch (struct symtab_and_line sal)
4917 return get_objfile_arch (sal.section->objfile);
4919 return get_objfile_arch (sal.symtab->objfile);
4924 /* set_raw_breakpoint is a low level routine for allocating and
4925 partially initializing a breakpoint of type BPTYPE. The newly
4926 created breakpoint's address, section, source file name, and line
4927 number are provided by SAL. The newly created and partially
4928 initialized breakpoint is added to the breakpoint chain and
4929 is also returned as the value of this function.
4931 It is expected that the caller will complete the initialization of
4932 the newly created breakpoint struct as well as output any status
4933 information regarding the creation of a new breakpoint. In
4934 particular, set_raw_breakpoint does NOT set the breakpoint
4935 number! Care should be taken to not allow an error to occur
4936 prior to completing the initialization of the breakpoint. If this
4937 should happen, a bogus breakpoint will be left on the chain. */
4940 set_raw_breakpoint (struct gdbarch *gdbarch,
4941 struct symtab_and_line sal, enum bptype bptype)
4943 struct breakpoint *b = set_raw_breakpoint_without_location (gdbarch, bptype);
4944 CORE_ADDR adjusted_address;
4945 struct gdbarch *loc_gdbarch;
4947 loc_gdbarch = get_sal_arch (sal);
4949 loc_gdbarch = b->gdbarch;
4951 if (bptype != bp_catchpoint)
4952 gdb_assert (sal.pspace != NULL);
4954 /* Adjust the breakpoint's address prior to allocating a location.
4955 Once we call allocate_bp_location(), that mostly uninitialized
4956 location will be placed on the location chain. Adjustment of the
4957 breakpoint may cause target_read_memory() to be called and we do
4958 not want its scan of the location chain to find a breakpoint and
4959 location that's only been partially initialized. */
4960 adjusted_address = adjust_breakpoint_address (loc_gdbarch, sal.pc, b->type);
4962 b->loc = allocate_bp_location (b);
4963 b->loc->gdbarch = loc_gdbarch;
4964 b->loc->requested_address = sal.pc;
4965 b->loc->address = adjusted_address;
4966 b->loc->pspace = sal.pspace;
4968 /* Store the program space that was used to set the breakpoint, for
4969 breakpoint resetting. */
4970 b->pspace = sal.pspace;
4972 if (sal.symtab == NULL)
4973 b->source_file = NULL;
4975 b->source_file = xstrdup (sal.symtab->filename);
4976 b->loc->section = sal.section;
4977 b->line_number = sal.line;
4979 set_breakpoint_location_function (b->loc);
4981 breakpoints_changed ();
4987 /* Note that the breakpoint object B describes a permanent breakpoint
4988 instruction, hard-wired into the inferior's code. */
4990 make_breakpoint_permanent (struct breakpoint *b)
4992 struct bp_location *bl;
4993 b->enable_state = bp_permanent;
4995 /* By definition, permanent breakpoints are already present in the code.
4996 Mark all locations as inserted. For now, make_breakpoint_permanent
4997 is called in just one place, so it's hard to say if it's reasonable
4998 to have permanent breakpoint with multiple locations or not,
4999 but it's easy to implmement. */
5000 for (bl = b->loc; bl; bl = bl->next)
5004 /* Call this routine when stepping and nexting to enable a breakpoint
5005 if we do a longjmp() in THREAD. When we hit that breakpoint, call
5006 set_longjmp_resume_breakpoint() to figure out where we are going. */
5009 set_longjmp_breakpoint (int thread)
5011 struct breakpoint *b, *temp;
5013 /* To avoid having to rescan all objfile symbols at every step,
5014 we maintain a list of continually-inserted but always disabled
5015 longjmp "master" breakpoints. Here, we simply create momentary
5016 clones of those and enable them for the requested thread. */
5017 ALL_BREAKPOINTS_SAFE (b, temp)
5018 if (b->pspace == current_program_space
5019 && b->type == bp_longjmp_master)
5021 struct breakpoint *clone = clone_momentary_breakpoint (b);
5022 clone->type = bp_longjmp;
5023 clone->thread = thread;
5027 /* Delete all longjmp breakpoints from THREAD. */
5029 delete_longjmp_breakpoint (int thread)
5031 struct breakpoint *b, *temp;
5033 ALL_BREAKPOINTS_SAFE (b, temp)
5034 if (b->type == bp_longjmp)
5036 if (b->thread == thread)
5037 delete_breakpoint (b);
5042 enable_overlay_breakpoints (void)
5044 struct breakpoint *b;
5047 if (b->type == bp_overlay_event)
5049 b->enable_state = bp_enabled;
5050 update_global_location_list (1);
5051 overlay_events_enabled = 1;
5056 disable_overlay_breakpoints (void)
5058 struct breakpoint *b;
5061 if (b->type == bp_overlay_event)
5063 b->enable_state = bp_disabled;
5064 update_global_location_list (0);
5065 overlay_events_enabled = 0;
5070 create_thread_event_breakpoint (struct gdbarch *gdbarch, CORE_ADDR address)
5072 struct breakpoint *b;
5074 b = create_internal_breakpoint (gdbarch, address, bp_thread_event);
5076 b->enable_state = bp_enabled;
5077 /* addr_string has to be used or breakpoint_re_set will delete me. */
5079 = xstrprintf ("*%s", paddress (b->loc->gdbarch, b->loc->address));
5081 update_global_location_list_nothrow (1);
5087 remove_thread_event_breakpoints (void)
5089 struct breakpoint *b, *temp;
5091 ALL_BREAKPOINTS_SAFE (b, temp)
5092 if (b->type == bp_thread_event
5093 && b->loc->pspace == current_program_space)
5094 delete_breakpoint (b);
5097 struct captured_parse_breakpoint_args
5100 struct symtabs_and_lines *sals_p;
5101 char ***addr_string_p;
5105 struct lang_and_radix
5111 /* Create a breakpoint for JIT code registration and unregistration. */
5114 create_jit_event_breakpoint (struct gdbarch *gdbarch, CORE_ADDR address)
5116 struct breakpoint *b;
5118 b = create_internal_breakpoint (gdbarch, address, bp_jit_event);
5119 update_global_location_list_nothrow (1);
5124 remove_solib_event_breakpoints (void)
5126 struct breakpoint *b, *temp;
5128 ALL_BREAKPOINTS_SAFE (b, temp)
5129 if (b->type == bp_shlib_event
5130 && b->loc->pspace == current_program_space)
5131 delete_breakpoint (b);
5135 create_solib_event_breakpoint (struct gdbarch *gdbarch, CORE_ADDR address)
5137 struct breakpoint *b;
5139 b = create_internal_breakpoint (gdbarch, address, bp_shlib_event);
5140 update_global_location_list_nothrow (1);
5144 /* Disable any breakpoints that are on code in shared libraries. Only
5145 apply to enabled breakpoints, disabled ones can just stay disabled. */
5148 disable_breakpoints_in_shlibs (void)
5150 struct bp_location *loc, **locp_tmp;
5152 ALL_BP_LOCATIONS (loc, locp_tmp)
5154 struct breakpoint *b = loc->owner;
5155 /* We apply the check to all breakpoints, including disabled
5156 for those with loc->duplicate set. This is so that when breakpoint
5157 becomes enabled, or the duplicate is removed, gdb will try to insert
5158 all breakpoints. If we don't set shlib_disabled here, we'll try
5159 to insert those breakpoints and fail. */
5160 if (((b->type == bp_breakpoint)
5161 || (b->type == bp_hardware_breakpoint)
5162 || (b->type == bp_tracepoint))
5163 && loc->pspace == current_program_space
5164 && !loc->shlib_disabled
5166 && PC_SOLIB (loc->address)
5168 && solib_name_from_address (loc->pspace, loc->address)
5172 loc->shlib_disabled = 1;
5177 /* Disable any breakpoints that are in in an unloaded shared library. Only
5178 apply to enabled breakpoints, disabled ones can just stay disabled. */
5181 disable_breakpoints_in_unloaded_shlib (struct so_list *solib)
5183 struct bp_location *loc, **locp_tmp;
5184 int disabled_shlib_breaks = 0;
5186 /* SunOS a.out shared libraries are always mapped, so do not
5187 disable breakpoints; they will only be reported as unloaded
5188 through clear_solib when GDB discards its shared library
5189 list. See clear_solib for more information. */
5190 if (exec_bfd != NULL
5191 && bfd_get_flavour (exec_bfd) == bfd_target_aout_flavour)
5194 ALL_BP_LOCATIONS (loc, locp_tmp)
5196 struct breakpoint *b = loc->owner;
5197 if ((loc->loc_type == bp_loc_hardware_breakpoint
5198 || loc->loc_type == bp_loc_software_breakpoint)
5199 && solib->pspace == loc->pspace
5200 && !loc->shlib_disabled
5201 && (b->type == bp_breakpoint || b->type == bp_hardware_breakpoint)
5202 && solib_contains_address_p (solib, loc->address))
5204 loc->shlib_disabled = 1;
5205 /* At this point, we cannot rely on remove_breakpoint
5206 succeeding so we must mark the breakpoint as not inserted
5207 to prevent future errors occurring in remove_breakpoints. */
5209 if (!disabled_shlib_breaks)
5211 target_terminal_ours_for_output ();
5212 warning (_("Temporarily disabling breakpoints for unloaded shared library \"%s\""),
5215 disabled_shlib_breaks = 1;
5220 /* FORK & VFORK catchpoints. */
5222 /* Implement the "insert" breakpoint_ops method for fork catchpoints. */
5225 insert_catch_fork (struct breakpoint *b)
5227 target_insert_fork_catchpoint (PIDGET (inferior_ptid));
5230 /* Implement the "remove" breakpoint_ops method for fork catchpoints. */
5233 remove_catch_fork (struct breakpoint *b)
5235 return target_remove_fork_catchpoint (PIDGET (inferior_ptid));
5238 /* Implement the "breakpoint_hit" breakpoint_ops method for fork
5242 breakpoint_hit_catch_fork (struct breakpoint *b)
5244 return inferior_has_forked (inferior_ptid, &b->forked_inferior_pid);
5247 /* Implement the "print_it" breakpoint_ops method for fork catchpoints. */
5249 static enum print_stop_action
5250 print_it_catch_fork (struct breakpoint *b)
5252 annotate_catchpoint (b->number);
5253 printf_filtered (_("\nCatchpoint %d (forked process %d), "),
5254 b->number, ptid_get_pid (b->forked_inferior_pid));
5255 return PRINT_SRC_AND_LOC;
5258 /* Implement the "print_one" breakpoint_ops method for fork catchpoints. */
5261 print_one_catch_fork (struct breakpoint *b, struct bp_location **last_loc)
5263 struct value_print_options opts;
5265 get_user_print_options (&opts);
5267 /* Field 4, the address, is omitted (which makes the columns
5268 not line up too nicely with the headers, but the effect
5269 is relatively readable). */
5270 if (opts.addressprint)
5271 ui_out_field_skip (uiout, "addr");
5273 ui_out_text (uiout, "fork");
5274 if (!ptid_equal (b->forked_inferior_pid, null_ptid))
5276 ui_out_text (uiout, ", process ");
5277 ui_out_field_int (uiout, "what",
5278 ptid_get_pid (b->forked_inferior_pid));
5279 ui_out_spaces (uiout, 1);
5283 /* Implement the "print_mention" breakpoint_ops method for fork
5287 print_mention_catch_fork (struct breakpoint *b)
5289 printf_filtered (_("Catchpoint %d (fork)"), b->number);
5292 /* The breakpoint_ops structure to be used in fork catchpoints. */
5294 static struct breakpoint_ops catch_fork_breakpoint_ops =
5298 breakpoint_hit_catch_fork,
5299 print_it_catch_fork,
5300 print_one_catch_fork,
5301 print_mention_catch_fork
5304 /* Implement the "insert" breakpoint_ops method for vfork catchpoints. */
5307 insert_catch_vfork (struct breakpoint *b)
5309 target_insert_vfork_catchpoint (PIDGET (inferior_ptid));
5312 /* Implement the "remove" breakpoint_ops method for vfork catchpoints. */
5315 remove_catch_vfork (struct breakpoint *b)
5317 return target_remove_vfork_catchpoint (PIDGET (inferior_ptid));
5320 /* Implement the "breakpoint_hit" breakpoint_ops method for vfork
5324 breakpoint_hit_catch_vfork (struct breakpoint *b)
5326 return inferior_has_vforked (inferior_ptid, &b->forked_inferior_pid);
5329 /* Implement the "print_it" breakpoint_ops method for vfork catchpoints. */
5331 static enum print_stop_action
5332 print_it_catch_vfork (struct breakpoint *b)
5334 annotate_catchpoint (b->number);
5335 printf_filtered (_("\nCatchpoint %d (vforked process %d), "),
5336 b->number, ptid_get_pid (b->forked_inferior_pid));
5337 return PRINT_SRC_AND_LOC;
5340 /* Implement the "print_one" breakpoint_ops method for vfork catchpoints. */
5343 print_one_catch_vfork (struct breakpoint *b, struct bp_location **last_loc)
5345 struct value_print_options opts;
5347 get_user_print_options (&opts);
5348 /* Field 4, the address, is omitted (which makes the columns
5349 not line up too nicely with the headers, but the effect
5350 is relatively readable). */
5351 if (opts.addressprint)
5352 ui_out_field_skip (uiout, "addr");
5354 ui_out_text (uiout, "vfork");
5355 if (!ptid_equal (b->forked_inferior_pid, null_ptid))
5357 ui_out_text (uiout, ", process ");
5358 ui_out_field_int (uiout, "what",
5359 ptid_get_pid (b->forked_inferior_pid));
5360 ui_out_spaces (uiout, 1);
5364 /* Implement the "print_mention" breakpoint_ops method for vfork
5368 print_mention_catch_vfork (struct breakpoint *b)
5370 printf_filtered (_("Catchpoint %d (vfork)"), b->number);
5373 /* The breakpoint_ops structure to be used in vfork catchpoints. */
5375 static struct breakpoint_ops catch_vfork_breakpoint_ops =
5379 breakpoint_hit_catch_vfork,
5380 print_it_catch_vfork,
5381 print_one_catch_vfork,
5382 print_mention_catch_vfork
5385 /* Implement the "insert" breakpoint_ops method for syscall
5389 insert_catch_syscall (struct breakpoint *b)
5391 struct inferior *inf = current_inferior ();
5393 ++inf->total_syscalls_count;
5394 if (!b->syscalls_to_be_caught)
5395 ++inf->any_syscall_count;
5400 VEC_iterate (int, b->syscalls_to_be_caught, i, iter);
5404 if (iter >= VEC_length (int, inf->syscalls_counts))
5406 int old_size = VEC_length (int, inf->syscalls_counts);
5407 uintptr_t vec_addr_offset = old_size * ((uintptr_t) sizeof (int));
5409 VEC_safe_grow (int, inf->syscalls_counts, iter + 1);
5410 vec_addr = (uintptr_t) VEC_address (int, inf->syscalls_counts) +
5412 memset ((void *) vec_addr, 0,
5413 (iter + 1 - old_size) * sizeof (int));
5415 elem = VEC_index (int, inf->syscalls_counts, iter);
5416 VEC_replace (int, inf->syscalls_counts, iter, ++elem);
5420 target_set_syscall_catchpoint (PIDGET (inferior_ptid),
5421 inf->total_syscalls_count != 0,
5422 inf->any_syscall_count,
5423 VEC_length (int, inf->syscalls_counts),
5424 VEC_address (int, inf->syscalls_counts));
5427 /* Implement the "remove" breakpoint_ops method for syscall
5431 remove_catch_syscall (struct breakpoint *b)
5433 struct inferior *inf = current_inferior ();
5435 --inf->total_syscalls_count;
5436 if (!b->syscalls_to_be_caught)
5437 --inf->any_syscall_count;
5442 VEC_iterate (int, b->syscalls_to_be_caught, i, iter);
5446 if (iter >= VEC_length (int, inf->syscalls_counts))
5447 /* Shouldn't happen. */
5449 elem = VEC_index (int, inf->syscalls_counts, iter);
5450 VEC_replace (int, inf->syscalls_counts, iter, --elem);
5454 return target_set_syscall_catchpoint (PIDGET (inferior_ptid),
5455 inf->total_syscalls_count != 0,
5456 inf->any_syscall_count,
5457 VEC_length (int, inf->syscalls_counts),
5458 VEC_address (int, inf->syscalls_counts));
5461 /* Implement the "breakpoint_hit" breakpoint_ops method for syscall
5465 breakpoint_hit_catch_syscall (struct breakpoint *b)
5467 /* We must check if we are catching specific syscalls in this breakpoint.
5468 If we are, then we must guarantee that the called syscall is the same
5469 syscall we are catching. */
5470 int syscall_number = 0;
5472 if (!inferior_has_called_syscall (inferior_ptid, &syscall_number))
5475 /* Now, checking if the syscall is the same. */
5476 if (b->syscalls_to_be_caught)
5480 VEC_iterate (int, b->syscalls_to_be_caught, i, iter);
5482 if (syscall_number == iter)
5492 /* Implement the "print_it" breakpoint_ops method for syscall
5495 static enum print_stop_action
5496 print_it_catch_syscall (struct breakpoint *b)
5498 /* These are needed because we want to know in which state a
5499 syscall is. It can be in the TARGET_WAITKIND_SYSCALL_ENTRY
5500 or TARGET_WAITKIND_SYSCALL_RETURN, and depending on it we
5501 must print "called syscall" or "returned from syscall". */
5503 struct target_waitstatus last;
5505 struct cleanup *old_chain;
5508 get_last_target_status (&ptid, &last);
5510 get_syscall_by_number (last.value.syscall_number, &s);
5512 annotate_catchpoint (b->number);
5515 syscall_id = xstrprintf ("%d", last.value.syscall_number);
5517 syscall_id = xstrprintf ("'%s'", s.name);
5519 old_chain = make_cleanup (xfree, syscall_id);
5521 if (last.kind == TARGET_WAITKIND_SYSCALL_ENTRY)
5522 printf_filtered (_("\nCatchpoint %d (call to syscall %s), "),
5523 b->number, syscall_id);
5524 else if (last.kind == TARGET_WAITKIND_SYSCALL_RETURN)
5525 printf_filtered (_("\nCatchpoint %d (returned from syscall %s), "),
5526 b->number, syscall_id);
5528 do_cleanups (old_chain);
5530 return PRINT_SRC_AND_LOC;
5533 /* Implement the "print_one" breakpoint_ops method for syscall
5537 print_one_catch_syscall (struct breakpoint *b,
5538 struct bp_location **last_loc)
5540 struct value_print_options opts;
5542 get_user_print_options (&opts);
5543 /* Field 4, the address, is omitted (which makes the columns
5544 not line up too nicely with the headers, but the effect
5545 is relatively readable). */
5546 if (opts.addressprint)
5547 ui_out_field_skip (uiout, "addr");
5550 if (b->syscalls_to_be_caught
5551 && VEC_length (int, b->syscalls_to_be_caught) > 1)
5552 ui_out_text (uiout, "syscalls \"");
5554 ui_out_text (uiout, "syscall \"");
5556 if (b->syscalls_to_be_caught)
5559 char *text = xstrprintf ("%s", "");
5561 VEC_iterate (int, b->syscalls_to_be_caught, i, iter);
5566 get_syscall_by_number (iter, &s);
5569 text = xstrprintf ("%s%s, ", text, s.name);
5571 text = xstrprintf ("%s%d, ", text, iter);
5573 /* We have to xfree the last 'text' (now stored at 'x')
5574 because xstrprintf dinamically allocates new space for it
5578 /* Remove the last comma. */
5579 text[strlen (text) - 2] = '\0';
5580 ui_out_field_string (uiout, "what", text);
5583 ui_out_field_string (uiout, "what", "<any syscall>");
5584 ui_out_text (uiout, "\" ");
5587 /* Implement the "print_mention" breakpoint_ops method for syscall
5591 print_mention_catch_syscall (struct breakpoint *b)
5593 if (b->syscalls_to_be_caught)
5597 if (VEC_length (int, b->syscalls_to_be_caught) > 1)
5598 printf_filtered (_("Catchpoint %d (syscalls"), b->number);
5600 printf_filtered (_("Catchpoint %d (syscall"), b->number);
5603 VEC_iterate (int, b->syscalls_to_be_caught, i, iter);
5607 get_syscall_by_number (iter, &s);
5610 printf_filtered (" '%s' [%d]", s.name, s.number);
5612 printf_filtered (" %d", s.number);
5614 printf_filtered (")");
5617 printf_filtered (_("Catchpoint %d (any syscall)"),
5621 /* The breakpoint_ops structure to be used in syscall catchpoints. */
5623 static struct breakpoint_ops catch_syscall_breakpoint_ops =
5625 insert_catch_syscall,
5626 remove_catch_syscall,
5627 breakpoint_hit_catch_syscall,
5628 print_it_catch_syscall,
5629 print_one_catch_syscall,
5630 print_mention_catch_syscall
5633 /* Returns non-zero if 'b' is a syscall catchpoint. */
5636 syscall_catchpoint_p (struct breakpoint *b)
5638 return (b->ops == &catch_syscall_breakpoint_ops);
5641 /* Create a new breakpoint of the bp_catchpoint kind and return it,
5642 but does NOT mention it nor update the global location list.
5643 This is useful if you need to fill more fields in the
5644 struct breakpoint before calling mention.
5646 If TEMPFLAG is non-zero, then make the breakpoint temporary.
5647 If COND_STRING is not NULL, then store it in the breakpoint.
5648 OPS, if not NULL, is the breakpoint_ops structure associated
5649 to the catchpoint. */
5651 static struct breakpoint *
5652 create_catchpoint_without_mention (struct gdbarch *gdbarch, int tempflag,
5654 struct breakpoint_ops *ops)
5656 struct symtab_and_line sal;
5657 struct breakpoint *b;
5660 sal.pspace = current_program_space;
5662 b = set_raw_breakpoint (gdbarch, sal, bp_catchpoint);
5663 set_breakpoint_count (breakpoint_count + 1);
5664 b->number = breakpoint_count;
5666 b->cond_string = (cond_string == NULL) ? NULL : xstrdup (cond_string);
5668 b->addr_string = NULL;
5669 b->enable_state = bp_enabled;
5670 b->disposition = tempflag ? disp_del : disp_donttouch;
5676 /* Create a new breakpoint of the bp_catchpoint kind and return it.
5678 If TEMPFLAG is non-zero, then make the breakpoint temporary.
5679 If COND_STRING is not NULL, then store it in the breakpoint.
5680 OPS, if not NULL, is the breakpoint_ops structure associated
5681 to the catchpoint. */
5683 static struct breakpoint *
5684 create_catchpoint (struct gdbarch *gdbarch, int tempflag,
5685 char *cond_string, struct breakpoint_ops *ops)
5687 struct breakpoint *b =
5688 create_catchpoint_without_mention (gdbarch, tempflag, cond_string, ops);
5691 update_global_location_list (1);
5697 create_fork_vfork_event_catchpoint (struct gdbarch *gdbarch,
5698 int tempflag, char *cond_string,
5699 struct breakpoint_ops *ops)
5701 struct breakpoint *b
5702 = create_catchpoint (gdbarch, tempflag, cond_string, ops);
5704 /* FIXME: We should put this information in a breakpoint private data
5706 b->forked_inferior_pid = null_ptid;
5709 /* Exec catchpoints. */
5712 insert_catch_exec (struct breakpoint *b)
5714 target_insert_exec_catchpoint (PIDGET (inferior_ptid));
5718 remove_catch_exec (struct breakpoint *b)
5720 return target_remove_exec_catchpoint (PIDGET (inferior_ptid));
5724 breakpoint_hit_catch_exec (struct breakpoint *b)
5726 return inferior_has_execd (inferior_ptid, &b->exec_pathname);
5729 static enum print_stop_action
5730 print_it_catch_exec (struct breakpoint *b)
5732 annotate_catchpoint (b->number);
5733 printf_filtered (_("\nCatchpoint %d (exec'd %s), "), b->number,
5735 return PRINT_SRC_AND_LOC;
5739 print_one_catch_exec (struct breakpoint *b, struct bp_location **last_loc)
5741 struct value_print_options opts;
5743 get_user_print_options (&opts);
5745 /* Field 4, the address, is omitted (which makes the columns
5746 not line up too nicely with the headers, but the effect
5747 is relatively readable). */
5748 if (opts.addressprint)
5749 ui_out_field_skip (uiout, "addr");
5751 ui_out_text (uiout, "exec");
5752 if (b->exec_pathname != NULL)
5754 ui_out_text (uiout, ", program \"");
5755 ui_out_field_string (uiout, "what", b->exec_pathname);
5756 ui_out_text (uiout, "\" ");
5761 print_mention_catch_exec (struct breakpoint *b)
5763 printf_filtered (_("Catchpoint %d (exec)"), b->number);
5766 static struct breakpoint_ops catch_exec_breakpoint_ops =
5770 breakpoint_hit_catch_exec,
5771 print_it_catch_exec,
5772 print_one_catch_exec,
5773 print_mention_catch_exec
5777 create_syscall_event_catchpoint (int tempflag, VEC(int) *filter,
5778 struct breakpoint_ops *ops)
5780 struct gdbarch *gdbarch = get_current_arch ();
5781 struct breakpoint *b =
5782 create_catchpoint_without_mention (gdbarch, tempflag, NULL, ops);
5784 b->syscalls_to_be_caught = filter;
5786 /* Now, we have to mention the breakpoint and update the global
5789 update_global_location_list (1);
5793 hw_breakpoint_used_count (void)
5795 struct breakpoint *b;
5800 if (b->type == bp_hardware_breakpoint && breakpoint_enabled (b))
5808 hw_watchpoint_used_count (enum bptype type, int *other_type_used)
5810 struct breakpoint *b;
5813 *other_type_used = 0;
5816 if (breakpoint_enabled (b))
5818 if (b->type == type)
5820 else if ((b->type == bp_hardware_watchpoint
5821 || b->type == bp_read_watchpoint
5822 || b->type == bp_access_watchpoint))
5823 *other_type_used = 1;
5830 disable_watchpoints_before_interactive_call_start (void)
5832 struct breakpoint *b;
5836 if (((b->type == bp_watchpoint)
5837 || (b->type == bp_hardware_watchpoint)
5838 || (b->type == bp_read_watchpoint)
5839 || (b->type == bp_access_watchpoint))
5840 && breakpoint_enabled (b))
5842 b->enable_state = bp_call_disabled;
5843 update_global_location_list (0);
5849 enable_watchpoints_after_interactive_call_stop (void)
5851 struct breakpoint *b;
5855 if (((b->type == bp_watchpoint)
5856 || (b->type == bp_hardware_watchpoint)
5857 || (b->type == bp_read_watchpoint)
5858 || (b->type == bp_access_watchpoint))
5859 && (b->enable_state == bp_call_disabled))
5861 b->enable_state = bp_enabled;
5862 update_global_location_list (1);
5868 disable_breakpoints_before_startup (void)
5870 struct breakpoint *b;
5875 if (b->pspace != current_program_space)
5878 if ((b->type == bp_breakpoint
5879 || b->type == bp_hardware_breakpoint)
5880 && breakpoint_enabled (b))
5882 b->enable_state = bp_startup_disabled;
5888 update_global_location_list (0);
5890 current_program_space->executing_startup = 1;
5894 enable_breakpoints_after_startup (void)
5896 struct breakpoint *b;
5899 current_program_space->executing_startup = 0;
5903 if (b->pspace != current_program_space)
5906 if ((b->type == bp_breakpoint
5907 || b->type == bp_hardware_breakpoint)
5908 && b->enable_state == bp_startup_disabled)
5910 b->enable_state = bp_enabled;
5916 breakpoint_re_set ();
5920 /* Set a breakpoint that will evaporate an end of command
5921 at address specified by SAL.
5922 Restrict it to frame FRAME if FRAME is nonzero. */
5925 set_momentary_breakpoint (struct gdbarch *gdbarch, struct symtab_and_line sal,
5926 struct frame_id frame_id, enum bptype type)
5928 struct breakpoint *b;
5930 /* If FRAME_ID is valid, it should be a real frame, not an inlined
5932 gdb_assert (!frame_id_inlined_p (frame_id));
5934 b = set_raw_breakpoint (gdbarch, sal, type);
5935 b->enable_state = bp_enabled;
5936 b->disposition = disp_donttouch;
5937 b->frame_id = frame_id;
5939 /* If we're debugging a multi-threaded program, then we
5940 want momentary breakpoints to be active in only a
5941 single thread of control. */
5942 if (in_thread_list (inferior_ptid))
5943 b->thread = pid_to_thread_id (inferior_ptid);
5945 update_global_location_list_nothrow (1);
5950 /* Make a deep copy of momentary breakpoint ORIG. Returns NULL if
5954 clone_momentary_breakpoint (struct breakpoint *orig)
5956 struct breakpoint *copy;
5958 /* If there's nothing to clone, then return nothing. */
5962 copy = set_raw_breakpoint_without_location (orig->gdbarch, orig->type);
5963 copy->loc = allocate_bp_location (copy);
5964 set_breakpoint_location_function (copy->loc);
5966 copy->loc->gdbarch = orig->loc->gdbarch;
5967 copy->loc->requested_address = orig->loc->requested_address;
5968 copy->loc->address = orig->loc->address;
5969 copy->loc->section = orig->loc->section;
5970 copy->loc->pspace = orig->loc->pspace;
5972 if (orig->source_file == NULL)
5973 copy->source_file = NULL;
5975 copy->source_file = xstrdup (orig->source_file);
5977 copy->line_number = orig->line_number;
5978 copy->frame_id = orig->frame_id;
5979 copy->thread = orig->thread;
5980 copy->pspace = orig->pspace;
5982 copy->enable_state = bp_enabled;
5983 copy->disposition = disp_donttouch;
5984 copy->number = internal_breakpoint_number--;
5986 update_global_location_list_nothrow (0);
5991 set_momentary_breakpoint_at_pc (struct gdbarch *gdbarch, CORE_ADDR pc,
5994 struct symtab_and_line sal;
5996 sal = find_pc_line (pc, 0);
5998 sal.section = find_pc_overlay (pc);
5999 sal.explicit_pc = 1;
6001 return set_momentary_breakpoint (gdbarch, sal, null_frame_id, type);
6005 /* Tell the user we have just set a breakpoint B. */
6008 mention (struct breakpoint *b)
6011 struct cleanup *ui_out_chain;
6012 struct value_print_options opts;
6014 get_user_print_options (&opts);
6016 /* FIXME: This is misplaced; mention() is called by things (like
6017 hitting a watchpoint) other than breakpoint creation. It should
6018 be possible to clean this up and at the same time replace the
6019 random calls to breakpoint_changed with this hook. */
6020 observer_notify_breakpoint_created (b->number);
6022 if (b->ops != NULL && b->ops->print_mention != NULL)
6023 b->ops->print_mention (b);
6028 printf_filtered (_("(apparently deleted?) Eventpoint %d: "), b->number);
6031 ui_out_text (uiout, "Watchpoint ");
6032 ui_out_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "wpt");
6033 ui_out_field_int (uiout, "number", b->number);
6034 ui_out_text (uiout, ": ");
6035 ui_out_field_string (uiout, "exp", b->exp_string);
6036 do_cleanups (ui_out_chain);
6038 case bp_hardware_watchpoint:
6039 ui_out_text (uiout, "Hardware watchpoint ");
6040 ui_out_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "wpt");
6041 ui_out_field_int (uiout, "number", b->number);
6042 ui_out_text (uiout, ": ");
6043 ui_out_field_string (uiout, "exp", b->exp_string);
6044 do_cleanups (ui_out_chain);
6046 case bp_read_watchpoint:
6047 ui_out_text (uiout, "Hardware read watchpoint ");
6048 ui_out_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "hw-rwpt");
6049 ui_out_field_int (uiout, "number", b->number);
6050 ui_out_text (uiout, ": ");
6051 ui_out_field_string (uiout, "exp", b->exp_string);
6052 do_cleanups (ui_out_chain);
6054 case bp_access_watchpoint:
6055 ui_out_text (uiout, "Hardware access (read/write) watchpoint ");
6056 ui_out_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "hw-awpt");
6057 ui_out_field_int (uiout, "number", b->number);
6058 ui_out_text (uiout, ": ");
6059 ui_out_field_string (uiout, "exp", b->exp_string);
6060 do_cleanups (ui_out_chain);
6063 if (ui_out_is_mi_like_p (uiout))
6068 if (b->disposition == disp_del)
6069 printf_filtered (_("Temporary breakpoint"));
6071 printf_filtered (_("Breakpoint"));
6072 printf_filtered (_(" %d"), b->number);
6075 case bp_hardware_breakpoint:
6076 if (ui_out_is_mi_like_p (uiout))
6081 printf_filtered (_("Hardware assisted breakpoint %d"), b->number);
6085 if (ui_out_is_mi_like_p (uiout))
6090 printf_filtered (_("Tracepoint"));
6091 printf_filtered (_(" %d"), b->number);
6098 case bp_longjmp_resume:
6099 case bp_step_resume:
6101 case bp_watchpoint_scope:
6102 case bp_shlib_event:
6103 case bp_thread_event:
6104 case bp_overlay_event:
6106 case bp_longjmp_master:
6112 /* i18n: cagney/2005-02-11: Below needs to be merged into a
6116 printf_filtered (_(" (%s) pending."), b->addr_string);
6120 if (opts.addressprint || b->source_file == NULL)
6122 printf_filtered (" at ");
6123 fputs_filtered (paddress (b->loc->gdbarch, b->loc->address),
6127 printf_filtered (": file %s, line %d.",
6128 b->source_file, b->line_number);
6132 struct bp_location *loc = b->loc;
6134 for (; loc; loc = loc->next)
6136 printf_filtered (" (%d locations)", n);
6141 if (ui_out_is_mi_like_p (uiout))
6143 printf_filtered ("\n");
6147 static struct bp_location *
6148 add_location_to_breakpoint (struct breakpoint *b,
6149 const struct symtab_and_line *sal)
6151 struct bp_location *loc, **tmp;
6153 loc = allocate_bp_location (b);
6154 for (tmp = &(b->loc); *tmp != NULL; tmp = &((*tmp)->next))
6157 loc->gdbarch = get_sal_arch (*sal);
6159 loc->gdbarch = b->gdbarch;
6160 loc->requested_address = sal->pc;
6161 loc->address = adjust_breakpoint_address (loc->gdbarch,
6162 loc->requested_address, b->type);
6163 loc->pspace = sal->pspace;
6164 gdb_assert (loc->pspace != NULL);
6165 loc->section = sal->section;
6167 set_breakpoint_location_function (loc);
6172 /* Return 1 if LOC is pointing to a permanent breakpoint,
6173 return 0 otherwise. */
6176 bp_loc_is_permanent (struct bp_location *loc)
6180 const gdb_byte *brk;
6181 gdb_byte *target_mem;
6182 struct cleanup *cleanup;
6185 gdb_assert (loc != NULL);
6187 addr = loc->address;
6188 brk = gdbarch_breakpoint_from_pc (loc->gdbarch, &addr, &len);
6190 /* Software breakpoints unsupported? */
6194 target_mem = alloca (len);
6196 /* Enable the automatic memory restoration from breakpoints while
6197 we read the memory. Otherwise we could say about our temporary
6198 breakpoints they are permanent. */
6199 cleanup = save_current_space_and_thread ();
6201 switch_to_program_space_and_thread (loc->pspace);
6202 make_show_memory_breakpoints_cleanup (0);
6204 if (target_read_memory (loc->address, target_mem, len) == 0
6205 && memcmp (target_mem, brk, len) == 0)
6208 do_cleanups (cleanup);
6215 /* Create a breakpoint with SAL as location. Use ADDR_STRING
6216 as textual description of the location, and COND_STRING
6217 as condition expression. */
6220 create_breakpoint (struct gdbarch *gdbarch,
6221 struct symtabs_and_lines sals, char *addr_string,
6223 enum bptype type, enum bpdisp disposition,
6224 int thread, int task, int ignore_count,
6225 struct breakpoint_ops *ops, int from_tty, int enabled)
6227 struct breakpoint *b = NULL;
6230 if (type == bp_hardware_breakpoint)
6232 int i = hw_breakpoint_used_count ();
6233 int target_resources_ok =
6234 target_can_use_hardware_watchpoint (bp_hardware_breakpoint,
6236 if (target_resources_ok == 0)
6237 error (_("No hardware breakpoint support in the target."));
6238 else if (target_resources_ok < 0)
6239 error (_("Hardware breakpoints used exceeds limit."));
6242 gdb_assert (sals.nelts > 0);
6244 for (i = 0; i < sals.nelts; ++i)
6246 struct symtab_and_line sal = sals.sals[i];
6247 struct bp_location *loc;
6251 struct gdbarch *loc_gdbarch = get_sal_arch (sal);
6253 loc_gdbarch = gdbarch;
6255 describe_other_breakpoints (loc_gdbarch,
6256 sal.pspace, sal.pc, sal.section, thread);
6261 b = set_raw_breakpoint (gdbarch, sal, type);
6262 set_breakpoint_count (breakpoint_count + 1);
6263 b->number = breakpoint_count;
6267 b->cond_string = cond_string;
6268 b->ignore_count = ignore_count;
6269 b->enable_state = enabled ? bp_enabled : bp_disabled;
6270 b->disposition = disposition;
6272 b->pspace = sals.sals[0].pspace;
6274 if (enabled && b->pspace->executing_startup
6275 && (b->type == bp_breakpoint
6276 || b->type == bp_hardware_breakpoint))
6277 b->enable_state = bp_startup_disabled;
6283 loc = add_location_to_breakpoint (b, &sal);
6286 if (bp_loc_is_permanent (loc))
6287 make_breakpoint_permanent (b);
6291 char *arg = b->cond_string;
6292 loc->cond = parse_exp_1 (&arg, block_for_pc (loc->address), 0);
6294 error (_("Garbage %s follows condition"), arg);
6299 b->addr_string = addr_string;
6301 /* addr_string has to be used or breakpoint_re_set will delete
6304 = xstrprintf ("*%s", paddress (b->loc->gdbarch, b->loc->address));
6310 /* Remove element at INDEX_TO_REMOVE from SAL, shifting other
6311 elements to fill the void space. */
6313 remove_sal (struct symtabs_and_lines *sal, int index_to_remove)
6315 int i = index_to_remove+1;
6316 int last_index = sal->nelts-1;
6318 for (;i <= last_index; ++i)
6319 sal->sals[i-1] = sal->sals[i];
6324 /* If appropriate, obtains all sals that correspond to the same file
6325 and line as SAL, in all program spaces. Users debugging with IDEs,
6326 will want to set a breakpoint at foo.c:line, and not really care
6327 about program spaces. This is done only if SAL does not have
6328 explicit PC and has line and file information. If we got just a
6329 single expanded sal, return the original.
6331 Otherwise, if SAL.explicit_line is not set, filter out all sals for
6332 which the name of enclosing function is different from SAL. This
6333 makes sure that if we have breakpoint originally set in template
6334 instantiation, say foo<int>(), we won't expand SAL to locations at
6335 the same line in all existing instantiations of 'foo'. */
6337 static struct symtabs_and_lines
6338 expand_line_sal_maybe (struct symtab_and_line sal)
6340 struct symtabs_and_lines expanded;
6341 CORE_ADDR original_pc = sal.pc;
6342 char *original_function = NULL;
6345 struct cleanup *old_chain;
6347 /* If we have explicit pc, don't expand.
6348 If we have no line number, we can't expand. */
6349 if (sal.explicit_pc || sal.line == 0 || sal.symtab == NULL)
6352 expanded.sals = xmalloc (sizeof (struct symtab_and_line));
6353 expanded.sals[0] = sal;
6359 old_chain = save_current_space_and_thread ();
6361 switch_to_program_space_and_thread (sal.pspace);
6363 find_pc_partial_function (original_pc, &original_function, NULL, NULL);
6365 /* Note that expand_line_sal visits *all* program spaces. */
6366 expanded = expand_line_sal (sal);
6368 if (expanded.nelts == 1)
6370 /* We had one sal, we got one sal. Return that sal, adjusting it
6371 past the function prologue if necessary. */
6372 xfree (expanded.sals);
6374 expanded.sals = xmalloc (sizeof (struct symtab_and_line));
6375 sal.pc = original_pc;
6376 expanded.sals[0] = sal;
6377 skip_prologue_sal (&expanded.sals[0]);
6378 do_cleanups (old_chain);
6382 if (!sal.explicit_line)
6384 CORE_ADDR func_addr, func_end;
6385 for (i = 0; i < expanded.nelts; ++i)
6387 CORE_ADDR pc = expanded.sals[i].pc;
6388 char *this_function;
6390 /* We need to switch threads as well since we're about to
6392 switch_to_program_space_and_thread (expanded.sals[i].pspace);
6394 if (find_pc_partial_function (pc, &this_function,
6395 &func_addr, &func_end))
6398 && strcmp (this_function, original_function) != 0)
6400 remove_sal (&expanded, i);
6403 else if (func_addr == pc)
6405 /* We're at beginning of a function, and should
6407 struct symbol *sym = find_pc_function (pc);
6409 expanded.sals[i] = find_function_start_sal (sym, 1);
6412 /* Since find_pc_partial_function returned true,
6413 we should really always find the section here. */
6414 struct obj_section *section = find_pc_section (pc);
6417 struct gdbarch *gdbarch
6418 = get_objfile_arch (section->objfile);
6420 = gdbarch_skip_prologue (gdbarch, pc);
6429 for (i = 0; i < expanded.nelts; ++i)
6431 /* If this SAL corresponds to a breakpoint inserted using a
6432 line number, then skip the function prologue if necessary. */
6433 skip_prologue_sal (&expanded.sals[i]);
6437 do_cleanups (old_chain);
6439 if (expanded.nelts <= 1)
6441 /* This is un ugly workaround. If we get zero
6442 expanded sals then something is really wrong.
6443 Fix that by returnign the original sal. */
6444 xfree (expanded.sals);
6446 expanded.sals = xmalloc (sizeof (struct symtab_and_line));
6447 sal.pc = original_pc;
6448 expanded.sals[0] = sal;
6455 for (i = 0; i < expanded.nelts; ++i)
6456 if (expanded.sals[i].pc == original_pc)
6467 /* Add SALS.nelts breakpoints to the breakpoint table. For each
6468 SALS.sal[i] breakpoint, include the corresponding ADDR_STRING[i]
6469 value. COND_STRING, if not NULL, specified the condition to be
6470 used for all breakpoints. Essentially the only case where
6471 SALS.nelts is not 1 is when we set a breakpoint on an overloaded
6472 function. In that case, it's still not possible to specify
6473 separate conditions for different overloaded functions, so
6474 we take just a single condition string.
6476 NOTE: If the function succeeds, the caller is expected to cleanup
6477 the arrays ADDR_STRING, COND_STRING, and SALS (but not the
6478 array contents). If the function fails (error() is called), the
6479 caller is expected to cleanups both the ADDR_STRING, COND_STRING,
6480 COND and SALS arrays and each of those arrays contents. */
6483 create_breakpoints (struct gdbarch *gdbarch,
6484 struct symtabs_and_lines sals, char **addr_string,
6486 enum bptype type, enum bpdisp disposition,
6487 int thread, int task, int ignore_count,
6488 struct breakpoint_ops *ops, int from_tty,
6492 for (i = 0; i < sals.nelts; ++i)
6494 struct symtabs_and_lines expanded =
6495 expand_line_sal_maybe (sals.sals[i]);
6497 create_breakpoint (gdbarch, expanded, addr_string[i],
6498 cond_string, type, disposition,
6499 thread, task, ignore_count, ops, from_tty, enabled);
6503 /* Parse ARG which is assumed to be a SAL specification possibly
6504 followed by conditionals. On return, SALS contains an array of SAL
6505 addresses found. ADDR_STRING contains a vector of (canonical)
6506 address strings. ARG points to the end of the SAL. */
6509 parse_breakpoint_sals (char **address,
6510 struct symtabs_and_lines *sals,
6511 char ***addr_string,
6514 char *addr_start = *address;
6515 *addr_string = NULL;
6516 /* If no arg given, or if first arg is 'if ', use the default
6518 if ((*address) == NULL
6519 || (strncmp ((*address), "if", 2) == 0 && isspace ((*address)[2])))
6521 if (default_breakpoint_valid)
6523 struct symtab_and_line sal;
6524 init_sal (&sal); /* initialize to zeroes */
6525 sals->sals = (struct symtab_and_line *)
6526 xmalloc (sizeof (struct symtab_and_line));
6527 sal.pc = default_breakpoint_address;
6528 sal.line = default_breakpoint_line;
6529 sal.symtab = default_breakpoint_symtab;
6530 sal.pspace = default_breakpoint_pspace;
6531 sal.section = find_pc_overlay (sal.pc);
6533 /* "break" without arguments is equivalent to "break *PC" where PC is
6534 the default_breakpoint_address. So make sure to set
6535 sal.explicit_pc to prevent GDB from trying to expand the list of
6536 sals to include all other instances with the same symtab and line.
6538 sal.explicit_pc = 1;
6540 sals->sals[0] = sal;
6544 error (_("No default breakpoint address now."));
6548 /* Force almost all breakpoints to be in terms of the
6549 current_source_symtab (which is decode_line_1's default). This
6550 should produce the results we want almost all of the time while
6551 leaving default_breakpoint_* alone.
6552 ObjC: However, don't match an Objective-C method name which
6553 may have a '+' or '-' succeeded by a '[' */
6555 struct symtab_and_line cursal = get_current_source_symtab_and_line ();
6557 if (default_breakpoint_valid
6559 || ((strchr ("+-", (*address)[0]) != NULL)
6560 && ((*address)[1] != '['))))
6561 *sals = decode_line_1 (address, 1, default_breakpoint_symtab,
6562 default_breakpoint_line, addr_string,
6565 *sals = decode_line_1 (address, 1, (struct symtab *) NULL, 0,
6566 addr_string, not_found_ptr);
6568 /* For any SAL that didn't have a canonical string, fill one in. */
6569 if (sals->nelts > 0 && *addr_string == NULL)
6570 *addr_string = xcalloc (sals->nelts, sizeof (char **));
6571 if (addr_start != (*address))
6574 for (i = 0; i < sals->nelts; i++)
6576 /* Add the string if not present. */
6577 if ((*addr_string)[i] == NULL)
6578 (*addr_string)[i] = savestring (addr_start, (*address) - addr_start);
6584 /* Convert each SAL into a real PC. Verify that the PC can be
6585 inserted as a breakpoint. If it can't throw an error. */
6588 breakpoint_sals_to_pc (struct symtabs_and_lines *sals,
6592 for (i = 0; i < sals->nelts; i++)
6593 resolve_sal_pc (&sals->sals[i]);
6597 do_captured_parse_breakpoint (struct ui_out *ui, void *data)
6599 struct captured_parse_breakpoint_args *args = data;
6601 parse_breakpoint_sals (args->arg_p, args->sals_p, args->addr_string_p,
6602 args->not_found_ptr);
6605 /* Given TOK, a string specification of condition and thread, as
6606 accepted by the 'break' command, extract the condition
6607 string and thread number and set *COND_STRING and *THREAD.
6608 PC identifies the context at which the condition should be parsed.
6609 If no condition is found, *COND_STRING is set to NULL.
6610 If no thread is found, *THREAD is set to -1. */
6612 find_condition_and_thread (char *tok, CORE_ADDR pc,
6613 char **cond_string, int *thread, int *task)
6615 *cond_string = NULL;
6621 char *cond_start = NULL;
6622 char *cond_end = NULL;
6623 while (*tok == ' ' || *tok == '\t')
6628 while (*end_tok != ' ' && *end_tok != '\t' && *end_tok != '\000')
6631 toklen = end_tok - tok;
6633 if (toklen >= 1 && strncmp (tok, "if", toklen) == 0)
6635 struct expression *expr;
6637 tok = cond_start = end_tok + 1;
6638 expr = parse_exp_1 (&tok, block_for_pc (pc), 0);
6641 *cond_string = savestring (cond_start,
6642 cond_end - cond_start);
6644 else if (toklen >= 1 && strncmp (tok, "thread", toklen) == 0)
6650 *thread = strtol (tok, &tok, 0);
6652 error (_("Junk after thread keyword."));
6653 if (!valid_thread_id (*thread))
6654 error (_("Unknown thread %d."), *thread);
6656 else if (toklen >= 1 && strncmp (tok, "task", toklen) == 0)
6662 *task = strtol (tok, &tok, 0);
6664 error (_("Junk after task keyword."));
6665 if (!valid_task_id (*task))
6666 error (_("Unknown task %d."), *task);
6669 error (_("Junk at end of arguments."));
6673 /* Set a breakpoint. This function is shared between
6674 CLI and MI functions for setting a breakpoint.
6675 This function has two major modes of operations,
6676 selected by the PARSE_CONDITION_AND_THREAD parameter.
6677 If non-zero, the function will parse arg, extracting
6678 breakpoint location, address and thread. Otherwise,
6679 ARG is just the location of breakpoint, with condition
6680 and thread specified by the COND_STRING and THREAD
6684 break_command_really (struct gdbarch *gdbarch,
6685 char *arg, char *cond_string, int thread,
6686 int parse_condition_and_thread,
6687 int tempflag, int hardwareflag, int traceflag,
6689 enum auto_boolean pending_break_support,
6690 struct breakpoint_ops *ops,
6694 struct gdb_exception e;
6695 struct symtabs_and_lines sals;
6696 struct symtab_and_line pending_sal;
6699 char *addr_start = arg;
6701 struct cleanup *old_chain;
6702 struct cleanup *bkpt_chain = NULL;
6703 struct captured_parse_breakpoint_args parse_args;
6707 enum bptype type_wanted;
6714 parse_args.arg_p = &arg;
6715 parse_args.sals_p = &sals;
6716 parse_args.addr_string_p = &addr_string;
6717 parse_args.not_found_ptr = ¬_found;
6719 e = catch_exception (uiout, do_captured_parse_breakpoint,
6720 &parse_args, RETURN_MASK_ALL);
6722 /* If caller is interested in rc value from parse, set value. */
6726 throw_exception (e);
6730 case NOT_FOUND_ERROR:
6732 /* If pending breakpoint support is turned off, throw
6735 if (pending_break_support == AUTO_BOOLEAN_FALSE)
6736 throw_exception (e);
6738 exception_print (gdb_stderr, e);
6740 /* If pending breakpoint support is auto query and the user
6741 selects no, then simply return the error code. */
6742 if (pending_break_support == AUTO_BOOLEAN_AUTO
6743 && !nquery ("Make breakpoint pending on future shared library load? "))
6746 /* At this point, either the user was queried about setting
6747 a pending breakpoint and selected yes, or pending
6748 breakpoint behavior is on and thus a pending breakpoint
6749 is defaulted on behalf of the user. */
6750 copy_arg = xstrdup (addr_start);
6751 addr_string = ©_arg;
6753 sals.sals = &pending_sal;
6758 throw_exception (e);
6765 /* Create a chain of things that always need to be cleaned up. */
6766 old_chain = make_cleanup (null_cleanup, 0);
6770 /* Make sure that all storage allocated to SALS gets freed. */
6771 make_cleanup (xfree, sals.sals);
6773 /* Cleanup the addr_string array but not its contents. */
6774 make_cleanup (xfree, addr_string);
6777 /* ----------------------------- SNIP -----------------------------
6778 Anything added to the cleanup chain beyond this point is assumed
6779 to be part of a breakpoint. If the breakpoint create succeeds
6780 then the memory is not reclaimed. */
6781 bkpt_chain = make_cleanup (null_cleanup, 0);
6783 /* Mark the contents of the addr_string for cleanup. These go on
6784 the bkpt_chain and only occur if the breakpoint create fails. */
6785 for (i = 0; i < sals.nelts; i++)
6787 if (addr_string[i] != NULL)
6788 make_cleanup (xfree, addr_string[i]);
6791 /* Resolve all line numbers to PC's and verify that the addresses
6792 are ok for the target. */
6794 breakpoint_sals_to_pc (&sals, addr_start);
6796 type_wanted = (traceflag
6798 : (hardwareflag ? bp_hardware_breakpoint : bp_breakpoint));
6800 /* Verify that condition can be parsed, before setting any
6801 breakpoints. Allocate a separate condition expression for each
6805 if (parse_condition_and_thread)
6807 /* Here we only parse 'arg' to separate condition
6808 from thread number, so parsing in context of first
6809 sal is OK. When setting the breakpoint we'll
6810 re-parse it in context of each sal. */
6813 find_condition_and_thread (arg, sals.sals[0].pc, &cond_string,
6816 make_cleanup (xfree, cond_string);
6820 /* Create a private copy of condition string. */
6823 cond_string = xstrdup (cond_string);
6824 make_cleanup (xfree, cond_string);
6827 create_breakpoints (gdbarch, sals, addr_string, cond_string, type_wanted,
6828 tempflag ? disp_del : disp_donttouch,
6829 thread, task, ignore_count, ops, from_tty, enabled);
6833 struct symtab_and_line sal = {0};
6834 struct breakpoint *b;
6836 make_cleanup (xfree, copy_arg);
6838 b = set_raw_breakpoint_without_location (gdbarch, type_wanted);
6839 set_breakpoint_count (breakpoint_count + 1);
6840 b->number = breakpoint_count;
6842 b->addr_string = addr_string[0];
6843 b->cond_string = NULL;
6844 b->ignore_count = ignore_count;
6845 b->disposition = tempflag ? disp_del : disp_donttouch;
6846 b->condition_not_parsed = 1;
6848 b->enable_state = enabled ? bp_enabled : bp_disabled;
6849 b->pspace = current_program_space;
6851 if (enabled && b->pspace->executing_startup
6852 && (b->type == bp_breakpoint
6853 || b->type == bp_hardware_breakpoint))
6854 b->enable_state = bp_startup_disabled;
6860 warning (_("Multiple breakpoints were set.\n"
6861 "Use the \"delete\" command to delete unwanted breakpoints."));
6862 /* That's it. Discard the cleanups for data inserted into the
6864 discard_cleanups (bkpt_chain);
6865 /* But cleanup everything else. */
6866 do_cleanups (old_chain);
6868 /* error call may happen here - have BKPT_CHAIN already discarded. */
6869 update_global_location_list (1);
6872 /* Set a breakpoint.
6873 ARG is a string describing breakpoint address,
6874 condition, and thread.
6875 FLAG specifies if a breakpoint is hardware on,
6876 and if breakpoint is temporary, using BP_HARDWARE_FLAG
6880 break_command_1 (char *arg, int flag, int from_tty)
6882 int hardwareflag = flag & BP_HARDWAREFLAG;
6883 int tempflag = flag & BP_TEMPFLAG;
6885 break_command_really (get_current_arch (),
6887 NULL, 0, 1 /* parse arg */,
6888 tempflag, hardwareflag, 0 /* traceflag */,
6889 0 /* Ignore count */,
6890 pending_break_support,
6891 NULL /* breakpoint_ops */,
6898 set_breakpoint (struct gdbarch *gdbarch,
6899 char *address, char *condition,
6900 int hardwareflag, int tempflag,
6901 int thread, int ignore_count,
6902 int pending, int enabled)
6904 break_command_really (gdbarch,
6905 address, condition, thread,
6906 0 /* condition and thread are valid. */,
6907 tempflag, hardwareflag, 0 /* traceflag */,
6910 ? AUTO_BOOLEAN_TRUE : AUTO_BOOLEAN_FALSE,
6914 /* Adjust SAL to the first instruction past the function prologue.
6915 The end of the prologue is determined using the line table from
6916 the debugging information. explicit_pc and explicit_line are
6919 If SAL is already past the prologue, then do nothing. */
6922 skip_prologue_sal (struct symtab_and_line *sal)
6925 struct symtab_and_line start_sal;
6926 struct cleanup *old_chain;
6928 old_chain = save_current_space_and_thread ();
6930 sym = find_pc_function (sal->pc);
6933 start_sal = find_function_start_sal (sym, 1);
6934 if (sal->pc < start_sal.pc)
6936 start_sal.explicit_line = sal->explicit_line;
6937 start_sal.explicit_pc = sal->explicit_pc;
6942 do_cleanups (old_chain);
6945 /* Helper function for break_command_1 and disassemble_command. */
6948 resolve_sal_pc (struct symtab_and_line *sal)
6952 if (sal->pc == 0 && sal->symtab != NULL)
6954 if (!find_line_pc (sal->symtab, sal->line, &pc))
6955 error (_("No line %d in file \"%s\"."),
6956 sal->line, sal->symtab->filename);
6959 /* If this SAL corresponds to a breakpoint inserted using
6960 a line number, then skip the function prologue if necessary. */
6961 if (sal->explicit_line)
6963 /* Preserve the original line number. */
6964 int saved_line = sal->line;
6965 skip_prologue_sal (sal);
6966 sal->line = saved_line;
6970 if (sal->section == 0 && sal->symtab != NULL)
6972 struct blockvector *bv;
6976 bv = blockvector_for_pc_sect (sal->pc, 0, &b, sal->symtab);
6979 sym = block_linkage_function (b);
6982 fixup_symbol_section (sym, sal->symtab->objfile);
6983 sal->section = SYMBOL_OBJ_SECTION (sym);
6987 /* It really is worthwhile to have the section, so we'll just
6988 have to look harder. This case can be executed if we have
6989 line numbers but no functions (as can happen in assembly
6992 struct minimal_symbol *msym;
6993 struct cleanup *old_chain = save_current_space_and_thread ();
6995 switch_to_program_space_and_thread (sal->pspace);
6997 msym = lookup_minimal_symbol_by_pc (sal->pc);
6999 sal->section = SYMBOL_OBJ_SECTION (msym);
7001 do_cleanups (old_chain);
7008 break_command (char *arg, int from_tty)
7010 break_command_1 (arg, 0, from_tty);
7014 tbreak_command (char *arg, int from_tty)
7016 break_command_1 (arg, BP_TEMPFLAG, from_tty);
7020 hbreak_command (char *arg, int from_tty)
7022 break_command_1 (arg, BP_HARDWAREFLAG, from_tty);
7026 thbreak_command (char *arg, int from_tty)
7028 break_command_1 (arg, (BP_TEMPFLAG | BP_HARDWAREFLAG), from_tty);
7032 stop_command (char *arg, int from_tty)
7034 printf_filtered (_("Specify the type of breakpoint to set.\n\
7035 Usage: stop in <function | address>\n\
7036 stop at <line>\n"));
7040 stopin_command (char *arg, int from_tty)
7044 if (arg == (char *) NULL)
7046 else if (*arg != '*')
7051 /* look for a ':'. If this is a line number specification, then
7052 say it is bad, otherwise, it should be an address or
7053 function/method name */
7054 while (*argptr && !hasColon)
7056 hasColon = (*argptr == ':');
7061 badInput = (*argptr != ':'); /* Not a class::method */
7063 badInput = isdigit (*arg); /* a simple line number */
7067 printf_filtered (_("Usage: stop in <function | address>\n"));
7069 break_command_1 (arg, 0, from_tty);
7073 stopat_command (char *arg, int from_tty)
7077 if (arg == (char *) NULL || *arg == '*') /* no line number */
7084 /* look for a ':'. If there is a '::' then get out, otherwise
7085 it is probably a line number. */
7086 while (*argptr && !hasColon)
7088 hasColon = (*argptr == ':');
7093 badInput = (*argptr == ':'); /* we have class::method */
7095 badInput = !isdigit (*arg); /* not a line number */
7099 printf_filtered (_("Usage: stop at <line>\n"));
7101 break_command_1 (arg, 0, from_tty);
7104 /* accessflag: hw_write: watch write,
7105 hw_read: watch read,
7106 hw_access: watch access (read or write) */
7108 watch_command_1 (char *arg, int accessflag, int from_tty)
7110 struct gdbarch *gdbarch = get_current_arch ();
7111 struct breakpoint *b, *scope_breakpoint = NULL;
7112 struct expression *exp;
7113 struct block *exp_valid_block;
7114 struct value *val, *mark;
7115 struct frame_info *frame;
7116 char *exp_start = NULL;
7117 char *exp_end = NULL;
7118 char *tok, *id_tok_start, *end_tok;
7120 char *cond_start = NULL;
7121 char *cond_end = NULL;
7122 int i, other_type_used, target_resources_ok = 0;
7123 enum bptype bp_type;
7127 /* Make sure that we actually have parameters to parse. */
7128 if (arg != NULL && arg[0] != '\0')
7130 toklen = strlen (arg); /* Size of argument list. */
7132 /* Points tok to the end of the argument list. */
7133 tok = arg + toklen - 1;
7135 /* Go backwards in the parameters list. Skip the last parameter.
7136 If we're expecting a 'thread <thread_num>' parameter, this should
7137 be the thread identifier. */
7138 while (tok > arg && (*tok == ' ' || *tok == '\t'))
7140 while (tok > arg && (*tok != ' ' && *tok != '\t'))
7143 /* Points end_tok to the beginning of the last token. */
7144 id_tok_start = tok + 1;
7146 /* Go backwards in the parameters list. Skip one more parameter.
7147 If we're expecting a 'thread <thread_num>' parameter, we should
7148 reach a "thread" token. */
7149 while (tok > arg && (*tok == ' ' || *tok == '\t'))
7154 while (tok > arg && (*tok != ' ' && *tok != '\t'))
7157 /* Move the pointer forward to skip the whitespace and
7158 calculate the length of the token. */
7160 toklen = end_tok - tok;
7162 if (toklen >= 1 && strncmp (tok, "thread", toklen) == 0)
7164 /* At this point we've found a "thread" token, which means
7165 the user is trying to set a watchpoint that triggers
7166 only in a specific thread. */
7169 /* Extract the thread ID from the next token. */
7170 thread = strtol (id_tok_start, &endp, 0);
7172 /* Check if the user provided a valid numeric value for the
7174 if (*endp != ' ' && *endp != '\t' && *endp != '\0')
7175 error (_("Invalid thread ID specification %s."), id_tok_start);
7177 /* Check if the thread actually exists. */
7178 if (!valid_thread_id (thread))
7179 error (_("Unknown thread %d."), thread);
7181 /* Truncate the string and get rid of the thread <thread_num>
7182 parameter before the parameter list is parsed by the
7183 evaluate_expression() function. */
7188 /* Parse the rest of the arguments. */
7189 innermost_block = NULL;
7191 exp = parse_exp_1 (&arg, 0, 0);
7193 /* Remove trailing whitespace from the expression before saving it.
7194 This makes the eventual display of the expression string a bit
7196 while (exp_end > exp_start && (exp_end[-1] == ' ' || exp_end[-1] == '\t'))
7199 exp_valid_block = innermost_block;
7200 mark = value_mark ();
7201 fetch_watchpoint_value (exp, &val, NULL, NULL);
7203 release_value (val);
7206 while (*tok == ' ' || *tok == '\t')
7210 while (*end_tok != ' ' && *end_tok != '\t' && *end_tok != '\000')
7213 toklen = end_tok - tok;
7214 if (toklen >= 1 && strncmp (tok, "if", toklen) == 0)
7216 struct expression *cond;
7218 tok = cond_start = end_tok + 1;
7219 cond = parse_exp_1 (&tok, 0, 0);
7224 error (_("Junk at end of command."));
7226 if (accessflag == hw_read)
7227 bp_type = bp_read_watchpoint;
7228 else if (accessflag == hw_access)
7229 bp_type = bp_access_watchpoint;
7231 bp_type = bp_hardware_watchpoint;
7233 mem_cnt = can_use_hardware_watchpoint (val);
7234 if (mem_cnt == 0 && bp_type != bp_hardware_watchpoint)
7235 error (_("Expression cannot be implemented with read/access watchpoint."));
7238 i = hw_watchpoint_used_count (bp_type, &other_type_used);
7239 target_resources_ok =
7240 target_can_use_hardware_watchpoint (bp_type, i + mem_cnt,
7242 if (target_resources_ok == 0 && bp_type != bp_hardware_watchpoint)
7243 error (_("Target does not support this type of hardware watchpoint."));
7245 if (target_resources_ok < 0 && bp_type != bp_hardware_watchpoint)
7246 error (_("Target can only support one kind of HW watchpoint at a time."));
7249 /* Change the type of breakpoint to an ordinary watchpoint if a hardware
7250 watchpoint could not be set. */
7251 if (!mem_cnt || target_resources_ok <= 0)
7252 bp_type = bp_watchpoint;
7254 frame = block_innermost_frame (exp_valid_block);
7256 /* If the expression is "local", then set up a "watchpoint scope"
7257 breakpoint at the point where we've left the scope of the watchpoint
7258 expression. Create the scope breakpoint before the watchpoint, so
7259 that we will encounter it first in bpstat_stop_status. */
7260 if (innermost_block && frame)
7262 if (frame_id_p (frame_unwind_caller_id (frame)))
7265 = create_internal_breakpoint (frame_unwind_caller_arch (frame),
7266 frame_unwind_caller_pc (frame),
7267 bp_watchpoint_scope);
7269 scope_breakpoint->enable_state = bp_enabled;
7271 /* Automatically delete the breakpoint when it hits. */
7272 scope_breakpoint->disposition = disp_del;
7274 /* Only break in the proper frame (help with recursion). */
7275 scope_breakpoint->frame_id = frame_unwind_caller_id (frame);
7277 /* Set the address at which we will stop. */
7278 scope_breakpoint->loc->gdbarch
7279 = frame_unwind_caller_arch (frame);
7280 scope_breakpoint->loc->requested_address
7281 = frame_unwind_caller_pc (frame);
7282 scope_breakpoint->loc->address
7283 = adjust_breakpoint_address (scope_breakpoint->loc->gdbarch,
7284 scope_breakpoint->loc->requested_address,
7285 scope_breakpoint->type);
7289 /* Now set up the breakpoint. */
7290 b = set_raw_breakpoint_without_location (NULL, bp_type);
7291 set_breakpoint_count (breakpoint_count + 1);
7292 b->number = breakpoint_count;
7294 b->disposition = disp_donttouch;
7296 b->exp_valid_block = exp_valid_block;
7297 b->exp_string = savestring (exp_start, exp_end - exp_start);
7301 b->cond_string = savestring (cond_start, cond_end - cond_start);
7307 b->watchpoint_frame = get_frame_id (frame);
7308 b->watchpoint_thread = inferior_ptid;
7312 b->watchpoint_frame = null_frame_id;
7313 b->watchpoint_thread = null_ptid;
7316 if (scope_breakpoint != NULL)
7318 /* The scope breakpoint is related to the watchpoint. We will
7319 need to act on them together. */
7320 b->related_breakpoint = scope_breakpoint;
7321 scope_breakpoint->related_breakpoint = b;
7324 value_free_to_mark (mark);
7326 /* Finally update the new watchpoint. This creates the locations
7327 that should be inserted. */
7328 update_watchpoint (b, 1);
7331 update_global_location_list (1);
7334 /* Return count of locations need to be watched and can be handled
7335 in hardware. If the watchpoint can not be handled
7336 in hardware return zero. */
7339 can_use_hardware_watchpoint (struct value *v)
7341 int found_memory_cnt = 0;
7342 struct value *head = v;
7344 /* Did the user specifically forbid us to use hardware watchpoints? */
7345 if (!can_use_hw_watchpoints)
7348 /* Make sure that the value of the expression depends only upon
7349 memory contents, and values computed from them within GDB. If we
7350 find any register references or function calls, we can't use a
7351 hardware watchpoint.
7353 The idea here is that evaluating an expression generates a series
7354 of values, one holding the value of every subexpression. (The
7355 expression a*b+c has five subexpressions: a, b, a*b, c, and
7356 a*b+c.) GDB's values hold almost enough information to establish
7357 the criteria given above --- they identify memory lvalues,
7358 register lvalues, computed values, etcetera. So we can evaluate
7359 the expression, and then scan the chain of values that leaves
7360 behind to decide whether we can detect any possible change to the
7361 expression's final value using only hardware watchpoints.
7363 However, I don't think that the values returned by inferior
7364 function calls are special in any way. So this function may not
7365 notice that an expression involving an inferior function call
7366 can't be watched with hardware watchpoints. FIXME. */
7367 for (; v; v = value_next (v))
7369 if (VALUE_LVAL (v) == lval_memory)
7372 /* A lazy memory lvalue is one that GDB never needed to fetch;
7373 we either just used its address (e.g., `a' in `a.b') or
7374 we never needed it at all (e.g., `a' in `a,b'). */
7378 /* Ahh, memory we actually used! Check if we can cover
7379 it with hardware watchpoints. */
7380 struct type *vtype = check_typedef (value_type (v));
7382 /* We only watch structs and arrays if user asked for it
7383 explicitly, never if they just happen to appear in a
7384 middle of some value chain. */
7386 || (TYPE_CODE (vtype) != TYPE_CODE_STRUCT
7387 && TYPE_CODE (vtype) != TYPE_CODE_ARRAY))
7389 CORE_ADDR vaddr = value_address (v);
7390 int len = TYPE_LENGTH (value_type (v));
7392 if (!target_region_ok_for_hw_watchpoint (vaddr, len))
7399 else if (VALUE_LVAL (v) != not_lval
7400 && deprecated_value_modifiable (v) == 0)
7401 return 0; /* ??? What does this represent? */
7402 else if (VALUE_LVAL (v) == lval_register)
7403 return 0; /* cannot watch a register with a HW watchpoint */
7406 /* The expression itself looks suitable for using a hardware
7407 watchpoint, but give the target machine a chance to reject it. */
7408 return found_memory_cnt;
7412 watch_command_wrapper (char *arg, int from_tty)
7414 watch_command (arg, from_tty);
7418 watch_command (char *arg, int from_tty)
7420 watch_command_1 (arg, hw_write, from_tty);
7424 rwatch_command_wrapper (char *arg, int from_tty)
7426 rwatch_command (arg, from_tty);
7430 rwatch_command (char *arg, int from_tty)
7432 watch_command_1 (arg, hw_read, from_tty);
7436 awatch_command_wrapper (char *arg, int from_tty)
7438 awatch_command (arg, from_tty);
7442 awatch_command (char *arg, int from_tty)
7444 watch_command_1 (arg, hw_access, from_tty);
7448 /* Helper routines for the until_command routine in infcmd.c. Here
7449 because it uses the mechanisms of breakpoints. */
7451 struct until_break_command_continuation_args
7453 struct breakpoint *breakpoint;
7454 struct breakpoint *breakpoint2;
7457 /* This function is called by fetch_inferior_event via the
7458 cmd_continuation pointer, to complete the until command. It takes
7459 care of cleaning up the temporary breakpoints set up by the until
7462 until_break_command_continuation (void *arg)
7464 struct until_break_command_continuation_args *a = arg;
7466 delete_breakpoint (a->breakpoint);
7468 delete_breakpoint (a->breakpoint2);
7472 until_break_command (char *arg, int from_tty, int anywhere)
7474 struct symtabs_and_lines sals;
7475 struct symtab_and_line sal;
7476 struct frame_info *frame = get_selected_frame (NULL);
7477 struct breakpoint *breakpoint;
7478 struct breakpoint *breakpoint2 = NULL;
7479 struct cleanup *old_chain;
7481 clear_proceed_status ();
7483 /* Set a breakpoint where the user wants it and at return from
7486 if (default_breakpoint_valid)
7487 sals = decode_line_1 (&arg, 1, default_breakpoint_symtab,
7488 default_breakpoint_line, (char ***) NULL, NULL);
7490 sals = decode_line_1 (&arg, 1, (struct symtab *) NULL,
7491 0, (char ***) NULL, NULL);
7493 if (sals.nelts != 1)
7494 error (_("Couldn't get information on specified line."));
7497 xfree (sals.sals); /* malloc'd, so freed */
7500 error (_("Junk at end of arguments."));
7502 resolve_sal_pc (&sal);
7505 /* If the user told us to continue until a specified location,
7506 we don't specify a frame at which we need to stop. */
7507 breakpoint = set_momentary_breakpoint (get_frame_arch (frame), sal,
7508 null_frame_id, bp_until);
7510 /* Otherwise, specify the selected frame, because we want to stop only
7511 at the very same frame. */
7512 breakpoint = set_momentary_breakpoint (get_frame_arch (frame), sal,
7513 get_stack_frame_id (frame),
7516 old_chain = make_cleanup_delete_breakpoint (breakpoint);
7518 /* Keep within the current frame, or in frames called by the current
7521 if (frame_id_p (frame_unwind_caller_id (frame)))
7523 sal = find_pc_line (frame_unwind_caller_pc (frame), 0);
7524 sal.pc = frame_unwind_caller_pc (frame);
7525 breakpoint2 = set_momentary_breakpoint (frame_unwind_caller_arch (frame),
7527 frame_unwind_caller_id (frame),
7529 make_cleanup_delete_breakpoint (breakpoint2);
7532 proceed (-1, TARGET_SIGNAL_DEFAULT, 0);
7534 /* If we are running asynchronously, and proceed call above has actually
7535 managed to start the target, arrange for breakpoints to be
7536 deleted when the target stops. Otherwise, we're already stopped and
7537 delete breakpoints via cleanup chain. */
7539 if (target_can_async_p () && is_running (inferior_ptid))
7541 struct until_break_command_continuation_args *args;
7542 args = xmalloc (sizeof (*args));
7544 args->breakpoint = breakpoint;
7545 args->breakpoint2 = breakpoint2;
7547 discard_cleanups (old_chain);
7548 add_continuation (inferior_thread (),
7549 until_break_command_continuation, args,
7553 do_cleanups (old_chain);
7557 ep_skip_leading_whitespace (char **s)
7559 if ((s == NULL) || (*s == NULL))
7561 while (isspace (**s))
7565 /* This function attempts to parse an optional "if <cond>" clause
7566 from the arg string. If one is not found, it returns NULL.
7568 Else, it returns a pointer to the condition string. (It does not
7569 attempt to evaluate the string against a particular block.) And,
7570 it updates arg to point to the first character following the parsed
7571 if clause in the arg string. */
7574 ep_parse_optional_if_clause (char **arg)
7578 if (((*arg)[0] != 'i') || ((*arg)[1] != 'f') || !isspace ((*arg)[2]))
7581 /* Skip the "if" keyword. */
7584 /* Skip any extra leading whitespace, and record the start of the
7585 condition string. */
7586 ep_skip_leading_whitespace (arg);
7589 /* Assume that the condition occupies the remainder of the arg string. */
7590 (*arg) += strlen (cond_string);
7595 /* This function attempts to parse an optional filename from the arg
7596 string. If one is not found, it returns NULL.
7598 Else, it returns a pointer to the parsed filename. (This function
7599 makes no attempt to verify that a file of that name exists, or is
7600 accessible.) And, it updates arg to point to the first character
7601 following the parsed filename in the arg string.
7603 Note that clients needing to preserve the returned filename for
7604 future access should copy it to their own buffers. */
7606 ep_parse_optional_filename (char **arg)
7608 static char filename[1024];
7613 if ((*arg_p == '\0') || isspace (*arg_p))
7631 /* Commands to deal with catching events, such as signals, exceptions,
7632 process start/exit, etc. */
7636 catch_fork_temporary, catch_vfork_temporary,
7637 catch_fork_permanent, catch_vfork_permanent
7642 catch_fork_command_1 (char *arg, int from_tty, struct cmd_list_element *command)
7644 struct gdbarch *gdbarch = get_current_arch ();
7645 char *cond_string = NULL;
7646 catch_fork_kind fork_kind;
7649 fork_kind = (catch_fork_kind) (uintptr_t) get_cmd_context (command);
7650 tempflag = (fork_kind == catch_fork_temporary
7651 || fork_kind == catch_vfork_temporary);
7655 ep_skip_leading_whitespace (&arg);
7657 /* The allowed syntax is:
7659 catch [v]fork if <cond>
7661 First, check if there's an if clause. */
7662 cond_string = ep_parse_optional_if_clause (&arg);
7664 if ((*arg != '\0') && !isspace (*arg))
7665 error (_("Junk at end of arguments."));
7667 /* If this target supports it, create a fork or vfork catchpoint
7668 and enable reporting of such events. */
7671 case catch_fork_temporary:
7672 case catch_fork_permanent:
7673 create_fork_vfork_event_catchpoint (gdbarch, tempflag, cond_string,
7674 &catch_fork_breakpoint_ops);
7676 case catch_vfork_temporary:
7677 case catch_vfork_permanent:
7678 create_fork_vfork_event_catchpoint (gdbarch, tempflag, cond_string,
7679 &catch_vfork_breakpoint_ops);
7682 error (_("unsupported or unknown fork kind; cannot catch it"));
7688 catch_exec_command_1 (char *arg, int from_tty, struct cmd_list_element *command)
7690 struct gdbarch *gdbarch = get_current_arch ();
7692 char *cond_string = NULL;
7694 tempflag = get_cmd_context (command) == CATCH_TEMPORARY;
7698 ep_skip_leading_whitespace (&arg);
7700 /* The allowed syntax is:
7702 catch exec if <cond>
7704 First, check if there's an if clause. */
7705 cond_string = ep_parse_optional_if_clause (&arg);
7707 if ((*arg != '\0') && !isspace (*arg))
7708 error (_("Junk at end of arguments."));
7710 /* If this target supports it, create an exec catchpoint
7711 and enable reporting of such events. */
7712 create_catchpoint (gdbarch, tempflag, cond_string,
7713 &catch_exec_breakpoint_ops);
7716 static enum print_stop_action
7717 print_exception_catchpoint (struct breakpoint *b)
7719 int bp_temp, bp_throw;
7721 annotate_catchpoint (b->number);
7723 bp_throw = strstr (b->addr_string, "throw") != NULL;
7724 if (b->loc->address != b->loc->requested_address)
7725 breakpoint_adjustment_warning (b->loc->requested_address,
7728 bp_temp = b->disposition == disp_del;
7730 bp_temp ? "Temporary catchpoint "
7732 if (!ui_out_is_mi_like_p (uiout))
7733 ui_out_field_int (uiout, "bkptno", b->number);
7735 bp_throw ? " (exception thrown), "
7736 : " (exception caught), ");
7737 if (ui_out_is_mi_like_p (uiout))
7739 ui_out_field_string (uiout, "reason",
7740 async_reason_lookup (EXEC_ASYNC_BREAKPOINT_HIT));
7741 ui_out_field_string (uiout, "disp", bpdisp_text (b->disposition));
7742 ui_out_field_int (uiout, "bkptno", b->number);
7744 return PRINT_SRC_AND_LOC;
7748 print_one_exception_catchpoint (struct breakpoint *b, struct bp_location **last_loc)
7750 struct value_print_options opts;
7751 get_user_print_options (&opts);
7752 if (opts.addressprint)
7755 if (b->loc == NULL || b->loc->shlib_disabled)
7756 ui_out_field_string (uiout, "addr", "<PENDING>");
7758 ui_out_field_core_addr (uiout, "addr",
7759 b->loc->gdbarch, b->loc->address);
7764 if (strstr (b->addr_string, "throw") != NULL)
7765 ui_out_field_string (uiout, "what", "exception throw");
7767 ui_out_field_string (uiout, "what", "exception catch");
7771 print_mention_exception_catchpoint (struct breakpoint *b)
7776 bp_temp = b->disposition == disp_del;
7777 bp_throw = strstr (b->addr_string, "throw") != NULL;
7778 ui_out_text (uiout, bp_temp ? _("Temporary catchpoint ")
7779 : _("Catchpoint "));
7780 ui_out_field_int (uiout, "bkptno", b->number);
7781 ui_out_text (uiout, bp_throw ? _(" (throw)")
7785 static struct breakpoint_ops gnu_v3_exception_catchpoint_ops = {
7788 NULL, /* breakpoint_hit */
7789 print_exception_catchpoint,
7790 print_one_exception_catchpoint,
7791 print_mention_exception_catchpoint
7795 handle_gnu_v3_exceptions (int tempflag, char *cond_string,
7796 enum exception_event_kind ex_event, int from_tty)
7798 char *trigger_func_name;
7800 if (ex_event == EX_EVENT_CATCH)
7801 trigger_func_name = "__cxa_begin_catch";
7803 trigger_func_name = "__cxa_throw";
7805 break_command_really (get_current_arch (),
7806 trigger_func_name, cond_string, -1,
7807 0 /* condition and thread are valid. */,
7810 AUTO_BOOLEAN_TRUE /* pending */,
7811 &gnu_v3_exception_catchpoint_ops, from_tty,
7817 /* Deal with "catch catch" and "catch throw" commands */
7820 catch_exception_command_1 (enum exception_event_kind ex_event, char *arg,
7821 int tempflag, int from_tty)
7823 char *cond_string = NULL;
7824 struct symtab_and_line *sal = NULL;
7828 ep_skip_leading_whitespace (&arg);
7830 cond_string = ep_parse_optional_if_clause (&arg);
7832 if ((*arg != '\0') && !isspace (*arg))
7833 error (_("Junk at end of arguments."));
7835 if (ex_event != EX_EVENT_THROW
7836 && ex_event != EX_EVENT_CATCH)
7837 error (_("Unsupported or unknown exception event; cannot catch it"));
7839 if (handle_gnu_v3_exceptions (tempflag, cond_string, ex_event, from_tty))
7842 warning (_("Unsupported with this platform/compiler combination."));
7845 /* Implementation of "catch catch" command. */
7848 catch_catch_command (char *arg, int from_tty, struct cmd_list_element *command)
7850 int tempflag = get_cmd_context (command) == CATCH_TEMPORARY;
7851 catch_exception_command_1 (EX_EVENT_CATCH, arg, tempflag, from_tty);
7854 /* Implementation of "catch throw" command. */
7857 catch_throw_command (char *arg, int from_tty, struct cmd_list_element *command)
7859 int tempflag = get_cmd_context (command) == CATCH_TEMPORARY;
7860 catch_exception_command_1 (EX_EVENT_THROW, arg, tempflag, from_tty);
7863 /* Create a breakpoint struct for Ada exception catchpoints. */
7866 create_ada_exception_breakpoint (struct gdbarch *gdbarch,
7867 struct symtab_and_line sal,
7871 struct expression *cond,
7872 struct breakpoint_ops *ops,
7876 struct breakpoint *b;
7880 struct gdbarch *loc_gdbarch = get_sal_arch (sal);
7882 loc_gdbarch = gdbarch;
7884 describe_other_breakpoints (loc_gdbarch,
7885 sal.pspace, sal.pc, sal.section, -1);
7886 /* FIXME: brobecker/2006-12-28: Actually, re-implement a special
7887 version for exception catchpoints, because two catchpoints
7888 used for different exception names will use the same address.
7889 In this case, a "breakpoint ... also set at..." warning is
7890 unproductive. Besides. the warning phrasing is also a bit
7891 inapropriate, we should use the word catchpoint, and tell
7892 the user what type of catchpoint it is. The above is good
7893 enough for now, though. */
7896 b = set_raw_breakpoint (gdbarch, sal, bp_breakpoint);
7897 set_breakpoint_count (breakpoint_count + 1);
7899 b->enable_state = bp_enabled;
7900 b->disposition = tempflag ? disp_del : disp_donttouch;
7901 b->number = breakpoint_count;
7902 b->ignore_count = 0;
7903 b->loc->cond = cond;
7904 b->addr_string = addr_string;
7905 b->language = language_ada;
7906 b->cond_string = cond_string;
7907 b->exp_string = exp_string;
7912 update_global_location_list (1);
7915 /* Implement the "catch exception" command. */
7918 catch_ada_exception_command (char *arg, int from_tty,
7919 struct cmd_list_element *command)
7921 struct gdbarch *gdbarch = get_current_arch ();
7923 struct symtab_and_line sal;
7925 char *addr_string = NULL;
7926 char *exp_string = NULL;
7927 char *cond_string = NULL;
7928 struct expression *cond = NULL;
7929 struct breakpoint_ops *ops = NULL;
7931 tempflag = get_cmd_context (command) == CATCH_TEMPORARY;
7935 sal = ada_decode_exception_location (arg, &addr_string, &exp_string,
7936 &cond_string, &cond, &ops);
7937 create_ada_exception_breakpoint (gdbarch, sal, addr_string, exp_string,
7938 cond_string, cond, ops, tempflag,
7942 /* Cleanup function for a syscall filter list. */
7944 clean_up_filters (void *arg)
7946 VEC(int) *iter = *(VEC(int) **) arg;
7947 VEC_free (int, iter);
7950 /* Splits the argument using space as delimiter. Returns an xmalloc'd
7951 filter list, or NULL if no filtering is required. */
7953 catch_syscall_split_args (char *arg)
7955 VEC(int) *result = NULL;
7956 struct cleanup *cleanup = make_cleanup (clean_up_filters, &result);
7958 while (*arg != '\0')
7960 int i, syscall_number;
7965 /* Skip whitespace. */
7966 while (isspace (*arg))
7969 for (i = 0; i < 127 && arg[i] && !isspace (arg[i]); ++i)
7970 cur_name[i] = arg[i];
7974 /* Check if the user provided a syscall name or a number. */
7975 syscall_number = (int) strtol (cur_name, &endptr, 0);
7976 if (*endptr == '\0')
7977 get_syscall_by_number (syscall_number, &s);
7980 /* We have a name. Let's check if it's valid and convert it
7982 get_syscall_by_name (cur_name, &s);
7984 if (s.number == UNKNOWN_SYSCALL)
7985 /* Here we have to issue an error instead of a warning, because
7986 GDB cannot do anything useful if there's no syscall number to
7988 error (_("Unknown syscall name '%s'."), cur_name);
7991 /* Ok, it's valid. */
7992 VEC_safe_push (int, result, s.number);
7995 discard_cleanups (cleanup);
7999 /* Implement the "catch syscall" command. */
8002 catch_syscall_command_1 (char *arg, int from_tty, struct cmd_list_element *command)
8007 struct gdbarch *gdbarch = get_current_arch ();
8009 /* Checking if the feature if supported. */
8010 if (gdbarch_get_syscall_number_p (gdbarch) == 0)
8011 error (_("The feature 'catch syscall' is not supported on \
8012 this architeture yet."));
8014 tempflag = get_cmd_context (command) == CATCH_TEMPORARY;
8016 ep_skip_leading_whitespace (&arg);
8018 /* We need to do this first "dummy" translation in order
8019 to get the syscall XML file loaded or, most important,
8020 to display a warning to the user if there's no XML file
8021 for his/her architecture. */
8022 get_syscall_by_number (0, &s);
8024 /* The allowed syntax is:
8026 catch syscall <name | number> [<name | number> ... <name | number>]
8028 Let's check if there's a syscall name. */
8031 filter = catch_syscall_split_args (arg);
8035 create_syscall_event_catchpoint (tempflag, filter,
8036 &catch_syscall_breakpoint_ops);
8039 /* Implement the "catch assert" command. */
8042 catch_assert_command (char *arg, int from_tty, struct cmd_list_element *command)
8044 struct gdbarch *gdbarch = get_current_arch ();
8046 struct symtab_and_line sal;
8047 char *addr_string = NULL;
8048 struct breakpoint_ops *ops = NULL;
8050 tempflag = get_cmd_context (command) == CATCH_TEMPORARY;
8054 sal = ada_decode_assert_location (arg, &addr_string, &ops);
8055 create_ada_exception_breakpoint (gdbarch, sal, addr_string, NULL, NULL, NULL,
8056 ops, tempflag, from_tty);
8060 catch_command (char *arg, int from_tty)
8062 error (_("Catch requires an event name."));
8067 tcatch_command (char *arg, int from_tty)
8069 error (_("Catch requires an event name."));
8072 /* Delete breakpoints by address or line. */
8075 clear_command (char *arg, int from_tty)
8077 struct breakpoint *b;
8078 VEC(breakpoint_p) *found = 0;
8081 struct symtabs_and_lines sals;
8082 struct symtab_and_line sal;
8087 sals = decode_line_spec (arg, 1);
8092 sals.sals = (struct symtab_and_line *)
8093 xmalloc (sizeof (struct symtab_and_line));
8094 make_cleanup (xfree, sals.sals);
8095 init_sal (&sal); /* initialize to zeroes */
8096 sal.line = default_breakpoint_line;
8097 sal.symtab = default_breakpoint_symtab;
8098 sal.pc = default_breakpoint_address;
8099 sal.pspace = default_breakpoint_pspace;
8100 if (sal.symtab == 0)
8101 error (_("No source file specified."));
8109 /* We don't call resolve_sal_pc here. That's not
8110 as bad as it seems, because all existing breakpoints
8111 typically have both file/line and pc set. So, if
8112 clear is given file/line, we can match this to existing
8113 breakpoint without obtaining pc at all.
8115 We only support clearing given the address explicitly
8116 present in breakpoint table. Say, we've set breakpoint
8117 at file:line. There were several PC values for that file:line,
8118 due to optimization, all in one block.
8119 We've picked one PC value. If "clear" is issued with another
8120 PC corresponding to the same file:line, the breakpoint won't
8121 be cleared. We probably can still clear the breakpoint, but
8122 since the other PC value is never presented to user, user
8123 can only find it by guessing, and it does not seem important
8126 /* For each line spec given, delete bps which correspond
8127 to it. Do it in two passes, solely to preserve the current
8128 behavior that from_tty is forced true if we delete more than
8132 for (i = 0; i < sals.nelts; i++)
8134 /* If exact pc given, clear bpts at that pc.
8135 If line given (pc == 0), clear all bpts on specified line.
8136 If defaulting, clear all bpts on default line
8139 defaulting sal.pc != 0 tests to do
8144 1 0 <can't happen> */
8148 /* Find all matching breakpoints and add them to
8153 /* Are we going to delete b? */
8154 if (b->type != bp_none
8155 && b->type != bp_watchpoint
8156 && b->type != bp_hardware_watchpoint
8157 && b->type != bp_read_watchpoint
8158 && b->type != bp_access_watchpoint)
8160 struct bp_location *loc = b->loc;
8161 for (; loc; loc = loc->next)
8163 int pc_match = sal.pc
8164 && (loc->pspace == sal.pspace)
8165 && (loc->address == sal.pc)
8166 && (!section_is_overlay (loc->section)
8167 || loc->section == sal.section);
8168 int line_match = ((default_match || (0 == sal.pc))
8169 && b->source_file != NULL
8170 && sal.symtab != NULL
8171 && sal.pspace == loc->pspace
8172 && strcmp (b->source_file, sal.symtab->filename) == 0
8173 && b->line_number == sal.line);
8174 if (pc_match || line_match)
8183 VEC_safe_push(breakpoint_p, found, b);
8186 /* Now go thru the 'found' chain and delete them. */
8187 if (VEC_empty(breakpoint_p, found))
8190 error (_("No breakpoint at %s."), arg);
8192 error (_("No breakpoint at this line."));
8195 if (VEC_length(breakpoint_p, found) > 1)
8196 from_tty = 1; /* Always report if deleted more than one */
8199 if (VEC_length(breakpoint_p, found) == 1)
8200 printf_unfiltered (_("Deleted breakpoint "));
8202 printf_unfiltered (_("Deleted breakpoints "));
8204 breakpoints_changed ();
8206 for (ix = 0; VEC_iterate(breakpoint_p, found, ix, b); ix++)
8209 printf_unfiltered ("%d ", b->number);
8210 delete_breakpoint (b);
8213 putchar_unfiltered ('\n');
8216 /* Delete breakpoint in BS if they are `delete' breakpoints and
8217 all breakpoints that are marked for deletion, whether hit or not.
8218 This is called after any breakpoint is hit, or after errors. */
8221 breakpoint_auto_delete (bpstat bs)
8223 struct breakpoint *b, *temp;
8225 for (; bs; bs = bs->next)
8226 if (bs->breakpoint_at
8227 && bs->breakpoint_at->owner
8228 && bs->breakpoint_at->owner->disposition == disp_del
8230 delete_breakpoint (bs->breakpoint_at->owner);
8232 ALL_BREAKPOINTS_SAFE (b, temp)
8234 if (b->disposition == disp_del_at_next_stop)
8235 delete_breakpoint (b);
8239 /* A comparison function for bp_location AP and BP being interfaced to qsort.
8240 Sort elements primarily by their ADDRESS (no matter what does
8241 breakpoint_address_is_meaningful say for its OWNER), secondarily by ordering
8242 first bp_permanent OWNERed elements and terciarily just ensuring the array
8243 is sorted stable way despite qsort being an instable algorithm. */
8246 bp_location_compare (const void *ap, const void *bp)
8248 struct bp_location *a = *(void **) ap;
8249 struct bp_location *b = *(void **) bp;
8250 int a_perm = a->owner->enable_state == bp_permanent;
8251 int b_perm = b->owner->enable_state == bp_permanent;
8253 if (a->address != b->address)
8254 return (a->address > b->address) - (a->address < b->address);
8256 /* Sort permanent breakpoints first. */
8257 if (a_perm != b_perm)
8258 return (a_perm < b_perm) - (a_perm > b_perm);
8260 /* Make the user-visible order stable across GDB runs. Locations of the same
8261 breakpoint can be sorted in arbitrary order. */
8263 if (a->owner->number != b->owner->number)
8264 return (a->owner->number > b->owner->number)
8265 - (a->owner->number < b->owner->number);
8267 return (a > b) - (a < b);
8270 /* Set bp_location_placed_address_before_address_max and
8271 bp_location_shadow_len_after_address_max according to the current content of
8272 the bp_location array. */
8275 bp_location_target_extensions_update (void)
8277 struct bp_location *bl, **blp_tmp;
8279 bp_location_placed_address_before_address_max = 0;
8280 bp_location_shadow_len_after_address_max = 0;
8282 ALL_BP_LOCATIONS (bl, blp_tmp)
8284 CORE_ADDR start, end, addr;
8286 if (!bp_location_has_shadow (bl))
8289 start = bl->target_info.placed_address;
8290 end = start + bl->target_info.shadow_len;
8292 gdb_assert (bl->address >= start);
8293 addr = bl->address - start;
8294 if (addr > bp_location_placed_address_before_address_max)
8295 bp_location_placed_address_before_address_max = addr;
8297 /* Zero SHADOW_LEN would not pass bp_location_has_shadow. */
8299 gdb_assert (bl->address < end);
8300 addr = end - bl->address;
8301 if (addr > bp_location_shadow_len_after_address_max)
8302 bp_location_shadow_len_after_address_max = addr;
8306 /* If SHOULD_INSERT is false, do not insert any breakpoint locations
8307 into the inferior, only remove already-inserted locations that no
8308 longer should be inserted. Functions that delete a breakpoint or
8309 breakpoints should pass false, so that deleting a breakpoint
8310 doesn't have the side effect of inserting the locations of other
8311 breakpoints that are marked not-inserted, but should_be_inserted
8312 returns true on them.
8314 This behaviour is useful is situations close to tear-down -- e.g.,
8315 after an exec, while the target still has execution, but breakpoint
8316 shadows of the previous executable image should *NOT* be restored
8317 to the new image; or before detaching, where the target still has
8318 execution and wants to delete breakpoints from GDB's lists, and all
8319 breakpoints had already been removed from the inferior. */
8322 update_global_location_list (int should_insert)
8324 struct breakpoint *b;
8325 struct bp_location **locp, *loc;
8326 struct cleanup *cleanups;
8328 /* Used in the duplicates detection below. When iterating over all
8329 bp_locations, points to the first bp_location of a given address.
8330 Breakpoints and watchpoints of different types are never
8331 duplicates of each other. Keep one pointer for each type of
8332 breakpoint/watchpoint, so we only need to loop over all locations
8334 struct bp_location *bp_loc_first; /* breakpoint */
8335 struct bp_location *wp_loc_first; /* hardware watchpoint */
8336 struct bp_location *awp_loc_first; /* access watchpoint */
8337 struct bp_location *rwp_loc_first; /* read watchpoint */
8339 /* Saved former bp_location array which we compare against the newly built
8340 bp_location from the current state of ALL_BREAKPOINTS. */
8341 struct bp_location **old_location, **old_locp;
8342 unsigned old_location_count;
8344 old_location = bp_location;
8345 old_location_count = bp_location_count;
8347 bp_location_count = 0;
8348 cleanups = make_cleanup (xfree, old_location);
8351 for (loc = b->loc; loc; loc = loc->next)
8352 bp_location_count++;
8354 bp_location = xmalloc (sizeof (*bp_location) * bp_location_count);
8357 for (loc = b->loc; loc; loc = loc->next)
8359 qsort (bp_location, bp_location_count, sizeof (*bp_location),
8360 bp_location_compare);
8362 bp_location_target_extensions_update ();
8364 /* Identify bp_location instances that are no longer present in the new
8365 list, and therefore should be freed. Note that it's not necessary that
8366 those locations should be removed from inferior -- if there's another
8367 location at the same address (previously marked as duplicate),
8368 we don't need to remove/insert the location.
8370 LOCP is kept in sync with OLD_LOCP, each pointing to the current and
8371 former bp_location array state respectively. */
8374 for (old_locp = old_location; old_locp < old_location + old_location_count;
8377 struct bp_location *old_loc = *old_locp;
8378 struct bp_location **loc2p;
8380 /* Tells if 'old_loc' is found amoung the new locations. If not, we
8382 int found_object = 0;
8383 /* Tells if the location should remain inserted in the target. */
8384 int keep_in_target = 0;
8387 /* Skip LOCP entries which will definitely never be needed. Stop either
8388 at or being the one matching OLD_LOC. */
8389 while (locp < bp_location + bp_location_count
8390 && (*locp)->address < old_loc->address)
8394 (loc2p < bp_location + bp_location_count
8395 && (*loc2p)->address == old_loc->address);
8398 if (*loc2p == old_loc)
8405 /* If this location is no longer present, and inserted, look if there's
8406 maybe a new location at the same address. If so, mark that one
8407 inserted, and don't remove this one. This is needed so that we
8408 don't have a time window where a breakpoint at certain location is not
8411 if (old_loc->inserted)
8413 /* If the location is inserted now, we might have to remove it. */
8415 if (found_object && should_be_inserted (old_loc))
8417 /* The location is still present in the location list, and still
8418 should be inserted. Don't do anything. */
8423 /* The location is either no longer present, or got disabled.
8424 See if there's another location at the same address, in which
8425 case we don't need to remove this one from the target. */
8427 if (breakpoint_address_is_meaningful (old_loc->owner))
8430 (loc2p < bp_location + bp_location_count
8431 && (*loc2p)->address == old_loc->address);
8434 struct bp_location *loc2 = *loc2p;
8436 if (breakpoint_locations_match (loc2, old_loc))
8438 /* For the sake of should_be_inserted.
8439 Duplicates check below will fix up this later. */
8440 loc2->duplicate = 0;
8441 if (loc2 != old_loc && should_be_inserted (loc2))
8444 loc2->target_info = old_loc->target_info;
8453 if (!keep_in_target)
8455 if (remove_breakpoint (old_loc, mark_uninserted))
8457 /* This is just about all we can do. We could keep this
8458 location on the global list, and try to remove it next
8459 time, but there's no particular reason why we will
8462 Note that at this point, old_loc->owner is still valid,
8463 as delete_breakpoint frees the breakpoint only
8464 after calling us. */
8465 printf_filtered (_("warning: Error removing breakpoint %d\n"),
8466 old_loc->owner->number);
8474 if (removed && non_stop
8475 && breakpoint_address_is_meaningful (old_loc->owner)
8476 && !is_hardware_watchpoint (old_loc->owner))
8478 /* This location was removed from the target. In
8479 non-stop mode, a race condition is possible where
8480 we've removed a breakpoint, but stop events for that
8481 breakpoint are already queued and will arrive later.
8482 We apply an heuristic to be able to distinguish such
8483 SIGTRAPs from other random SIGTRAPs: we keep this
8484 breakpoint location for a bit, and will retire it
8485 after we see some number of events. The theory here
8486 is that reporting of events should, "on the average",
8487 be fair, so after a while we'll see events from all
8488 threads that have anything of interest, and no longer
8489 need to keep this breakpoint location around. We
8490 don't hold locations forever so to reduce chances of
8491 mistaking a non-breakpoint SIGTRAP for a breakpoint
8494 The heuristic failing can be disastrous on
8495 decr_pc_after_break targets.
8497 On decr_pc_after_break targets, like e.g., x86-linux,
8498 if we fail to recognize a late breakpoint SIGTRAP,
8499 because events_till_retirement has reached 0 too
8500 soon, we'll fail to do the PC adjustment, and report
8501 a random SIGTRAP to the user. When the user resumes
8502 the inferior, it will most likely immediately crash
8503 with SIGILL/SIGBUS/SEGSEGV, or worse, get silently
8504 corrupted, because of being resumed e.g., in the
8505 middle of a multi-byte instruction, or skipped a
8506 one-byte instruction. This was actually seen happen
8507 on native x86-linux, and should be less rare on
8508 targets that do not support new thread events, like
8509 remote, due to the heuristic depending on
8512 Mistaking a random SIGTRAP for a breakpoint trap
8513 causes similar symptoms (PC adjustment applied when
8514 it shouldn't), but then again, playing with SIGTRAPs
8515 behind the debugger's back is asking for trouble.
8517 Since hardware watchpoint traps are always
8518 distinguishable from other traps, so we don't need to
8519 apply keep hardware watchpoint moribund locations
8520 around. We simply always ignore hardware watchpoint
8521 traps we can no longer explain. */
8523 old_loc->events_till_retirement = 3 * (thread_count () + 1);
8524 old_loc->owner = NULL;
8526 VEC_safe_push (bp_location_p, moribund_locations, old_loc);
8529 free_bp_location (old_loc);
8533 /* Rescan breakpoints at the same address and section, marking the
8534 first one as "first" and any others as "duplicates". This is so
8535 that the bpt instruction is only inserted once. If we have a
8536 permanent breakpoint at the same place as BPT, make that one the
8537 official one, and the rest as duplicates. Permanent breakpoints
8538 are sorted first for the same address.
8540 Do the same for hardware watchpoints, but also considering the
8541 watchpoint's type (regular/access/read) and length. */
8543 bp_loc_first = NULL;
8544 wp_loc_first = NULL;
8545 awp_loc_first = NULL;
8546 rwp_loc_first = NULL;
8547 ALL_BP_LOCATIONS (loc, locp)
8549 struct breakpoint *b = loc->owner;
8550 struct bp_location **loc_first_p;
8552 if (b->enable_state == bp_disabled
8553 || b->enable_state == bp_call_disabled
8554 || b->enable_state == bp_startup_disabled
8556 || loc->shlib_disabled
8557 || !breakpoint_address_is_meaningful (b))
8560 /* Permanent breakpoint should always be inserted. */
8561 if (b->enable_state == bp_permanent && ! loc->inserted)
8562 internal_error (__FILE__, __LINE__,
8563 _("allegedly permanent breakpoint is not "
8564 "actually inserted"));
8566 if (b->type == bp_hardware_watchpoint)
8567 loc_first_p = &wp_loc_first;
8568 else if (b->type == bp_read_watchpoint)
8569 loc_first_p = &rwp_loc_first;
8570 else if (b->type == bp_access_watchpoint)
8571 loc_first_p = &awp_loc_first;
8573 loc_first_p = &bp_loc_first;
8575 if (*loc_first_p == NULL
8576 || (overlay_debugging && loc->section != (*loc_first_p)->section)
8577 || !breakpoint_locations_match (loc, *loc_first_p))
8586 if ((*loc_first_p)->owner->enable_state == bp_permanent && loc->inserted
8587 && b->enable_state != bp_permanent)
8588 internal_error (__FILE__, __LINE__,
8589 _("another breakpoint was inserted on top of "
8590 "a permanent breakpoint"));
8593 if (breakpoints_always_inserted_mode () && should_insert
8594 && (have_live_inferiors ()
8595 || (gdbarch_has_global_breakpoints (target_gdbarch))))
8596 insert_breakpoint_locations ();
8598 do_cleanups (cleanups);
8602 breakpoint_retire_moribund (void)
8604 struct bp_location *loc;
8607 for (ix = 0; VEC_iterate (bp_location_p, moribund_locations, ix, loc); ++ix)
8608 if (--(loc->events_till_retirement) == 0)
8610 free_bp_location (loc);
8611 VEC_unordered_remove (bp_location_p, moribund_locations, ix);
8617 update_global_location_list_nothrow (int inserting)
8619 struct gdb_exception e;
8620 TRY_CATCH (e, RETURN_MASK_ERROR)
8621 update_global_location_list (inserting);
8624 /* Clear BPT from a BPS. */
8626 bpstat_remove_breakpoint (bpstat bps, struct breakpoint *bpt)
8629 for (bs = bps; bs; bs = bs->next)
8630 if (bs->breakpoint_at && bs->breakpoint_at->owner == bpt)
8632 bs->breakpoint_at = NULL;
8634 /* bs->commands will be freed later. */
8638 /* Callback for iterate_over_threads. */
8640 bpstat_remove_breakpoint_callback (struct thread_info *th, void *data)
8642 struct breakpoint *bpt = data;
8643 bpstat_remove_breakpoint (th->stop_bpstat, bpt);
8647 /* Delete a breakpoint and clean up all traces of it in the data
8651 delete_breakpoint (struct breakpoint *bpt)
8653 struct breakpoint *b;
8654 struct bp_location *loc, *next;
8656 gdb_assert (bpt != NULL);
8658 /* Has this bp already been deleted? This can happen because multiple
8659 lists can hold pointers to bp's. bpstat lists are especial culprits.
8661 One example of this happening is a watchpoint's scope bp. When the
8662 scope bp triggers, we notice that the watchpoint is out of scope, and
8663 delete it. We also delete its scope bp. But the scope bp is marked
8664 "auto-deleting", and is already on a bpstat. That bpstat is then
8665 checked for auto-deleting bp's, which are deleted.
8667 A real solution to this problem might involve reference counts in bp's,
8668 and/or giving them pointers back to their referencing bpstat's, and
8669 teaching delete_breakpoint to only free a bp's storage when no more
8670 references were extent. A cheaper bandaid was chosen. */
8671 if (bpt->type == bp_none)
8674 observer_notify_breakpoint_deleted (bpt->number);
8676 if (breakpoint_chain == bpt)
8677 breakpoint_chain = bpt->next;
8682 b->next = bpt->next;
8686 free_command_lines (&bpt->commands);
8687 if (bpt->cond_string != NULL)
8688 xfree (bpt->cond_string);
8689 if (bpt->addr_string != NULL)
8690 xfree (bpt->addr_string);
8691 if (bpt->exp != NULL)
8693 if (bpt->exp_string != NULL)
8694 xfree (bpt->exp_string);
8695 if (bpt->val != NULL)
8696 value_free (bpt->val);
8697 if (bpt->source_file != NULL)
8698 xfree (bpt->source_file);
8699 if (bpt->exec_pathname != NULL)
8700 xfree (bpt->exec_pathname);
8701 clean_up_filters (&bpt->syscalls_to_be_caught);
8703 /* Be sure no bpstat's are pointing at it after it's been freed. */
8704 /* FIXME, how can we find all bpstat's?
8705 We just check stop_bpstat for now. Note that we cannot just
8706 remove bpstats pointing at bpt from the stop_bpstat list
8707 entirely, as breakpoint commands are associated with the bpstat;
8708 if we remove it here, then the later call to
8709 bpstat_do_actions (&stop_bpstat);
8710 in event-top.c won't do anything, and temporary breakpoints
8711 with commands won't work. */
8713 iterate_over_threads (bpstat_remove_breakpoint_callback, bpt);
8715 /* Now that breakpoint is removed from breakpoint
8716 list, update the global location list. This
8717 will remove locations that used to belong to
8718 this breakpoint. Do this before freeing
8719 the breakpoint itself, since remove_breakpoint
8720 looks at location's owner. It might be better
8721 design to have location completely self-contained,
8722 but it's not the case now. */
8723 update_global_location_list (0);
8726 /* On the chance that someone will soon try again to delete this same
8727 bp, we mark it as deleted before freeing its storage. */
8728 bpt->type = bp_none;
8734 do_delete_breakpoint_cleanup (void *b)
8736 delete_breakpoint (b);
8740 make_cleanup_delete_breakpoint (struct breakpoint *b)
8742 return make_cleanup (do_delete_breakpoint_cleanup, b);
8746 delete_command (char *arg, int from_tty)
8748 struct breakpoint *b, *temp;
8754 int breaks_to_delete = 0;
8756 /* Delete all breakpoints if no argument.
8757 Do not delete internal or call-dummy breakpoints, these
8758 have to be deleted with an explicit breakpoint number argument. */
8761 if (b->type != bp_call_dummy
8762 && b->type != bp_shlib_event
8763 && b->type != bp_jit_event
8764 && b->type != bp_thread_event
8765 && b->type != bp_overlay_event
8766 && b->type != bp_longjmp_master
8769 breaks_to_delete = 1;
8774 /* Ask user only if there are some breakpoints to delete. */
8776 || (breaks_to_delete && query (_("Delete all breakpoints? "))))
8778 ALL_BREAKPOINTS_SAFE (b, temp)
8780 if (b->type != bp_call_dummy
8781 && b->type != bp_shlib_event
8782 && b->type != bp_thread_event
8783 && b->type != bp_jit_event
8784 && b->type != bp_overlay_event
8785 && b->type != bp_longjmp_master
8787 delete_breakpoint (b);
8792 map_breakpoint_numbers (arg, delete_breakpoint);
8796 all_locations_are_pending (struct bp_location *loc)
8798 for (; loc; loc = loc->next)
8799 if (!loc->shlib_disabled)
8804 /* Subroutine of update_breakpoint_locations to simplify it.
8805 Return non-zero if multiple fns in list LOC have the same name.
8806 Null names are ignored. */
8809 ambiguous_names_p (struct bp_location *loc)
8811 struct bp_location *l;
8812 htab_t htab = htab_create_alloc (13, htab_hash_string,
8813 (int (*) (const void *, const void *)) streq,
8814 NULL, xcalloc, xfree);
8816 for (l = loc; l != NULL; l = l->next)
8819 const char *name = l->function_name;
8821 /* Allow for some names to be NULL, ignore them. */
8825 slot = (const char **) htab_find_slot (htab, (const void *) name,
8827 /* NOTE: We can assume slot != NULL here because xcalloc never returns
8842 update_breakpoint_locations (struct breakpoint *b,
8843 struct symtabs_and_lines sals)
8847 struct bp_location *existing_locations = b->loc;
8849 /* If there's no new locations, and all existing locations
8850 are pending, don't do anything. This optimizes
8851 the common case where all locations are in the same
8852 shared library, that was unloaded. We'd like to
8853 retain the location, so that when the library
8854 is loaded again, we don't loose the enabled/disabled
8855 status of the individual locations. */
8856 if (all_locations_are_pending (existing_locations) && sals.nelts == 0)
8861 for (i = 0; i < sals.nelts; ++i)
8863 struct bp_location *new_loc =
8864 add_location_to_breakpoint (b, &(sals.sals[i]));
8866 /* Reparse conditions, they might contain references to the
8868 if (b->cond_string != NULL)
8870 struct gdb_exception e;
8873 TRY_CATCH (e, RETURN_MASK_ERROR)
8875 new_loc->cond = parse_exp_1 (&s, block_for_pc (sals.sals[i].pc),
8880 warning (_("failed to reevaluate condition for breakpoint %d: %s"),
8881 b->number, e.message);
8882 new_loc->enabled = 0;
8886 if (b->source_file != NULL)
8887 xfree (b->source_file);
8888 if (sals.sals[i].symtab == NULL)
8889 b->source_file = NULL;
8891 b->source_file = xstrdup (sals.sals[i].symtab->filename);
8893 if (b->line_number == 0)
8894 b->line_number = sals.sals[i].line;
8897 /* Update locations of permanent breakpoints. */
8898 if (b->enable_state == bp_permanent)
8899 make_breakpoint_permanent (b);
8901 /* If possible, carry over 'disable' status from existing breakpoints. */
8903 struct bp_location *e = existing_locations;
8904 /* If there are multiple breakpoints with the same function name,
8905 e.g. for inline functions, comparing function names won't work.
8906 Instead compare pc addresses; this is just a heuristic as things
8907 may have moved, but in practice it gives the correct answer
8908 often enough until a better solution is found. */
8909 int have_ambiguous_names = ambiguous_names_p (b->loc);
8911 for (; e; e = e->next)
8913 if (!e->enabled && e->function_name)
8915 struct bp_location *l = b->loc;
8916 if (have_ambiguous_names)
8918 for (; l; l = l->next)
8919 if (breakpoint_address_match (e->pspace->aspace, e->address,
8920 l->pspace->aspace, l->address))
8928 for (; l; l = l->next)
8929 if (l->function_name
8930 && strcmp (e->function_name, l->function_name) == 0)
8940 update_global_location_list (1);
8944 /* Reset a breakpoint given it's struct breakpoint * BINT.
8945 The value we return ends up being the return value from catch_errors.
8946 Unused in this case. */
8949 breakpoint_re_set_one (void *bint)
8951 /* get past catch_errs */
8952 struct breakpoint *b = (struct breakpoint *) bint;
8956 int *not_found_ptr = ¬_found;
8957 struct symtabs_and_lines sals = {0};
8958 struct symtabs_and_lines expanded = {0};
8960 enum enable_state save_enable;
8961 struct gdb_exception e;
8962 struct cleanup *cleanups = make_cleanup (null_cleanup, NULL);
8967 warning (_("attempted to reset apparently deleted breakpoint #%d?"),
8971 case bp_hardware_breakpoint:
8973 /* Do not attempt to re-set breakpoints disabled during startup. */
8974 if (b->enable_state == bp_startup_disabled)
8977 if (b->addr_string == NULL)
8979 /* Anything without a string can't be re-set. */
8980 delete_breakpoint (b);
8984 set_language (b->language);
8985 input_radix = b->input_radix;
8988 save_current_space_and_thread ();
8989 switch_to_program_space_and_thread (b->pspace);
8991 TRY_CATCH (e, RETURN_MASK_ERROR)
8993 sals = decode_line_1 (&s, 1, (struct symtab *) NULL, 0, (char ***) NULL,
8998 int not_found_and_ok = 0;
8999 /* For pending breakpoints, it's expected that parsing
9000 will fail until the right shared library is loaded.
9001 User has already told to create pending breakpoints and
9002 don't need extra messages. If breakpoint is in bp_shlib_disabled
9003 state, then user already saw the message about that breakpoint
9004 being disabled, and don't want to see more errors. */
9006 && (b->condition_not_parsed
9007 || (b->loc && b->loc->shlib_disabled)
9008 || b->enable_state == bp_disabled))
9009 not_found_and_ok = 1;
9011 if (!not_found_and_ok)
9013 /* We surely don't want to warn about the same breakpoint
9014 10 times. One solution, implemented here, is disable
9015 the breakpoint on error. Another solution would be to
9016 have separate 'warning emitted' flag. Since this
9017 happens only when a binary has changed, I don't know
9018 which approach is better. */
9019 b->enable_state = bp_disabled;
9020 throw_exception (e);
9026 gdb_assert (sals.nelts == 1);
9028 resolve_sal_pc (&sals.sals[0]);
9029 if (b->condition_not_parsed && s && s[0])
9031 char *cond_string = 0;
9035 find_condition_and_thread (s, sals.sals[0].pc,
9036 &cond_string, &thread, &task);
9038 b->cond_string = cond_string;
9041 b->condition_not_parsed = 0;
9044 expanded = expand_line_sal_maybe (sals.sals[0]);
9047 make_cleanup (xfree, sals.sals);
9048 update_breakpoint_locations (b, expanded);
9052 case bp_hardware_watchpoint:
9053 case bp_read_watchpoint:
9054 case bp_access_watchpoint:
9055 /* Watchpoint can be either on expression using entirely global variables,
9056 or it can be on local variables.
9058 Watchpoints of the first kind are never auto-deleted, and even persist
9059 across program restarts. Since they can use variables from shared
9060 libraries, we need to reparse expression as libraries are loaded
9063 Watchpoints on local variables can also change meaning as result
9064 of solib event. For example, if a watchpoint uses both a local and
9065 a global variables in expression, it's a local watchpoint, but
9066 unloading of a shared library will make the expression invalid.
9067 This is not a very common use case, but we still re-evaluate
9068 expression, to avoid surprises to the user.
9070 Note that for local watchpoints, we re-evaluate it only if
9071 watchpoints frame id is still valid. If it's not, it means
9072 the watchpoint is out of scope and will be deleted soon. In fact,
9073 I'm not sure we'll ever be called in this case.
9075 If a local watchpoint's frame id is still valid, then
9076 b->exp_valid_block is likewise valid, and we can safely use it.
9078 Don't do anything about disabled watchpoints, since they will
9079 be reevaluated again when enabled. */
9080 update_watchpoint (b, 1 /* reparse */);
9082 /* We needn't really do anything to reset these, since the mask
9083 that requests them is unaffected by e.g., new libraries being
9089 printf_filtered (_("Deleting unknown breakpoint type %d\n"), b->type);
9091 /* Delete overlay event and longjmp master breakpoints; they will be
9092 reset later by breakpoint_re_set. */
9093 case bp_overlay_event:
9094 case bp_longjmp_master:
9095 delete_breakpoint (b);
9098 /* This breakpoint is special, it's set up when the inferior
9099 starts and we really don't want to touch it. */
9100 case bp_shlib_event:
9102 /* Like bp_shlib_event, this breakpoint type is special.
9103 Once it is set up, we do not want to touch it. */
9104 case bp_thread_event:
9106 /* Keep temporary breakpoints, which can be encountered when we step
9107 over a dlopen call and SOLIB_ADD is resetting the breakpoints.
9108 Otherwise these should have been blown away via the cleanup chain
9109 or by breakpoint_init_inferior when we rerun the executable. */
9112 case bp_watchpoint_scope:
9114 case bp_step_resume:
9116 case bp_longjmp_resume:
9121 do_cleanups (cleanups);
9125 /* Re-set all breakpoints after symbols have been re-loaded. */
9127 breakpoint_re_set (void)
9129 struct breakpoint *b, *temp;
9130 enum language save_language;
9131 int save_input_radix;
9132 struct cleanup *old_chain;
9134 save_language = current_language->la_language;
9135 save_input_radix = input_radix;
9136 old_chain = save_current_program_space ();
9138 ALL_BREAKPOINTS_SAFE (b, temp)
9140 /* Format possible error msg */
9141 char *message = xstrprintf ("Error in re-setting breakpoint %d: ",
9143 struct cleanup *cleanups = make_cleanup (xfree, message);
9144 catch_errors (breakpoint_re_set_one, b, message, RETURN_MASK_ALL);
9145 do_cleanups (cleanups);
9147 set_language (save_language);
9148 input_radix = save_input_radix;
9150 jit_breakpoint_re_set ();
9152 do_cleanups (old_chain);
9154 create_overlay_event_breakpoint ("_ovly_debug_event");
9155 create_longjmp_master_breakpoint ("longjmp");
9156 create_longjmp_master_breakpoint ("_longjmp");
9157 create_longjmp_master_breakpoint ("siglongjmp");
9158 create_longjmp_master_breakpoint ("_siglongjmp");
9161 /* Reset the thread number of this breakpoint:
9163 - If the breakpoint is for all threads, leave it as-is.
9164 - Else, reset it to the current thread for inferior_ptid. */
9166 breakpoint_re_set_thread (struct breakpoint *b)
9168 if (b->thread != -1)
9170 if (in_thread_list (inferior_ptid))
9171 b->thread = pid_to_thread_id (inferior_ptid);
9173 /* We're being called after following a fork. The new fork is
9174 selected as current, and unless this was a vfork will have a
9175 different program space from the original thread. Reset that
9177 b->loc->pspace = current_program_space;
9181 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
9182 If from_tty is nonzero, it prints a message to that effect,
9183 which ends with a period (no newline). */
9186 set_ignore_count (int bptnum, int count, int from_tty)
9188 struct breakpoint *b;
9194 if (b->number == bptnum)
9196 b->ignore_count = count;
9200 printf_filtered (_("Will stop next time breakpoint %d is reached."),
9202 else if (count == 1)
9203 printf_filtered (_("Will ignore next crossing of breakpoint %d."),
9206 printf_filtered (_("Will ignore next %d crossings of breakpoint %d."),
9209 breakpoints_changed ();
9210 observer_notify_breakpoint_modified (b->number);
9214 error (_("No breakpoint number %d."), bptnum);
9218 make_breakpoint_silent (struct breakpoint *b)
9220 /* Silence the breakpoint. */
9224 /* Command to set ignore-count of breakpoint N to COUNT. */
9227 ignore_command (char *args, int from_tty)
9233 error_no_arg (_("a breakpoint number"));
9235 num = get_number (&p);
9237 error (_("bad breakpoint number: '%s'"), args);
9239 error (_("Second argument (specified ignore-count) is missing."));
9241 set_ignore_count (num,
9242 longest_to_int (value_as_long (parse_and_eval (p))),
9245 printf_filtered ("\n");
9248 /* Call FUNCTION on each of the breakpoints
9249 whose numbers are given in ARGS. */
9252 map_breakpoint_numbers (char *args, void (*function) (struct breakpoint *))
9257 struct breakpoint *b, *tmp;
9261 error_no_arg (_("one or more breakpoint numbers"));
9268 num = get_number_or_range (&p1);
9271 warning (_("bad breakpoint number at or near '%s'"), p);
9275 ALL_BREAKPOINTS_SAFE (b, tmp)
9276 if (b->number == num)
9278 struct breakpoint *related_breakpoint = b->related_breakpoint;
9281 if (related_breakpoint)
9282 function (related_breakpoint);
9286 printf_unfiltered (_("No breakpoint number %d.\n"), num);
9292 static struct bp_location *
9293 find_location_by_number (char *number)
9295 char *dot = strchr (number, '.');
9299 struct breakpoint *b;
9300 struct bp_location *loc;
9305 bp_num = get_number_or_range (&p1);
9307 error (_("Bad breakpoint number '%s'"), number);
9310 if (b->number == bp_num)
9315 if (!b || b->number != bp_num)
9316 error (_("Bad breakpoint number '%s'"), number);
9319 loc_num = get_number_or_range (&p1);
9321 error (_("Bad breakpoint location number '%s'"), number);
9325 for (;loc_num && loc; --loc_num, loc = loc->next)
9328 error (_("Bad breakpoint location number '%s'"), dot+1);
9334 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
9335 If from_tty is nonzero, it prints a message to that effect,
9336 which ends with a period (no newline). */
9339 disable_breakpoint (struct breakpoint *bpt)
9341 /* Never disable a watchpoint scope breakpoint; we want to
9342 hit them when we leave scope so we can delete both the
9343 watchpoint and its scope breakpoint at that time. */
9344 if (bpt->type == bp_watchpoint_scope)
9347 /* You can't disable permanent breakpoints. */
9348 if (bpt->enable_state == bp_permanent)
9351 bpt->enable_state = bp_disabled;
9353 update_global_location_list (0);
9355 observer_notify_breakpoint_modified (bpt->number);
9359 disable_command (char *args, int from_tty)
9361 struct breakpoint *bpt;
9363 ALL_BREAKPOINTS (bpt)
9367 warning (_("attempted to disable apparently deleted breakpoint #%d?"),
9373 case bp_hardware_breakpoint:
9375 case bp_hardware_watchpoint:
9376 case bp_read_watchpoint:
9377 case bp_access_watchpoint:
9378 disable_breakpoint (bpt);
9382 else if (strchr (args, '.'))
9384 struct bp_location *loc = find_location_by_number (args);
9387 update_global_location_list (0);
9390 map_breakpoint_numbers (args, disable_breakpoint);
9394 do_enable_breakpoint (struct breakpoint *bpt, enum bpdisp disposition)
9396 int target_resources_ok, other_type_used;
9399 if (bpt->type == bp_hardware_breakpoint)
9402 i = hw_breakpoint_used_count ();
9403 target_resources_ok =
9404 target_can_use_hardware_watchpoint (bp_hardware_breakpoint,
9406 if (target_resources_ok == 0)
9407 error (_("No hardware breakpoint support in the target."));
9408 else if (target_resources_ok < 0)
9409 error (_("Hardware breakpoints used exceeds limit."));
9412 if (bpt->type == bp_watchpoint
9413 || bpt->type == bp_hardware_watchpoint
9414 || bpt->type == bp_read_watchpoint
9415 || bpt->type == bp_access_watchpoint)
9417 struct gdb_exception e;
9419 TRY_CATCH (e, RETURN_MASK_ALL)
9421 update_watchpoint (bpt, 1 /* reparse */);
9425 exception_fprintf (gdb_stderr, e, _("Cannot enable watchpoint %d: "),
9431 if (bpt->enable_state != bp_permanent)
9432 bpt->enable_state = bp_enabled;
9433 bpt->disposition = disposition;
9434 update_global_location_list (1);
9435 breakpoints_changed ();
9437 observer_notify_breakpoint_modified (bpt->number);
9442 enable_breakpoint (struct breakpoint *bpt)
9444 do_enable_breakpoint (bpt, bpt->disposition);
9447 /* The enable command enables the specified breakpoints (or all defined
9448 breakpoints) so they once again become (or continue to be) effective
9449 in stopping the inferior. */
9452 enable_command (char *args, int from_tty)
9454 struct breakpoint *bpt;
9456 ALL_BREAKPOINTS (bpt)
9460 warning (_("attempted to enable apparently deleted breakpoint #%d?"),
9466 case bp_hardware_breakpoint:
9468 case bp_hardware_watchpoint:
9469 case bp_read_watchpoint:
9470 case bp_access_watchpoint:
9471 enable_breakpoint (bpt);
9475 else if (strchr (args, '.'))
9477 struct bp_location *loc = find_location_by_number (args);
9480 update_global_location_list (1);
9483 map_breakpoint_numbers (args, enable_breakpoint);
9487 enable_once_breakpoint (struct breakpoint *bpt)
9489 do_enable_breakpoint (bpt, disp_disable);
9493 enable_once_command (char *args, int from_tty)
9495 map_breakpoint_numbers (args, enable_once_breakpoint);
9499 enable_delete_breakpoint (struct breakpoint *bpt)
9501 do_enable_breakpoint (bpt, disp_del);
9505 enable_delete_command (char *args, int from_tty)
9507 map_breakpoint_numbers (args, enable_delete_breakpoint);
9511 set_breakpoint_cmd (char *args, int from_tty)
9516 show_breakpoint_cmd (char *args, int from_tty)
9520 /* Invalidate last known value of any hardware watchpoint if
9521 the memory which that value represents has been written to by
9525 invalidate_bp_value_on_memory_change (CORE_ADDR addr, int len,
9526 const bfd_byte *data)
9528 struct breakpoint *bp;
9530 ALL_BREAKPOINTS (bp)
9531 if (bp->enable_state == bp_enabled
9532 && bp->type == bp_hardware_watchpoint
9533 && bp->val_valid && bp->val)
9535 struct bp_location *loc;
9537 for (loc = bp->loc; loc != NULL; loc = loc->next)
9538 if (loc->loc_type == bp_loc_hardware_watchpoint
9539 && loc->address + loc->length > addr
9540 && addr + len > loc->address)
9542 value_free (bp->val);
9549 /* Use default_breakpoint_'s, or nothing if they aren't valid. */
9551 struct symtabs_and_lines
9552 decode_line_spec_1 (char *string, int funfirstline)
9554 struct symtabs_and_lines sals;
9556 error (_("Empty line specification."));
9557 if (default_breakpoint_valid)
9558 sals = decode_line_1 (&string, funfirstline,
9559 default_breakpoint_symtab,
9560 default_breakpoint_line,
9561 (char ***) NULL, NULL);
9563 sals = decode_line_1 (&string, funfirstline,
9564 (struct symtab *) NULL, 0, (char ***) NULL, NULL);
9566 error (_("Junk at end of line specification: %s"), string);
9570 /* Create and insert a raw software breakpoint at PC. Return an
9571 identifier, which should be used to remove the breakpoint later.
9572 In general, places which call this should be using something on the
9573 breakpoint chain instead; this function should be eliminated
9577 deprecated_insert_raw_breakpoint (struct gdbarch *gdbarch,
9578 struct address_space *aspace, CORE_ADDR pc)
9580 struct bp_target_info *bp_tgt;
9582 bp_tgt = XZALLOC (struct bp_target_info);
9584 bp_tgt->placed_address_space = aspace;
9585 bp_tgt->placed_address = pc;
9587 if (target_insert_breakpoint (gdbarch, bp_tgt) != 0)
9589 /* Could not insert the breakpoint. */
9597 /* Remove a breakpoint BP inserted by deprecated_insert_raw_breakpoint. */
9600 deprecated_remove_raw_breakpoint (struct gdbarch *gdbarch, void *bp)
9602 struct bp_target_info *bp_tgt = bp;
9605 ret = target_remove_breakpoint (gdbarch, bp_tgt);
9611 /* One (or perhaps two) breakpoints used for software single stepping. */
9613 static void *single_step_breakpoints[2];
9614 static struct gdbarch *single_step_gdbarch[2];
9616 /* Create and insert a breakpoint for software single step. */
9619 insert_single_step_breakpoint (struct gdbarch *gdbarch,
9620 struct address_space *aspace, CORE_ADDR next_pc)
9624 if (single_step_breakpoints[0] == NULL)
9626 bpt_p = &single_step_breakpoints[0];
9627 single_step_gdbarch[0] = gdbarch;
9631 gdb_assert (single_step_breakpoints[1] == NULL);
9632 bpt_p = &single_step_breakpoints[1];
9633 single_step_gdbarch[1] = gdbarch;
9636 /* NOTE drow/2006-04-11: A future improvement to this function would be
9637 to only create the breakpoints once, and actually put them on the
9638 breakpoint chain. That would let us use set_raw_breakpoint. We could
9639 adjust the addresses each time they were needed. Doing this requires
9640 corresponding changes elsewhere where single step breakpoints are
9641 handled, however. So, for now, we use this. */
9643 *bpt_p = deprecated_insert_raw_breakpoint (gdbarch, aspace, next_pc);
9645 error (_("Could not insert single-step breakpoint at %s"),
9646 paddress (gdbarch, next_pc));
9649 /* Remove and delete any breakpoints used for software single step. */
9652 remove_single_step_breakpoints (void)
9654 gdb_assert (single_step_breakpoints[0] != NULL);
9656 /* See insert_single_step_breakpoint for more about this deprecated
9658 deprecated_remove_raw_breakpoint (single_step_gdbarch[0],
9659 single_step_breakpoints[0]);
9660 single_step_gdbarch[0] = NULL;
9661 single_step_breakpoints[0] = NULL;
9663 if (single_step_breakpoints[1] != NULL)
9665 deprecated_remove_raw_breakpoint (single_step_gdbarch[1],
9666 single_step_breakpoints[1]);
9667 single_step_gdbarch[1] = NULL;
9668 single_step_breakpoints[1] = NULL;
9672 /* Check whether a software single-step breakpoint is inserted at PC. */
9675 single_step_breakpoint_inserted_here_p (struct address_space *aspace, CORE_ADDR pc)
9679 for (i = 0; i < 2; i++)
9681 struct bp_target_info *bp_tgt = single_step_breakpoints[i];
9683 && breakpoint_address_match (bp_tgt->placed_address_space,
9684 bp_tgt->placed_address,
9692 /* Returns 0 if 'bp' is NOT a syscall catchpoint,
9693 non-zero otherwise. */
9695 is_syscall_catchpoint_enabled (struct breakpoint *bp)
9697 if (syscall_catchpoint_p (bp)
9698 && bp->enable_state != bp_disabled
9699 && bp->enable_state != bp_call_disabled)
9706 catch_syscall_enabled (void)
9708 struct inferior *inf = current_inferior ();
9710 return inf->total_syscalls_count != 0;
9714 catching_syscall_number (int syscall_number)
9716 struct breakpoint *bp;
9718 ALL_BREAKPOINTS (bp)
9719 if (is_syscall_catchpoint_enabled (bp))
9721 if (bp->syscalls_to_be_caught)
9725 VEC_iterate (int, bp->syscalls_to_be_caught, i, iter);
9727 if (syscall_number == iter)
9737 /* Complete syscall names. Used by "catch syscall". */
9739 catch_syscall_completer (struct cmd_list_element *cmd,
9740 char *text, char *word)
9742 const char **list = get_syscall_names ();
9743 return (list == NULL) ? NULL : complete_on_enum (list, text, word);
9746 /* Tracepoint-specific operations. */
9748 /* Set tracepoint count to NUM. */
9750 set_tracepoint_count (int num)
9752 tracepoint_count = num;
9753 set_internalvar_integer (lookup_internalvar ("tpnum"), num);
9757 trace_command (char *arg, int from_tty)
9759 break_command_really (get_current_arch (),
9761 NULL, 0, 1 /* parse arg */,
9762 0 /* tempflag */, 0 /* hardwareflag */,
9764 0 /* Ignore count */,
9765 pending_break_support,
9769 set_tracepoint_count (breakpoint_count);
9772 /* Print information on tracepoint number TPNUM_EXP, or all if
9776 tracepoints_info (char *tpnum_exp, int from_tty)
9778 struct breakpoint *b;
9779 int tps_to_list = 0;
9781 /* In the no-arguments case, say "No tracepoints" if none found. */
9794 ui_out_message (uiout, 0, "No tracepoints.\n");
9799 /* Otherwise be the same as "info break". */
9800 breakpoints_info (tpnum_exp, from_tty);
9803 /* The 'enable trace' command enables tracepoints.
9804 Not supported by all targets. */
9806 enable_trace_command (char *args, int from_tty)
9808 enable_command (args, from_tty);
9811 /* The 'disable trace' command disables tracepoints.
9812 Not supported by all targets. */
9814 disable_trace_command (char *args, int from_tty)
9816 disable_command (args, from_tty);
9819 /* Remove a tracepoint (or all if no argument) */
9821 delete_trace_command (char *arg, int from_tty)
9823 struct breakpoint *b, *temp;
9829 int breaks_to_delete = 0;
9831 /* Delete all breakpoints if no argument.
9832 Do not delete internal or call-dummy breakpoints, these
9833 have to be deleted with an explicit breakpoint number argument. */
9838 breaks_to_delete = 1;
9843 /* Ask user only if there are some breakpoints to delete. */
9845 || (breaks_to_delete && query (_("Delete all tracepoints? "))))
9847 ALL_BREAKPOINTS_SAFE (b, temp)
9849 if (b->type == bp_tracepoint
9851 delete_breakpoint (b);
9856 map_breakpoint_numbers (arg, delete_breakpoint);
9859 /* Set passcount for tracepoint.
9861 First command argument is passcount, second is tracepoint number.
9862 If tracepoint number omitted, apply to most recently defined.
9863 Also accepts special argument "all". */
9866 trace_pass_command (char *args, int from_tty)
9868 struct breakpoint *t1 = (struct breakpoint *) -1, *t2;
9872 if (args == 0 || *args == 0)
9873 error (_("passcount command requires an argument (count + optional TP num)"));
9875 count = strtoul (args, &args, 10); /* Count comes first, then TP num. */
9877 while (*args && isspace ((int) *args))
9880 if (*args && strncasecmp (args, "all", 3) == 0)
9882 args += 3; /* Skip special argument "all". */
9885 error (_("Junk at end of arguments."));
9888 t1 = get_tracepoint_by_number (&args, 1, 1);
9894 ALL_TRACEPOINTS (t2)
9895 if (t1 == (struct breakpoint *) -1 || t1 == t2)
9897 t2->pass_count = count;
9898 observer_notify_tracepoint_modified (t2->number);
9900 printf_filtered (_("Setting tracepoint %d's passcount to %d\n"),
9904 t1 = get_tracepoint_by_number (&args, 1, 0);
9911 get_tracepoint (int num)
9913 struct breakpoint *t;
9916 if (t->number == num)
9922 /* Utility: parse a tracepoint number and look it up in the list.
9923 If MULTI_P is true, there might be a range of tracepoints in ARG.
9924 if OPTIONAL_P is true, then if the argument is missing, the most
9925 recent tracepoint (tracepoint_count) is returned. */
9927 get_tracepoint_by_number (char **arg, int multi_p, int optional_p)
9929 extern int tracepoint_count;
9930 struct breakpoint *t;
9932 char *instring = arg == NULL ? NULL : *arg;
9934 if (arg == NULL || *arg == NULL || ! **arg)
9937 tpnum = tracepoint_count;
9939 error_no_arg (_("tracepoint number"));
9942 tpnum = multi_p ? get_number_or_range (arg) : get_number (arg);
9946 if (instring && *instring)
9947 printf_filtered (_("bad tracepoint number at or near '%s'\n"),
9950 printf_filtered (_("Tracepoint argument missing and no previous tracepoint\n"));
9955 if (t->number == tpnum)
9960 /* FIXME: if we are in the middle of a range we don't want to give
9961 a message. The current interface to get_number_or_range doesn't
9962 allow us to discover this. */
9963 printf_unfiltered ("No tracepoint number %d.\n", tpnum);
9967 /* save-tracepoints command */
9969 tracepoint_save_command (char *args, int from_tty)
9971 struct breakpoint *tp;
9973 struct action_line *line;
9975 char *i1 = " ", *i2 = " ";
9976 char *indent, *actionline, *pathname;
9978 struct cleanup *cleanup;
9980 if (args == 0 || *args == 0)
9981 error (_("Argument required (file name in which to save tracepoints)"));
9983 /* See if we have anything to save. */
9984 ALL_TRACEPOINTS (tp)
9991 warning (_("save-tracepoints: no tracepoints to save."));
9995 pathname = tilde_expand (args);
9996 cleanup = make_cleanup (xfree, pathname);
9997 fp = fopen (pathname, "w");
9999 error (_("Unable to open file '%s' for saving tracepoints (%s)"),
10000 args, safe_strerror (errno));
10001 make_cleanup_fclose (fp);
10003 ALL_TRACEPOINTS (tp)
10005 if (tp->addr_string)
10006 fprintf (fp, "trace %s\n", tp->addr_string);
10009 sprintf_vma (tmp, tp->loc->address);
10010 fprintf (fp, "trace *0x%s\n", tmp);
10013 if (tp->pass_count)
10014 fprintf (fp, " passcount %d\n", tp->pass_count);
10018 fprintf (fp, " actions\n");
10020 for (line = tp->actions; line; line = line->next)
10022 struct cmd_list_element *cmd;
10024 QUIT; /* allow user to bail out with ^C */
10025 actionline = line->action;
10026 while (isspace ((int) *actionline))
10029 fprintf (fp, "%s%s\n", indent, actionline);
10030 if (*actionline != '#') /* skip for comment lines */
10032 cmd = lookup_cmd (&actionline, cmdlist, "", -1, 1);
10034 error (_("Bad action list item: %s"), actionline);
10035 if (cmd_cfunc_eq (cmd, while_stepping_pseudocommand))
10037 else if (cmd_cfunc_eq (cmd, end_actions_pseudocommand))
10043 do_cleanups (cleanup);
10045 printf_filtered (_("Tracepoints saved to file '%s'.\n"), args);
10049 /* Create a vector of all tracepoints. */
10051 VEC(breakpoint_p) *
10054 VEC(breakpoint_p) *tp_vec = 0;
10055 struct breakpoint *tp;
10057 ALL_TRACEPOINTS (tp)
10059 VEC_safe_push (breakpoint_p, tp_vec, tp);
10066 /* This help string is used for the break, hbreak, tbreak and thbreak commands.
10067 It is defined as a macro to prevent duplication.
10068 COMMAND should be a string constant containing the name of the command. */
10069 #define BREAK_ARGS_HELP(command) \
10070 command" [LOCATION] [thread THREADNUM] [if CONDITION]\n\
10071 LOCATION may be a line number, function name, or \"*\" and an address.\n\
10072 If a line number is specified, break at start of code for that line.\n\
10073 If a function is specified, break at start of code for that function.\n\
10074 If an address is specified, break at that exact address.\n\
10075 With no LOCATION, uses current execution address of selected stack frame.\n\
10076 This is useful for breaking on return to a stack frame.\n\
10078 THREADNUM is the number from \"info threads\".\n\
10079 CONDITION is a boolean expression.\n\
10081 Multiple breakpoints at one place are permitted, and useful if conditional.\n\
10083 Do \"help breakpoints\" for info on other commands dealing with breakpoints."
10085 /* List of subcommands for "catch". */
10086 static struct cmd_list_element *catch_cmdlist;
10088 /* List of subcommands for "tcatch". */
10089 static struct cmd_list_element *tcatch_cmdlist;
10091 /* Like add_cmd, but add the command to both the "catch" and "tcatch"
10092 lists, and pass some additional user data to the command function. */
10094 add_catch_command (char *name, char *docstring,
10095 void (*sfunc) (char *args, int from_tty,
10096 struct cmd_list_element *command),
10097 char **(*completer) (struct cmd_list_element *cmd,
10098 char *text, char *word),
10099 void *user_data_catch,
10100 void *user_data_tcatch)
10102 struct cmd_list_element *command;
10104 command = add_cmd (name, class_breakpoint, NULL, docstring,
10106 set_cmd_sfunc (command, sfunc);
10107 set_cmd_context (command, user_data_catch);
10108 set_cmd_completer (command, completer);
10110 command = add_cmd (name, class_breakpoint, NULL, docstring,
10112 set_cmd_sfunc (command, sfunc);
10113 set_cmd_context (command, user_data_tcatch);
10114 set_cmd_completer (command, completer);
10118 clear_syscall_counts (int pid)
10120 struct inferior *inf = find_inferior_pid (pid);
10122 inf->total_syscalls_count = 0;
10123 inf->any_syscall_count = 0;
10124 VEC_free (int, inf->syscalls_counts);
10128 _initialize_breakpoint (void)
10130 static struct cmd_list_element *breakpoint_set_cmdlist;
10131 static struct cmd_list_element *breakpoint_show_cmdlist;
10132 struct cmd_list_element *c;
10134 observer_attach_solib_unloaded (disable_breakpoints_in_unloaded_shlib);
10135 observer_attach_inferior_exit (clear_syscall_counts);
10136 observer_attach_memory_changed (invalidate_bp_value_on_memory_change);
10138 breakpoint_chain = 0;
10139 /* Don't bother to call set_breakpoint_count. $bpnum isn't useful
10140 before a breakpoint is set. */
10141 breakpoint_count = 0;
10143 tracepoint_count = 0;
10145 add_com ("ignore", class_breakpoint, ignore_command, _("\
10146 Set ignore-count of breakpoint number N to COUNT.\n\
10147 Usage is `ignore N COUNT'."));
10149 add_com_alias ("bc", "ignore", class_breakpoint, 1);
10151 add_com ("commands", class_breakpoint, commands_command, _("\
10152 Set commands to be executed when a breakpoint is hit.\n\
10153 Give breakpoint number as argument after \"commands\".\n\
10154 With no argument, the targeted breakpoint is the last one set.\n\
10155 The commands themselves follow starting on the next line.\n\
10156 Type a line containing \"end\" to indicate the end of them.\n\
10157 Give \"silent\" as the first line to make the breakpoint silent;\n\
10158 then no output is printed when it is hit, except what the commands print."));
10160 add_com ("condition", class_breakpoint, condition_command, _("\
10161 Specify breakpoint number N to break only if COND is true.\n\
10162 Usage is `condition N COND', where N is an integer and COND is an\n\
10163 expression to be evaluated whenever breakpoint N is reached."));
10165 c = add_com ("tbreak", class_breakpoint, tbreak_command, _("\
10166 Set a temporary breakpoint.\n\
10167 Like \"break\" except the breakpoint is only temporary,\n\
10168 so it will be deleted when hit. Equivalent to \"break\" followed\n\
10169 by using \"enable delete\" on the breakpoint number.\n\
10171 BREAK_ARGS_HELP ("tbreak")));
10172 set_cmd_completer (c, location_completer);
10174 c = add_com ("hbreak", class_breakpoint, hbreak_command, _("\
10175 Set a hardware assisted breakpoint.\n\
10176 Like \"break\" except the breakpoint requires hardware support,\n\
10177 some target hardware may not have this support.\n\
10179 BREAK_ARGS_HELP ("hbreak")));
10180 set_cmd_completer (c, location_completer);
10182 c = add_com ("thbreak", class_breakpoint, thbreak_command, _("\
10183 Set a temporary hardware assisted breakpoint.\n\
10184 Like \"hbreak\" except the breakpoint is only temporary,\n\
10185 so it will be deleted when hit.\n\
10187 BREAK_ARGS_HELP ("thbreak")));
10188 set_cmd_completer (c, location_completer);
10190 add_prefix_cmd ("enable", class_breakpoint, enable_command, _("\
10191 Enable some breakpoints.\n\
10192 Give breakpoint numbers (separated by spaces) as arguments.\n\
10193 With no subcommand, breakpoints are enabled until you command otherwise.\n\
10194 This is used to cancel the effect of the \"disable\" command.\n\
10195 With a subcommand you can enable temporarily."),
10196 &enablelist, "enable ", 1, &cmdlist);
10198 add_com ("ab", class_breakpoint, enable_command, _("\
10199 Enable some breakpoints.\n\
10200 Give breakpoint numbers (separated by spaces) as arguments.\n\
10201 With no subcommand, breakpoints are enabled until you command otherwise.\n\
10202 This is used to cancel the effect of the \"disable\" command.\n\
10203 With a subcommand you can enable temporarily."));
10205 add_com_alias ("en", "enable", class_breakpoint, 1);
10207 add_abbrev_prefix_cmd ("breakpoints", class_breakpoint, enable_command, _("\
10208 Enable some breakpoints.\n\
10209 Give breakpoint numbers (separated by spaces) as arguments.\n\
10210 This is used to cancel the effect of the \"disable\" command.\n\
10211 May be abbreviated to simply \"enable\".\n"),
10212 &enablebreaklist, "enable breakpoints ", 1, &enablelist);
10214 add_cmd ("once", no_class, enable_once_command, _("\
10215 Enable breakpoints for one hit. Give breakpoint numbers.\n\
10216 If a breakpoint is hit while enabled in this fashion, it becomes disabled."),
10219 add_cmd ("delete", no_class, enable_delete_command, _("\
10220 Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
10221 If a breakpoint is hit while enabled in this fashion, it is deleted."),
10224 add_cmd ("delete", no_class, enable_delete_command, _("\
10225 Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
10226 If a breakpoint is hit while enabled in this fashion, it is deleted."),
10229 add_cmd ("once", no_class, enable_once_command, _("\
10230 Enable breakpoints for one hit. Give breakpoint numbers.\n\
10231 If a breakpoint is hit while enabled in this fashion, it becomes disabled."),
10234 add_prefix_cmd ("disable", class_breakpoint, disable_command, _("\
10235 Disable some breakpoints.\n\
10236 Arguments are breakpoint numbers with spaces in between.\n\
10237 To disable all breakpoints, give no argument.\n\
10238 A disabled breakpoint is not forgotten, but has no effect until reenabled."),
10239 &disablelist, "disable ", 1, &cmdlist);
10240 add_com_alias ("dis", "disable", class_breakpoint, 1);
10241 add_com_alias ("disa", "disable", class_breakpoint, 1);
10243 add_com ("sb", class_breakpoint, disable_command, _("\
10244 Disable some breakpoints.\n\
10245 Arguments are breakpoint numbers with spaces in between.\n\
10246 To disable all breakpoints, give no argument.\n\
10247 A disabled breakpoint is not forgotten, but has no effect until reenabled."));
10249 add_cmd ("breakpoints", class_alias, disable_command, _("\
10250 Disable some breakpoints.\n\
10251 Arguments are breakpoint numbers with spaces in between.\n\
10252 To disable all breakpoints, give no argument.\n\
10253 A disabled breakpoint is not forgotten, but has no effect until reenabled.\n\
10254 This command may be abbreviated \"disable\"."),
10257 add_prefix_cmd ("delete", class_breakpoint, delete_command, _("\
10258 Delete some breakpoints or auto-display expressions.\n\
10259 Arguments are breakpoint numbers with spaces in between.\n\
10260 To delete all breakpoints, give no argument.\n\
10262 Also a prefix command for deletion of other GDB objects.\n\
10263 The \"unset\" command is also an alias for \"delete\"."),
10264 &deletelist, "delete ", 1, &cmdlist);
10265 add_com_alias ("d", "delete", class_breakpoint, 1);
10266 add_com_alias ("del", "delete", class_breakpoint, 1);
10268 add_com ("db", class_breakpoint, delete_command, _("\
10269 Delete some breakpoints.\n\
10270 Arguments are breakpoint numbers with spaces in between.\n\
10271 To delete all breakpoints, give no argument.\n"));
10273 add_cmd ("breakpoints", class_alias, delete_command, _("\
10274 Delete some breakpoints or auto-display expressions.\n\
10275 Arguments are breakpoint numbers with spaces in between.\n\
10276 To delete all breakpoints, give no argument.\n\
10277 This command may be abbreviated \"delete\"."),
10280 add_com ("clear", class_breakpoint, clear_command, _("\
10281 Clear breakpoint at specified line or function.\n\
10282 Argument may be line number, function name, or \"*\" and an address.\n\
10283 If line number is specified, all breakpoints in that line are cleared.\n\
10284 If function is specified, breakpoints at beginning of function are cleared.\n\
10285 If an address is specified, breakpoints at that address are cleared.\n\
10287 With no argument, clears all breakpoints in the line that the selected frame\n\
10288 is executing in.\n\
10290 See also the \"delete\" command which clears breakpoints by number."));
10292 c = add_com ("break", class_breakpoint, break_command, _("\
10293 Set breakpoint at specified line or function.\n"
10294 BREAK_ARGS_HELP ("break")));
10295 set_cmd_completer (c, location_completer);
10297 add_com_alias ("b", "break", class_run, 1);
10298 add_com_alias ("br", "break", class_run, 1);
10299 add_com_alias ("bre", "break", class_run, 1);
10300 add_com_alias ("brea", "break", class_run, 1);
10303 add_com_alias ("ba", "break", class_breakpoint, 1);
10307 add_abbrev_prefix_cmd ("stop", class_breakpoint, stop_command, _("\
10308 Break in function/address or break at a line in the current file."),
10309 &stoplist, "stop ", 1, &cmdlist);
10310 add_cmd ("in", class_breakpoint, stopin_command,
10311 _("Break in function or address."), &stoplist);
10312 add_cmd ("at", class_breakpoint, stopat_command,
10313 _("Break at a line in the current file."), &stoplist);
10314 add_com ("status", class_info, breakpoints_info, _("\
10315 Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
10316 The \"Type\" column indicates one of:\n\
10317 \tbreakpoint - normal breakpoint\n\
10318 \twatchpoint - watchpoint\n\
10319 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
10320 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
10321 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
10322 address and file/line number respectively.\n\
10324 Convenience variable \"$_\" and default examine address for \"x\"\n\
10325 are set to the address of the last breakpoint listed unless the command\n\
10326 is prefixed with \"server \".\n\n\
10327 Convenience variable \"$bpnum\" contains the number of the last\n\
10328 breakpoint set."));
10331 add_info ("breakpoints", breakpoints_info, _("\
10332 Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
10333 The \"Type\" column indicates one of:\n\
10334 \tbreakpoint - normal breakpoint\n\
10335 \twatchpoint - watchpoint\n\
10336 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
10337 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
10338 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
10339 address and file/line number respectively.\n\
10341 Convenience variable \"$_\" and default examine address for \"x\"\n\
10342 are set to the address of the last breakpoint listed unless the command\n\
10343 is prefixed with \"server \".\n\n\
10344 Convenience variable \"$bpnum\" contains the number of the last\n\
10345 breakpoint set."));
10347 add_info_alias ("b", "breakpoints", 1);
10350 add_com ("lb", class_breakpoint, breakpoints_info, _("\
10351 Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
10352 The \"Type\" column indicates one of:\n\
10353 \tbreakpoint - normal breakpoint\n\
10354 \twatchpoint - watchpoint\n\
10355 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
10356 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
10357 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
10358 address and file/line number respectively.\n\
10360 Convenience variable \"$_\" and default examine address for \"x\"\n\
10361 are set to the address of the last breakpoint listed unless the command\n\
10362 is prefixed with \"server \".\n\n\
10363 Convenience variable \"$bpnum\" contains the number of the last\n\
10364 breakpoint set."));
10366 add_cmd ("breakpoints", class_maintenance, maintenance_info_breakpoints, _("\
10367 Status of all breakpoints, or breakpoint number NUMBER.\n\
10368 The \"Type\" column indicates one of:\n\
10369 \tbreakpoint - normal breakpoint\n\
10370 \twatchpoint - watchpoint\n\
10371 \tlongjmp - internal breakpoint used to step through longjmp()\n\
10372 \tlongjmp resume - internal breakpoint at the target of longjmp()\n\
10373 \tuntil - internal breakpoint used by the \"until\" command\n\
10374 \tfinish - internal breakpoint used by the \"finish\" command\n\
10375 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
10376 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
10377 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
10378 address and file/line number respectively.\n\
10380 Convenience variable \"$_\" and default examine address for \"x\"\n\
10381 are set to the address of the last breakpoint listed unless the command\n\
10382 is prefixed with \"server \".\n\n\
10383 Convenience variable \"$bpnum\" contains the number of the last\n\
10385 &maintenanceinfolist);
10387 add_prefix_cmd ("catch", class_breakpoint, catch_command, _("\
10388 Set catchpoints to catch events."),
10389 &catch_cmdlist, "catch ",
10390 0/*allow-unknown*/, &cmdlist);
10392 add_prefix_cmd ("tcatch", class_breakpoint, tcatch_command, _("\
10393 Set temporary catchpoints to catch events."),
10394 &tcatch_cmdlist, "tcatch ",
10395 0/*allow-unknown*/, &cmdlist);
10397 /* Add catch and tcatch sub-commands. */
10398 add_catch_command ("catch", _("\
10399 Catch an exception, when caught.\n\
10400 With an argument, catch only exceptions with the given name."),
10401 catch_catch_command,
10405 add_catch_command ("throw", _("\
10406 Catch an exception, when thrown.\n\
10407 With an argument, catch only exceptions with the given name."),
10408 catch_throw_command,
10412 add_catch_command ("fork", _("Catch calls to fork."),
10413 catch_fork_command_1,
10415 (void *) (uintptr_t) catch_fork_permanent,
10416 (void *) (uintptr_t) catch_fork_temporary);
10417 add_catch_command ("vfork", _("Catch calls to vfork."),
10418 catch_fork_command_1,
10420 (void *) (uintptr_t) catch_vfork_permanent,
10421 (void *) (uintptr_t) catch_vfork_temporary);
10422 add_catch_command ("exec", _("Catch calls to exec."),
10423 catch_exec_command_1,
10427 add_catch_command ("syscall", _("\
10428 Catch system calls by their names and/or numbers.\n\
10429 Arguments say which system calls to catch. If no arguments\n\
10430 are given, every system call will be caught.\n\
10431 Arguments, if given, should be one or more system call names\n\
10432 (if your system supports that), or system call numbers."),
10433 catch_syscall_command_1,
10434 catch_syscall_completer,
10437 add_catch_command ("exception", _("\
10438 Catch Ada exceptions, when raised.\n\
10439 With an argument, catch only exceptions with the given name."),
10440 catch_ada_exception_command,
10444 add_catch_command ("assert", _("\
10445 Catch failed Ada assertions, when raised.\n\
10446 With an argument, catch only exceptions with the given name."),
10447 catch_assert_command,
10452 c = add_com ("watch", class_breakpoint, watch_command, _("\
10453 Set a watchpoint for an expression.\n\
10454 A watchpoint stops execution of your program whenever the value of\n\
10455 an expression changes."));
10456 set_cmd_completer (c, expression_completer);
10458 c = add_com ("rwatch", class_breakpoint, rwatch_command, _("\
10459 Set a read watchpoint for an expression.\n\
10460 A watchpoint stops execution of your program whenever the value of\n\
10461 an expression is read."));
10462 set_cmd_completer (c, expression_completer);
10464 c = add_com ("awatch", class_breakpoint, awatch_command, _("\
10465 Set a watchpoint for an expression.\n\
10466 A watchpoint stops execution of your program whenever the value of\n\
10467 an expression is either read or written."));
10468 set_cmd_completer (c, expression_completer);
10470 add_info ("watchpoints", breakpoints_info,
10471 _("Synonym for ``info breakpoints''."));
10474 /* XXX: cagney/2005-02-23: This should be a boolean, and should
10475 respond to changes - contrary to the description. */
10476 add_setshow_zinteger_cmd ("can-use-hw-watchpoints", class_support,
10477 &can_use_hw_watchpoints, _("\
10478 Set debugger's willingness to use watchpoint hardware."), _("\
10479 Show debugger's willingness to use watchpoint hardware."), _("\
10480 If zero, gdb will not use hardware for new watchpoints, even if\n\
10481 such is available. (However, any hardware watchpoints that were\n\
10482 created before setting this to nonzero, will continue to use watchpoint\n\
10485 show_can_use_hw_watchpoints,
10486 &setlist, &showlist);
10488 can_use_hw_watchpoints = 1;
10490 /* Tracepoint manipulation commands. */
10492 c = add_com ("trace", class_breakpoint, trace_command, _("\
10493 Set a tracepoint at specified line or function.\n\
10495 BREAK_ARGS_HELP ("trace") "\n\
10496 Do \"help tracepoints\" for info on other tracepoint commands."));
10497 set_cmd_completer (c, location_completer);
10499 add_com_alias ("tp", "trace", class_alias, 0);
10500 add_com_alias ("tr", "trace", class_alias, 1);
10501 add_com_alias ("tra", "trace", class_alias, 1);
10502 add_com_alias ("trac", "trace", class_alias, 1);
10504 add_info ("tracepoints", tracepoints_info, _("\
10505 Status of tracepoints, or tracepoint number NUMBER.\n\
10506 Convenience variable \"$tpnum\" contains the number of the\n\
10507 last tracepoint set."));
10509 add_info_alias ("tp", "tracepoints", 1);
10511 add_cmd ("tracepoints", class_trace, delete_trace_command, _("\
10512 Delete specified tracepoints.\n\
10513 Arguments are tracepoint numbers, separated by spaces.\n\
10514 No argument means delete all tracepoints."),
10517 c = add_cmd ("tracepoints", class_trace, disable_trace_command, _("\
10518 Disable specified tracepoints.\n\
10519 Arguments are tracepoint numbers, separated by spaces.\n\
10520 No argument means disable all tracepoints."),
10522 deprecate_cmd (c, "disable");
10524 c = add_cmd ("tracepoints", class_trace, enable_trace_command, _("\
10525 Enable specified tracepoints.\n\
10526 Arguments are tracepoint numbers, separated by spaces.\n\
10527 No argument means enable all tracepoints."),
10529 deprecate_cmd (c, "enable");
10531 add_com ("passcount", class_trace, trace_pass_command, _("\
10532 Set the passcount for a tracepoint.\n\
10533 The trace will end when the tracepoint has been passed 'count' times.\n\
10534 Usage: passcount COUNT TPNUM, where TPNUM may also be \"all\";\n\
10535 if TPNUM is omitted, passcount refers to the last tracepoint defined."));
10537 c = add_com ("save-tracepoints", class_trace, tracepoint_save_command, _("\
10538 Save current tracepoint definitions as a script.\n\
10539 Use the 'source' command in another debug session to restore them."));
10540 set_cmd_completer (c, filename_completer);
10542 add_prefix_cmd ("breakpoint", class_maintenance, set_breakpoint_cmd, _("\
10543 Breakpoint specific settings\n\
10544 Configure various breakpoint-specific variables such as\n\
10545 pending breakpoint behavior"),
10546 &breakpoint_set_cmdlist, "set breakpoint ",
10547 0/*allow-unknown*/, &setlist);
10548 add_prefix_cmd ("breakpoint", class_maintenance, show_breakpoint_cmd, _("\
10549 Breakpoint specific settings\n\
10550 Configure various breakpoint-specific variables such as\n\
10551 pending breakpoint behavior"),
10552 &breakpoint_show_cmdlist, "show breakpoint ",
10553 0/*allow-unknown*/, &showlist);
10555 add_setshow_auto_boolean_cmd ("pending", no_class,
10556 &pending_break_support, _("\
10557 Set debugger's behavior regarding pending breakpoints."), _("\
10558 Show debugger's behavior regarding pending breakpoints."), _("\
10559 If on, an unrecognized breakpoint location will cause gdb to create a\n\
10560 pending breakpoint. If off, an unrecognized breakpoint location results in\n\
10561 an error. If auto, an unrecognized breakpoint location results in a\n\
10562 user-query to see if a pending breakpoint should be created."),
10564 show_pending_break_support,
10565 &breakpoint_set_cmdlist,
10566 &breakpoint_show_cmdlist);
10568 pending_break_support = AUTO_BOOLEAN_AUTO;
10570 add_setshow_boolean_cmd ("auto-hw", no_class,
10571 &automatic_hardware_breakpoints, _("\
10572 Set automatic usage of hardware breakpoints."), _("\
10573 Show automatic usage of hardware breakpoints."), _("\
10574 If set, the debugger will automatically use hardware breakpoints for\n\
10575 breakpoints set with \"break\" but falling in read-only memory. If not set,\n\
10576 a warning will be emitted for such breakpoints."),
10578 show_automatic_hardware_breakpoints,
10579 &breakpoint_set_cmdlist,
10580 &breakpoint_show_cmdlist);
10582 add_setshow_enum_cmd ("always-inserted", class_support,
10583 always_inserted_enums, &always_inserted_mode, _("\
10584 Set mode for inserting breakpoints."), _("\
10585 Show mode for inserting breakpoints."), _("\
10586 When this mode is off, breakpoints are inserted in inferior when it is\n\
10587 resumed, and removed when execution stops. When this mode is on,\n\
10588 breakpoints are inserted immediately and removed only when the user\n\
10589 deletes the breakpoint. When this mode is auto (which is the default),\n\
10590 the behaviour depends on the non-stop setting (see help set non-stop).\n\
10591 In this case, if gdb is controlling the inferior in non-stop mode, gdb\n\
10592 behaves as if always-inserted mode is on; if gdb is controlling the\n\
10593 inferior in all-stop mode, gdb behaves as if always-inserted mode is off."),
10595 &show_always_inserted_mode,
10596 &breakpoint_set_cmdlist,
10597 &breakpoint_show_cmdlist);
10599 automatic_hardware_breakpoints = 1;
10601 observer_attach_about_to_proceed (breakpoint_about_to_proceed);