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 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/>. */
27 #include "breakpoint.h"
29 #include "expression.h"
35 #include "gdbthread.h"
38 #include "gdb_string.h"
45 #include "completer.h"
48 #include "cli/cli-script.h"
49 #include "gdb_assert.h"
54 #include "exceptions.h"
60 #include "gdb-events.h"
61 #include "mi/mi-common.h"
63 #include "gdb_stdint.h"
65 /* Prototypes for local functions. */
67 static void until_break_command_continuation (struct continuation_arg
*arg
,
70 static void catch_command_1 (char *, int, int);
72 static void enable_delete_command (char *, int);
74 static void enable_delete_breakpoint (struct breakpoint
*);
76 static void enable_once_command (char *, int);
78 static void enable_once_breakpoint (struct breakpoint
*);
80 static void disable_command (char *, int);
82 static void enable_command (char *, int);
84 static void map_breakpoint_numbers (char *, void (*)(struct breakpoint
*));
86 static void ignore_command (char *, int);
88 static int breakpoint_re_set_one (void *);
90 static void clear_command (char *, int);
92 static void catch_command (char *, int);
94 static void watch_command (char *, int);
96 static int can_use_hardware_watchpoint (struct value
*);
98 static void break_command_1 (char *, int, int);
100 static void mention (struct breakpoint
*);
102 struct breakpoint
*set_raw_breakpoint (struct symtab_and_line
, enum bptype
);
104 static void check_duplicates (struct breakpoint
*);
106 static void breakpoint_adjustment_warning (CORE_ADDR
, CORE_ADDR
, int, int);
108 static CORE_ADDR
adjust_breakpoint_address (CORE_ADDR bpaddr
,
111 static void describe_other_breakpoints (CORE_ADDR
, asection
*, int);
113 static void breakpoints_info (char *, int);
115 static void breakpoint_1 (int, int);
117 static bpstat
bpstat_alloc (const struct bp_location
*, bpstat
);
119 static int breakpoint_cond_eval (void *);
121 static void cleanup_executing_breakpoints (void *);
123 static void commands_command (char *, int);
125 static void condition_command (char *, int);
127 static int get_number_trailer (char **, int);
129 void set_breakpoint_count (int);
138 static int remove_breakpoint (struct bp_location
*, insertion_state_t
);
140 static enum print_stop_action
print_it_typical (bpstat
);
142 static enum print_stop_action
print_bp_stop_message (bpstat bs
);
146 enum exception_event_kind kind
;
149 args_for_catchpoint_enable
;
151 static int watchpoint_check (void *);
153 static void maintenance_info_breakpoints (char *, int);
155 static void create_longjmp_breakpoint (char *);
157 static void create_overlay_event_breakpoint (char *);
159 static int hw_breakpoint_used_count (void);
161 static int hw_watchpoint_used_count (enum bptype
, int *);
163 static void hbreak_command (char *, int);
165 static void thbreak_command (char *, int);
167 static void watch_command_1 (char *, int, int);
169 static void rwatch_command (char *, int);
171 static void awatch_command (char *, int);
173 static void do_enable_breakpoint (struct breakpoint
*, enum bpdisp
);
175 static void create_fork_vfork_event_catchpoint (int tempflag
,
177 enum bptype bp_kind
);
179 static void stop_command (char *arg
, int from_tty
);
181 static void stopin_command (char *arg
, int from_tty
);
183 static void stopat_command (char *arg
, int from_tty
);
185 static char *ep_find_event_name_end (char *arg
);
187 static char *ep_parse_optional_if_clause (char **arg
);
189 static char *ep_parse_optional_filename (char **arg
);
191 static void create_exception_catchpoint (int tempflag
, char *cond_string
,
192 enum exception_event_kind ex_event
,
193 struct symtab_and_line
*sal
);
195 static void catch_exception_command_1 (enum exception_event_kind ex_event
,
196 char *arg
, int tempflag
, int from_tty
);
198 static void tcatch_command (char *arg
, int from_tty
);
200 static void ep_skip_leading_whitespace (char **s
);
202 static int single_step_breakpoint_inserted_here_p (CORE_ADDR pc
);
204 static void free_bp_location (struct bp_location
*loc
);
206 static void mark_breakpoints_out (void);
208 static struct bp_location
*
209 allocate_bp_location (struct breakpoint
*bpt
, enum bptype bp_type
);
211 static void update_global_location_list (void);
213 static void update_global_location_list_nothrow (void);
215 static int is_hardware_watchpoint (struct breakpoint
*bpt
);
217 static void insert_breakpoint_locations (void);
220 bpdisp_text (enum bpdisp disp
)
222 /* NOTE: the following values are a part of MI protocol and represent
223 values of 'disp' field returned when inferior stops at a breakpoint. */
224 static char *bpdisps
[] = {"del", "dstp", "dis", "keep"};
225 return bpdisps
[(int) disp
];
228 /* Prototypes for exported functions. */
229 /* If FALSE, gdb will not use hardware support for watchpoints, even
230 if such is available. */
231 static int can_use_hw_watchpoints
;
234 show_can_use_hw_watchpoints (struct ui_file
*file
, int from_tty
,
235 struct cmd_list_element
*c
,
238 fprintf_filtered (file
, _("\
239 Debugger's willingness to use watchpoint hardware is %s.\n"),
243 /* If AUTO_BOOLEAN_FALSE, gdb will not attempt to create pending breakpoints.
244 If AUTO_BOOLEAN_TRUE, gdb will automatically create pending breakpoints
245 for unrecognized breakpoint locations.
246 If AUTO_BOOLEAN_AUTO, gdb will query when breakpoints are unrecognized. */
247 static enum auto_boolean pending_break_support
;
249 show_pending_break_support (struct ui_file
*file
, int from_tty
,
250 struct cmd_list_element
*c
,
253 fprintf_filtered (file
, _("\
254 Debugger's behavior regarding pending breakpoints is %s.\n"),
258 /* If 1, gdb will automatically use hardware breakpoints for breakpoints
259 set with "break" but falling in read-only memory.
260 If 0, gdb will warn about such breakpoints, but won't automatically
261 use hardware breakpoints. */
262 static int automatic_hardware_breakpoints
;
264 show_automatic_hardware_breakpoints (struct ui_file
*file
, int from_tty
,
265 struct cmd_list_element
*c
,
268 fprintf_filtered (file
, _("\
269 Automatic usage of hardware breakpoints is %s.\n"),
273 /* If 1, gdb will keep breakpoints inserted even as inferior is stopped,
274 and immediately insert any new breakpoints. If 0, gdb will insert
275 breakpoints into inferior only when resuming it, and will remove
276 breakpoints upon stop. */
277 static int always_inserted_mode
= 0;
279 show_always_inserted_mode (struct ui_file
*file
, int from_tty
,
280 struct cmd_list_element
*c
, const char *value
)
282 fprintf_filtered (file
, _("Always inserted breakpoint mode is %s.\n"), value
);
286 void _initialize_breakpoint (void);
288 extern int addressprint
; /* Print machine addresses? */
290 /* Are we executing breakpoint commands? */
291 static int executing_breakpoint_commands
;
293 /* Are overlay event breakpoints enabled? */
294 static int overlay_events_enabled
;
296 /* Walk the following statement or block through all breakpoints.
297 ALL_BREAKPOINTS_SAFE does so even if the statment deletes the current
300 #define ALL_BREAKPOINTS(B) for (B = breakpoint_chain; B; B = B->next)
302 #define ALL_BREAKPOINTS_SAFE(B,TMP) \
303 for (B = breakpoint_chain; \
304 B ? (TMP=B->next, 1): 0; \
307 /* Similar iterators for the low-level breakpoints. */
309 #define ALL_BP_LOCATIONS(B) for (B = bp_location_chain; B; B = B->global_next)
311 #define ALL_BP_LOCATIONS_SAFE(B,TMP) \
312 for (B = bp_location_chain; \
313 B ? (TMP=B->global_next, 1): 0; \
316 /* True if breakpoint hit counts should be displayed in breakpoint info. */
318 int show_breakpoint_hit_counts
= 1;
320 /* Chains of all breakpoints defined. */
322 struct breakpoint
*breakpoint_chain
;
324 struct bp_location
*bp_location_chain
;
326 /* Number of last breakpoint made. */
328 int breakpoint_count
;
330 /* Pointer to current exception event record */
331 static struct exception_event_record
*current_exception_event
;
333 /* This function returns a pointer to the string representation of the
334 pathname of the dynamically-linked library that has just been
337 This function must be used only when SOLIB_HAVE_LOAD_EVENT is TRUE,
338 or undefined results are guaranteed.
340 This string's contents are only valid immediately after the
341 inferior has stopped in the dynamic linker hook, and becomes
342 invalid as soon as the inferior is continued. Clients should make
343 a copy of this string if they wish to continue the inferior and
344 then access the string. */
346 #ifndef SOLIB_LOADED_LIBRARY_PATHNAME
347 #define SOLIB_LOADED_LIBRARY_PATHNAME(pid) ""
350 /* This function returns a pointer to the string representation of the
351 pathname of the dynamically-linked library that has just been
354 This function must be used only when SOLIB_HAVE_UNLOAD_EVENT is
355 TRUE, or undefined results are guaranteed.
357 This string's contents are only valid immediately after the
358 inferior has stopped in the dynamic linker hook, and becomes
359 invalid as soon as the inferior is continued. Clients should make
360 a copy of this string if they wish to continue the inferior and
361 then access the string. */
363 #ifndef SOLIB_UNLOADED_LIBRARY_PATHNAME
364 #define SOLIB_UNLOADED_LIBRARY_PATHNAME(pid) ""
367 /* This function is called by the "catch load" command. It allows the
368 debugger to be notified by the dynamic linker when a specified
369 library file (or any library file, if filename is NULL) is loaded. */
371 #ifndef SOLIB_CREATE_CATCH_LOAD_HOOK
372 #define SOLIB_CREATE_CATCH_LOAD_HOOK(pid,tempflag,filename,cond_string) \
373 error (_("catch of library loads not yet implemented on this platform"))
376 /* This function is called by the "catch unload" command. It allows
377 the debugger to be notified by the dynamic linker when a specified
378 library file (or any library file, if filename is NULL) is
381 #ifndef SOLIB_CREATE_CATCH_UNLOAD_HOOK
382 #define SOLIB_CREATE_CATCH_UNLOAD_HOOK(pid, tempflag, filename, cond_string) \
383 error (_("catch of library unloads not yet implemented on this platform"))
386 /* Return whether a breakpoint is an active enabled breakpoint. */
388 breakpoint_enabled (struct breakpoint
*b
)
390 return (b
->enable_state
== bp_enabled
);
393 /* Set breakpoint count to NUM. */
396 set_breakpoint_count (int num
)
398 breakpoint_count
= num
;
399 set_internalvar (lookup_internalvar ("bpnum"),
400 value_from_longest (builtin_type_int
, (LONGEST
) num
));
403 /* Used in run_command to zero the hit count when a new run starts. */
406 clear_breakpoint_hit_counts (void)
408 struct breakpoint
*b
;
414 /* Default address, symtab and line to put a breakpoint at
415 for "break" command with no arg.
416 if default_breakpoint_valid is zero, the other three are
417 not valid, and "break" with no arg is an error.
419 This set by print_stack_frame, which calls set_default_breakpoint. */
421 int default_breakpoint_valid
;
422 CORE_ADDR default_breakpoint_address
;
423 struct symtab
*default_breakpoint_symtab
;
424 int default_breakpoint_line
;
426 /* *PP is a string denoting a breakpoint. Get the number of the breakpoint.
427 Advance *PP after the string and any trailing whitespace.
429 Currently the string can either be a number or "$" followed by the name
430 of a convenience variable. Making it an expression wouldn't work well
431 for map_breakpoint_numbers (e.g. "4 + 5 + 6").
433 If the string is a NULL pointer, that denotes the last breakpoint.
435 TRAILER is a character which can be found after the number; most
436 commonly this is `-'. If you don't want a trailer, use \0. */
438 get_number_trailer (char **pp
, int trailer
)
440 int retval
= 0; /* default */
444 /* Empty line means refer to the last breakpoint. */
445 return breakpoint_count
;
448 /* Make a copy of the name, so we can null-terminate it
449 to pass to lookup_internalvar(). */
454 while (isalnum (*p
) || *p
== '_')
456 varname
= (char *) alloca (p
- start
+ 1);
457 strncpy (varname
, start
, p
- start
);
458 varname
[p
- start
] = '\0';
459 val
= value_of_internalvar (lookup_internalvar (varname
));
460 if (TYPE_CODE (value_type (val
)) == TYPE_CODE_INT
)
461 retval
= (int) value_as_long (val
);
464 printf_filtered (_("Convenience variable must have integer value.\n"));
472 while (*p
>= '0' && *p
<= '9')
475 /* There is no number here. (e.g. "cond a == b"). */
477 /* Skip non-numeric token */
478 while (*p
&& !isspace((int) *p
))
480 /* Return zero, which caller must interpret as error. */
486 if (!(isspace (*p
) || *p
== '\0' || *p
== trailer
))
488 /* Trailing junk: return 0 and let caller print error msg. */
489 while (!(isspace (*p
) || *p
== '\0' || *p
== trailer
))
500 /* Like get_number_trailer, but don't allow a trailer. */
502 get_number (char **pp
)
504 return get_number_trailer (pp
, '\0');
507 /* Parse a number or a range.
508 * A number will be of the form handled by get_number.
509 * A range will be of the form <number1> - <number2>, and
510 * will represent all the integers between number1 and number2,
513 * While processing a range, this fuction is called iteratively;
514 * At each call it will return the next value in the range.
516 * At the beginning of parsing a range, the char pointer PP will
517 * be advanced past <number1> and left pointing at the '-' token.
518 * Subsequent calls will not advance the pointer until the range
519 * is completed. The call that completes the range will advance
520 * pointer PP past <number2>.
524 get_number_or_range (char **pp
)
526 static int last_retval
, end_value
;
527 static char *end_ptr
;
528 static int in_range
= 0;
532 /* Default case: pp is pointing either to a solo number,
533 or to the first number of a range. */
534 last_retval
= get_number_trailer (pp
, '-');
539 /* This is the start of a range (<number1> - <number2>).
540 Skip the '-', parse and remember the second number,
541 and also remember the end of the final token. */
545 while (isspace ((int) *end_ptr
))
546 end_ptr
++; /* skip white space */
547 end_value
= get_number (temp
);
548 if (end_value
< last_retval
)
550 error (_("inverted range"));
552 else if (end_value
== last_retval
)
554 /* degenerate range (number1 == number2). Advance the
555 token pointer so that the range will be treated as a
564 error (_("negative value"));
567 /* pp points to the '-' that betokens a range. All
568 number-parsing has already been done. Return the next
569 integer value (one greater than the saved previous value).
570 Do not advance the token pointer 'pp' until the end of range
573 if (++last_retval
== end_value
)
575 /* End of range reached; advance token pointer. */
585 /* condition N EXP -- set break condition of breakpoint N to EXP. */
588 condition_command (char *arg
, int from_tty
)
590 struct breakpoint
*b
;
595 error_no_arg (_("breakpoint number"));
598 bnum
= get_number (&p
);
600 error (_("Bad breakpoint argument: '%s'"), arg
);
603 if (b
->number
== bnum
)
605 struct bp_location
*loc
= b
->loc
;
606 for (; loc
; loc
= loc
->next
)
614 if (b
->cond_string
!= NULL
)
615 xfree (b
->cond_string
);
619 b
->cond_string
= NULL
;
621 printf_filtered (_("Breakpoint %d now unconditional.\n"), bnum
);
626 /* I don't know if it matters whether this is the string the user
627 typed in or the decompiled expression. */
628 b
->cond_string
= savestring (arg
, strlen (arg
));
629 b
->condition_not_parsed
= 0;
630 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
633 loc
->cond
= parse_exp_1 (&arg
, block_for_pc (loc
->address
), 0);
635 error (_("Junk at end of expression"));
638 breakpoints_changed ();
639 breakpoint_modify_event (b
->number
);
643 error (_("No breakpoint number %d."), bnum
);
647 commands_command (char *arg
, int from_tty
)
649 struct breakpoint
*b
;
652 struct command_line
*l
;
654 /* If we allowed this, we would have problems with when to
655 free the storage, if we change the commands currently
658 if (executing_breakpoint_commands
)
659 error (_("Can't use the \"commands\" command among a breakpoint's commands."));
662 bnum
= get_number (&p
);
665 error (_("Unexpected extra arguments following breakpoint number."));
668 if (b
->number
== bnum
)
670 char *tmpbuf
= xstrprintf ("Type commands for when breakpoint %d is hit, one per line.",
672 struct cleanup
*cleanups
= make_cleanup (xfree
, tmpbuf
);
673 l
= read_command_lines (tmpbuf
, from_tty
);
674 do_cleanups (cleanups
);
675 free_command_lines (&b
->commands
);
677 breakpoints_changed ();
678 breakpoint_modify_event (b
->number
);
681 error (_("No breakpoint number %d."), bnum
);
684 /* Like commands_command, but instead of reading the commands from
685 input stream, takes them from an already parsed command structure.
687 This is used by cli-script.c to DTRT with breakpoint commands
688 that are part of if and while bodies. */
689 enum command_control_type
690 commands_from_control_command (char *arg
, struct command_line
*cmd
)
692 struct breakpoint
*b
;
696 /* If we allowed this, we would have problems with when to
697 free the storage, if we change the commands currently
700 if (executing_breakpoint_commands
)
701 error (_("Can't use the \"commands\" command among a breakpoint's commands."));
703 /* An empty string for the breakpoint number means the last
704 breakpoint, but get_number expects a NULL pointer. */
709 bnum
= get_number (&p
);
712 error (_("Unexpected extra arguments following breakpoint number."));
715 if (b
->number
== bnum
)
717 free_command_lines (&b
->commands
);
718 if (cmd
->body_count
!= 1)
719 error (_("Invalid \"commands\" block structure."));
720 /* We need to copy the commands because if/while will free the
721 list after it finishes execution. */
722 b
->commands
= copy_command_lines (cmd
->body_list
[0]);
723 breakpoints_changed ();
724 breakpoint_modify_event (b
->number
);
725 return simple_control
;
727 error (_("No breakpoint number %d."), bnum
);
730 /* Update BUF, which is LEN bytes read from the target address MEMADDR,
731 by replacing any memory breakpoints with their shadowed contents. */
734 breakpoint_restore_shadows (gdb_byte
*buf
, ULONGEST memaddr
, LONGEST len
)
736 struct bp_location
*b
;
737 CORE_ADDR bp_addr
= 0;
743 if (b
->owner
->type
== bp_none
)
744 warning (_("reading through apparently deleted breakpoint #%d?"),
747 if (b
->loc_type
!= bp_loc_software_breakpoint
)
751 /* Addresses and length of the part of the breakpoint that
753 bp_addr
= b
->target_info
.placed_address
;
754 bp_size
= b
->target_info
.shadow_len
;
756 /* bp isn't valid, or doesn't shadow memory. */
759 if (bp_addr
+ bp_size
<= memaddr
)
760 /* The breakpoint is entirely before the chunk of memory we
764 if (bp_addr
>= memaddr
+ len
)
765 /* The breakpoint is entirely after the chunk of memory we are
769 /* Offset within shadow_contents. */
770 if (bp_addr
< memaddr
)
772 /* Only copy the second part of the breakpoint. */
773 bp_size
-= memaddr
- bp_addr
;
774 bptoffset
= memaddr
- bp_addr
;
778 if (bp_addr
+ bp_size
> memaddr
+ len
)
780 /* Only copy the first part of the breakpoint. */
781 bp_size
-= (bp_addr
+ bp_size
) - (memaddr
+ len
);
784 memcpy (buf
+ bp_addr
- memaddr
,
785 b
->target_info
.shadow_contents
+ bptoffset
, bp_size
);
790 /* A wrapper function for inserting catchpoints. */
792 insert_catchpoint (struct ui_out
*uo
, void *args
)
794 struct breakpoint
*b
= (struct breakpoint
*) args
;
800 target_insert_fork_catchpoint (PIDGET (inferior_ptid
));
803 target_insert_vfork_catchpoint (PIDGET (inferior_ptid
));
806 target_insert_exec_catchpoint (PIDGET (inferior_ptid
));
809 internal_error (__FILE__
, __LINE__
, _("unknown breakpoint type"));
815 is_hardware_watchpoint (struct breakpoint
*bpt
)
817 return (bpt
->type
== bp_hardware_watchpoint
818 || bpt
->type
== bp_read_watchpoint
819 || bpt
->type
== bp_access_watchpoint
);
822 /* Find the current value of a watchpoint on EXP. Return the value in
823 *VALP and *RESULTP and the chain of intermediate and final values
824 in *VAL_CHAIN. RESULTP and VAL_CHAIN may be NULL if the caller does
827 If an error occurs while evaluating the expression, *RESULTP will
828 be set to NULL. *RESULTP may be a lazy value, if the result could
829 not be read from memory. It is used to determine whether a value
830 is user-specified (we should watch the whole value) or intermediate
831 (we should watch only the bit used to locate the final value).
833 If the final value, or any intermediate value, could not be read
834 from memory, *VALP will be set to NULL. *VAL_CHAIN will still be
835 set to any referenced values. *VALP will never be a lazy value.
836 This is the value which we store in struct breakpoint.
838 If VAL_CHAIN is non-NULL, *VAL_CHAIN will be released from the
839 value chain. The caller must free the values individually. If
840 VAL_CHAIN is NULL, all generated values will be left on the value
844 fetch_watchpoint_value (struct expression
*exp
, struct value
**valp
,
845 struct value
**resultp
, struct value
**val_chain
)
847 struct value
*mark
, *new_mark
, *result
;
855 /* Evaluate the expression. */
856 mark
= value_mark ();
858 gdb_evaluate_expression (exp
, &result
);
859 new_mark
= value_mark ();
860 if (mark
== new_mark
)
865 /* Make sure it's not lazy, so that after the target stops again we
866 have a non-lazy previous value to compare with. */
868 && (!value_lazy (result
) || gdb_value_fetch_lazy (result
)))
873 /* Return the chain of intermediate values. We use this to
874 decide which addresses to watch. */
875 *val_chain
= new_mark
;
876 value_release_to_mark (mark
);
880 /* Assuming that B is a hardware watchpoint:
881 - Reparse watchpoint expression, is REPARSE is non-zero
882 - Evaluate expression and store the result in B->val
883 - Update the list of values that must be watched in B->loc.
885 If the watchpoint is disabled, do nothing. If this is
886 local watchpoint that is out of scope, delete it. */
888 update_watchpoint (struct breakpoint
*b
, int reparse
)
890 int within_current_scope
;
891 struct frame_id saved_frame_id
;
892 struct bp_location
*loc
;
895 /* We don't free locations. They are stored in
896 bp_location_chain and update_global_locations will
897 eventually delete them and remove breakpoints if
901 if (b
->disposition
== disp_del_at_next_stop
)
904 /* Save the current frame's ID so we can restore it after
905 evaluating the watchpoint expression on its own frame. */
906 /* FIXME drow/2003-09-09: It would be nice if evaluate_expression
907 took a frame parameter, so that we didn't have to change the
909 saved_frame_id
= get_frame_id (get_selected_frame (NULL
));
911 /* Determine if the watchpoint is within scope. */
912 if (b
->exp_valid_block
== NULL
)
913 within_current_scope
= 1;
916 struct frame_info
*fi
;
917 fi
= frame_find_by_id (b
->watchpoint_frame
);
918 within_current_scope
= (fi
!= NULL
);
919 if (within_current_scope
)
923 if (within_current_scope
&& reparse
)
932 b
->exp
= parse_exp_1 (&s
, b
->exp_valid_block
, 0);
933 /* If the meaning of expression itself changed, the old value is
934 no longer relevant. We don't want to report a watchpoint hit
935 to the user when the old value and the new value may actually
936 be completely different objects. */
942 /* If we failed to parse the expression, for example because
943 it refers to a global variable in a not-yet-loaded shared library,
944 don't try to insert watchpoint. We don't automatically delete
945 such watchpoint, though, since failure to parse expression
946 is different from out-of-scope watchpoint. */
947 if (within_current_scope
&& b
->exp
)
949 struct value
*val_chain
, *v
, *result
, *next
;
951 fetch_watchpoint_value (b
->exp
, &v
, &result
, &val_chain
);
953 /* Avoid setting b->val if it's already set. The meaning of
954 b->val is 'the last value' user saw, and we should update
955 it only if we reported that last value to user. As it
956 happens, the code that reports it updates b->val directly. */
963 /* Look at each value on the value chain. */
964 for (v
= val_chain
; v
; v
= next
)
966 /* If it's a memory location, and GDB actually needed
967 its contents to evaluate the expression, then we
968 must watch it. If the first value returned is
969 still lazy, that means an error occurred reading it;
970 watch it anyway in case it becomes readable. */
971 if (VALUE_LVAL (v
) == lval_memory
972 && (v
== val_chain
|| ! value_lazy (v
)))
974 struct type
*vtype
= check_typedef (value_type (v
));
976 /* We only watch structs and arrays if user asked
977 for it explicitly, never if they just happen to
978 appear in the middle of some value chain. */
980 || (TYPE_CODE (vtype
) != TYPE_CODE_STRUCT
981 && TYPE_CODE (vtype
) != TYPE_CODE_ARRAY
))
985 struct bp_location
*loc
, **tmp
;
987 addr
= VALUE_ADDRESS (v
) + value_offset (v
);
988 len
= TYPE_LENGTH (value_type (v
));
990 if (b
->type
== bp_read_watchpoint
)
992 else if (b
->type
== bp_access_watchpoint
)
995 loc
= allocate_bp_location (b
, bp_hardware_watchpoint
);
996 for (tmp
= &(b
->loc
); *tmp
!= NULL
; tmp
= &((*tmp
)->next
))
1001 loc
->watchpoint_type
= type
;
1005 next
= value_next (v
);
1010 /* We just regenerated the list of breakpoint locations.
1011 The new location does not have its condition field set to anything
1012 and therefore, we must always reparse the cond_string, independently
1013 of the value of the reparse flag. */
1014 if (b
->cond_string
!= NULL
)
1016 char *s
= b
->cond_string
;
1017 b
->loc
->cond
= parse_exp_1 (&s
, b
->exp_valid_block
, 0);
1020 else if (!within_current_scope
)
1022 printf_filtered (_("\
1023 Hardware watchpoint %d deleted because the program has left the block \n\
1024 in which its expression is valid.\n"),
1026 if (b
->related_breakpoint
)
1027 b
->related_breakpoint
->disposition
= disp_del_at_next_stop
;
1028 b
->disposition
= disp_del_at_next_stop
;
1031 /* Restore the selected frame. */
1032 select_frame (frame_find_by_id (saved_frame_id
));
1036 /* Returns 1 iff breakpoint location should be
1037 inserted in the inferior. */
1039 should_be_inserted (struct bp_location
*bpt
)
1041 if (!breakpoint_enabled (bpt
->owner
))
1044 if (bpt
->owner
->disposition
== disp_del_at_next_stop
)
1047 if (!bpt
->enabled
|| bpt
->shlib_disabled
|| bpt
->duplicate
)
1053 /* Insert a low-level "breakpoint" of some type. BPT is the breakpoint.
1054 Any error messages are printed to TMP_ERROR_STREAM; and DISABLED_BREAKS,
1055 PROCESS_WARNING, and HW_BREAKPOINT_ERROR are used to report problems.
1057 NOTE drow/2003-09-09: This routine could be broken down to an object-style
1058 method for each breakpoint or catchpoint type. */
1060 insert_bp_location (struct bp_location
*bpt
,
1061 struct ui_file
*tmp_error_stream
,
1062 int *disabled_breaks
, int *process_warning
,
1063 int *hw_breakpoint_error
)
1067 if (!should_be_inserted (bpt
) || bpt
->inserted
)
1070 /* Initialize the target-specific information. */
1071 memset (&bpt
->target_info
, 0, sizeof (bpt
->target_info
));
1072 bpt
->target_info
.placed_address
= bpt
->address
;
1074 if (bpt
->loc_type
== bp_loc_software_breakpoint
1075 || bpt
->loc_type
== bp_loc_hardware_breakpoint
)
1077 if (bpt
->owner
->type
!= bp_hardware_breakpoint
)
1079 /* If the explicitly specified breakpoint type
1080 is not hardware breakpoint, check the memory map to see
1081 if the breakpoint address is in read only memory or not.
1082 Two important cases are:
1083 - location type is not hardware breakpoint, memory
1084 is readonly. We change the type of the location to
1085 hardware breakpoint.
1086 - location type is hardware breakpoint, memory is read-write.
1087 This means we've previously made the location hardware one, but
1088 then the memory map changed, so we undo.
1090 When breakpoints are removed, remove_breakpoints will
1091 use location types we've just set here, the only possible
1092 problem is that memory map has changed during running program,
1093 but it's not going to work anyway with current gdb. */
1094 struct mem_region
*mr
1095 = lookup_mem_region (bpt
->target_info
.placed_address
);
1099 if (automatic_hardware_breakpoints
)
1102 enum bp_loc_type new_type
;
1104 if (mr
->attrib
.mode
!= MEM_RW
)
1105 new_type
= bp_loc_hardware_breakpoint
;
1107 new_type
= bp_loc_software_breakpoint
;
1109 if (new_type
!= bpt
->loc_type
)
1111 static int said
= 0;
1112 bpt
->loc_type
= new_type
;
1115 fprintf_filtered (gdb_stdout
, _("\
1116 Note: automatically using hardware breakpoints for read-only addresses.\n"));
1121 else if (bpt
->loc_type
== bp_loc_software_breakpoint
1122 && mr
->attrib
.mode
!= MEM_RW
)
1123 warning (_("cannot set software breakpoint at readonly address %s"),
1124 paddr (bpt
->address
));
1128 /* First check to see if we have to handle an overlay. */
1129 if (overlay_debugging
== ovly_off
1130 || bpt
->section
== NULL
1131 || !(section_is_overlay (bpt
->section
)))
1133 /* No overlay handling: just set the breakpoint. */
1135 if (bpt
->loc_type
== bp_loc_hardware_breakpoint
)
1136 val
= target_insert_hw_breakpoint (&bpt
->target_info
);
1138 val
= target_insert_breakpoint (&bpt
->target_info
);
1142 /* This breakpoint is in an overlay section.
1143 Shall we set a breakpoint at the LMA? */
1144 if (!overlay_events_enabled
)
1146 /* Yes -- overlay event support is not active,
1147 so we must try to set a breakpoint at the LMA.
1148 This will not work for a hardware breakpoint. */
1149 if (bpt
->loc_type
== bp_loc_hardware_breakpoint
)
1150 warning (_("hardware breakpoint %d not supported in overlay!"),
1151 bpt
->owner
->number
);
1154 CORE_ADDR addr
= overlay_unmapped_address (bpt
->address
,
1156 /* Set a software (trap) breakpoint at the LMA. */
1157 bpt
->overlay_target_info
= bpt
->target_info
;
1158 bpt
->overlay_target_info
.placed_address
= addr
;
1159 val
= target_insert_breakpoint (&bpt
->overlay_target_info
);
1161 fprintf_unfiltered (tmp_error_stream
,
1162 "Overlay breakpoint %d failed: in ROM?",
1163 bpt
->owner
->number
);
1166 /* Shall we set a breakpoint at the VMA? */
1167 if (section_is_mapped (bpt
->section
))
1169 /* Yes. This overlay section is mapped into memory. */
1170 if (bpt
->loc_type
== bp_loc_hardware_breakpoint
)
1171 val
= target_insert_hw_breakpoint (&bpt
->target_info
);
1173 val
= target_insert_breakpoint (&bpt
->target_info
);
1177 /* No. This breakpoint will not be inserted.
1178 No error, but do not mark the bp as 'inserted'. */
1185 /* Can't set the breakpoint. */
1186 if (solib_address (bpt
->address
))
1188 /* See also: disable_breakpoints_in_shlibs. */
1190 bpt
->shlib_disabled
= 1;
1191 if (!*disabled_breaks
)
1193 fprintf_unfiltered (tmp_error_stream
,
1194 "Cannot insert breakpoint %d.\n",
1195 bpt
->owner
->number
);
1196 fprintf_unfiltered (tmp_error_stream
,
1197 "Temporarily disabling shared library breakpoints:\n");
1199 *disabled_breaks
= 1;
1200 fprintf_unfiltered (tmp_error_stream
,
1201 "breakpoint #%d\n", bpt
->owner
->number
);
1205 #ifdef ONE_PROCESS_WRITETEXT
1206 *process_warning
= 1;
1208 if (bpt
->loc_type
== bp_loc_hardware_breakpoint
)
1210 *hw_breakpoint_error
= 1;
1211 fprintf_unfiltered (tmp_error_stream
,
1212 "Cannot insert hardware breakpoint %d.\n",
1213 bpt
->owner
->number
);
1217 fprintf_unfiltered (tmp_error_stream
,
1218 "Cannot insert breakpoint %d.\n",
1219 bpt
->owner
->number
);
1220 fprintf_filtered (tmp_error_stream
,
1221 "Error accessing memory address ");
1222 fputs_filtered (paddress (bpt
->address
), tmp_error_stream
);
1223 fprintf_filtered (tmp_error_stream
, ": %s.\n",
1224 safe_strerror (val
));
1235 else if (bpt
->loc_type
== bp_loc_hardware_watchpoint
1236 /* NOTE drow/2003-09-08: This state only exists for removing
1237 watchpoints. It's not clear that it's necessary... */
1238 && bpt
->owner
->disposition
!= disp_del_at_next_stop
)
1240 val
= target_insert_watchpoint (bpt
->address
,
1242 bpt
->watchpoint_type
);
1243 bpt
->inserted
= (val
!= -1);
1246 else if (bpt
->owner
->type
== bp_catch_fork
1247 || bpt
->owner
->type
== bp_catch_vfork
1248 || bpt
->owner
->type
== bp_catch_exec
)
1250 struct gdb_exception e
= catch_exception (uiout
, insert_catchpoint
,
1251 bpt
->owner
, RETURN_MASK_ERROR
);
1252 exception_fprintf (gdb_stderr
, e
, "warning: inserting catchpoint %d: ",
1253 bpt
->owner
->number
);
1255 bpt
->owner
->enable_state
= bp_disabled
;
1259 /* We've already printed an error message if there was a problem
1260 inserting this catchpoint, and we've disabled the catchpoint,
1261 so just return success. */
1268 /* Make sure all breakpoints are inserted in inferior.
1269 Throws exception on any error.
1270 A breakpoint that is already inserted won't be inserted
1271 again, so calling this function twice is safe. */
1273 insert_breakpoints (void)
1275 struct breakpoint
*bpt
;
1277 ALL_BREAKPOINTS (bpt
)
1278 if (is_hardware_watchpoint (bpt
))
1279 update_watchpoint (bpt
, 0 /* don't reparse. */);
1281 update_global_location_list ();
1283 if (!always_inserted_mode
&& target_has_execution
)
1284 /* update_global_location_list does not insert breakpoints
1285 when always_inserted_mode is not enabled. Explicitly
1287 insert_breakpoint_locations ();
1290 /* insert_breakpoints is used when starting or continuing the program.
1291 remove_breakpoints is used when the program stops.
1292 Both return zero if successful,
1293 or an `errno' value if could not write the inferior. */
1296 insert_breakpoint_locations (void)
1298 struct breakpoint
*bpt
;
1299 struct bp_location
*b
, *temp
;
1302 int disabled_breaks
= 0;
1303 int hw_breakpoint_error
= 0;
1304 int process_warning
= 0;
1306 struct ui_file
*tmp_error_stream
= mem_fileopen ();
1307 make_cleanup_ui_file_delete (tmp_error_stream
);
1309 /* Explicitly mark the warning -- this will only be printed if
1310 there was an error. */
1311 fprintf_unfiltered (tmp_error_stream
, "Warning:\n");
1313 ALL_BP_LOCATIONS_SAFE (b
, temp
)
1315 if (!should_be_inserted (b
) || b
->inserted
)
1318 /* There is no point inserting thread-specific breakpoints if the
1319 thread no longer exists. */
1320 if (b
->owner
->thread
!= -1
1321 && !valid_thread_id (b
->owner
->thread
))
1324 val
= insert_bp_location (b
, tmp_error_stream
,
1325 &disabled_breaks
, &process_warning
,
1326 &hw_breakpoint_error
);
1331 /* If we failed to insert all locations of a watchpoint,
1332 remove them, as half-inserted watchpoint is of limited use. */
1333 ALL_BREAKPOINTS (bpt
)
1335 int some_failed
= 0;
1336 struct bp_location
*loc
;
1338 if (!is_hardware_watchpoint (bpt
))
1341 if (bpt
->enable_state
!= bp_enabled
)
1344 if (bpt
->disposition
== disp_del_at_next_stop
)
1347 for (loc
= bpt
->loc
; loc
; loc
= loc
->next
)
1355 for (loc
= bpt
->loc
; loc
; loc
= loc
->next
)
1357 remove_breakpoint (loc
, mark_uninserted
);
1359 hw_breakpoint_error
= 1;
1360 fprintf_unfiltered (tmp_error_stream
,
1361 "Could not insert hardware watchpoint %d.\n",
1369 /* If a hardware breakpoint or watchpoint was inserted, add a
1370 message about possibly exhausted resources. */
1371 if (hw_breakpoint_error
)
1373 fprintf_unfiltered (tmp_error_stream
,
1374 "Could not insert hardware breakpoints:\n\
1375 You may have requested too many hardware breakpoints/watchpoints.\n");
1377 #ifdef ONE_PROCESS_WRITETEXT
1378 if (process_warning
)
1379 fprintf_unfiltered (tmp_error_stream
,
1380 "The same program may be running in another process.");
1382 target_terminal_ours_for_output ();
1383 error_stream (tmp_error_stream
);
1388 remove_breakpoints (void)
1390 struct bp_location
*b
;
1393 ALL_BP_LOCATIONS (b
)
1397 val
= remove_breakpoint (b
, mark_uninserted
);
1406 remove_hw_watchpoints (void)
1408 struct bp_location
*b
;
1411 ALL_BP_LOCATIONS (b
)
1413 if (b
->inserted
&& b
->loc_type
== bp_loc_hardware_watchpoint
)
1415 val
= remove_breakpoint (b
, mark_uninserted
);
1424 reattach_breakpoints (int pid
)
1426 struct bp_location
*b
;
1428 struct cleanup
*old_chain
= save_inferior_ptid ();
1429 struct ui_file
*tmp_error_stream
= mem_fileopen ();
1430 int dummy1
= 0, dummy2
= 0, dummy3
= 0;
1432 make_cleanup_ui_file_delete (tmp_error_stream
);
1434 inferior_ptid
= pid_to_ptid (pid
);
1435 ALL_BP_LOCATIONS (b
)
1440 val
= insert_bp_location (b
, tmp_error_stream
,
1441 &dummy1
, &dummy2
, &dummy3
);
1444 do_cleanups (old_chain
);
1449 do_cleanups (old_chain
);
1454 restore_always_inserted_mode (void *p
)
1456 always_inserted_mode
= (uintptr_t) p
;
1460 update_breakpoints_after_exec (void)
1462 struct breakpoint
*b
;
1463 struct breakpoint
*temp
;
1464 struct cleanup
*cleanup
;
1466 /* Doing this first prevents the badness of having delete_breakpoint()
1467 write a breakpoint's current "shadow contents" to lift the bp. That
1468 shadow is NOT valid after an exec()! */
1469 mark_breakpoints_out ();
1471 /* The binary we used to debug is now gone, and we're updating
1472 breakpoints for the new binary. Until we're done, we should not
1473 try to insert breakpoints. */
1474 cleanup
= make_cleanup (restore_always_inserted_mode
,
1475 (void *) (uintptr_t) always_inserted_mode
);
1476 always_inserted_mode
= 0;
1478 ALL_BREAKPOINTS_SAFE (b
, temp
)
1480 /* Solib breakpoints must be explicitly reset after an exec(). */
1481 if (b
->type
== bp_shlib_event
)
1483 delete_breakpoint (b
);
1487 /* Thread event breakpoints must be set anew after an exec(),
1488 as must overlay event breakpoints. */
1489 if (b
->type
== bp_thread_event
|| b
->type
== bp_overlay_event
)
1491 delete_breakpoint (b
);
1495 /* Step-resume breakpoints are meaningless after an exec(). */
1496 if (b
->type
== bp_step_resume
)
1498 delete_breakpoint (b
);
1502 /* Don't delete an exec catchpoint, because else the inferior
1503 won't stop when it ought!
1505 Similarly, we probably ought to keep vfork catchpoints, 'cause
1506 on this target, we may not be able to stop when the vfork is
1507 seen, but only when the subsequent exec is seen. (And because
1508 deleting fork catchpoints here but not vfork catchpoints will
1509 seem mysterious to users, keep those too.) */
1510 if ((b
->type
== bp_catch_exec
) ||
1511 (b
->type
== bp_catch_vfork
) ||
1512 (b
->type
== bp_catch_fork
))
1517 /* bp_finish is a special case. The only way we ought to be able
1518 to see one of these when an exec() has happened, is if the user
1519 caught a vfork, and then said "finish". Ordinarily a finish just
1520 carries them to the call-site of the current callee, by setting
1521 a temporary bp there and resuming. But in this case, the finish
1522 will carry them entirely through the vfork & exec.
1524 We don't want to allow a bp_finish to remain inserted now. But
1525 we can't safely delete it, 'cause finish_command has a handle to
1526 the bp on a bpstat, and will later want to delete it. There's a
1527 chance (and I've seen it happen) that if we delete the bp_finish
1528 here, that its storage will get reused by the time finish_command
1529 gets 'round to deleting the "use to be a bp_finish" breakpoint.
1530 We really must allow finish_command to delete a bp_finish.
1532 In the absense of a general solution for the "how do we know
1533 it's safe to delete something others may have handles to?"
1534 problem, what we'll do here is just uninsert the bp_finish, and
1535 let finish_command delete it.
1537 (We know the bp_finish is "doomed" in the sense that it's
1538 momentary, and will be deleted as soon as finish_command sees
1539 the inferior stopped. So it doesn't matter that the bp's
1540 address is probably bogus in the new a.out, unlike e.g., the
1541 solib breakpoints.) */
1543 if (b
->type
== bp_finish
)
1548 /* Without a symbolic address, we have little hope of the
1549 pre-exec() address meaning the same thing in the post-exec()
1551 if (b
->addr_string
== NULL
)
1553 delete_breakpoint (b
);
1557 /* FIXME what about longjmp breakpoints? Re-create them here? */
1558 create_overlay_event_breakpoint ("_ovly_debug_event");
1559 do_cleanups (cleanup
);
1563 detach_breakpoints (int pid
)
1565 struct bp_location
*b
;
1567 struct cleanup
*old_chain
= save_inferior_ptid ();
1569 if (pid
== PIDGET (inferior_ptid
))
1570 error (_("Cannot detach breakpoints of inferior_ptid"));
1572 /* Set inferior_ptid; remove_breakpoint uses this global. */
1573 inferior_ptid
= pid_to_ptid (pid
);
1574 ALL_BP_LOCATIONS (b
)
1578 val
= remove_breakpoint (b
, mark_inserted
);
1581 do_cleanups (old_chain
);
1586 do_cleanups (old_chain
);
1591 remove_breakpoint (struct bp_location
*b
, insertion_state_t is
)
1595 if (b
->owner
->enable_state
== bp_permanent
)
1596 /* Permanent breakpoints cannot be inserted or removed. */
1599 /* The type of none suggests that owner is actually deleted.
1600 This should not ever happen. */
1601 gdb_assert (b
->owner
->type
!= bp_none
);
1603 if (b
->loc_type
== bp_loc_software_breakpoint
1604 || b
->loc_type
== bp_loc_hardware_breakpoint
)
1606 /* "Normal" instruction breakpoint: either the standard
1607 trap-instruction bp (bp_breakpoint), or a
1608 bp_hardware_breakpoint. */
1610 /* First check to see if we have to handle an overlay. */
1611 if (overlay_debugging
== ovly_off
1612 || b
->section
== NULL
1613 || !(section_is_overlay (b
->section
)))
1615 /* No overlay handling: just remove the breakpoint. */
1617 if (b
->loc_type
== bp_loc_hardware_breakpoint
)
1618 val
= target_remove_hw_breakpoint (&b
->target_info
);
1620 val
= target_remove_breakpoint (&b
->target_info
);
1624 /* This breakpoint is in an overlay section.
1625 Did we set a breakpoint at the LMA? */
1626 if (!overlay_events_enabled
)
1628 /* Yes -- overlay event support is not active, so we
1629 should have set a breakpoint at the LMA. Remove it.
1631 /* Ignore any failures: if the LMA is in ROM, we will
1632 have already warned when we failed to insert it. */
1633 if (b
->loc_type
== bp_loc_hardware_breakpoint
)
1634 target_remove_hw_breakpoint (&b
->overlay_target_info
);
1636 target_remove_breakpoint (&b
->overlay_target_info
);
1638 /* Did we set a breakpoint at the VMA?
1639 If so, we will have marked the breakpoint 'inserted'. */
1642 /* Yes -- remove it. Previously we did not bother to
1643 remove the breakpoint if the section had been
1644 unmapped, but let's not rely on that being safe. We
1645 don't know what the overlay manager might do. */
1646 if (b
->loc_type
== bp_loc_hardware_breakpoint
)
1647 val
= target_remove_hw_breakpoint (&b
->target_info
);
1649 /* However, we should remove *software* breakpoints only
1650 if the section is still mapped, or else we overwrite
1651 wrong code with the saved shadow contents. */
1652 else if (section_is_mapped (b
->section
))
1653 val
= target_remove_breakpoint (&b
->target_info
);
1659 /* No -- not inserted, so no need to remove. No error. */
1665 b
->inserted
= (is
== mark_inserted
);
1667 else if (b
->loc_type
== bp_loc_hardware_watchpoint
)
1672 b
->inserted
= (is
== mark_inserted
);
1673 val
= target_remove_watchpoint (b
->address
, b
->length
,
1674 b
->watchpoint_type
);
1676 /* Failure to remove any of the hardware watchpoints comes here. */
1677 if ((is
== mark_uninserted
) && (b
->inserted
))
1678 warning (_("Could not remove hardware watchpoint %d."),
1681 else if ((b
->owner
->type
== bp_catch_fork
||
1682 b
->owner
->type
== bp_catch_vfork
||
1683 b
->owner
->type
== bp_catch_exec
)
1684 && breakpoint_enabled (b
->owner
)
1688 switch (b
->owner
->type
)
1691 val
= target_remove_fork_catchpoint (PIDGET (inferior_ptid
));
1693 case bp_catch_vfork
:
1694 val
= target_remove_vfork_catchpoint (PIDGET (inferior_ptid
));
1697 val
= target_remove_exec_catchpoint (PIDGET (inferior_ptid
));
1700 warning (_("Internal error, %s line %d."), __FILE__
, __LINE__
);
1705 b
->inserted
= (is
== mark_inserted
);
1711 /* Clear the "inserted" flag in all breakpoints. */
1714 mark_breakpoints_out (void)
1716 struct bp_location
*bpt
;
1718 ALL_BP_LOCATIONS (bpt
)
1722 /* Clear the "inserted" flag in all breakpoints and delete any
1723 breakpoints which should go away between runs of the program.
1725 Plus other such housekeeping that has to be done for breakpoints
1728 Note: this function gets called at the end of a run (by
1729 generic_mourn_inferior) and when a run begins (by
1730 init_wait_for_inferior). */
1735 breakpoint_init_inferior (enum inf_context context
)
1737 struct breakpoint
*b
, *temp
;
1738 struct bp_location
*bpt
;
1740 ALL_BP_LOCATIONS (bpt
)
1743 ALL_BREAKPOINTS_SAFE (b
, temp
)
1748 case bp_watchpoint_scope
:
1750 /* If the call dummy breakpoint is at the entry point it will
1751 cause problems when the inferior is rerun, so we better
1754 Also get rid of scope breakpoints. */
1755 delete_breakpoint (b
);
1759 case bp_hardware_watchpoint
:
1760 case bp_read_watchpoint
:
1761 case bp_access_watchpoint
:
1763 /* Likewise for watchpoints on local expressions. */
1764 if (b
->exp_valid_block
!= NULL
)
1765 delete_breakpoint (b
);
1766 else if (context
== inf_starting
)
1768 /* Reset val field to force reread of starting value
1769 in insert_breakpoints. */
1771 value_free (b
->val
);
1782 /* breakpoint_here_p (PC) returns non-zero if an enabled breakpoint
1783 exists at PC. It returns ordinary_breakpoint_here if it's an
1784 ordinary breakpoint, or permanent_breakpoint_here if it's a
1785 permanent breakpoint.
1786 - When continuing from a location with an ordinary breakpoint, we
1787 actually single step once before calling insert_breakpoints.
1788 - When continuing from a localion with a permanent breakpoint, we
1789 need to use the `SKIP_PERMANENT_BREAKPOINT' macro, provided by
1790 the target, to advance the PC past the breakpoint. */
1792 enum breakpoint_here
1793 breakpoint_here_p (CORE_ADDR pc
)
1795 const struct bp_location
*bpt
;
1796 int any_breakpoint_here
= 0;
1798 ALL_BP_LOCATIONS (bpt
)
1800 if (bpt
->loc_type
!= bp_loc_software_breakpoint
1801 && bpt
->loc_type
!= bp_loc_hardware_breakpoint
)
1804 if ((breakpoint_enabled (bpt
->owner
)
1805 || bpt
->owner
->enable_state
== bp_permanent
)
1806 && bpt
->address
== pc
) /* bp is enabled and matches pc */
1808 if (overlay_debugging
1809 && section_is_overlay (bpt
->section
)
1810 && !section_is_mapped (bpt
->section
))
1811 continue; /* unmapped overlay -- can't be a match */
1812 else if (bpt
->owner
->enable_state
== bp_permanent
)
1813 return permanent_breakpoint_here
;
1815 any_breakpoint_here
= 1;
1819 return any_breakpoint_here
? ordinary_breakpoint_here
: 0;
1823 /* Returns non-zero if there's a breakpoint inserted at PC, which is
1824 inserted using regular breakpoint_chain/bp_location_chain mechanism.
1825 This does not check for single-step breakpoints, which are
1826 inserted and removed using direct target manipulation. */
1829 regular_breakpoint_inserted_here_p (CORE_ADDR pc
)
1831 const struct bp_location
*bpt
;
1833 ALL_BP_LOCATIONS (bpt
)
1835 if (bpt
->loc_type
!= bp_loc_software_breakpoint
1836 && bpt
->loc_type
!= bp_loc_hardware_breakpoint
)
1840 && bpt
->address
== pc
) /* bp is inserted and matches pc */
1842 if (overlay_debugging
1843 && section_is_overlay (bpt
->section
)
1844 && !section_is_mapped (bpt
->section
))
1845 continue; /* unmapped overlay -- can't be a match */
1853 /* Returns non-zero iff there's either regular breakpoint
1854 or a single step breakpoint inserted at PC. */
1857 breakpoint_inserted_here_p (CORE_ADDR pc
)
1859 if (regular_breakpoint_inserted_here_p (pc
))
1862 if (single_step_breakpoint_inserted_here_p (pc
))
1868 /* This function returns non-zero iff there is a software breakpoint
1872 software_breakpoint_inserted_here_p (CORE_ADDR pc
)
1874 const struct bp_location
*bpt
;
1875 int any_breakpoint_here
= 0;
1877 ALL_BP_LOCATIONS (bpt
)
1879 if (bpt
->loc_type
!= bp_loc_software_breakpoint
)
1883 && bpt
->address
== pc
) /* bp is enabled and matches pc */
1885 if (overlay_debugging
1886 && section_is_overlay (bpt
->section
)
1887 && !section_is_mapped (bpt
->section
))
1888 continue; /* unmapped overlay -- can't be a match */
1894 /* Also check for software single-step breakpoints. */
1895 if (single_step_breakpoint_inserted_here_p (pc
))
1901 /* breakpoint_thread_match (PC, PTID) returns true if the breakpoint at
1902 PC is valid for process/thread PTID. */
1905 breakpoint_thread_match (CORE_ADDR pc
, ptid_t ptid
)
1907 const struct bp_location
*bpt
;
1910 thread
= pid_to_thread_id (ptid
);
1912 ALL_BP_LOCATIONS (bpt
)
1914 if (bpt
->loc_type
!= bp_loc_software_breakpoint
1915 && bpt
->loc_type
!= bp_loc_hardware_breakpoint
)
1918 if ((breakpoint_enabled (bpt
->owner
)
1919 || bpt
->owner
->enable_state
== bp_permanent
)
1920 && bpt
->address
== pc
1921 && (bpt
->owner
->thread
== -1 || bpt
->owner
->thread
== thread
))
1923 if (overlay_debugging
1924 && section_is_overlay (bpt
->section
)
1925 && !section_is_mapped (bpt
->section
))
1926 continue; /* unmapped overlay -- can't be a match */
1936 /* bpstat stuff. External routines' interfaces are documented
1940 ep_is_catchpoint (struct breakpoint
*ep
)
1943 (ep
->type
== bp_catch_load
)
1944 || (ep
->type
== bp_catch_unload
)
1945 || (ep
->type
== bp_catch_fork
)
1946 || (ep
->type
== bp_catch_vfork
)
1947 || (ep
->type
== bp_catch_exec
);
1949 /* ??rehrauer: Add more kinds here, as are implemented... */
1953 ep_is_shlib_catchpoint (struct breakpoint
*ep
)
1956 (ep
->type
== bp_catch_load
)
1957 || (ep
->type
== bp_catch_unload
);
1961 bpstat_free (bpstat bs
)
1963 if (bs
->old_val
!= NULL
)
1964 value_free (bs
->old_val
);
1965 free_command_lines (&bs
->commands
);
1969 /* Clear a bpstat so that it says we are not at any breakpoint.
1970 Also free any storage that is part of a bpstat. */
1973 bpstat_clear (bpstat
*bsp
)
1990 /* Return a copy of a bpstat. Like "bs1 = bs2" but all storage that
1991 is part of the bpstat is copied as well. */
1994 bpstat_copy (bpstat bs
)
1998 bpstat retval
= NULL
;
2003 for (; bs
!= NULL
; bs
= bs
->next
)
2005 tmp
= (bpstat
) xmalloc (sizeof (*tmp
));
2006 memcpy (tmp
, bs
, sizeof (*tmp
));
2007 if (bs
->commands
!= NULL
)
2008 tmp
->commands
= copy_command_lines (bs
->commands
);
2009 if (bs
->old_val
!= NULL
)
2010 tmp
->old_val
= value_copy (bs
->old_val
);
2013 /* This is the first thing in the chain. */
2023 /* Find the bpstat associated with this breakpoint */
2026 bpstat_find_breakpoint (bpstat bsp
, struct breakpoint
*breakpoint
)
2031 for (; bsp
!= NULL
; bsp
= bsp
->next
)
2033 if (bsp
->breakpoint_at
&& bsp
->breakpoint_at
->owner
== breakpoint
)
2039 /* Find a step_resume breakpoint associated with this bpstat.
2040 (If there are multiple step_resume bp's on the list, this function
2041 will arbitrarily pick one.)
2043 It is an error to use this function if BPSTAT doesn't contain a
2044 step_resume breakpoint.
2046 See wait_for_inferior's use of this function. */
2048 bpstat_find_step_resume_breakpoint (bpstat bsp
)
2052 gdb_assert (bsp
!= NULL
);
2054 current_thread
= pid_to_thread_id (inferior_ptid
);
2056 for (; bsp
!= NULL
; bsp
= bsp
->next
)
2058 if ((bsp
->breakpoint_at
!= NULL
) &&
2059 (bsp
->breakpoint_at
->owner
->type
== bp_step_resume
) &&
2060 (bsp
->breakpoint_at
->owner
->thread
== current_thread
||
2061 bsp
->breakpoint_at
->owner
->thread
== -1))
2062 return bsp
->breakpoint_at
->owner
;
2065 internal_error (__FILE__
, __LINE__
, _("No step_resume breakpoint found."));
2069 /* Put in *NUM the breakpoint number of the first breakpoint we are stopped
2070 at. *BSP upon return is a bpstat which points to the remaining
2071 breakpoints stopped at (but which is not guaranteed to be good for
2072 anything but further calls to bpstat_num).
2073 Return 0 if passed a bpstat which does not indicate any breakpoints.
2074 Return -1 if stopped at a breakpoint that has been deleted since
2076 Return 1 otherwise. */
2079 bpstat_num (bpstat
*bsp
, int *num
)
2081 struct breakpoint
*b
;
2084 return 0; /* No more breakpoint values */
2086 /* We assume we'll never have several bpstats that
2087 correspond to a single breakpoint -- otherwise,
2088 this function might return the same number more
2089 than once and this will look ugly. */
2090 b
= (*bsp
)->breakpoint_at
? (*bsp
)->breakpoint_at
->owner
: NULL
;
2091 *bsp
= (*bsp
)->next
;
2093 return -1; /* breakpoint that's been deleted since */
2095 *num
= b
->number
; /* We have its number */
2099 /* Modify BS so that the actions will not be performed. */
2102 bpstat_clear_actions (bpstat bs
)
2104 for (; bs
!= NULL
; bs
= bs
->next
)
2106 free_command_lines (&bs
->commands
);
2107 if (bs
->old_val
!= NULL
)
2109 value_free (bs
->old_val
);
2115 /* Stub for cleaning up our state if we error-out of a breakpoint command */
2117 cleanup_executing_breakpoints (void *ignore
)
2119 executing_breakpoint_commands
= 0;
2122 /* Execute all the commands associated with all the breakpoints at this
2123 location. Any of these commands could cause the process to proceed
2124 beyond this point, etc. We look out for such changes by checking
2125 the global "breakpoint_proceeded" after each command. */
2128 bpstat_do_actions (bpstat
*bsp
)
2131 struct cleanup
*old_chain
;
2133 /* Avoid endless recursion if a `source' command is contained
2135 if (executing_breakpoint_commands
)
2138 executing_breakpoint_commands
= 1;
2139 old_chain
= make_cleanup (cleanup_executing_breakpoints
, 0);
2142 /* Note that (as of this writing), our callers all appear to
2143 be passing us the address of global stop_bpstat. And, if
2144 our calls to execute_control_command cause the inferior to
2145 proceed, that global (and hence, *bsp) will change.
2147 We must be careful to not touch *bsp unless the inferior
2148 has not proceeded. */
2150 /* This pointer will iterate over the list of bpstat's. */
2153 breakpoint_proceeded
= 0;
2154 for (; bs
!= NULL
; bs
= bs
->next
)
2156 struct command_line
*cmd
;
2157 struct cleanup
*this_cmd_tree_chain
;
2159 /* Take ownership of the BSP's command tree, if it has one.
2161 The command tree could legitimately contain commands like
2162 'step' and 'next', which call clear_proceed_status, which
2163 frees stop_bpstat's command tree. To make sure this doesn't
2164 free the tree we're executing out from under us, we need to
2165 take ownership of the tree ourselves. Since a given bpstat's
2166 commands are only executed once, we don't need to copy it; we
2167 can clear the pointer in the bpstat, and make sure we free
2168 the tree when we're done. */
2171 this_cmd_tree_chain
= make_cleanup_free_command_lines (&cmd
);
2175 execute_control_command (cmd
);
2177 if (breakpoint_proceeded
)
2183 /* We can free this command tree now. */
2184 do_cleanups (this_cmd_tree_chain
);
2186 if (breakpoint_proceeded
)
2188 if (target_can_async_p ())
2189 /* If we are in async mode, then the target might
2190 be still running, not stopped at any breakpoint,
2191 so nothing for us to do here -- just return to
2195 /* In sync mode, when execute_control_command returns
2196 we're already standing on the next breakpoint.
2197 Breakpoint commands for that stop were not run,
2198 since execute_command does not run breakpoint
2199 commands -- only command_line_handler does, but
2200 that one is not involved in execution of breakpoint
2201 commands. So, we can now execute breakpoint commands.
2202 There's an implicit assumption that we're called with
2203 stop_bpstat, so our parameter is the new bpstat to
2205 It should be noted that making execute_command do
2206 bpstat actions is not an option -- in this case we'll
2207 have recursive invocation of bpstat for each breakpoint
2208 with a command, and can easily blow up GDB stack. */
2212 do_cleanups (old_chain
);
2215 /* Print out the (old or new) value associated with a watchpoint. */
2218 watchpoint_value_print (struct value
*val
, struct ui_file
*stream
)
2221 fprintf_unfiltered (stream
, _("<unreadable>"));
2223 value_print (val
, stream
, 0, Val_pretty_default
);
2226 /* This is the normal print function for a bpstat. In the future,
2227 much of this logic could (should?) be moved to bpstat_stop_status,
2228 by having it set different print_it values.
2230 Current scheme: When we stop, bpstat_print() is called. It loops
2231 through the bpstat list of things causing this stop, calling the
2232 print_bp_stop_message function on each one. The behavior of the
2233 print_bp_stop_message function depends on the print_it field of
2234 bpstat. If such field so indicates, call this function here.
2236 Return values from this routine (ultimately used by bpstat_print()
2237 and normal_stop() to decide what to do):
2238 PRINT_NOTHING: Means we already printed all we needed to print,
2239 don't print anything else.
2240 PRINT_SRC_ONLY: Means we printed something, and we do *not* desire
2241 that something to be followed by a location.
2242 PRINT_SCR_AND_LOC: Means we printed something, and we *do* desire
2243 that something to be followed by a location.
2244 PRINT_UNKNOWN: Means we printed nothing or we need to do some more
2247 static enum print_stop_action
2248 print_it_typical (bpstat bs
)
2250 struct cleanup
*old_chain
, *ui_out_chain
;
2251 struct breakpoint
*b
;
2252 const struct bp_location
*bl
;
2253 struct ui_stream
*stb
;
2255 stb
= ui_out_stream_new (uiout
);
2256 old_chain
= make_cleanup_ui_out_stream_delete (stb
);
2257 /* bs->breakpoint_at can be NULL if it was a momentary breakpoint
2258 which has since been deleted. */
2259 if (bs
->breakpoint_at
== NULL
)
2260 return PRINT_UNKNOWN
;
2261 bl
= bs
->breakpoint_at
;
2267 case bp_hardware_breakpoint
:
2268 bp_temp
= bs
->breakpoint_at
->owner
->disposition
== disp_del
;
2269 if (bl
->address
!= bl
->requested_address
)
2270 breakpoint_adjustment_warning (bl
->requested_address
,
2273 annotate_breakpoint (b
->number
);
2275 ui_out_text (uiout
, "\nTemporary breakpoint ");
2277 ui_out_text (uiout
, "\nBreakpoint ");
2278 if (ui_out_is_mi_like_p (uiout
))
2280 ui_out_field_string (uiout
, "reason",
2281 async_reason_lookup (EXEC_ASYNC_BREAKPOINT_HIT
));
2282 ui_out_field_string (uiout
, "disp", bpdisp_text (b
->disposition
));
2284 ui_out_field_int (uiout
, "bkptno", b
->number
);
2285 ui_out_text (uiout
, ", ");
2286 return PRINT_SRC_AND_LOC
;
2289 case bp_shlib_event
:
2290 /* Did we stop because the user set the stop_on_solib_events
2291 variable? (If so, we report this as a generic, "Stopped due
2292 to shlib event" message.) */
2293 printf_filtered (_("Stopped due to shared library event\n"));
2294 return PRINT_NOTHING
;
2297 case bp_thread_event
:
2298 /* Not sure how we will get here.
2299 GDB should not stop for these breakpoints. */
2300 printf_filtered (_("Thread Event Breakpoint: gdb should not stop!\n"));
2301 return PRINT_NOTHING
;
2304 case bp_overlay_event
:
2305 /* By analogy with the thread event, GDB should not stop for these. */
2306 printf_filtered (_("Overlay Event Breakpoint: gdb should not stop!\n"));
2307 return PRINT_NOTHING
;
2311 annotate_catchpoint (b
->number
);
2312 printf_filtered (_("\nCatchpoint %d (loaded %s), "),
2314 b
->triggered_dll_pathname
);
2315 return PRINT_SRC_AND_LOC
;
2318 case bp_catch_unload
:
2319 annotate_catchpoint (b
->number
);
2320 printf_filtered (_("\nCatchpoint %d (unloaded %s), "),
2322 b
->triggered_dll_pathname
);
2323 return PRINT_SRC_AND_LOC
;
2327 annotate_catchpoint (b
->number
);
2328 printf_filtered (_("\nCatchpoint %d (forked process %d), "),
2330 b
->forked_inferior_pid
);
2331 return PRINT_SRC_AND_LOC
;
2334 case bp_catch_vfork
:
2335 annotate_catchpoint (b
->number
);
2336 printf_filtered (_("\nCatchpoint %d (vforked process %d), "),
2338 b
->forked_inferior_pid
);
2339 return PRINT_SRC_AND_LOC
;
2343 annotate_catchpoint (b
->number
);
2344 printf_filtered (_("\nCatchpoint %d (exec'd %s), "),
2347 return PRINT_SRC_AND_LOC
;
2351 case bp_hardware_watchpoint
:
2352 annotate_watchpoint (b
->number
);
2353 if (ui_out_is_mi_like_p (uiout
))
2356 async_reason_lookup (EXEC_ASYNC_WATCHPOINT_TRIGGER
));
2358 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "value");
2359 ui_out_text (uiout
, "\nOld value = ");
2360 watchpoint_value_print (bs
->old_val
, stb
->stream
);
2361 ui_out_field_stream (uiout
, "old", stb
);
2362 ui_out_text (uiout
, "\nNew value = ");
2363 watchpoint_value_print (b
->val
, stb
->stream
);
2364 ui_out_field_stream (uiout
, "new", stb
);
2365 do_cleanups (ui_out_chain
);
2366 ui_out_text (uiout
, "\n");
2367 /* More than one watchpoint may have been triggered. */
2368 return PRINT_UNKNOWN
;
2371 case bp_read_watchpoint
:
2372 if (ui_out_is_mi_like_p (uiout
))
2375 async_reason_lookup (EXEC_ASYNC_READ_WATCHPOINT_TRIGGER
));
2377 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "value");
2378 ui_out_text (uiout
, "\nValue = ");
2379 watchpoint_value_print (b
->val
, stb
->stream
);
2380 ui_out_field_stream (uiout
, "value", stb
);
2381 do_cleanups (ui_out_chain
);
2382 ui_out_text (uiout
, "\n");
2383 return PRINT_UNKNOWN
;
2386 case bp_access_watchpoint
:
2387 if (bs
->old_val
!= NULL
)
2389 annotate_watchpoint (b
->number
);
2390 if (ui_out_is_mi_like_p (uiout
))
2393 async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER
));
2395 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "value");
2396 ui_out_text (uiout
, "\nOld value = ");
2397 watchpoint_value_print (bs
->old_val
, stb
->stream
);
2398 ui_out_field_stream (uiout
, "old", stb
);
2399 ui_out_text (uiout
, "\nNew value = ");
2404 if (ui_out_is_mi_like_p (uiout
))
2407 async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER
));
2408 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "value");
2409 ui_out_text (uiout
, "\nValue = ");
2411 watchpoint_value_print (b
->val
, stb
->stream
);
2412 ui_out_field_stream (uiout
, "new", stb
);
2413 do_cleanups (ui_out_chain
);
2414 ui_out_text (uiout
, "\n");
2415 return PRINT_UNKNOWN
;
2418 /* Fall through, we don't deal with these types of breakpoints
2422 if (ui_out_is_mi_like_p (uiout
))
2425 async_reason_lookup (EXEC_ASYNC_FUNCTION_FINISHED
));
2426 return PRINT_UNKNOWN
;
2430 if (ui_out_is_mi_like_p (uiout
))
2433 async_reason_lookup (EXEC_ASYNC_LOCATION_REACHED
));
2434 return PRINT_UNKNOWN
;
2439 case bp_longjmp_resume
:
2440 case bp_step_resume
:
2441 case bp_watchpoint_scope
:
2444 return PRINT_UNKNOWN
;
2448 /* Generic routine for printing messages indicating why we
2449 stopped. The behavior of this function depends on the value
2450 'print_it' in the bpstat structure. Under some circumstances we
2451 may decide not to print anything here and delegate the task to
2454 static enum print_stop_action
2455 print_bp_stop_message (bpstat bs
)
2457 switch (bs
->print_it
)
2460 /* Nothing should be printed for this bpstat entry. */
2461 return PRINT_UNKNOWN
;
2465 /* We still want to print the frame, but we already printed the
2466 relevant messages. */
2467 return PRINT_SRC_AND_LOC
;
2470 case print_it_normal
:
2472 const struct bp_location
*bl
= bs
->breakpoint_at
;
2473 struct breakpoint
*b
= bl
? bl
->owner
: NULL
;
2475 /* Normal case. Call the breakpoint's print_it method, or
2476 print_it_typical. */
2477 /* FIXME: how breakpoint can ever be NULL here? */
2478 if (b
!= NULL
&& b
->ops
!= NULL
&& b
->ops
->print_it
!= NULL
)
2479 return b
->ops
->print_it (b
);
2481 return print_it_typical (bs
);
2486 internal_error (__FILE__
, __LINE__
,
2487 _("print_bp_stop_message: unrecognized enum value"));
2492 /* Print a message indicating what happened. This is called from
2493 normal_stop(). The input to this routine is the head of the bpstat
2494 list - a list of the eventpoints that caused this stop. This
2495 routine calls the generic print routine for printing a message
2496 about reasons for stopping. This will print (for example) the
2497 "Breakpoint n," part of the output. The return value of this
2500 PRINT_UNKNOWN: Means we printed nothing
2501 PRINT_SRC_AND_LOC: Means we printed something, and expect subsequent
2502 code to print the location. An example is
2503 "Breakpoint 1, " which should be followed by
2505 PRINT_SRC_ONLY: Means we printed something, but there is no need
2506 to also print the location part of the message.
2507 An example is the catch/throw messages, which
2508 don't require a location appended to the end.
2509 PRINT_NOTHING: We have done some printing and we don't need any
2510 further info to be printed.*/
2512 enum print_stop_action
2513 bpstat_print (bpstat bs
)
2517 /* Maybe another breakpoint in the chain caused us to stop.
2518 (Currently all watchpoints go on the bpstat whether hit or not.
2519 That probably could (should) be changed, provided care is taken
2520 with respect to bpstat_explains_signal). */
2521 for (; bs
; bs
= bs
->next
)
2523 val
= print_bp_stop_message (bs
);
2524 if (val
== PRINT_SRC_ONLY
2525 || val
== PRINT_SRC_AND_LOC
2526 || val
== PRINT_NOTHING
)
2530 /* We reached the end of the chain, or we got a null BS to start
2531 with and nothing was printed. */
2532 return PRINT_UNKNOWN
;
2535 /* Evaluate the expression EXP and return 1 if value is zero.
2536 This is used inside a catch_errors to evaluate the breakpoint condition.
2537 The argument is a "struct expression *" that has been cast to char * to
2538 make it pass through catch_errors. */
2541 breakpoint_cond_eval (void *exp
)
2543 struct value
*mark
= value_mark ();
2544 int i
= !value_true (evaluate_expression ((struct expression
*) exp
));
2545 value_free_to_mark (mark
);
2549 /* Allocate a new bpstat and chain it to the current one. */
2552 bpstat_alloc (const struct bp_location
*bl
, bpstat cbs
/* Current "bs" value */ )
2556 bs
= (bpstat
) xmalloc (sizeof (*bs
));
2558 bs
->breakpoint_at
= bl
;
2559 /* If the condition is false, etc., don't do the commands. */
2560 bs
->commands
= NULL
;
2562 bs
->print_it
= print_it_normal
;
2566 /* The target has stopped with waitstatus WS. Check if any hardware
2567 watchpoints have triggered, according to the target. */
2570 watchpoints_triggered (struct target_waitstatus
*ws
)
2572 int stopped_by_watchpoint
= STOPPED_BY_WATCHPOINT (*ws
);
2574 struct breakpoint
*b
;
2576 if (!stopped_by_watchpoint
)
2578 /* We were not stopped by a watchpoint. Mark all watchpoints
2579 as not triggered. */
2581 if (b
->type
== bp_hardware_watchpoint
2582 || b
->type
== bp_read_watchpoint
2583 || b
->type
== bp_access_watchpoint
)
2584 b
->watchpoint_triggered
= watch_triggered_no
;
2589 if (!target_stopped_data_address (¤t_target
, &addr
))
2591 /* We were stopped by a watchpoint, but we don't know where.
2592 Mark all watchpoints as unknown. */
2594 if (b
->type
== bp_hardware_watchpoint
2595 || b
->type
== bp_read_watchpoint
2596 || b
->type
== bp_access_watchpoint
)
2597 b
->watchpoint_triggered
= watch_triggered_unknown
;
2599 return stopped_by_watchpoint
;
2602 /* The target could report the data address. Mark watchpoints
2603 affected by this data address as triggered, and all others as not
2607 if (b
->type
== bp_hardware_watchpoint
2608 || b
->type
== bp_read_watchpoint
2609 || b
->type
== bp_access_watchpoint
)
2611 struct bp_location
*loc
;
2614 b
->watchpoint_triggered
= watch_triggered_no
;
2615 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
2616 /* Exact match not required. Within range is
2618 if (addr
>= loc
->address
2619 && addr
< loc
->address
+ loc
->length
)
2621 b
->watchpoint_triggered
= watch_triggered_yes
;
2629 /* Possible return values for watchpoint_check (this can't be an enum
2630 because of check_errors). */
2631 /* The watchpoint has been deleted. */
2632 #define WP_DELETED 1
2633 /* The value has changed. */
2634 #define WP_VALUE_CHANGED 2
2635 /* The value has not changed. */
2636 #define WP_VALUE_NOT_CHANGED 3
2638 #define BP_TEMPFLAG 1
2639 #define BP_HARDWAREFLAG 2
2641 /* Check watchpoint condition. */
2644 watchpoint_check (void *p
)
2646 bpstat bs
= (bpstat
) p
;
2647 struct breakpoint
*b
;
2648 struct frame_info
*fr
;
2649 int within_current_scope
;
2651 b
= bs
->breakpoint_at
->owner
;
2653 if (b
->exp_valid_block
== NULL
)
2654 within_current_scope
= 1;
2657 /* There is no current frame at this moment. If we're going to have
2658 any chance of handling watchpoints on local variables, we'll need
2659 the frame chain (so we can determine if we're in scope). */
2660 reinit_frame_cache ();
2661 fr
= frame_find_by_id (b
->watchpoint_frame
);
2662 within_current_scope
= (fr
!= NULL
);
2664 /* If we've gotten confused in the unwinder, we might have
2665 returned a frame that can't describe this variable. */
2666 if (within_current_scope
2667 && block_function (b
->exp_valid_block
) != get_frame_function (fr
))
2668 within_current_scope
= 0;
2670 /* in_function_epilogue_p() returns a non-zero value if we're still
2671 in the function but the stack frame has already been invalidated.
2672 Since we can't rely on the values of local variables after the
2673 stack has been destroyed, we are treating the watchpoint in that
2674 state as `not changed' without further checking.
2676 vinschen/2003-09-04: The former implementation left out the case
2677 that the watchpoint frame couldn't be found by frame_find_by_id()
2678 because the current PC is currently in an epilogue. Calling
2679 gdbarch_in_function_epilogue_p() also when fr == NULL fixes that. */
2680 if ((!within_current_scope
|| fr
== get_current_frame ())
2681 && gdbarch_in_function_epilogue_p (current_gdbarch
, read_pc ()))
2682 return WP_VALUE_NOT_CHANGED
;
2683 if (fr
&& within_current_scope
)
2684 /* If we end up stopping, the current frame will get selected
2685 in normal_stop. So this call to select_frame won't affect
2690 if (within_current_scope
)
2692 /* We use value_{,free_to_}mark because it could be a
2693 *long* time before we return to the command level and
2694 call free_all_values. We can't call free_all_values because
2695 we might be in the middle of evaluating a function call. */
2697 struct value
*mark
= value_mark ();
2698 struct value
*new_val
;
2700 fetch_watchpoint_value (b
->exp
, &new_val
, NULL
, NULL
);
2701 if ((b
->val
!= NULL
) != (new_val
!= NULL
)
2702 || (b
->val
!= NULL
&& !value_equal (b
->val
, new_val
)))
2704 if (new_val
!= NULL
)
2706 release_value (new_val
);
2707 value_free_to_mark (mark
);
2709 bs
->old_val
= b
->val
;
2712 /* We will stop here */
2713 return WP_VALUE_CHANGED
;
2717 /* Nothing changed, don't do anything. */
2718 value_free_to_mark (mark
);
2719 /* We won't stop here */
2720 return WP_VALUE_NOT_CHANGED
;
2725 /* This seems like the only logical thing to do because
2726 if we temporarily ignored the watchpoint, then when
2727 we reenter the block in which it is valid it contains
2728 garbage (in the case of a function, it may have two
2729 garbage values, one before and one after the prologue).
2730 So we can't even detect the first assignment to it and
2731 watch after that (since the garbage may or may not equal
2732 the first value assigned). */
2733 /* We print all the stop information in print_it_typical(), but
2734 in this case, by the time we call print_it_typical() this bp
2735 will be deleted already. So we have no choice but print the
2736 information here. */
2737 if (ui_out_is_mi_like_p (uiout
))
2739 (uiout
, "reason", async_reason_lookup (EXEC_ASYNC_WATCHPOINT_SCOPE
));
2740 ui_out_text (uiout
, "\nWatchpoint ");
2741 ui_out_field_int (uiout
, "wpnum", b
->number
);
2742 ui_out_text (uiout
, " deleted because the program has left the block in\n\
2743 which its expression is valid.\n");
2745 if (b
->related_breakpoint
)
2746 b
->related_breakpoint
->disposition
= disp_del_at_next_stop
;
2747 b
->disposition
= disp_del_at_next_stop
;
2753 /* Get a bpstat associated with having just stopped at address
2754 BP_ADDR in thread PTID.
2756 Determine whether we stopped at a breakpoint, etc, or whether we
2757 don't understand this stop. Result is a chain of bpstat's such that:
2759 if we don't understand the stop, the result is a null pointer.
2761 if we understand why we stopped, the result is not null.
2763 Each element of the chain refers to a particular breakpoint or
2764 watchpoint at which we have stopped. (We may have stopped for
2765 several reasons concurrently.)
2767 Each element of the chain has valid next, breakpoint_at,
2768 commands, FIXME??? fields. */
2771 bpstat_stop_status (CORE_ADDR bp_addr
, ptid_t ptid
)
2773 struct breakpoint
*b
= NULL
;
2774 const struct bp_location
*bl
;
2775 /* Root of the chain of bpstat's */
2776 struct bpstats root_bs
[1];
2777 /* Pointer to the last thing in the chain currently. */
2778 bpstat bs
= root_bs
;
2779 int thread_id
= pid_to_thread_id (ptid
);
2781 ALL_BP_LOCATIONS (bl
)
2785 if (!breakpoint_enabled (b
) && b
->enable_state
!= bp_permanent
)
2788 if (b
->type
!= bp_watchpoint
2789 && b
->type
!= bp_hardware_watchpoint
2790 && b
->type
!= bp_read_watchpoint
2791 && b
->type
!= bp_access_watchpoint
2792 && b
->type
!= bp_hardware_breakpoint
2793 && b
->type
!= bp_catch_fork
2794 && b
->type
!= bp_catch_vfork
2795 && b
->type
!= bp_catch_exec
) /* a non-watchpoint bp */
2797 if (bl
->address
!= bp_addr
) /* address doesn't match */
2799 if (overlay_debugging
/* unmapped overlay section */
2800 && section_is_overlay (bl
->section
)
2801 && !section_is_mapped (bl
->section
))
2805 /* Continuable hardware watchpoints are treated as non-existent if the
2806 reason we stopped wasn't a hardware watchpoint (we didn't stop on
2807 some data address). Otherwise gdb won't stop on a break instruction
2808 in the code (not from a breakpoint) when a hardware watchpoint has
2809 been defined. Also skip watchpoints which we know did not trigger
2810 (did not match the data address). */
2812 if ((b
->type
== bp_hardware_watchpoint
2813 || b
->type
== bp_read_watchpoint
2814 || b
->type
== bp_access_watchpoint
)
2815 && b
->watchpoint_triggered
== watch_triggered_no
)
2818 if (b
->type
== bp_hardware_breakpoint
)
2820 if (bl
->address
!= bp_addr
)
2822 if (overlay_debugging
/* unmapped overlay section */
2823 && section_is_overlay (bl
->section
)
2824 && !section_is_mapped (bl
->section
))
2828 /* Is this a catchpoint of a load or unload? If so, did we
2829 get a load or unload of the specified library? If not,
2831 if ((b
->type
== bp_catch_load
)
2832 #if defined(SOLIB_HAVE_LOAD_EVENT)
2833 && (!SOLIB_HAVE_LOAD_EVENT (PIDGET (inferior_ptid
))
2834 || ((b
->dll_pathname
!= NULL
)
2835 && (strcmp (b
->dll_pathname
,
2836 SOLIB_LOADED_LIBRARY_PATHNAME (
2837 PIDGET (inferior_ptid
)))
2843 if ((b
->type
== bp_catch_unload
)
2844 #if defined(SOLIB_HAVE_UNLOAD_EVENT)
2845 && (!SOLIB_HAVE_UNLOAD_EVENT (PIDGET (inferior_ptid
))
2846 || ((b
->dll_pathname
!= NULL
)
2847 && (strcmp (b
->dll_pathname
,
2848 SOLIB_UNLOADED_LIBRARY_PATHNAME (
2849 PIDGET (inferior_ptid
)))
2855 if ((b
->type
== bp_catch_fork
)
2856 && !inferior_has_forked (PIDGET (inferior_ptid
),
2857 &b
->forked_inferior_pid
))
2860 if ((b
->type
== bp_catch_vfork
)
2861 && !inferior_has_vforked (PIDGET (inferior_ptid
),
2862 &b
->forked_inferior_pid
))
2865 if ((b
->type
== bp_catch_exec
)
2866 && !inferior_has_execd (PIDGET (inferior_ptid
), &b
->exec_pathname
))
2869 /* For hardware watchpoints, we look only at the first location.
2870 The watchpoint_check function will work on entire expression,
2871 not the individual locations. For read watchopints, the
2872 watchpoints_triggered function have checked all locations
2875 if (b
->type
== bp_hardware_watchpoint
&& bl
!= b
->loc
)
2878 /* Come here if it's a watchpoint, or if the break address matches */
2880 bs
= bpstat_alloc (bl
, bs
); /* Alloc a bpstat to explain stop */
2882 /* Watchpoints may change this, if not found to have triggered. */
2886 if (b
->type
== bp_watchpoint
2887 || b
->type
== bp_read_watchpoint
2888 || b
->type
== bp_access_watchpoint
2889 || b
->type
== bp_hardware_watchpoint
)
2893 int must_check_value
= 0;
2895 if (b
->type
== bp_watchpoint
)
2896 /* For a software watchpoint, we must always check the
2898 must_check_value
= 1;
2899 else if (b
->watchpoint_triggered
== watch_triggered_yes
)
2900 /* We have a hardware watchpoint (read, write, or access)
2901 and the target earlier reported an address watched by
2903 must_check_value
= 1;
2904 else if (b
->watchpoint_triggered
== watch_triggered_unknown
2905 && b
->type
== bp_hardware_watchpoint
)
2906 /* We were stopped by a hardware watchpoint, but the target could
2907 not report the data address. We must check the watchpoint's
2908 value. Access and read watchpoints are out of luck; without
2909 a data address, we can't figure it out. */
2910 must_check_value
= 1;
2912 if (must_check_value
)
2914 char *message
= xstrprintf ("Error evaluating expression for watchpoint %d\n",
2916 struct cleanup
*cleanups
= make_cleanup (xfree
, message
);
2917 int e
= catch_errors (watchpoint_check
, bs
, message
,
2919 do_cleanups (cleanups
);
2923 /* We've already printed what needs to be printed. */
2924 bs
->print_it
= print_it_done
;
2927 case WP_VALUE_CHANGED
:
2928 if (b
->type
== bp_read_watchpoint
)
2930 /* Don't stop: read watchpoints shouldn't fire if
2931 the value has changed. This is for targets
2932 which cannot set read-only watchpoints. */
2933 bs
->print_it
= print_it_noop
;
2939 case WP_VALUE_NOT_CHANGED
:
2940 if (b
->type
== bp_hardware_watchpoint
2941 || b
->type
== bp_watchpoint
)
2943 /* Don't stop: write watchpoints shouldn't fire if
2944 the value hasn't changed. */
2945 bs
->print_it
= print_it_noop
;
2955 /* Error from catch_errors. */
2956 printf_filtered (_("Watchpoint %d deleted.\n"), b
->number
);
2957 if (b
->related_breakpoint
)
2958 b
->related_breakpoint
->disposition
= disp_del_at_next_stop
;
2959 b
->disposition
= disp_del_at_next_stop
;
2960 /* We've already printed what needs to be printed. */
2961 bs
->print_it
= print_it_done
;
2965 else /* must_check_value == 0 */
2967 /* This is a case where some watchpoint(s) triggered, but
2968 not at the address of this watchpoint, or else no
2969 watchpoint triggered after all. So don't print
2970 anything for this watchpoint. */
2971 bs
->print_it
= print_it_noop
;
2978 /* By definition, an encountered breakpoint is a triggered
2983 if (frame_id_p (b
->frame_id
)
2984 && !frame_id_eq (b
->frame_id
, get_frame_id (get_current_frame ())))
2988 int value_is_zero
= 0;
2990 /* If this is a scope breakpoint, mark the associated
2991 watchpoint as triggered so that we will handle the
2992 out-of-scope event. We'll get to the watchpoint next
2994 if (b
->type
== bp_watchpoint_scope
)
2995 b
->related_breakpoint
->watchpoint_triggered
= watch_triggered_yes
;
2997 if (bl
->cond
&& bl
->owner
->disposition
!= disp_del_at_next_stop
)
2999 /* Need to select the frame, with all that implies
3000 so that the conditions will have the right context. */
3001 select_frame (get_current_frame ());
3003 = catch_errors (breakpoint_cond_eval
, (bl
->cond
),
3004 "Error in testing breakpoint condition:\n",
3006 /* FIXME-someday, should give breakpoint # */
3009 if (bl
->cond
&& value_is_zero
)
3012 /* Don't consider this a hit. */
3015 else if (b
->thread
!= -1 && b
->thread
!= thread_id
)
3018 /* Don't consider this a hit. */
3021 else if (b
->ignore_count
> 0)
3024 annotate_ignore_count_change ();
3027 else if (b
->type
== bp_thread_event
|| b
->type
== bp_overlay_event
)
3028 /* We do not stop for these. */
3032 /* We will stop here */
3033 if (b
->disposition
== disp_disable
)
3035 b
->enable_state
= bp_disabled
;
3036 update_global_location_list ();
3040 bs
->commands
= b
->commands
;
3042 (strcmp ("silent", bs
->commands
->line
) == 0
3043 || (xdb_commands
&& strcmp ("Q", bs
->commands
->line
) == 0)))
3045 bs
->commands
= bs
->commands
->next
;
3048 bs
->commands
= copy_command_lines (bs
->commands
);
3051 /* Print nothing for this entry if we dont stop or if we dont print. */
3052 if (bs
->stop
== 0 || bs
->print
== 0)
3053 bs
->print_it
= print_it_noop
;
3056 bs
->next
= NULL
; /* Terminate the chain */
3057 bs
= root_bs
->next
; /* Re-grab the head of the chain */
3059 /* If we aren't stopping, the value of some hardware watchpoint may
3060 not have changed, but the intermediate memory locations we are
3061 watching may have. Don't bother if we're stopping; this will get
3063 for (bs
= root_bs
->next
; bs
!= NULL
; bs
= bs
->next
)
3068 for (bs
= root_bs
->next
; bs
!= NULL
; bs
= bs
->next
)
3070 && (bs
->breakpoint_at
->owner
->type
== bp_hardware_watchpoint
3071 || bs
->breakpoint_at
->owner
->type
== bp_read_watchpoint
3072 || bs
->breakpoint_at
->owner
->type
== bp_access_watchpoint
))
3074 /* remove/insert can invalidate bs->breakpoint_at, if this
3075 location is no longer used by the watchpoint. Prevent
3076 further code from trying to use it. */
3077 bs
->breakpoint_at
= NULL
;
3078 remove_breakpoints ();
3079 insert_breakpoints ();
3083 return root_bs
->next
;
3086 /* Tell what to do about this bpstat. */
3088 bpstat_what (bpstat bs
)
3090 /* Classify each bpstat as one of the following. */
3093 /* This bpstat element has no effect on the main_action. */
3096 /* There was a watchpoint, stop but don't print. */
3099 /* There was a watchpoint, stop and print. */
3102 /* There was a breakpoint but we're not stopping. */
3105 /* There was a breakpoint, stop but don't print. */
3108 /* There was a breakpoint, stop and print. */
3111 /* We hit the longjmp breakpoint. */
3114 /* We hit the longjmp_resume breakpoint. */
3117 /* We hit the step_resume breakpoint. */
3120 /* We hit the shared library event breakpoint. */
3123 /* We caught a shared library event. */
3126 /* This is just used to count how many enums there are. */
3130 /* Here is the table which drives this routine. So that we can
3131 format it pretty, we define some abbreviations for the
3132 enum bpstat_what codes. */
3133 #define kc BPSTAT_WHAT_KEEP_CHECKING
3134 #define ss BPSTAT_WHAT_STOP_SILENT
3135 #define sn BPSTAT_WHAT_STOP_NOISY
3136 #define sgl BPSTAT_WHAT_SINGLE
3137 #define slr BPSTAT_WHAT_SET_LONGJMP_RESUME
3138 #define clr BPSTAT_WHAT_CLEAR_LONGJMP_RESUME
3139 #define clrs BPSTAT_WHAT_CLEAR_LONGJMP_RESUME_SINGLE
3140 #define sr BPSTAT_WHAT_STEP_RESUME
3141 #define shl BPSTAT_WHAT_CHECK_SHLIBS
3142 #define shlr BPSTAT_WHAT_CHECK_SHLIBS_RESUME_FROM_HOOK
3144 /* "Can't happen." Might want to print an error message.
3145 abort() is not out of the question, but chances are GDB is just
3146 a bit confused, not unusable. */
3147 #define err BPSTAT_WHAT_STOP_NOISY
3149 /* Given an old action and a class, come up with a new action. */
3150 /* One interesting property of this table is that wp_silent is the same
3151 as bp_silent and wp_noisy is the same as bp_noisy. That is because
3152 after stopping, the check for whether to step over a breakpoint
3153 (BPSTAT_WHAT_SINGLE type stuff) is handled in proceed() without
3154 reference to how we stopped. We retain separate wp_silent and
3155 bp_silent codes in case we want to change that someday.
3157 Another possibly interesting property of this table is that
3158 there's a partial ordering, priority-like, of the actions. Once
3159 you've decided that some action is appropriate, you'll never go
3160 back and decide something of a lower priority is better. The
3163 kc < clr sgl shl shlr slr sn sr ss
3164 sgl < clrs shl shlr slr sn sr ss
3165 slr < err shl shlr sn sr ss
3166 clr < clrs err shl shlr sn sr ss
3167 clrs < err shl shlr sn sr ss
3174 What I think this means is that we don't need a damned table
3175 here. If you just put the rows and columns in the right order,
3176 it'd look awfully regular. We could simply walk the bpstat list
3177 and choose the highest priority action we find, with a little
3178 logic to handle the 'err' cases, and the CLEAR_LONGJMP_RESUME/
3179 CLEAR_LONGJMP_RESUME_SINGLE distinction (which breakpoint.h says
3180 is messy anyway). */
3182 /* step_resume entries: a step resume breakpoint overrides another
3183 breakpoint of signal handling (see comment in wait_for_inferior
3184 at where we set the step_resume breakpoint). */
3186 static const enum bpstat_what_main_action
3187 table
[(int) class_last
][(int) BPSTAT_WHAT_LAST
] =
3190 /* kc ss sn sgl slr clr clrs sr shl shlr
3193 {kc
, ss
, sn
, sgl
, slr
, clr
, clrs
, sr
, shl
, shlr
},
3195 {ss
, ss
, sn
, ss
, ss
, ss
, ss
, sr
, shl
, shlr
},
3197 {sn
, sn
, sn
, sn
, sn
, sn
, sn
, sr
, shl
, shlr
},
3199 {sgl
, ss
, sn
, sgl
, slr
, clrs
, clrs
, sr
, shl
, shlr
},
3201 {ss
, ss
, sn
, ss
, ss
, ss
, ss
, sr
, shl
, shlr
},
3203 {sn
, sn
, sn
, sn
, sn
, sn
, sn
, sr
, shl
, shlr
},
3205 {slr
, ss
, sn
, slr
, slr
, err
, err
, sr
, shl
, shlr
},
3207 {clr
, ss
, sn
, clrs
, err
, err
, err
, sr
, shl
, shlr
},
3209 {sr
, sr
, sr
, sr
, sr
, sr
, sr
, sr
, sr
, sr
},
3211 {shl
, shl
, shl
, shl
, shl
, shl
, shl
, sr
, shl
, shlr
},
3213 {shlr
, shlr
, shlr
, shlr
, shlr
, shlr
, shlr
, sr
, shlr
, shlr
}
3228 enum bpstat_what_main_action current_action
= BPSTAT_WHAT_KEEP_CHECKING
;
3229 struct bpstat_what retval
;
3231 retval
.call_dummy
= 0;
3232 for (; bs
!= NULL
; bs
= bs
->next
)
3234 enum class bs_class
= no_effect
;
3235 if (bs
->breakpoint_at
== NULL
)
3236 /* I suspect this can happen if it was a momentary breakpoint
3237 which has since been deleted. */
3239 switch (bs
->breakpoint_at
->owner
->type
)
3245 case bp_hardware_breakpoint
:
3251 bs_class
= bp_noisy
;
3253 bs_class
= bp_silent
;
3256 bs_class
= bp_nostop
;
3259 case bp_hardware_watchpoint
:
3260 case bp_read_watchpoint
:
3261 case bp_access_watchpoint
:
3265 bs_class
= wp_noisy
;
3267 bs_class
= wp_silent
;
3270 /* There was a watchpoint, but we're not stopping.
3271 This requires no further action. */
3272 bs_class
= no_effect
;
3275 bs_class
= long_jump
;
3277 case bp_longjmp_resume
:
3278 bs_class
= long_resume
;
3280 case bp_step_resume
:
3283 bs_class
= step_resume
;
3286 /* It is for the wrong frame. */
3287 bs_class
= bp_nostop
;
3289 case bp_watchpoint_scope
:
3290 bs_class
= bp_nostop
;
3292 case bp_shlib_event
:
3293 bs_class
= shlib_event
;
3295 case bp_thread_event
:
3296 case bp_overlay_event
:
3297 bs_class
= bp_nostop
;
3300 case bp_catch_unload
:
3301 /* Only if this catchpoint triggered should we cause the
3302 step-out-of-dld behaviour. Otherwise, we ignore this
3305 bs_class
= catch_shlib_event
;
3307 bs_class
= no_effect
;
3310 case bp_catch_vfork
:
3315 bs_class
= bp_noisy
;
3317 bs_class
= bp_silent
;
3320 /* There was a catchpoint, but we're not stopping.
3321 This requires no further action. */
3322 bs_class
= no_effect
;
3325 /* Make sure the action is stop (silent or noisy),
3326 so infrun.c pops the dummy frame. */
3327 bs_class
= bp_silent
;
3328 retval
.call_dummy
= 1;
3331 current_action
= table
[(int) bs_class
][(int) current_action
];
3333 retval
.main_action
= current_action
;
3337 /* Nonzero if we should step constantly (e.g. watchpoints on machines
3338 without hardware support). This isn't related to a specific bpstat,
3339 just to things like whether watchpoints are set. */
3342 bpstat_should_step (void)
3344 struct breakpoint
*b
;
3346 if (breakpoint_enabled (b
) && b
->type
== bp_watchpoint
)
3353 /* Given a bpstat that records zero or more triggered eventpoints, this
3354 function returns another bpstat which contains only the catchpoints
3355 on that first list, if any. */
3357 bpstat_get_triggered_catchpoints (bpstat ep_list
, bpstat
*cp_list
)
3359 struct bpstats root_bs
[1];
3360 bpstat bs
= root_bs
;
3361 struct breakpoint
*ep
;
3364 bpstat_clear (cp_list
);
3365 root_bs
->next
= NULL
;
3367 for (; ep_list
!= NULL
; ep_list
= ep_list
->next
)
3369 /* Is this eventpoint a catchpoint? If not, ignore it. */
3370 ep
= ep_list
->breakpoint_at
->owner
;
3373 if ((ep
->type
!= bp_catch_load
) &&
3374 (ep
->type
!= bp_catch_unload
))
3375 /* pai: (temp) ADD fork/vfork here!! */
3378 /* Yes; add it to the list. */
3379 bs
= bpstat_alloc (ep_list
->breakpoint_at
, bs
);
3384 #if defined(SOLIB_ADD)
3385 /* Also, for each triggered catchpoint, tag it with the name of
3386 the library that caused this trigger. (We copy the name now,
3387 because it's only guaranteed to be available NOW, when the
3388 catchpoint triggers. Clients who may wish to know the name
3389 later must get it from the catchpoint itself.) */
3390 if (ep
->triggered_dll_pathname
!= NULL
)
3391 xfree (ep
->triggered_dll_pathname
);
3392 if (ep
->type
== bp_catch_load
)
3393 dll_pathname
= SOLIB_LOADED_LIBRARY_PATHNAME (
3394 PIDGET (inferior_ptid
));
3396 dll_pathname
= SOLIB_UNLOADED_LIBRARY_PATHNAME (
3397 PIDGET (inferior_ptid
));
3399 dll_pathname
= NULL
;
3403 ep
->triggered_dll_pathname
= (char *)
3404 xmalloc (strlen (dll_pathname
) + 1);
3405 strcpy (ep
->triggered_dll_pathname
, dll_pathname
);
3408 ep
->triggered_dll_pathname
= NULL
;
3414 static void print_breakpoint_location (struct breakpoint
*b
,
3415 struct bp_location
*loc
,
3417 struct ui_stream
*stb
)
3422 = find_pc_sect_function (loc
->address
, loc
->section
);
3425 ui_out_text (uiout
, "in ");
3426 ui_out_field_string (uiout
, "func",
3427 SYMBOL_PRINT_NAME (sym
));
3428 ui_out_wrap_hint (uiout
, wrap_indent
);
3429 ui_out_text (uiout
, " at ");
3431 ui_out_field_string (uiout
, "file", b
->source_file
);
3432 ui_out_text (uiout
, ":");
3434 if (ui_out_is_mi_like_p (uiout
))
3436 struct symtab_and_line sal
= find_pc_line (loc
->address
, 0);
3437 char *fullname
= symtab_to_fullname (sal
.symtab
);
3440 ui_out_field_string (uiout
, "fullname", fullname
);
3443 ui_out_field_int (uiout
, "line", b
->line_number
);
3447 ui_out_field_string (uiout
, "pending", b
->addr_string
);
3451 print_address_symbolic (loc
->address
, stb
->stream
, demangle
, "");
3452 ui_out_field_stream (uiout
, "at", stb
);
3456 /* Print B to gdb_stdout. */
3458 print_one_breakpoint_location (struct breakpoint
*b
,
3459 struct bp_location
*loc
,
3461 CORE_ADDR
*last_addr
)
3463 struct command_line
*l
;
3465 struct ep_type_description
3470 static struct ep_type_description bptypes
[] =
3472 {bp_none
, "?deleted?"},
3473 {bp_breakpoint
, "breakpoint"},
3474 {bp_hardware_breakpoint
, "hw breakpoint"},
3475 {bp_until
, "until"},
3476 {bp_finish
, "finish"},
3477 {bp_watchpoint
, "watchpoint"},
3478 {bp_hardware_watchpoint
, "hw watchpoint"},
3479 {bp_read_watchpoint
, "read watchpoint"},
3480 {bp_access_watchpoint
, "acc watchpoint"},
3481 {bp_longjmp
, "longjmp"},
3482 {bp_longjmp_resume
, "longjmp resume"},
3483 {bp_step_resume
, "step resume"},
3484 {bp_watchpoint_scope
, "watchpoint scope"},
3485 {bp_call_dummy
, "call dummy"},
3486 {bp_shlib_event
, "shlib events"},
3487 {bp_thread_event
, "thread events"},
3488 {bp_overlay_event
, "overlay events"},
3489 {bp_catch_load
, "catch load"},
3490 {bp_catch_unload
, "catch unload"},
3491 {bp_catch_fork
, "catch fork"},
3492 {bp_catch_vfork
, "catch vfork"},
3493 {bp_catch_exec
, "catch exec"}
3496 static char bpenables
[] = "nynny";
3497 char wrap_indent
[80];
3498 struct ui_stream
*stb
= ui_out_stream_new (uiout
);
3499 struct cleanup
*old_chain
= make_cleanup_ui_out_stream_delete (stb
);
3500 struct cleanup
*bkpt_chain
;
3502 int header_of_multiple
= 0;
3503 int part_of_multiple
= (loc
!= NULL
);
3505 gdb_assert (!loc
|| loc_number
!= 0);
3506 /* See comment in print_one_breakpoint concerning
3507 treatment of breakpoints with single disabled
3511 && (b
->loc
->next
!= NULL
|| !b
->loc
->enabled
)))
3512 header_of_multiple
= 1;
3517 bkpt_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "bkpt");
3521 if (part_of_multiple
)
3524 formatted
= xstrprintf ("%d.%d", b
->number
, loc_number
);
3525 ui_out_field_string (uiout
, "number", formatted
);
3530 ui_out_field_int (uiout
, "number", b
->number
);
3535 if (part_of_multiple
)
3536 ui_out_field_skip (uiout
, "type");
3539 if (((int) b
->type
>= (sizeof (bptypes
) / sizeof (bptypes
[0])))
3540 || ((int) b
->type
!= bptypes
[(int) b
->type
].type
))
3541 internal_error (__FILE__
, __LINE__
,
3542 _("bptypes table does not describe type #%d."),
3544 ui_out_field_string (uiout
, "type", bptypes
[(int) b
->type
].description
);
3549 if (part_of_multiple
)
3550 ui_out_field_skip (uiout
, "disp");
3552 ui_out_field_string (uiout
, "disp", bpdisp_text (b
->disposition
));
3557 if (part_of_multiple
)
3558 ui_out_field_string (uiout
, "enabled", loc
->enabled
? "y" : "n");
3560 ui_out_field_fmt (uiout
, "enabled", "%c",
3561 bpenables
[(int) b
->enable_state
]);
3562 ui_out_spaces (uiout
, 2);
3566 strcpy (wrap_indent
, " ");
3569 if (gdbarch_addr_bit (current_gdbarch
) <= 32)
3570 strcat (wrap_indent
, " ");
3572 strcat (wrap_indent
, " ");
3575 if (b
->ops
!= NULL
&& b
->ops
->print_one
!= NULL
)
3577 /* Although the print_one can possibly print
3578 all locations, calling it here is not likely
3579 to get any nice result. So, make sure there's
3580 just one location. */
3581 gdb_assert (b
->loc
== NULL
|| b
->loc
->next
== NULL
);
3582 b
->ops
->print_one (b
, last_addr
);
3588 internal_error (__FILE__
, __LINE__
,
3589 _("print_one_breakpoint: bp_none encountered\n"));
3593 case bp_hardware_watchpoint
:
3594 case bp_read_watchpoint
:
3595 case bp_access_watchpoint
:
3596 /* Field 4, the address, is omitted (which makes the columns
3597 not line up too nicely with the headers, but the effect
3598 is relatively readable). */
3600 ui_out_field_skip (uiout
, "addr");
3602 print_expression (b
->exp
, stb
->stream
);
3603 ui_out_field_stream (uiout
, "what", stb
);
3607 case bp_catch_unload
:
3608 /* Field 4, the address, is omitted (which makes the columns
3609 not line up too nicely with the headers, but the effect
3610 is relatively readable). */
3612 ui_out_field_skip (uiout
, "addr");
3614 if (b
->dll_pathname
== NULL
)
3616 ui_out_field_string (uiout
, "what", "<any library>");
3617 ui_out_spaces (uiout
, 1);
3621 ui_out_text (uiout
, "library \"");
3622 ui_out_field_string (uiout
, "what", b
->dll_pathname
);
3623 ui_out_text (uiout
, "\" ");
3628 case bp_catch_vfork
:
3629 /* Field 4, the address, is omitted (which makes the columns
3630 not line up too nicely with the headers, but the effect
3631 is relatively readable). */
3633 ui_out_field_skip (uiout
, "addr");
3635 if (b
->forked_inferior_pid
!= 0)
3637 ui_out_text (uiout
, "process ");
3638 ui_out_field_int (uiout
, "what", b
->forked_inferior_pid
);
3639 ui_out_spaces (uiout
, 1);
3644 /* Field 4, the address, is omitted (which makes the columns
3645 not line up too nicely with the headers, but the effect
3646 is relatively readable). */
3648 ui_out_field_skip (uiout
, "addr");
3650 if (b
->exec_pathname
!= NULL
)
3652 ui_out_text (uiout
, "program \"");
3653 ui_out_field_string (uiout
, "what", b
->exec_pathname
);
3654 ui_out_text (uiout
, "\" ");
3659 case bp_hardware_breakpoint
:
3663 case bp_longjmp_resume
:
3664 case bp_step_resume
:
3665 case bp_watchpoint_scope
:
3667 case bp_shlib_event
:
3668 case bp_thread_event
:
3669 case bp_overlay_event
:
3673 if (header_of_multiple
)
3674 ui_out_field_string (uiout
, "addr", "<MULTIPLE>");
3675 else if (b
->loc
== NULL
|| loc
->shlib_disabled
)
3676 ui_out_field_string (uiout
, "addr", "<PENDING>");
3678 ui_out_field_core_addr (uiout
, "addr", loc
->address
);
3681 if (!header_of_multiple
)
3682 print_breakpoint_location (b
, loc
, wrap_indent
, stb
);
3684 *last_addr
= b
->loc
->address
;
3688 if (!part_of_multiple
&& b
->thread
!= -1)
3690 /* FIXME: This seems to be redundant and lost here; see the
3691 "stop only in" line a little further down. */
3692 ui_out_text (uiout
, " thread ");
3693 ui_out_field_int (uiout
, "thread", b
->thread
);
3696 ui_out_text (uiout
, "\n");
3698 if (part_of_multiple
&& frame_id_p (b
->frame_id
))
3701 ui_out_text (uiout
, "\tstop only in stack frame at ");
3702 /* FIXME: cagney/2002-12-01: Shouldn't be poeking around inside
3704 ui_out_field_core_addr (uiout
, "frame", b
->frame_id
.stack_addr
);
3705 ui_out_text (uiout
, "\n");
3708 if (!part_of_multiple
&& b
->cond_string
&& !ada_exception_catchpoint_p (b
))
3710 /* We do not print the condition for Ada exception catchpoints
3711 because the condition is an internal implementation detail
3712 that we do not want to expose to the user. */
3714 ui_out_text (uiout
, "\tstop only if ");
3715 ui_out_field_string (uiout
, "cond", b
->cond_string
);
3716 ui_out_text (uiout
, "\n");
3719 if (!part_of_multiple
&& b
->thread
!= -1)
3721 /* FIXME should make an annotation for this */
3722 ui_out_text (uiout
, "\tstop only in thread ");
3723 ui_out_field_int (uiout
, "thread", b
->thread
);
3724 ui_out_text (uiout
, "\n");
3727 if (!part_of_multiple
&& show_breakpoint_hit_counts
&& b
->hit_count
)
3729 /* FIXME should make an annotation for this */
3730 if (ep_is_catchpoint (b
))
3731 ui_out_text (uiout
, "\tcatchpoint");
3733 ui_out_text (uiout
, "\tbreakpoint");
3734 ui_out_text (uiout
, " already hit ");
3735 ui_out_field_int (uiout
, "times", b
->hit_count
);
3736 if (b
->hit_count
== 1)
3737 ui_out_text (uiout
, " time\n");
3739 ui_out_text (uiout
, " times\n");
3742 /* Output the count also if it is zero, but only if this is
3743 mi. FIXME: Should have a better test for this. */
3744 if (ui_out_is_mi_like_p (uiout
))
3745 if (!part_of_multiple
&& show_breakpoint_hit_counts
&& b
->hit_count
== 0)
3746 ui_out_field_int (uiout
, "times", b
->hit_count
);
3748 if (!part_of_multiple
&& b
->ignore_count
)
3751 ui_out_text (uiout
, "\tignore next ");
3752 ui_out_field_int (uiout
, "ignore", b
->ignore_count
);
3753 ui_out_text (uiout
, " hits\n");
3756 if (!part_of_multiple
&& (l
= b
->commands
))
3758 struct cleanup
*script_chain
;
3761 script_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "script");
3762 print_command_lines (uiout
, l
, 4);
3763 do_cleanups (script_chain
);
3766 if (ui_out_is_mi_like_p (uiout
) && !part_of_multiple
)
3769 ui_out_field_string (uiout
, "original-location", b
->addr_string
);
3770 else if (b
->exp_string
)
3771 ui_out_field_string (uiout
, "original-location", b
->exp_string
);
3774 do_cleanups (bkpt_chain
);
3775 do_cleanups (old_chain
);
3779 print_one_breakpoint (struct breakpoint
*b
,
3780 CORE_ADDR
*last_addr
)
3782 print_one_breakpoint_location (b
, NULL
, 0, last_addr
);
3784 /* If this breakpoint has custom print function,
3785 it's already printed. Otherwise, print individual
3786 locations, if any. */
3787 if (b
->ops
== NULL
|| b
->ops
->print_one
== NULL
)
3789 /* If breakpoint has a single location that is
3790 disabled, we print it as if it had
3791 several locations, since otherwise it's hard to
3792 represent "breakpoint enabled, location disabled"
3794 Note that while hardware watchpoints have
3795 several locations internally, that's no a property
3798 && !is_hardware_watchpoint (b
)
3799 && (b
->loc
->next
|| !b
->loc
->enabled
)
3800 && !ui_out_is_mi_like_p (uiout
))
3802 struct bp_location
*loc
;
3804 for (loc
= b
->loc
; loc
; loc
= loc
->next
, ++n
)
3805 print_one_breakpoint_location (b
, loc
, n
, last_addr
);
3811 struct captured_breakpoint_query_args
3817 do_captured_breakpoint_query (struct ui_out
*uiout
, void *data
)
3819 struct captured_breakpoint_query_args
*args
= data
;
3820 struct breakpoint
*b
;
3821 CORE_ADDR dummy_addr
= 0;
3824 if (args
->bnum
== b
->number
)
3826 print_one_breakpoint (b
, &dummy_addr
);
3834 gdb_breakpoint_query (struct ui_out
*uiout
, int bnum
, char **error_message
)
3836 struct captured_breakpoint_query_args args
;
3838 /* For the moment we don't trust print_one_breakpoint() to not throw
3840 if (catch_exceptions_with_msg (uiout
, do_captured_breakpoint_query
, &args
,
3841 error_message
, RETURN_MASK_ALL
) < 0)
3847 /* Return non-zero if B is user settable (breakpoints, watchpoints,
3848 catchpoints, et.al.). */
3851 user_settable_breakpoint (const struct breakpoint
*b
)
3853 return (b
->type
== bp_breakpoint
3854 || b
->type
== bp_catch_load
3855 || b
->type
== bp_catch_unload
3856 || b
->type
== bp_catch_fork
3857 || b
->type
== bp_catch_vfork
3858 || b
->type
== bp_catch_exec
3859 || b
->type
== bp_hardware_breakpoint
3860 || b
->type
== bp_watchpoint
3861 || b
->type
== bp_read_watchpoint
3862 || b
->type
== bp_access_watchpoint
3863 || b
->type
== bp_hardware_watchpoint
);
3866 /* Print information on user settable breakpoint (watchpoint, etc)
3867 number BNUM. If BNUM is -1 print all user settable breakpoints.
3868 If ALLFLAG is non-zero, include non- user settable breakpoints. */
3871 breakpoint_1 (int bnum
, int allflag
)
3873 struct breakpoint
*b
;
3874 CORE_ADDR last_addr
= (CORE_ADDR
) -1;
3875 int nr_printable_breakpoints
;
3876 struct cleanup
*bkpttbl_chain
;
3878 /* Compute the number of rows in the table. */
3879 nr_printable_breakpoints
= 0;
3882 || bnum
== b
->number
)
3884 if (allflag
|| user_settable_breakpoint (b
))
3885 nr_printable_breakpoints
++;
3890 = make_cleanup_ui_out_table_begin_end (uiout
, 6, nr_printable_breakpoints
,
3894 = make_cleanup_ui_out_table_begin_end (uiout
, 5, nr_printable_breakpoints
,
3897 if (nr_printable_breakpoints
> 0)
3898 annotate_breakpoints_headers ();
3899 if (nr_printable_breakpoints
> 0)
3901 ui_out_table_header (uiout
, 7, ui_left
, "number", "Num"); /* 1 */
3902 if (nr_printable_breakpoints
> 0)
3904 ui_out_table_header (uiout
, 14, ui_left
, "type", "Type"); /* 2 */
3905 if (nr_printable_breakpoints
> 0)
3907 ui_out_table_header (uiout
, 4, ui_left
, "disp", "Disp"); /* 3 */
3908 if (nr_printable_breakpoints
> 0)
3910 ui_out_table_header (uiout
, 3, ui_left
, "enabled", "Enb"); /* 4 */
3913 if (nr_printable_breakpoints
> 0)
3915 if (gdbarch_addr_bit (current_gdbarch
) <= 32)
3916 ui_out_table_header (uiout
, 10, ui_left
, "addr", "Address");/* 5 */
3918 ui_out_table_header (uiout
, 18, ui_left
, "addr", "Address");/* 5 */
3920 if (nr_printable_breakpoints
> 0)
3922 ui_out_table_header (uiout
, 40, ui_noalign
, "what", "What"); /* 6 */
3923 ui_out_table_body (uiout
);
3924 if (nr_printable_breakpoints
> 0)
3925 annotate_breakpoints_table ();
3929 || bnum
== b
->number
)
3931 /* We only print out user settable breakpoints unless the
3933 if (allflag
|| user_settable_breakpoint (b
))
3934 print_one_breakpoint (b
, &last_addr
);
3937 do_cleanups (bkpttbl_chain
);
3939 if (nr_printable_breakpoints
== 0)
3942 ui_out_message (uiout
, 0, "No breakpoints or watchpoints.\n");
3944 ui_out_message (uiout
, 0, "No breakpoint or watchpoint number %d.\n",
3949 /* Compare against (CORE_ADDR)-1 in case some compiler decides
3950 that a comparison of an unsigned with -1 is always false. */
3951 if (last_addr
!= (CORE_ADDR
) -1 && !server_command
)
3952 set_next_address (last_addr
);
3955 /* FIXME? Should this be moved up so that it is only called when
3956 there have been breakpoints? */
3957 annotate_breakpoints_table_end ();
3961 breakpoints_info (char *bnum_exp
, int from_tty
)
3966 bnum
= parse_and_eval_long (bnum_exp
);
3968 breakpoint_1 (bnum
, 0);
3972 maintenance_info_breakpoints (char *bnum_exp
, int from_tty
)
3977 bnum
= parse_and_eval_long (bnum_exp
);
3979 breakpoint_1 (bnum
, 1);
3983 breakpoint_has_pc (struct breakpoint
*b
, CORE_ADDR pc
, asection
*section
)
3985 struct bp_location
*bl
= b
->loc
;
3986 for (; bl
; bl
= bl
->next
)
3988 if (bl
->address
== pc
3989 && (!overlay_debugging
|| bl
->section
== section
))
3995 /* Print a message describing any breakpoints set at PC. */
3998 describe_other_breakpoints (CORE_ADDR pc
, asection
*section
, int thread
)
4001 struct breakpoint
*b
;
4004 others
+= breakpoint_has_pc (b
, pc
, section
);
4008 printf_filtered (_("Note: breakpoint "));
4009 else /* if (others == ???) */
4010 printf_filtered (_("Note: breakpoints "));
4012 if (breakpoint_has_pc (b
, pc
, section
))
4015 printf_filtered ("%d", b
->number
);
4016 if (b
->thread
== -1 && thread
!= -1)
4017 printf_filtered (" (all threads)");
4018 else if (b
->thread
!= -1)
4019 printf_filtered (" (thread %d)", b
->thread
);
4020 printf_filtered ("%s%s ",
4021 ((b
->enable_state
== bp_disabled
||
4022 b
->enable_state
== bp_call_disabled
)
4024 : b
->enable_state
== bp_permanent
4028 : ((others
== 1) ? " and" : ""));
4030 printf_filtered (_("also set at pc "));
4031 fputs_filtered (paddress (pc
), gdb_stdout
);
4032 printf_filtered (".\n");
4036 /* Set the default place to put a breakpoint
4037 for the `break' command with no arguments. */
4040 set_default_breakpoint (int valid
, CORE_ADDR addr
, struct symtab
*symtab
,
4043 default_breakpoint_valid
= valid
;
4044 default_breakpoint_address
= addr
;
4045 default_breakpoint_symtab
= symtab
;
4046 default_breakpoint_line
= line
;
4049 /* Return true iff it is meaningful to use the address member of
4050 BPT. For some breakpoint types, the address member is irrelevant
4051 and it makes no sense to attempt to compare it to other addresses
4052 (or use it for any other purpose either).
4054 More specifically, each of the following breakpoint types will always
4055 have a zero valued address and we don't want check_duplicates() to mark
4056 breakpoints of any of these types to be a duplicate of an actual
4057 breakpoint at address zero:
4060 bp_hardware_watchpoint
4062 bp_access_watchpoint
4069 breakpoint_address_is_meaningful (struct breakpoint
*bpt
)
4071 enum bptype type
= bpt
->type
;
4073 return (type
!= bp_watchpoint
4074 && type
!= bp_hardware_watchpoint
4075 && type
!= bp_read_watchpoint
4076 && type
!= bp_access_watchpoint
4077 && type
!= bp_catch_exec
4078 && type
!= bp_longjmp_resume
4079 && type
!= bp_catch_fork
4080 && type
!= bp_catch_vfork
);
4083 /* Rescan breakpoints at the same address and section as BPT,
4084 marking the first one as "first" and any others as "duplicates".
4085 This is so that the bpt instruction is only inserted once.
4086 If we have a permanent breakpoint at the same place as BPT, make
4087 that one the official one, and the rest as duplicates. */
4090 check_duplicates_for (CORE_ADDR address
, asection
*section
)
4092 struct bp_location
*b
;
4094 struct bp_location
*perm_bp
= 0;
4096 ALL_BP_LOCATIONS (b
)
4097 if (b
->owner
->enable_state
!= bp_disabled
4098 && b
->owner
->enable_state
!= bp_call_disabled
4100 && !b
->shlib_disabled
4101 && b
->address
== address
/* address / overlay match */
4102 && (!overlay_debugging
|| b
->section
== section
)
4103 && breakpoint_address_is_meaningful (b
->owner
))
4105 /* Have we found a permanent breakpoint? */
4106 if (b
->owner
->enable_state
== bp_permanent
)
4113 b
->duplicate
= count
> 1;
4116 /* If we found a permanent breakpoint at this address, go over the
4117 list again and declare all the other breakpoints there to be the
4121 perm_bp
->duplicate
= 0;
4123 /* Permanent breakpoint should always be inserted. */
4124 if (! perm_bp
->inserted
)
4125 internal_error (__FILE__
, __LINE__
,
4126 _("allegedly permanent breakpoint is not "
4127 "actually inserted"));
4129 ALL_BP_LOCATIONS (b
)
4132 if (b
->owner
->enable_state
!= bp_disabled
4133 && b
->owner
->enable_state
!= bp_call_disabled
4134 && b
->enabled
&& !b
->shlib_disabled
4135 && b
->address
== address
/* address / overlay match */
4136 && (!overlay_debugging
|| b
->section
== section
)
4137 && breakpoint_address_is_meaningful (b
->owner
))
4140 internal_error (__FILE__
, __LINE__
,
4141 _("another breakpoint was inserted on top of "
4142 "a permanent breakpoint"));
4151 check_duplicates (struct breakpoint
*bpt
)
4153 struct bp_location
*bl
= bpt
->loc
;
4155 if (! breakpoint_address_is_meaningful (bpt
))
4158 for (; bl
; bl
= bl
->next
)
4159 check_duplicates_for (bl
->address
, bl
->section
);
4163 breakpoint_adjustment_warning (CORE_ADDR from_addr
, CORE_ADDR to_addr
,
4164 int bnum
, int have_bnum
)
4169 strcpy (astr1
, hex_string_custom ((unsigned long) from_addr
, 8));
4170 strcpy (astr2
, hex_string_custom ((unsigned long) to_addr
, 8));
4172 warning (_("Breakpoint %d address previously adjusted from %s to %s."),
4173 bnum
, astr1
, astr2
);
4175 warning (_("Breakpoint address adjusted from %s to %s."), astr1
, astr2
);
4178 /* Adjust a breakpoint's address to account for architectural constraints
4179 on breakpoint placement. Return the adjusted address. Note: Very
4180 few targets require this kind of adjustment. For most targets,
4181 this function is simply the identity function. */
4184 adjust_breakpoint_address (CORE_ADDR bpaddr
, enum bptype bptype
)
4186 if (!gdbarch_adjust_breakpoint_address_p (current_gdbarch
))
4188 /* Very few targets need any kind of breakpoint adjustment. */
4191 else if (bptype
== bp_watchpoint
4192 || bptype
== bp_hardware_watchpoint
4193 || bptype
== bp_read_watchpoint
4194 || bptype
== bp_access_watchpoint
4195 || bptype
== bp_catch_fork
4196 || bptype
== bp_catch_vfork
4197 || bptype
== bp_catch_exec
)
4199 /* Watchpoints and the various bp_catch_* eventpoints should not
4200 have their addresses modified. */
4205 CORE_ADDR adjusted_bpaddr
;
4207 /* Some targets have architectural constraints on the placement
4208 of breakpoint instructions. Obtain the adjusted address. */
4209 adjusted_bpaddr
= gdbarch_adjust_breakpoint_address (current_gdbarch
,
4212 /* An adjusted breakpoint address can significantly alter
4213 a user's expectations. Print a warning if an adjustment
4215 if (adjusted_bpaddr
!= bpaddr
)
4216 breakpoint_adjustment_warning (bpaddr
, adjusted_bpaddr
, 0, 0);
4218 return adjusted_bpaddr
;
4222 /* Allocate a struct bp_location. */
4224 static struct bp_location
*
4225 allocate_bp_location (struct breakpoint
*bpt
, enum bptype bp_type
)
4227 struct bp_location
*loc
, *loc_p
;
4229 loc
= xmalloc (sizeof (struct bp_location
));
4230 memset (loc
, 0, sizeof (*loc
));
4234 loc
->shlib_disabled
= 0;
4243 case bp_longjmp_resume
:
4244 case bp_step_resume
:
4245 case bp_watchpoint_scope
:
4247 case bp_shlib_event
:
4248 case bp_thread_event
:
4249 case bp_overlay_event
:
4251 case bp_catch_unload
:
4252 loc
->loc_type
= bp_loc_software_breakpoint
;
4254 case bp_hardware_breakpoint
:
4255 loc
->loc_type
= bp_loc_hardware_breakpoint
;
4257 case bp_hardware_watchpoint
:
4258 case bp_read_watchpoint
:
4259 case bp_access_watchpoint
:
4260 loc
->loc_type
= bp_loc_hardware_watchpoint
;
4264 case bp_catch_vfork
:
4266 loc
->loc_type
= bp_loc_other
;
4269 internal_error (__FILE__
, __LINE__
, _("unknown breakpoint type"));
4275 static void free_bp_location (struct bp_location
*loc
)
4280 if (loc
->function_name
)
4281 xfree (loc
->function_name
);
4286 /* Helper to set_raw_breakpoint below. Creates a breakpoint
4287 that has type BPTYPE and has no locations as yet. */
4289 static struct breakpoint
*
4290 set_raw_breakpoint_without_location (enum bptype bptype
)
4292 struct breakpoint
*b
, *b1
;
4294 b
= (struct breakpoint
*) xmalloc (sizeof (struct breakpoint
));
4295 memset (b
, 0, sizeof (*b
));
4298 b
->language
= current_language
->la_language
;
4299 b
->input_radix
= input_radix
;
4301 b
->enable_state
= bp_enabled
;
4304 b
->ignore_count
= 0;
4306 b
->frame_id
= null_frame_id
;
4307 b
->dll_pathname
= NULL
;
4308 b
->triggered_dll_pathname
= NULL
;
4309 b
->forked_inferior_pid
= 0;
4310 b
->exec_pathname
= NULL
;
4312 b
->condition_not_parsed
= 0;
4314 /* Add this breakpoint to the end of the chain
4315 so that a list of breakpoints will come out in order
4316 of increasing numbers. */
4318 b1
= breakpoint_chain
;
4320 breakpoint_chain
= b
;
4330 /* Initialize loc->function_name. */
4332 set_breakpoint_location_function (struct bp_location
*loc
)
4334 if (loc
->owner
->type
== bp_breakpoint
4335 || loc
->owner
->type
== bp_hardware_breakpoint
)
4337 find_pc_partial_function (loc
->address
, &(loc
->function_name
),
4339 if (loc
->function_name
)
4340 loc
->function_name
= xstrdup (loc
->function_name
);
4344 /* set_raw_breakpoint is a low level routine for allocating and
4345 partially initializing a breakpoint of type BPTYPE. The newly
4346 created breakpoint's address, section, source file name, and line
4347 number are provided by SAL. The newly created and partially
4348 initialized breakpoint is added to the breakpoint chain and
4349 is also returned as the value of this function.
4351 It is expected that the caller will complete the initialization of
4352 the newly created breakpoint struct as well as output any status
4353 information regarding the creation of a new breakpoint. In
4354 particular, set_raw_breakpoint does NOT set the breakpoint
4355 number! Care should be taken to not allow an error to occur
4356 prior to completing the initialization of the breakpoint. If this
4357 should happen, a bogus breakpoint will be left on the chain. */
4360 set_raw_breakpoint (struct symtab_and_line sal
, enum bptype bptype
)
4362 struct breakpoint
*b
= set_raw_breakpoint_without_location (bptype
);
4363 CORE_ADDR adjusted_address
;
4365 /* Adjust the breakpoint's address prior to allocating a location.
4366 Once we call allocate_bp_location(), that mostly uninitialized
4367 location will be placed on the location chain. Adjustment of the
4368 breakpoint may cause target_read_memory() to be called and we do
4369 not want its scan of the location chain to find a breakpoint and
4370 location that's only been partially initialized. */
4371 adjusted_address
= adjust_breakpoint_address (sal
.pc
, bptype
);
4373 b
->loc
= allocate_bp_location (b
, bptype
);
4374 b
->loc
->requested_address
= sal
.pc
;
4375 b
->loc
->address
= adjusted_address
;
4377 if (sal
.symtab
== NULL
)
4378 b
->source_file
= NULL
;
4380 b
->source_file
= savestring (sal
.symtab
->filename
,
4381 strlen (sal
.symtab
->filename
));
4382 b
->loc
->section
= sal
.section
;
4383 b
->line_number
= sal
.line
;
4385 set_breakpoint_location_function (b
->loc
);
4387 breakpoints_changed ();
4393 /* Note that the breakpoint object B describes a permanent breakpoint
4394 instruction, hard-wired into the inferior's code. */
4396 make_breakpoint_permanent (struct breakpoint
*b
)
4398 struct bp_location
*bl
;
4399 b
->enable_state
= bp_permanent
;
4401 /* By definition, permanent breakpoints are already present in the code.
4402 Mark all locations as inserted. For now, make_breakpoint_permanent
4403 is called in just one place, so it's hard to say if it's reasonable
4404 to have permanent breakpoint with multiple locations or not,
4405 but it's easy to implmement. */
4406 for (bl
= b
->loc
; bl
; bl
= bl
->next
)
4410 static struct breakpoint
*
4411 create_internal_breakpoint (CORE_ADDR address
, enum bptype type
)
4413 static int internal_breakpoint_number
= -1;
4414 struct symtab_and_line sal
;
4415 struct breakpoint
*b
;
4417 init_sal (&sal
); /* initialize to zeroes */
4420 sal
.section
= find_pc_overlay (sal
.pc
);
4422 b
= set_raw_breakpoint (sal
, type
);
4423 b
->number
= internal_breakpoint_number
--;
4424 b
->disposition
= disp_donttouch
;
4431 create_longjmp_breakpoint (char *func_name
)
4433 struct breakpoint
*b
;
4434 struct minimal_symbol
*m
;
4436 if (func_name
== NULL
)
4437 b
= create_internal_breakpoint (0, bp_longjmp_resume
);
4440 if ((m
= lookup_minimal_symbol_text (func_name
, NULL
)) == NULL
)
4443 b
= create_internal_breakpoint (SYMBOL_VALUE_ADDRESS (m
), bp_longjmp
);
4446 b
->enable_state
= bp_disabled
;
4449 b
->addr_string
= xstrdup (func_name
);
4450 update_global_location_list ();
4453 /* Call this routine when stepping and nexting to enable a breakpoint
4454 if we do a longjmp(). When we hit that breakpoint, call
4455 set_longjmp_resume_breakpoint() to figure out where we are going. */
4458 enable_longjmp_breakpoint (void)
4460 struct breakpoint
*b
;
4463 if (b
->type
== bp_longjmp
)
4465 b
->enable_state
= bp_enabled
;
4466 update_global_location_list ();
4471 disable_longjmp_breakpoint (void)
4473 struct breakpoint
*b
;
4476 if (b
->type
== bp_longjmp
4477 || b
->type
== bp_longjmp_resume
)
4479 b
->enable_state
= bp_disabled
;
4480 update_global_location_list ();
4485 create_overlay_event_breakpoint (char *func_name
)
4487 struct breakpoint
*b
;
4488 struct minimal_symbol
*m
;
4490 if ((m
= lookup_minimal_symbol_text (func_name
, NULL
)) == NULL
)
4493 b
= create_internal_breakpoint (SYMBOL_VALUE_ADDRESS (m
),
4495 b
->addr_string
= xstrdup (func_name
);
4497 if (overlay_debugging
== ovly_auto
)
4499 b
->enable_state
= bp_enabled
;
4500 overlay_events_enabled
= 1;
4504 b
->enable_state
= bp_disabled
;
4505 overlay_events_enabled
= 0;
4507 update_global_location_list ();
4511 enable_overlay_breakpoints (void)
4513 struct breakpoint
*b
;
4516 if (b
->type
== bp_overlay_event
)
4518 b
->enable_state
= bp_enabled
;
4519 update_global_location_list ();
4520 overlay_events_enabled
= 1;
4525 disable_overlay_breakpoints (void)
4527 struct breakpoint
*b
;
4530 if (b
->type
== bp_overlay_event
)
4532 b
->enable_state
= bp_disabled
;
4533 update_global_location_list ();
4534 overlay_events_enabled
= 0;
4539 create_thread_event_breakpoint (CORE_ADDR address
)
4541 struct breakpoint
*b
;
4543 b
= create_internal_breakpoint (address
, bp_thread_event
);
4545 b
->enable_state
= bp_enabled
;
4546 /* addr_string has to be used or breakpoint_re_set will delete me. */
4547 b
->addr_string
= xstrprintf ("*0x%s", paddr (b
->loc
->address
));
4549 update_global_location_list_nothrow ();
4555 remove_thread_event_breakpoints (void)
4557 struct breakpoint
*b
, *temp
;
4559 ALL_BREAKPOINTS_SAFE (b
, temp
)
4560 if (b
->type
== bp_thread_event
)
4561 delete_breakpoint (b
);
4564 struct captured_parse_breakpoint_args
4567 struct symtabs_and_lines
*sals_p
;
4568 char ***addr_string_p
;
4572 struct lang_and_radix
4580 remove_solib_event_breakpoints (void)
4582 struct breakpoint
*b
, *temp
;
4584 ALL_BREAKPOINTS_SAFE (b
, temp
)
4585 if (b
->type
== bp_shlib_event
)
4586 delete_breakpoint (b
);
4590 create_solib_event_breakpoint (CORE_ADDR address
)
4592 struct breakpoint
*b
;
4594 b
= create_internal_breakpoint (address
, bp_shlib_event
);
4595 update_global_location_list_nothrow ();
4599 /* Disable any breakpoints that are on code in shared libraries. Only
4600 apply to enabled breakpoints, disabled ones can just stay disabled. */
4603 disable_breakpoints_in_shlibs (void)
4605 struct bp_location
*loc
;
4606 int disabled_shlib_breaks
= 0;
4608 ALL_BP_LOCATIONS (loc
)
4610 struct breakpoint
*b
= loc
->owner
;
4611 /* We apply the check to all breakpoints, including disabled
4612 for those with loc->duplicate set. This is so that when breakpoint
4613 becomes enabled, or the duplicate is removed, gdb will try to insert
4614 all breakpoints. If we don't set shlib_disabled here, we'll try
4615 to insert those breakpoints and fail. */
4616 if (((b
->type
== bp_breakpoint
) || (b
->type
== bp_hardware_breakpoint
))
4617 && !loc
->shlib_disabled
4619 && PC_SOLIB (loc
->address
)
4621 && solib_address (loc
->address
)
4625 loc
->shlib_disabled
= 1;
4630 /* Disable any breakpoints that are in in an unloaded shared library. Only
4631 apply to enabled breakpoints, disabled ones can just stay disabled. */
4634 disable_breakpoints_in_unloaded_shlib (struct so_list
*solib
)
4636 struct bp_location
*loc
;
4637 int disabled_shlib_breaks
= 0;
4639 ALL_BP_LOCATIONS (loc
)
4641 struct breakpoint
*b
= loc
->owner
;
4642 if ((loc
->loc_type
== bp_loc_hardware_breakpoint
4643 || loc
->loc_type
== bp_loc_software_breakpoint
)
4644 && !loc
->shlib_disabled
)
4647 char *so_name
= PC_SOLIB (loc
->address
);
4649 char *so_name
= solib_address (loc
->address
);
4651 if (so_name
&& !strcmp (so_name
, solib
->so_name
))
4653 loc
->shlib_disabled
= 1;
4654 /* At this point, we cannot rely on remove_breakpoint
4655 succeeding so we must mark the breakpoint as not inserted
4656 to prevent future errors occurring in remove_breakpoints. */
4658 if (!disabled_shlib_breaks
)
4660 target_terminal_ours_for_output ();
4661 warning (_("Temporarily disabling breakpoints for unloaded shared library \"%s\""),
4664 disabled_shlib_breaks
= 1;
4671 create_fork_vfork_event_catchpoint (int tempflag
, char *cond_string
,
4672 enum bptype bp_kind
)
4674 struct symtab_and_line sal
;
4675 struct breakpoint
*b
;
4676 int thread
= -1; /* All threads. */
4683 b
= set_raw_breakpoint (sal
, bp_kind
);
4684 set_breakpoint_count (breakpoint_count
+ 1);
4685 b
->number
= breakpoint_count
;
4686 b
->cond_string
= (cond_string
== NULL
) ?
4687 NULL
: savestring (cond_string
, strlen (cond_string
));
4689 b
->addr_string
= NULL
;
4690 b
->enable_state
= bp_enabled
;
4691 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
4692 b
->forked_inferior_pid
= 0;
4693 update_global_location_list ();
4700 create_fork_event_catchpoint (int tempflag
, char *cond_string
)
4702 create_fork_vfork_event_catchpoint (tempflag
, cond_string
, bp_catch_fork
);
4706 create_vfork_event_catchpoint (int tempflag
, char *cond_string
)
4708 create_fork_vfork_event_catchpoint (tempflag
, cond_string
, bp_catch_vfork
);
4712 create_exec_event_catchpoint (int tempflag
, char *cond_string
)
4714 struct symtab_and_line sal
;
4715 struct breakpoint
*b
;
4716 int thread
= -1; /* All threads. */
4723 b
= set_raw_breakpoint (sal
, bp_catch_exec
);
4724 set_breakpoint_count (breakpoint_count
+ 1);
4725 b
->number
= breakpoint_count
;
4726 b
->cond_string
= (cond_string
== NULL
) ?
4727 NULL
: savestring (cond_string
, strlen (cond_string
));
4729 b
->addr_string
= NULL
;
4730 b
->enable_state
= bp_enabled
;
4731 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
4732 update_global_location_list ();
4738 hw_breakpoint_used_count (void)
4740 struct breakpoint
*b
;
4745 if (b
->type
== bp_hardware_breakpoint
&& b
->enable_state
== bp_enabled
)
4753 hw_watchpoint_used_count (enum bptype type
, int *other_type_used
)
4755 struct breakpoint
*b
;
4758 *other_type_used
= 0;
4761 if (breakpoint_enabled (b
))
4763 if (b
->type
== type
)
4765 else if ((b
->type
== bp_hardware_watchpoint
||
4766 b
->type
== bp_read_watchpoint
||
4767 b
->type
== bp_access_watchpoint
))
4768 *other_type_used
= 1;
4774 /* Call this after hitting the longjmp() breakpoint. Use this to set
4775 a new breakpoint at the target of the jmp_buf.
4777 FIXME - This ought to be done by setting a temporary breakpoint
4778 that gets deleted automatically... */
4781 set_longjmp_resume_breakpoint (CORE_ADDR pc
, struct frame_id frame_id
)
4783 struct breakpoint
*b
;
4786 if (b
->type
== bp_longjmp_resume
)
4788 b
->loc
->requested_address
= pc
;
4789 b
->loc
->address
= adjust_breakpoint_address (b
->loc
->requested_address
,
4791 b
->enable_state
= bp_enabled
;
4792 b
->frame_id
= frame_id
;
4793 update_global_location_list ();
4799 disable_watchpoints_before_interactive_call_start (void)
4801 struct breakpoint
*b
;
4805 if (((b
->type
== bp_watchpoint
)
4806 || (b
->type
== bp_hardware_watchpoint
)
4807 || (b
->type
== bp_read_watchpoint
)
4808 || (b
->type
== bp_access_watchpoint
))
4809 && breakpoint_enabled (b
))
4811 b
->enable_state
= bp_call_disabled
;
4812 update_global_location_list ();
4818 enable_watchpoints_after_interactive_call_stop (void)
4820 struct breakpoint
*b
;
4824 if (((b
->type
== bp_watchpoint
)
4825 || (b
->type
== bp_hardware_watchpoint
)
4826 || (b
->type
== bp_read_watchpoint
)
4827 || (b
->type
== bp_access_watchpoint
))
4828 && (b
->enable_state
== bp_call_disabled
))
4830 b
->enable_state
= bp_enabled
;
4831 update_global_location_list ();
4837 /* Set a breakpoint that will evaporate an end of command
4838 at address specified by SAL.
4839 Restrict it to frame FRAME if FRAME is nonzero. */
4842 set_momentary_breakpoint (struct symtab_and_line sal
, struct frame_id frame_id
,
4845 struct breakpoint
*b
;
4846 b
= set_raw_breakpoint (sal
, type
);
4847 b
->enable_state
= bp_enabled
;
4848 b
->disposition
= disp_donttouch
;
4849 b
->frame_id
= frame_id
;
4851 /* If we're debugging a multi-threaded program, then we
4852 want momentary breakpoints to be active in only a
4853 single thread of control. */
4854 if (in_thread_list (inferior_ptid
))
4855 b
->thread
= pid_to_thread_id (inferior_ptid
);
4857 update_global_location_list_nothrow ();
4863 /* Tell the user we have just set a breakpoint B. */
4866 mention (struct breakpoint
*b
)
4869 struct cleanup
*old_chain
, *ui_out_chain
;
4870 struct ui_stream
*stb
;
4872 stb
= ui_out_stream_new (uiout
);
4873 old_chain
= make_cleanup_ui_out_stream_delete (stb
);
4875 /* FIXME: This is misplaced; mention() is called by things (like
4876 hitting a watchpoint) other than breakpoint creation. It should
4877 be possible to clean this up and at the same time replace the
4878 random calls to breakpoint_changed with this hook, as has already
4879 been done for deprecated_delete_breakpoint_hook and so on. */
4880 if (deprecated_create_breakpoint_hook
)
4881 deprecated_create_breakpoint_hook (b
);
4882 breakpoint_create_event (b
->number
);
4884 if (b
->ops
!= NULL
&& b
->ops
->print_mention
!= NULL
)
4885 b
->ops
->print_mention (b
);
4890 printf_filtered (_("(apparently deleted?) Eventpoint %d: "), b
->number
);
4893 ui_out_text (uiout
, "Watchpoint ");
4894 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "wpt");
4895 ui_out_field_int (uiout
, "number", b
->number
);
4896 ui_out_text (uiout
, ": ");
4897 print_expression (b
->exp
, stb
->stream
);
4898 ui_out_field_stream (uiout
, "exp", stb
);
4899 do_cleanups (ui_out_chain
);
4901 case bp_hardware_watchpoint
:
4902 ui_out_text (uiout
, "Hardware watchpoint ");
4903 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "wpt");
4904 ui_out_field_int (uiout
, "number", b
->number
);
4905 ui_out_text (uiout
, ": ");
4906 print_expression (b
->exp
, stb
->stream
);
4907 ui_out_field_stream (uiout
, "exp", stb
);
4908 do_cleanups (ui_out_chain
);
4910 case bp_read_watchpoint
:
4911 ui_out_text (uiout
, "Hardware read watchpoint ");
4912 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "hw-rwpt");
4913 ui_out_field_int (uiout
, "number", b
->number
);
4914 ui_out_text (uiout
, ": ");
4915 print_expression (b
->exp
, stb
->stream
);
4916 ui_out_field_stream (uiout
, "exp", stb
);
4917 do_cleanups (ui_out_chain
);
4919 case bp_access_watchpoint
:
4920 ui_out_text (uiout
, "Hardware access (read/write) watchpoint ");
4921 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "hw-awpt");
4922 ui_out_field_int (uiout
, "number", b
->number
);
4923 ui_out_text (uiout
, ": ");
4924 print_expression (b
->exp
, stb
->stream
);
4925 ui_out_field_stream (uiout
, "exp", stb
);
4926 do_cleanups (ui_out_chain
);
4929 if (ui_out_is_mi_like_p (uiout
))
4934 if (b
->disposition
== disp_del
)
4935 printf_filtered (_("Temporary breakpoint"));
4937 printf_filtered (_("Breakpoint"));
4938 printf_filtered (_(" %d"), b
->number
);
4941 case bp_hardware_breakpoint
:
4942 if (ui_out_is_mi_like_p (uiout
))
4947 printf_filtered (_("Hardware assisted breakpoint %d"), b
->number
);
4951 case bp_catch_unload
:
4952 printf_filtered (_("Catchpoint %d (%s %s)"),
4954 (b
->type
== bp_catch_load
) ? "load" : "unload",
4955 (b
->dll_pathname
!= NULL
) ?
4956 b
->dll_pathname
: "<any library>");
4959 case bp_catch_vfork
:
4960 printf_filtered (_("Catchpoint %d (%s)"),
4962 (b
->type
== bp_catch_fork
) ? "fork" : "vfork");
4965 printf_filtered (_("Catchpoint %d (exec)"),
4972 case bp_longjmp_resume
:
4973 case bp_step_resume
:
4975 case bp_watchpoint_scope
:
4976 case bp_shlib_event
:
4977 case bp_thread_event
:
4978 case bp_overlay_event
:
4984 /* i18n: cagney/2005-02-11: Below needs to be merged into a
4988 printf_filtered (_(" (%s) pending."), b
->addr_string
);
4992 if (addressprint
|| b
->source_file
== NULL
)
4994 printf_filtered (" at ");
4995 fputs_filtered (paddress (b
->loc
->address
), gdb_stdout
);
4998 printf_filtered (": file %s, line %d.",
4999 b
->source_file
, b
->line_number
);
5003 struct bp_location
*loc
= b
->loc
;
5005 for (; loc
; loc
= loc
->next
)
5007 printf_filtered (" (%d locations)", n
);
5012 do_cleanups (old_chain
);
5013 if (ui_out_is_mi_like_p (uiout
))
5015 printf_filtered ("\n");
5019 static struct bp_location
*
5020 add_location_to_breakpoint (struct breakpoint
*b
, enum bptype bptype
,
5021 const struct symtab_and_line
*sal
)
5023 struct bp_location
*loc
, **tmp
;
5025 loc
= allocate_bp_location (b
, bptype
);
5026 for (tmp
= &(b
->loc
); *tmp
!= NULL
; tmp
= &((*tmp
)->next
))
5029 loc
->requested_address
= sal
->pc
;
5030 loc
->address
= adjust_breakpoint_address (loc
->requested_address
,
5032 loc
->section
= sal
->section
;
5034 set_breakpoint_location_function (loc
);
5038 /* Create a breakpoint with SAL as location. Use ADDR_STRING
5039 as textual description of the location, and COND_STRING
5040 as condition expression. */
5043 create_breakpoint (struct symtabs_and_lines sals
, char *addr_string
,
5045 enum bptype type
, enum bpdisp disposition
,
5046 int thread
, int ignore_count
, int from_tty
)
5048 struct breakpoint
*b
= NULL
;
5051 if (type
== bp_hardware_breakpoint
)
5053 int i
= hw_breakpoint_used_count ();
5054 int target_resources_ok
=
5055 TARGET_CAN_USE_HARDWARE_WATCHPOINT (bp_hardware_breakpoint
,
5057 if (target_resources_ok
== 0)
5058 error (_("No hardware breakpoint support in the target."));
5059 else if (target_resources_ok
< 0)
5060 error (_("Hardware breakpoints used exceeds limit."));
5063 for (i
= 0; i
< sals
.nelts
; ++i
)
5065 struct symtab_and_line sal
= sals
.sals
[i
];
5066 struct bp_location
*loc
;
5069 describe_other_breakpoints (sal
.pc
, sal
.section
, thread
);
5073 b
= set_raw_breakpoint (sal
, type
);
5074 set_breakpoint_count (breakpoint_count
+ 1);
5075 b
->number
= breakpoint_count
;
5078 b
->cond_string
= cond_string
;
5079 b
->ignore_count
= ignore_count
;
5080 b
->enable_state
= bp_enabled
;
5081 b
->disposition
= disposition
;
5087 loc
= add_location_to_breakpoint (b
, type
, &sal
);
5092 char *arg
= b
->cond_string
;
5093 loc
->cond
= parse_exp_1 (&arg
, block_for_pc (loc
->address
), 0);
5095 error (_("Garbage %s follows condition"), arg
);
5100 b
->addr_string
= addr_string
;
5102 /* addr_string has to be used or breakpoint_re_set will delete
5104 b
->addr_string
= xstrprintf ("*0x%s", paddr (b
->loc
->address
));
5109 /* Remove element at INDEX_TO_REMOVE from SAL, shifting other
5110 elements to fill the void space. */
5111 static void remove_sal (struct symtabs_and_lines
*sal
, int index_to_remove
)
5113 int i
= index_to_remove
+1;
5114 int last_index
= sal
->nelts
-1;
5116 for (;i
<= last_index
; ++i
)
5117 sal
->sals
[i
-1] = sal
->sals
[i
];
5122 /* If appropriate, obtains all sals that correspond
5123 to the same file and line as SAL. This is done
5124 only if SAL does not have explicit PC and has
5125 line and file information. If we got just a single
5126 expanded sal, return the original.
5128 Otherwise, if SAL.explicit_line is not set, filter out
5129 all sals for which the name of enclosing function
5130 is different from SAL. This makes sure that if we have
5131 breakpoint originally set in template instantiation, say
5132 foo<int>(), we won't expand SAL to locations at the same
5133 line in all existing instantiations of 'foo'.
5136 struct symtabs_and_lines
5137 expand_line_sal_maybe (struct symtab_and_line sal
)
5139 struct symtabs_and_lines expanded
;
5140 CORE_ADDR original_pc
= sal
.pc
;
5141 char *original_function
= NULL
;
5145 /* If we have explicit pc, don't expand.
5146 If we have no line number, we can't expand. */
5147 if (sal
.explicit_pc
|| sal
.line
== 0 || sal
.symtab
== NULL
)
5150 expanded
.sals
= xmalloc (sizeof (struct symtab_and_line
));
5151 expanded
.sals
[0] = sal
;
5156 find_pc_partial_function (original_pc
, &original_function
, NULL
, NULL
);
5158 expanded
= expand_line_sal (sal
);
5159 if (expanded
.nelts
== 1)
5161 /* We had one sal, we got one sal. Without futher
5162 processing, just return the original sal. */
5163 xfree (expanded
.sals
);
5165 expanded
.sals
= xmalloc (sizeof (struct symtab_and_line
));
5166 sal
.pc
= original_pc
;
5167 expanded
.sals
[0] = sal
;
5171 if (!sal
.explicit_line
)
5173 CORE_ADDR func_addr
, func_end
;
5174 for (i
= 0; i
< expanded
.nelts
; ++i
)
5176 CORE_ADDR pc
= expanded
.sals
[i
].pc
;
5177 char *this_function
;
5178 if (find_pc_partial_function (pc
, &this_function
,
5179 &func_addr
, &func_end
))
5181 if (this_function
&&
5182 strcmp (this_function
, original_function
) != 0)
5184 remove_sal (&expanded
, i
);
5187 else if (func_addr
== pc
)
5189 /* We're at beginning of a function, and should
5191 struct symbol
*sym
= find_pc_function (pc
);
5193 expanded
.sals
[i
] = find_function_start_sal (sym
, 1);
5196 = gdbarch_skip_prologue (current_gdbarch
, pc
);
5203 if (expanded
.nelts
<= 1)
5205 /* This is un ugly workaround. If we get zero
5206 expanded sals then something is really wrong.
5207 Fix that by returnign the original sal. */
5208 xfree (expanded
.sals
);
5210 expanded
.sals
= xmalloc (sizeof (struct symtab_and_line
));
5211 sal
.pc
= original_pc
;
5212 expanded
.sals
[0] = sal
;
5219 for (i
= 0; i
< expanded
.nelts
; ++i
)
5220 if (expanded
.sals
[i
].pc
== original_pc
)
5231 /* Add SALS.nelts breakpoints to the breakpoint table. For each
5232 SALS.sal[i] breakpoint, include the corresponding ADDR_STRING[i]
5233 value. COND_STRING, if not NULL, specified the condition to be
5234 used for all breakpoints. Essentially the only case where
5235 SALS.nelts is not 1 is when we set a breakpoint on an overloaded
5236 function. In that case, it's still not possible to specify
5237 separate conditions for different overloaded functions, so
5238 we take just a single condition string.
5240 NOTE: If the function succeeds, the caller is expected to cleanup
5241 the arrays ADDR_STRING, COND_STRING, and SALS (but not the
5242 array contents). If the function fails (error() is called), the
5243 caller is expected to cleanups both the ADDR_STRING, COND_STRING,
5244 COND and SALS arrays and each of those arrays contents. */
5247 create_breakpoints (struct symtabs_and_lines sals
, char **addr_string
,
5249 enum bptype type
, enum bpdisp disposition
,
5250 int thread
, int ignore_count
, int from_tty
)
5253 for (i
= 0; i
< sals
.nelts
; ++i
)
5255 struct symtabs_and_lines expanded
=
5256 expand_line_sal_maybe (sals
.sals
[i
]);
5258 create_breakpoint (expanded
, addr_string
[i
],
5259 cond_string
, type
, disposition
,
5260 thread
, ignore_count
, from_tty
);
5263 update_global_location_list ();
5266 /* Parse ARG which is assumed to be a SAL specification possibly
5267 followed by conditionals. On return, SALS contains an array of SAL
5268 addresses found. ADDR_STRING contains a vector of (canonical)
5269 address strings. ARG points to the end of the SAL. */
5272 parse_breakpoint_sals (char **address
,
5273 struct symtabs_and_lines
*sals
,
5274 char ***addr_string
,
5277 char *addr_start
= *address
;
5278 *addr_string
= NULL
;
5279 /* If no arg given, or if first arg is 'if ', use the default
5281 if ((*address
) == NULL
5282 || (strncmp ((*address
), "if", 2) == 0 && isspace ((*address
)[2])))
5284 if (default_breakpoint_valid
)
5286 struct symtab_and_line sal
;
5287 init_sal (&sal
); /* initialize to zeroes */
5288 sals
->sals
= (struct symtab_and_line
*)
5289 xmalloc (sizeof (struct symtab_and_line
));
5290 sal
.pc
= default_breakpoint_address
;
5291 sal
.line
= default_breakpoint_line
;
5292 sal
.symtab
= default_breakpoint_symtab
;
5293 sal
.section
= find_pc_overlay (sal
.pc
);
5294 sals
->sals
[0] = sal
;
5298 error (_("No default breakpoint address now."));
5302 /* Force almost all breakpoints to be in terms of the
5303 current_source_symtab (which is decode_line_1's default). This
5304 should produce the results we want almost all of the time while
5305 leaving default_breakpoint_* alone.
5306 ObjC: However, don't match an Objective-C method name which
5307 may have a '+' or '-' succeeded by a '[' */
5309 struct symtab_and_line cursal
= get_current_source_symtab_and_line ();
5311 if (default_breakpoint_valid
5313 || ((strchr ("+-", (*address
)[0]) != NULL
)
5314 && ((*address
)[1] != '['))))
5315 *sals
= decode_line_1 (address
, 1, default_breakpoint_symtab
,
5316 default_breakpoint_line
, addr_string
,
5319 *sals
= decode_line_1 (address
, 1, (struct symtab
*) NULL
, 0,
5320 addr_string
, not_found_ptr
);
5322 /* For any SAL that didn't have a canonical string, fill one in. */
5323 if (sals
->nelts
> 0 && *addr_string
== NULL
)
5324 *addr_string
= xcalloc (sals
->nelts
, sizeof (char **));
5325 if (addr_start
!= (*address
))
5328 for (i
= 0; i
< sals
->nelts
; i
++)
5330 /* Add the string if not present. */
5331 if ((*addr_string
)[i
] == NULL
)
5332 (*addr_string
)[i
] = savestring (addr_start
, (*address
) - addr_start
);
5338 /* Convert each SAL into a real PC. Verify that the PC can be
5339 inserted as a breakpoint. If it can't throw an error. */
5342 breakpoint_sals_to_pc (struct symtabs_and_lines
*sals
,
5346 for (i
= 0; i
< sals
->nelts
; i
++)
5347 resolve_sal_pc (&sals
->sals
[i
]);
5351 do_captured_parse_breakpoint (struct ui_out
*ui
, void *data
)
5353 struct captured_parse_breakpoint_args
*args
= data
;
5355 parse_breakpoint_sals (args
->arg_p
, args
->sals_p
, args
->addr_string_p
,
5356 args
->not_found_ptr
);
5359 /* Given TOK, a string specification of condition and thread, as
5360 accepted by the 'break' command, extract the condition
5361 string and thread number and set *COND_STRING and *THREAD.
5362 PC identifies the context at which the condition should be parsed.
5363 If no condition is found, *COND_STRING is set to NULL.
5364 If no thread is found, *THREAD is set to -1. */
5366 find_condition_and_thread (char *tok
, CORE_ADDR pc
,
5367 char **cond_string
, int *thread
)
5369 *cond_string
= NULL
;
5375 char *cond_start
= NULL
;
5376 char *cond_end
= NULL
;
5377 while (*tok
== ' ' || *tok
== '\t')
5382 while (*end_tok
!= ' ' && *end_tok
!= '\t' && *end_tok
!= '\000')
5385 toklen
= end_tok
- tok
;
5387 if (toklen
>= 1 && strncmp (tok
, "if", toklen
) == 0)
5389 tok
= cond_start
= end_tok
+ 1;
5390 parse_exp_1 (&tok
, block_for_pc (pc
), 0);
5392 *cond_string
= savestring (cond_start
,
5393 cond_end
- cond_start
);
5395 else if (toklen
>= 1 && strncmp (tok
, "thread", toklen
) == 0)
5401 *thread
= strtol (tok
, &tok
, 0);
5403 error (_("Junk after thread keyword."));
5404 if (!valid_thread_id (*thread
))
5405 error (_("Unknown thread %d."), *thread
);
5408 error (_("Junk at end of arguments."));
5412 /* Set a breakpoint. This function is shared between
5413 CLI and MI functions for setting a breakpoint.
5414 This function has two major modes of operations,
5415 selected by the PARSE_CONDITION_AND_THREAD parameter.
5416 If non-zero, the function will parse arg, extracting
5417 breakpoint location, address and thread. Otherwise,
5418 ARG is just the location of breakpoint, with condition
5419 and thread specified by the COND_STRING and THREAD
5423 break_command_really (char *arg
, char *cond_string
, int thread
,
5424 int parse_condition_and_thread
,
5425 int tempflag
, int hardwareflag
,
5427 enum auto_boolean pending_break_support
,
5430 struct gdb_exception e
;
5431 struct symtabs_and_lines sals
;
5432 struct symtab_and_line pending_sal
;
5435 char *addr_start
= arg
;
5437 struct cleanup
*old_chain
;
5438 struct cleanup
*breakpoint_chain
= NULL
;
5439 struct captured_parse_breakpoint_args parse_args
;
5448 parse_args
.arg_p
= &arg
;
5449 parse_args
.sals_p
= &sals
;
5450 parse_args
.addr_string_p
= &addr_string
;
5451 parse_args
.not_found_ptr
= ¬_found
;
5453 e
= catch_exception (uiout
, do_captured_parse_breakpoint
,
5454 &parse_args
, RETURN_MASK_ALL
);
5456 /* If caller is interested in rc value from parse, set value. */
5460 throw_exception (e
);
5464 case NOT_FOUND_ERROR
:
5466 /* If pending breakpoint support is turned off, throw
5469 if (pending_break_support
== AUTO_BOOLEAN_FALSE
)
5470 throw_exception (e
);
5472 exception_print (gdb_stderr
, e
);
5474 /* If pending breakpoint support is auto query and the user
5475 selects no, then simply return the error code. */
5476 if (pending_break_support
== AUTO_BOOLEAN_AUTO
&&
5477 !nquery ("Make breakpoint pending on future shared library load? "))
5480 /* At this point, either the user was queried about setting
5481 a pending breakpoint and selected yes, or pending
5482 breakpoint behavior is on and thus a pending breakpoint
5483 is defaulted on behalf of the user. */
5484 copy_arg
= xstrdup (addr_start
);
5485 addr_string
= ©_arg
;
5487 sals
.sals
= &pending_sal
;
5492 throw_exception (e
);
5499 /* Create a chain of things that always need to be cleaned up. */
5500 old_chain
= make_cleanup (null_cleanup
, 0);
5504 /* Make sure that all storage allocated to SALS gets freed. */
5505 make_cleanup (xfree
, sals
.sals
);
5507 /* Cleanup the addr_string array but not its contents. */
5508 make_cleanup (xfree
, addr_string
);
5511 /* ----------------------------- SNIP -----------------------------
5512 Anything added to the cleanup chain beyond this point is assumed
5513 to be part of a breakpoint. If the breakpoint create succeeds
5514 then the memory is not reclaimed. */
5515 breakpoint_chain
= make_cleanup (null_cleanup
, 0);
5517 /* Mark the contents of the addr_string for cleanup. These go on
5518 the breakpoint_chain and only occure if the breakpoint create
5520 for (i
= 0; i
< sals
.nelts
; i
++)
5522 if (addr_string
[i
] != NULL
)
5523 make_cleanup (xfree
, addr_string
[i
]);
5526 /* Resolve all line numbers to PC's and verify that the addresses
5527 are ok for the target. */
5529 breakpoint_sals_to_pc (&sals
, addr_start
);
5531 /* Verify that condition can be parsed, before setting any
5532 breakpoints. Allocate a separate condition expression for each
5536 if (parse_condition_and_thread
)
5538 /* Here we only parse 'arg' to separate condition
5539 from thread number, so parsing in context of first
5540 sal is OK. When setting the breakpoint we'll
5541 re-parse it in context of each sal. */
5544 find_condition_and_thread (arg
, sals
.sals
[0].pc
, &cond_string
, &thread
);
5546 make_cleanup (xfree
, cond_string
);
5550 /* Create a private copy of condition string. */
5553 cond_string
= xstrdup (cond_string
);
5554 make_cleanup (xfree
, cond_string
);
5557 create_breakpoints (sals
, addr_string
, cond_string
,
5558 hardwareflag
? bp_hardware_breakpoint
5560 tempflag
? disp_del
: disp_donttouch
,
5561 thread
, ignore_count
, from_tty
);
5565 struct symtab_and_line sal
= {0};
5566 struct breakpoint
*b
;
5568 make_cleanup (xfree
, copy_arg
);
5570 b
= set_raw_breakpoint_without_location (hardwareflag
5571 ? bp_hardware_breakpoint
5573 set_breakpoint_count (breakpoint_count
+ 1);
5574 b
->number
= breakpoint_count
;
5576 b
->addr_string
= addr_string
[0];
5577 b
->cond_string
= NULL
;
5578 b
->ignore_count
= ignore_count
;
5579 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
5580 b
->condition_not_parsed
= 1;
5582 update_global_location_list ();
5587 warning (_("Multiple breakpoints were set.\n"
5588 "Use the \"delete\" command to delete unwanted breakpoints."));
5589 /* That's it. Discard the cleanups for data inserted into the
5591 discard_cleanups (breakpoint_chain
);
5592 /* But cleanup everything else. */
5593 do_cleanups (old_chain
);
5596 /* Set a breakpoint.
5597 ARG is a string describing breakpoint address,
5598 condition, and thread.
5599 FLAG specifies if a breakpoint is hardware on,
5600 and if breakpoint is temporary, using BP_HARDWARE_FLAG
5604 break_command_1 (char *arg
, int flag
, int from_tty
)
5606 int hardwareflag
= flag
& BP_HARDWAREFLAG
;
5607 int tempflag
= flag
& BP_TEMPFLAG
;
5609 break_command_really (arg
,
5610 NULL
, 0, 1 /* parse arg */,
5611 tempflag
, hardwareflag
,
5612 0 /* Ignore count */,
5613 pending_break_support
, from_tty
);
5618 set_breakpoint (char *address
, char *condition
,
5619 int hardwareflag
, int tempflag
,
5620 int thread
, int ignore_count
,
5623 break_command_really (address
, condition
, thread
,
5624 0 /* condition and thread are valid. */,
5625 tempflag
, hardwareflag
,
5628 ? AUTO_BOOLEAN_TRUE
: AUTO_BOOLEAN_FALSE
,
5632 /* Adjust SAL to the first instruction past the function prologue.
5633 The end of the prologue is determined using the line table from
5634 the debugging information.
5636 If SAL is already past the prologue, then do nothing. */
5639 skip_prologue_sal (struct symtab_and_line
*sal
)
5641 struct symbol
*sym
= find_pc_function (sal
->pc
);
5642 struct symtab_and_line start_sal
;
5647 start_sal
= find_function_start_sal (sym
, 1);
5648 if (sal
->pc
< start_sal
.pc
)
5652 /* Helper function for break_command_1 and disassemble_command. */
5655 resolve_sal_pc (struct symtab_and_line
*sal
)
5659 if (sal
->pc
== 0 && sal
->symtab
!= NULL
)
5661 if (!find_line_pc (sal
->symtab
, sal
->line
, &pc
))
5662 error (_("No line %d in file \"%s\"."),
5663 sal
->line
, sal
->symtab
->filename
);
5666 /* If this SAL corresponds to a breakpoint inserted using
5667 a line number, then skip the function prologue if necessary. */
5668 if (sal
->explicit_line
)
5669 skip_prologue_sal (sal
);
5672 if (sal
->section
== 0 && sal
->symtab
!= NULL
)
5674 struct blockvector
*bv
;
5678 bv
= blockvector_for_pc_sect (sal
->pc
, 0, &b
, sal
->symtab
);
5681 sym
= block_function (b
);
5684 fixup_symbol_section (sym
, sal
->symtab
->objfile
);
5685 sal
->section
= SYMBOL_BFD_SECTION (sym
);
5689 /* It really is worthwhile to have the section, so we'll just
5690 have to look harder. This case can be executed if we have
5691 line numbers but no functions (as can happen in assembly
5694 struct minimal_symbol
*msym
;
5696 msym
= lookup_minimal_symbol_by_pc (sal
->pc
);
5698 sal
->section
= SYMBOL_BFD_SECTION (msym
);
5705 break_command (char *arg
, int from_tty
)
5707 break_command_1 (arg
, 0, from_tty
);
5711 tbreak_command (char *arg
, int from_tty
)
5713 break_command_1 (arg
, BP_TEMPFLAG
, from_tty
);
5717 hbreak_command (char *arg
, int from_tty
)
5719 break_command_1 (arg
, BP_HARDWAREFLAG
, from_tty
);
5723 thbreak_command (char *arg
, int from_tty
)
5725 break_command_1 (arg
, (BP_TEMPFLAG
| BP_HARDWAREFLAG
), from_tty
);
5729 stop_command (char *arg
, int from_tty
)
5731 printf_filtered (_("Specify the type of breakpoint to set.\n\
5732 Usage: stop in <function | address>\n\
5733 stop at <line>\n"));
5737 stopin_command (char *arg
, int from_tty
)
5741 if (arg
== (char *) NULL
)
5743 else if (*arg
!= '*')
5748 /* look for a ':'. If this is a line number specification, then
5749 say it is bad, otherwise, it should be an address or
5750 function/method name */
5751 while (*argptr
&& !hasColon
)
5753 hasColon
= (*argptr
== ':');
5758 badInput
= (*argptr
!= ':'); /* Not a class::method */
5760 badInput
= isdigit (*arg
); /* a simple line number */
5764 printf_filtered (_("Usage: stop in <function | address>\n"));
5766 break_command_1 (arg
, 0, from_tty
);
5770 stopat_command (char *arg
, int from_tty
)
5774 if (arg
== (char *) NULL
|| *arg
== '*') /* no line number */
5781 /* look for a ':'. If there is a '::' then get out, otherwise
5782 it is probably a line number. */
5783 while (*argptr
&& !hasColon
)
5785 hasColon
= (*argptr
== ':');
5790 badInput
= (*argptr
== ':'); /* we have class::method */
5792 badInput
= !isdigit (*arg
); /* not a line number */
5796 printf_filtered (_("Usage: stop at <line>\n"));
5798 break_command_1 (arg
, 0, from_tty
);
5801 /* accessflag: hw_write: watch write,
5802 hw_read: watch read,
5803 hw_access: watch access (read or write) */
5805 watch_command_1 (char *arg
, int accessflag
, int from_tty
)
5807 struct breakpoint
*b
, *scope_breakpoint
= NULL
;
5808 struct symtab_and_line sal
;
5809 struct expression
*exp
;
5810 struct block
*exp_valid_block
;
5811 struct value
*val
, *mark
;
5812 struct frame_info
*frame
;
5813 struct frame_info
*prev_frame
= NULL
;
5814 char *exp_start
= NULL
;
5815 char *exp_end
= NULL
;
5816 char *tok
, *id_tok_start
, *end_tok
;
5818 char *cond_start
= NULL
;
5819 char *cond_end
= NULL
;
5820 struct expression
*cond
= NULL
;
5821 int i
, other_type_used
, target_resources_ok
= 0;
5822 enum bptype bp_type
;
5826 init_sal (&sal
); /* initialize to zeroes */
5828 /* Make sure that we actually have parameters to parse. */
5829 if (arg
!= NULL
&& arg
[0] != '\0')
5831 toklen
= strlen (arg
); /* Size of argument list. */
5833 /* Points tok to the end of the argument list. */
5834 tok
= arg
+ toklen
- 1;
5836 /* Go backwards in the parameters list. Skip the last parameter.
5837 If we're expecting a 'thread <thread_num>' parameter, this should
5838 be the thread identifier. */
5839 while (tok
> arg
&& (*tok
== ' ' || *tok
== '\t'))
5841 while (tok
> arg
&& (*tok
!= ' ' && *tok
!= '\t'))
5844 /* Points end_tok to the beginning of the last token. */
5845 id_tok_start
= tok
+ 1;
5847 /* Go backwards in the parameters list. Skip one more parameter.
5848 If we're expecting a 'thread <thread_num>' parameter, we should
5849 reach a "thread" token. */
5850 while (tok
> arg
&& (*tok
== ' ' || *tok
== '\t'))
5855 while (tok
> arg
&& (*tok
!= ' ' && *tok
!= '\t'))
5858 /* Move the pointer forward to skip the whitespace and
5859 calculate the length of the token. */
5861 toklen
= end_tok
- tok
;
5863 if (toklen
>= 1 && strncmp (tok
, "thread", toklen
) == 0)
5865 /* At this point we've found a "thread" token, which means
5866 the user is trying to set a watchpoint that triggers
5867 only in a specific thread. */
5870 /* Extract the thread ID from the next token. */
5871 thread
= strtol (id_tok_start
, &endp
, 0);
5873 /* Check if the user provided a valid numeric value for the
5875 if (*endp
!= ' ' && *endp
!= '\t' && *endp
!= '\0')
5876 error (_("Invalid thread ID specification %s."), id_tok_start
);
5878 /* Check if the thread actually exists. */
5879 if (!valid_thread_id (thread
))
5880 error (_("Unknown thread %d."), thread
);
5882 /* Truncate the string and get rid of the thread <thread_num>
5883 parameter before the parameter list is parsed by the
5884 evaluate_expression() function. */
5889 /* Parse the rest of the arguments. */
5890 innermost_block
= NULL
;
5892 exp
= parse_exp_1 (&arg
, 0, 0);
5894 exp_valid_block
= innermost_block
;
5895 mark
= value_mark ();
5896 fetch_watchpoint_value (exp
, &val
, NULL
, NULL
);
5898 release_value (val
);
5901 while (*tok
== ' ' || *tok
== '\t')
5905 while (*end_tok
!= ' ' && *end_tok
!= '\t' && *end_tok
!= '\000')
5908 toklen
= end_tok
- tok
;
5909 if (toklen
>= 1 && strncmp (tok
, "if", toklen
) == 0)
5911 tok
= cond_start
= end_tok
+ 1;
5912 cond
= parse_exp_1 (&tok
, 0, 0);
5916 error (_("Junk at end of command."));
5918 if (accessflag
== hw_read
)
5919 bp_type
= bp_read_watchpoint
;
5920 else if (accessflag
== hw_access
)
5921 bp_type
= bp_access_watchpoint
;
5923 bp_type
= bp_hardware_watchpoint
;
5925 mem_cnt
= can_use_hardware_watchpoint (val
);
5926 if (mem_cnt
== 0 && bp_type
!= bp_hardware_watchpoint
)
5927 error (_("Expression cannot be implemented with read/access watchpoint."));
5930 i
= hw_watchpoint_used_count (bp_type
, &other_type_used
);
5931 target_resources_ok
=
5932 TARGET_CAN_USE_HARDWARE_WATCHPOINT (bp_type
, i
+ mem_cnt
,
5934 if (target_resources_ok
== 0 && bp_type
!= bp_hardware_watchpoint
)
5935 error (_("Target does not support this type of hardware watchpoint."));
5937 if (target_resources_ok
< 0 && bp_type
!= bp_hardware_watchpoint
)
5938 error (_("Target can only support one kind of HW watchpoint at a time."));
5941 /* Change the type of breakpoint to an ordinary watchpoint if a hardware
5942 watchpoint could not be set. */
5943 if (!mem_cnt
|| target_resources_ok
<= 0)
5944 bp_type
= bp_watchpoint
;
5946 frame
= block_innermost_frame (exp_valid_block
);
5948 prev_frame
= get_prev_frame (frame
);
5952 /* If the expression is "local", then set up a "watchpoint scope"
5953 breakpoint at the point where we've left the scope of the watchpoint
5954 expression. Create the scope breakpoint before the watchpoint, so
5955 that we will encounter it first in bpstat_stop_status. */
5956 if (innermost_block
&& prev_frame
)
5958 scope_breakpoint
= create_internal_breakpoint (get_frame_pc (prev_frame
),
5959 bp_watchpoint_scope
);
5961 scope_breakpoint
->enable_state
= bp_enabled
;
5963 /* Automatically delete the breakpoint when it hits. */
5964 scope_breakpoint
->disposition
= disp_del
;
5966 /* Only break in the proper frame (help with recursion). */
5967 scope_breakpoint
->frame_id
= get_frame_id (prev_frame
);
5969 /* Set the address at which we will stop. */
5970 scope_breakpoint
->loc
->requested_address
5971 = get_frame_pc (prev_frame
);
5972 scope_breakpoint
->loc
->address
5973 = adjust_breakpoint_address (scope_breakpoint
->loc
->requested_address
,
5974 scope_breakpoint
->type
);
5977 /* Now set up the breakpoint. */
5978 b
= set_raw_breakpoint (sal
, bp_type
);
5979 set_breakpoint_count (breakpoint_count
+ 1);
5980 b
->number
= breakpoint_count
;
5982 b
->disposition
= disp_donttouch
;
5984 b
->exp_valid_block
= exp_valid_block
;
5985 b
->exp_string
= savestring (exp_start
, exp_end
- exp_start
);
5988 b
->loc
->cond
= cond
;
5990 b
->cond_string
= savestring (cond_start
, cond_end
- cond_start
);
5995 b
->watchpoint_frame
= get_frame_id (frame
);
5997 b
->watchpoint_frame
= null_frame_id
;
5999 if (scope_breakpoint
!= NULL
)
6001 /* The scope breakpoint is related to the watchpoint. We will
6002 need to act on them together. */
6003 b
->related_breakpoint
= scope_breakpoint
;
6004 scope_breakpoint
->related_breakpoint
= b
;
6007 value_free_to_mark (mark
);
6009 update_global_location_list ();
6012 /* Return count of locations need to be watched and can be handled
6013 in hardware. If the watchpoint can not be handled
6014 in hardware return zero. */
6017 can_use_hardware_watchpoint (struct value
*v
)
6019 int found_memory_cnt
= 0;
6020 struct value
*head
= v
;
6022 /* Did the user specifically forbid us to use hardware watchpoints? */
6023 if (!can_use_hw_watchpoints
)
6026 /* Make sure that the value of the expression depends only upon
6027 memory contents, and values computed from them within GDB. If we
6028 find any register references or function calls, we can't use a
6029 hardware watchpoint.
6031 The idea here is that evaluating an expression generates a series
6032 of values, one holding the value of every subexpression. (The
6033 expression a*b+c has five subexpressions: a, b, a*b, c, and
6034 a*b+c.) GDB's values hold almost enough information to establish
6035 the criteria given above --- they identify memory lvalues,
6036 register lvalues, computed values, etcetera. So we can evaluate
6037 the expression, and then scan the chain of values that leaves
6038 behind to decide whether we can detect any possible change to the
6039 expression's final value using only hardware watchpoints.
6041 However, I don't think that the values returned by inferior
6042 function calls are special in any way. So this function may not
6043 notice that an expression involving an inferior function call
6044 can't be watched with hardware watchpoints. FIXME. */
6045 for (; v
; v
= value_next (v
))
6047 if (VALUE_LVAL (v
) == lval_memory
)
6050 /* A lazy memory lvalue is one that GDB never needed to fetch;
6051 we either just used its address (e.g., `a' in `a.b') or
6052 we never needed it at all (e.g., `a' in `a,b'). */
6056 /* Ahh, memory we actually used! Check if we can cover
6057 it with hardware watchpoints. */
6058 struct type
*vtype
= check_typedef (value_type (v
));
6060 /* We only watch structs and arrays if user asked for it
6061 explicitly, never if they just happen to appear in a
6062 middle of some value chain. */
6064 || (TYPE_CODE (vtype
) != TYPE_CODE_STRUCT
6065 && TYPE_CODE (vtype
) != TYPE_CODE_ARRAY
))
6067 CORE_ADDR vaddr
= VALUE_ADDRESS (v
) + value_offset (v
);
6068 int len
= TYPE_LENGTH (value_type (v
));
6070 if (!TARGET_REGION_OK_FOR_HW_WATCHPOINT (vaddr
, len
))
6077 else if (VALUE_LVAL (v
) != not_lval
6078 && deprecated_value_modifiable (v
) == 0)
6079 return 0; /* ??? What does this represent? */
6080 else if (VALUE_LVAL (v
) == lval_register
)
6081 return 0; /* cannot watch a register with a HW watchpoint */
6084 /* The expression itself looks suitable for using a hardware
6085 watchpoint, but give the target machine a chance to reject it. */
6086 return found_memory_cnt
;
6090 watch_command_wrapper (char *arg
, int from_tty
)
6092 watch_command (arg
, from_tty
);
6096 watch_command (char *arg
, int from_tty
)
6098 watch_command_1 (arg
, hw_write
, from_tty
);
6102 rwatch_command_wrapper (char *arg
, int from_tty
)
6104 rwatch_command (arg
, from_tty
);
6108 rwatch_command (char *arg
, int from_tty
)
6110 watch_command_1 (arg
, hw_read
, from_tty
);
6114 awatch_command_wrapper (char *arg
, int from_tty
)
6116 awatch_command (arg
, from_tty
);
6120 awatch_command (char *arg
, int from_tty
)
6122 watch_command_1 (arg
, hw_access
, from_tty
);
6126 /* Helper routines for the until_command routine in infcmd.c. Here
6127 because it uses the mechanisms of breakpoints. */
6129 /* This function is called by fetch_inferior_event via the
6130 cmd_continuation pointer, to complete the until command. It takes
6131 care of cleaning up the temporary breakpoints set up by the until
6134 until_break_command_continuation (struct continuation_arg
*arg
, int error
)
6136 delete_breakpoint ((struct breakpoint
*)(arg
->data
.pointer
));
6138 delete_breakpoint ((struct breakpoint
*)(arg
->next
->data
.pointer
));
6142 until_break_command (char *arg
, int from_tty
, int anywhere
)
6144 struct symtabs_and_lines sals
;
6145 struct symtab_and_line sal
;
6146 struct frame_info
*frame
= get_selected_frame (NULL
);
6147 struct frame_info
*prev_frame
= get_prev_frame (frame
);
6148 struct breakpoint
*breakpoint
;
6149 struct breakpoint
*breakpoint2
= NULL
;
6150 struct cleanup
*old_chain
;
6151 struct continuation_arg
*arg1
;
6152 struct continuation_arg
*arg2
;
6155 clear_proceed_status ();
6157 /* Set a breakpoint where the user wants it and at return from
6160 if (default_breakpoint_valid
)
6161 sals
= decode_line_1 (&arg
, 1, default_breakpoint_symtab
,
6162 default_breakpoint_line
, (char ***) NULL
, NULL
);
6164 sals
= decode_line_1 (&arg
, 1, (struct symtab
*) NULL
,
6165 0, (char ***) NULL
, NULL
);
6167 if (sals
.nelts
!= 1)
6168 error (_("Couldn't get information on specified line."));
6171 xfree (sals
.sals
); /* malloc'd, so freed */
6174 error (_("Junk at end of arguments."));
6176 resolve_sal_pc (&sal
);
6179 /* If the user told us to continue until a specified location,
6180 we don't specify a frame at which we need to stop. */
6181 breakpoint
= set_momentary_breakpoint (sal
, null_frame_id
, bp_until
);
6183 /* Otherwise, specify the current frame, because we want to stop only
6184 at the very same frame. */
6185 breakpoint
= set_momentary_breakpoint (sal
, get_frame_id (frame
),
6188 old_chain
= make_cleanup_delete_breakpoint (breakpoint
);
6190 /* Keep within the current frame, or in frames called by the current
6194 sal
= find_pc_line (get_frame_pc (prev_frame
), 0);
6195 sal
.pc
= get_frame_pc (prev_frame
);
6196 breakpoint2
= set_momentary_breakpoint (sal
, get_frame_id (prev_frame
),
6198 make_cleanup_delete_breakpoint (breakpoint2
);
6201 proceed (-1, TARGET_SIGNAL_DEFAULT
, 0);
6203 /* If we are running asynchronously, and proceed call above has actually
6204 managed to start the target, arrange for breakpoints to be
6205 deleted when the target stops. Otherwise, we're already stopped and
6206 delete breakpoints via cleanup chain. */
6208 if (target_can_async_p () && target_executing
)
6211 (struct continuation_arg
*) xmalloc (sizeof (struct continuation_arg
));
6213 arg1
->data
.pointer
= breakpoint
;
6217 arg2
= (struct continuation_arg
*)
6218 xmalloc ( sizeof (struct continuation_arg
));
6220 arg2
->data
.pointer
= breakpoint2
;
6224 discard_cleanups (old_chain
);
6225 add_continuation (until_break_command_continuation
, arg1
);
6228 do_cleanups (old_chain
);
6232 ep_skip_leading_whitespace (char **s
)
6234 if ((s
== NULL
) || (*s
== NULL
))
6236 while (isspace (**s
))
6240 /* This function examines a string, and attempts to find a token
6241 that might be an event name in the leading characters. If a
6242 possible match is found, a pointer to the last character of
6243 the token is returned. Else, NULL is returned. */
6246 ep_find_event_name_end (char *arg
)
6249 char *event_name_end
= NULL
;
6251 /* If we could depend upon the presense of strrpbrk, we'd use that... */
6255 /* We break out of the loop when we find a token delimiter.
6256 Basically, we're looking for alphanumerics and underscores;
6257 anything else delimites the token. */
6260 if (!isalnum (*s
) && (*s
!= '_'))
6266 return event_name_end
;
6270 /* This function attempts to parse an optional "if <cond>" clause
6271 from the arg string. If one is not found, it returns NULL.
6273 Else, it returns a pointer to the condition string. (It does not
6274 attempt to evaluate the string against a particular block.) And,
6275 it updates arg to point to the first character following the parsed
6276 if clause in the arg string. */
6279 ep_parse_optional_if_clause (char **arg
)
6283 if (((*arg
)[0] != 'i') || ((*arg
)[1] != 'f') || !isspace ((*arg
)[2]))
6286 /* Skip the "if" keyword. */
6289 /* Skip any extra leading whitespace, and record the start of the
6290 condition string. */
6291 ep_skip_leading_whitespace (arg
);
6294 /* Assume that the condition occupies the remainder of the arg string. */
6295 (*arg
) += strlen (cond_string
);
6300 /* This function attempts to parse an optional filename from the arg
6301 string. If one is not found, it returns NULL.
6303 Else, it returns a pointer to the parsed filename. (This function
6304 makes no attempt to verify that a file of that name exists, or is
6305 accessible.) And, it updates arg to point to the first character
6306 following the parsed filename in the arg string.
6308 Note that clients needing to preserve the returned filename for
6309 future access should copy it to their own buffers. */
6311 ep_parse_optional_filename (char **arg
)
6313 static char filename
[1024];
6318 if ((*arg_p
== '\0') || isspace (*arg_p
))
6336 /* Commands to deal with catching events, such as signals, exceptions,
6337 process start/exit, etc. */
6341 catch_fork
, catch_vfork
6346 catch_fork_command_1 (catch_fork_kind fork_kind
, char *arg
, int tempflag
,
6349 char *cond_string
= NULL
;
6351 ep_skip_leading_whitespace (&arg
);
6353 /* The allowed syntax is:
6355 catch [v]fork if <cond>
6357 First, check if there's an if clause. */
6358 cond_string
= ep_parse_optional_if_clause (&arg
);
6360 if ((*arg
!= '\0') && !isspace (*arg
))
6361 error (_("Junk at end of arguments."));
6363 /* If this target supports it, create a fork or vfork catchpoint
6364 and enable reporting of such events. */
6368 create_fork_event_catchpoint (tempflag
, cond_string
);
6371 create_vfork_event_catchpoint (tempflag
, cond_string
);
6374 error (_("unsupported or unknown fork kind; cannot catch it"));
6380 catch_exec_command_1 (char *arg
, int tempflag
, int from_tty
)
6382 char *cond_string
= NULL
;
6384 ep_skip_leading_whitespace (&arg
);
6386 /* The allowed syntax is:
6388 catch exec if <cond>
6390 First, check if there's an if clause. */
6391 cond_string
= ep_parse_optional_if_clause (&arg
);
6393 if ((*arg
!= '\0') && !isspace (*arg
))
6394 error (_("Junk at end of arguments."));
6396 /* If this target supports it, create an exec catchpoint
6397 and enable reporting of such events. */
6398 create_exec_event_catchpoint (tempflag
, cond_string
);
6402 catch_load_command_1 (char *arg
, int tempflag
, int from_tty
)
6404 char *dll_pathname
= NULL
;
6405 char *cond_string
= NULL
;
6407 ep_skip_leading_whitespace (&arg
);
6409 /* The allowed syntax is:
6411 catch load if <cond>
6412 catch load <filename>
6413 catch load <filename> if <cond>
6415 The user is not allowed to specify the <filename> after an
6418 We'll ignore the pathological case of a file named "if".
6420 First, check if there's an if clause. If so, then there
6421 cannot be a filename. */
6422 cond_string
= ep_parse_optional_if_clause (&arg
);
6424 /* If there was an if clause, then there cannot be a filename.
6425 Else, there might be a filename and an if clause. */
6426 if (cond_string
== NULL
)
6428 dll_pathname
= ep_parse_optional_filename (&arg
);
6429 ep_skip_leading_whitespace (&arg
);
6430 cond_string
= ep_parse_optional_if_clause (&arg
);
6433 if ((*arg
!= '\0') && !isspace (*arg
))
6434 error (_("Junk at end of arguments."));
6436 /* Create a load breakpoint that only triggers when a load of
6437 the specified dll (or any dll, if no pathname was specified)
6439 SOLIB_CREATE_CATCH_LOAD_HOOK (PIDGET (inferior_ptid
), tempflag
,
6440 dll_pathname
, cond_string
);
6444 catch_unload_command_1 (char *arg
, int tempflag
, int from_tty
)
6446 char *dll_pathname
= NULL
;
6447 char *cond_string
= NULL
;
6449 ep_skip_leading_whitespace (&arg
);
6451 /* The allowed syntax is:
6453 catch unload if <cond>
6454 catch unload <filename>
6455 catch unload <filename> if <cond>
6457 The user is not allowed to specify the <filename> after an
6460 We'll ignore the pathological case of a file named "if".
6462 First, check if there's an if clause. If so, then there
6463 cannot be a filename. */
6464 cond_string
= ep_parse_optional_if_clause (&arg
);
6466 /* If there was an if clause, then there cannot be a filename.
6467 Else, there might be a filename and an if clause. */
6468 if (cond_string
== NULL
)
6470 dll_pathname
= ep_parse_optional_filename (&arg
);
6471 ep_skip_leading_whitespace (&arg
);
6472 cond_string
= ep_parse_optional_if_clause (&arg
);
6475 if ((*arg
!= '\0') && !isspace (*arg
))
6476 error (_("Junk at end of arguments."));
6478 /* Create an unload breakpoint that only triggers when an unload of
6479 the specified dll (or any dll, if no pathname was specified)
6481 SOLIB_CREATE_CATCH_UNLOAD_HOOK (PIDGET (inferior_ptid
), tempflag
,
6482 dll_pathname
, cond_string
);
6485 static enum print_stop_action
6486 print_exception_catchpoint (struct breakpoint
*b
)
6488 annotate_catchpoint (b
->number
);
6490 if (strstr (b
->addr_string
, "throw") != NULL
)
6491 printf_filtered (_("\nCatchpoint %d (exception thrown)\n"),
6494 printf_filtered (_("\nCatchpoint %d (exception caught)\n"),
6497 return PRINT_SRC_AND_LOC
;
6501 print_one_exception_catchpoint (struct breakpoint
*b
, CORE_ADDR
*last_addr
)
6506 ui_out_field_core_addr (uiout
, "addr", b
->loc
->address
);
6509 *last_addr
= b
->loc
->address
;
6510 if (strstr (b
->addr_string
, "throw") != NULL
)
6511 ui_out_field_string (uiout
, "what", "exception throw");
6513 ui_out_field_string (uiout
, "what", "exception catch");
6517 print_mention_exception_catchpoint (struct breakpoint
*b
)
6519 if (strstr (b
->addr_string
, "throw") != NULL
)
6520 printf_filtered (_("Catchpoint %d (throw)"), b
->number
);
6522 printf_filtered (_("Catchpoint %d (catch)"), b
->number
);
6525 static struct breakpoint_ops gnu_v3_exception_catchpoint_ops
= {
6526 print_exception_catchpoint
,
6527 print_one_exception_catchpoint
,
6528 print_mention_exception_catchpoint
6532 handle_gnu_v3_exceptions (int tempflag
, char *cond_string
,
6533 enum exception_event_kind ex_event
, int from_tty
)
6535 char *trigger_func_name
, *nameptr
;
6536 struct symtabs_and_lines sals
;
6537 struct breakpoint
*b
;
6539 if (ex_event
== EX_EVENT_CATCH
)
6540 trigger_func_name
= xstrdup ("__cxa_begin_catch");
6542 trigger_func_name
= xstrdup ("__cxa_throw");
6544 nameptr
= trigger_func_name
;
6545 sals
= decode_line_1 (&nameptr
, 1, NULL
, 0, NULL
, NULL
);
6546 if (sals
.nelts
== 0)
6548 xfree (trigger_func_name
);
6552 b
= set_raw_breakpoint (sals
.sals
[0], bp_breakpoint
);
6553 set_breakpoint_count (breakpoint_count
+ 1);
6554 b
->number
= breakpoint_count
;
6555 b
->cond_string
= (cond_string
== NULL
) ?
6556 NULL
: savestring (cond_string
, strlen (cond_string
));
6558 b
->addr_string
= trigger_func_name
;
6559 b
->enable_state
= bp_enabled
;
6560 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
6561 b
->ops
= &gnu_v3_exception_catchpoint_ops
;
6565 update_global_location_list ();
6569 /* Deal with "catch catch" and "catch throw" commands */
6572 catch_exception_command_1 (enum exception_event_kind ex_event
, char *arg
,
6573 int tempflag
, int from_tty
)
6575 char *cond_string
= NULL
;
6576 struct symtab_and_line
*sal
= NULL
;
6578 ep_skip_leading_whitespace (&arg
);
6580 cond_string
= ep_parse_optional_if_clause (&arg
);
6582 if ((*arg
!= '\0') && !isspace (*arg
))
6583 error (_("Junk at end of arguments."));
6585 if ((ex_event
!= EX_EVENT_THROW
) &&
6586 (ex_event
!= EX_EVENT_CATCH
))
6587 error (_("Unsupported or unknown exception event; cannot catch it"));
6589 if (handle_gnu_v3_exceptions (tempflag
, cond_string
, ex_event
, from_tty
))
6592 warning (_("Unsupported with this platform/compiler combination."));
6595 /* Create a breakpoint struct for Ada exception catchpoints. */
6598 create_ada_exception_breakpoint (struct symtab_and_line sal
,
6602 struct expression
*cond
,
6603 struct breakpoint_ops
*ops
,
6607 struct breakpoint
*b
;
6611 describe_other_breakpoints (sal
.pc
, sal
.section
, -1);
6612 /* FIXME: brobecker/2006-12-28: Actually, re-implement a special
6613 version for exception catchpoints, because two catchpoints
6614 used for different exception names will use the same address.
6615 In this case, a "breakpoint ... also set at..." warning is
6616 unproductive. Besides. the warning phrasing is also a bit
6617 inapropriate, we should use the word catchpoint, and tell
6618 the user what type of catchpoint it is. The above is good
6619 enough for now, though. */
6622 b
= set_raw_breakpoint (sal
, bp_breakpoint
);
6623 set_breakpoint_count (breakpoint_count
+ 1);
6625 b
->enable_state
= bp_enabled
;
6626 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
6627 b
->number
= breakpoint_count
;
6628 b
->ignore_count
= 0;
6629 b
->loc
->cond
= cond
;
6630 b
->addr_string
= addr_string
;
6631 b
->language
= language_ada
;
6632 b
->cond_string
= cond_string
;
6633 b
->exp_string
= exp_string
;
6638 update_global_location_list ();
6641 /* Implement the "catch exception" command. */
6644 catch_ada_exception_command (char *arg
, int tempflag
, int from_tty
)
6646 struct symtab_and_line sal
;
6648 char *addr_string
= NULL
;
6649 char *exp_string
= NULL
;
6650 char *cond_string
= NULL
;
6651 struct expression
*cond
= NULL
;
6652 struct breakpoint_ops
*ops
= NULL
;
6654 sal
= ada_decode_exception_location (arg
, &addr_string
, &exp_string
,
6655 &cond_string
, &cond
, &ops
);
6656 create_ada_exception_breakpoint (sal
, addr_string
, exp_string
,
6657 cond_string
, cond
, ops
, tempflag
,
6661 /* Implement the "catch assert" command. */
6664 catch_assert_command (char *arg
, int tempflag
, int from_tty
)
6666 struct symtab_and_line sal
;
6667 char *addr_string
= NULL
;
6668 struct breakpoint_ops
*ops
= NULL
;
6670 sal
= ada_decode_assert_location (arg
, &addr_string
, &ops
);
6671 create_ada_exception_breakpoint (sal
, addr_string
, NULL
, NULL
, NULL
, ops
,
6672 tempflag
, from_tty
);
6676 catch_command_1 (char *arg
, int tempflag
, int from_tty
)
6679 /* The first argument may be an event name, such as "start" or "load".
6680 If so, then handle it as such. If it doesn't match an event name,
6681 then attempt to interpret it as an exception name. (This latter is
6682 the v4.16-and-earlier GDB meaning of the "catch" command.)
6684 First, try to find the bounds of what might be an event name. */
6685 char *arg1_start
= arg
;
6689 if (arg1_start
== NULL
)
6691 /* Old behaviour was to use pre-v-4.16 syntax */
6692 /* catch_throw_command_1 (arg1_start, tempflag, from_tty); */
6694 /* Now, this is not allowed */
6695 error (_("Catch requires an event name."));
6698 arg1_end
= ep_find_event_name_end (arg1_start
);
6699 if (arg1_end
== NULL
)
6700 error (_("catch requires an event"));
6701 arg1_length
= arg1_end
+ 1 - arg1_start
;
6703 /* Try to match what we found against known event names. */
6704 if (strncmp (arg1_start
, "signal", arg1_length
) == 0)
6706 error (_("Catch of signal not yet implemented"));
6708 else if (strncmp (arg1_start
, "catch", arg1_length
) == 0)
6710 catch_exception_command_1 (EX_EVENT_CATCH
, arg1_end
+ 1,
6711 tempflag
, from_tty
);
6713 else if (strncmp (arg1_start
, "throw", arg1_length
) == 0)
6715 catch_exception_command_1 (EX_EVENT_THROW
, arg1_end
+ 1,
6716 tempflag
, from_tty
);
6718 else if (strncmp (arg1_start
, "thread_start", arg1_length
) == 0)
6720 error (_("Catch of thread_start not yet implemented"));
6722 else if (strncmp (arg1_start
, "thread_exit", arg1_length
) == 0)
6724 error (_("Catch of thread_exit not yet implemented"));
6726 else if (strncmp (arg1_start
, "thread_join", arg1_length
) == 0)
6728 error (_("Catch of thread_join not yet implemented"));
6730 else if (strncmp (arg1_start
, "start", arg1_length
) == 0)
6732 error (_("Catch of start not yet implemented"));
6734 else if (strncmp (arg1_start
, "exit", arg1_length
) == 0)
6736 error (_("Catch of exit not yet implemented"));
6738 else if (strncmp (arg1_start
, "fork", arg1_length
) == 0)
6740 catch_fork_command_1 (catch_fork
, arg1_end
+ 1, tempflag
, from_tty
);
6742 else if (strncmp (arg1_start
, "vfork", arg1_length
) == 0)
6744 catch_fork_command_1 (catch_vfork
, arg1_end
+ 1, tempflag
, from_tty
);
6746 else if (strncmp (arg1_start
, "exec", arg1_length
) == 0)
6748 catch_exec_command_1 (arg1_end
+ 1, tempflag
, from_tty
);
6750 else if (strncmp (arg1_start
, "load", arg1_length
) == 0)
6752 catch_load_command_1 (arg1_end
+ 1, tempflag
, from_tty
);
6754 else if (strncmp (arg1_start
, "unload", arg1_length
) == 0)
6756 catch_unload_command_1 (arg1_end
+ 1, tempflag
, from_tty
);
6758 else if (strncmp (arg1_start
, "stop", arg1_length
) == 0)
6760 error (_("Catch of stop not yet implemented"));
6762 else if (strncmp (arg1_start
, "exception", arg1_length
) == 0)
6764 catch_ada_exception_command (arg1_end
+ 1, tempflag
, from_tty
);
6767 else if (strncmp (arg1_start
, "assert", arg1_length
) == 0)
6769 catch_assert_command (arg1_end
+ 1, tempflag
, from_tty
);
6772 /* This doesn't appear to be an event name */
6776 /* Pre-v.4.16 behaviour was to treat the argument
6777 as the name of an exception */
6778 /* catch_throw_command_1 (arg1_start, tempflag, from_tty); */
6779 /* Now this is not allowed */
6780 error (_("Unknown event kind specified for catch"));
6786 catch_command (char *arg
, int from_tty
)
6788 catch_command_1 (arg
, 0, from_tty
);
6793 tcatch_command (char *arg
, int from_tty
)
6795 catch_command_1 (arg
, 1, from_tty
);
6798 /* Delete breakpoints by address or line. */
6801 clear_command (char *arg
, int from_tty
)
6803 struct breakpoint
*b
;
6804 VEC(breakpoint_p
) *found
= 0;
6807 struct symtabs_and_lines sals
;
6808 struct symtab_and_line sal
;
6813 sals
= decode_line_spec (arg
, 1);
6818 sals
.sals
= (struct symtab_and_line
*)
6819 xmalloc (sizeof (struct symtab_and_line
));
6820 make_cleanup (xfree
, sals
.sals
);
6821 init_sal (&sal
); /* initialize to zeroes */
6822 sal
.line
= default_breakpoint_line
;
6823 sal
.symtab
= default_breakpoint_symtab
;
6824 sal
.pc
= default_breakpoint_address
;
6825 if (sal
.symtab
== 0)
6826 error (_("No source file specified."));
6834 /* We don't call resolve_sal_pc here. That's not
6835 as bad as it seems, because all existing breakpoints
6836 typically have both file/line and pc set. So, if
6837 clear is given file/line, we can match this to existing
6838 breakpoint without obtaining pc at all.
6840 We only support clearing given the address explicitly
6841 present in breakpoint table. Say, we've set breakpoint
6842 at file:line. There were several PC values for that file:line,
6843 due to optimization, all in one block.
6844 We've picked one PC value. If "clear" is issued with another
6845 PC corresponding to the same file:line, the breakpoint won't
6846 be cleared. We probably can still clear the breakpoint, but
6847 since the other PC value is never presented to user, user
6848 can only find it by guessing, and it does not seem important
6851 /* For each line spec given, delete bps which correspond
6852 to it. Do it in two passes, solely to preserve the current
6853 behavior that from_tty is forced true if we delete more than
6857 for (i
= 0; i
< sals
.nelts
; i
++)
6859 /* If exact pc given, clear bpts at that pc.
6860 If line given (pc == 0), clear all bpts on specified line.
6861 If defaulting, clear all bpts on default line
6864 defaulting sal.pc != 0 tests to do
6869 1 0 <can't happen> */
6873 /* Find all matching breakpoints and add them to
6878 /* Are we going to delete b? */
6879 if (b
->type
!= bp_none
6880 && b
->type
!= bp_watchpoint
6881 && b
->type
!= bp_hardware_watchpoint
6882 && b
->type
!= bp_read_watchpoint
6883 && b
->type
!= bp_access_watchpoint
)
6885 struct bp_location
*loc
= b
->loc
;
6886 for (; loc
; loc
= loc
->next
)
6888 int pc_match
= sal
.pc
6889 && (loc
->address
== sal
.pc
)
6890 && (!section_is_overlay (loc
->section
)
6891 || loc
->section
== sal
.section
);
6892 int line_match
= ((default_match
|| (0 == sal
.pc
))
6893 && b
->source_file
!= NULL
6894 && sal
.symtab
!= NULL
6895 && strcmp (b
->source_file
, sal
.symtab
->filename
) == 0
6896 && b
->line_number
== sal
.line
);
6897 if (pc_match
|| line_match
)
6906 VEC_safe_push(breakpoint_p
, found
, b
);
6909 /* Now go thru the 'found' chain and delete them. */
6910 if (VEC_empty(breakpoint_p
, found
))
6913 error (_("No breakpoint at %s."), arg
);
6915 error (_("No breakpoint at this line."));
6918 if (VEC_length(breakpoint_p
, found
) > 1)
6919 from_tty
= 1; /* Always report if deleted more than one */
6922 if (VEC_length(breakpoint_p
, found
) == 1)
6923 printf_unfiltered (_("Deleted breakpoint "));
6925 printf_unfiltered (_("Deleted breakpoints "));
6927 breakpoints_changed ();
6929 for (ix
= 0; VEC_iterate(breakpoint_p
, found
, ix
, b
); ix
++)
6932 printf_unfiltered ("%d ", b
->number
);
6933 delete_breakpoint (b
);
6936 putchar_unfiltered ('\n');
6939 /* Delete breakpoint in BS if they are `delete' breakpoints and
6940 all breakpoints that are marked for deletion, whether hit or not.
6941 This is called after any breakpoint is hit, or after errors. */
6944 breakpoint_auto_delete (bpstat bs
)
6946 struct breakpoint
*b
, *temp
;
6948 for (; bs
; bs
= bs
->next
)
6949 if (bs
->breakpoint_at
&& bs
->breakpoint_at
->owner
->disposition
== disp_del
6951 delete_breakpoint (bs
->breakpoint_at
->owner
);
6953 ALL_BREAKPOINTS_SAFE (b
, temp
)
6955 if (b
->disposition
== disp_del_at_next_stop
)
6956 delete_breakpoint (b
);
6961 update_global_location_list (void)
6963 struct breakpoint
*b
;
6964 struct bp_location
**next
= &bp_location_chain
;
6965 struct bp_location
*loc
;
6966 struct bp_location
*loc2
;
6967 struct gdb_exception e
;
6968 VEC(bp_location_p
) *old_locations
= NULL
;
6972 /* Store old locations for future reference. */
6973 for (loc
= bp_location_chain
; loc
; loc
= loc
->global_next
)
6974 VEC_safe_push (bp_location_p
, old_locations
, loc
);
6976 bp_location_chain
= NULL
;
6979 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
6982 next
= &(loc
->global_next
);
6987 /* Identify bp_location instances that are no longer present in the new
6988 list, and therefore should be freed. Note that it's not necessary that
6989 those locations should be removed from inferior -- if there's another
6990 location at the same address (previously marked as duplicate),
6991 we don't need to remove/insert the location. */
6992 for (ix
= 0; VEC_iterate(bp_location_p
, old_locations
, ix
, loc
); ++ix
)
6994 /* Tells if 'loc' is found amoung the new locations. If not, we
6996 int found_object
= 0;
6997 for (loc2
= bp_location_chain
; loc2
; loc2
= loc2
->global_next
)
7004 /* If this location is no longer present, and inserted, look if there's
7005 maybe a new location at the same address. If so, mark that one
7006 inserted, and don't remove this one. This is needed so that we
7007 don't have a time window where a breakpoint at certain location is not
7012 /* If the location is inserted now, we might have to remove it. */
7015 if (found_object
&& should_be_inserted (loc
))
7017 /* The location is still present in the location list, and still
7018 should be inserted. Don't do anything. */
7023 /* The location is either no longer present, or got disabled.
7024 See if there's another location at the same address, in which
7025 case we don't need to remove this one from the target. */
7026 if (breakpoint_address_is_meaningful (loc
->owner
))
7027 for (loc2
= bp_location_chain
; loc2
; loc2
= loc2
->global_next
)
7029 /* For the sake of should_insert_location. The
7030 call to check_duplicates will fix up this later. */
7031 loc2
->duplicate
= 0;
7032 if (should_be_inserted (loc2
)
7033 && loc2
!= loc
&& loc2
->address
== loc
->address
)
7036 loc2
->target_info
= loc
->target_info
;
7044 if (remove_breakpoint (loc
, mark_uninserted
))
7046 /* This is just about all we can do. We could keep this
7047 location on the global list, and try to remove it next
7048 time, but there's no particular reason why we will
7051 Note that at this point, loc->owner is still valid,
7052 as delete_breakpoint frees the breakpoint only
7053 after calling us. */
7054 printf_filtered (_("warning: Error removing breakpoint %d\n"),
7055 loc
->owner
->number
);
7060 free_bp_location (loc
);
7065 check_duplicates (b
);
7068 if (always_inserted_mode
&& target_has_execution
)
7069 insert_breakpoint_locations ();
7073 update_global_location_list_nothrow (void)
7075 struct gdb_exception e
;
7076 TRY_CATCH (e
, RETURN_MASK_ERROR
)
7077 update_global_location_list ();
7080 /* Delete a breakpoint and clean up all traces of it in the data
7084 delete_breakpoint (struct breakpoint
*bpt
)
7086 struct breakpoint
*b
;
7088 struct bp_location
*loc
, *next
;
7090 gdb_assert (bpt
!= NULL
);
7092 /* Has this bp already been deleted? This can happen because multiple
7093 lists can hold pointers to bp's. bpstat lists are especial culprits.
7095 One example of this happening is a watchpoint's scope bp. When the
7096 scope bp triggers, we notice that the watchpoint is out of scope, and
7097 delete it. We also delete its scope bp. But the scope bp is marked
7098 "auto-deleting", and is already on a bpstat. That bpstat is then
7099 checked for auto-deleting bp's, which are deleted.
7101 A real solution to this problem might involve reference counts in bp's,
7102 and/or giving them pointers back to their referencing bpstat's, and
7103 teaching delete_breakpoint to only free a bp's storage when no more
7104 references were extent. A cheaper bandaid was chosen. */
7105 if (bpt
->type
== bp_none
)
7108 if (deprecated_delete_breakpoint_hook
)
7109 deprecated_delete_breakpoint_hook (bpt
);
7110 breakpoint_delete_event (bpt
->number
);
7112 if (breakpoint_chain
== bpt
)
7113 breakpoint_chain
= bpt
->next
;
7118 b
->next
= bpt
->next
;
7122 free_command_lines (&bpt
->commands
);
7123 if (bpt
->cond_string
!= NULL
)
7124 xfree (bpt
->cond_string
);
7125 if (bpt
->addr_string
!= NULL
)
7126 xfree (bpt
->addr_string
);
7127 if (bpt
->exp
!= NULL
)
7129 if (bpt
->exp_string
!= NULL
)
7130 xfree (bpt
->exp_string
);
7131 if (bpt
->val
!= NULL
)
7132 value_free (bpt
->val
);
7133 if (bpt
->source_file
!= NULL
)
7134 xfree (bpt
->source_file
);
7135 if (bpt
->dll_pathname
!= NULL
)
7136 xfree (bpt
->dll_pathname
);
7137 if (bpt
->triggered_dll_pathname
!= NULL
)
7138 xfree (bpt
->triggered_dll_pathname
);
7139 if (bpt
->exec_pathname
!= NULL
)
7140 xfree (bpt
->exec_pathname
);
7142 /* Be sure no bpstat's are pointing at it after it's been freed. */
7143 /* FIXME, how can we find all bpstat's?
7144 We just check stop_bpstat for now. Note that we cannot just
7145 remove bpstats pointing at bpt from the stop_bpstat list
7146 entirely, as breakpoint commands are associated with the bpstat;
7147 if we remove it here, then the later call to
7148 bpstat_do_actions (&stop_bpstat);
7149 in event-top.c won't do anything, and temporary breakpoints
7150 with commands won't work. */
7151 for (bs
= stop_bpstat
; bs
; bs
= bs
->next
)
7152 if (bs
->breakpoint_at
&& bs
->breakpoint_at
->owner
== bpt
)
7154 bs
->breakpoint_at
= NULL
;
7156 /* bs->commands will be freed later. */
7159 /* Now that breakpoint is removed from breakpoint
7160 list, update the global location list. This
7161 will remove locations that used to belong to
7162 this breakpoint. Do this before freeing
7163 the breakpoint itself, since remove_breakpoint
7164 looks at location's owner. It might be better
7165 design to have location completely self-contained,
7166 but it's not the case now. */
7167 update_global_location_list ();
7170 /* On the chance that someone will soon try again to delete this same
7171 bp, we mark it as deleted before freeing its storage. */
7172 bpt
->type
= bp_none
;
7178 do_delete_breakpoint_cleanup (void *b
)
7180 delete_breakpoint (b
);
7184 make_cleanup_delete_breakpoint (struct breakpoint
*b
)
7186 return make_cleanup (do_delete_breakpoint_cleanup
, b
);
7190 delete_command (char *arg
, int from_tty
)
7192 struct breakpoint
*b
, *temp
;
7198 int breaks_to_delete
= 0;
7200 /* Delete all breakpoints if no argument.
7201 Do not delete internal or call-dummy breakpoints, these
7202 have to be deleted with an explicit breakpoint number argument. */
7205 if (b
->type
!= bp_call_dummy
&&
7206 b
->type
!= bp_shlib_event
&&
7207 b
->type
!= bp_thread_event
&&
7208 b
->type
!= bp_overlay_event
&&
7211 breaks_to_delete
= 1;
7216 /* Ask user only if there are some breakpoints to delete. */
7218 || (breaks_to_delete
&& query (_("Delete all breakpoints? "))))
7220 ALL_BREAKPOINTS_SAFE (b
, temp
)
7222 if (b
->type
!= bp_call_dummy
&&
7223 b
->type
!= bp_shlib_event
&&
7224 b
->type
!= bp_thread_event
&&
7225 b
->type
!= bp_overlay_event
&&
7227 delete_breakpoint (b
);
7232 map_breakpoint_numbers (arg
, delete_breakpoint
);
7236 all_locations_are_pending (struct bp_location
*loc
)
7238 for (; loc
; loc
= loc
->next
)
7239 if (!loc
->shlib_disabled
)
7244 /* Subroutine of update_breakpoint_locations to simplify it.
7245 Return non-zero if multiple fns in list LOC have the same name.
7246 Null names are ignored. */
7249 ambiguous_names_p (struct bp_location
*loc
)
7251 struct bp_location
*l
;
7252 htab_t htab
= htab_create_alloc (13, htab_hash_string
,
7253 (int (*) (const void *, const void *)) streq
,
7254 NULL
, xcalloc
, xfree
);
7256 for (l
= loc
; l
!= NULL
; l
= l
->next
)
7259 const char *name
= l
->function_name
;
7261 /* Allow for some names to be NULL, ignore them. */
7265 slot
= (const char **) htab_find_slot (htab
, (const void *) name
,
7267 /* NOTE: We can assume slot != NULL here because xcalloc never returns
7282 update_breakpoint_locations (struct breakpoint
*b
,
7283 struct symtabs_and_lines sals
)
7287 struct bp_location
*existing_locations
= b
->loc
;
7289 /* If there's no new locations, and all existing locations
7290 are pending, don't do anything. This optimizes
7291 the common case where all locations are in the same
7292 shared library, that was unloaded. We'd like to
7293 retain the location, so that when the library
7294 is loaded again, we don't loose the enabled/disabled
7295 status of the individual locations. */
7296 if (all_locations_are_pending (existing_locations
) && sals
.nelts
== 0)
7301 for (i
= 0; i
< sals
.nelts
; ++i
)
7303 struct bp_location
*new_loc
=
7304 add_location_to_breakpoint (b
, b
->type
, &(sals
.sals
[i
]));
7306 /* Reparse conditions, they might contain references to the
7308 if (b
->cond_string
!= NULL
)
7310 struct gdb_exception e
;
7313 TRY_CATCH (e
, RETURN_MASK_ERROR
)
7315 new_loc
->cond
= parse_exp_1 (&s
, block_for_pc (sals
.sals
[i
].pc
),
7320 warning (_("failed to reevaluate condition for breakpoint %d: %s"),
7321 b
->number
, e
.message
);
7322 new_loc
->enabled
= 0;
7326 if (b
->source_file
!= NULL
)
7327 xfree (b
->source_file
);
7328 if (sals
.sals
[i
].symtab
== NULL
)
7329 b
->source_file
= NULL
;
7332 savestring (sals
.sals
[i
].symtab
->filename
,
7333 strlen (sals
.sals
[i
].symtab
->filename
));
7335 if (b
->line_number
== 0)
7336 b
->line_number
= sals
.sals
[i
].line
;
7339 /* If possible, carry over 'disable' status from existing breakpoints. */
7341 struct bp_location
*e
= existing_locations
;
7342 /* If there are multiple breakpoints with the same function name,
7343 e.g. for inline functions, comparing function names won't work.
7344 Instead compare pc addresses; this is just a heuristic as things
7345 may have moved, but in practice it gives the correct answer
7346 often enough until a better solution is found. */
7347 int have_ambiguous_names
= ambiguous_names_p (b
->loc
);
7349 for (; e
; e
= e
->next
)
7351 if (!e
->enabled
&& e
->function_name
)
7353 struct bp_location
*l
= b
->loc
;
7354 if (have_ambiguous_names
)
7356 for (; l
; l
= l
->next
)
7357 if (e
->address
== l
->address
)
7365 for (; l
; l
= l
->next
)
7366 if (l
->function_name
7367 && strcmp (e
->function_name
, l
->function_name
) == 0)
7377 update_global_location_list ();
7381 /* Reset a breakpoint given it's struct breakpoint * BINT.
7382 The value we return ends up being the return value from catch_errors.
7383 Unused in this case. */
7386 breakpoint_re_set_one (void *bint
)
7388 /* get past catch_errs */
7389 struct breakpoint
*b
= (struct breakpoint
*) bint
;
7393 int *not_found_ptr
= ¬_found
;
7394 struct symtabs_and_lines sals
= {};
7395 struct symtabs_and_lines expanded
;
7397 enum enable_state save_enable
;
7398 struct gdb_exception e
;
7404 warning (_("attempted to reset apparently deleted breakpoint #%d?"),
7408 case bp_hardware_breakpoint
:
7410 case bp_catch_unload
:
7411 if (b
->addr_string
== NULL
)
7413 /* Anything without a string can't be re-set. */
7414 delete_breakpoint (b
);
7418 set_language (b
->language
);
7419 input_radix
= b
->input_radix
;
7421 TRY_CATCH (e
, RETURN_MASK_ERROR
)
7423 sals
= decode_line_1 (&s
, 1, (struct symtab
*) NULL
, 0, (char ***) NULL
,
7428 int not_found_and_ok
= 0;
7429 /* For pending breakpoints, it's expected that parsing
7430 will fail until the right shared library is loaded.
7431 User has already told to create pending breakpoints and
7432 don't need extra messages. If breakpoint is in bp_shlib_disabled
7433 state, then user already saw the message about that breakpoint
7434 being disabled, and don't want to see more errors. */
7436 && (b
->condition_not_parsed
7437 || (b
->loc
&& b
->loc
->shlib_disabled
)
7438 || b
->enable_state
== bp_disabled
))
7439 not_found_and_ok
= 1;
7441 if (!not_found_and_ok
)
7443 /* We surely don't want to warn about the same breakpoint
7444 10 times. One solution, implemented here, is disable
7445 the breakpoint on error. Another solution would be to
7446 have separate 'warning emitted' flag. Since this
7447 happens only when a binary has changed, I don't know
7448 which approach is better. */
7449 b
->enable_state
= bp_disabled
;
7450 throw_exception (e
);
7457 gdb_assert (sals
.nelts
== 1);
7458 resolve_sal_pc (&sals
.sals
[0]);
7459 if (b
->condition_not_parsed
&& s
&& s
[0])
7461 char *cond_string
= 0;
7463 find_condition_and_thread (s
, sals
.sals
[0].pc
,
7464 &cond_string
, &thread
);
7466 b
->cond_string
= cond_string
;
7468 b
->condition_not_parsed
= 0;
7470 expanded
= expand_line_sal_maybe (sals
.sals
[0]);
7471 update_breakpoint_locations (b
, expanded
);
7477 case bp_hardware_watchpoint
:
7478 case bp_read_watchpoint
:
7479 case bp_access_watchpoint
:
7480 /* Watchpoint can be either on expression using entirely global variables,
7481 or it can be on local variables.
7483 Watchpoints of the first kind are never auto-deleted, and even persist
7484 across program restarts. Since they can use variables from shared
7485 libraries, we need to reparse expression as libraries are loaded
7488 Watchpoints on local variables can also change meaning as result
7489 of solib event. For example, if a watchpoint uses both a local and
7490 a global variables in expression, it's a local watchpoint, but
7491 unloading of a shared library will make the expression invalid.
7492 This is not a very common use case, but we still re-evaluate
7493 expression, to avoid surprises to the user.
7495 Note that for local watchpoints, we re-evaluate it only if
7496 watchpoints frame id is still valid. If it's not, it means
7497 the watchpoint is out of scope and will be deleted soon. In fact,
7498 I'm not sure we'll ever be called in this case.
7500 If a local watchpoint's frame id is still valid, then
7501 b->exp_valid_block is likewise valid, and we can safely use it.
7503 Don't do anything about disabled watchpoints, since they will
7504 be reevaluated again when enabled. */
7505 update_watchpoint (b
, 1 /* reparse */);
7507 /* We needn't really do anything to reset these, since the mask
7508 that requests them is unaffected by e.g., new libraries being
7511 case bp_catch_vfork
:
7516 printf_filtered (_("Deleting unknown breakpoint type %d\n"), b
->type
);
7518 /* Delete longjmp and overlay event breakpoints; they will be
7519 reset later by breakpoint_re_set. */
7521 case bp_longjmp_resume
:
7522 case bp_overlay_event
:
7523 delete_breakpoint (b
);
7526 /* This breakpoint is special, it's set up when the inferior
7527 starts and we really don't want to touch it. */
7528 case bp_shlib_event
:
7530 /* Like bp_shlib_event, this breakpoint type is special.
7531 Once it is set up, we do not want to touch it. */
7532 case bp_thread_event
:
7534 /* Keep temporary breakpoints, which can be encountered when we step
7535 over a dlopen call and SOLIB_ADD is resetting the breakpoints.
7536 Otherwise these should have been blown away via the cleanup chain
7537 or by breakpoint_init_inferior when we rerun the executable. */
7540 case bp_watchpoint_scope
:
7542 case bp_step_resume
:
7549 /* Re-set all breakpoints after symbols have been re-loaded. */
7551 breakpoint_re_set (void)
7553 struct breakpoint
*b
, *temp
;
7554 enum language save_language
;
7555 int save_input_radix
;
7557 save_language
= current_language
->la_language
;
7558 save_input_radix
= input_radix
;
7559 ALL_BREAKPOINTS_SAFE (b
, temp
)
7561 /* Format possible error msg */
7562 char *message
= xstrprintf ("Error in re-setting breakpoint %d: ",
7564 struct cleanup
*cleanups
= make_cleanup (xfree
, message
);
7565 catch_errors (breakpoint_re_set_one
, b
, message
, RETURN_MASK_ALL
);
7566 do_cleanups (cleanups
);
7568 set_language (save_language
);
7569 input_radix
= save_input_radix
;
7571 if (gdbarch_get_longjmp_target_p (current_gdbarch
))
7573 create_longjmp_breakpoint ("longjmp");
7574 create_longjmp_breakpoint ("_longjmp");
7575 create_longjmp_breakpoint ("siglongjmp");
7576 create_longjmp_breakpoint ("_siglongjmp");
7577 create_longjmp_breakpoint (NULL
);
7580 create_overlay_event_breakpoint ("_ovly_debug_event");
7583 /* Reset the thread number of this breakpoint:
7585 - If the breakpoint is for all threads, leave it as-is.
7586 - Else, reset it to the current thread for inferior_ptid. */
7588 breakpoint_re_set_thread (struct breakpoint
*b
)
7590 if (b
->thread
!= -1)
7592 if (in_thread_list (inferior_ptid
))
7593 b
->thread
= pid_to_thread_id (inferior_ptid
);
7597 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
7598 If from_tty is nonzero, it prints a message to that effect,
7599 which ends with a period (no newline). */
7602 set_ignore_count (int bptnum
, int count
, int from_tty
)
7604 struct breakpoint
*b
;
7610 if (b
->number
== bptnum
)
7612 b
->ignore_count
= count
;
7616 printf_filtered (_("Will stop next time breakpoint %d is reached."),
7618 else if (count
== 1)
7619 printf_filtered (_("Will ignore next crossing of breakpoint %d."),
7622 printf_filtered (_("Will ignore next %d crossings of breakpoint %d."),
7625 breakpoints_changed ();
7626 breakpoint_modify_event (b
->number
);
7630 error (_("No breakpoint number %d."), bptnum
);
7633 /* Clear the ignore counts of all breakpoints. */
7635 breakpoint_clear_ignore_counts (void)
7637 struct breakpoint
*b
;
7640 b
->ignore_count
= 0;
7643 /* Command to set ignore-count of breakpoint N to COUNT. */
7646 ignore_command (char *args
, int from_tty
)
7652 error_no_arg (_("a breakpoint number"));
7654 num
= get_number (&p
);
7656 error (_("bad breakpoint number: '%s'"), args
);
7658 error (_("Second argument (specified ignore-count) is missing."));
7660 set_ignore_count (num
,
7661 longest_to_int (value_as_long (parse_and_eval (p
))),
7664 printf_filtered ("\n");
7667 /* Call FUNCTION on each of the breakpoints
7668 whose numbers are given in ARGS. */
7671 map_breakpoint_numbers (char *args
, void (*function
) (struct breakpoint
*))
7676 struct breakpoint
*b
, *tmp
;
7680 error_no_arg (_("one or more breakpoint numbers"));
7687 num
= get_number_or_range (&p1
);
7690 warning (_("bad breakpoint number at or near '%s'"), p
);
7694 ALL_BREAKPOINTS_SAFE (b
, tmp
)
7695 if (b
->number
== num
)
7697 struct breakpoint
*related_breakpoint
= b
->related_breakpoint
;
7700 if (related_breakpoint
)
7701 function (related_breakpoint
);
7705 printf_unfiltered (_("No breakpoint number %d.\n"), num
);
7711 static struct bp_location
*
7712 find_location_by_number (char *number
)
7714 char *dot
= strchr (number
, '.');
7718 struct breakpoint
*b
;
7719 struct bp_location
*loc
;
7724 bp_num
= get_number_or_range (&p1
);
7726 error (_("Bad breakpoint number '%s'"), number
);
7729 if (b
->number
== bp_num
)
7734 if (!b
|| b
->number
!= bp_num
)
7735 error (_("Bad breakpoint number '%s'"), number
);
7738 loc_num
= get_number_or_range (&p1
);
7740 error (_("Bad breakpoint location number '%s'"), number
);
7744 for (;loc_num
&& loc
; --loc_num
, loc
= loc
->next
)
7747 error (_("Bad breakpoint location number '%s'"), dot
+1);
7753 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
7754 If from_tty is nonzero, it prints a message to that effect,
7755 which ends with a period (no newline). */
7758 disable_breakpoint (struct breakpoint
*bpt
)
7760 /* Never disable a watchpoint scope breakpoint; we want to
7761 hit them when we leave scope so we can delete both the
7762 watchpoint and its scope breakpoint at that time. */
7763 if (bpt
->type
== bp_watchpoint_scope
)
7766 /* You can't disable permanent breakpoints. */
7767 if (bpt
->enable_state
== bp_permanent
)
7770 bpt
->enable_state
= bp_disabled
;
7772 update_global_location_list ();
7774 if (deprecated_modify_breakpoint_hook
)
7775 deprecated_modify_breakpoint_hook (bpt
);
7776 breakpoint_modify_event (bpt
->number
);
7780 disable_command (char *args
, int from_tty
)
7782 struct breakpoint
*bpt
;
7784 ALL_BREAKPOINTS (bpt
)
7788 warning (_("attempted to disable apparently deleted breakpoint #%d?"),
7793 case bp_catch_unload
:
7795 case bp_catch_vfork
:
7797 case bp_hardware_breakpoint
:
7799 case bp_hardware_watchpoint
:
7800 case bp_read_watchpoint
:
7801 case bp_access_watchpoint
:
7802 disable_breakpoint (bpt
);
7806 else if (strchr (args
, '.'))
7808 struct bp_location
*loc
= find_location_by_number (args
);
7811 update_global_location_list ();
7814 map_breakpoint_numbers (args
, disable_breakpoint
);
7818 do_enable_breakpoint (struct breakpoint
*bpt
, enum bpdisp disposition
)
7820 int target_resources_ok
, other_type_used
;
7823 if (bpt
->type
== bp_hardware_breakpoint
)
7826 i
= hw_breakpoint_used_count ();
7827 target_resources_ok
=
7828 TARGET_CAN_USE_HARDWARE_WATCHPOINT (bp_hardware_breakpoint
,
7830 if (target_resources_ok
== 0)
7831 error (_("No hardware breakpoint support in the target."));
7832 else if (target_resources_ok
< 0)
7833 error (_("Hardware breakpoints used exceeds limit."));
7836 if (bpt
->type
== bp_watchpoint
||
7837 bpt
->type
== bp_hardware_watchpoint
||
7838 bpt
->type
== bp_read_watchpoint
||
7839 bpt
->type
== bp_access_watchpoint
)
7841 struct frame_id saved_frame_id
;
7843 saved_frame_id
= get_frame_id (get_selected_frame (NULL
));
7844 if (bpt
->exp_valid_block
!= NULL
)
7846 struct frame_info
*fr
=
7847 fr
= frame_find_by_id (bpt
->watchpoint_frame
);
7850 printf_filtered (_("\
7851 Cannot enable watchpoint %d because the block in which its expression\n\
7852 is valid is not currently in scope.\n"), bpt
->number
);
7859 value_free (bpt
->val
);
7860 mark
= value_mark ();
7861 fetch_watchpoint_value (bpt
->exp
, &bpt
->val
, NULL
, NULL
);
7863 release_value (bpt
->val
);
7866 if (bpt
->type
== bp_hardware_watchpoint
||
7867 bpt
->type
== bp_read_watchpoint
||
7868 bpt
->type
== bp_access_watchpoint
)
7870 int i
= hw_watchpoint_used_count (bpt
->type
, &other_type_used
);
7871 int mem_cnt
= can_use_hardware_watchpoint (bpt
->val
);
7873 /* Hack around 'unused var' error for some targets here */
7874 (void) mem_cnt
, (void) i
;
7875 target_resources_ok
= TARGET_CAN_USE_HARDWARE_WATCHPOINT (
7876 bpt
->type
, i
+ mem_cnt
, other_type_used
);
7877 /* we can consider of type is bp_hardware_watchpoint, convert to
7878 bp_watchpoint in the following condition */
7879 if (target_resources_ok
< 0)
7881 printf_filtered (_("\
7882 Cannot enable watchpoint %d because target watch resources\n\
7883 have been allocated for other watchpoints.\n"), bpt
->number
);
7884 value_free_to_mark (mark
);
7889 select_frame (frame_find_by_id (saved_frame_id
));
7890 value_free_to_mark (mark
);
7893 if (bpt
->enable_state
!= bp_permanent
)
7894 bpt
->enable_state
= bp_enabled
;
7895 bpt
->disposition
= disposition
;
7896 update_global_location_list ();
7897 breakpoints_changed ();
7899 if (deprecated_modify_breakpoint_hook
)
7900 deprecated_modify_breakpoint_hook (bpt
);
7901 breakpoint_modify_event (bpt
->number
);
7906 enable_breakpoint (struct breakpoint
*bpt
)
7908 do_enable_breakpoint (bpt
, bpt
->disposition
);
7911 /* The enable command enables the specified breakpoints (or all defined
7912 breakpoints) so they once again become (or continue to be) effective
7913 in stopping the inferior. */
7916 enable_command (char *args
, int from_tty
)
7918 struct breakpoint
*bpt
;
7920 ALL_BREAKPOINTS (bpt
)
7924 warning (_("attempted to enable apparently deleted breakpoint #%d?"),
7929 case bp_catch_unload
:
7931 case bp_catch_vfork
:
7933 case bp_hardware_breakpoint
:
7935 case bp_hardware_watchpoint
:
7936 case bp_read_watchpoint
:
7937 case bp_access_watchpoint
:
7938 enable_breakpoint (bpt
);
7942 else if (strchr (args
, '.'))
7944 struct bp_location
*loc
= find_location_by_number (args
);
7947 update_global_location_list ();
7950 map_breakpoint_numbers (args
, enable_breakpoint
);
7954 enable_once_breakpoint (struct breakpoint
*bpt
)
7956 do_enable_breakpoint (bpt
, disp_disable
);
7960 enable_once_command (char *args
, int from_tty
)
7962 map_breakpoint_numbers (args
, enable_once_breakpoint
);
7966 enable_delete_breakpoint (struct breakpoint
*bpt
)
7968 do_enable_breakpoint (bpt
, disp_del
);
7972 enable_delete_command (char *args
, int from_tty
)
7974 map_breakpoint_numbers (args
, enable_delete_breakpoint
);
7978 set_breakpoint_cmd (char *args
, int from_tty
)
7983 show_breakpoint_cmd (char *args
, int from_tty
)
7987 /* Use default_breakpoint_'s, or nothing if they aren't valid. */
7989 struct symtabs_and_lines
7990 decode_line_spec_1 (char *string
, int funfirstline
)
7992 struct symtabs_and_lines sals
;
7994 error (_("Empty line specification."));
7995 if (default_breakpoint_valid
)
7996 sals
= decode_line_1 (&string
, funfirstline
,
7997 default_breakpoint_symtab
,
7998 default_breakpoint_line
,
7999 (char ***) NULL
, NULL
);
8001 sals
= decode_line_1 (&string
, funfirstline
,
8002 (struct symtab
*) NULL
, 0, (char ***) NULL
, NULL
);
8004 error (_("Junk at end of line specification: %s"), string
);
8008 /* Create and insert a raw software breakpoint at PC. Return an
8009 identifier, which should be used to remove the breakpoint later.
8010 In general, places which call this should be using something on the
8011 breakpoint chain instead; this function should be eliminated
8015 deprecated_insert_raw_breakpoint (CORE_ADDR pc
)
8017 struct bp_target_info
*bp_tgt
;
8019 bp_tgt
= xmalloc (sizeof (struct bp_target_info
));
8020 memset (bp_tgt
, 0, sizeof (struct bp_target_info
));
8022 bp_tgt
->placed_address
= pc
;
8023 if (target_insert_breakpoint (bp_tgt
) != 0)
8025 /* Could not insert the breakpoint. */
8033 /* Remove a breakpoint BP inserted by deprecated_insert_raw_breakpoint. */
8036 deprecated_remove_raw_breakpoint (void *bp
)
8038 struct bp_target_info
*bp_tgt
= bp
;
8041 ret
= target_remove_breakpoint (bp_tgt
);
8047 /* One (or perhaps two) breakpoints used for software single stepping. */
8049 static void *single_step_breakpoints
[2];
8051 /* Create and insert a breakpoint for software single step. */
8054 insert_single_step_breakpoint (CORE_ADDR next_pc
)
8058 if (single_step_breakpoints
[0] == NULL
)
8059 bpt_p
= &single_step_breakpoints
[0];
8062 gdb_assert (single_step_breakpoints
[1] == NULL
);
8063 bpt_p
= &single_step_breakpoints
[1];
8066 /* NOTE drow/2006-04-11: A future improvement to this function would be
8067 to only create the breakpoints once, and actually put them on the
8068 breakpoint chain. That would let us use set_raw_breakpoint. We could
8069 adjust the addresses each time they were needed. Doing this requires
8070 corresponding changes elsewhere where single step breakpoints are
8071 handled, however. So, for now, we use this. */
8073 *bpt_p
= deprecated_insert_raw_breakpoint (next_pc
);
8075 error (_("Could not insert single-step breakpoint at 0x%s"),
8076 paddr_nz (next_pc
));
8079 /* Remove and delete any breakpoints used for software single step. */
8082 remove_single_step_breakpoints (void)
8084 gdb_assert (single_step_breakpoints
[0] != NULL
);
8086 /* See insert_single_step_breakpoint for more about this deprecated
8088 deprecated_remove_raw_breakpoint (single_step_breakpoints
[0]);
8089 single_step_breakpoints
[0] = NULL
;
8091 if (single_step_breakpoints
[1] != NULL
)
8093 deprecated_remove_raw_breakpoint (single_step_breakpoints
[1]);
8094 single_step_breakpoints
[1] = NULL
;
8098 /* Check whether a software single-step breakpoint is inserted at PC. */
8101 single_step_breakpoint_inserted_here_p (CORE_ADDR pc
)
8105 for (i
= 0; i
< 2; i
++)
8107 struct bp_target_info
*bp_tgt
= single_step_breakpoints
[i
];
8108 if (bp_tgt
&& bp_tgt
->placed_address
== pc
)
8115 int breakpoints_always_inserted_mode (void)
8117 return always_inserted_mode
;
8121 /* This help string is used for the break, hbreak, tbreak and thbreak commands.
8122 It is defined as a macro to prevent duplication.
8123 COMMAND should be a string constant containing the name of the command. */
8124 #define BREAK_ARGS_HELP(command) \
8125 command" [LOCATION] [thread THREADNUM] [if CONDITION]\n\
8126 LOCATION may be a line number, function name, or \"*\" and an address.\n\
8127 If a line number is specified, break at start of code for that line.\n\
8128 If a function is specified, break at start of code for that function.\n\
8129 If an address is specified, break at that exact address.\n\
8130 With no LOCATION, uses current execution address of selected stack frame.\n\
8131 This is useful for breaking on return to a stack frame.\n\
8133 THREADNUM is the number from \"info threads\".\n\
8134 CONDITION is a boolean expression.\n\
8136 Multiple breakpoints at one place are permitted, and useful if conditional.\n\
8138 Do \"help breakpoints\" for info on other commands dealing with breakpoints."
8141 _initialize_breakpoint (void)
8143 static struct cmd_list_element
*breakpoint_set_cmdlist
;
8144 static struct cmd_list_element
*breakpoint_show_cmdlist
;
8145 struct cmd_list_element
*c
;
8147 observer_attach_solib_unloaded (disable_breakpoints_in_unloaded_shlib
);
8149 breakpoint_chain
= 0;
8150 /* Don't bother to call set_breakpoint_count. $bpnum isn't useful
8151 before a breakpoint is set. */
8152 breakpoint_count
= 0;
8154 add_com ("ignore", class_breakpoint
, ignore_command
, _("\
8155 Set ignore-count of breakpoint number N to COUNT.\n\
8156 Usage is `ignore N COUNT'."));
8158 add_com_alias ("bc", "ignore", class_breakpoint
, 1);
8160 add_com ("commands", class_breakpoint
, commands_command
, _("\
8161 Set commands to be executed when a breakpoint is hit.\n\
8162 Give breakpoint number as argument after \"commands\".\n\
8163 With no argument, the targeted breakpoint is the last one set.\n\
8164 The commands themselves follow starting on the next line.\n\
8165 Type a line containing \"end\" to indicate the end of them.\n\
8166 Give \"silent\" as the first line to make the breakpoint silent;\n\
8167 then no output is printed when it is hit, except what the commands print."));
8169 add_com ("condition", class_breakpoint
, condition_command
, _("\
8170 Specify breakpoint number N to break only if COND is true.\n\
8171 Usage is `condition N COND', where N is an integer and COND is an\n\
8172 expression to be evaluated whenever breakpoint N is reached."));
8174 c
= add_com ("tbreak", class_breakpoint
, tbreak_command
, _("\
8175 Set a temporary breakpoint.\n\
8176 Like \"break\" except the breakpoint is only temporary,\n\
8177 so it will be deleted when hit. Equivalent to \"break\" followed\n\
8178 by using \"enable delete\" on the breakpoint number.\n\
8180 BREAK_ARGS_HELP ("tbreak")));
8181 set_cmd_completer (c
, location_completer
);
8183 c
= add_com ("hbreak", class_breakpoint
, hbreak_command
, _("\
8184 Set a hardware assisted breakpoint.\n\
8185 Like \"break\" except the breakpoint requires hardware support,\n\
8186 some target hardware may not have this support.\n\
8188 BREAK_ARGS_HELP ("hbreak")));
8189 set_cmd_completer (c
, location_completer
);
8191 c
= add_com ("thbreak", class_breakpoint
, thbreak_command
, _("\
8192 Set a temporary hardware assisted breakpoint.\n\
8193 Like \"hbreak\" except the breakpoint is only temporary,\n\
8194 so it will be deleted when hit.\n\
8196 BREAK_ARGS_HELP ("thbreak")));
8197 set_cmd_completer (c
, location_completer
);
8199 add_prefix_cmd ("enable", class_breakpoint
, enable_command
, _("\
8200 Enable some breakpoints.\n\
8201 Give breakpoint numbers (separated by spaces) as arguments.\n\
8202 With no subcommand, breakpoints are enabled until you command otherwise.\n\
8203 This is used to cancel the effect of the \"disable\" command.\n\
8204 With a subcommand you can enable temporarily."),
8205 &enablelist
, "enable ", 1, &cmdlist
);
8207 add_com ("ab", class_breakpoint
, enable_command
, _("\
8208 Enable some breakpoints.\n\
8209 Give breakpoint numbers (separated by spaces) as arguments.\n\
8210 With no subcommand, breakpoints are enabled until you command otherwise.\n\
8211 This is used to cancel the effect of the \"disable\" command.\n\
8212 With a subcommand you can enable temporarily."));
8214 add_com_alias ("en", "enable", class_breakpoint
, 1);
8216 add_abbrev_prefix_cmd ("breakpoints", class_breakpoint
, enable_command
, _("\
8217 Enable some breakpoints.\n\
8218 Give breakpoint numbers (separated by spaces) as arguments.\n\
8219 This is used to cancel the effect of the \"disable\" command.\n\
8220 May be abbreviated to simply \"enable\".\n"),
8221 &enablebreaklist
, "enable breakpoints ", 1, &enablelist
);
8223 add_cmd ("once", no_class
, enable_once_command
, _("\
8224 Enable breakpoints for one hit. Give breakpoint numbers.\n\
8225 If a breakpoint is hit while enabled in this fashion, it becomes disabled."),
8228 add_cmd ("delete", no_class
, enable_delete_command
, _("\
8229 Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
8230 If a breakpoint is hit while enabled in this fashion, it is deleted."),
8233 add_cmd ("delete", no_class
, enable_delete_command
, _("\
8234 Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
8235 If a breakpoint is hit while enabled in this fashion, it is deleted."),
8238 add_cmd ("once", no_class
, enable_once_command
, _("\
8239 Enable breakpoints for one hit. Give breakpoint numbers.\n\
8240 If a breakpoint is hit while enabled in this fashion, it becomes disabled."),
8243 add_prefix_cmd ("disable", class_breakpoint
, disable_command
, _("\
8244 Disable some breakpoints.\n\
8245 Arguments are breakpoint numbers with spaces in between.\n\
8246 To disable all breakpoints, give no argument.\n\
8247 A disabled breakpoint is not forgotten, but has no effect until reenabled."),
8248 &disablelist
, "disable ", 1, &cmdlist
);
8249 add_com_alias ("dis", "disable", class_breakpoint
, 1);
8250 add_com_alias ("disa", "disable", class_breakpoint
, 1);
8252 add_com ("sb", class_breakpoint
, disable_command
, _("\
8253 Disable some breakpoints.\n\
8254 Arguments are breakpoint numbers with spaces in between.\n\
8255 To disable all breakpoints, give no argument.\n\
8256 A disabled breakpoint is not forgotten, but has no effect until reenabled."));
8258 add_cmd ("breakpoints", class_alias
, disable_command
, _("\
8259 Disable some breakpoints.\n\
8260 Arguments are breakpoint numbers with spaces in between.\n\
8261 To disable all breakpoints, give no argument.\n\
8262 A disabled breakpoint is not forgotten, but has no effect until reenabled.\n\
8263 This command may be abbreviated \"disable\"."),
8266 add_prefix_cmd ("delete", class_breakpoint
, delete_command
, _("\
8267 Delete some breakpoints or auto-display expressions.\n\
8268 Arguments are breakpoint numbers with spaces in between.\n\
8269 To delete all breakpoints, give no argument.\n\
8271 Also a prefix command for deletion of other GDB objects.\n\
8272 The \"unset\" command is also an alias for \"delete\"."),
8273 &deletelist
, "delete ", 1, &cmdlist
);
8274 add_com_alias ("d", "delete", class_breakpoint
, 1);
8275 add_com_alias ("del", "delete", class_breakpoint
, 1);
8277 add_com ("db", class_breakpoint
, delete_command
, _("\
8278 Delete some breakpoints.\n\
8279 Arguments are breakpoint numbers with spaces in between.\n\
8280 To delete all breakpoints, give no argument.\n"));
8282 add_cmd ("breakpoints", class_alias
, delete_command
, _("\
8283 Delete some breakpoints or auto-display expressions.\n\
8284 Arguments are breakpoint numbers with spaces in between.\n\
8285 To delete all breakpoints, give no argument.\n\
8286 This command may be abbreviated \"delete\"."),
8289 add_com ("clear", class_breakpoint
, clear_command
, _("\
8290 Clear breakpoint at specified line or function.\n\
8291 Argument may be line number, function name, or \"*\" and an address.\n\
8292 If line number is specified, all breakpoints in that line are cleared.\n\
8293 If function is specified, breakpoints at beginning of function are cleared.\n\
8294 If an address is specified, breakpoints at that address are cleared.\n\
8296 With no argument, clears all breakpoints in the line that the selected frame\n\
8299 See also the \"delete\" command which clears breakpoints by number."));
8301 c
= add_com ("break", class_breakpoint
, break_command
, _("\
8302 Set breakpoint at specified line or function.\n"
8303 BREAK_ARGS_HELP ("break")));
8304 set_cmd_completer (c
, location_completer
);
8306 add_com_alias ("b", "break", class_run
, 1);
8307 add_com_alias ("br", "break", class_run
, 1);
8308 add_com_alias ("bre", "break", class_run
, 1);
8309 add_com_alias ("brea", "break", class_run
, 1);
8313 add_com_alias ("ba", "break", class_breakpoint
, 1);
8314 add_com_alias ("bu", "ubreak", class_breakpoint
, 1);
8319 add_abbrev_prefix_cmd ("stop", class_breakpoint
, stop_command
, _("\
8320 Break in function/address or break at a line in the current file."),
8321 &stoplist
, "stop ", 1, &cmdlist
);
8322 add_cmd ("in", class_breakpoint
, stopin_command
,
8323 _("Break in function or address."), &stoplist
);
8324 add_cmd ("at", class_breakpoint
, stopat_command
,
8325 _("Break at a line in the current file."), &stoplist
);
8326 add_com ("status", class_info
, breakpoints_info
, _("\
8327 Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
8328 The \"Type\" column indicates one of:\n\
8329 \tbreakpoint - normal breakpoint\n\
8330 \twatchpoint - watchpoint\n\
8331 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
8332 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
8333 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
8334 address and file/line number respectively.\n\
8336 Convenience variable \"$_\" and default examine address for \"x\"\n\
8337 are set to the address of the last breakpoint listed unless the command\n\
8338 is prefixed with \"server \".\n\n\
8339 Convenience variable \"$bpnum\" contains the number of the last\n\
8343 add_info ("breakpoints", breakpoints_info
, _("\
8344 Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
8345 The \"Type\" column indicates one of:\n\
8346 \tbreakpoint - normal breakpoint\n\
8347 \twatchpoint - watchpoint\n\
8348 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
8349 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
8350 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
8351 address and file/line number respectively.\n\
8353 Convenience variable \"$_\" and default examine address for \"x\"\n\
8354 are set to the address of the last breakpoint listed unless the command\n\
8355 is prefixed with \"server \".\n\n\
8356 Convenience variable \"$bpnum\" contains the number of the last\n\
8360 add_com ("lb", class_breakpoint
, breakpoints_info
, _("\
8361 Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
8362 The \"Type\" column indicates one of:\n\
8363 \tbreakpoint - normal breakpoint\n\
8364 \twatchpoint - watchpoint\n\
8365 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
8366 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
8367 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
8368 address and file/line number respectively.\n\
8370 Convenience variable \"$_\" and default examine address for \"x\"\n\
8371 are set to the address of the last breakpoint listed unless the command\n\
8372 is prefixed with \"server \".\n\n\
8373 Convenience variable \"$bpnum\" contains the number of the last\n\
8376 add_cmd ("breakpoints", class_maintenance
, maintenance_info_breakpoints
, _("\
8377 Status of all breakpoints, or breakpoint number NUMBER.\n\
8378 The \"Type\" column indicates one of:\n\
8379 \tbreakpoint - normal breakpoint\n\
8380 \twatchpoint - watchpoint\n\
8381 \tlongjmp - internal breakpoint used to step through longjmp()\n\
8382 \tlongjmp resume - internal breakpoint at the target of longjmp()\n\
8383 \tuntil - internal breakpoint used by the \"until\" command\n\
8384 \tfinish - internal breakpoint used by the \"finish\" command\n\
8385 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
8386 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
8387 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
8388 address and file/line number respectively.\n\
8390 Convenience variable \"$_\" and default examine address for \"x\"\n\
8391 are set to the address of the last breakpoint listed unless the command\n\
8392 is prefixed with \"server \".\n\n\
8393 Convenience variable \"$bpnum\" contains the number of the last\n\
8395 &maintenanceinfolist
);
8397 add_com ("catch", class_breakpoint
, catch_command
, _("\
8398 Set catchpoints to catch events.\n\
8399 Raised signals may be caught:\n\
8400 \tcatch signal - all signals\n\
8401 \tcatch signal <signame> - a particular signal\n\
8402 Raised exceptions may be caught:\n\
8403 \tcatch throw - all exceptions, when thrown\n\
8404 \tcatch throw <exceptname> - a particular exception, when thrown\n\
8405 \tcatch catch - all exceptions, when caught\n\
8406 \tcatch catch <exceptname> - a particular exception, when caught\n\
8407 Thread or process events may be caught:\n\
8408 \tcatch thread_start - any threads, just after creation\n\
8409 \tcatch thread_exit - any threads, just before expiration\n\
8410 \tcatch thread_join - any threads, just after joins\n\
8411 Process events may be caught:\n\
8412 \tcatch start - any processes, just after creation\n\
8413 \tcatch exit - any processes, just before expiration\n\
8414 \tcatch fork - calls to fork()\n\
8415 \tcatch vfork - calls to vfork()\n\
8416 \tcatch exec - calls to exec()\n\
8417 Dynamically-linked library events may be caught:\n\
8418 \tcatch load - loads of any library\n\
8419 \tcatch load <libname> - loads of a particular library\n\
8420 \tcatch unload - unloads of any library\n\
8421 \tcatch unload <libname> - unloads of a particular library\n\
8422 The act of your program's execution stopping may also be caught:\n\
8424 C++ exceptions may be caught:\n\
8425 \tcatch throw - all exceptions, when thrown\n\
8426 \tcatch catch - all exceptions, when caught\n\
8427 Ada exceptions may be caught:\n\
8428 \tcatch exception - all exceptions, when raised\n\
8429 \tcatch exception <name> - a particular exception, when raised\n\
8430 \tcatch exception unhandled - all unhandled exceptions, when raised\n\
8431 \tcatch assert - all failed assertions, when raised\n\
8433 Do \"help set follow-fork-mode\" for info on debugging your program\n\
8434 after a fork or vfork is caught.\n\n\
8435 Do \"help breakpoints\" for info on other commands dealing with breakpoints."));
8437 add_com ("tcatch", class_breakpoint
, tcatch_command
, _("\
8438 Set temporary catchpoints to catch events.\n\
8439 Args like \"catch\" command.\n\
8440 Like \"catch\" except the catchpoint is only temporary,\n\
8441 so it will be deleted when hit. Equivalent to \"catch\" followed\n\
8442 by using \"enable delete\" on the catchpoint number."));
8444 c
= add_com ("watch", class_breakpoint
, watch_command
, _("\
8445 Set a watchpoint for an expression.\n\
8446 A watchpoint stops execution of your program whenever the value of\n\
8447 an expression changes."));
8448 set_cmd_completer (c
, location_completer
);
8450 c
= add_com ("rwatch", class_breakpoint
, rwatch_command
, _("\
8451 Set a read watchpoint for an expression.\n\
8452 A watchpoint stops execution of your program whenever the value of\n\
8453 an expression is read."));
8454 set_cmd_completer (c
, location_completer
);
8456 c
= add_com ("awatch", class_breakpoint
, awatch_command
, _("\
8457 Set a watchpoint for an expression.\n\
8458 A watchpoint stops execution of your program whenever the value of\n\
8459 an expression is either read or written."));
8460 set_cmd_completer (c
, location_completer
);
8462 add_info ("watchpoints", breakpoints_info
,
8463 _("Synonym for ``info breakpoints''."));
8466 /* XXX: cagney/2005-02-23: This should be a boolean, and should
8467 respond to changes - contrary to the description. */
8468 add_setshow_zinteger_cmd ("can-use-hw-watchpoints", class_support
,
8469 &can_use_hw_watchpoints
, _("\
8470 Set debugger's willingness to use watchpoint hardware."), _("\
8471 Show debugger's willingness to use watchpoint hardware."), _("\
8472 If zero, gdb will not use hardware for new watchpoints, even if\n\
8473 such is available. (However, any hardware watchpoints that were\n\
8474 created before setting this to nonzero, will continue to use watchpoint\n\
8477 show_can_use_hw_watchpoints
,
8478 &setlist
, &showlist
);
8480 can_use_hw_watchpoints
= 1;
8482 add_prefix_cmd ("breakpoint", class_maintenance
, set_breakpoint_cmd
, _("\
8483 Breakpoint specific settings\n\
8484 Configure various breakpoint-specific variables such as\n\
8485 pending breakpoint behavior"),
8486 &breakpoint_set_cmdlist
, "set breakpoint ",
8487 0/*allow-unknown*/, &setlist
);
8488 add_prefix_cmd ("breakpoint", class_maintenance
, show_breakpoint_cmd
, _("\
8489 Breakpoint specific settings\n\
8490 Configure various breakpoint-specific variables such as\n\
8491 pending breakpoint behavior"),
8492 &breakpoint_show_cmdlist
, "show breakpoint ",
8493 0/*allow-unknown*/, &showlist
);
8495 add_setshow_auto_boolean_cmd ("pending", no_class
,
8496 &pending_break_support
, _("\
8497 Set debugger's behavior regarding pending breakpoints."), _("\
8498 Show debugger's behavior regarding pending breakpoints."), _("\
8499 If on, an unrecognized breakpoint location will cause gdb to create a\n\
8500 pending breakpoint. If off, an unrecognized breakpoint location results in\n\
8501 an error. If auto, an unrecognized breakpoint location results in a\n\
8502 user-query to see if a pending breakpoint should be created."),
8504 show_pending_break_support
,
8505 &breakpoint_set_cmdlist
,
8506 &breakpoint_show_cmdlist
);
8508 pending_break_support
= AUTO_BOOLEAN_AUTO
;
8510 add_setshow_boolean_cmd ("auto-hw", no_class
,
8511 &automatic_hardware_breakpoints
, _("\
8512 Set automatic usage of hardware breakpoints."), _("\
8513 Show automatic usage of hardware breakpoints."), _("\
8514 If set, the debugger will automatically use hardware breakpoints for\n\
8515 breakpoints set with \"break\" but falling in read-only memory. If not set,\n\
8516 a warning will be emitted for such breakpoints."),
8518 show_automatic_hardware_breakpoints
,
8519 &breakpoint_set_cmdlist
,
8520 &breakpoint_show_cmdlist
);
8522 add_setshow_boolean_cmd ("always-inserted", class_support
,
8523 &always_inserted_mode
, _("\
8524 Set mode for inserting breakpoints."), _("\
8525 Show mode for inserting breakpoints."), _("\
8526 When this mode is off (which is the default), breakpoints are inserted in\n\
8527 inferior when it is resumed, and removed when execution stops. When this\n\
8528 mode is on, breakpoints are inserted immediately and removed only when\n\
8529 the user deletes the breakpoint."),
8531 &show_always_inserted_mode
,
8532 &breakpoint_set_cmdlist
,
8533 &breakpoint_show_cmdlist
);
8535 automatic_hardware_breakpoints
= 1;