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
);
144 static int watchpoint_check (void *);
146 static void maintenance_info_breakpoints (char *, int);
148 static void create_overlay_event_breakpoint (char *);
150 static int hw_breakpoint_used_count (void);
152 static int hw_watchpoint_used_count (enum bptype
, int *);
154 static void hbreak_command (char *, int);
156 static void thbreak_command (char *, int);
158 static void watch_command_1 (char *, int, int);
160 static void rwatch_command (char *, int);
162 static void awatch_command (char *, int);
164 static void do_enable_breakpoint (struct breakpoint
*, enum bpdisp
);
166 static void create_fork_vfork_event_catchpoint (int tempflag
,
168 enum bptype bp_kind
);
170 static void stop_command (char *arg
, int from_tty
);
172 static void stopin_command (char *arg
, int from_tty
);
174 static void stopat_command (char *arg
, int from_tty
);
176 static char *ep_find_event_name_end (char *arg
);
178 static char *ep_parse_optional_if_clause (char **arg
);
180 static char *ep_parse_optional_filename (char **arg
);
182 static void catch_exception_command_1 (enum exception_event_kind ex_event
,
183 char *arg
, int tempflag
, int from_tty
);
185 static void tcatch_command (char *arg
, int from_tty
);
187 static void ep_skip_leading_whitespace (char **s
);
189 static int single_step_breakpoint_inserted_here_p (CORE_ADDR pc
);
191 static void free_bp_location (struct bp_location
*loc
);
193 static void mark_breakpoints_out (void);
195 static struct bp_location
*
196 allocate_bp_location (struct breakpoint
*bpt
, enum bptype bp_type
);
198 static void update_global_location_list (void);
200 static void update_global_location_list_nothrow (void);
202 static int is_hardware_watchpoint (struct breakpoint
*bpt
);
204 static void insert_breakpoint_locations (void);
207 bpdisp_text (enum bpdisp disp
)
209 /* NOTE: the following values are a part of MI protocol and represent
210 values of 'disp' field returned when inferior stops at a breakpoint. */
211 static char *bpdisps
[] = {"del", "dstp", "dis", "keep"};
212 return bpdisps
[(int) disp
];
215 /* Prototypes for exported functions. */
216 /* If FALSE, gdb will not use hardware support for watchpoints, even
217 if such is available. */
218 static int can_use_hw_watchpoints
;
221 show_can_use_hw_watchpoints (struct ui_file
*file
, int from_tty
,
222 struct cmd_list_element
*c
,
225 fprintf_filtered (file
, _("\
226 Debugger's willingness to use watchpoint hardware is %s.\n"),
230 /* If AUTO_BOOLEAN_FALSE, gdb will not attempt to create pending breakpoints.
231 If AUTO_BOOLEAN_TRUE, gdb will automatically create pending breakpoints
232 for unrecognized breakpoint locations.
233 If AUTO_BOOLEAN_AUTO, gdb will query when breakpoints are unrecognized. */
234 static enum auto_boolean pending_break_support
;
236 show_pending_break_support (struct ui_file
*file
, int from_tty
,
237 struct cmd_list_element
*c
,
240 fprintf_filtered (file
, _("\
241 Debugger's behavior regarding pending breakpoints is %s.\n"),
245 /* If 1, gdb will automatically use hardware breakpoints for breakpoints
246 set with "break" but falling in read-only memory.
247 If 0, gdb will warn about such breakpoints, but won't automatically
248 use hardware breakpoints. */
249 static int automatic_hardware_breakpoints
;
251 show_automatic_hardware_breakpoints (struct ui_file
*file
, int from_tty
,
252 struct cmd_list_element
*c
,
255 fprintf_filtered (file
, _("\
256 Automatic usage of hardware breakpoints is %s.\n"),
260 /* If 1, gdb will keep breakpoints inserted even as inferior is stopped,
261 and immediately insert any new breakpoints. If 0, gdb will insert
262 breakpoints into inferior only when resuming it, and will remove
263 breakpoints upon stop. */
264 static int always_inserted_mode
= 0;
266 show_always_inserted_mode (struct ui_file
*file
, int from_tty
,
267 struct cmd_list_element
*c
, const char *value
)
269 fprintf_filtered (file
, _("Always inserted breakpoint mode is %s.\n"), value
);
273 void _initialize_breakpoint (void);
275 extern int addressprint
; /* Print machine addresses? */
277 /* Are we executing breakpoint commands? */
278 static int executing_breakpoint_commands
;
280 /* Are overlay event breakpoints enabled? */
281 static int overlay_events_enabled
;
283 /* Walk the following statement or block through all breakpoints.
284 ALL_BREAKPOINTS_SAFE does so even if the statment deletes the current
287 #define ALL_BREAKPOINTS(B) for (B = breakpoint_chain; B; B = B->next)
289 #define ALL_BREAKPOINTS_SAFE(B,TMP) \
290 for (B = breakpoint_chain; \
291 B ? (TMP=B->next, 1): 0; \
294 /* Similar iterators for the low-level breakpoints. */
296 #define ALL_BP_LOCATIONS(B) for (B = bp_location_chain; B; B = B->global_next)
298 #define ALL_BP_LOCATIONS_SAFE(B,TMP) \
299 for (B = bp_location_chain; \
300 B ? (TMP=B->global_next, 1): 0; \
303 /* True if breakpoint hit counts should be displayed in breakpoint info. */
305 int show_breakpoint_hit_counts
= 1;
307 /* Chains of all breakpoints defined. */
309 struct breakpoint
*breakpoint_chain
;
311 struct bp_location
*bp_location_chain
;
313 /* Number of last breakpoint made. */
315 int breakpoint_count
;
317 /* This function returns a pointer to the string representation of the
318 pathname of the dynamically-linked library that has just been
321 This function must be used only when SOLIB_HAVE_LOAD_EVENT is TRUE,
322 or undefined results are guaranteed.
324 This string's contents are only valid immediately after the
325 inferior has stopped in the dynamic linker hook, and becomes
326 invalid as soon as the inferior is continued. Clients should make
327 a copy of this string if they wish to continue the inferior and
328 then access the string. */
330 #ifndef SOLIB_LOADED_LIBRARY_PATHNAME
331 #define SOLIB_LOADED_LIBRARY_PATHNAME(pid) ""
334 /* This function returns a pointer to the string representation of the
335 pathname of the dynamically-linked library that has just been
338 This function must be used only when SOLIB_HAVE_UNLOAD_EVENT is
339 TRUE, or undefined results are guaranteed.
341 This string's contents are only valid immediately after the
342 inferior has stopped in the dynamic linker hook, and becomes
343 invalid as soon as the inferior is continued. Clients should make
344 a copy of this string if they wish to continue the inferior and
345 then access the string. */
347 #ifndef SOLIB_UNLOADED_LIBRARY_PATHNAME
348 #define SOLIB_UNLOADED_LIBRARY_PATHNAME(pid) ""
351 /* This function is called by the "catch load" command. It allows the
352 debugger to be notified by the dynamic linker when a specified
353 library file (or any library file, if filename is NULL) is loaded. */
355 #ifndef SOLIB_CREATE_CATCH_LOAD_HOOK
356 #define SOLIB_CREATE_CATCH_LOAD_HOOK(pid,tempflag,filename,cond_string) \
357 error (_("catch of library loads not yet implemented on this platform"))
360 /* This function is called by the "catch unload" command. It allows
361 the debugger to be notified by the dynamic linker when a specified
362 library file (or any library file, if filename is NULL) is
365 #ifndef SOLIB_CREATE_CATCH_UNLOAD_HOOK
366 #define SOLIB_CREATE_CATCH_UNLOAD_HOOK(pid, tempflag, filename, cond_string) \
367 error (_("catch of library unloads not yet implemented on this platform"))
370 /* Return whether a breakpoint is an active enabled breakpoint. */
372 breakpoint_enabled (struct breakpoint
*b
)
374 return (b
->enable_state
== bp_enabled
);
377 /* Set breakpoint count to NUM. */
380 set_breakpoint_count (int num
)
382 breakpoint_count
= num
;
383 set_internalvar (lookup_internalvar ("bpnum"),
384 value_from_longest (builtin_type_int
, (LONGEST
) num
));
387 /* Used in run_command to zero the hit count when a new run starts. */
390 clear_breakpoint_hit_counts (void)
392 struct breakpoint
*b
;
398 /* Default address, symtab and line to put a breakpoint at
399 for "break" command with no arg.
400 if default_breakpoint_valid is zero, the other three are
401 not valid, and "break" with no arg is an error.
403 This set by print_stack_frame, which calls set_default_breakpoint. */
405 int default_breakpoint_valid
;
406 CORE_ADDR default_breakpoint_address
;
407 struct symtab
*default_breakpoint_symtab
;
408 int default_breakpoint_line
;
410 /* *PP is a string denoting a breakpoint. Get the number of the breakpoint.
411 Advance *PP after the string and any trailing whitespace.
413 Currently the string can either be a number or "$" followed by the name
414 of a convenience variable. Making it an expression wouldn't work well
415 for map_breakpoint_numbers (e.g. "4 + 5 + 6").
417 If the string is a NULL pointer, that denotes the last breakpoint.
419 TRAILER is a character which can be found after the number; most
420 commonly this is `-'. If you don't want a trailer, use \0. */
422 get_number_trailer (char **pp
, int trailer
)
424 int retval
= 0; /* default */
428 /* Empty line means refer to the last breakpoint. */
429 return breakpoint_count
;
432 /* Make a copy of the name, so we can null-terminate it
433 to pass to lookup_internalvar(). */
438 while (isalnum (*p
) || *p
== '_')
440 varname
= (char *) alloca (p
- start
+ 1);
441 strncpy (varname
, start
, p
- start
);
442 varname
[p
- start
] = '\0';
443 val
= value_of_internalvar (lookup_internalvar (varname
));
444 if (TYPE_CODE (value_type (val
)) == TYPE_CODE_INT
)
445 retval
= (int) value_as_long (val
);
448 printf_filtered (_("Convenience variable must have integer value.\n"));
456 while (*p
>= '0' && *p
<= '9')
459 /* There is no number here. (e.g. "cond a == b"). */
461 /* Skip non-numeric token */
462 while (*p
&& !isspace((int) *p
))
464 /* Return zero, which caller must interpret as error. */
470 if (!(isspace (*p
) || *p
== '\0' || *p
== trailer
))
472 /* Trailing junk: return 0 and let caller print error msg. */
473 while (!(isspace (*p
) || *p
== '\0' || *p
== trailer
))
484 /* Like get_number_trailer, but don't allow a trailer. */
486 get_number (char **pp
)
488 return get_number_trailer (pp
, '\0');
491 /* Parse a number or a range.
492 * A number will be of the form handled by get_number.
493 * A range will be of the form <number1> - <number2>, and
494 * will represent all the integers between number1 and number2,
497 * While processing a range, this fuction is called iteratively;
498 * At each call it will return the next value in the range.
500 * At the beginning of parsing a range, the char pointer PP will
501 * be advanced past <number1> and left pointing at the '-' token.
502 * Subsequent calls will not advance the pointer until the range
503 * is completed. The call that completes the range will advance
504 * pointer PP past <number2>.
508 get_number_or_range (char **pp
)
510 static int last_retval
, end_value
;
511 static char *end_ptr
;
512 static int in_range
= 0;
516 /* Default case: pp is pointing either to a solo number,
517 or to the first number of a range. */
518 last_retval
= get_number_trailer (pp
, '-');
523 /* This is the start of a range (<number1> - <number2>).
524 Skip the '-', parse and remember the second number,
525 and also remember the end of the final token. */
529 while (isspace ((int) *end_ptr
))
530 end_ptr
++; /* skip white space */
531 end_value
= get_number (temp
);
532 if (end_value
< last_retval
)
534 error (_("inverted range"));
536 else if (end_value
== last_retval
)
538 /* degenerate range (number1 == number2). Advance the
539 token pointer so that the range will be treated as a
548 error (_("negative value"));
551 /* pp points to the '-' that betokens a range. All
552 number-parsing has already been done. Return the next
553 integer value (one greater than the saved previous value).
554 Do not advance the token pointer 'pp' until the end of range
557 if (++last_retval
== end_value
)
559 /* End of range reached; advance token pointer. */
569 /* condition N EXP -- set break condition of breakpoint N to EXP. */
572 condition_command (char *arg
, int from_tty
)
574 struct breakpoint
*b
;
579 error_no_arg (_("breakpoint number"));
582 bnum
= get_number (&p
);
584 error (_("Bad breakpoint argument: '%s'"), arg
);
587 if (b
->number
== bnum
)
589 struct bp_location
*loc
= b
->loc
;
590 for (; loc
; loc
= loc
->next
)
598 if (b
->cond_string
!= NULL
)
599 xfree (b
->cond_string
);
603 b
->cond_string
= NULL
;
605 printf_filtered (_("Breakpoint %d now unconditional.\n"), bnum
);
610 /* I don't know if it matters whether this is the string the user
611 typed in or the decompiled expression. */
612 b
->cond_string
= savestring (arg
, strlen (arg
));
613 b
->condition_not_parsed
= 0;
614 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
618 parse_exp_1 (&arg
, block_for_pc (loc
->address
), 0);
620 error (_("Junk at end of expression"));
623 breakpoints_changed ();
624 breakpoint_modify_event (b
->number
);
628 error (_("No breakpoint number %d."), bnum
);
632 commands_command (char *arg
, int from_tty
)
634 struct breakpoint
*b
;
637 struct command_line
*l
;
639 /* If we allowed this, we would have problems with when to
640 free the storage, if we change the commands currently
643 if (executing_breakpoint_commands
)
644 error (_("Can't use the \"commands\" command among a breakpoint's commands."));
647 bnum
= get_number (&p
);
650 error (_("Unexpected extra arguments following breakpoint number."));
653 if (b
->number
== bnum
)
655 char *tmpbuf
= xstrprintf ("Type commands for when breakpoint %d is hit, one per line.",
657 struct cleanup
*cleanups
= make_cleanup (xfree
, tmpbuf
);
658 l
= read_command_lines (tmpbuf
, from_tty
);
659 do_cleanups (cleanups
);
660 free_command_lines (&b
->commands
);
662 breakpoints_changed ();
663 breakpoint_modify_event (b
->number
);
666 error (_("No breakpoint number %d."), bnum
);
669 /* Like commands_command, but instead of reading the commands from
670 input stream, takes them from an already parsed command structure.
672 This is used by cli-script.c to DTRT with breakpoint commands
673 that are part of if and while bodies. */
674 enum command_control_type
675 commands_from_control_command (char *arg
, struct command_line
*cmd
)
677 struct breakpoint
*b
;
681 /* If we allowed this, we would have problems with when to
682 free the storage, if we change the commands currently
685 if (executing_breakpoint_commands
)
686 error (_("Can't use the \"commands\" command among a breakpoint's commands."));
688 /* An empty string for the breakpoint number means the last
689 breakpoint, but get_number expects a NULL pointer. */
694 bnum
= get_number (&p
);
697 error (_("Unexpected extra arguments following breakpoint number."));
700 if (b
->number
== bnum
)
702 free_command_lines (&b
->commands
);
703 if (cmd
->body_count
!= 1)
704 error (_("Invalid \"commands\" block structure."));
705 /* We need to copy the commands because if/while will free the
706 list after it finishes execution. */
707 b
->commands
= copy_command_lines (cmd
->body_list
[0]);
708 breakpoints_changed ();
709 breakpoint_modify_event (b
->number
);
710 return simple_control
;
712 error (_("No breakpoint number %d."), bnum
);
715 /* Update BUF, which is LEN bytes read from the target address MEMADDR,
716 by replacing any memory breakpoints with their shadowed contents. */
719 breakpoint_restore_shadows (gdb_byte
*buf
, ULONGEST memaddr
, LONGEST len
)
721 struct bp_location
*b
;
722 CORE_ADDR bp_addr
= 0;
728 if (b
->owner
->type
== bp_none
)
729 warning (_("reading through apparently deleted breakpoint #%d?"),
732 if (b
->loc_type
!= bp_loc_software_breakpoint
)
736 /* Addresses and length of the part of the breakpoint that
738 bp_addr
= b
->target_info
.placed_address
;
739 bp_size
= b
->target_info
.shadow_len
;
741 /* bp isn't valid, or doesn't shadow memory. */
744 if (bp_addr
+ bp_size
<= memaddr
)
745 /* The breakpoint is entirely before the chunk of memory we
749 if (bp_addr
>= memaddr
+ len
)
750 /* The breakpoint is entirely after the chunk of memory we are
754 /* Offset within shadow_contents. */
755 if (bp_addr
< memaddr
)
757 /* Only copy the second part of the breakpoint. */
758 bp_size
-= memaddr
- bp_addr
;
759 bptoffset
= memaddr
- bp_addr
;
763 if (bp_addr
+ bp_size
> memaddr
+ len
)
765 /* Only copy the first part of the breakpoint. */
766 bp_size
-= (bp_addr
+ bp_size
) - (memaddr
+ len
);
769 memcpy (buf
+ bp_addr
- memaddr
,
770 b
->target_info
.shadow_contents
+ bptoffset
, bp_size
);
775 /* A wrapper function for inserting catchpoints. */
777 insert_catchpoint (struct ui_out
*uo
, void *args
)
779 struct breakpoint
*b
= (struct breakpoint
*) args
;
785 target_insert_fork_catchpoint (PIDGET (inferior_ptid
));
788 target_insert_vfork_catchpoint (PIDGET (inferior_ptid
));
791 target_insert_exec_catchpoint (PIDGET (inferior_ptid
));
794 internal_error (__FILE__
, __LINE__
, _("unknown breakpoint type"));
800 is_hardware_watchpoint (struct breakpoint
*bpt
)
802 return (bpt
->type
== bp_hardware_watchpoint
803 || bpt
->type
== bp_read_watchpoint
804 || bpt
->type
== bp_access_watchpoint
);
807 /* Find the current value of a watchpoint on EXP. Return the value in
808 *VALP and *RESULTP and the chain of intermediate and final values
809 in *VAL_CHAIN. RESULTP and VAL_CHAIN may be NULL if the caller does
812 If an error occurs while evaluating the expression, *RESULTP will
813 be set to NULL. *RESULTP may be a lazy value, if the result could
814 not be read from memory. It is used to determine whether a value
815 is user-specified (we should watch the whole value) or intermediate
816 (we should watch only the bit used to locate the final value).
818 If the final value, or any intermediate value, could not be read
819 from memory, *VALP will be set to NULL. *VAL_CHAIN will still be
820 set to any referenced values. *VALP will never be a lazy value.
821 This is the value which we store in struct breakpoint.
823 If VAL_CHAIN is non-NULL, *VAL_CHAIN will be released from the
824 value chain. The caller must free the values individually. If
825 VAL_CHAIN is NULL, all generated values will be left on the value
829 fetch_watchpoint_value (struct expression
*exp
, struct value
**valp
,
830 struct value
**resultp
, struct value
**val_chain
)
832 struct value
*mark
, *new_mark
, *result
;
840 /* Evaluate the expression. */
841 mark
= value_mark ();
843 gdb_evaluate_expression (exp
, &result
);
844 new_mark
= value_mark ();
845 if (mark
== new_mark
)
850 /* Make sure it's not lazy, so that after the target stops again we
851 have a non-lazy previous value to compare with. */
853 && (!value_lazy (result
) || gdb_value_fetch_lazy (result
)))
858 /* Return the chain of intermediate values. We use this to
859 decide which addresses to watch. */
860 *val_chain
= new_mark
;
861 value_release_to_mark (mark
);
865 /* Assuming that B is a hardware watchpoint:
866 - Reparse watchpoint expression, is REPARSE is non-zero
867 - Evaluate expression and store the result in B->val
868 - Update the list of values that must be watched in B->loc.
870 If the watchpoint is disabled, do nothing. If this is
871 local watchpoint that is out of scope, delete it. */
873 update_watchpoint (struct breakpoint
*b
, int reparse
)
875 int within_current_scope
;
876 struct frame_id saved_frame_id
;
877 struct bp_location
*loc
;
880 /* We don't free locations. They are stored in
881 bp_location_chain and update_global_locations will
882 eventually delete them and remove breakpoints if
886 if (b
->disposition
== disp_del_at_next_stop
)
889 /* Save the current frame's ID so we can restore it after
890 evaluating the watchpoint expression on its own frame. */
891 /* FIXME drow/2003-09-09: It would be nice if evaluate_expression
892 took a frame parameter, so that we didn't have to change the
894 saved_frame_id
= get_frame_id (get_selected_frame (NULL
));
896 /* Determine if the watchpoint is within scope. */
897 if (b
->exp_valid_block
== NULL
)
898 within_current_scope
= 1;
901 struct frame_info
*fi
;
902 fi
= frame_find_by_id (b
->watchpoint_frame
);
903 within_current_scope
= (fi
!= NULL
);
904 if (within_current_scope
)
908 if (within_current_scope
&& reparse
)
917 b
->exp
= parse_exp_1 (&s
, b
->exp_valid_block
, 0);
918 /* If the meaning of expression itself changed, the old value is
919 no longer relevant. We don't want to report a watchpoint hit
920 to the user when the old value and the new value may actually
921 be completely different objects. */
927 /* If we failed to parse the expression, for example because
928 it refers to a global variable in a not-yet-loaded shared library,
929 don't try to insert watchpoint. We don't automatically delete
930 such watchpoint, though, since failure to parse expression
931 is different from out-of-scope watchpoint. */
932 if (within_current_scope
&& b
->exp
)
934 struct value
*val_chain
, *v
, *result
, *next
;
936 fetch_watchpoint_value (b
->exp
, &v
, &result
, &val_chain
);
938 /* Avoid setting b->val if it's already set. The meaning of
939 b->val is 'the last value' user saw, and we should update
940 it only if we reported that last value to user. As it
941 happens, the code that reports it updates b->val directly. */
948 /* Look at each value on the value chain. */
949 for (v
= val_chain
; v
; v
= next
)
951 /* If it's a memory location, and GDB actually needed
952 its contents to evaluate the expression, then we
953 must watch it. If the first value returned is
954 still lazy, that means an error occurred reading it;
955 watch it anyway in case it becomes readable. */
956 if (VALUE_LVAL (v
) == lval_memory
957 && (v
== val_chain
|| ! value_lazy (v
)))
959 struct type
*vtype
= check_typedef (value_type (v
));
961 /* We only watch structs and arrays if user asked
962 for it explicitly, never if they just happen to
963 appear in the middle of some value chain. */
965 || (TYPE_CODE (vtype
) != TYPE_CODE_STRUCT
966 && TYPE_CODE (vtype
) != TYPE_CODE_ARRAY
))
970 struct bp_location
*loc
, **tmp
;
972 addr
= VALUE_ADDRESS (v
) + value_offset (v
);
973 len
= TYPE_LENGTH (value_type (v
));
975 if (b
->type
== bp_read_watchpoint
)
977 else if (b
->type
== bp_access_watchpoint
)
980 loc
= allocate_bp_location (b
, bp_hardware_watchpoint
);
981 for (tmp
= &(b
->loc
); *tmp
!= NULL
; tmp
= &((*tmp
)->next
))
986 loc
->watchpoint_type
= type
;
990 next
= value_next (v
);
995 /* We just regenerated the list of breakpoint locations.
996 The new location does not have its condition field set to anything
997 and therefore, we must always reparse the cond_string, independently
998 of the value of the reparse flag. */
999 if (b
->cond_string
!= NULL
)
1001 char *s
= b
->cond_string
;
1002 b
->loc
->cond
= parse_exp_1 (&s
, b
->exp_valid_block
, 0);
1005 else if (!within_current_scope
)
1007 printf_filtered (_("\
1008 Hardware watchpoint %d deleted because the program has left the block \n\
1009 in which its expression is valid.\n"),
1011 if (b
->related_breakpoint
)
1012 b
->related_breakpoint
->disposition
= disp_del_at_next_stop
;
1013 b
->disposition
= disp_del_at_next_stop
;
1016 /* Restore the selected frame. */
1017 select_frame (frame_find_by_id (saved_frame_id
));
1021 /* Returns 1 iff breakpoint location should be
1022 inserted in the inferior. */
1024 should_be_inserted (struct bp_location
*bpt
)
1026 if (!breakpoint_enabled (bpt
->owner
))
1029 if (bpt
->owner
->disposition
== disp_del_at_next_stop
)
1032 if (!bpt
->enabled
|| bpt
->shlib_disabled
|| bpt
->duplicate
)
1038 /* Insert a low-level "breakpoint" of some type. BPT is the breakpoint.
1039 Any error messages are printed to TMP_ERROR_STREAM; and DISABLED_BREAKS,
1040 PROCESS_WARNING, and HW_BREAKPOINT_ERROR are used to report problems.
1042 NOTE drow/2003-09-09: This routine could be broken down to an object-style
1043 method for each breakpoint or catchpoint type. */
1045 insert_bp_location (struct bp_location
*bpt
,
1046 struct ui_file
*tmp_error_stream
,
1047 int *disabled_breaks
, int *process_warning
,
1048 int *hw_breakpoint_error
)
1052 if (!should_be_inserted (bpt
) || bpt
->inserted
)
1055 /* Initialize the target-specific information. */
1056 memset (&bpt
->target_info
, 0, sizeof (bpt
->target_info
));
1057 bpt
->target_info
.placed_address
= bpt
->address
;
1059 if (bpt
->loc_type
== bp_loc_software_breakpoint
1060 || bpt
->loc_type
== bp_loc_hardware_breakpoint
)
1062 if (bpt
->owner
->type
!= bp_hardware_breakpoint
)
1064 /* If the explicitly specified breakpoint type
1065 is not hardware breakpoint, check the memory map to see
1066 if the breakpoint address is in read only memory or not.
1067 Two important cases are:
1068 - location type is not hardware breakpoint, memory
1069 is readonly. We change the type of the location to
1070 hardware breakpoint.
1071 - location type is hardware breakpoint, memory is read-write.
1072 This means we've previously made the location hardware one, but
1073 then the memory map changed, so we undo.
1075 When breakpoints are removed, remove_breakpoints will
1076 use location types we've just set here, the only possible
1077 problem is that memory map has changed during running program,
1078 but it's not going to work anyway with current gdb. */
1079 struct mem_region
*mr
1080 = lookup_mem_region (bpt
->target_info
.placed_address
);
1084 if (automatic_hardware_breakpoints
)
1087 enum bp_loc_type new_type
;
1089 if (mr
->attrib
.mode
!= MEM_RW
)
1090 new_type
= bp_loc_hardware_breakpoint
;
1092 new_type
= bp_loc_software_breakpoint
;
1094 if (new_type
!= bpt
->loc_type
)
1096 static int said
= 0;
1097 bpt
->loc_type
= new_type
;
1100 fprintf_filtered (gdb_stdout
, _("\
1101 Note: automatically using hardware breakpoints for read-only addresses.\n"));
1106 else if (bpt
->loc_type
== bp_loc_software_breakpoint
1107 && mr
->attrib
.mode
!= MEM_RW
)
1108 warning (_("cannot set software breakpoint at readonly address %s"),
1109 paddr (bpt
->address
));
1113 /* First check to see if we have to handle an overlay. */
1114 if (overlay_debugging
== ovly_off
1115 || bpt
->section
== NULL
1116 || !(section_is_overlay (bpt
->section
)))
1118 /* No overlay handling: just set the breakpoint. */
1120 if (bpt
->loc_type
== bp_loc_hardware_breakpoint
)
1121 val
= target_insert_hw_breakpoint (&bpt
->target_info
);
1123 val
= target_insert_breakpoint (&bpt
->target_info
);
1127 /* This breakpoint is in an overlay section.
1128 Shall we set a breakpoint at the LMA? */
1129 if (!overlay_events_enabled
)
1131 /* Yes -- overlay event support is not active,
1132 so we must try to set a breakpoint at the LMA.
1133 This will not work for a hardware breakpoint. */
1134 if (bpt
->loc_type
== bp_loc_hardware_breakpoint
)
1135 warning (_("hardware breakpoint %d not supported in overlay!"),
1136 bpt
->owner
->number
);
1139 CORE_ADDR addr
= overlay_unmapped_address (bpt
->address
,
1141 /* Set a software (trap) breakpoint at the LMA. */
1142 bpt
->overlay_target_info
= bpt
->target_info
;
1143 bpt
->overlay_target_info
.placed_address
= addr
;
1144 val
= target_insert_breakpoint (&bpt
->overlay_target_info
);
1146 fprintf_unfiltered (tmp_error_stream
,
1147 "Overlay breakpoint %d failed: in ROM?",
1148 bpt
->owner
->number
);
1151 /* Shall we set a breakpoint at the VMA? */
1152 if (section_is_mapped (bpt
->section
))
1154 /* Yes. This overlay section is mapped into memory. */
1155 if (bpt
->loc_type
== bp_loc_hardware_breakpoint
)
1156 val
= target_insert_hw_breakpoint (&bpt
->target_info
);
1158 val
= target_insert_breakpoint (&bpt
->target_info
);
1162 /* No. This breakpoint will not be inserted.
1163 No error, but do not mark the bp as 'inserted'. */
1170 /* Can't set the breakpoint. */
1171 if (solib_address (bpt
->address
))
1173 /* See also: disable_breakpoints_in_shlibs. */
1175 bpt
->shlib_disabled
= 1;
1176 if (!*disabled_breaks
)
1178 fprintf_unfiltered (tmp_error_stream
,
1179 "Cannot insert breakpoint %d.\n",
1180 bpt
->owner
->number
);
1181 fprintf_unfiltered (tmp_error_stream
,
1182 "Temporarily disabling shared library breakpoints:\n");
1184 *disabled_breaks
= 1;
1185 fprintf_unfiltered (tmp_error_stream
,
1186 "breakpoint #%d\n", bpt
->owner
->number
);
1190 #ifdef ONE_PROCESS_WRITETEXT
1191 *process_warning
= 1;
1193 if (bpt
->loc_type
== bp_loc_hardware_breakpoint
)
1195 *hw_breakpoint_error
= 1;
1196 fprintf_unfiltered (tmp_error_stream
,
1197 "Cannot insert hardware breakpoint %d.\n",
1198 bpt
->owner
->number
);
1202 fprintf_unfiltered (tmp_error_stream
,
1203 "Cannot insert breakpoint %d.\n",
1204 bpt
->owner
->number
);
1205 fprintf_filtered (tmp_error_stream
,
1206 "Error accessing memory address ");
1207 fputs_filtered (paddress (bpt
->address
), tmp_error_stream
);
1208 fprintf_filtered (tmp_error_stream
, ": %s.\n",
1209 safe_strerror (val
));
1220 else if (bpt
->loc_type
== bp_loc_hardware_watchpoint
1221 /* NOTE drow/2003-09-08: This state only exists for removing
1222 watchpoints. It's not clear that it's necessary... */
1223 && bpt
->owner
->disposition
!= disp_del_at_next_stop
)
1225 val
= target_insert_watchpoint (bpt
->address
,
1227 bpt
->watchpoint_type
);
1228 bpt
->inserted
= (val
!= -1);
1231 else if (bpt
->owner
->type
== bp_catch_fork
1232 || bpt
->owner
->type
== bp_catch_vfork
1233 || bpt
->owner
->type
== bp_catch_exec
)
1235 struct gdb_exception e
= catch_exception (uiout
, insert_catchpoint
,
1236 bpt
->owner
, RETURN_MASK_ERROR
);
1237 exception_fprintf (gdb_stderr
, e
, "warning: inserting catchpoint %d: ",
1238 bpt
->owner
->number
);
1240 bpt
->owner
->enable_state
= bp_disabled
;
1244 /* We've already printed an error message if there was a problem
1245 inserting this catchpoint, and we've disabled the catchpoint,
1246 so just return success. */
1253 /* Make sure all breakpoints are inserted in inferior.
1254 Throws exception on any error.
1255 A breakpoint that is already inserted won't be inserted
1256 again, so calling this function twice is safe. */
1258 insert_breakpoints (void)
1260 struct breakpoint
*bpt
;
1262 ALL_BREAKPOINTS (bpt
)
1263 if (is_hardware_watchpoint (bpt
))
1264 update_watchpoint (bpt
, 0 /* don't reparse. */);
1266 update_global_location_list ();
1268 if (!always_inserted_mode
&& target_has_execution
)
1269 /* update_global_location_list does not insert breakpoints
1270 when always_inserted_mode is not enabled. Explicitly
1272 insert_breakpoint_locations ();
1275 /* insert_breakpoints is used when starting or continuing the program.
1276 remove_breakpoints is used when the program stops.
1277 Both return zero if successful,
1278 or an `errno' value if could not write the inferior. */
1281 insert_breakpoint_locations (void)
1283 struct breakpoint
*bpt
;
1284 struct bp_location
*b
, *temp
;
1287 int disabled_breaks
= 0;
1288 int hw_breakpoint_error
= 0;
1289 int process_warning
= 0;
1291 struct ui_file
*tmp_error_stream
= mem_fileopen ();
1292 make_cleanup_ui_file_delete (tmp_error_stream
);
1294 /* Explicitly mark the warning -- this will only be printed if
1295 there was an error. */
1296 fprintf_unfiltered (tmp_error_stream
, "Warning:\n");
1298 ALL_BP_LOCATIONS_SAFE (b
, temp
)
1300 if (!should_be_inserted (b
) || b
->inserted
)
1303 /* There is no point inserting thread-specific breakpoints if the
1304 thread no longer exists. */
1305 if (b
->owner
->thread
!= -1
1306 && !valid_thread_id (b
->owner
->thread
))
1309 val
= insert_bp_location (b
, tmp_error_stream
,
1310 &disabled_breaks
, &process_warning
,
1311 &hw_breakpoint_error
);
1316 /* If we failed to insert all locations of a watchpoint,
1317 remove them, as half-inserted watchpoint is of limited use. */
1318 ALL_BREAKPOINTS (bpt
)
1320 int some_failed
= 0;
1321 struct bp_location
*loc
;
1323 if (!is_hardware_watchpoint (bpt
))
1326 if (bpt
->enable_state
!= bp_enabled
)
1329 if (bpt
->disposition
== disp_del_at_next_stop
)
1332 for (loc
= bpt
->loc
; loc
; loc
= loc
->next
)
1340 for (loc
= bpt
->loc
; loc
; loc
= loc
->next
)
1342 remove_breakpoint (loc
, mark_uninserted
);
1344 hw_breakpoint_error
= 1;
1345 fprintf_unfiltered (tmp_error_stream
,
1346 "Could not insert hardware watchpoint %d.\n",
1354 /* If a hardware breakpoint or watchpoint was inserted, add a
1355 message about possibly exhausted resources. */
1356 if (hw_breakpoint_error
)
1358 fprintf_unfiltered (tmp_error_stream
,
1359 "Could not insert hardware breakpoints:\n\
1360 You may have requested too many hardware breakpoints/watchpoints.\n");
1362 #ifdef ONE_PROCESS_WRITETEXT
1363 if (process_warning
)
1364 fprintf_unfiltered (tmp_error_stream
,
1365 "The same program may be running in another process.");
1367 target_terminal_ours_for_output ();
1368 error_stream (tmp_error_stream
);
1373 remove_breakpoints (void)
1375 struct bp_location
*b
;
1378 ALL_BP_LOCATIONS (b
)
1382 val
= remove_breakpoint (b
, mark_uninserted
);
1391 remove_hw_watchpoints (void)
1393 struct bp_location
*b
;
1396 ALL_BP_LOCATIONS (b
)
1398 if (b
->inserted
&& b
->loc_type
== bp_loc_hardware_watchpoint
)
1400 val
= remove_breakpoint (b
, mark_uninserted
);
1409 reattach_breakpoints (int pid
)
1411 struct bp_location
*b
;
1413 struct cleanup
*old_chain
= save_inferior_ptid ();
1414 struct ui_file
*tmp_error_stream
= mem_fileopen ();
1415 int dummy1
= 0, dummy2
= 0, dummy3
= 0;
1417 make_cleanup_ui_file_delete (tmp_error_stream
);
1419 inferior_ptid
= pid_to_ptid (pid
);
1420 ALL_BP_LOCATIONS (b
)
1425 val
= insert_bp_location (b
, tmp_error_stream
,
1426 &dummy1
, &dummy2
, &dummy3
);
1429 do_cleanups (old_chain
);
1434 do_cleanups (old_chain
);
1439 update_breakpoints_after_exec (void)
1441 struct breakpoint
*b
;
1442 struct breakpoint
*temp
;
1443 struct cleanup
*cleanup
;
1445 /* Doing this first prevents the badness of having delete_breakpoint()
1446 write a breakpoint's current "shadow contents" to lift the bp. That
1447 shadow is NOT valid after an exec()! */
1448 mark_breakpoints_out ();
1450 /* The binary we used to debug is now gone, and we're updating
1451 breakpoints for the new binary. Until we're done, we should not
1452 try to insert breakpoints. */
1453 cleanup
= make_cleanup_restore_integer (&always_inserted_mode
);
1454 always_inserted_mode
= 0;
1456 ALL_BREAKPOINTS_SAFE (b
, temp
)
1458 /* Solib breakpoints must be explicitly reset after an exec(). */
1459 if (b
->type
== bp_shlib_event
)
1461 delete_breakpoint (b
);
1465 /* Thread event breakpoints must be set anew after an exec(),
1466 as must overlay event breakpoints. */
1467 if (b
->type
== bp_thread_event
|| b
->type
== bp_overlay_event
)
1469 delete_breakpoint (b
);
1473 /* Step-resume breakpoints are meaningless after an exec(). */
1474 if (b
->type
== bp_step_resume
)
1476 delete_breakpoint (b
);
1480 /* Longjmp and longjmp-resume breakpoints are also meaningless
1482 if (b
->type
== bp_longjmp
|| b
->type
== bp_longjmp_resume
)
1484 delete_breakpoint (b
);
1488 /* Don't delete an exec catchpoint, because else the inferior
1489 won't stop when it ought!
1491 Similarly, we probably ought to keep vfork catchpoints, 'cause
1492 on this target, we may not be able to stop when the vfork is
1493 seen, but only when the subsequent exec is seen. (And because
1494 deleting fork catchpoints here but not vfork catchpoints will
1495 seem mysterious to users, keep those too.) */
1496 if ((b
->type
== bp_catch_exec
) ||
1497 (b
->type
== bp_catch_vfork
) ||
1498 (b
->type
== bp_catch_fork
))
1503 /* bp_finish is a special case. The only way we ought to be able
1504 to see one of these when an exec() has happened, is if the user
1505 caught a vfork, and then said "finish". Ordinarily a finish just
1506 carries them to the call-site of the current callee, by setting
1507 a temporary bp there and resuming. But in this case, the finish
1508 will carry them entirely through the vfork & exec.
1510 We don't want to allow a bp_finish to remain inserted now. But
1511 we can't safely delete it, 'cause finish_command has a handle to
1512 the bp on a bpstat, and will later want to delete it. There's a
1513 chance (and I've seen it happen) that if we delete the bp_finish
1514 here, that its storage will get reused by the time finish_command
1515 gets 'round to deleting the "use to be a bp_finish" breakpoint.
1516 We really must allow finish_command to delete a bp_finish.
1518 In the absense of a general solution for the "how do we know
1519 it's safe to delete something others may have handles to?"
1520 problem, what we'll do here is just uninsert the bp_finish, and
1521 let finish_command delete it.
1523 (We know the bp_finish is "doomed" in the sense that it's
1524 momentary, and will be deleted as soon as finish_command sees
1525 the inferior stopped. So it doesn't matter that the bp's
1526 address is probably bogus in the new a.out, unlike e.g., the
1527 solib breakpoints.) */
1529 if (b
->type
== bp_finish
)
1534 /* Without a symbolic address, we have little hope of the
1535 pre-exec() address meaning the same thing in the post-exec()
1537 if (b
->addr_string
== NULL
)
1539 delete_breakpoint (b
);
1543 /* FIXME what about longjmp breakpoints? Re-create them here? */
1544 create_overlay_event_breakpoint ("_ovly_debug_event");
1545 do_cleanups (cleanup
);
1549 detach_breakpoints (int pid
)
1551 struct bp_location
*b
;
1553 struct cleanup
*old_chain
= save_inferior_ptid ();
1555 if (pid
== PIDGET (inferior_ptid
))
1556 error (_("Cannot detach breakpoints of inferior_ptid"));
1558 /* Set inferior_ptid; remove_breakpoint uses this global. */
1559 inferior_ptid
= pid_to_ptid (pid
);
1560 ALL_BP_LOCATIONS (b
)
1564 val
= remove_breakpoint (b
, mark_inserted
);
1567 do_cleanups (old_chain
);
1572 do_cleanups (old_chain
);
1577 remove_breakpoint (struct bp_location
*b
, insertion_state_t is
)
1581 if (b
->owner
->enable_state
== bp_permanent
)
1582 /* Permanent breakpoints cannot be inserted or removed. */
1585 /* The type of none suggests that owner is actually deleted.
1586 This should not ever happen. */
1587 gdb_assert (b
->owner
->type
!= bp_none
);
1589 if (b
->loc_type
== bp_loc_software_breakpoint
1590 || b
->loc_type
== bp_loc_hardware_breakpoint
)
1592 /* "Normal" instruction breakpoint: either the standard
1593 trap-instruction bp (bp_breakpoint), or a
1594 bp_hardware_breakpoint. */
1596 /* First check to see if we have to handle an overlay. */
1597 if (overlay_debugging
== ovly_off
1598 || b
->section
== NULL
1599 || !(section_is_overlay (b
->section
)))
1601 /* No overlay handling: just remove the breakpoint. */
1603 if (b
->loc_type
== bp_loc_hardware_breakpoint
)
1604 val
= target_remove_hw_breakpoint (&b
->target_info
);
1606 val
= target_remove_breakpoint (&b
->target_info
);
1610 /* This breakpoint is in an overlay section.
1611 Did we set a breakpoint at the LMA? */
1612 if (!overlay_events_enabled
)
1614 /* Yes -- overlay event support is not active, so we
1615 should have set a breakpoint at the LMA. Remove it.
1617 /* Ignore any failures: if the LMA is in ROM, we will
1618 have already warned when we failed to insert it. */
1619 if (b
->loc_type
== bp_loc_hardware_breakpoint
)
1620 target_remove_hw_breakpoint (&b
->overlay_target_info
);
1622 target_remove_breakpoint (&b
->overlay_target_info
);
1624 /* Did we set a breakpoint at the VMA?
1625 If so, we will have marked the breakpoint 'inserted'. */
1628 /* Yes -- remove it. Previously we did not bother to
1629 remove the breakpoint if the section had been
1630 unmapped, but let's not rely on that being safe. We
1631 don't know what the overlay manager might do. */
1632 if (b
->loc_type
== bp_loc_hardware_breakpoint
)
1633 val
= target_remove_hw_breakpoint (&b
->target_info
);
1635 /* However, we should remove *software* breakpoints only
1636 if the section is still mapped, or else we overwrite
1637 wrong code with the saved shadow contents. */
1638 else if (section_is_mapped (b
->section
))
1639 val
= target_remove_breakpoint (&b
->target_info
);
1645 /* No -- not inserted, so no need to remove. No error. */
1651 b
->inserted
= (is
== mark_inserted
);
1653 else if (b
->loc_type
== bp_loc_hardware_watchpoint
)
1658 b
->inserted
= (is
== mark_inserted
);
1659 val
= target_remove_watchpoint (b
->address
, b
->length
,
1660 b
->watchpoint_type
);
1662 /* Failure to remove any of the hardware watchpoints comes here. */
1663 if ((is
== mark_uninserted
) && (b
->inserted
))
1664 warning (_("Could not remove hardware watchpoint %d."),
1667 else if ((b
->owner
->type
== bp_catch_fork
||
1668 b
->owner
->type
== bp_catch_vfork
||
1669 b
->owner
->type
== bp_catch_exec
)
1670 && breakpoint_enabled (b
->owner
)
1674 switch (b
->owner
->type
)
1677 val
= target_remove_fork_catchpoint (PIDGET (inferior_ptid
));
1679 case bp_catch_vfork
:
1680 val
= target_remove_vfork_catchpoint (PIDGET (inferior_ptid
));
1683 val
= target_remove_exec_catchpoint (PIDGET (inferior_ptid
));
1686 warning (_("Internal error, %s line %d."), __FILE__
, __LINE__
);
1691 b
->inserted
= (is
== mark_inserted
);
1697 /* Clear the "inserted" flag in all breakpoints. */
1700 mark_breakpoints_out (void)
1702 struct bp_location
*bpt
;
1704 ALL_BP_LOCATIONS (bpt
)
1708 /* Clear the "inserted" flag in all breakpoints and delete any
1709 breakpoints which should go away between runs of the program.
1711 Plus other such housekeeping that has to be done for breakpoints
1714 Note: this function gets called at the end of a run (by
1715 generic_mourn_inferior) and when a run begins (by
1716 init_wait_for_inferior). */
1721 breakpoint_init_inferior (enum inf_context context
)
1723 struct breakpoint
*b
, *temp
;
1724 struct bp_location
*bpt
;
1726 ALL_BP_LOCATIONS (bpt
)
1729 ALL_BREAKPOINTS_SAFE (b
, temp
)
1734 case bp_watchpoint_scope
:
1736 /* If the call dummy breakpoint is at the entry point it will
1737 cause problems when the inferior is rerun, so we better
1740 Also get rid of scope breakpoints. */
1741 delete_breakpoint (b
);
1745 case bp_hardware_watchpoint
:
1746 case bp_read_watchpoint
:
1747 case bp_access_watchpoint
:
1749 /* Likewise for watchpoints on local expressions. */
1750 if (b
->exp_valid_block
!= NULL
)
1751 delete_breakpoint (b
);
1752 else if (context
== inf_starting
)
1754 /* Reset val field to force reread of starting value
1755 in insert_breakpoints. */
1757 value_free (b
->val
);
1768 /* breakpoint_here_p (PC) returns non-zero if an enabled breakpoint
1769 exists at PC. It returns ordinary_breakpoint_here if it's an
1770 ordinary breakpoint, or permanent_breakpoint_here if it's a
1771 permanent breakpoint.
1772 - When continuing from a location with an ordinary breakpoint, we
1773 actually single step once before calling insert_breakpoints.
1774 - When continuing from a localion with a permanent breakpoint, we
1775 need to use the `SKIP_PERMANENT_BREAKPOINT' macro, provided by
1776 the target, to advance the PC past the breakpoint. */
1778 enum breakpoint_here
1779 breakpoint_here_p (CORE_ADDR pc
)
1781 const struct bp_location
*bpt
;
1782 int any_breakpoint_here
= 0;
1784 ALL_BP_LOCATIONS (bpt
)
1786 if (bpt
->loc_type
!= bp_loc_software_breakpoint
1787 && bpt
->loc_type
!= bp_loc_hardware_breakpoint
)
1790 if ((breakpoint_enabled (bpt
->owner
)
1791 || bpt
->owner
->enable_state
== bp_permanent
)
1792 && bpt
->address
== pc
) /* bp is enabled and matches pc */
1794 if (overlay_debugging
1795 && section_is_overlay (bpt
->section
)
1796 && !section_is_mapped (bpt
->section
))
1797 continue; /* unmapped overlay -- can't be a match */
1798 else if (bpt
->owner
->enable_state
== bp_permanent
)
1799 return permanent_breakpoint_here
;
1801 any_breakpoint_here
= 1;
1805 return any_breakpoint_here
? ordinary_breakpoint_here
: 0;
1809 /* Returns non-zero if there's a breakpoint inserted at PC, which is
1810 inserted using regular breakpoint_chain/bp_location_chain mechanism.
1811 This does not check for single-step breakpoints, which are
1812 inserted and removed using direct target manipulation. */
1815 regular_breakpoint_inserted_here_p (CORE_ADDR pc
)
1817 const struct bp_location
*bpt
;
1819 ALL_BP_LOCATIONS (bpt
)
1821 if (bpt
->loc_type
!= bp_loc_software_breakpoint
1822 && bpt
->loc_type
!= bp_loc_hardware_breakpoint
)
1826 && bpt
->address
== pc
) /* bp is inserted and matches pc */
1828 if (overlay_debugging
1829 && section_is_overlay (bpt
->section
)
1830 && !section_is_mapped (bpt
->section
))
1831 continue; /* unmapped overlay -- can't be a match */
1839 /* Returns non-zero iff there's either regular breakpoint
1840 or a single step breakpoint inserted at PC. */
1843 breakpoint_inserted_here_p (CORE_ADDR pc
)
1845 if (regular_breakpoint_inserted_here_p (pc
))
1848 if (single_step_breakpoint_inserted_here_p (pc
))
1854 /* This function returns non-zero iff there is a software breakpoint
1858 software_breakpoint_inserted_here_p (CORE_ADDR pc
)
1860 const struct bp_location
*bpt
;
1861 int any_breakpoint_here
= 0;
1863 ALL_BP_LOCATIONS (bpt
)
1865 if (bpt
->loc_type
!= bp_loc_software_breakpoint
)
1869 && bpt
->address
== pc
) /* bp is enabled and matches pc */
1871 if (overlay_debugging
1872 && section_is_overlay (bpt
->section
)
1873 && !section_is_mapped (bpt
->section
))
1874 continue; /* unmapped overlay -- can't be a match */
1880 /* Also check for software single-step breakpoints. */
1881 if (single_step_breakpoint_inserted_here_p (pc
))
1887 /* breakpoint_thread_match (PC, PTID) returns true if the breakpoint at
1888 PC is valid for process/thread PTID. */
1891 breakpoint_thread_match (CORE_ADDR pc
, ptid_t ptid
)
1893 const struct bp_location
*bpt
;
1896 thread
= pid_to_thread_id (ptid
);
1898 ALL_BP_LOCATIONS (bpt
)
1900 if (bpt
->loc_type
!= bp_loc_software_breakpoint
1901 && bpt
->loc_type
!= bp_loc_hardware_breakpoint
)
1904 if ((breakpoint_enabled (bpt
->owner
)
1905 || bpt
->owner
->enable_state
== bp_permanent
)
1906 && bpt
->address
== pc
1907 && (bpt
->owner
->thread
== -1 || bpt
->owner
->thread
== thread
))
1909 if (overlay_debugging
1910 && section_is_overlay (bpt
->section
)
1911 && !section_is_mapped (bpt
->section
))
1912 continue; /* unmapped overlay -- can't be a match */
1922 /* bpstat stuff. External routines' interfaces are documented
1926 ep_is_catchpoint (struct breakpoint
*ep
)
1929 (ep
->type
== bp_catch_load
)
1930 || (ep
->type
== bp_catch_unload
)
1931 || (ep
->type
== bp_catch_fork
)
1932 || (ep
->type
== bp_catch_vfork
)
1933 || (ep
->type
== bp_catch_exec
);
1935 /* ??rehrauer: Add more kinds here, as are implemented... */
1939 ep_is_shlib_catchpoint (struct breakpoint
*ep
)
1942 (ep
->type
== bp_catch_load
)
1943 || (ep
->type
== bp_catch_unload
);
1947 bpstat_free (bpstat bs
)
1949 if (bs
->old_val
!= NULL
)
1950 value_free (bs
->old_val
);
1951 free_command_lines (&bs
->commands
);
1955 /* Clear a bpstat so that it says we are not at any breakpoint.
1956 Also free any storage that is part of a bpstat. */
1959 bpstat_clear (bpstat
*bsp
)
1976 /* Return a copy of a bpstat. Like "bs1 = bs2" but all storage that
1977 is part of the bpstat is copied as well. */
1980 bpstat_copy (bpstat bs
)
1984 bpstat retval
= NULL
;
1989 for (; bs
!= NULL
; bs
= bs
->next
)
1991 tmp
= (bpstat
) xmalloc (sizeof (*tmp
));
1992 memcpy (tmp
, bs
, sizeof (*tmp
));
1993 if (bs
->commands
!= NULL
)
1994 tmp
->commands
= copy_command_lines (bs
->commands
);
1995 if (bs
->old_val
!= NULL
)
1996 tmp
->old_val
= value_copy (bs
->old_val
);
1999 /* This is the first thing in the chain. */
2009 /* Find the bpstat associated with this breakpoint */
2012 bpstat_find_breakpoint (bpstat bsp
, struct breakpoint
*breakpoint
)
2017 for (; bsp
!= NULL
; bsp
= bsp
->next
)
2019 if (bsp
->breakpoint_at
&& bsp
->breakpoint_at
->owner
== breakpoint
)
2025 /* Find a step_resume breakpoint associated with this bpstat.
2026 (If there are multiple step_resume bp's on the list, this function
2027 will arbitrarily pick one.)
2029 It is an error to use this function if BPSTAT doesn't contain a
2030 step_resume breakpoint.
2032 See wait_for_inferior's use of this function. */
2034 bpstat_find_step_resume_breakpoint (bpstat bsp
)
2038 gdb_assert (bsp
!= NULL
);
2040 current_thread
= pid_to_thread_id (inferior_ptid
);
2042 for (; bsp
!= NULL
; bsp
= bsp
->next
)
2044 if ((bsp
->breakpoint_at
!= NULL
) &&
2045 (bsp
->breakpoint_at
->owner
->type
== bp_step_resume
) &&
2046 (bsp
->breakpoint_at
->owner
->thread
== current_thread
||
2047 bsp
->breakpoint_at
->owner
->thread
== -1))
2048 return bsp
->breakpoint_at
->owner
;
2051 internal_error (__FILE__
, __LINE__
, _("No step_resume breakpoint found."));
2055 /* Put in *NUM the breakpoint number of the first breakpoint we are stopped
2056 at. *BSP upon return is a bpstat which points to the remaining
2057 breakpoints stopped at (but which is not guaranteed to be good for
2058 anything but further calls to bpstat_num).
2059 Return 0 if passed a bpstat which does not indicate any breakpoints.
2060 Return -1 if stopped at a breakpoint that has been deleted since
2062 Return 1 otherwise. */
2065 bpstat_num (bpstat
*bsp
, int *num
)
2067 struct breakpoint
*b
;
2070 return 0; /* No more breakpoint values */
2072 /* We assume we'll never have several bpstats that
2073 correspond to a single breakpoint -- otherwise,
2074 this function might return the same number more
2075 than once and this will look ugly. */
2076 b
= (*bsp
)->breakpoint_at
? (*bsp
)->breakpoint_at
->owner
: NULL
;
2077 *bsp
= (*bsp
)->next
;
2079 return -1; /* breakpoint that's been deleted since */
2081 *num
= b
->number
; /* We have its number */
2085 /* Modify BS so that the actions will not be performed. */
2088 bpstat_clear_actions (bpstat bs
)
2090 for (; bs
!= NULL
; bs
= bs
->next
)
2092 free_command_lines (&bs
->commands
);
2093 if (bs
->old_val
!= NULL
)
2095 value_free (bs
->old_val
);
2101 /* Stub for cleaning up our state if we error-out of a breakpoint command */
2103 cleanup_executing_breakpoints (void *ignore
)
2105 executing_breakpoint_commands
= 0;
2108 /* Execute all the commands associated with all the breakpoints at this
2109 location. Any of these commands could cause the process to proceed
2110 beyond this point, etc. We look out for such changes by checking
2111 the global "breakpoint_proceeded" after each command. */
2114 bpstat_do_actions (bpstat
*bsp
)
2117 struct cleanup
*old_chain
;
2119 /* Avoid endless recursion if a `source' command is contained
2121 if (executing_breakpoint_commands
)
2124 executing_breakpoint_commands
= 1;
2125 old_chain
= make_cleanup (cleanup_executing_breakpoints
, 0);
2128 /* Note that (as of this writing), our callers all appear to
2129 be passing us the address of global stop_bpstat. And, if
2130 our calls to execute_control_command cause the inferior to
2131 proceed, that global (and hence, *bsp) will change.
2133 We must be careful to not touch *bsp unless the inferior
2134 has not proceeded. */
2136 /* This pointer will iterate over the list of bpstat's. */
2139 breakpoint_proceeded
= 0;
2140 for (; bs
!= NULL
; bs
= bs
->next
)
2142 struct command_line
*cmd
;
2143 struct cleanup
*this_cmd_tree_chain
;
2145 /* Take ownership of the BSP's command tree, if it has one.
2147 The command tree could legitimately contain commands like
2148 'step' and 'next', which call clear_proceed_status, which
2149 frees stop_bpstat's command tree. To make sure this doesn't
2150 free the tree we're executing out from under us, we need to
2151 take ownership of the tree ourselves. Since a given bpstat's
2152 commands are only executed once, we don't need to copy it; we
2153 can clear the pointer in the bpstat, and make sure we free
2154 the tree when we're done. */
2157 this_cmd_tree_chain
= make_cleanup_free_command_lines (&cmd
);
2161 execute_control_command (cmd
);
2163 if (breakpoint_proceeded
)
2169 /* We can free this command tree now. */
2170 do_cleanups (this_cmd_tree_chain
);
2172 if (breakpoint_proceeded
)
2174 if (target_can_async_p ())
2175 /* If we are in async mode, then the target might
2176 be still running, not stopped at any breakpoint,
2177 so nothing for us to do here -- just return to
2181 /* In sync mode, when execute_control_command returns
2182 we're already standing on the next breakpoint.
2183 Breakpoint commands for that stop were not run,
2184 since execute_command does not run breakpoint
2185 commands -- only command_line_handler does, but
2186 that one is not involved in execution of breakpoint
2187 commands. So, we can now execute breakpoint commands.
2188 There's an implicit assumption that we're called with
2189 stop_bpstat, so our parameter is the new bpstat to
2191 It should be noted that making execute_command do
2192 bpstat actions is not an option -- in this case we'll
2193 have recursive invocation of bpstat for each breakpoint
2194 with a command, and can easily blow up GDB stack. */
2198 do_cleanups (old_chain
);
2201 /* Print out the (old or new) value associated with a watchpoint. */
2204 watchpoint_value_print (struct value
*val
, struct ui_file
*stream
)
2207 fprintf_unfiltered (stream
, _("<unreadable>"));
2209 value_print (val
, stream
, 0, Val_pretty_default
);
2212 /* This is the normal print function for a bpstat. In the future,
2213 much of this logic could (should?) be moved to bpstat_stop_status,
2214 by having it set different print_it values.
2216 Current scheme: When we stop, bpstat_print() is called. It loops
2217 through the bpstat list of things causing this stop, calling the
2218 print_bp_stop_message function on each one. The behavior of the
2219 print_bp_stop_message function depends on the print_it field of
2220 bpstat. If such field so indicates, call this function here.
2222 Return values from this routine (ultimately used by bpstat_print()
2223 and normal_stop() to decide what to do):
2224 PRINT_NOTHING: Means we already printed all we needed to print,
2225 don't print anything else.
2226 PRINT_SRC_ONLY: Means we printed something, and we do *not* desire
2227 that something to be followed by a location.
2228 PRINT_SCR_AND_LOC: Means we printed something, and we *do* desire
2229 that something to be followed by a location.
2230 PRINT_UNKNOWN: Means we printed nothing or we need to do some more
2233 static enum print_stop_action
2234 print_it_typical (bpstat bs
)
2236 struct cleanup
*old_chain
, *ui_out_chain
;
2237 struct breakpoint
*b
;
2238 const struct bp_location
*bl
;
2239 struct ui_stream
*stb
;
2241 stb
= ui_out_stream_new (uiout
);
2242 old_chain
= make_cleanup_ui_out_stream_delete (stb
);
2243 /* bs->breakpoint_at can be NULL if it was a momentary breakpoint
2244 which has since been deleted. */
2245 if (bs
->breakpoint_at
== NULL
)
2246 return PRINT_UNKNOWN
;
2247 bl
= bs
->breakpoint_at
;
2253 case bp_hardware_breakpoint
:
2254 bp_temp
= bs
->breakpoint_at
->owner
->disposition
== disp_del
;
2255 if (bl
->address
!= bl
->requested_address
)
2256 breakpoint_adjustment_warning (bl
->requested_address
,
2259 annotate_breakpoint (b
->number
);
2261 ui_out_text (uiout
, "\nTemporary breakpoint ");
2263 ui_out_text (uiout
, "\nBreakpoint ");
2264 if (ui_out_is_mi_like_p (uiout
))
2266 ui_out_field_string (uiout
, "reason",
2267 async_reason_lookup (EXEC_ASYNC_BREAKPOINT_HIT
));
2268 ui_out_field_string (uiout
, "disp", bpdisp_text (b
->disposition
));
2270 ui_out_field_int (uiout
, "bkptno", b
->number
);
2271 ui_out_text (uiout
, ", ");
2272 return PRINT_SRC_AND_LOC
;
2275 case bp_shlib_event
:
2276 /* Did we stop because the user set the stop_on_solib_events
2277 variable? (If so, we report this as a generic, "Stopped due
2278 to shlib event" message.) */
2279 printf_filtered (_("Stopped due to shared library event\n"));
2280 return PRINT_NOTHING
;
2283 case bp_thread_event
:
2284 /* Not sure how we will get here.
2285 GDB should not stop for these breakpoints. */
2286 printf_filtered (_("Thread Event Breakpoint: gdb should not stop!\n"));
2287 return PRINT_NOTHING
;
2290 case bp_overlay_event
:
2291 /* By analogy with the thread event, GDB should not stop for these. */
2292 printf_filtered (_("Overlay Event Breakpoint: gdb should not stop!\n"));
2293 return PRINT_NOTHING
;
2297 annotate_catchpoint (b
->number
);
2298 printf_filtered (_("\nCatchpoint %d (loaded %s), "),
2300 b
->triggered_dll_pathname
);
2301 return PRINT_SRC_AND_LOC
;
2304 case bp_catch_unload
:
2305 annotate_catchpoint (b
->number
);
2306 printf_filtered (_("\nCatchpoint %d (unloaded %s), "),
2308 b
->triggered_dll_pathname
);
2309 return PRINT_SRC_AND_LOC
;
2313 annotate_catchpoint (b
->number
);
2314 printf_filtered (_("\nCatchpoint %d (forked process %d), "),
2316 b
->forked_inferior_pid
);
2317 return PRINT_SRC_AND_LOC
;
2320 case bp_catch_vfork
:
2321 annotate_catchpoint (b
->number
);
2322 printf_filtered (_("\nCatchpoint %d (vforked process %d), "),
2324 b
->forked_inferior_pid
);
2325 return PRINT_SRC_AND_LOC
;
2329 annotate_catchpoint (b
->number
);
2330 printf_filtered (_("\nCatchpoint %d (exec'd %s), "),
2333 return PRINT_SRC_AND_LOC
;
2337 case bp_hardware_watchpoint
:
2338 annotate_watchpoint (b
->number
);
2339 if (ui_out_is_mi_like_p (uiout
))
2342 async_reason_lookup (EXEC_ASYNC_WATCHPOINT_TRIGGER
));
2344 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "value");
2345 ui_out_text (uiout
, "\nOld value = ");
2346 watchpoint_value_print (bs
->old_val
, stb
->stream
);
2347 ui_out_field_stream (uiout
, "old", stb
);
2348 ui_out_text (uiout
, "\nNew value = ");
2349 watchpoint_value_print (b
->val
, stb
->stream
);
2350 ui_out_field_stream (uiout
, "new", stb
);
2351 do_cleanups (ui_out_chain
);
2352 ui_out_text (uiout
, "\n");
2353 /* More than one watchpoint may have been triggered. */
2354 return PRINT_UNKNOWN
;
2357 case bp_read_watchpoint
:
2358 if (ui_out_is_mi_like_p (uiout
))
2361 async_reason_lookup (EXEC_ASYNC_READ_WATCHPOINT_TRIGGER
));
2363 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "value");
2364 ui_out_text (uiout
, "\nValue = ");
2365 watchpoint_value_print (b
->val
, stb
->stream
);
2366 ui_out_field_stream (uiout
, "value", stb
);
2367 do_cleanups (ui_out_chain
);
2368 ui_out_text (uiout
, "\n");
2369 return PRINT_UNKNOWN
;
2372 case bp_access_watchpoint
:
2373 if (bs
->old_val
!= NULL
)
2375 annotate_watchpoint (b
->number
);
2376 if (ui_out_is_mi_like_p (uiout
))
2379 async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER
));
2381 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "value");
2382 ui_out_text (uiout
, "\nOld value = ");
2383 watchpoint_value_print (bs
->old_val
, stb
->stream
);
2384 ui_out_field_stream (uiout
, "old", stb
);
2385 ui_out_text (uiout
, "\nNew value = ");
2390 if (ui_out_is_mi_like_p (uiout
))
2393 async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER
));
2394 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "value");
2395 ui_out_text (uiout
, "\nValue = ");
2397 watchpoint_value_print (b
->val
, stb
->stream
);
2398 ui_out_field_stream (uiout
, "new", stb
);
2399 do_cleanups (ui_out_chain
);
2400 ui_out_text (uiout
, "\n");
2401 return PRINT_UNKNOWN
;
2404 /* Fall through, we don't deal with these types of breakpoints
2408 if (ui_out_is_mi_like_p (uiout
))
2411 async_reason_lookup (EXEC_ASYNC_FUNCTION_FINISHED
));
2412 return PRINT_UNKNOWN
;
2416 if (ui_out_is_mi_like_p (uiout
))
2419 async_reason_lookup (EXEC_ASYNC_LOCATION_REACHED
));
2420 return PRINT_UNKNOWN
;
2425 case bp_longjmp_resume
:
2426 case bp_step_resume
:
2427 case bp_watchpoint_scope
:
2430 return PRINT_UNKNOWN
;
2434 /* Generic routine for printing messages indicating why we
2435 stopped. The behavior of this function depends on the value
2436 'print_it' in the bpstat structure. Under some circumstances we
2437 may decide not to print anything here and delegate the task to
2440 static enum print_stop_action
2441 print_bp_stop_message (bpstat bs
)
2443 switch (bs
->print_it
)
2446 /* Nothing should be printed for this bpstat entry. */
2447 return PRINT_UNKNOWN
;
2451 /* We still want to print the frame, but we already printed the
2452 relevant messages. */
2453 return PRINT_SRC_AND_LOC
;
2456 case print_it_normal
:
2458 const struct bp_location
*bl
= bs
->breakpoint_at
;
2459 struct breakpoint
*b
= bl
? bl
->owner
: NULL
;
2461 /* Normal case. Call the breakpoint's print_it method, or
2462 print_it_typical. */
2463 /* FIXME: how breakpoint can ever be NULL here? */
2464 if (b
!= NULL
&& b
->ops
!= NULL
&& b
->ops
->print_it
!= NULL
)
2465 return b
->ops
->print_it (b
);
2467 return print_it_typical (bs
);
2472 internal_error (__FILE__
, __LINE__
,
2473 _("print_bp_stop_message: unrecognized enum value"));
2478 /* Print a message indicating what happened. This is called from
2479 normal_stop(). The input to this routine is the head of the bpstat
2480 list - a list of the eventpoints that caused this stop. This
2481 routine calls the generic print routine for printing a message
2482 about reasons for stopping. This will print (for example) the
2483 "Breakpoint n," part of the output. The return value of this
2486 PRINT_UNKNOWN: Means we printed nothing
2487 PRINT_SRC_AND_LOC: Means we printed something, and expect subsequent
2488 code to print the location. An example is
2489 "Breakpoint 1, " which should be followed by
2491 PRINT_SRC_ONLY: Means we printed something, but there is no need
2492 to also print the location part of the message.
2493 An example is the catch/throw messages, which
2494 don't require a location appended to the end.
2495 PRINT_NOTHING: We have done some printing and we don't need any
2496 further info to be printed.*/
2498 enum print_stop_action
2499 bpstat_print (bpstat bs
)
2503 /* Maybe another breakpoint in the chain caused us to stop.
2504 (Currently all watchpoints go on the bpstat whether hit or not.
2505 That probably could (should) be changed, provided care is taken
2506 with respect to bpstat_explains_signal). */
2507 for (; bs
; bs
= bs
->next
)
2509 val
= print_bp_stop_message (bs
);
2510 if (val
== PRINT_SRC_ONLY
2511 || val
== PRINT_SRC_AND_LOC
2512 || val
== PRINT_NOTHING
)
2516 /* We reached the end of the chain, or we got a null BS to start
2517 with and nothing was printed. */
2518 return PRINT_UNKNOWN
;
2521 /* Evaluate the expression EXP and return 1 if value is zero.
2522 This is used inside a catch_errors to evaluate the breakpoint condition.
2523 The argument is a "struct expression *" that has been cast to char * to
2524 make it pass through catch_errors. */
2527 breakpoint_cond_eval (void *exp
)
2529 struct value
*mark
= value_mark ();
2530 int i
= !value_true (evaluate_expression ((struct expression
*) exp
));
2531 value_free_to_mark (mark
);
2535 /* Allocate a new bpstat and chain it to the current one. */
2538 bpstat_alloc (const struct bp_location
*bl
, bpstat cbs
/* Current "bs" value */ )
2542 bs
= (bpstat
) xmalloc (sizeof (*bs
));
2544 bs
->breakpoint_at
= bl
;
2545 /* If the condition is false, etc., don't do the commands. */
2546 bs
->commands
= NULL
;
2548 bs
->print_it
= print_it_normal
;
2552 /* The target has stopped with waitstatus WS. Check if any hardware
2553 watchpoints have triggered, according to the target. */
2556 watchpoints_triggered (struct target_waitstatus
*ws
)
2558 int stopped_by_watchpoint
= STOPPED_BY_WATCHPOINT (*ws
);
2560 struct breakpoint
*b
;
2562 if (!stopped_by_watchpoint
)
2564 /* We were not stopped by a watchpoint. Mark all watchpoints
2565 as not triggered. */
2567 if (b
->type
== bp_hardware_watchpoint
2568 || b
->type
== bp_read_watchpoint
2569 || b
->type
== bp_access_watchpoint
)
2570 b
->watchpoint_triggered
= watch_triggered_no
;
2575 if (!target_stopped_data_address (¤t_target
, &addr
))
2577 /* We were stopped by a watchpoint, but we don't know where.
2578 Mark all watchpoints as unknown. */
2580 if (b
->type
== bp_hardware_watchpoint
2581 || b
->type
== bp_read_watchpoint
2582 || b
->type
== bp_access_watchpoint
)
2583 b
->watchpoint_triggered
= watch_triggered_unknown
;
2585 return stopped_by_watchpoint
;
2588 /* The target could report the data address. Mark watchpoints
2589 affected by this data address as triggered, and all others as not
2593 if (b
->type
== bp_hardware_watchpoint
2594 || b
->type
== bp_read_watchpoint
2595 || b
->type
== bp_access_watchpoint
)
2597 struct bp_location
*loc
;
2600 b
->watchpoint_triggered
= watch_triggered_no
;
2601 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
2602 /* Exact match not required. Within range is
2604 if (target_watchpoint_addr_within_range (¤t_target
,
2608 b
->watchpoint_triggered
= watch_triggered_yes
;
2616 /* Possible return values for watchpoint_check (this can't be an enum
2617 because of check_errors). */
2618 /* The watchpoint has been deleted. */
2619 #define WP_DELETED 1
2620 /* The value has changed. */
2621 #define WP_VALUE_CHANGED 2
2622 /* The value has not changed. */
2623 #define WP_VALUE_NOT_CHANGED 3
2625 #define BP_TEMPFLAG 1
2626 #define BP_HARDWAREFLAG 2
2628 /* Check watchpoint condition. */
2631 watchpoint_check (void *p
)
2633 bpstat bs
= (bpstat
) p
;
2634 struct breakpoint
*b
;
2635 struct frame_info
*fr
;
2636 int within_current_scope
;
2638 b
= bs
->breakpoint_at
->owner
;
2640 if (b
->exp_valid_block
== NULL
)
2641 within_current_scope
= 1;
2644 /* There is no current frame at this moment. If we're going to have
2645 any chance of handling watchpoints on local variables, we'll need
2646 the frame chain (so we can determine if we're in scope). */
2647 reinit_frame_cache ();
2648 fr
= frame_find_by_id (b
->watchpoint_frame
);
2649 within_current_scope
= (fr
!= NULL
);
2651 /* If we've gotten confused in the unwinder, we might have
2652 returned a frame that can't describe this variable. */
2653 if (within_current_scope
2654 && block_function (b
->exp_valid_block
) != get_frame_function (fr
))
2655 within_current_scope
= 0;
2657 /* in_function_epilogue_p() returns a non-zero value if we're still
2658 in the function but the stack frame has already been invalidated.
2659 Since we can't rely on the values of local variables after the
2660 stack has been destroyed, we are treating the watchpoint in that
2661 state as `not changed' without further checking.
2663 vinschen/2003-09-04: The former implementation left out the case
2664 that the watchpoint frame couldn't be found by frame_find_by_id()
2665 because the current PC is currently in an epilogue. Calling
2666 gdbarch_in_function_epilogue_p() also when fr == NULL fixes that. */
2667 if ((!within_current_scope
|| fr
== get_current_frame ())
2668 && gdbarch_in_function_epilogue_p (current_gdbarch
, read_pc ()))
2669 return WP_VALUE_NOT_CHANGED
;
2670 if (fr
&& within_current_scope
)
2671 /* If we end up stopping, the current frame will get selected
2672 in normal_stop. So this call to select_frame won't affect
2677 if (within_current_scope
)
2679 /* We use value_{,free_to_}mark because it could be a
2680 *long* time before we return to the command level and
2681 call free_all_values. We can't call free_all_values because
2682 we might be in the middle of evaluating a function call. */
2684 struct value
*mark
= value_mark ();
2685 struct value
*new_val
;
2687 fetch_watchpoint_value (b
->exp
, &new_val
, NULL
, NULL
);
2688 if ((b
->val
!= NULL
) != (new_val
!= NULL
)
2689 || (b
->val
!= NULL
&& !value_equal (b
->val
, new_val
)))
2691 if (new_val
!= NULL
)
2693 release_value (new_val
);
2694 value_free_to_mark (mark
);
2696 bs
->old_val
= b
->val
;
2699 /* We will stop here */
2700 return WP_VALUE_CHANGED
;
2704 /* Nothing changed, don't do anything. */
2705 value_free_to_mark (mark
);
2706 /* We won't stop here */
2707 return WP_VALUE_NOT_CHANGED
;
2712 /* This seems like the only logical thing to do because
2713 if we temporarily ignored the watchpoint, then when
2714 we reenter the block in which it is valid it contains
2715 garbage (in the case of a function, it may have two
2716 garbage values, one before and one after the prologue).
2717 So we can't even detect the first assignment to it and
2718 watch after that (since the garbage may or may not equal
2719 the first value assigned). */
2720 /* We print all the stop information in print_it_typical(), but
2721 in this case, by the time we call print_it_typical() this bp
2722 will be deleted already. So we have no choice but print the
2723 information here. */
2724 if (ui_out_is_mi_like_p (uiout
))
2726 (uiout
, "reason", async_reason_lookup (EXEC_ASYNC_WATCHPOINT_SCOPE
));
2727 ui_out_text (uiout
, "\nWatchpoint ");
2728 ui_out_field_int (uiout
, "wpnum", b
->number
);
2729 ui_out_text (uiout
, " deleted because the program has left the block in\n\
2730 which its expression is valid.\n");
2732 if (b
->related_breakpoint
)
2733 b
->related_breakpoint
->disposition
= disp_del_at_next_stop
;
2734 b
->disposition
= disp_del_at_next_stop
;
2740 /* Return true if it looks like target has stopped due to hitting
2741 breakpoint location BL. This function does not check if we
2742 should stop, only if BL explains the stop. */
2744 bpstat_check_location (const struct bp_location
*bl
, CORE_ADDR bp_addr
)
2746 struct breakpoint
*b
= bl
->owner
;
2748 if (b
->type
!= bp_watchpoint
2749 && b
->type
!= bp_hardware_watchpoint
2750 && b
->type
!= bp_read_watchpoint
2751 && b
->type
!= bp_access_watchpoint
2752 && b
->type
!= bp_hardware_breakpoint
2753 && b
->type
!= bp_catch_fork
2754 && b
->type
!= bp_catch_vfork
2755 && b
->type
!= bp_catch_exec
) /* a non-watchpoint bp */
2757 if (bl
->address
!= bp_addr
) /* address doesn't match */
2759 if (overlay_debugging
/* unmapped overlay section */
2760 && section_is_overlay (bl
->section
)
2761 && !section_is_mapped (bl
->section
))
2765 /* Continuable hardware watchpoints are treated as non-existent if the
2766 reason we stopped wasn't a hardware watchpoint (we didn't stop on
2767 some data address). Otherwise gdb won't stop on a break instruction
2768 in the code (not from a breakpoint) when a hardware watchpoint has
2769 been defined. Also skip watchpoints which we know did not trigger
2770 (did not match the data address). */
2772 if ((b
->type
== bp_hardware_watchpoint
2773 || b
->type
== bp_read_watchpoint
2774 || b
->type
== bp_access_watchpoint
)
2775 && b
->watchpoint_triggered
== watch_triggered_no
)
2778 if (b
->type
== bp_hardware_breakpoint
)
2780 if (bl
->address
!= bp_addr
)
2782 if (overlay_debugging
/* unmapped overlay section */
2783 && section_is_overlay (bl
->section
)
2784 && !section_is_mapped (bl
->section
))
2788 /* Is this a catchpoint of a load or unload? If so, did we
2789 get a load or unload of the specified library? If not,
2791 if ((b
->type
== bp_catch_load
)
2792 #if defined(SOLIB_HAVE_LOAD_EVENT)
2793 && (!SOLIB_HAVE_LOAD_EVENT (PIDGET (inferior_ptid
))
2794 || ((b
->dll_pathname
!= NULL
)
2795 && (strcmp (b
->dll_pathname
,
2796 SOLIB_LOADED_LIBRARY_PATHNAME (
2797 PIDGET (inferior_ptid
)))
2803 if ((b
->type
== bp_catch_unload
)
2804 #if defined(SOLIB_HAVE_UNLOAD_EVENT)
2805 && (!SOLIB_HAVE_UNLOAD_EVENT (PIDGET (inferior_ptid
))
2806 || ((b
->dll_pathname
!= NULL
)
2807 && (strcmp (b
->dll_pathname
,
2808 SOLIB_UNLOADED_LIBRARY_PATHNAME (
2809 PIDGET (inferior_ptid
)))
2815 if ((b
->type
== bp_catch_fork
)
2816 && !inferior_has_forked (PIDGET (inferior_ptid
),
2817 &b
->forked_inferior_pid
))
2820 if ((b
->type
== bp_catch_vfork
)
2821 && !inferior_has_vforked (PIDGET (inferior_ptid
),
2822 &b
->forked_inferior_pid
))
2825 if ((b
->type
== bp_catch_exec
)
2826 && !inferior_has_execd (PIDGET (inferior_ptid
), &b
->exec_pathname
))
2832 /* If BS refers to a watchpoint, determine if the watched values
2833 has actually changed, and we should stop. If not, set BS->stop
2836 bpstat_check_watchpoint (bpstat bs
)
2838 const struct bp_location
*bl
= bs
->breakpoint_at
;
2839 struct breakpoint
*b
= bl
->owner
;
2841 if (b
->type
== bp_watchpoint
2842 || b
->type
== bp_read_watchpoint
2843 || b
->type
== bp_access_watchpoint
2844 || b
->type
== bp_hardware_watchpoint
)
2848 int must_check_value
= 0;
2850 if (b
->type
== bp_watchpoint
)
2851 /* For a software watchpoint, we must always check the
2853 must_check_value
= 1;
2854 else if (b
->watchpoint_triggered
== watch_triggered_yes
)
2855 /* We have a hardware watchpoint (read, write, or access)
2856 and the target earlier reported an address watched by
2858 must_check_value
= 1;
2859 else if (b
->watchpoint_triggered
== watch_triggered_unknown
2860 && b
->type
== bp_hardware_watchpoint
)
2861 /* We were stopped by a hardware watchpoint, but the target could
2862 not report the data address. We must check the watchpoint's
2863 value. Access and read watchpoints are out of luck; without
2864 a data address, we can't figure it out. */
2865 must_check_value
= 1;
2867 if (must_check_value
)
2869 char *message
= xstrprintf ("Error evaluating expression for watchpoint %d\n",
2871 struct cleanup
*cleanups
= make_cleanup (xfree
, message
);
2872 int e
= catch_errors (watchpoint_check
, bs
, message
,
2874 do_cleanups (cleanups
);
2878 /* We've already printed what needs to be printed. */
2879 bs
->print_it
= print_it_done
;
2882 case WP_VALUE_CHANGED
:
2883 if (b
->type
== bp_read_watchpoint
)
2885 /* Don't stop: read watchpoints shouldn't fire if
2886 the value has changed. This is for targets
2887 which cannot set read-only watchpoints. */
2888 bs
->print_it
= print_it_noop
;
2892 case WP_VALUE_NOT_CHANGED
:
2893 if (b
->type
== bp_hardware_watchpoint
2894 || b
->type
== bp_watchpoint
)
2896 /* Don't stop: write watchpoints shouldn't fire if
2897 the value hasn't changed. */
2898 bs
->print_it
= print_it_noop
;
2906 /* Error from catch_errors. */
2907 printf_filtered (_("Watchpoint %d deleted.\n"), b
->number
);
2908 if (b
->related_breakpoint
)
2909 b
->related_breakpoint
->disposition
= disp_del_at_next_stop
;
2910 b
->disposition
= disp_del_at_next_stop
;
2911 /* We've already printed what needs to be printed. */
2912 bs
->print_it
= print_it_done
;
2916 else /* must_check_value == 0 */
2918 /* This is a case where some watchpoint(s) triggered, but
2919 not at the address of this watchpoint, or else no
2920 watchpoint triggered after all. So don't print
2921 anything for this watchpoint. */
2922 bs
->print_it
= print_it_noop
;
2929 /* Check conditions (condition proper, frame, thread and ignore count)
2930 of breakpoint referred to by BS. If we should not stop for this
2931 breakpoint, set BS->stop to 0. */
2933 bpstat_check_breakpoint_conditions (bpstat bs
, ptid_t ptid
)
2935 int thread_id
= pid_to_thread_id (ptid
);
2936 const struct bp_location
*bl
= bs
->breakpoint_at
;
2937 struct breakpoint
*b
= bl
->owner
;
2939 if (frame_id_p (b
->frame_id
)
2940 && !frame_id_eq (b
->frame_id
, get_frame_id (get_current_frame ())))
2944 int value_is_zero
= 0;
2946 /* If this is a scope breakpoint, mark the associated
2947 watchpoint as triggered so that we will handle the
2948 out-of-scope event. We'll get to the watchpoint next
2950 if (b
->type
== bp_watchpoint_scope
)
2951 b
->related_breakpoint
->watchpoint_triggered
= watch_triggered_yes
;
2953 if (bl
->cond
&& bl
->owner
->disposition
!= disp_del_at_next_stop
)
2955 /* Need to select the frame, with all that implies
2956 so that the conditions will have the right context. */
2957 select_frame (get_current_frame ());
2959 = catch_errors (breakpoint_cond_eval
, (bl
->cond
),
2960 "Error in testing breakpoint condition:\n",
2962 /* FIXME-someday, should give breakpoint # */
2965 if (bl
->cond
&& value_is_zero
)
2969 else if (b
->thread
!= -1 && b
->thread
!= thread_id
)
2973 else if (b
->ignore_count
> 0)
2976 annotate_ignore_count_change ();
2978 /* Increase the hit count even though we don't
2986 /* Get a bpstat associated with having just stopped at address
2987 BP_ADDR in thread PTID.
2989 Determine whether we stopped at a breakpoint, etc, or whether we
2990 don't understand this stop. Result is a chain of bpstat's such that:
2992 if we don't understand the stop, the result is a null pointer.
2994 if we understand why we stopped, the result is not null.
2996 Each element of the chain refers to a particular breakpoint or
2997 watchpoint at which we have stopped. (We may have stopped for
2998 several reasons concurrently.)
3000 Each element of the chain has valid next, breakpoint_at,
3001 commands, FIXME??? fields. */
3004 bpstat_stop_status (CORE_ADDR bp_addr
, ptid_t ptid
)
3006 struct breakpoint
*b
= NULL
;
3007 const struct bp_location
*bl
;
3008 /* Root of the chain of bpstat's */
3009 struct bpstats root_bs
[1];
3010 /* Pointer to the last thing in the chain currently. */
3011 bpstat bs
= root_bs
;
3013 ALL_BP_LOCATIONS (bl
)
3017 if (!breakpoint_enabled (b
) && b
->enable_state
!= bp_permanent
)
3020 /* For hardware watchpoints, we look only at the first location.
3021 The watchpoint_check function will work on entire expression,
3022 not the individual locations. For read watchopints, the
3023 watchpoints_triggered function have checked all locations
3026 if (b
->type
== bp_hardware_watchpoint
&& bl
!= b
->loc
)
3029 if (!bpstat_check_location (bl
, bp_addr
))
3032 /* Come here if it's a watchpoint, or if the break address matches */
3034 bs
= bpstat_alloc (bl
, bs
); /* Alloc a bpstat to explain stop */
3036 /* Assume we stop. Should we find watchpoint that is not actually
3037 triggered, or if condition of breakpoint is false, we'll reset
3042 bpstat_check_watchpoint (bs
);
3046 if (b
->type
== bp_thread_event
|| b
->type
== bp_overlay_event
)
3047 /* We do not stop for these. */
3050 bpstat_check_breakpoint_conditions (bs
, ptid
);
3056 /* We will stop here */
3057 if (b
->disposition
== disp_disable
)
3059 b
->enable_state
= bp_disabled
;
3060 update_global_location_list ();
3064 bs
->commands
= b
->commands
;
3066 (strcmp ("silent", bs
->commands
->line
) == 0
3067 || (xdb_commands
&& strcmp ("Q", bs
->commands
->line
) == 0)))
3069 bs
->commands
= bs
->commands
->next
;
3072 bs
->commands
= copy_command_lines (bs
->commands
);
3075 /* Print nothing for this entry if we dont stop or if we dont print. */
3076 if (bs
->stop
== 0 || bs
->print
== 0)
3077 bs
->print_it
= print_it_noop
;
3080 bs
->next
= NULL
; /* Terminate the chain */
3081 bs
= root_bs
->next
; /* Re-grab the head of the chain */
3083 /* If we aren't stopping, the value of some hardware watchpoint may
3084 not have changed, but the intermediate memory locations we are
3085 watching may have. Don't bother if we're stopping; this will get
3087 for (bs
= root_bs
->next
; bs
!= NULL
; bs
= bs
->next
)
3092 for (bs
= root_bs
->next
; bs
!= NULL
; bs
= bs
->next
)
3094 && (bs
->breakpoint_at
->owner
->type
== bp_hardware_watchpoint
3095 || bs
->breakpoint_at
->owner
->type
== bp_read_watchpoint
3096 || bs
->breakpoint_at
->owner
->type
== bp_access_watchpoint
))
3098 /* remove/insert can invalidate bs->breakpoint_at, if this
3099 location is no longer used by the watchpoint. Prevent
3100 further code from trying to use it. */
3101 bs
->breakpoint_at
= NULL
;
3102 remove_breakpoints ();
3103 insert_breakpoints ();
3107 return root_bs
->next
;
3110 /* Tell what to do about this bpstat. */
3112 bpstat_what (bpstat bs
)
3114 /* Classify each bpstat as one of the following. */
3117 /* This bpstat element has no effect on the main_action. */
3120 /* There was a watchpoint, stop but don't print. */
3123 /* There was a watchpoint, stop and print. */
3126 /* There was a breakpoint but we're not stopping. */
3129 /* There was a breakpoint, stop but don't print. */
3132 /* There was a breakpoint, stop and print. */
3135 /* We hit the longjmp breakpoint. */
3138 /* We hit the longjmp_resume breakpoint. */
3141 /* We hit the step_resume breakpoint. */
3144 /* We hit the shared library event breakpoint. */
3147 /* We caught a shared library event. */
3150 /* This is just used to count how many enums there are. */
3154 /* Here is the table which drives this routine. So that we can
3155 format it pretty, we define some abbreviations for the
3156 enum bpstat_what codes. */
3157 #define kc BPSTAT_WHAT_KEEP_CHECKING
3158 #define ss BPSTAT_WHAT_STOP_SILENT
3159 #define sn BPSTAT_WHAT_STOP_NOISY
3160 #define sgl BPSTAT_WHAT_SINGLE
3161 #define slr BPSTAT_WHAT_SET_LONGJMP_RESUME
3162 #define clr BPSTAT_WHAT_CLEAR_LONGJMP_RESUME
3163 #define sr BPSTAT_WHAT_STEP_RESUME
3164 #define shl BPSTAT_WHAT_CHECK_SHLIBS
3165 #define shlr BPSTAT_WHAT_CHECK_SHLIBS_RESUME_FROM_HOOK
3167 /* "Can't happen." Might want to print an error message.
3168 abort() is not out of the question, but chances are GDB is just
3169 a bit confused, not unusable. */
3170 #define err BPSTAT_WHAT_STOP_NOISY
3172 /* Given an old action and a class, come up with a new action. */
3173 /* One interesting property of this table is that wp_silent is the same
3174 as bp_silent and wp_noisy is the same as bp_noisy. That is because
3175 after stopping, the check for whether to step over a breakpoint
3176 (BPSTAT_WHAT_SINGLE type stuff) is handled in proceed() without
3177 reference to how we stopped. We retain separate wp_silent and
3178 bp_silent codes in case we want to change that someday.
3180 Another possibly interesting property of this table is that
3181 there's a partial ordering, priority-like, of the actions. Once
3182 you've decided that some action is appropriate, you'll never go
3183 back and decide something of a lower priority is better. The
3186 kc < clr sgl shl shlr slr sn sr ss
3187 sgl < shl shlr slr sn sr ss
3188 slr < err shl shlr sn sr ss
3189 clr < err shl shlr sn sr ss
3196 What I think this means is that we don't need a damned table
3197 here. If you just put the rows and columns in the right order,
3198 it'd look awfully regular. We could simply walk the bpstat list
3199 and choose the highest priority action we find, with a little
3200 logic to handle the 'err' cases. */
3202 /* step_resume entries: a step resume breakpoint overrides another
3203 breakpoint of signal handling (see comment in wait_for_inferior
3204 at where we set the step_resume breakpoint). */
3206 static const enum bpstat_what_main_action
3207 table
[(int) class_last
][(int) BPSTAT_WHAT_LAST
] =
3210 /* kc ss sn sgl slr clr sr shl shlr
3213 {kc
, ss
, sn
, sgl
, slr
, clr
, sr
, shl
, shlr
},
3215 {ss
, ss
, sn
, ss
, ss
, ss
, sr
, shl
, shlr
},
3217 {sn
, sn
, sn
, sn
, sn
, sn
, sr
, shl
, shlr
},
3219 {sgl
, ss
, sn
, sgl
, slr
, slr
, sr
, shl
, shlr
},
3221 {ss
, ss
, sn
, ss
, ss
, ss
, sr
, shl
, shlr
},
3223 {sn
, sn
, sn
, sn
, sn
, sn
, sr
, shl
, shlr
},
3225 {slr
, ss
, sn
, slr
, slr
, err
, sr
, shl
, shlr
},
3227 {clr
, ss
, sn
, err
, err
, err
, sr
, shl
, shlr
},
3229 {sr
, sr
, sr
, sr
, sr
, sr
, sr
, sr
, sr
},
3231 {shl
, shl
, shl
, shl
, shl
, shl
, sr
, shl
, shlr
},
3233 {shlr
, shlr
, shlr
, shlr
, shlr
, shlr
, sr
, shlr
, shlr
}
3247 enum bpstat_what_main_action current_action
= BPSTAT_WHAT_KEEP_CHECKING
;
3248 struct bpstat_what retval
;
3250 retval
.call_dummy
= 0;
3251 for (; bs
!= NULL
; bs
= bs
->next
)
3253 enum class bs_class
= no_effect
;
3254 if (bs
->breakpoint_at
== NULL
)
3255 /* I suspect this can happen if it was a momentary breakpoint
3256 which has since been deleted. */
3258 switch (bs
->breakpoint_at
->owner
->type
)
3264 case bp_hardware_breakpoint
:
3270 bs_class
= bp_noisy
;
3272 bs_class
= bp_silent
;
3275 bs_class
= bp_nostop
;
3278 case bp_hardware_watchpoint
:
3279 case bp_read_watchpoint
:
3280 case bp_access_watchpoint
:
3284 bs_class
= wp_noisy
;
3286 bs_class
= wp_silent
;
3289 /* There was a watchpoint, but we're not stopping.
3290 This requires no further action. */
3291 bs_class
= no_effect
;
3294 bs_class
= long_jump
;
3296 case bp_longjmp_resume
:
3297 bs_class
= long_resume
;
3299 case bp_step_resume
:
3302 bs_class
= step_resume
;
3305 /* It is for the wrong frame. */
3306 bs_class
= bp_nostop
;
3308 case bp_watchpoint_scope
:
3309 bs_class
= bp_nostop
;
3311 case bp_shlib_event
:
3312 bs_class
= shlib_event
;
3314 case bp_thread_event
:
3315 case bp_overlay_event
:
3316 bs_class
= bp_nostop
;
3319 case bp_catch_unload
:
3320 /* Only if this catchpoint triggered should we cause the
3321 step-out-of-dld behaviour. Otherwise, we ignore this
3324 bs_class
= catch_shlib_event
;
3326 bs_class
= no_effect
;
3329 case bp_catch_vfork
:
3334 bs_class
= bp_noisy
;
3336 bs_class
= bp_silent
;
3339 /* There was a catchpoint, but we're not stopping.
3340 This requires no further action. */
3341 bs_class
= no_effect
;
3344 /* Make sure the action is stop (silent or noisy),
3345 so infrun.c pops the dummy frame. */
3346 bs_class
= bp_silent
;
3347 retval
.call_dummy
= 1;
3350 current_action
= table
[(int) bs_class
][(int) current_action
];
3352 retval
.main_action
= current_action
;
3356 /* Nonzero if we should step constantly (e.g. watchpoints on machines
3357 without hardware support). This isn't related to a specific bpstat,
3358 just to things like whether watchpoints are set. */
3361 bpstat_should_step (void)
3363 struct breakpoint
*b
;
3365 if (breakpoint_enabled (b
) && b
->type
== bp_watchpoint
)
3372 /* Given a bpstat that records zero or more triggered eventpoints, this
3373 function returns another bpstat which contains only the catchpoints
3374 on that first list, if any. */
3376 bpstat_get_triggered_catchpoints (bpstat ep_list
, bpstat
*cp_list
)
3378 struct bpstats root_bs
[1];
3379 bpstat bs
= root_bs
;
3380 struct breakpoint
*ep
;
3383 bpstat_clear (cp_list
);
3384 root_bs
->next
= NULL
;
3386 for (; ep_list
!= NULL
; ep_list
= ep_list
->next
)
3388 /* Is this eventpoint a catchpoint? If not, ignore it. */
3389 ep
= ep_list
->breakpoint_at
->owner
;
3392 if ((ep
->type
!= bp_catch_load
) &&
3393 (ep
->type
!= bp_catch_unload
))
3394 /* pai: (temp) ADD fork/vfork here!! */
3397 /* Yes; add it to the list. */
3398 bs
= bpstat_alloc (ep_list
->breakpoint_at
, bs
);
3403 #if defined(SOLIB_ADD)
3404 /* Also, for each triggered catchpoint, tag it with the name of
3405 the library that caused this trigger. (We copy the name now,
3406 because it's only guaranteed to be available NOW, when the
3407 catchpoint triggers. Clients who may wish to know the name
3408 later must get it from the catchpoint itself.) */
3409 if (ep
->triggered_dll_pathname
!= NULL
)
3410 xfree (ep
->triggered_dll_pathname
);
3411 if (ep
->type
== bp_catch_load
)
3412 dll_pathname
= SOLIB_LOADED_LIBRARY_PATHNAME (
3413 PIDGET (inferior_ptid
));
3415 dll_pathname
= SOLIB_UNLOADED_LIBRARY_PATHNAME (
3416 PIDGET (inferior_ptid
));
3418 dll_pathname
= NULL
;
3422 ep
->triggered_dll_pathname
= (char *)
3423 xmalloc (strlen (dll_pathname
) + 1);
3424 strcpy (ep
->triggered_dll_pathname
, dll_pathname
);
3427 ep
->triggered_dll_pathname
= NULL
;
3433 static void print_breakpoint_location (struct breakpoint
*b
,
3434 struct bp_location
*loc
,
3436 struct ui_stream
*stb
)
3441 = find_pc_sect_function (loc
->address
, loc
->section
);
3444 ui_out_text (uiout
, "in ");
3445 ui_out_field_string (uiout
, "func",
3446 SYMBOL_PRINT_NAME (sym
));
3447 ui_out_wrap_hint (uiout
, wrap_indent
);
3448 ui_out_text (uiout
, " at ");
3450 ui_out_field_string (uiout
, "file", b
->source_file
);
3451 ui_out_text (uiout
, ":");
3453 if (ui_out_is_mi_like_p (uiout
))
3455 struct symtab_and_line sal
= find_pc_line (loc
->address
, 0);
3456 char *fullname
= symtab_to_fullname (sal
.symtab
);
3459 ui_out_field_string (uiout
, "fullname", fullname
);
3462 ui_out_field_int (uiout
, "line", b
->line_number
);
3466 ui_out_field_string (uiout
, "pending", b
->addr_string
);
3470 print_address_symbolic (loc
->address
, stb
->stream
, demangle
, "");
3471 ui_out_field_stream (uiout
, "at", stb
);
3475 /* Print B to gdb_stdout. */
3477 print_one_breakpoint_location (struct breakpoint
*b
,
3478 struct bp_location
*loc
,
3480 CORE_ADDR
*last_addr
)
3482 struct command_line
*l
;
3484 struct ep_type_description
3489 static struct ep_type_description bptypes
[] =
3491 {bp_none
, "?deleted?"},
3492 {bp_breakpoint
, "breakpoint"},
3493 {bp_hardware_breakpoint
, "hw breakpoint"},
3494 {bp_until
, "until"},
3495 {bp_finish
, "finish"},
3496 {bp_watchpoint
, "watchpoint"},
3497 {bp_hardware_watchpoint
, "hw watchpoint"},
3498 {bp_read_watchpoint
, "read watchpoint"},
3499 {bp_access_watchpoint
, "acc watchpoint"},
3500 {bp_longjmp
, "longjmp"},
3501 {bp_longjmp_resume
, "longjmp resume"},
3502 {bp_step_resume
, "step resume"},
3503 {bp_watchpoint_scope
, "watchpoint scope"},
3504 {bp_call_dummy
, "call dummy"},
3505 {bp_shlib_event
, "shlib events"},
3506 {bp_thread_event
, "thread events"},
3507 {bp_overlay_event
, "overlay events"},
3508 {bp_catch_load
, "catch load"},
3509 {bp_catch_unload
, "catch unload"},
3510 {bp_catch_fork
, "catch fork"},
3511 {bp_catch_vfork
, "catch vfork"},
3512 {bp_catch_exec
, "catch exec"}
3515 static char bpenables
[] = "nynny";
3516 char wrap_indent
[80];
3517 struct ui_stream
*stb
= ui_out_stream_new (uiout
);
3518 struct cleanup
*old_chain
= make_cleanup_ui_out_stream_delete (stb
);
3519 struct cleanup
*bkpt_chain
;
3521 int header_of_multiple
= 0;
3522 int part_of_multiple
= (loc
!= NULL
);
3524 gdb_assert (!loc
|| loc_number
!= 0);
3525 /* See comment in print_one_breakpoint concerning
3526 treatment of breakpoints with single disabled
3530 && (b
->loc
->next
!= NULL
|| !b
->loc
->enabled
)))
3531 header_of_multiple
= 1;
3536 bkpt_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "bkpt");
3540 if (part_of_multiple
)
3543 formatted
= xstrprintf ("%d.%d", b
->number
, loc_number
);
3544 ui_out_field_string (uiout
, "number", formatted
);
3549 ui_out_field_int (uiout
, "number", b
->number
);
3554 if (part_of_multiple
)
3555 ui_out_field_skip (uiout
, "type");
3558 if (((int) b
->type
>= (sizeof (bptypes
) / sizeof (bptypes
[0])))
3559 || ((int) b
->type
!= bptypes
[(int) b
->type
].type
))
3560 internal_error (__FILE__
, __LINE__
,
3561 _("bptypes table does not describe type #%d."),
3563 ui_out_field_string (uiout
, "type", bptypes
[(int) b
->type
].description
);
3568 if (part_of_multiple
)
3569 ui_out_field_skip (uiout
, "disp");
3571 ui_out_field_string (uiout
, "disp", bpdisp_text (b
->disposition
));
3576 if (part_of_multiple
)
3577 ui_out_field_string (uiout
, "enabled", loc
->enabled
? "y" : "n");
3579 ui_out_field_fmt (uiout
, "enabled", "%c",
3580 bpenables
[(int) b
->enable_state
]);
3581 ui_out_spaces (uiout
, 2);
3585 strcpy (wrap_indent
, " ");
3588 if (gdbarch_addr_bit (current_gdbarch
) <= 32)
3589 strcat (wrap_indent
, " ");
3591 strcat (wrap_indent
, " ");
3594 if (b
->ops
!= NULL
&& b
->ops
->print_one
!= NULL
)
3596 /* Although the print_one can possibly print
3597 all locations, calling it here is not likely
3598 to get any nice result. So, make sure there's
3599 just one location. */
3600 gdb_assert (b
->loc
== NULL
|| b
->loc
->next
== NULL
);
3601 b
->ops
->print_one (b
, last_addr
);
3607 internal_error (__FILE__
, __LINE__
,
3608 _("print_one_breakpoint: bp_none encountered\n"));
3612 case bp_hardware_watchpoint
:
3613 case bp_read_watchpoint
:
3614 case bp_access_watchpoint
:
3615 /* Field 4, the address, is omitted (which makes the columns
3616 not line up too nicely with the headers, but the effect
3617 is relatively readable). */
3619 ui_out_field_skip (uiout
, "addr");
3621 print_expression (b
->exp
, stb
->stream
);
3622 ui_out_field_stream (uiout
, "what", stb
);
3626 case bp_catch_unload
:
3627 /* Field 4, the address, is omitted (which makes the columns
3628 not line up too nicely with the headers, but the effect
3629 is relatively readable). */
3631 ui_out_field_skip (uiout
, "addr");
3633 if (b
->dll_pathname
== NULL
)
3635 ui_out_field_string (uiout
, "what", "<any library>");
3636 ui_out_spaces (uiout
, 1);
3640 ui_out_text (uiout
, "library \"");
3641 ui_out_field_string (uiout
, "what", b
->dll_pathname
);
3642 ui_out_text (uiout
, "\" ");
3647 case bp_catch_vfork
:
3648 /* Field 4, the address, is omitted (which makes the columns
3649 not line up too nicely with the headers, but the effect
3650 is relatively readable). */
3652 ui_out_field_skip (uiout
, "addr");
3654 if (b
->forked_inferior_pid
!= 0)
3656 ui_out_text (uiout
, "process ");
3657 ui_out_field_int (uiout
, "what", b
->forked_inferior_pid
);
3658 ui_out_spaces (uiout
, 1);
3663 /* Field 4, the address, is omitted (which makes the columns
3664 not line up too nicely with the headers, but the effect
3665 is relatively readable). */
3667 ui_out_field_skip (uiout
, "addr");
3669 if (b
->exec_pathname
!= NULL
)
3671 ui_out_text (uiout
, "program \"");
3672 ui_out_field_string (uiout
, "what", b
->exec_pathname
);
3673 ui_out_text (uiout
, "\" ");
3678 case bp_hardware_breakpoint
:
3682 case bp_longjmp_resume
:
3683 case bp_step_resume
:
3684 case bp_watchpoint_scope
:
3686 case bp_shlib_event
:
3687 case bp_thread_event
:
3688 case bp_overlay_event
:
3692 if (header_of_multiple
)
3693 ui_out_field_string (uiout
, "addr", "<MULTIPLE>");
3694 else if (b
->loc
== NULL
|| loc
->shlib_disabled
)
3695 ui_out_field_string (uiout
, "addr", "<PENDING>");
3697 ui_out_field_core_addr (uiout
, "addr", loc
->address
);
3700 if (!header_of_multiple
)
3701 print_breakpoint_location (b
, loc
, wrap_indent
, stb
);
3703 *last_addr
= b
->loc
->address
;
3707 if (!part_of_multiple
&& b
->thread
!= -1)
3709 /* FIXME: This seems to be redundant and lost here; see the
3710 "stop only in" line a little further down. */
3711 ui_out_text (uiout
, " thread ");
3712 ui_out_field_int (uiout
, "thread", b
->thread
);
3715 ui_out_text (uiout
, "\n");
3717 if (part_of_multiple
&& frame_id_p (b
->frame_id
))
3720 ui_out_text (uiout
, "\tstop only in stack frame at ");
3721 /* FIXME: cagney/2002-12-01: Shouldn't be poeking around inside
3723 ui_out_field_core_addr (uiout
, "frame", b
->frame_id
.stack_addr
);
3724 ui_out_text (uiout
, "\n");
3727 if (!part_of_multiple
&& b
->cond_string
&& !ada_exception_catchpoint_p (b
))
3729 /* We do not print the condition for Ada exception catchpoints
3730 because the condition is an internal implementation detail
3731 that we do not want to expose to the user. */
3733 ui_out_text (uiout
, "\tstop only if ");
3734 ui_out_field_string (uiout
, "cond", b
->cond_string
);
3735 ui_out_text (uiout
, "\n");
3738 if (!part_of_multiple
&& b
->thread
!= -1)
3740 /* FIXME should make an annotation for this */
3741 ui_out_text (uiout
, "\tstop only in thread ");
3742 ui_out_field_int (uiout
, "thread", b
->thread
);
3743 ui_out_text (uiout
, "\n");
3746 if (!part_of_multiple
&& show_breakpoint_hit_counts
&& b
->hit_count
)
3748 /* FIXME should make an annotation for this */
3749 if (ep_is_catchpoint (b
))
3750 ui_out_text (uiout
, "\tcatchpoint");
3752 ui_out_text (uiout
, "\tbreakpoint");
3753 ui_out_text (uiout
, " already hit ");
3754 ui_out_field_int (uiout
, "times", b
->hit_count
);
3755 if (b
->hit_count
== 1)
3756 ui_out_text (uiout
, " time\n");
3758 ui_out_text (uiout
, " times\n");
3761 /* Output the count also if it is zero, but only if this is
3762 mi. FIXME: Should have a better test for this. */
3763 if (ui_out_is_mi_like_p (uiout
))
3764 if (!part_of_multiple
&& show_breakpoint_hit_counts
&& b
->hit_count
== 0)
3765 ui_out_field_int (uiout
, "times", b
->hit_count
);
3767 if (!part_of_multiple
&& b
->ignore_count
)
3770 ui_out_text (uiout
, "\tignore next ");
3771 ui_out_field_int (uiout
, "ignore", b
->ignore_count
);
3772 ui_out_text (uiout
, " hits\n");
3775 if (!part_of_multiple
&& (l
= b
->commands
))
3777 struct cleanup
*script_chain
;
3780 script_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "script");
3781 print_command_lines (uiout
, l
, 4);
3782 do_cleanups (script_chain
);
3785 if (ui_out_is_mi_like_p (uiout
) && !part_of_multiple
)
3788 ui_out_field_string (uiout
, "original-location", b
->addr_string
);
3789 else if (b
->exp_string
)
3790 ui_out_field_string (uiout
, "original-location", b
->exp_string
);
3793 do_cleanups (bkpt_chain
);
3794 do_cleanups (old_chain
);
3798 print_one_breakpoint (struct breakpoint
*b
,
3799 CORE_ADDR
*last_addr
)
3801 print_one_breakpoint_location (b
, NULL
, 0, last_addr
);
3803 /* If this breakpoint has custom print function,
3804 it's already printed. Otherwise, print individual
3805 locations, if any. */
3806 if (b
->ops
== NULL
|| b
->ops
->print_one
== NULL
)
3808 /* If breakpoint has a single location that is
3809 disabled, we print it as if it had
3810 several locations, since otherwise it's hard to
3811 represent "breakpoint enabled, location disabled"
3813 Note that while hardware watchpoints have
3814 several locations internally, that's no a property
3817 && !is_hardware_watchpoint (b
)
3818 && (b
->loc
->next
|| !b
->loc
->enabled
)
3819 && !ui_out_is_mi_like_p (uiout
))
3821 struct bp_location
*loc
;
3823 for (loc
= b
->loc
; loc
; loc
= loc
->next
, ++n
)
3824 print_one_breakpoint_location (b
, loc
, n
, last_addr
);
3830 struct captured_breakpoint_query_args
3836 do_captured_breakpoint_query (struct ui_out
*uiout
, void *data
)
3838 struct captured_breakpoint_query_args
*args
= data
;
3839 struct breakpoint
*b
;
3840 CORE_ADDR dummy_addr
= 0;
3843 if (args
->bnum
== b
->number
)
3845 print_one_breakpoint (b
, &dummy_addr
);
3853 gdb_breakpoint_query (struct ui_out
*uiout
, int bnum
, char **error_message
)
3855 struct captured_breakpoint_query_args args
;
3857 /* For the moment we don't trust print_one_breakpoint() to not throw
3859 if (catch_exceptions_with_msg (uiout
, do_captured_breakpoint_query
, &args
,
3860 error_message
, RETURN_MASK_ALL
) < 0)
3866 /* Return non-zero if B is user settable (breakpoints, watchpoints,
3867 catchpoints, et.al.). */
3870 user_settable_breakpoint (const struct breakpoint
*b
)
3872 return (b
->type
== bp_breakpoint
3873 || b
->type
== bp_catch_load
3874 || b
->type
== bp_catch_unload
3875 || b
->type
== bp_catch_fork
3876 || b
->type
== bp_catch_vfork
3877 || b
->type
== bp_catch_exec
3878 || b
->type
== bp_hardware_breakpoint
3879 || b
->type
== bp_watchpoint
3880 || b
->type
== bp_read_watchpoint
3881 || b
->type
== bp_access_watchpoint
3882 || b
->type
== bp_hardware_watchpoint
);
3885 /* Print information on user settable breakpoint (watchpoint, etc)
3886 number BNUM. If BNUM is -1 print all user settable breakpoints.
3887 If ALLFLAG is non-zero, include non- user settable breakpoints. */
3890 breakpoint_1 (int bnum
, int allflag
)
3892 struct breakpoint
*b
;
3893 CORE_ADDR last_addr
= (CORE_ADDR
) -1;
3894 int nr_printable_breakpoints
;
3895 struct cleanup
*bkpttbl_chain
;
3897 /* Compute the number of rows in the table. */
3898 nr_printable_breakpoints
= 0;
3901 || bnum
== b
->number
)
3903 if (allflag
|| user_settable_breakpoint (b
))
3904 nr_printable_breakpoints
++;
3909 = make_cleanup_ui_out_table_begin_end (uiout
, 6, nr_printable_breakpoints
,
3913 = make_cleanup_ui_out_table_begin_end (uiout
, 5, nr_printable_breakpoints
,
3916 if (nr_printable_breakpoints
> 0)
3917 annotate_breakpoints_headers ();
3918 if (nr_printable_breakpoints
> 0)
3920 ui_out_table_header (uiout
, 7, ui_left
, "number", "Num"); /* 1 */
3921 if (nr_printable_breakpoints
> 0)
3923 ui_out_table_header (uiout
, 14, ui_left
, "type", "Type"); /* 2 */
3924 if (nr_printable_breakpoints
> 0)
3926 ui_out_table_header (uiout
, 4, ui_left
, "disp", "Disp"); /* 3 */
3927 if (nr_printable_breakpoints
> 0)
3929 ui_out_table_header (uiout
, 3, ui_left
, "enabled", "Enb"); /* 4 */
3932 if (nr_printable_breakpoints
> 0)
3934 if (gdbarch_addr_bit (current_gdbarch
) <= 32)
3935 ui_out_table_header (uiout
, 10, ui_left
, "addr", "Address");/* 5 */
3937 ui_out_table_header (uiout
, 18, ui_left
, "addr", "Address");/* 5 */
3939 if (nr_printable_breakpoints
> 0)
3941 ui_out_table_header (uiout
, 40, ui_noalign
, "what", "What"); /* 6 */
3942 ui_out_table_body (uiout
);
3943 if (nr_printable_breakpoints
> 0)
3944 annotate_breakpoints_table ();
3948 || bnum
== b
->number
)
3950 /* We only print out user settable breakpoints unless the
3952 if (allflag
|| user_settable_breakpoint (b
))
3953 print_one_breakpoint (b
, &last_addr
);
3956 do_cleanups (bkpttbl_chain
);
3958 if (nr_printable_breakpoints
== 0)
3961 ui_out_message (uiout
, 0, "No breakpoints or watchpoints.\n");
3963 ui_out_message (uiout
, 0, "No breakpoint or watchpoint number %d.\n",
3968 /* Compare against (CORE_ADDR)-1 in case some compiler decides
3969 that a comparison of an unsigned with -1 is always false. */
3970 if (last_addr
!= (CORE_ADDR
) -1 && !server_command
)
3971 set_next_address (last_addr
);
3974 /* FIXME? Should this be moved up so that it is only called when
3975 there have been breakpoints? */
3976 annotate_breakpoints_table_end ();
3980 breakpoints_info (char *bnum_exp
, int from_tty
)
3985 bnum
= parse_and_eval_long (bnum_exp
);
3987 breakpoint_1 (bnum
, 0);
3991 maintenance_info_breakpoints (char *bnum_exp
, int from_tty
)
3996 bnum
= parse_and_eval_long (bnum_exp
);
3998 breakpoint_1 (bnum
, 1);
4002 breakpoint_has_pc (struct breakpoint
*b
, CORE_ADDR pc
, asection
*section
)
4004 struct bp_location
*bl
= b
->loc
;
4005 for (; bl
; bl
= bl
->next
)
4007 if (bl
->address
== pc
4008 && (!overlay_debugging
|| bl
->section
== section
))
4014 /* Print a message describing any breakpoints set at PC. */
4017 describe_other_breakpoints (CORE_ADDR pc
, asection
*section
, int thread
)
4020 struct breakpoint
*b
;
4023 others
+= breakpoint_has_pc (b
, pc
, section
);
4027 printf_filtered (_("Note: breakpoint "));
4028 else /* if (others == ???) */
4029 printf_filtered (_("Note: breakpoints "));
4031 if (breakpoint_has_pc (b
, pc
, section
))
4034 printf_filtered ("%d", b
->number
);
4035 if (b
->thread
== -1 && thread
!= -1)
4036 printf_filtered (" (all threads)");
4037 else if (b
->thread
!= -1)
4038 printf_filtered (" (thread %d)", b
->thread
);
4039 printf_filtered ("%s%s ",
4040 ((b
->enable_state
== bp_disabled
||
4041 b
->enable_state
== bp_call_disabled
)
4043 : b
->enable_state
== bp_permanent
4047 : ((others
== 1) ? " and" : ""));
4049 printf_filtered (_("also set at pc "));
4050 fputs_filtered (paddress (pc
), gdb_stdout
);
4051 printf_filtered (".\n");
4055 /* Set the default place to put a breakpoint
4056 for the `break' command with no arguments. */
4059 set_default_breakpoint (int valid
, CORE_ADDR addr
, struct symtab
*symtab
,
4062 default_breakpoint_valid
= valid
;
4063 default_breakpoint_address
= addr
;
4064 default_breakpoint_symtab
= symtab
;
4065 default_breakpoint_line
= line
;
4068 /* Return true iff it is meaningful to use the address member of
4069 BPT. For some breakpoint types, the address member is irrelevant
4070 and it makes no sense to attempt to compare it to other addresses
4071 (or use it for any other purpose either).
4073 More specifically, each of the following breakpoint types will always
4074 have a zero valued address and we don't want check_duplicates() to mark
4075 breakpoints of any of these types to be a duplicate of an actual
4076 breakpoint at address zero:
4079 bp_hardware_watchpoint
4081 bp_access_watchpoint
4087 breakpoint_address_is_meaningful (struct breakpoint
*bpt
)
4089 enum bptype type
= bpt
->type
;
4091 return (type
!= bp_watchpoint
4092 && type
!= bp_hardware_watchpoint
4093 && type
!= bp_read_watchpoint
4094 && type
!= bp_access_watchpoint
4095 && type
!= bp_catch_exec
4096 && type
!= bp_catch_fork
4097 && type
!= bp_catch_vfork
);
4100 /* Rescan breakpoints at the same address and section as BPT,
4101 marking the first one as "first" and any others as "duplicates".
4102 This is so that the bpt instruction is only inserted once.
4103 If we have a permanent breakpoint at the same place as BPT, make
4104 that one the official one, and the rest as duplicates. */
4107 check_duplicates_for (CORE_ADDR address
, asection
*section
)
4109 struct bp_location
*b
;
4111 struct bp_location
*perm_bp
= 0;
4113 ALL_BP_LOCATIONS (b
)
4114 if (b
->owner
->enable_state
!= bp_disabled
4115 && b
->owner
->enable_state
!= bp_call_disabled
4117 && !b
->shlib_disabled
4118 && b
->address
== address
/* address / overlay match */
4119 && (!overlay_debugging
|| b
->section
== section
)
4120 && breakpoint_address_is_meaningful (b
->owner
))
4122 /* Have we found a permanent breakpoint? */
4123 if (b
->owner
->enable_state
== bp_permanent
)
4130 b
->duplicate
= count
> 1;
4133 /* If we found a permanent breakpoint at this address, go over the
4134 list again and declare all the other breakpoints there to be the
4138 perm_bp
->duplicate
= 0;
4140 /* Permanent breakpoint should always be inserted. */
4141 if (! perm_bp
->inserted
)
4142 internal_error (__FILE__
, __LINE__
,
4143 _("allegedly permanent breakpoint is not "
4144 "actually inserted"));
4146 ALL_BP_LOCATIONS (b
)
4149 if (b
->owner
->enable_state
!= bp_disabled
4150 && b
->owner
->enable_state
!= bp_call_disabled
4151 && b
->enabled
&& !b
->shlib_disabled
4152 && b
->address
== address
/* address / overlay match */
4153 && (!overlay_debugging
|| b
->section
== section
)
4154 && breakpoint_address_is_meaningful (b
->owner
))
4157 internal_error (__FILE__
, __LINE__
,
4158 _("another breakpoint was inserted on top of "
4159 "a permanent breakpoint"));
4168 check_duplicates (struct breakpoint
*bpt
)
4170 struct bp_location
*bl
= bpt
->loc
;
4172 if (! breakpoint_address_is_meaningful (bpt
))
4175 for (; bl
; bl
= bl
->next
)
4176 check_duplicates_for (bl
->address
, bl
->section
);
4180 breakpoint_adjustment_warning (CORE_ADDR from_addr
, CORE_ADDR to_addr
,
4181 int bnum
, int have_bnum
)
4186 strcpy (astr1
, hex_string_custom ((unsigned long) from_addr
, 8));
4187 strcpy (astr2
, hex_string_custom ((unsigned long) to_addr
, 8));
4189 warning (_("Breakpoint %d address previously adjusted from %s to %s."),
4190 bnum
, astr1
, astr2
);
4192 warning (_("Breakpoint address adjusted from %s to %s."), astr1
, astr2
);
4195 /* Adjust a breakpoint's address to account for architectural constraints
4196 on breakpoint placement. Return the adjusted address. Note: Very
4197 few targets require this kind of adjustment. For most targets,
4198 this function is simply the identity function. */
4201 adjust_breakpoint_address (CORE_ADDR bpaddr
, enum bptype bptype
)
4203 if (!gdbarch_adjust_breakpoint_address_p (current_gdbarch
))
4205 /* Very few targets need any kind of breakpoint adjustment. */
4208 else if (bptype
== bp_watchpoint
4209 || bptype
== bp_hardware_watchpoint
4210 || bptype
== bp_read_watchpoint
4211 || bptype
== bp_access_watchpoint
4212 || bptype
== bp_catch_fork
4213 || bptype
== bp_catch_vfork
4214 || bptype
== bp_catch_exec
)
4216 /* Watchpoints and the various bp_catch_* eventpoints should not
4217 have their addresses modified. */
4222 CORE_ADDR adjusted_bpaddr
;
4224 /* Some targets have architectural constraints on the placement
4225 of breakpoint instructions. Obtain the adjusted address. */
4226 adjusted_bpaddr
= gdbarch_adjust_breakpoint_address (current_gdbarch
,
4229 /* An adjusted breakpoint address can significantly alter
4230 a user's expectations. Print a warning if an adjustment
4232 if (adjusted_bpaddr
!= bpaddr
)
4233 breakpoint_adjustment_warning (bpaddr
, adjusted_bpaddr
, 0, 0);
4235 return adjusted_bpaddr
;
4239 /* Allocate a struct bp_location. */
4241 static struct bp_location
*
4242 allocate_bp_location (struct breakpoint
*bpt
, enum bptype bp_type
)
4244 struct bp_location
*loc
, *loc_p
;
4246 loc
= xmalloc (sizeof (struct bp_location
));
4247 memset (loc
, 0, sizeof (*loc
));
4251 loc
->shlib_disabled
= 0;
4260 case bp_longjmp_resume
:
4261 case bp_step_resume
:
4262 case bp_watchpoint_scope
:
4264 case bp_shlib_event
:
4265 case bp_thread_event
:
4266 case bp_overlay_event
:
4268 case bp_catch_unload
:
4269 loc
->loc_type
= bp_loc_software_breakpoint
;
4271 case bp_hardware_breakpoint
:
4272 loc
->loc_type
= bp_loc_hardware_breakpoint
;
4274 case bp_hardware_watchpoint
:
4275 case bp_read_watchpoint
:
4276 case bp_access_watchpoint
:
4277 loc
->loc_type
= bp_loc_hardware_watchpoint
;
4281 case bp_catch_vfork
:
4283 loc
->loc_type
= bp_loc_other
;
4286 internal_error (__FILE__
, __LINE__
, _("unknown breakpoint type"));
4292 static void free_bp_location (struct bp_location
*loc
)
4297 if (loc
->function_name
)
4298 xfree (loc
->function_name
);
4303 /* Helper to set_raw_breakpoint below. Creates a breakpoint
4304 that has type BPTYPE and has no locations as yet. */
4306 static struct breakpoint
*
4307 set_raw_breakpoint_without_location (enum bptype bptype
)
4309 struct breakpoint
*b
, *b1
;
4311 b
= (struct breakpoint
*) xmalloc (sizeof (struct breakpoint
));
4312 memset (b
, 0, sizeof (*b
));
4315 b
->language
= current_language
->la_language
;
4316 b
->input_radix
= input_radix
;
4318 b
->enable_state
= bp_enabled
;
4321 b
->ignore_count
= 0;
4323 b
->frame_id
= null_frame_id
;
4324 b
->dll_pathname
= NULL
;
4325 b
->triggered_dll_pathname
= NULL
;
4326 b
->forked_inferior_pid
= 0;
4327 b
->exec_pathname
= NULL
;
4329 b
->condition_not_parsed
= 0;
4331 /* Add this breakpoint to the end of the chain
4332 so that a list of breakpoints will come out in order
4333 of increasing numbers. */
4335 b1
= breakpoint_chain
;
4337 breakpoint_chain
= b
;
4347 /* Initialize loc->function_name. */
4349 set_breakpoint_location_function (struct bp_location
*loc
)
4351 if (loc
->owner
->type
== bp_breakpoint
4352 || loc
->owner
->type
== bp_hardware_breakpoint
)
4354 find_pc_partial_function (loc
->address
, &(loc
->function_name
),
4356 if (loc
->function_name
)
4357 loc
->function_name
= xstrdup (loc
->function_name
);
4361 /* set_raw_breakpoint is a low level routine for allocating and
4362 partially initializing a breakpoint of type BPTYPE. The newly
4363 created breakpoint's address, section, source file name, and line
4364 number are provided by SAL. The newly created and partially
4365 initialized breakpoint is added to the breakpoint chain and
4366 is also returned as the value of this function.
4368 It is expected that the caller will complete the initialization of
4369 the newly created breakpoint struct as well as output any status
4370 information regarding the creation of a new breakpoint. In
4371 particular, set_raw_breakpoint does NOT set the breakpoint
4372 number! Care should be taken to not allow an error to occur
4373 prior to completing the initialization of the breakpoint. If this
4374 should happen, a bogus breakpoint will be left on the chain. */
4377 set_raw_breakpoint (struct symtab_and_line sal
, enum bptype bptype
)
4379 struct breakpoint
*b
= set_raw_breakpoint_without_location (bptype
);
4380 CORE_ADDR adjusted_address
;
4382 /* Adjust the breakpoint's address prior to allocating a location.
4383 Once we call allocate_bp_location(), that mostly uninitialized
4384 location will be placed on the location chain. Adjustment of the
4385 breakpoint may cause target_read_memory() to be called and we do
4386 not want its scan of the location chain to find a breakpoint and
4387 location that's only been partially initialized. */
4388 adjusted_address
= adjust_breakpoint_address (sal
.pc
, bptype
);
4390 b
->loc
= allocate_bp_location (b
, bptype
);
4391 b
->loc
->requested_address
= sal
.pc
;
4392 b
->loc
->address
= adjusted_address
;
4394 if (sal
.symtab
== NULL
)
4395 b
->source_file
= NULL
;
4397 b
->source_file
= savestring (sal
.symtab
->filename
,
4398 strlen (sal
.symtab
->filename
));
4399 b
->loc
->section
= sal
.section
;
4400 b
->line_number
= sal
.line
;
4402 set_breakpoint_location_function (b
->loc
);
4404 breakpoints_changed ();
4410 /* Note that the breakpoint object B describes a permanent breakpoint
4411 instruction, hard-wired into the inferior's code. */
4413 make_breakpoint_permanent (struct breakpoint
*b
)
4415 struct bp_location
*bl
;
4416 b
->enable_state
= bp_permanent
;
4418 /* By definition, permanent breakpoints are already present in the code.
4419 Mark all locations as inserted. For now, make_breakpoint_permanent
4420 is called in just one place, so it's hard to say if it's reasonable
4421 to have permanent breakpoint with multiple locations or not,
4422 but it's easy to implmement. */
4423 for (bl
= b
->loc
; bl
; bl
= bl
->next
)
4427 static struct breakpoint
*
4428 create_internal_breakpoint (CORE_ADDR address
, enum bptype type
)
4430 static int internal_breakpoint_number
= -1;
4431 struct symtab_and_line sal
;
4432 struct breakpoint
*b
;
4434 init_sal (&sal
); /* initialize to zeroes */
4437 sal
.section
= find_pc_overlay (sal
.pc
);
4439 b
= set_raw_breakpoint (sal
, type
);
4440 b
->number
= internal_breakpoint_number
--;
4441 b
->disposition
= disp_donttouch
;
4448 create_longjmp_breakpoint (char *func_name
)
4450 struct breakpoint
*b
;
4451 struct minimal_symbol
*m
;
4453 if ((m
= lookup_minimal_symbol_text (func_name
, NULL
)) == NULL
)
4455 set_momentary_breakpoint_at_pc (SYMBOL_VALUE_ADDRESS (m
), bp_longjmp
);
4456 update_global_location_list ();
4459 /* Call this routine when stepping and nexting to enable a breakpoint
4460 if we do a longjmp(). When we hit that breakpoint, call
4461 set_longjmp_resume_breakpoint() to figure out where we are going. */
4464 set_longjmp_breakpoint (void)
4466 struct breakpoint
*b
;
4468 if (gdbarch_get_longjmp_target_p (current_gdbarch
))
4470 create_longjmp_breakpoint ("longjmp");
4471 create_longjmp_breakpoint ("_longjmp");
4472 create_longjmp_breakpoint ("siglongjmp");
4473 create_longjmp_breakpoint ("_siglongjmp");
4477 /* Delete all longjmp breakpoints from THREAD. */
4479 delete_longjmp_breakpoint (int thread
)
4481 struct breakpoint
*b
, *temp
;
4483 ALL_BREAKPOINTS_SAFE (b
, temp
)
4484 if (b
->type
== bp_longjmp
)
4486 if (b
->thread
== thread
)
4487 delete_breakpoint (b
);
4492 create_overlay_event_breakpoint (char *func_name
)
4494 struct breakpoint
*b
;
4495 struct minimal_symbol
*m
;
4497 if ((m
= lookup_minimal_symbol_text (func_name
, NULL
)) == NULL
)
4500 b
= create_internal_breakpoint (SYMBOL_VALUE_ADDRESS (m
),
4502 b
->addr_string
= xstrdup (func_name
);
4504 if (overlay_debugging
== ovly_auto
)
4506 b
->enable_state
= bp_enabled
;
4507 overlay_events_enabled
= 1;
4511 b
->enable_state
= bp_disabled
;
4512 overlay_events_enabled
= 0;
4514 update_global_location_list ();
4518 enable_overlay_breakpoints (void)
4520 struct breakpoint
*b
;
4523 if (b
->type
== bp_overlay_event
)
4525 b
->enable_state
= bp_enabled
;
4526 update_global_location_list ();
4527 overlay_events_enabled
= 1;
4532 disable_overlay_breakpoints (void)
4534 struct breakpoint
*b
;
4537 if (b
->type
== bp_overlay_event
)
4539 b
->enable_state
= bp_disabled
;
4540 update_global_location_list ();
4541 overlay_events_enabled
= 0;
4546 create_thread_event_breakpoint (CORE_ADDR address
)
4548 struct breakpoint
*b
;
4550 b
= create_internal_breakpoint (address
, bp_thread_event
);
4552 b
->enable_state
= bp_enabled
;
4553 /* addr_string has to be used or breakpoint_re_set will delete me. */
4554 b
->addr_string
= xstrprintf ("*0x%s", paddr (b
->loc
->address
));
4556 update_global_location_list_nothrow ();
4562 remove_thread_event_breakpoints (void)
4564 struct breakpoint
*b
, *temp
;
4566 ALL_BREAKPOINTS_SAFE (b
, temp
)
4567 if (b
->type
== bp_thread_event
)
4568 delete_breakpoint (b
);
4571 struct captured_parse_breakpoint_args
4574 struct symtabs_and_lines
*sals_p
;
4575 char ***addr_string_p
;
4579 struct lang_and_radix
4587 remove_solib_event_breakpoints (void)
4589 struct breakpoint
*b
, *temp
;
4591 ALL_BREAKPOINTS_SAFE (b
, temp
)
4592 if (b
->type
== bp_shlib_event
)
4593 delete_breakpoint (b
);
4597 create_solib_event_breakpoint (CORE_ADDR address
)
4599 struct breakpoint
*b
;
4601 b
= create_internal_breakpoint (address
, bp_shlib_event
);
4602 update_global_location_list_nothrow ();
4606 /* Disable any breakpoints that are on code in shared libraries. Only
4607 apply to enabled breakpoints, disabled ones can just stay disabled. */
4610 disable_breakpoints_in_shlibs (void)
4612 struct bp_location
*loc
;
4613 int disabled_shlib_breaks
= 0;
4615 ALL_BP_LOCATIONS (loc
)
4617 struct breakpoint
*b
= loc
->owner
;
4618 /* We apply the check to all breakpoints, including disabled
4619 for those with loc->duplicate set. This is so that when breakpoint
4620 becomes enabled, or the duplicate is removed, gdb will try to insert
4621 all breakpoints. If we don't set shlib_disabled here, we'll try
4622 to insert those breakpoints and fail. */
4623 if (((b
->type
== bp_breakpoint
) || (b
->type
== bp_hardware_breakpoint
))
4624 && !loc
->shlib_disabled
4626 && PC_SOLIB (loc
->address
)
4628 && solib_address (loc
->address
)
4632 loc
->shlib_disabled
= 1;
4637 /* Disable any breakpoints that are in in an unloaded shared library. Only
4638 apply to enabled breakpoints, disabled ones can just stay disabled. */
4641 disable_breakpoints_in_unloaded_shlib (struct so_list
*solib
)
4643 struct bp_location
*loc
;
4644 int disabled_shlib_breaks
= 0;
4646 ALL_BP_LOCATIONS (loc
)
4648 struct breakpoint
*b
= loc
->owner
;
4649 if ((loc
->loc_type
== bp_loc_hardware_breakpoint
4650 || loc
->loc_type
== bp_loc_software_breakpoint
)
4651 && !loc
->shlib_disabled
)
4654 char *so_name
= PC_SOLIB (loc
->address
);
4656 char *so_name
= solib_address (loc
->address
);
4658 if (so_name
&& !strcmp (so_name
, solib
->so_name
))
4660 loc
->shlib_disabled
= 1;
4661 /* At this point, we cannot rely on remove_breakpoint
4662 succeeding so we must mark the breakpoint as not inserted
4663 to prevent future errors occurring in remove_breakpoints. */
4665 if (!disabled_shlib_breaks
)
4667 target_terminal_ours_for_output ();
4668 warning (_("Temporarily disabling breakpoints for unloaded shared library \"%s\""),
4671 disabled_shlib_breaks
= 1;
4678 create_fork_vfork_event_catchpoint (int tempflag
, char *cond_string
,
4679 enum bptype bp_kind
)
4681 struct symtab_and_line sal
;
4682 struct breakpoint
*b
;
4683 int thread
= -1; /* All threads. */
4690 b
= set_raw_breakpoint (sal
, bp_kind
);
4691 set_breakpoint_count (breakpoint_count
+ 1);
4692 b
->number
= breakpoint_count
;
4693 b
->cond_string
= (cond_string
== NULL
) ?
4694 NULL
: savestring (cond_string
, strlen (cond_string
));
4696 b
->addr_string
= NULL
;
4697 b
->enable_state
= bp_enabled
;
4698 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
4699 b
->forked_inferior_pid
= 0;
4700 update_global_location_list ();
4707 create_fork_event_catchpoint (int tempflag
, char *cond_string
)
4709 create_fork_vfork_event_catchpoint (tempflag
, cond_string
, bp_catch_fork
);
4713 create_vfork_event_catchpoint (int tempflag
, char *cond_string
)
4715 create_fork_vfork_event_catchpoint (tempflag
, cond_string
, bp_catch_vfork
);
4719 create_exec_event_catchpoint (int tempflag
, char *cond_string
)
4721 struct symtab_and_line sal
;
4722 struct breakpoint
*b
;
4723 int thread
= -1; /* All threads. */
4730 b
= set_raw_breakpoint (sal
, bp_catch_exec
);
4731 set_breakpoint_count (breakpoint_count
+ 1);
4732 b
->number
= breakpoint_count
;
4733 b
->cond_string
= (cond_string
== NULL
) ?
4734 NULL
: savestring (cond_string
, strlen (cond_string
));
4736 b
->addr_string
= NULL
;
4737 b
->enable_state
= bp_enabled
;
4738 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
4739 update_global_location_list ();
4745 hw_breakpoint_used_count (void)
4747 struct breakpoint
*b
;
4752 if (b
->type
== bp_hardware_breakpoint
&& b
->enable_state
== bp_enabled
)
4760 hw_watchpoint_used_count (enum bptype type
, int *other_type_used
)
4762 struct breakpoint
*b
;
4765 *other_type_used
= 0;
4768 if (breakpoint_enabled (b
))
4770 if (b
->type
== type
)
4772 else if ((b
->type
== bp_hardware_watchpoint
||
4773 b
->type
== bp_read_watchpoint
||
4774 b
->type
== bp_access_watchpoint
))
4775 *other_type_used
= 1;
4782 disable_watchpoints_before_interactive_call_start (void)
4784 struct breakpoint
*b
;
4788 if (((b
->type
== bp_watchpoint
)
4789 || (b
->type
== bp_hardware_watchpoint
)
4790 || (b
->type
== bp_read_watchpoint
)
4791 || (b
->type
== bp_access_watchpoint
))
4792 && breakpoint_enabled (b
))
4794 b
->enable_state
= bp_call_disabled
;
4795 update_global_location_list ();
4801 enable_watchpoints_after_interactive_call_stop (void)
4803 struct breakpoint
*b
;
4807 if (((b
->type
== bp_watchpoint
)
4808 || (b
->type
== bp_hardware_watchpoint
)
4809 || (b
->type
== bp_read_watchpoint
)
4810 || (b
->type
== bp_access_watchpoint
))
4811 && (b
->enable_state
== bp_call_disabled
))
4813 b
->enable_state
= bp_enabled
;
4814 update_global_location_list ();
4820 /* Set a breakpoint that will evaporate an end of command
4821 at address specified by SAL.
4822 Restrict it to frame FRAME if FRAME is nonzero. */
4825 set_momentary_breakpoint (struct symtab_and_line sal
, struct frame_id frame_id
,
4828 struct breakpoint
*b
;
4829 b
= set_raw_breakpoint (sal
, type
);
4830 b
->enable_state
= bp_enabled
;
4831 b
->disposition
= disp_donttouch
;
4832 b
->frame_id
= frame_id
;
4834 /* If we're debugging a multi-threaded program, then we
4835 want momentary breakpoints to be active in only a
4836 single thread of control. */
4837 if (in_thread_list (inferior_ptid
))
4838 b
->thread
= pid_to_thread_id (inferior_ptid
);
4840 update_global_location_list_nothrow ();
4846 set_momentary_breakpoint_at_pc (CORE_ADDR pc
, enum bptype type
)
4848 struct symtab_and_line sal
;
4850 sal
= find_pc_line (pc
, 0);
4852 sal
.section
= find_pc_overlay (pc
);
4853 sal
.explicit_pc
= 1;
4855 return set_momentary_breakpoint (sal
, null_frame_id
, type
);
4859 /* Tell the user we have just set a breakpoint B. */
4862 mention (struct breakpoint
*b
)
4865 struct cleanup
*old_chain
, *ui_out_chain
;
4866 struct ui_stream
*stb
;
4868 stb
= ui_out_stream_new (uiout
);
4869 old_chain
= make_cleanup_ui_out_stream_delete (stb
);
4871 /* FIXME: This is misplaced; mention() is called by things (like
4872 hitting a watchpoint) other than breakpoint creation. It should
4873 be possible to clean this up and at the same time replace the
4874 random calls to breakpoint_changed with this hook, as has already
4875 been done for deprecated_delete_breakpoint_hook and so on. */
4876 if (deprecated_create_breakpoint_hook
)
4877 deprecated_create_breakpoint_hook (b
);
4878 breakpoint_create_event (b
->number
);
4880 if (b
->ops
!= NULL
&& b
->ops
->print_mention
!= NULL
)
4881 b
->ops
->print_mention (b
);
4886 printf_filtered (_("(apparently deleted?) Eventpoint %d: "), b
->number
);
4889 ui_out_text (uiout
, "Watchpoint ");
4890 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "wpt");
4891 ui_out_field_int (uiout
, "number", b
->number
);
4892 ui_out_text (uiout
, ": ");
4893 print_expression (b
->exp
, stb
->stream
);
4894 ui_out_field_stream (uiout
, "exp", stb
);
4895 do_cleanups (ui_out_chain
);
4897 case bp_hardware_watchpoint
:
4898 ui_out_text (uiout
, "Hardware watchpoint ");
4899 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "wpt");
4900 ui_out_field_int (uiout
, "number", b
->number
);
4901 ui_out_text (uiout
, ": ");
4902 print_expression (b
->exp
, stb
->stream
);
4903 ui_out_field_stream (uiout
, "exp", stb
);
4904 do_cleanups (ui_out_chain
);
4906 case bp_read_watchpoint
:
4907 ui_out_text (uiout
, "Hardware read watchpoint ");
4908 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "hw-rwpt");
4909 ui_out_field_int (uiout
, "number", b
->number
);
4910 ui_out_text (uiout
, ": ");
4911 print_expression (b
->exp
, stb
->stream
);
4912 ui_out_field_stream (uiout
, "exp", stb
);
4913 do_cleanups (ui_out_chain
);
4915 case bp_access_watchpoint
:
4916 ui_out_text (uiout
, "Hardware access (read/write) watchpoint ");
4917 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "hw-awpt");
4918 ui_out_field_int (uiout
, "number", b
->number
);
4919 ui_out_text (uiout
, ": ");
4920 print_expression (b
->exp
, stb
->stream
);
4921 ui_out_field_stream (uiout
, "exp", stb
);
4922 do_cleanups (ui_out_chain
);
4925 if (ui_out_is_mi_like_p (uiout
))
4930 if (b
->disposition
== disp_del
)
4931 printf_filtered (_("Temporary breakpoint"));
4933 printf_filtered (_("Breakpoint"));
4934 printf_filtered (_(" %d"), b
->number
);
4937 case bp_hardware_breakpoint
:
4938 if (ui_out_is_mi_like_p (uiout
))
4943 printf_filtered (_("Hardware assisted breakpoint %d"), b
->number
);
4947 case bp_catch_unload
:
4948 printf_filtered (_("Catchpoint %d (%s %s)"),
4950 (b
->type
== bp_catch_load
) ? "load" : "unload",
4951 (b
->dll_pathname
!= NULL
) ?
4952 b
->dll_pathname
: "<any library>");
4955 case bp_catch_vfork
:
4956 printf_filtered (_("Catchpoint %d (%s)"),
4958 (b
->type
== bp_catch_fork
) ? "fork" : "vfork");
4961 printf_filtered (_("Catchpoint %d (exec)"),
4968 case bp_longjmp_resume
:
4969 case bp_step_resume
:
4971 case bp_watchpoint_scope
:
4972 case bp_shlib_event
:
4973 case bp_thread_event
:
4974 case bp_overlay_event
:
4980 /* i18n: cagney/2005-02-11: Below needs to be merged into a
4984 printf_filtered (_(" (%s) pending."), b
->addr_string
);
4988 if (addressprint
|| b
->source_file
== NULL
)
4990 printf_filtered (" at ");
4991 fputs_filtered (paddress (b
->loc
->address
), gdb_stdout
);
4994 printf_filtered (": file %s, line %d.",
4995 b
->source_file
, b
->line_number
);
4999 struct bp_location
*loc
= b
->loc
;
5001 for (; loc
; loc
= loc
->next
)
5003 printf_filtered (" (%d locations)", n
);
5008 do_cleanups (old_chain
);
5009 if (ui_out_is_mi_like_p (uiout
))
5011 printf_filtered ("\n");
5015 static struct bp_location
*
5016 add_location_to_breakpoint (struct breakpoint
*b
, enum bptype bptype
,
5017 const struct symtab_and_line
*sal
)
5019 struct bp_location
*loc
, **tmp
;
5021 loc
= allocate_bp_location (b
, bptype
);
5022 for (tmp
= &(b
->loc
); *tmp
!= NULL
; tmp
= &((*tmp
)->next
))
5025 loc
->requested_address
= sal
->pc
;
5026 loc
->address
= adjust_breakpoint_address (loc
->requested_address
,
5028 loc
->section
= sal
->section
;
5030 set_breakpoint_location_function (loc
);
5034 /* Create a breakpoint with SAL as location. Use ADDR_STRING
5035 as textual description of the location, and COND_STRING
5036 as condition expression. */
5039 create_breakpoint (struct symtabs_and_lines sals
, char *addr_string
,
5041 enum bptype type
, enum bpdisp disposition
,
5042 int thread
, int ignore_count
,
5043 struct breakpoint_ops
*ops
, int from_tty
)
5045 struct breakpoint
*b
= NULL
;
5048 if (type
== bp_hardware_breakpoint
)
5050 int i
= hw_breakpoint_used_count ();
5051 int target_resources_ok
=
5052 TARGET_CAN_USE_HARDWARE_WATCHPOINT (bp_hardware_breakpoint
,
5054 if (target_resources_ok
== 0)
5055 error (_("No hardware breakpoint support in the target."));
5056 else if (target_resources_ok
< 0)
5057 error (_("Hardware breakpoints used exceeds limit."));
5060 for (i
= 0; i
< sals
.nelts
; ++i
)
5062 struct symtab_and_line sal
= sals
.sals
[i
];
5063 struct bp_location
*loc
;
5066 describe_other_breakpoints (sal
.pc
, sal
.section
, thread
);
5070 b
= set_raw_breakpoint (sal
, type
);
5071 set_breakpoint_count (breakpoint_count
+ 1);
5072 b
->number
= breakpoint_count
;
5075 b
->cond_string
= cond_string
;
5076 b
->ignore_count
= ignore_count
;
5077 b
->enable_state
= bp_enabled
;
5078 b
->disposition
= disposition
;
5084 loc
= add_location_to_breakpoint (b
, type
, &sal
);
5089 char *arg
= b
->cond_string
;
5090 loc
->cond
= parse_exp_1 (&arg
, block_for_pc (loc
->address
), 0);
5092 error (_("Garbage %s follows condition"), arg
);
5097 b
->addr_string
= addr_string
;
5099 /* addr_string has to be used or breakpoint_re_set will delete
5101 b
->addr_string
= xstrprintf ("*0x%s", paddr (b
->loc
->address
));
5107 /* Remove element at INDEX_TO_REMOVE from SAL, shifting other
5108 elements to fill the void space. */
5109 static void remove_sal (struct symtabs_and_lines
*sal
, int index_to_remove
)
5111 int i
= index_to_remove
+1;
5112 int last_index
= sal
->nelts
-1;
5114 for (;i
<= last_index
; ++i
)
5115 sal
->sals
[i
-1] = sal
->sals
[i
];
5120 /* If appropriate, obtains all sals that correspond
5121 to the same file and line as SAL. This is done
5122 only if SAL does not have explicit PC and has
5123 line and file information. If we got just a single
5124 expanded sal, return the original.
5126 Otherwise, if SAL.explicit_line is not set, filter out
5127 all sals for which the name of enclosing function
5128 is different from SAL. This makes sure that if we have
5129 breakpoint originally set in template instantiation, say
5130 foo<int>(), we won't expand SAL to locations at the same
5131 line in all existing instantiations of 'foo'.
5134 struct symtabs_and_lines
5135 expand_line_sal_maybe (struct symtab_and_line sal
)
5137 struct symtabs_and_lines expanded
;
5138 CORE_ADDR original_pc
= sal
.pc
;
5139 char *original_function
= NULL
;
5143 /* If we have explicit pc, don't expand.
5144 If we have no line number, we can't expand. */
5145 if (sal
.explicit_pc
|| sal
.line
== 0 || sal
.symtab
== NULL
)
5148 expanded
.sals
= xmalloc (sizeof (struct symtab_and_line
));
5149 expanded
.sals
[0] = sal
;
5154 find_pc_partial_function (original_pc
, &original_function
, NULL
, NULL
);
5156 expanded
= expand_line_sal (sal
);
5157 if (expanded
.nelts
== 1)
5159 /* We had one sal, we got one sal. Without futher
5160 processing, just return the original sal. */
5161 xfree (expanded
.sals
);
5163 expanded
.sals
= xmalloc (sizeof (struct symtab_and_line
));
5164 sal
.pc
= original_pc
;
5165 expanded
.sals
[0] = sal
;
5169 if (!sal
.explicit_line
)
5171 CORE_ADDR func_addr
, func_end
;
5172 for (i
= 0; i
< expanded
.nelts
; ++i
)
5174 CORE_ADDR pc
= expanded
.sals
[i
].pc
;
5175 char *this_function
;
5176 if (find_pc_partial_function (pc
, &this_function
,
5177 &func_addr
, &func_end
))
5179 if (this_function
&&
5180 strcmp (this_function
, original_function
) != 0)
5182 remove_sal (&expanded
, i
);
5185 else if (func_addr
== pc
)
5187 /* We're at beginning of a function, and should
5189 struct symbol
*sym
= find_pc_function (pc
);
5191 expanded
.sals
[i
] = find_function_start_sal (sym
, 1);
5194 = gdbarch_skip_prologue (current_gdbarch
, pc
);
5201 if (expanded
.nelts
<= 1)
5203 /* This is un ugly workaround. If we get zero
5204 expanded sals then something is really wrong.
5205 Fix that by returnign the original sal. */
5206 xfree (expanded
.sals
);
5208 expanded
.sals
= xmalloc (sizeof (struct symtab_and_line
));
5209 sal
.pc
= original_pc
;
5210 expanded
.sals
[0] = sal
;
5217 for (i
= 0; i
< expanded
.nelts
; ++i
)
5218 if (expanded
.sals
[i
].pc
== original_pc
)
5229 /* Add SALS.nelts breakpoints to the breakpoint table. For each
5230 SALS.sal[i] breakpoint, include the corresponding ADDR_STRING[i]
5231 value. COND_STRING, if not NULL, specified the condition to be
5232 used for all breakpoints. Essentially the only case where
5233 SALS.nelts is not 1 is when we set a breakpoint on an overloaded
5234 function. In that case, it's still not possible to specify
5235 separate conditions for different overloaded functions, so
5236 we take just a single condition string.
5238 NOTE: If the function succeeds, the caller is expected to cleanup
5239 the arrays ADDR_STRING, COND_STRING, and SALS (but not the
5240 array contents). If the function fails (error() is called), the
5241 caller is expected to cleanups both the ADDR_STRING, COND_STRING,
5242 COND and SALS arrays and each of those arrays contents. */
5245 create_breakpoints (struct symtabs_and_lines sals
, char **addr_string
,
5247 enum bptype type
, enum bpdisp disposition
,
5248 int thread
, int ignore_count
,
5249 struct breakpoint_ops
*ops
, int from_tty
)
5252 for (i
= 0; i
< sals
.nelts
; ++i
)
5254 struct symtabs_and_lines expanded
=
5255 expand_line_sal_maybe (sals
.sals
[i
]);
5257 create_breakpoint (expanded
, addr_string
[i
],
5258 cond_string
, type
, disposition
,
5259 thread
, ignore_count
, ops
, from_tty
);
5262 update_global_location_list ();
5265 /* Parse ARG which is assumed to be a SAL specification possibly
5266 followed by conditionals. On return, SALS contains an array of SAL
5267 addresses found. ADDR_STRING contains a vector of (canonical)
5268 address strings. ARG points to the end of the SAL. */
5271 parse_breakpoint_sals (char **address
,
5272 struct symtabs_and_lines
*sals
,
5273 char ***addr_string
,
5276 char *addr_start
= *address
;
5277 *addr_string
= NULL
;
5278 /* If no arg given, or if first arg is 'if ', use the default
5280 if ((*address
) == NULL
5281 || (strncmp ((*address
), "if", 2) == 0 && isspace ((*address
)[2])))
5283 if (default_breakpoint_valid
)
5285 struct symtab_and_line sal
;
5286 init_sal (&sal
); /* initialize to zeroes */
5287 sals
->sals
= (struct symtab_and_line
*)
5288 xmalloc (sizeof (struct symtab_and_line
));
5289 sal
.pc
= default_breakpoint_address
;
5290 sal
.line
= default_breakpoint_line
;
5291 sal
.symtab
= default_breakpoint_symtab
;
5292 sal
.section
= find_pc_overlay (sal
.pc
);
5293 sals
->sals
[0] = sal
;
5297 error (_("No default breakpoint address now."));
5301 /* Force almost all breakpoints to be in terms of the
5302 current_source_symtab (which is decode_line_1's default). This
5303 should produce the results we want almost all of the time while
5304 leaving default_breakpoint_* alone.
5305 ObjC: However, don't match an Objective-C method name which
5306 may have a '+' or '-' succeeded by a '[' */
5308 struct symtab_and_line cursal
= get_current_source_symtab_and_line ();
5310 if (default_breakpoint_valid
5312 || ((strchr ("+-", (*address
)[0]) != NULL
)
5313 && ((*address
)[1] != '['))))
5314 *sals
= decode_line_1 (address
, 1, default_breakpoint_symtab
,
5315 default_breakpoint_line
, addr_string
,
5318 *sals
= decode_line_1 (address
, 1, (struct symtab
*) NULL
, 0,
5319 addr_string
, not_found_ptr
);
5321 /* For any SAL that didn't have a canonical string, fill one in. */
5322 if (sals
->nelts
> 0 && *addr_string
== NULL
)
5323 *addr_string
= xcalloc (sals
->nelts
, sizeof (char **));
5324 if (addr_start
!= (*address
))
5327 for (i
= 0; i
< sals
->nelts
; i
++)
5329 /* Add the string if not present. */
5330 if ((*addr_string
)[i
] == NULL
)
5331 (*addr_string
)[i
] = savestring (addr_start
, (*address
) - addr_start
);
5337 /* Convert each SAL into a real PC. Verify that the PC can be
5338 inserted as a breakpoint. If it can't throw an error. */
5341 breakpoint_sals_to_pc (struct symtabs_and_lines
*sals
,
5345 for (i
= 0; i
< sals
->nelts
; i
++)
5346 resolve_sal_pc (&sals
->sals
[i
]);
5350 do_captured_parse_breakpoint (struct ui_out
*ui
, void *data
)
5352 struct captured_parse_breakpoint_args
*args
= data
;
5354 parse_breakpoint_sals (args
->arg_p
, args
->sals_p
, args
->addr_string_p
,
5355 args
->not_found_ptr
);
5358 /* Given TOK, a string specification of condition and thread, as
5359 accepted by the 'break' command, extract the condition
5360 string and thread number and set *COND_STRING and *THREAD.
5361 PC identifies the context at which the condition should be parsed.
5362 If no condition is found, *COND_STRING is set to NULL.
5363 If no thread is found, *THREAD is set to -1. */
5365 find_condition_and_thread (char *tok
, CORE_ADDR pc
,
5366 char **cond_string
, int *thread
)
5368 *cond_string
= NULL
;
5374 char *cond_start
= NULL
;
5375 char *cond_end
= NULL
;
5376 while (*tok
== ' ' || *tok
== '\t')
5381 while (*end_tok
!= ' ' && *end_tok
!= '\t' && *end_tok
!= '\000')
5384 toklen
= end_tok
- tok
;
5386 if (toklen
>= 1 && strncmp (tok
, "if", toklen
) == 0)
5388 tok
= cond_start
= end_tok
+ 1;
5389 parse_exp_1 (&tok
, block_for_pc (pc
), 0);
5391 *cond_string
= savestring (cond_start
,
5392 cond_end
- cond_start
);
5394 else if (toklen
>= 1 && strncmp (tok
, "thread", toklen
) == 0)
5400 *thread
= strtol (tok
, &tok
, 0);
5402 error (_("Junk after thread keyword."));
5403 if (!valid_thread_id (*thread
))
5404 error (_("Unknown thread %d."), *thread
);
5407 error (_("Junk at end of arguments."));
5411 /* Set a breakpoint. This function is shared between
5412 CLI and MI functions for setting a breakpoint.
5413 This function has two major modes of operations,
5414 selected by the PARSE_CONDITION_AND_THREAD parameter.
5415 If non-zero, the function will parse arg, extracting
5416 breakpoint location, address and thread. Otherwise,
5417 ARG is just the location of breakpoint, with condition
5418 and thread specified by the COND_STRING and THREAD
5422 break_command_really (char *arg
, char *cond_string
, int thread
,
5423 int parse_condition_and_thread
,
5424 int tempflag
, int hardwareflag
,
5426 enum auto_boolean pending_break_support
,
5427 struct breakpoint_ops
*ops
,
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
, ops
, 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;
5583 update_global_location_list ();
5588 warning (_("Multiple breakpoints were set.\n"
5589 "Use the \"delete\" command to delete unwanted breakpoints."));
5590 /* That's it. Discard the cleanups for data inserted into the
5592 discard_cleanups (breakpoint_chain
);
5593 /* But cleanup everything else. */
5594 do_cleanups (old_chain
);
5597 /* Set a breakpoint.
5598 ARG is a string describing breakpoint address,
5599 condition, and thread.
5600 FLAG specifies if a breakpoint is hardware on,
5601 and if breakpoint is temporary, using BP_HARDWARE_FLAG
5605 break_command_1 (char *arg
, int flag
, int from_tty
)
5607 int hardwareflag
= flag
& BP_HARDWAREFLAG
;
5608 int tempflag
= flag
& BP_TEMPFLAG
;
5610 break_command_really (arg
,
5611 NULL
, 0, 1 /* parse arg */,
5612 tempflag
, hardwareflag
,
5613 0 /* Ignore count */,
5614 pending_break_support
,
5615 NULL
/* breakpoint_ops */,
5621 set_breakpoint (char *address
, char *condition
,
5622 int hardwareflag
, int tempflag
,
5623 int thread
, int ignore_count
,
5626 break_command_really (address
, condition
, thread
,
5627 0 /* condition and thread are valid. */,
5628 tempflag
, hardwareflag
,
5631 ? AUTO_BOOLEAN_TRUE
: AUTO_BOOLEAN_FALSE
,
5635 /* Adjust SAL to the first instruction past the function prologue.
5636 The end of the prologue is determined using the line table from
5637 the debugging information.
5639 If SAL is already past the prologue, then do nothing. */
5642 skip_prologue_sal (struct symtab_and_line
*sal
)
5644 struct symbol
*sym
= find_pc_function (sal
->pc
);
5645 struct symtab_and_line start_sal
;
5650 start_sal
= find_function_start_sal (sym
, 1);
5651 if (sal
->pc
< start_sal
.pc
)
5655 /* Helper function for break_command_1 and disassemble_command. */
5658 resolve_sal_pc (struct symtab_and_line
*sal
)
5662 if (sal
->pc
== 0 && sal
->symtab
!= NULL
)
5664 if (!find_line_pc (sal
->symtab
, sal
->line
, &pc
))
5665 error (_("No line %d in file \"%s\"."),
5666 sal
->line
, sal
->symtab
->filename
);
5669 /* If this SAL corresponds to a breakpoint inserted using
5670 a line number, then skip the function prologue if necessary. */
5671 if (sal
->explicit_line
)
5672 skip_prologue_sal (sal
);
5675 if (sal
->section
== 0 && sal
->symtab
!= NULL
)
5677 struct blockvector
*bv
;
5681 bv
= blockvector_for_pc_sect (sal
->pc
, 0, &b
, sal
->symtab
);
5684 sym
= block_function (b
);
5687 fixup_symbol_section (sym
, sal
->symtab
->objfile
);
5688 sal
->section
= SYMBOL_BFD_SECTION (sym
);
5692 /* It really is worthwhile to have the section, so we'll just
5693 have to look harder. This case can be executed if we have
5694 line numbers but no functions (as can happen in assembly
5697 struct minimal_symbol
*msym
;
5699 msym
= lookup_minimal_symbol_by_pc (sal
->pc
);
5701 sal
->section
= SYMBOL_BFD_SECTION (msym
);
5708 break_command (char *arg
, int from_tty
)
5710 break_command_1 (arg
, 0, from_tty
);
5714 tbreak_command (char *arg
, int from_tty
)
5716 break_command_1 (arg
, BP_TEMPFLAG
, from_tty
);
5720 hbreak_command (char *arg
, int from_tty
)
5722 break_command_1 (arg
, BP_HARDWAREFLAG
, from_tty
);
5726 thbreak_command (char *arg
, int from_tty
)
5728 break_command_1 (arg
, (BP_TEMPFLAG
| BP_HARDWAREFLAG
), from_tty
);
5732 stop_command (char *arg
, int from_tty
)
5734 printf_filtered (_("Specify the type of breakpoint to set.\n\
5735 Usage: stop in <function | address>\n\
5736 stop at <line>\n"));
5740 stopin_command (char *arg
, int from_tty
)
5744 if (arg
== (char *) NULL
)
5746 else if (*arg
!= '*')
5751 /* look for a ':'. If this is a line number specification, then
5752 say it is bad, otherwise, it should be an address or
5753 function/method name */
5754 while (*argptr
&& !hasColon
)
5756 hasColon
= (*argptr
== ':');
5761 badInput
= (*argptr
!= ':'); /* Not a class::method */
5763 badInput
= isdigit (*arg
); /* a simple line number */
5767 printf_filtered (_("Usage: stop in <function | address>\n"));
5769 break_command_1 (arg
, 0, from_tty
);
5773 stopat_command (char *arg
, int from_tty
)
5777 if (arg
== (char *) NULL
|| *arg
== '*') /* no line number */
5784 /* look for a ':'. If there is a '::' then get out, otherwise
5785 it is probably a line number. */
5786 while (*argptr
&& !hasColon
)
5788 hasColon
= (*argptr
== ':');
5793 badInput
= (*argptr
== ':'); /* we have class::method */
5795 badInput
= !isdigit (*arg
); /* not a line number */
5799 printf_filtered (_("Usage: stop at <line>\n"));
5801 break_command_1 (arg
, 0, from_tty
);
5804 /* accessflag: hw_write: watch write,
5805 hw_read: watch read,
5806 hw_access: watch access (read or write) */
5808 watch_command_1 (char *arg
, int accessflag
, int from_tty
)
5810 struct breakpoint
*b
, *scope_breakpoint
= NULL
;
5811 struct symtab_and_line sal
;
5812 struct expression
*exp
;
5813 struct block
*exp_valid_block
;
5814 struct value
*val
, *mark
;
5815 struct frame_info
*frame
;
5816 struct frame_info
*prev_frame
= NULL
;
5817 char *exp_start
= NULL
;
5818 char *exp_end
= NULL
;
5819 char *tok
, *id_tok_start
, *end_tok
;
5821 char *cond_start
= NULL
;
5822 char *cond_end
= NULL
;
5823 struct expression
*cond
= NULL
;
5824 int i
, other_type_used
, target_resources_ok
= 0;
5825 enum bptype bp_type
;
5829 init_sal (&sal
); /* initialize to zeroes */
5831 /* Make sure that we actually have parameters to parse. */
5832 if (arg
!= NULL
&& arg
[0] != '\0')
5834 toklen
= strlen (arg
); /* Size of argument list. */
5836 /* Points tok to the end of the argument list. */
5837 tok
= arg
+ toklen
- 1;
5839 /* Go backwards in the parameters list. Skip the last parameter.
5840 If we're expecting a 'thread <thread_num>' parameter, this should
5841 be the thread identifier. */
5842 while (tok
> arg
&& (*tok
== ' ' || *tok
== '\t'))
5844 while (tok
> arg
&& (*tok
!= ' ' && *tok
!= '\t'))
5847 /* Points end_tok to the beginning of the last token. */
5848 id_tok_start
= tok
+ 1;
5850 /* Go backwards in the parameters list. Skip one more parameter.
5851 If we're expecting a 'thread <thread_num>' parameter, we should
5852 reach a "thread" token. */
5853 while (tok
> arg
&& (*tok
== ' ' || *tok
== '\t'))
5858 while (tok
> arg
&& (*tok
!= ' ' && *tok
!= '\t'))
5861 /* Move the pointer forward to skip the whitespace and
5862 calculate the length of the token. */
5864 toklen
= end_tok
- tok
;
5866 if (toklen
>= 1 && strncmp (tok
, "thread", toklen
) == 0)
5868 /* At this point we've found a "thread" token, which means
5869 the user is trying to set a watchpoint that triggers
5870 only in a specific thread. */
5873 /* Extract the thread ID from the next token. */
5874 thread
= strtol (id_tok_start
, &endp
, 0);
5876 /* Check if the user provided a valid numeric value for the
5878 if (*endp
!= ' ' && *endp
!= '\t' && *endp
!= '\0')
5879 error (_("Invalid thread ID specification %s."), id_tok_start
);
5881 /* Check if the thread actually exists. */
5882 if (!valid_thread_id (thread
))
5883 error (_("Unknown thread %d."), thread
);
5885 /* Truncate the string and get rid of the thread <thread_num>
5886 parameter before the parameter list is parsed by the
5887 evaluate_expression() function. */
5892 /* Parse the rest of the arguments. */
5893 innermost_block
= NULL
;
5895 exp
= parse_exp_1 (&arg
, 0, 0);
5897 exp_valid_block
= innermost_block
;
5898 mark
= value_mark ();
5899 fetch_watchpoint_value (exp
, &val
, NULL
, NULL
);
5901 release_value (val
);
5904 while (*tok
== ' ' || *tok
== '\t')
5908 while (*end_tok
!= ' ' && *end_tok
!= '\t' && *end_tok
!= '\000')
5911 toklen
= end_tok
- tok
;
5912 if (toklen
>= 1 && strncmp (tok
, "if", toklen
) == 0)
5914 tok
= cond_start
= end_tok
+ 1;
5915 cond
= parse_exp_1 (&tok
, 0, 0);
5919 error (_("Junk at end of command."));
5921 if (accessflag
== hw_read
)
5922 bp_type
= bp_read_watchpoint
;
5923 else if (accessflag
== hw_access
)
5924 bp_type
= bp_access_watchpoint
;
5926 bp_type
= bp_hardware_watchpoint
;
5928 mem_cnt
= can_use_hardware_watchpoint (val
);
5929 if (mem_cnt
== 0 && bp_type
!= bp_hardware_watchpoint
)
5930 error (_("Expression cannot be implemented with read/access watchpoint."));
5933 i
= hw_watchpoint_used_count (bp_type
, &other_type_used
);
5934 target_resources_ok
=
5935 TARGET_CAN_USE_HARDWARE_WATCHPOINT (bp_type
, i
+ mem_cnt
,
5937 if (target_resources_ok
== 0 && bp_type
!= bp_hardware_watchpoint
)
5938 error (_("Target does not support this type of hardware watchpoint."));
5940 if (target_resources_ok
< 0 && bp_type
!= bp_hardware_watchpoint
)
5941 error (_("Target can only support one kind of HW watchpoint at a time."));
5944 /* Change the type of breakpoint to an ordinary watchpoint if a hardware
5945 watchpoint could not be set. */
5946 if (!mem_cnt
|| target_resources_ok
<= 0)
5947 bp_type
= bp_watchpoint
;
5949 frame
= block_innermost_frame (exp_valid_block
);
5951 prev_frame
= get_prev_frame (frame
);
5955 /* If the expression is "local", then set up a "watchpoint scope"
5956 breakpoint at the point where we've left the scope of the watchpoint
5957 expression. Create the scope breakpoint before the watchpoint, so
5958 that we will encounter it first in bpstat_stop_status. */
5959 if (innermost_block
&& prev_frame
)
5961 scope_breakpoint
= create_internal_breakpoint (get_frame_pc (prev_frame
),
5962 bp_watchpoint_scope
);
5964 scope_breakpoint
->enable_state
= bp_enabled
;
5966 /* Automatically delete the breakpoint when it hits. */
5967 scope_breakpoint
->disposition
= disp_del
;
5969 /* Only break in the proper frame (help with recursion). */
5970 scope_breakpoint
->frame_id
= get_frame_id (prev_frame
);
5972 /* Set the address at which we will stop. */
5973 scope_breakpoint
->loc
->requested_address
5974 = get_frame_pc (prev_frame
);
5975 scope_breakpoint
->loc
->address
5976 = adjust_breakpoint_address (scope_breakpoint
->loc
->requested_address
,
5977 scope_breakpoint
->type
);
5980 /* Now set up the breakpoint. */
5981 b
= set_raw_breakpoint (sal
, bp_type
);
5982 set_breakpoint_count (breakpoint_count
+ 1);
5983 b
->number
= breakpoint_count
;
5985 b
->disposition
= disp_donttouch
;
5987 b
->exp_valid_block
= exp_valid_block
;
5988 b
->exp_string
= savestring (exp_start
, exp_end
- exp_start
);
5991 b
->loc
->cond
= cond
;
5993 b
->cond_string
= savestring (cond_start
, cond_end
- cond_start
);
5998 b
->watchpoint_frame
= get_frame_id (frame
);
6000 b
->watchpoint_frame
= null_frame_id
;
6002 if (scope_breakpoint
!= NULL
)
6004 /* The scope breakpoint is related to the watchpoint. We will
6005 need to act on them together. */
6006 b
->related_breakpoint
= scope_breakpoint
;
6007 scope_breakpoint
->related_breakpoint
= b
;
6010 value_free_to_mark (mark
);
6012 update_global_location_list ();
6015 /* Return count of locations need to be watched and can be handled
6016 in hardware. If the watchpoint can not be handled
6017 in hardware return zero. */
6020 can_use_hardware_watchpoint (struct value
*v
)
6022 int found_memory_cnt
= 0;
6023 struct value
*head
= v
;
6025 /* Did the user specifically forbid us to use hardware watchpoints? */
6026 if (!can_use_hw_watchpoints
)
6029 /* Make sure that the value of the expression depends only upon
6030 memory contents, and values computed from them within GDB. If we
6031 find any register references or function calls, we can't use a
6032 hardware watchpoint.
6034 The idea here is that evaluating an expression generates a series
6035 of values, one holding the value of every subexpression. (The
6036 expression a*b+c has five subexpressions: a, b, a*b, c, and
6037 a*b+c.) GDB's values hold almost enough information to establish
6038 the criteria given above --- they identify memory lvalues,
6039 register lvalues, computed values, etcetera. So we can evaluate
6040 the expression, and then scan the chain of values that leaves
6041 behind to decide whether we can detect any possible change to the
6042 expression's final value using only hardware watchpoints.
6044 However, I don't think that the values returned by inferior
6045 function calls are special in any way. So this function may not
6046 notice that an expression involving an inferior function call
6047 can't be watched with hardware watchpoints. FIXME. */
6048 for (; v
; v
= value_next (v
))
6050 if (VALUE_LVAL (v
) == lval_memory
)
6053 /* A lazy memory lvalue is one that GDB never needed to fetch;
6054 we either just used its address (e.g., `a' in `a.b') or
6055 we never needed it at all (e.g., `a' in `a,b'). */
6059 /* Ahh, memory we actually used! Check if we can cover
6060 it with hardware watchpoints. */
6061 struct type
*vtype
= check_typedef (value_type (v
));
6063 /* We only watch structs and arrays if user asked for it
6064 explicitly, never if they just happen to appear in a
6065 middle of some value chain. */
6067 || (TYPE_CODE (vtype
) != TYPE_CODE_STRUCT
6068 && TYPE_CODE (vtype
) != TYPE_CODE_ARRAY
))
6070 CORE_ADDR vaddr
= VALUE_ADDRESS (v
) + value_offset (v
);
6071 int len
= TYPE_LENGTH (value_type (v
));
6073 if (!TARGET_REGION_OK_FOR_HW_WATCHPOINT (vaddr
, len
))
6080 else if (VALUE_LVAL (v
) != not_lval
6081 && deprecated_value_modifiable (v
) == 0)
6082 return 0; /* ??? What does this represent? */
6083 else if (VALUE_LVAL (v
) == lval_register
)
6084 return 0; /* cannot watch a register with a HW watchpoint */
6087 /* The expression itself looks suitable for using a hardware
6088 watchpoint, but give the target machine a chance to reject it. */
6089 return found_memory_cnt
;
6093 watch_command_wrapper (char *arg
, int from_tty
)
6095 watch_command (arg
, from_tty
);
6099 watch_command (char *arg
, int from_tty
)
6101 watch_command_1 (arg
, hw_write
, from_tty
);
6105 rwatch_command_wrapper (char *arg
, int from_tty
)
6107 rwatch_command (arg
, from_tty
);
6111 rwatch_command (char *arg
, int from_tty
)
6113 watch_command_1 (arg
, hw_read
, from_tty
);
6117 awatch_command_wrapper (char *arg
, int from_tty
)
6119 awatch_command (arg
, from_tty
);
6123 awatch_command (char *arg
, int from_tty
)
6125 watch_command_1 (arg
, hw_access
, from_tty
);
6129 /* Helper routines for the until_command routine in infcmd.c. Here
6130 because it uses the mechanisms of breakpoints. */
6132 /* This function is called by fetch_inferior_event via the
6133 cmd_continuation pointer, to complete the until command. It takes
6134 care of cleaning up the temporary breakpoints set up by the until
6137 until_break_command_continuation (struct continuation_arg
*arg
, int error
)
6139 delete_breakpoint ((struct breakpoint
*)(arg
->data
.pointer
));
6141 delete_breakpoint ((struct breakpoint
*)(arg
->next
->data
.pointer
));
6145 until_break_command (char *arg
, int from_tty
, int anywhere
)
6147 struct symtabs_and_lines sals
;
6148 struct symtab_and_line sal
;
6149 struct frame_info
*frame
= get_selected_frame (NULL
);
6150 struct frame_info
*prev_frame
= get_prev_frame (frame
);
6151 struct breakpoint
*breakpoint
;
6152 struct breakpoint
*breakpoint2
= NULL
;
6153 struct cleanup
*old_chain
;
6154 struct continuation_arg
*arg1
;
6155 struct continuation_arg
*arg2
;
6158 clear_proceed_status ();
6160 /* Set a breakpoint where the user wants it and at return from
6163 if (default_breakpoint_valid
)
6164 sals
= decode_line_1 (&arg
, 1, default_breakpoint_symtab
,
6165 default_breakpoint_line
, (char ***) NULL
, NULL
);
6167 sals
= decode_line_1 (&arg
, 1, (struct symtab
*) NULL
,
6168 0, (char ***) NULL
, NULL
);
6170 if (sals
.nelts
!= 1)
6171 error (_("Couldn't get information on specified line."));
6174 xfree (sals
.sals
); /* malloc'd, so freed */
6177 error (_("Junk at end of arguments."));
6179 resolve_sal_pc (&sal
);
6182 /* If the user told us to continue until a specified location,
6183 we don't specify a frame at which we need to stop. */
6184 breakpoint
= set_momentary_breakpoint (sal
, null_frame_id
, bp_until
);
6186 /* Otherwise, specify the current frame, because we want to stop only
6187 at the very same frame. */
6188 breakpoint
= set_momentary_breakpoint (sal
, get_frame_id (frame
),
6191 old_chain
= make_cleanup_delete_breakpoint (breakpoint
);
6193 /* Keep within the current frame, or in frames called by the current
6197 sal
= find_pc_line (get_frame_pc (prev_frame
), 0);
6198 sal
.pc
= get_frame_pc (prev_frame
);
6199 breakpoint2
= set_momentary_breakpoint (sal
, get_frame_id (prev_frame
),
6201 make_cleanup_delete_breakpoint (breakpoint2
);
6204 proceed (-1, TARGET_SIGNAL_DEFAULT
, 0);
6206 /* If we are running asynchronously, and proceed call above has actually
6207 managed to start the target, arrange for breakpoints to be
6208 deleted when the target stops. Otherwise, we're already stopped and
6209 delete breakpoints via cleanup chain. */
6211 if (target_can_async_p () && target_executing
)
6214 (struct continuation_arg
*) xmalloc (sizeof (struct continuation_arg
));
6216 arg1
->data
.pointer
= breakpoint
;
6220 arg2
= (struct continuation_arg
*)
6221 xmalloc ( sizeof (struct continuation_arg
));
6223 arg2
->data
.pointer
= breakpoint2
;
6227 discard_cleanups (old_chain
);
6228 add_continuation (until_break_command_continuation
, arg1
);
6231 do_cleanups (old_chain
);
6235 ep_skip_leading_whitespace (char **s
)
6237 if ((s
== NULL
) || (*s
== NULL
))
6239 while (isspace (**s
))
6243 /* This function examines a string, and attempts to find a token
6244 that might be an event name in the leading characters. If a
6245 possible match is found, a pointer to the last character of
6246 the token is returned. Else, NULL is returned. */
6249 ep_find_event_name_end (char *arg
)
6252 char *event_name_end
= NULL
;
6254 /* If we could depend upon the presense of strrpbrk, we'd use that... */
6258 /* We break out of the loop when we find a token delimiter.
6259 Basically, we're looking for alphanumerics and underscores;
6260 anything else delimites the token. */
6263 if (!isalnum (*s
) && (*s
!= '_'))
6269 return event_name_end
;
6273 /* This function attempts to parse an optional "if <cond>" clause
6274 from the arg string. If one is not found, it returns NULL.
6276 Else, it returns a pointer to the condition string. (It does not
6277 attempt to evaluate the string against a particular block.) And,
6278 it updates arg to point to the first character following the parsed
6279 if clause in the arg string. */
6282 ep_parse_optional_if_clause (char **arg
)
6286 if (((*arg
)[0] != 'i') || ((*arg
)[1] != 'f') || !isspace ((*arg
)[2]))
6289 /* Skip the "if" keyword. */
6292 /* Skip any extra leading whitespace, and record the start of the
6293 condition string. */
6294 ep_skip_leading_whitespace (arg
);
6297 /* Assume that the condition occupies the remainder of the arg string. */
6298 (*arg
) += strlen (cond_string
);
6303 /* This function attempts to parse an optional filename from the arg
6304 string. If one is not found, it returns NULL.
6306 Else, it returns a pointer to the parsed filename. (This function
6307 makes no attempt to verify that a file of that name exists, or is
6308 accessible.) And, it updates arg to point to the first character
6309 following the parsed filename in the arg string.
6311 Note that clients needing to preserve the returned filename for
6312 future access should copy it to their own buffers. */
6314 ep_parse_optional_filename (char **arg
)
6316 static char filename
[1024];
6321 if ((*arg_p
== '\0') || isspace (*arg_p
))
6339 /* Commands to deal with catching events, such as signals, exceptions,
6340 process start/exit, etc. */
6344 catch_fork
, catch_vfork
6349 catch_fork_command_1 (catch_fork_kind fork_kind
, char *arg
, int tempflag
,
6352 char *cond_string
= NULL
;
6354 ep_skip_leading_whitespace (&arg
);
6356 /* The allowed syntax is:
6358 catch [v]fork if <cond>
6360 First, check if there's an if clause. */
6361 cond_string
= ep_parse_optional_if_clause (&arg
);
6363 if ((*arg
!= '\0') && !isspace (*arg
))
6364 error (_("Junk at end of arguments."));
6366 /* If this target supports it, create a fork or vfork catchpoint
6367 and enable reporting of such events. */
6371 create_fork_event_catchpoint (tempflag
, cond_string
);
6374 create_vfork_event_catchpoint (tempflag
, cond_string
);
6377 error (_("unsupported or unknown fork kind; cannot catch it"));
6383 catch_exec_command_1 (char *arg
, int tempflag
, int from_tty
)
6385 char *cond_string
= NULL
;
6387 ep_skip_leading_whitespace (&arg
);
6389 /* The allowed syntax is:
6391 catch exec if <cond>
6393 First, check if there's an if clause. */
6394 cond_string
= ep_parse_optional_if_clause (&arg
);
6396 if ((*arg
!= '\0') && !isspace (*arg
))
6397 error (_("Junk at end of arguments."));
6399 /* If this target supports it, create an exec catchpoint
6400 and enable reporting of such events. */
6401 create_exec_event_catchpoint (tempflag
, cond_string
);
6405 catch_load_command_1 (char *arg
, int tempflag
, int from_tty
)
6407 char *dll_pathname
= NULL
;
6408 char *cond_string
= NULL
;
6410 ep_skip_leading_whitespace (&arg
);
6412 /* The allowed syntax is:
6414 catch load if <cond>
6415 catch load <filename>
6416 catch load <filename> if <cond>
6418 The user is not allowed to specify the <filename> after an
6421 We'll ignore the pathological case of a file named "if".
6423 First, check if there's an if clause. If so, then there
6424 cannot be a filename. */
6425 cond_string
= ep_parse_optional_if_clause (&arg
);
6427 /* If there was an if clause, then there cannot be a filename.
6428 Else, there might be a filename and an if clause. */
6429 if (cond_string
== NULL
)
6431 dll_pathname
= ep_parse_optional_filename (&arg
);
6432 ep_skip_leading_whitespace (&arg
);
6433 cond_string
= ep_parse_optional_if_clause (&arg
);
6436 if ((*arg
!= '\0') && !isspace (*arg
))
6437 error (_("Junk at end of arguments."));
6439 /* Create a load breakpoint that only triggers when a load of
6440 the specified dll (or any dll, if no pathname was specified)
6442 SOLIB_CREATE_CATCH_LOAD_HOOK (PIDGET (inferior_ptid
), tempflag
,
6443 dll_pathname
, cond_string
);
6447 catch_unload_command_1 (char *arg
, int tempflag
, int from_tty
)
6449 char *dll_pathname
= NULL
;
6450 char *cond_string
= NULL
;
6452 ep_skip_leading_whitespace (&arg
);
6454 /* The allowed syntax is:
6456 catch unload if <cond>
6457 catch unload <filename>
6458 catch unload <filename> if <cond>
6460 The user is not allowed to specify the <filename> after an
6463 We'll ignore the pathological case of a file named "if".
6465 First, check if there's an if clause. If so, then there
6466 cannot be a filename. */
6467 cond_string
= ep_parse_optional_if_clause (&arg
);
6469 /* If there was an if clause, then there cannot be a filename.
6470 Else, there might be a filename and an if clause. */
6471 if (cond_string
== NULL
)
6473 dll_pathname
= ep_parse_optional_filename (&arg
);
6474 ep_skip_leading_whitespace (&arg
);
6475 cond_string
= ep_parse_optional_if_clause (&arg
);
6478 if ((*arg
!= '\0') && !isspace (*arg
))
6479 error (_("Junk at end of arguments."));
6481 /* Create an unload breakpoint that only triggers when an unload of
6482 the specified dll (or any dll, if no pathname was specified)
6484 SOLIB_CREATE_CATCH_UNLOAD_HOOK (PIDGET (inferior_ptid
), tempflag
,
6485 dll_pathname
, cond_string
);
6488 static enum print_stop_action
6489 print_exception_catchpoint (struct breakpoint
*b
)
6491 int bp_temp
, bp_throw
;
6493 annotate_catchpoint (b
->number
);
6495 bp_throw
= strstr (b
->addr_string
, "throw") != NULL
;
6496 if (b
->loc
->address
!= b
->loc
->requested_address
)
6497 breakpoint_adjustment_warning (b
->loc
->requested_address
,
6500 bp_temp
= b
->loc
->owner
->disposition
== disp_del
;
6502 bp_temp
? "Temporary catchpoint "
6504 if (!ui_out_is_mi_like_p (uiout
))
6505 ui_out_field_int (uiout
, "bkptno", b
->number
);
6507 bp_throw
? " (exception thrown), "
6508 : " (exception caught), ");
6509 if (ui_out_is_mi_like_p (uiout
))
6511 ui_out_field_string (uiout
, "reason",
6512 async_reason_lookup (EXEC_ASYNC_BREAKPOINT_HIT
));
6513 ui_out_field_string (uiout
, "disp", bpdisp_text (b
->disposition
));
6514 ui_out_field_int (uiout
, "bkptno", b
->number
);
6516 return PRINT_SRC_AND_LOC
;
6520 print_one_exception_catchpoint (struct breakpoint
*b
, CORE_ADDR
*last_addr
)
6525 if (b
->loc
== NULL
|| b
->loc
->shlib_disabled
)
6526 ui_out_field_string (uiout
, "addr", "<PENDING>");
6528 ui_out_field_core_addr (uiout
, "addr", b
->loc
->address
);
6532 *last_addr
= b
->loc
->address
;
6533 if (strstr (b
->addr_string
, "throw") != NULL
)
6534 ui_out_field_string (uiout
, "what", "exception throw");
6536 ui_out_field_string (uiout
, "what", "exception catch");
6540 print_mention_exception_catchpoint (struct breakpoint
*b
)
6545 bp_temp
= b
->loc
->owner
->disposition
== disp_del
;
6546 bp_throw
= strstr (b
->addr_string
, "throw") != NULL
;
6547 ui_out_text (uiout
, bp_temp
? _("Temporary catchpoint ")
6548 : _("Catchpoint "));
6549 ui_out_field_int (uiout
, "bkptno", b
->number
);
6550 ui_out_text (uiout
, bp_throw
? _(" (throw)")
6554 static struct breakpoint_ops gnu_v3_exception_catchpoint_ops
= {
6555 print_exception_catchpoint
,
6556 print_one_exception_catchpoint
,
6557 print_mention_exception_catchpoint
6561 handle_gnu_v3_exceptions (int tempflag
, char *cond_string
,
6562 enum exception_event_kind ex_event
, int from_tty
)
6564 char *trigger_func_name
;
6566 if (ex_event
== EX_EVENT_CATCH
)
6567 trigger_func_name
= "__cxa_begin_catch";
6569 trigger_func_name
= "__cxa_throw";
6571 break_command_really (trigger_func_name
, cond_string
, -1,
6572 0 /* condition and thread are valid. */,
6575 AUTO_BOOLEAN_TRUE
/* pending */,
6576 &gnu_v3_exception_catchpoint_ops
, from_tty
);
6581 /* Deal with "catch catch" and "catch throw" commands */
6584 catch_exception_command_1 (enum exception_event_kind ex_event
, char *arg
,
6585 int tempflag
, int from_tty
)
6587 char *cond_string
= NULL
;
6588 struct symtab_and_line
*sal
= NULL
;
6590 ep_skip_leading_whitespace (&arg
);
6592 cond_string
= ep_parse_optional_if_clause (&arg
);
6594 if ((*arg
!= '\0') && !isspace (*arg
))
6595 error (_("Junk at end of arguments."));
6597 if ((ex_event
!= EX_EVENT_THROW
) &&
6598 (ex_event
!= EX_EVENT_CATCH
))
6599 error (_("Unsupported or unknown exception event; cannot catch it"));
6601 if (handle_gnu_v3_exceptions (tempflag
, cond_string
, ex_event
, from_tty
))
6604 warning (_("Unsupported with this platform/compiler combination."));
6607 /* Create a breakpoint struct for Ada exception catchpoints. */
6610 create_ada_exception_breakpoint (struct symtab_and_line sal
,
6614 struct expression
*cond
,
6615 struct breakpoint_ops
*ops
,
6619 struct breakpoint
*b
;
6623 describe_other_breakpoints (sal
.pc
, sal
.section
, -1);
6624 /* FIXME: brobecker/2006-12-28: Actually, re-implement a special
6625 version for exception catchpoints, because two catchpoints
6626 used for different exception names will use the same address.
6627 In this case, a "breakpoint ... also set at..." warning is
6628 unproductive. Besides. the warning phrasing is also a bit
6629 inapropriate, we should use the word catchpoint, and tell
6630 the user what type of catchpoint it is. The above is good
6631 enough for now, though. */
6634 b
= set_raw_breakpoint (sal
, bp_breakpoint
);
6635 set_breakpoint_count (breakpoint_count
+ 1);
6637 b
->enable_state
= bp_enabled
;
6638 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
6639 b
->number
= breakpoint_count
;
6640 b
->ignore_count
= 0;
6641 b
->loc
->cond
= cond
;
6642 b
->addr_string
= addr_string
;
6643 b
->language
= language_ada
;
6644 b
->cond_string
= cond_string
;
6645 b
->exp_string
= exp_string
;
6650 update_global_location_list ();
6653 /* Implement the "catch exception" command. */
6656 catch_ada_exception_command (char *arg
, int tempflag
, int from_tty
)
6658 struct symtab_and_line sal
;
6660 char *addr_string
= NULL
;
6661 char *exp_string
= NULL
;
6662 char *cond_string
= NULL
;
6663 struct expression
*cond
= NULL
;
6664 struct breakpoint_ops
*ops
= NULL
;
6666 sal
= ada_decode_exception_location (arg
, &addr_string
, &exp_string
,
6667 &cond_string
, &cond
, &ops
);
6668 create_ada_exception_breakpoint (sal
, addr_string
, exp_string
,
6669 cond_string
, cond
, ops
, tempflag
,
6673 /* Implement the "catch assert" command. */
6676 catch_assert_command (char *arg
, int tempflag
, int from_tty
)
6678 struct symtab_and_line sal
;
6679 char *addr_string
= NULL
;
6680 struct breakpoint_ops
*ops
= NULL
;
6682 sal
= ada_decode_assert_location (arg
, &addr_string
, &ops
);
6683 create_ada_exception_breakpoint (sal
, addr_string
, NULL
, NULL
, NULL
, ops
,
6684 tempflag
, from_tty
);
6688 catch_command_1 (char *arg
, int tempflag
, int from_tty
)
6691 /* The first argument may be an event name, such as "start" or "load".
6692 If so, then handle it as such. If it doesn't match an event name,
6693 then attempt to interpret it as an exception name. (This latter is
6694 the v4.16-and-earlier GDB meaning of the "catch" command.)
6696 First, try to find the bounds of what might be an event name. */
6697 char *arg1_start
= arg
;
6701 if (arg1_start
== NULL
)
6703 /* Old behaviour was to use pre-v-4.16 syntax */
6704 /* catch_throw_command_1 (arg1_start, tempflag, from_tty); */
6706 /* Now, this is not allowed */
6707 error (_("Catch requires an event name."));
6710 arg1_end
= ep_find_event_name_end (arg1_start
);
6711 if (arg1_end
== NULL
)
6712 error (_("catch requires an event"));
6713 arg1_length
= arg1_end
+ 1 - arg1_start
;
6715 /* Try to match what we found against known event names. */
6716 if (strncmp (arg1_start
, "signal", arg1_length
) == 0)
6718 error (_("Catch of signal not yet implemented"));
6720 else if (strncmp (arg1_start
, "catch", arg1_length
) == 0)
6722 catch_exception_command_1 (EX_EVENT_CATCH
, arg1_end
+ 1,
6723 tempflag
, from_tty
);
6725 else if (strncmp (arg1_start
, "throw", arg1_length
) == 0)
6727 catch_exception_command_1 (EX_EVENT_THROW
, arg1_end
+ 1,
6728 tempflag
, from_tty
);
6730 else if (strncmp (arg1_start
, "thread_start", arg1_length
) == 0)
6732 error (_("Catch of thread_start not yet implemented"));
6734 else if (strncmp (arg1_start
, "thread_exit", arg1_length
) == 0)
6736 error (_("Catch of thread_exit not yet implemented"));
6738 else if (strncmp (arg1_start
, "thread_join", arg1_length
) == 0)
6740 error (_("Catch of thread_join not yet implemented"));
6742 else if (strncmp (arg1_start
, "start", arg1_length
) == 0)
6744 error (_("Catch of start not yet implemented"));
6746 else if (strncmp (arg1_start
, "exit", arg1_length
) == 0)
6748 error (_("Catch of exit not yet implemented"));
6750 else if (strncmp (arg1_start
, "fork", arg1_length
) == 0)
6752 catch_fork_command_1 (catch_fork
, arg1_end
+ 1, tempflag
, from_tty
);
6754 else if (strncmp (arg1_start
, "vfork", arg1_length
) == 0)
6756 catch_fork_command_1 (catch_vfork
, arg1_end
+ 1, tempflag
, from_tty
);
6758 else if (strncmp (arg1_start
, "exec", arg1_length
) == 0)
6760 catch_exec_command_1 (arg1_end
+ 1, tempflag
, from_tty
);
6762 else if (strncmp (arg1_start
, "load", arg1_length
) == 0)
6764 catch_load_command_1 (arg1_end
+ 1, tempflag
, from_tty
);
6766 else if (strncmp (arg1_start
, "unload", arg1_length
) == 0)
6768 catch_unload_command_1 (arg1_end
+ 1, tempflag
, from_tty
);
6770 else if (strncmp (arg1_start
, "stop", arg1_length
) == 0)
6772 error (_("Catch of stop not yet implemented"));
6774 else if (strncmp (arg1_start
, "exception", arg1_length
) == 0)
6776 catch_ada_exception_command (arg1_end
+ 1, tempflag
, from_tty
);
6779 else if (strncmp (arg1_start
, "assert", arg1_length
) == 0)
6781 catch_assert_command (arg1_end
+ 1, tempflag
, from_tty
);
6784 /* This doesn't appear to be an event name */
6788 /* Pre-v.4.16 behaviour was to treat the argument
6789 as the name of an exception */
6790 /* catch_throw_command_1 (arg1_start, tempflag, from_tty); */
6791 /* Now this is not allowed */
6792 error (_("Unknown event kind specified for catch"));
6798 catch_command (char *arg
, int from_tty
)
6800 catch_command_1 (arg
, 0, from_tty
);
6805 tcatch_command (char *arg
, int from_tty
)
6807 catch_command_1 (arg
, 1, from_tty
);
6810 /* Delete breakpoints by address or line. */
6813 clear_command (char *arg
, int from_tty
)
6815 struct breakpoint
*b
;
6816 VEC(breakpoint_p
) *found
= 0;
6819 struct symtabs_and_lines sals
;
6820 struct symtab_and_line sal
;
6825 sals
= decode_line_spec (arg
, 1);
6830 sals
.sals
= (struct symtab_and_line
*)
6831 xmalloc (sizeof (struct symtab_and_line
));
6832 make_cleanup (xfree
, sals
.sals
);
6833 init_sal (&sal
); /* initialize to zeroes */
6834 sal
.line
= default_breakpoint_line
;
6835 sal
.symtab
= default_breakpoint_symtab
;
6836 sal
.pc
= default_breakpoint_address
;
6837 if (sal
.symtab
== 0)
6838 error (_("No source file specified."));
6846 /* We don't call resolve_sal_pc here. That's not
6847 as bad as it seems, because all existing breakpoints
6848 typically have both file/line and pc set. So, if
6849 clear is given file/line, we can match this to existing
6850 breakpoint without obtaining pc at all.
6852 We only support clearing given the address explicitly
6853 present in breakpoint table. Say, we've set breakpoint
6854 at file:line. There were several PC values for that file:line,
6855 due to optimization, all in one block.
6856 We've picked one PC value. If "clear" is issued with another
6857 PC corresponding to the same file:line, the breakpoint won't
6858 be cleared. We probably can still clear the breakpoint, but
6859 since the other PC value is never presented to user, user
6860 can only find it by guessing, and it does not seem important
6863 /* For each line spec given, delete bps which correspond
6864 to it. Do it in two passes, solely to preserve the current
6865 behavior that from_tty is forced true if we delete more than
6869 for (i
= 0; i
< sals
.nelts
; i
++)
6871 /* If exact pc given, clear bpts at that pc.
6872 If line given (pc == 0), clear all bpts on specified line.
6873 If defaulting, clear all bpts on default line
6876 defaulting sal.pc != 0 tests to do
6881 1 0 <can't happen> */
6885 /* Find all matching breakpoints and add them to
6890 /* Are we going to delete b? */
6891 if (b
->type
!= bp_none
6892 && b
->type
!= bp_watchpoint
6893 && b
->type
!= bp_hardware_watchpoint
6894 && b
->type
!= bp_read_watchpoint
6895 && b
->type
!= bp_access_watchpoint
)
6897 struct bp_location
*loc
= b
->loc
;
6898 for (; loc
; loc
= loc
->next
)
6900 int pc_match
= sal
.pc
6901 && (loc
->address
== sal
.pc
)
6902 && (!section_is_overlay (loc
->section
)
6903 || loc
->section
== sal
.section
);
6904 int line_match
= ((default_match
|| (0 == sal
.pc
))
6905 && b
->source_file
!= NULL
6906 && sal
.symtab
!= NULL
6907 && strcmp (b
->source_file
, sal
.symtab
->filename
) == 0
6908 && b
->line_number
== sal
.line
);
6909 if (pc_match
|| line_match
)
6918 VEC_safe_push(breakpoint_p
, found
, b
);
6921 /* Now go thru the 'found' chain and delete them. */
6922 if (VEC_empty(breakpoint_p
, found
))
6925 error (_("No breakpoint at %s."), arg
);
6927 error (_("No breakpoint at this line."));
6930 if (VEC_length(breakpoint_p
, found
) > 1)
6931 from_tty
= 1; /* Always report if deleted more than one */
6934 if (VEC_length(breakpoint_p
, found
) == 1)
6935 printf_unfiltered (_("Deleted breakpoint "));
6937 printf_unfiltered (_("Deleted breakpoints "));
6939 breakpoints_changed ();
6941 for (ix
= 0; VEC_iterate(breakpoint_p
, found
, ix
, b
); ix
++)
6944 printf_unfiltered ("%d ", b
->number
);
6945 delete_breakpoint (b
);
6948 putchar_unfiltered ('\n');
6951 /* Delete breakpoint in BS if they are `delete' breakpoints and
6952 all breakpoints that are marked for deletion, whether hit or not.
6953 This is called after any breakpoint is hit, or after errors. */
6956 breakpoint_auto_delete (bpstat bs
)
6958 struct breakpoint
*b
, *temp
;
6960 for (; bs
; bs
= bs
->next
)
6961 if (bs
->breakpoint_at
&& bs
->breakpoint_at
->owner
->disposition
== disp_del
6963 delete_breakpoint (bs
->breakpoint_at
->owner
);
6965 ALL_BREAKPOINTS_SAFE (b
, temp
)
6967 if (b
->disposition
== disp_del_at_next_stop
)
6968 delete_breakpoint (b
);
6973 update_global_location_list (void)
6975 struct breakpoint
*b
;
6976 struct bp_location
**next
= &bp_location_chain
;
6977 struct bp_location
*loc
;
6978 struct bp_location
*loc2
;
6979 struct gdb_exception e
;
6980 VEC(bp_location_p
) *old_locations
= NULL
;
6984 /* Store old locations for future reference. */
6985 for (loc
= bp_location_chain
; loc
; loc
= loc
->global_next
)
6986 VEC_safe_push (bp_location_p
, old_locations
, loc
);
6988 bp_location_chain
= NULL
;
6991 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
6994 next
= &(loc
->global_next
);
6999 /* Identify bp_location instances that are no longer present in the new
7000 list, and therefore should be freed. Note that it's not necessary that
7001 those locations should be removed from inferior -- if there's another
7002 location at the same address (previously marked as duplicate),
7003 we don't need to remove/insert the location. */
7004 for (ix
= 0; VEC_iterate(bp_location_p
, old_locations
, ix
, loc
); ++ix
)
7006 /* Tells if 'loc' is found amoung the new locations. If not, we
7008 int found_object
= 0;
7009 for (loc2
= bp_location_chain
; loc2
; loc2
= loc2
->global_next
)
7016 /* If this location is no longer present, and inserted, look if there's
7017 maybe a new location at the same address. If so, mark that one
7018 inserted, and don't remove this one. This is needed so that we
7019 don't have a time window where a breakpoint at certain location is not
7024 /* If the location is inserted now, we might have to remove it. */
7027 if (found_object
&& should_be_inserted (loc
))
7029 /* The location is still present in the location list, and still
7030 should be inserted. Don't do anything. */
7035 /* The location is either no longer present, or got disabled.
7036 See if there's another location at the same address, in which
7037 case we don't need to remove this one from the target. */
7038 if (breakpoint_address_is_meaningful (loc
->owner
))
7039 for (loc2
= bp_location_chain
; loc2
; loc2
= loc2
->global_next
)
7041 /* For the sake of should_insert_location. The
7042 call to check_duplicates will fix up this later. */
7043 loc2
->duplicate
= 0;
7044 if (should_be_inserted (loc2
)
7045 && loc2
!= loc
&& loc2
->address
== loc
->address
)
7048 loc2
->target_info
= loc
->target_info
;
7056 if (remove_breakpoint (loc
, mark_uninserted
))
7058 /* This is just about all we can do. We could keep this
7059 location on the global list, and try to remove it next
7060 time, but there's no particular reason why we will
7063 Note that at this point, loc->owner is still valid,
7064 as delete_breakpoint frees the breakpoint only
7065 after calling us. */
7066 printf_filtered (_("warning: Error removing breakpoint %d\n"),
7067 loc
->owner
->number
);
7072 free_bp_location (loc
);
7077 check_duplicates (b
);
7080 if (always_inserted_mode
&& target_has_execution
)
7081 insert_breakpoint_locations ();
7085 update_global_location_list_nothrow (void)
7087 struct gdb_exception e
;
7088 TRY_CATCH (e
, RETURN_MASK_ERROR
)
7089 update_global_location_list ();
7092 /* Delete a breakpoint and clean up all traces of it in the data
7096 delete_breakpoint (struct breakpoint
*bpt
)
7098 struct breakpoint
*b
;
7100 struct bp_location
*loc
, *next
;
7102 gdb_assert (bpt
!= NULL
);
7104 /* Has this bp already been deleted? This can happen because multiple
7105 lists can hold pointers to bp's. bpstat lists are especial culprits.
7107 One example of this happening is a watchpoint's scope bp. When the
7108 scope bp triggers, we notice that the watchpoint is out of scope, and
7109 delete it. We also delete its scope bp. But the scope bp is marked
7110 "auto-deleting", and is already on a bpstat. That bpstat is then
7111 checked for auto-deleting bp's, which are deleted.
7113 A real solution to this problem might involve reference counts in bp's,
7114 and/or giving them pointers back to their referencing bpstat's, and
7115 teaching delete_breakpoint to only free a bp's storage when no more
7116 references were extent. A cheaper bandaid was chosen. */
7117 if (bpt
->type
== bp_none
)
7120 if (deprecated_delete_breakpoint_hook
)
7121 deprecated_delete_breakpoint_hook (bpt
);
7122 breakpoint_delete_event (bpt
->number
);
7124 if (breakpoint_chain
== bpt
)
7125 breakpoint_chain
= bpt
->next
;
7130 b
->next
= bpt
->next
;
7134 free_command_lines (&bpt
->commands
);
7135 if (bpt
->cond_string
!= NULL
)
7136 xfree (bpt
->cond_string
);
7137 if (bpt
->addr_string
!= NULL
)
7138 xfree (bpt
->addr_string
);
7139 if (bpt
->exp
!= NULL
)
7141 if (bpt
->exp_string
!= NULL
)
7142 xfree (bpt
->exp_string
);
7143 if (bpt
->val
!= NULL
)
7144 value_free (bpt
->val
);
7145 if (bpt
->source_file
!= NULL
)
7146 xfree (bpt
->source_file
);
7147 if (bpt
->dll_pathname
!= NULL
)
7148 xfree (bpt
->dll_pathname
);
7149 if (bpt
->triggered_dll_pathname
!= NULL
)
7150 xfree (bpt
->triggered_dll_pathname
);
7151 if (bpt
->exec_pathname
!= NULL
)
7152 xfree (bpt
->exec_pathname
);
7154 /* Be sure no bpstat's are pointing at it after it's been freed. */
7155 /* FIXME, how can we find all bpstat's?
7156 We just check stop_bpstat for now. Note that we cannot just
7157 remove bpstats pointing at bpt from the stop_bpstat list
7158 entirely, as breakpoint commands are associated with the bpstat;
7159 if we remove it here, then the later call to
7160 bpstat_do_actions (&stop_bpstat);
7161 in event-top.c won't do anything, and temporary breakpoints
7162 with commands won't work. */
7163 for (bs
= stop_bpstat
; bs
; bs
= bs
->next
)
7164 if (bs
->breakpoint_at
&& bs
->breakpoint_at
->owner
== bpt
)
7166 bs
->breakpoint_at
= NULL
;
7168 /* bs->commands will be freed later. */
7171 /* Now that breakpoint is removed from breakpoint
7172 list, update the global location list. This
7173 will remove locations that used to belong to
7174 this breakpoint. Do this before freeing
7175 the breakpoint itself, since remove_breakpoint
7176 looks at location's owner. It might be better
7177 design to have location completely self-contained,
7178 but it's not the case now. */
7179 update_global_location_list ();
7182 /* On the chance that someone will soon try again to delete this same
7183 bp, we mark it as deleted before freeing its storage. */
7184 bpt
->type
= bp_none
;
7190 do_delete_breakpoint_cleanup (void *b
)
7192 delete_breakpoint (b
);
7196 make_cleanup_delete_breakpoint (struct breakpoint
*b
)
7198 return make_cleanup (do_delete_breakpoint_cleanup
, b
);
7202 delete_command (char *arg
, int from_tty
)
7204 struct breakpoint
*b
, *temp
;
7210 int breaks_to_delete
= 0;
7212 /* Delete all breakpoints if no argument.
7213 Do not delete internal or call-dummy breakpoints, these
7214 have to be deleted with an explicit breakpoint number argument. */
7217 if (b
->type
!= bp_call_dummy
&&
7218 b
->type
!= bp_shlib_event
&&
7219 b
->type
!= bp_thread_event
&&
7220 b
->type
!= bp_overlay_event
&&
7223 breaks_to_delete
= 1;
7228 /* Ask user only if there are some breakpoints to delete. */
7230 || (breaks_to_delete
&& query (_("Delete all breakpoints? "))))
7232 ALL_BREAKPOINTS_SAFE (b
, temp
)
7234 if (b
->type
!= bp_call_dummy
&&
7235 b
->type
!= bp_shlib_event
&&
7236 b
->type
!= bp_thread_event
&&
7237 b
->type
!= bp_overlay_event
&&
7239 delete_breakpoint (b
);
7244 map_breakpoint_numbers (arg
, delete_breakpoint
);
7248 all_locations_are_pending (struct bp_location
*loc
)
7250 for (; loc
; loc
= loc
->next
)
7251 if (!loc
->shlib_disabled
)
7256 /* Subroutine of update_breakpoint_locations to simplify it.
7257 Return non-zero if multiple fns in list LOC have the same name.
7258 Null names are ignored. */
7261 ambiguous_names_p (struct bp_location
*loc
)
7263 struct bp_location
*l
;
7264 htab_t htab
= htab_create_alloc (13, htab_hash_string
,
7265 (int (*) (const void *, const void *)) streq
,
7266 NULL
, xcalloc
, xfree
);
7268 for (l
= loc
; l
!= NULL
; l
= l
->next
)
7271 const char *name
= l
->function_name
;
7273 /* Allow for some names to be NULL, ignore them. */
7277 slot
= (const char **) htab_find_slot (htab
, (const void *) name
,
7279 /* NOTE: We can assume slot != NULL here because xcalloc never returns
7294 update_breakpoint_locations (struct breakpoint
*b
,
7295 struct symtabs_and_lines sals
)
7299 struct bp_location
*existing_locations
= b
->loc
;
7301 /* If there's no new locations, and all existing locations
7302 are pending, don't do anything. This optimizes
7303 the common case where all locations are in the same
7304 shared library, that was unloaded. We'd like to
7305 retain the location, so that when the library
7306 is loaded again, we don't loose the enabled/disabled
7307 status of the individual locations. */
7308 if (all_locations_are_pending (existing_locations
) && sals
.nelts
== 0)
7313 for (i
= 0; i
< sals
.nelts
; ++i
)
7315 struct bp_location
*new_loc
=
7316 add_location_to_breakpoint (b
, b
->type
, &(sals
.sals
[i
]));
7318 /* Reparse conditions, they might contain references to the
7320 if (b
->cond_string
!= NULL
)
7322 struct gdb_exception e
;
7325 TRY_CATCH (e
, RETURN_MASK_ERROR
)
7327 new_loc
->cond
= parse_exp_1 (&s
, block_for_pc (sals
.sals
[i
].pc
),
7332 warning (_("failed to reevaluate condition for breakpoint %d: %s"),
7333 b
->number
, e
.message
);
7334 new_loc
->enabled
= 0;
7338 if (b
->source_file
!= NULL
)
7339 xfree (b
->source_file
);
7340 if (sals
.sals
[i
].symtab
== NULL
)
7341 b
->source_file
= NULL
;
7344 savestring (sals
.sals
[i
].symtab
->filename
,
7345 strlen (sals
.sals
[i
].symtab
->filename
));
7347 if (b
->line_number
== 0)
7348 b
->line_number
= sals
.sals
[i
].line
;
7351 /* If possible, carry over 'disable' status from existing breakpoints. */
7353 struct bp_location
*e
= existing_locations
;
7354 /* If there are multiple breakpoints with the same function name,
7355 e.g. for inline functions, comparing function names won't work.
7356 Instead compare pc addresses; this is just a heuristic as things
7357 may have moved, but in practice it gives the correct answer
7358 often enough until a better solution is found. */
7359 int have_ambiguous_names
= ambiguous_names_p (b
->loc
);
7361 for (; e
; e
= e
->next
)
7363 if (!e
->enabled
&& e
->function_name
)
7365 struct bp_location
*l
= b
->loc
;
7366 if (have_ambiguous_names
)
7368 for (; l
; l
= l
->next
)
7369 if (e
->address
== l
->address
)
7377 for (; l
; l
= l
->next
)
7378 if (l
->function_name
7379 && strcmp (e
->function_name
, l
->function_name
) == 0)
7389 update_global_location_list ();
7393 /* Reset a breakpoint given it's struct breakpoint * BINT.
7394 The value we return ends up being the return value from catch_errors.
7395 Unused in this case. */
7398 breakpoint_re_set_one (void *bint
)
7400 /* get past catch_errs */
7401 struct breakpoint
*b
= (struct breakpoint
*) bint
;
7405 int *not_found_ptr
= ¬_found
;
7406 struct symtabs_and_lines sals
= {};
7407 struct symtabs_and_lines expanded
;
7409 enum enable_state save_enable
;
7410 struct gdb_exception e
;
7416 warning (_("attempted to reset apparently deleted breakpoint #%d?"),
7420 case bp_hardware_breakpoint
:
7422 case bp_catch_unload
:
7423 if (b
->addr_string
== NULL
)
7425 /* Anything without a string can't be re-set. */
7426 delete_breakpoint (b
);
7430 set_language (b
->language
);
7431 input_radix
= b
->input_radix
;
7433 TRY_CATCH (e
, RETURN_MASK_ERROR
)
7435 sals
= decode_line_1 (&s
, 1, (struct symtab
*) NULL
, 0, (char ***) NULL
,
7440 int not_found_and_ok
= 0;
7441 /* For pending breakpoints, it's expected that parsing
7442 will fail until the right shared library is loaded.
7443 User has already told to create pending breakpoints and
7444 don't need extra messages. If breakpoint is in bp_shlib_disabled
7445 state, then user already saw the message about that breakpoint
7446 being disabled, and don't want to see more errors. */
7448 && (b
->condition_not_parsed
7449 || (b
->loc
&& b
->loc
->shlib_disabled
)
7450 || b
->enable_state
== bp_disabled
))
7451 not_found_and_ok
= 1;
7453 if (!not_found_and_ok
)
7455 /* We surely don't want to warn about the same breakpoint
7456 10 times. One solution, implemented here, is disable
7457 the breakpoint on error. Another solution would be to
7458 have separate 'warning emitted' flag. Since this
7459 happens only when a binary has changed, I don't know
7460 which approach is better. */
7461 b
->enable_state
= bp_disabled
;
7462 throw_exception (e
);
7469 gdb_assert (sals
.nelts
== 1);
7470 resolve_sal_pc (&sals
.sals
[0]);
7471 if (b
->condition_not_parsed
&& s
&& s
[0])
7473 char *cond_string
= 0;
7475 find_condition_and_thread (s
, sals
.sals
[0].pc
,
7476 &cond_string
, &thread
);
7478 b
->cond_string
= cond_string
;
7480 b
->condition_not_parsed
= 0;
7482 expanded
= expand_line_sal_maybe (sals
.sals
[0]);
7483 update_breakpoint_locations (b
, expanded
);
7489 case bp_hardware_watchpoint
:
7490 case bp_read_watchpoint
:
7491 case bp_access_watchpoint
:
7492 /* Watchpoint can be either on expression using entirely global variables,
7493 or it can be on local variables.
7495 Watchpoints of the first kind are never auto-deleted, and even persist
7496 across program restarts. Since they can use variables from shared
7497 libraries, we need to reparse expression as libraries are loaded
7500 Watchpoints on local variables can also change meaning as result
7501 of solib event. For example, if a watchpoint uses both a local and
7502 a global variables in expression, it's a local watchpoint, but
7503 unloading of a shared library will make the expression invalid.
7504 This is not a very common use case, but we still re-evaluate
7505 expression, to avoid surprises to the user.
7507 Note that for local watchpoints, we re-evaluate it only if
7508 watchpoints frame id is still valid. If it's not, it means
7509 the watchpoint is out of scope and will be deleted soon. In fact,
7510 I'm not sure we'll ever be called in this case.
7512 If a local watchpoint's frame id is still valid, then
7513 b->exp_valid_block is likewise valid, and we can safely use it.
7515 Don't do anything about disabled watchpoints, since they will
7516 be reevaluated again when enabled. */
7517 update_watchpoint (b
, 1 /* reparse */);
7519 /* We needn't really do anything to reset these, since the mask
7520 that requests them is unaffected by e.g., new libraries being
7523 case bp_catch_vfork
:
7528 printf_filtered (_("Deleting unknown breakpoint type %d\n"), b
->type
);
7530 /* Delete overlay event breakpoints; they will be reset later by
7531 breakpoint_re_set. */
7532 case bp_overlay_event
:
7533 delete_breakpoint (b
);
7536 /* This breakpoint is special, it's set up when the inferior
7537 starts and we really don't want to touch it. */
7538 case bp_shlib_event
:
7540 /* Like bp_shlib_event, this breakpoint type is special.
7541 Once it is set up, we do not want to touch it. */
7542 case bp_thread_event
:
7544 /* Keep temporary breakpoints, which can be encountered when we step
7545 over a dlopen call and SOLIB_ADD is resetting the breakpoints.
7546 Otherwise these should have been blown away via the cleanup chain
7547 or by breakpoint_init_inferior when we rerun the executable. */
7550 case bp_watchpoint_scope
:
7552 case bp_step_resume
:
7554 case bp_longjmp_resume
:
7561 /* Re-set all breakpoints after symbols have been re-loaded. */
7563 breakpoint_re_set (void)
7565 struct breakpoint
*b
, *temp
;
7566 enum language save_language
;
7567 int save_input_radix
;
7569 save_language
= current_language
->la_language
;
7570 save_input_radix
= input_radix
;
7571 ALL_BREAKPOINTS_SAFE (b
, temp
)
7573 /* Format possible error msg */
7574 char *message
= xstrprintf ("Error in re-setting breakpoint %d: ",
7576 struct cleanup
*cleanups
= make_cleanup (xfree
, message
);
7577 catch_errors (breakpoint_re_set_one
, b
, message
, RETURN_MASK_ALL
);
7578 do_cleanups (cleanups
);
7580 set_language (save_language
);
7581 input_radix
= save_input_radix
;
7583 create_overlay_event_breakpoint ("_ovly_debug_event");
7586 /* Reset the thread number of this breakpoint:
7588 - If the breakpoint is for all threads, leave it as-is.
7589 - Else, reset it to the current thread for inferior_ptid. */
7591 breakpoint_re_set_thread (struct breakpoint
*b
)
7593 if (b
->thread
!= -1)
7595 if (in_thread_list (inferior_ptid
))
7596 b
->thread
= pid_to_thread_id (inferior_ptid
);
7600 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
7601 If from_tty is nonzero, it prints a message to that effect,
7602 which ends with a period (no newline). */
7605 set_ignore_count (int bptnum
, int count
, int from_tty
)
7607 struct breakpoint
*b
;
7613 if (b
->number
== bptnum
)
7615 b
->ignore_count
= count
;
7619 printf_filtered (_("Will stop next time breakpoint %d is reached."),
7621 else if (count
== 1)
7622 printf_filtered (_("Will ignore next crossing of breakpoint %d."),
7625 printf_filtered (_("Will ignore next %d crossings of breakpoint %d."),
7628 breakpoints_changed ();
7629 breakpoint_modify_event (b
->number
);
7633 error (_("No breakpoint number %d."), bptnum
);
7636 /* Clear the ignore counts of all breakpoints. */
7638 breakpoint_clear_ignore_counts (void)
7640 struct breakpoint
*b
;
7643 b
->ignore_count
= 0;
7646 /* Command to set ignore-count of breakpoint N to COUNT. */
7649 ignore_command (char *args
, int from_tty
)
7655 error_no_arg (_("a breakpoint number"));
7657 num
= get_number (&p
);
7659 error (_("bad breakpoint number: '%s'"), args
);
7661 error (_("Second argument (specified ignore-count) is missing."));
7663 set_ignore_count (num
,
7664 longest_to_int (value_as_long (parse_and_eval (p
))),
7667 printf_filtered ("\n");
7670 /* Call FUNCTION on each of the breakpoints
7671 whose numbers are given in ARGS. */
7674 map_breakpoint_numbers (char *args
, void (*function
) (struct breakpoint
*))
7679 struct breakpoint
*b
, *tmp
;
7683 error_no_arg (_("one or more breakpoint numbers"));
7690 num
= get_number_or_range (&p1
);
7693 warning (_("bad breakpoint number at or near '%s'"), p
);
7697 ALL_BREAKPOINTS_SAFE (b
, tmp
)
7698 if (b
->number
== num
)
7700 struct breakpoint
*related_breakpoint
= b
->related_breakpoint
;
7703 if (related_breakpoint
)
7704 function (related_breakpoint
);
7708 printf_unfiltered (_("No breakpoint number %d.\n"), num
);
7714 static struct bp_location
*
7715 find_location_by_number (char *number
)
7717 char *dot
= strchr (number
, '.');
7721 struct breakpoint
*b
;
7722 struct bp_location
*loc
;
7727 bp_num
= get_number_or_range (&p1
);
7729 error (_("Bad breakpoint number '%s'"), number
);
7732 if (b
->number
== bp_num
)
7737 if (!b
|| b
->number
!= bp_num
)
7738 error (_("Bad breakpoint number '%s'"), number
);
7741 loc_num
= get_number_or_range (&p1
);
7743 error (_("Bad breakpoint location number '%s'"), number
);
7747 for (;loc_num
&& loc
; --loc_num
, loc
= loc
->next
)
7750 error (_("Bad breakpoint location number '%s'"), dot
+1);
7756 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
7757 If from_tty is nonzero, it prints a message to that effect,
7758 which ends with a period (no newline). */
7761 disable_breakpoint (struct breakpoint
*bpt
)
7763 /* Never disable a watchpoint scope breakpoint; we want to
7764 hit them when we leave scope so we can delete both the
7765 watchpoint and its scope breakpoint at that time. */
7766 if (bpt
->type
== bp_watchpoint_scope
)
7769 /* You can't disable permanent breakpoints. */
7770 if (bpt
->enable_state
== bp_permanent
)
7773 bpt
->enable_state
= bp_disabled
;
7775 update_global_location_list ();
7777 if (deprecated_modify_breakpoint_hook
)
7778 deprecated_modify_breakpoint_hook (bpt
);
7779 breakpoint_modify_event (bpt
->number
);
7783 disable_command (char *args
, int from_tty
)
7785 struct breakpoint
*bpt
;
7787 ALL_BREAKPOINTS (bpt
)
7791 warning (_("attempted to disable apparently deleted breakpoint #%d?"),
7796 case bp_catch_unload
:
7798 case bp_catch_vfork
:
7800 case bp_hardware_breakpoint
:
7802 case bp_hardware_watchpoint
:
7803 case bp_read_watchpoint
:
7804 case bp_access_watchpoint
:
7805 disable_breakpoint (bpt
);
7809 else if (strchr (args
, '.'))
7811 struct bp_location
*loc
= find_location_by_number (args
);
7814 update_global_location_list ();
7817 map_breakpoint_numbers (args
, disable_breakpoint
);
7821 do_enable_breakpoint (struct breakpoint
*bpt
, enum bpdisp disposition
)
7823 int target_resources_ok
, other_type_used
;
7826 if (bpt
->type
== bp_hardware_breakpoint
)
7829 i
= hw_breakpoint_used_count ();
7830 target_resources_ok
=
7831 TARGET_CAN_USE_HARDWARE_WATCHPOINT (bp_hardware_breakpoint
,
7833 if (target_resources_ok
== 0)
7834 error (_("No hardware breakpoint support in the target."));
7835 else if (target_resources_ok
< 0)
7836 error (_("Hardware breakpoints used exceeds limit."));
7839 if (bpt
->type
== bp_watchpoint
||
7840 bpt
->type
== bp_hardware_watchpoint
||
7841 bpt
->type
== bp_read_watchpoint
||
7842 bpt
->type
== bp_access_watchpoint
)
7844 struct frame_id saved_frame_id
;
7846 saved_frame_id
= get_frame_id (get_selected_frame (NULL
));
7847 if (bpt
->exp_valid_block
!= NULL
)
7849 struct frame_info
*fr
=
7850 fr
= frame_find_by_id (bpt
->watchpoint_frame
);
7853 printf_filtered (_("\
7854 Cannot enable watchpoint %d because the block in which its expression\n\
7855 is valid is not currently in scope.\n"), bpt
->number
);
7862 value_free (bpt
->val
);
7863 mark
= value_mark ();
7864 fetch_watchpoint_value (bpt
->exp
, &bpt
->val
, NULL
, NULL
);
7866 release_value (bpt
->val
);
7869 if (bpt
->type
== bp_hardware_watchpoint
||
7870 bpt
->type
== bp_read_watchpoint
||
7871 bpt
->type
== bp_access_watchpoint
)
7873 int i
= hw_watchpoint_used_count (bpt
->type
, &other_type_used
);
7874 int mem_cnt
= can_use_hardware_watchpoint (bpt
->val
);
7876 /* Hack around 'unused var' error for some targets here */
7877 (void) mem_cnt
, (void) i
;
7878 target_resources_ok
= TARGET_CAN_USE_HARDWARE_WATCHPOINT (
7879 bpt
->type
, i
+ mem_cnt
, other_type_used
);
7880 /* we can consider of type is bp_hardware_watchpoint, convert to
7881 bp_watchpoint in the following condition */
7882 if (target_resources_ok
< 0)
7884 printf_filtered (_("\
7885 Cannot enable watchpoint %d because target watch resources\n\
7886 have been allocated for other watchpoints.\n"), bpt
->number
);
7887 value_free_to_mark (mark
);
7892 select_frame (frame_find_by_id (saved_frame_id
));
7893 value_free_to_mark (mark
);
7896 if (bpt
->enable_state
!= bp_permanent
)
7897 bpt
->enable_state
= bp_enabled
;
7898 bpt
->disposition
= disposition
;
7899 update_global_location_list ();
7900 breakpoints_changed ();
7902 if (deprecated_modify_breakpoint_hook
)
7903 deprecated_modify_breakpoint_hook (bpt
);
7904 breakpoint_modify_event (bpt
->number
);
7909 enable_breakpoint (struct breakpoint
*bpt
)
7911 do_enable_breakpoint (bpt
, bpt
->disposition
);
7914 /* The enable command enables the specified breakpoints (or all defined
7915 breakpoints) so they once again become (or continue to be) effective
7916 in stopping the inferior. */
7919 enable_command (char *args
, int from_tty
)
7921 struct breakpoint
*bpt
;
7923 ALL_BREAKPOINTS (bpt
)
7927 warning (_("attempted to enable apparently deleted breakpoint #%d?"),
7932 case bp_catch_unload
:
7934 case bp_catch_vfork
:
7936 case bp_hardware_breakpoint
:
7938 case bp_hardware_watchpoint
:
7939 case bp_read_watchpoint
:
7940 case bp_access_watchpoint
:
7941 enable_breakpoint (bpt
);
7945 else if (strchr (args
, '.'))
7947 struct bp_location
*loc
= find_location_by_number (args
);
7950 update_global_location_list ();
7953 map_breakpoint_numbers (args
, enable_breakpoint
);
7957 enable_once_breakpoint (struct breakpoint
*bpt
)
7959 do_enable_breakpoint (bpt
, disp_disable
);
7963 enable_once_command (char *args
, int from_tty
)
7965 map_breakpoint_numbers (args
, enable_once_breakpoint
);
7969 enable_delete_breakpoint (struct breakpoint
*bpt
)
7971 do_enable_breakpoint (bpt
, disp_del
);
7975 enable_delete_command (char *args
, int from_tty
)
7977 map_breakpoint_numbers (args
, enable_delete_breakpoint
);
7981 set_breakpoint_cmd (char *args
, int from_tty
)
7986 show_breakpoint_cmd (char *args
, int from_tty
)
7990 /* Use default_breakpoint_'s, or nothing if they aren't valid. */
7992 struct symtabs_and_lines
7993 decode_line_spec_1 (char *string
, int funfirstline
)
7995 struct symtabs_and_lines sals
;
7997 error (_("Empty line specification."));
7998 if (default_breakpoint_valid
)
7999 sals
= decode_line_1 (&string
, funfirstline
,
8000 default_breakpoint_symtab
,
8001 default_breakpoint_line
,
8002 (char ***) NULL
, NULL
);
8004 sals
= decode_line_1 (&string
, funfirstline
,
8005 (struct symtab
*) NULL
, 0, (char ***) NULL
, NULL
);
8007 error (_("Junk at end of line specification: %s"), string
);
8011 /* Create and insert a raw software breakpoint at PC. Return an
8012 identifier, which should be used to remove the breakpoint later.
8013 In general, places which call this should be using something on the
8014 breakpoint chain instead; this function should be eliminated
8018 deprecated_insert_raw_breakpoint (CORE_ADDR pc
)
8020 struct bp_target_info
*bp_tgt
;
8022 bp_tgt
= xmalloc (sizeof (struct bp_target_info
));
8023 memset (bp_tgt
, 0, sizeof (struct bp_target_info
));
8025 bp_tgt
->placed_address
= pc
;
8026 if (target_insert_breakpoint (bp_tgt
) != 0)
8028 /* Could not insert the breakpoint. */
8036 /* Remove a breakpoint BP inserted by deprecated_insert_raw_breakpoint. */
8039 deprecated_remove_raw_breakpoint (void *bp
)
8041 struct bp_target_info
*bp_tgt
= bp
;
8044 ret
= target_remove_breakpoint (bp_tgt
);
8050 /* One (or perhaps two) breakpoints used for software single stepping. */
8052 static void *single_step_breakpoints
[2];
8054 /* Create and insert a breakpoint for software single step. */
8057 insert_single_step_breakpoint (CORE_ADDR next_pc
)
8061 if (single_step_breakpoints
[0] == NULL
)
8062 bpt_p
= &single_step_breakpoints
[0];
8065 gdb_assert (single_step_breakpoints
[1] == NULL
);
8066 bpt_p
= &single_step_breakpoints
[1];
8069 /* NOTE drow/2006-04-11: A future improvement to this function would be
8070 to only create the breakpoints once, and actually put them on the
8071 breakpoint chain. That would let us use set_raw_breakpoint. We could
8072 adjust the addresses each time they were needed. Doing this requires
8073 corresponding changes elsewhere where single step breakpoints are
8074 handled, however. So, for now, we use this. */
8076 *bpt_p
= deprecated_insert_raw_breakpoint (next_pc
);
8078 error (_("Could not insert single-step breakpoint at 0x%s"),
8079 paddr_nz (next_pc
));
8082 /* Remove and delete any breakpoints used for software single step. */
8085 remove_single_step_breakpoints (void)
8087 gdb_assert (single_step_breakpoints
[0] != NULL
);
8089 /* See insert_single_step_breakpoint for more about this deprecated
8091 deprecated_remove_raw_breakpoint (single_step_breakpoints
[0]);
8092 single_step_breakpoints
[0] = NULL
;
8094 if (single_step_breakpoints
[1] != NULL
)
8096 deprecated_remove_raw_breakpoint (single_step_breakpoints
[1]);
8097 single_step_breakpoints
[1] = NULL
;
8101 /* Check whether a software single-step breakpoint is inserted at PC. */
8104 single_step_breakpoint_inserted_here_p (CORE_ADDR pc
)
8108 for (i
= 0; i
< 2; i
++)
8110 struct bp_target_info
*bp_tgt
= single_step_breakpoints
[i
];
8111 if (bp_tgt
&& bp_tgt
->placed_address
== pc
)
8118 int breakpoints_always_inserted_mode (void)
8120 return always_inserted_mode
;
8124 /* This help string is used for the break, hbreak, tbreak and thbreak commands.
8125 It is defined as a macro to prevent duplication.
8126 COMMAND should be a string constant containing the name of the command. */
8127 #define BREAK_ARGS_HELP(command) \
8128 command" [LOCATION] [thread THREADNUM] [if CONDITION]\n\
8129 LOCATION may be a line number, function name, or \"*\" and an address.\n\
8130 If a line number is specified, break at start of code for that line.\n\
8131 If a function is specified, break at start of code for that function.\n\
8132 If an address is specified, break at that exact address.\n\
8133 With no LOCATION, uses current execution address of selected stack frame.\n\
8134 This is useful for breaking on return to a stack frame.\n\
8136 THREADNUM is the number from \"info threads\".\n\
8137 CONDITION is a boolean expression.\n\
8139 Multiple breakpoints at one place are permitted, and useful if conditional.\n\
8141 Do \"help breakpoints\" for info on other commands dealing with breakpoints."
8144 _initialize_breakpoint (void)
8146 static struct cmd_list_element
*breakpoint_set_cmdlist
;
8147 static struct cmd_list_element
*breakpoint_show_cmdlist
;
8148 struct cmd_list_element
*c
;
8150 observer_attach_solib_unloaded (disable_breakpoints_in_unloaded_shlib
);
8152 breakpoint_chain
= 0;
8153 /* Don't bother to call set_breakpoint_count. $bpnum isn't useful
8154 before a breakpoint is set. */
8155 breakpoint_count
= 0;
8157 add_com ("ignore", class_breakpoint
, ignore_command
, _("\
8158 Set ignore-count of breakpoint number N to COUNT.\n\
8159 Usage is `ignore N COUNT'."));
8161 add_com_alias ("bc", "ignore", class_breakpoint
, 1);
8163 add_com ("commands", class_breakpoint
, commands_command
, _("\
8164 Set commands to be executed when a breakpoint is hit.\n\
8165 Give breakpoint number as argument after \"commands\".\n\
8166 With no argument, the targeted breakpoint is the last one set.\n\
8167 The commands themselves follow starting on the next line.\n\
8168 Type a line containing \"end\" to indicate the end of them.\n\
8169 Give \"silent\" as the first line to make the breakpoint silent;\n\
8170 then no output is printed when it is hit, except what the commands print."));
8172 add_com ("condition", class_breakpoint
, condition_command
, _("\
8173 Specify breakpoint number N to break only if COND is true.\n\
8174 Usage is `condition N COND', where N is an integer and COND is an\n\
8175 expression to be evaluated whenever breakpoint N is reached."));
8177 c
= add_com ("tbreak", class_breakpoint
, tbreak_command
, _("\
8178 Set a temporary breakpoint.\n\
8179 Like \"break\" except the breakpoint is only temporary,\n\
8180 so it will be deleted when hit. Equivalent to \"break\" followed\n\
8181 by using \"enable delete\" on the breakpoint number.\n\
8183 BREAK_ARGS_HELP ("tbreak")));
8184 set_cmd_completer (c
, location_completer
);
8186 c
= add_com ("hbreak", class_breakpoint
, hbreak_command
, _("\
8187 Set a hardware assisted breakpoint.\n\
8188 Like \"break\" except the breakpoint requires hardware support,\n\
8189 some target hardware may not have this support.\n\
8191 BREAK_ARGS_HELP ("hbreak")));
8192 set_cmd_completer (c
, location_completer
);
8194 c
= add_com ("thbreak", class_breakpoint
, thbreak_command
, _("\
8195 Set a temporary hardware assisted breakpoint.\n\
8196 Like \"hbreak\" except the breakpoint is only temporary,\n\
8197 so it will be deleted when hit.\n\
8199 BREAK_ARGS_HELP ("thbreak")));
8200 set_cmd_completer (c
, location_completer
);
8202 add_prefix_cmd ("enable", class_breakpoint
, enable_command
, _("\
8203 Enable some breakpoints.\n\
8204 Give breakpoint numbers (separated by spaces) as arguments.\n\
8205 With no subcommand, breakpoints are enabled until you command otherwise.\n\
8206 This is used to cancel the effect of the \"disable\" command.\n\
8207 With a subcommand you can enable temporarily."),
8208 &enablelist
, "enable ", 1, &cmdlist
);
8210 add_com ("ab", class_breakpoint
, enable_command
, _("\
8211 Enable some breakpoints.\n\
8212 Give breakpoint numbers (separated by spaces) as arguments.\n\
8213 With no subcommand, breakpoints are enabled until you command otherwise.\n\
8214 This is used to cancel the effect of the \"disable\" command.\n\
8215 With a subcommand you can enable temporarily."));
8217 add_com_alias ("en", "enable", class_breakpoint
, 1);
8219 add_abbrev_prefix_cmd ("breakpoints", class_breakpoint
, enable_command
, _("\
8220 Enable some breakpoints.\n\
8221 Give breakpoint numbers (separated by spaces) as arguments.\n\
8222 This is used to cancel the effect of the \"disable\" command.\n\
8223 May be abbreviated to simply \"enable\".\n"),
8224 &enablebreaklist
, "enable breakpoints ", 1, &enablelist
);
8226 add_cmd ("once", no_class
, enable_once_command
, _("\
8227 Enable breakpoints for one hit. Give breakpoint numbers.\n\
8228 If a breakpoint is hit while enabled in this fashion, it becomes disabled."),
8231 add_cmd ("delete", no_class
, enable_delete_command
, _("\
8232 Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
8233 If a breakpoint is hit while enabled in this fashion, it is deleted."),
8236 add_cmd ("delete", no_class
, enable_delete_command
, _("\
8237 Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
8238 If a breakpoint is hit while enabled in this fashion, it is deleted."),
8241 add_cmd ("once", no_class
, enable_once_command
, _("\
8242 Enable breakpoints for one hit. Give breakpoint numbers.\n\
8243 If a breakpoint is hit while enabled in this fashion, it becomes disabled."),
8246 add_prefix_cmd ("disable", class_breakpoint
, disable_command
, _("\
8247 Disable some breakpoints.\n\
8248 Arguments are breakpoint numbers with spaces in between.\n\
8249 To disable all breakpoints, give no argument.\n\
8250 A disabled breakpoint is not forgotten, but has no effect until reenabled."),
8251 &disablelist
, "disable ", 1, &cmdlist
);
8252 add_com_alias ("dis", "disable", class_breakpoint
, 1);
8253 add_com_alias ("disa", "disable", class_breakpoint
, 1);
8255 add_com ("sb", class_breakpoint
, disable_command
, _("\
8256 Disable some breakpoints.\n\
8257 Arguments are breakpoint numbers with spaces in between.\n\
8258 To disable all breakpoints, give no argument.\n\
8259 A disabled breakpoint is not forgotten, but has no effect until reenabled."));
8261 add_cmd ("breakpoints", class_alias
, disable_command
, _("\
8262 Disable some breakpoints.\n\
8263 Arguments are breakpoint numbers with spaces in between.\n\
8264 To disable all breakpoints, give no argument.\n\
8265 A disabled breakpoint is not forgotten, but has no effect until reenabled.\n\
8266 This command may be abbreviated \"disable\"."),
8269 add_prefix_cmd ("delete", class_breakpoint
, delete_command
, _("\
8270 Delete some breakpoints or auto-display expressions.\n\
8271 Arguments are breakpoint numbers with spaces in between.\n\
8272 To delete all breakpoints, give no argument.\n\
8274 Also a prefix command for deletion of other GDB objects.\n\
8275 The \"unset\" command is also an alias for \"delete\"."),
8276 &deletelist
, "delete ", 1, &cmdlist
);
8277 add_com_alias ("d", "delete", class_breakpoint
, 1);
8278 add_com_alias ("del", "delete", class_breakpoint
, 1);
8280 add_com ("db", class_breakpoint
, delete_command
, _("\
8281 Delete some breakpoints.\n\
8282 Arguments are breakpoint numbers with spaces in between.\n\
8283 To delete all breakpoints, give no argument.\n"));
8285 add_cmd ("breakpoints", class_alias
, delete_command
, _("\
8286 Delete some breakpoints or auto-display expressions.\n\
8287 Arguments are breakpoint numbers with spaces in between.\n\
8288 To delete all breakpoints, give no argument.\n\
8289 This command may be abbreviated \"delete\"."),
8292 add_com ("clear", class_breakpoint
, clear_command
, _("\
8293 Clear breakpoint at specified line or function.\n\
8294 Argument may be line number, function name, or \"*\" and an address.\n\
8295 If line number is specified, all breakpoints in that line are cleared.\n\
8296 If function is specified, breakpoints at beginning of function are cleared.\n\
8297 If an address is specified, breakpoints at that address are cleared.\n\
8299 With no argument, clears all breakpoints in the line that the selected frame\n\
8302 See also the \"delete\" command which clears breakpoints by number."));
8304 c
= add_com ("break", class_breakpoint
, break_command
, _("\
8305 Set breakpoint at specified line or function.\n"
8306 BREAK_ARGS_HELP ("break")));
8307 set_cmd_completer (c
, location_completer
);
8309 add_com_alias ("b", "break", class_run
, 1);
8310 add_com_alias ("br", "break", class_run
, 1);
8311 add_com_alias ("bre", "break", class_run
, 1);
8312 add_com_alias ("brea", "break", class_run
, 1);
8316 add_com_alias ("ba", "break", class_breakpoint
, 1);
8317 add_com_alias ("bu", "ubreak", class_breakpoint
, 1);
8322 add_abbrev_prefix_cmd ("stop", class_breakpoint
, stop_command
, _("\
8323 Break in function/address or break at a line in the current file."),
8324 &stoplist
, "stop ", 1, &cmdlist
);
8325 add_cmd ("in", class_breakpoint
, stopin_command
,
8326 _("Break in function or address."), &stoplist
);
8327 add_cmd ("at", class_breakpoint
, stopat_command
,
8328 _("Break at a line in the current file."), &stoplist
);
8329 add_com ("status", class_info
, breakpoints_info
, _("\
8330 Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
8331 The \"Type\" column indicates one of:\n\
8332 \tbreakpoint - normal breakpoint\n\
8333 \twatchpoint - watchpoint\n\
8334 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
8335 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
8336 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
8337 address and file/line number respectively.\n\
8339 Convenience variable \"$_\" and default examine address for \"x\"\n\
8340 are set to the address of the last breakpoint listed unless the command\n\
8341 is prefixed with \"server \".\n\n\
8342 Convenience variable \"$bpnum\" contains the number of the last\n\
8346 add_info ("breakpoints", breakpoints_info
, _("\
8347 Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
8348 The \"Type\" column indicates one of:\n\
8349 \tbreakpoint - normal breakpoint\n\
8350 \twatchpoint - watchpoint\n\
8351 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
8352 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
8353 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
8354 address and file/line number respectively.\n\
8356 Convenience variable \"$_\" and default examine address for \"x\"\n\
8357 are set to the address of the last breakpoint listed unless the command\n\
8358 is prefixed with \"server \".\n\n\
8359 Convenience variable \"$bpnum\" contains the number of the last\n\
8363 add_com ("lb", class_breakpoint
, breakpoints_info
, _("\
8364 Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
8365 The \"Type\" column indicates one of:\n\
8366 \tbreakpoint - normal breakpoint\n\
8367 \twatchpoint - watchpoint\n\
8368 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
8369 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
8370 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
8371 address and file/line number respectively.\n\
8373 Convenience variable \"$_\" and default examine address for \"x\"\n\
8374 are set to the address of the last breakpoint listed unless the command\n\
8375 is prefixed with \"server \".\n\n\
8376 Convenience variable \"$bpnum\" contains the number of the last\n\
8379 add_cmd ("breakpoints", class_maintenance
, maintenance_info_breakpoints
, _("\
8380 Status of all breakpoints, or breakpoint number NUMBER.\n\
8381 The \"Type\" column indicates one of:\n\
8382 \tbreakpoint - normal breakpoint\n\
8383 \twatchpoint - watchpoint\n\
8384 \tlongjmp - internal breakpoint used to step through longjmp()\n\
8385 \tlongjmp resume - internal breakpoint at the target of longjmp()\n\
8386 \tuntil - internal breakpoint used by the \"until\" command\n\
8387 \tfinish - internal breakpoint used by the \"finish\" command\n\
8388 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
8389 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
8390 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
8391 address and file/line number respectively.\n\
8393 Convenience variable \"$_\" and default examine address for \"x\"\n\
8394 are set to the address of the last breakpoint listed unless the command\n\
8395 is prefixed with \"server \".\n\n\
8396 Convenience variable \"$bpnum\" contains the number of the last\n\
8398 &maintenanceinfolist
);
8400 add_com ("catch", class_breakpoint
, catch_command
, _("\
8401 Set catchpoints to catch events.\n\
8402 Raised signals may be caught:\n\
8403 \tcatch signal - all signals\n\
8404 \tcatch signal <signame> - a particular signal\n\
8405 Raised exceptions may be caught:\n\
8406 \tcatch throw - all exceptions, when thrown\n\
8407 \tcatch throw <exceptname> - a particular exception, when thrown\n\
8408 \tcatch catch - all exceptions, when caught\n\
8409 \tcatch catch <exceptname> - a particular exception, when caught\n\
8410 Thread or process events may be caught:\n\
8411 \tcatch thread_start - any threads, just after creation\n\
8412 \tcatch thread_exit - any threads, just before expiration\n\
8413 \tcatch thread_join - any threads, just after joins\n\
8414 Process events may be caught:\n\
8415 \tcatch start - any processes, just after creation\n\
8416 \tcatch exit - any processes, just before expiration\n\
8417 \tcatch fork - calls to fork()\n\
8418 \tcatch vfork - calls to vfork()\n\
8419 \tcatch exec - calls to exec()\n\
8420 Dynamically-linked library events may be caught:\n\
8421 \tcatch load - loads of any library\n\
8422 \tcatch load <libname> - loads of a particular library\n\
8423 \tcatch unload - unloads of any library\n\
8424 \tcatch unload <libname> - unloads of a particular library\n\
8425 The act of your program's execution stopping may also be caught:\n\
8427 C++ exceptions may be caught:\n\
8428 \tcatch throw - all exceptions, when thrown\n\
8429 \tcatch catch - all exceptions, when caught\n\
8430 Ada exceptions may be caught:\n\
8431 \tcatch exception - all exceptions, when raised\n\
8432 \tcatch exception <name> - a particular exception, when raised\n\
8433 \tcatch exception unhandled - all unhandled exceptions, when raised\n\
8434 \tcatch assert - all failed assertions, when raised\n\
8436 Do \"help set follow-fork-mode\" for info on debugging your program\n\
8437 after a fork or vfork is caught.\n\n\
8438 Do \"help breakpoints\" for info on other commands dealing with breakpoints."));
8440 add_com ("tcatch", class_breakpoint
, tcatch_command
, _("\
8441 Set temporary catchpoints to catch events.\n\
8442 Args like \"catch\" command.\n\
8443 Like \"catch\" except the catchpoint is only temporary,\n\
8444 so it will be deleted when hit. Equivalent to \"catch\" followed\n\
8445 by using \"enable delete\" on the catchpoint number."));
8447 c
= add_com ("watch", class_breakpoint
, watch_command
, _("\
8448 Set a watchpoint for an expression.\n\
8449 A watchpoint stops execution of your program whenever the value of\n\
8450 an expression changes."));
8451 set_cmd_completer (c
, expression_completer
);
8453 c
= add_com ("rwatch", class_breakpoint
, rwatch_command
, _("\
8454 Set a read watchpoint for an expression.\n\
8455 A watchpoint stops execution of your program whenever the value of\n\
8456 an expression is read."));
8457 set_cmd_completer (c
, expression_completer
);
8459 c
= add_com ("awatch", class_breakpoint
, awatch_command
, _("\
8460 Set a watchpoint for an expression.\n\
8461 A watchpoint stops execution of your program whenever the value of\n\
8462 an expression is either read or written."));
8463 set_cmd_completer (c
, expression_completer
);
8465 add_info ("watchpoints", breakpoints_info
,
8466 _("Synonym for ``info breakpoints''."));
8469 /* XXX: cagney/2005-02-23: This should be a boolean, and should
8470 respond to changes - contrary to the description. */
8471 add_setshow_zinteger_cmd ("can-use-hw-watchpoints", class_support
,
8472 &can_use_hw_watchpoints
, _("\
8473 Set debugger's willingness to use watchpoint hardware."), _("\
8474 Show debugger's willingness to use watchpoint hardware."), _("\
8475 If zero, gdb will not use hardware for new watchpoints, even if\n\
8476 such is available. (However, any hardware watchpoints that were\n\
8477 created before setting this to nonzero, will continue to use watchpoint\n\
8480 show_can_use_hw_watchpoints
,
8481 &setlist
, &showlist
);
8483 can_use_hw_watchpoints
= 1;
8485 add_prefix_cmd ("breakpoint", class_maintenance
, set_breakpoint_cmd
, _("\
8486 Breakpoint specific settings\n\
8487 Configure various breakpoint-specific variables such as\n\
8488 pending breakpoint behavior"),
8489 &breakpoint_set_cmdlist
, "set breakpoint ",
8490 0/*allow-unknown*/, &setlist
);
8491 add_prefix_cmd ("breakpoint", class_maintenance
, show_breakpoint_cmd
, _("\
8492 Breakpoint specific settings\n\
8493 Configure various breakpoint-specific variables such as\n\
8494 pending breakpoint behavior"),
8495 &breakpoint_show_cmdlist
, "show breakpoint ",
8496 0/*allow-unknown*/, &showlist
);
8498 add_setshow_auto_boolean_cmd ("pending", no_class
,
8499 &pending_break_support
, _("\
8500 Set debugger's behavior regarding pending breakpoints."), _("\
8501 Show debugger's behavior regarding pending breakpoints."), _("\
8502 If on, an unrecognized breakpoint location will cause gdb to create a\n\
8503 pending breakpoint. If off, an unrecognized breakpoint location results in\n\
8504 an error. If auto, an unrecognized breakpoint location results in a\n\
8505 user-query to see if a pending breakpoint should be created."),
8507 show_pending_break_support
,
8508 &breakpoint_set_cmdlist
,
8509 &breakpoint_show_cmdlist
);
8511 pending_break_support
= AUTO_BOOLEAN_AUTO
;
8513 add_setshow_boolean_cmd ("auto-hw", no_class
,
8514 &automatic_hardware_breakpoints
, _("\
8515 Set automatic usage of hardware breakpoints."), _("\
8516 Show automatic usage of hardware breakpoints."), _("\
8517 If set, the debugger will automatically use hardware breakpoints for\n\
8518 breakpoints set with \"break\" but falling in read-only memory. If not set,\n\
8519 a warning will be emitted for such breakpoints."),
8521 show_automatic_hardware_breakpoints
,
8522 &breakpoint_set_cmdlist
,
8523 &breakpoint_show_cmdlist
);
8525 add_setshow_boolean_cmd ("always-inserted", class_support
,
8526 &always_inserted_mode
, _("\
8527 Set mode for inserting breakpoints."), _("\
8528 Show mode for inserting breakpoints."), _("\
8529 When this mode is off (which is the default), breakpoints are inserted in\n\
8530 inferior when it is resumed, and removed when execution stops. When this\n\
8531 mode is on, breakpoints are inserted immediately and removed only when\n\
8532 the user deletes the breakpoint."),
8534 &show_always_inserted_mode
,
8535 &breakpoint_set_cmdlist
,
8536 &breakpoint_show_cmdlist
);
8538 automatic_hardware_breakpoints
= 1;