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 /* Prototypes for local functions. */
65 static void until_break_command_continuation (void *arg
, int error
);
67 static void catch_command_1 (char *, int, int);
69 static void enable_delete_command (char *, int);
71 static void enable_delete_breakpoint (struct breakpoint
*);
73 static void enable_once_command (char *, int);
75 static void enable_once_breakpoint (struct breakpoint
*);
77 static void disable_command (char *, int);
79 static void enable_command (char *, int);
81 static void map_breakpoint_numbers (char *, void (*)(struct breakpoint
*));
83 static void ignore_command (char *, int);
85 static int breakpoint_re_set_one (void *);
87 static void clear_command (char *, int);
89 static void catch_command (char *, int);
91 static void watch_command (char *, int);
93 static int can_use_hardware_watchpoint (struct value
*);
95 static void break_command_1 (char *, int, int);
97 static void mention (struct breakpoint
*);
99 struct breakpoint
*set_raw_breakpoint (struct symtab_and_line
, enum bptype
);
101 static void check_duplicates (struct breakpoint
*);
103 static void breakpoint_adjustment_warning (CORE_ADDR
, CORE_ADDR
, int, int);
105 static CORE_ADDR
adjust_breakpoint_address (CORE_ADDR bpaddr
,
108 static void describe_other_breakpoints (CORE_ADDR
, asection
*, int);
110 static void breakpoints_info (char *, int);
112 static void breakpoint_1 (int, int);
114 static bpstat
bpstat_alloc (const struct bp_location
*, bpstat
);
116 static int breakpoint_cond_eval (void *);
118 static void cleanup_executing_breakpoints (void *);
120 static void commands_command (char *, int);
122 static void condition_command (char *, int);
124 static int get_number_trailer (char **, int);
126 void set_breakpoint_count (int);
135 static int remove_breakpoint (struct bp_location
*, insertion_state_t
);
137 static enum print_stop_action
print_it_typical (bpstat
);
139 static enum print_stop_action
print_bp_stop_message (bpstat bs
);
141 static int watchpoint_check (void *);
143 static void maintenance_info_breakpoints (char *, int);
145 static void create_overlay_event_breakpoint (char *);
147 static int hw_breakpoint_used_count (void);
149 static int hw_watchpoint_used_count (enum bptype
, int *);
151 static void hbreak_command (char *, int);
153 static void thbreak_command (char *, int);
155 static void watch_command_1 (char *, int, int);
157 static void rwatch_command (char *, int);
159 static void awatch_command (char *, int);
161 static void do_enable_breakpoint (struct breakpoint
*, enum bpdisp
);
163 static void create_fork_vfork_event_catchpoint (int tempflag
,
165 enum bptype bp_kind
);
167 static void stop_command (char *arg
, int from_tty
);
169 static void stopin_command (char *arg
, int from_tty
);
171 static void stopat_command (char *arg
, int from_tty
);
173 static char *ep_find_event_name_end (char *arg
);
175 static char *ep_parse_optional_if_clause (char **arg
);
177 static char *ep_parse_optional_filename (char **arg
);
179 static void catch_exception_command_1 (enum exception_event_kind ex_event
,
180 char *arg
, int tempflag
, int from_tty
);
182 static void tcatch_command (char *arg
, int from_tty
);
184 static void ep_skip_leading_whitespace (char **s
);
186 static int single_step_breakpoint_inserted_here_p (CORE_ADDR pc
);
188 static void free_bp_location (struct bp_location
*loc
);
190 static struct bp_location
*
191 allocate_bp_location (struct breakpoint
*bpt
, enum bptype bp_type
);
193 static void update_global_location_list (int);
195 static void update_global_location_list_nothrow (int);
197 static int is_hardware_watchpoint (struct breakpoint
*bpt
);
199 static void insert_breakpoint_locations (void);
202 bpdisp_text (enum bpdisp disp
)
204 /* NOTE: the following values are a part of MI protocol and represent
205 values of 'disp' field returned when inferior stops at a breakpoint. */
206 static char *bpdisps
[] = {"del", "dstp", "dis", "keep"};
207 return bpdisps
[(int) disp
];
210 /* Prototypes for exported functions. */
211 /* If FALSE, gdb will not use hardware support for watchpoints, even
212 if such is available. */
213 static int can_use_hw_watchpoints
;
216 show_can_use_hw_watchpoints (struct ui_file
*file
, int from_tty
,
217 struct cmd_list_element
*c
,
220 fprintf_filtered (file
, _("\
221 Debugger's willingness to use watchpoint hardware is %s.\n"),
225 /* If AUTO_BOOLEAN_FALSE, gdb will not attempt to create pending breakpoints.
226 If AUTO_BOOLEAN_TRUE, gdb will automatically create pending breakpoints
227 for unrecognized breakpoint locations.
228 If AUTO_BOOLEAN_AUTO, gdb will query when breakpoints are unrecognized. */
229 static enum auto_boolean pending_break_support
;
231 show_pending_break_support (struct ui_file
*file
, int from_tty
,
232 struct cmd_list_element
*c
,
235 fprintf_filtered (file
, _("\
236 Debugger's behavior regarding pending breakpoints is %s.\n"),
240 /* If 1, gdb will automatically use hardware breakpoints for breakpoints
241 set with "break" but falling in read-only memory.
242 If 0, gdb will warn about such breakpoints, but won't automatically
243 use hardware breakpoints. */
244 static int automatic_hardware_breakpoints
;
246 show_automatic_hardware_breakpoints (struct ui_file
*file
, int from_tty
,
247 struct cmd_list_element
*c
,
250 fprintf_filtered (file
, _("\
251 Automatic usage of hardware breakpoints is %s.\n"),
255 /* If 1, gdb will keep breakpoints inserted even as inferior is stopped,
256 and immediately insert any new breakpoints. If 0, gdb will insert
257 breakpoints into inferior only when resuming it, and will remove
258 breakpoints upon stop. */
259 static int always_inserted_mode
= 0;
261 show_always_inserted_mode (struct ui_file
*file
, int from_tty
,
262 struct cmd_list_element
*c
, const char *value
)
264 fprintf_filtered (file
, _("Always inserted breakpoint mode is %s.\n"), value
);
268 void _initialize_breakpoint (void);
270 extern int addressprint
; /* Print machine addresses? */
272 /* Are we executing breakpoint commands? */
273 static int executing_breakpoint_commands
;
275 /* Are overlay event breakpoints enabled? */
276 static int overlay_events_enabled
;
278 /* Walk the following statement or block through all breakpoints.
279 ALL_BREAKPOINTS_SAFE does so even if the statment deletes the current
282 #define ALL_BREAKPOINTS(B) for (B = breakpoint_chain; B; B = B->next)
284 #define ALL_BREAKPOINTS_SAFE(B,TMP) \
285 for (B = breakpoint_chain; \
286 B ? (TMP=B->next, 1): 0; \
289 /* Similar iterators for the low-level breakpoints. */
291 #define ALL_BP_LOCATIONS(B) for (B = bp_location_chain; B; B = B->global_next)
293 #define ALL_BP_LOCATIONS_SAFE(B,TMP) \
294 for (B = bp_location_chain; \
295 B ? (TMP=B->global_next, 1): 0; \
298 /* True if breakpoint hit counts should be displayed in breakpoint info. */
300 int show_breakpoint_hit_counts
= 1;
302 /* Chains of all breakpoints defined. */
304 struct breakpoint
*breakpoint_chain
;
306 struct bp_location
*bp_location_chain
;
308 /* The locations that no longer correspond to any breakpoint,
309 unlinked from bp_location_chain, but for which a hit
310 may still be reported by a target. */
311 VEC(bp_location_p
) *moribund_locations
= NULL
;
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 (1);
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 bp_location
*bploc
;
1445 /* We're about to delete breakpoints from GDB's lists. If the
1446 INSERTED flag is true, GDB will try to lift the breakpoints by
1447 writing the breakpoints' "shadow contents" back into memory. The
1448 "shadow contents" are NOT valid after an exec, so GDB should not
1449 do that. Instead, the target is responsible from marking
1450 breakpoints out as soon as it detects an exec. We don't do that
1451 here instead, because there may be other attempts to delete
1452 breakpoints after detecting an exec and before reaching here. */
1453 ALL_BP_LOCATIONS (bploc
)
1454 gdb_assert (!bploc
->inserted
);
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");
1548 detach_breakpoints (int pid
)
1550 struct bp_location
*b
;
1552 struct cleanup
*old_chain
= save_inferior_ptid ();
1554 if (pid
== PIDGET (inferior_ptid
))
1555 error (_("Cannot detach breakpoints of inferior_ptid"));
1557 /* Set inferior_ptid; remove_breakpoint uses this global. */
1558 inferior_ptid
= pid_to_ptid (pid
);
1559 ALL_BP_LOCATIONS (b
)
1563 val
= remove_breakpoint (b
, mark_inserted
);
1566 do_cleanups (old_chain
);
1571 do_cleanups (old_chain
);
1576 remove_breakpoint (struct bp_location
*b
, insertion_state_t is
)
1580 if (b
->owner
->enable_state
== bp_permanent
)
1581 /* Permanent breakpoints cannot be inserted or removed. */
1584 /* The type of none suggests that owner is actually deleted.
1585 This should not ever happen. */
1586 gdb_assert (b
->owner
->type
!= bp_none
);
1588 if (b
->loc_type
== bp_loc_software_breakpoint
1589 || b
->loc_type
== bp_loc_hardware_breakpoint
)
1591 /* "Normal" instruction breakpoint: either the standard
1592 trap-instruction bp (bp_breakpoint), or a
1593 bp_hardware_breakpoint. */
1595 /* First check to see if we have to handle an overlay. */
1596 if (overlay_debugging
== ovly_off
1597 || b
->section
== NULL
1598 || !(section_is_overlay (b
->section
)))
1600 /* No overlay handling: just remove the breakpoint. */
1602 if (b
->loc_type
== bp_loc_hardware_breakpoint
)
1603 val
= target_remove_hw_breakpoint (&b
->target_info
);
1605 val
= target_remove_breakpoint (&b
->target_info
);
1609 /* This breakpoint is in an overlay section.
1610 Did we set a breakpoint at the LMA? */
1611 if (!overlay_events_enabled
)
1613 /* Yes -- overlay event support is not active, so we
1614 should have set a breakpoint at the LMA. Remove it.
1616 /* Ignore any failures: if the LMA is in ROM, we will
1617 have already warned when we failed to insert it. */
1618 if (b
->loc_type
== bp_loc_hardware_breakpoint
)
1619 target_remove_hw_breakpoint (&b
->overlay_target_info
);
1621 target_remove_breakpoint (&b
->overlay_target_info
);
1623 /* Did we set a breakpoint at the VMA?
1624 If so, we will have marked the breakpoint 'inserted'. */
1627 /* Yes -- remove it. Previously we did not bother to
1628 remove the breakpoint if the section had been
1629 unmapped, but let's not rely on that being safe. We
1630 don't know what the overlay manager might do. */
1631 if (b
->loc_type
== bp_loc_hardware_breakpoint
)
1632 val
= target_remove_hw_breakpoint (&b
->target_info
);
1634 /* However, we should remove *software* breakpoints only
1635 if the section is still mapped, or else we overwrite
1636 wrong code with the saved shadow contents. */
1637 else if (section_is_mapped (b
->section
))
1638 val
= target_remove_breakpoint (&b
->target_info
);
1644 /* No -- not inserted, so no need to remove. No error. */
1650 b
->inserted
= (is
== mark_inserted
);
1652 else if (b
->loc_type
== bp_loc_hardware_watchpoint
)
1657 b
->inserted
= (is
== mark_inserted
);
1658 val
= target_remove_watchpoint (b
->address
, b
->length
,
1659 b
->watchpoint_type
);
1661 /* Failure to remove any of the hardware watchpoints comes here. */
1662 if ((is
== mark_uninserted
) && (b
->inserted
))
1663 warning (_("Could not remove hardware watchpoint %d."),
1666 else if ((b
->owner
->type
== bp_catch_fork
||
1667 b
->owner
->type
== bp_catch_vfork
||
1668 b
->owner
->type
== bp_catch_exec
)
1669 && breakpoint_enabled (b
->owner
)
1673 switch (b
->owner
->type
)
1676 val
= target_remove_fork_catchpoint (PIDGET (inferior_ptid
));
1678 case bp_catch_vfork
:
1679 val
= target_remove_vfork_catchpoint (PIDGET (inferior_ptid
));
1682 val
= target_remove_exec_catchpoint (PIDGET (inferior_ptid
));
1685 warning (_("Internal error, %s line %d."), __FILE__
, __LINE__
);
1690 b
->inserted
= (is
== mark_inserted
);
1696 /* Clear the "inserted" flag in all breakpoints. */
1699 mark_breakpoints_out (void)
1701 struct bp_location
*bpt
;
1703 ALL_BP_LOCATIONS (bpt
)
1707 /* Clear the "inserted" flag in all breakpoints and delete any
1708 breakpoints which should go away between runs of the program.
1710 Plus other such housekeeping that has to be done for breakpoints
1713 Note: this function gets called at the end of a run (by
1714 generic_mourn_inferior) and when a run begins (by
1715 init_wait_for_inferior). */
1720 breakpoint_init_inferior (enum inf_context context
)
1722 struct breakpoint
*b
, *temp
;
1723 struct bp_location
*bpt
;
1725 ALL_BP_LOCATIONS (bpt
)
1728 ALL_BREAKPOINTS_SAFE (b
, temp
)
1733 case bp_watchpoint_scope
:
1735 /* If the call dummy breakpoint is at the entry point it will
1736 cause problems when the inferior is rerun, so we better
1739 Also get rid of scope breakpoints. */
1740 delete_breakpoint (b
);
1744 case bp_hardware_watchpoint
:
1745 case bp_read_watchpoint
:
1746 case bp_access_watchpoint
:
1748 /* Likewise for watchpoints on local expressions. */
1749 if (b
->exp_valid_block
!= NULL
)
1750 delete_breakpoint (b
);
1751 else if (context
== inf_starting
)
1753 /* Reset val field to force reread of starting value
1754 in insert_breakpoints. */
1756 value_free (b
->val
);
1767 /* breakpoint_here_p (PC) returns non-zero if an enabled breakpoint
1768 exists at PC. It returns ordinary_breakpoint_here if it's an
1769 ordinary breakpoint, or permanent_breakpoint_here if it's a
1770 permanent breakpoint.
1771 - When continuing from a location with an ordinary breakpoint, we
1772 actually single step once before calling insert_breakpoints.
1773 - When continuing from a localion with a permanent breakpoint, we
1774 need to use the `SKIP_PERMANENT_BREAKPOINT' macro, provided by
1775 the target, to advance the PC past the breakpoint. */
1777 enum breakpoint_here
1778 breakpoint_here_p (CORE_ADDR pc
)
1780 const struct bp_location
*bpt
;
1781 int any_breakpoint_here
= 0;
1783 ALL_BP_LOCATIONS (bpt
)
1785 if (bpt
->loc_type
!= bp_loc_software_breakpoint
1786 && bpt
->loc_type
!= bp_loc_hardware_breakpoint
)
1789 if ((breakpoint_enabled (bpt
->owner
)
1790 || bpt
->owner
->enable_state
== bp_permanent
)
1791 && bpt
->address
== pc
) /* bp is enabled and matches pc */
1793 if (overlay_debugging
1794 && section_is_overlay (bpt
->section
)
1795 && !section_is_mapped (bpt
->section
))
1796 continue; /* unmapped overlay -- can't be a match */
1797 else if (bpt
->owner
->enable_state
== bp_permanent
)
1798 return permanent_breakpoint_here
;
1800 any_breakpoint_here
= 1;
1804 return any_breakpoint_here
? ordinary_breakpoint_here
: 0;
1808 /* Returns non-zero if there's a breakpoint inserted at PC, which is
1809 inserted using regular breakpoint_chain/bp_location_chain mechanism.
1810 This does not check for single-step breakpoints, which are
1811 inserted and removed using direct target manipulation. */
1814 regular_breakpoint_inserted_here_p (CORE_ADDR pc
)
1816 const struct bp_location
*bpt
;
1818 ALL_BP_LOCATIONS (bpt
)
1820 if (bpt
->loc_type
!= bp_loc_software_breakpoint
1821 && bpt
->loc_type
!= bp_loc_hardware_breakpoint
)
1825 && bpt
->address
== pc
) /* bp is inserted and matches pc */
1827 if (overlay_debugging
1828 && section_is_overlay (bpt
->section
)
1829 && !section_is_mapped (bpt
->section
))
1830 continue; /* unmapped overlay -- can't be a match */
1838 /* Returns non-zero iff there's either regular breakpoint
1839 or a single step breakpoint inserted at PC. */
1842 breakpoint_inserted_here_p (CORE_ADDR pc
)
1844 if (regular_breakpoint_inserted_here_p (pc
))
1847 if (single_step_breakpoint_inserted_here_p (pc
))
1853 /* This function returns non-zero iff there is a software breakpoint
1857 software_breakpoint_inserted_here_p (CORE_ADDR pc
)
1859 const struct bp_location
*bpt
;
1860 int any_breakpoint_here
= 0;
1862 ALL_BP_LOCATIONS (bpt
)
1864 if (bpt
->loc_type
!= bp_loc_software_breakpoint
)
1868 && bpt
->address
== pc
) /* bp is enabled and matches pc */
1870 if (overlay_debugging
1871 && section_is_overlay (bpt
->section
)
1872 && !section_is_mapped (bpt
->section
))
1873 continue; /* unmapped overlay -- can't be a match */
1879 /* Also check for software single-step breakpoints. */
1880 if (single_step_breakpoint_inserted_here_p (pc
))
1886 /* breakpoint_thread_match (PC, PTID) returns true if the breakpoint at
1887 PC is valid for process/thread PTID. */
1890 breakpoint_thread_match (CORE_ADDR pc
, ptid_t ptid
)
1892 const struct bp_location
*bpt
;
1895 thread
= pid_to_thread_id (ptid
);
1897 ALL_BP_LOCATIONS (bpt
)
1899 if (bpt
->loc_type
!= bp_loc_software_breakpoint
1900 && bpt
->loc_type
!= bp_loc_hardware_breakpoint
)
1903 if ((breakpoint_enabled (bpt
->owner
)
1904 || bpt
->owner
->enable_state
== bp_permanent
)
1905 && bpt
->address
== pc
1906 && (bpt
->owner
->thread
== -1 || bpt
->owner
->thread
== thread
))
1908 if (overlay_debugging
1909 && section_is_overlay (bpt
->section
)
1910 && !section_is_mapped (bpt
->section
))
1911 continue; /* unmapped overlay -- can't be a match */
1921 /* bpstat stuff. External routines' interfaces are documented
1925 ep_is_catchpoint (struct breakpoint
*ep
)
1928 (ep
->type
== bp_catch_load
)
1929 || (ep
->type
== bp_catch_unload
)
1930 || (ep
->type
== bp_catch_fork
)
1931 || (ep
->type
== bp_catch_vfork
)
1932 || (ep
->type
== bp_catch_exec
);
1934 /* ??rehrauer: Add more kinds here, as are implemented... */
1938 ep_is_shlib_catchpoint (struct breakpoint
*ep
)
1941 (ep
->type
== bp_catch_load
)
1942 || (ep
->type
== bp_catch_unload
);
1946 bpstat_free (bpstat bs
)
1948 if (bs
->old_val
!= NULL
)
1949 value_free (bs
->old_val
);
1950 free_command_lines (&bs
->commands
);
1954 /* Clear a bpstat so that it says we are not at any breakpoint.
1955 Also free any storage that is part of a bpstat. */
1958 bpstat_clear (bpstat
*bsp
)
1975 /* Return a copy of a bpstat. Like "bs1 = bs2" but all storage that
1976 is part of the bpstat is copied as well. */
1979 bpstat_copy (bpstat bs
)
1983 bpstat retval
= NULL
;
1988 for (; bs
!= NULL
; bs
= bs
->next
)
1990 tmp
= (bpstat
) xmalloc (sizeof (*tmp
));
1991 memcpy (tmp
, bs
, sizeof (*tmp
));
1992 if (bs
->commands
!= NULL
)
1993 tmp
->commands
= copy_command_lines (bs
->commands
);
1994 if (bs
->old_val
!= NULL
)
1996 tmp
->old_val
= value_copy (bs
->old_val
);
1997 release_value (tmp
->old_val
);
2001 /* This is the first thing in the chain. */
2011 /* Find the bpstat associated with this breakpoint */
2014 bpstat_find_breakpoint (bpstat bsp
, struct breakpoint
*breakpoint
)
2019 for (; bsp
!= NULL
; bsp
= bsp
->next
)
2021 if (bsp
->breakpoint_at
&& bsp
->breakpoint_at
->owner
== breakpoint
)
2027 /* Find a step_resume breakpoint associated with this bpstat.
2028 (If there are multiple step_resume bp's on the list, this function
2029 will arbitrarily pick one.)
2031 It is an error to use this function if BPSTAT doesn't contain a
2032 step_resume breakpoint.
2034 See wait_for_inferior's use of this function. */
2036 bpstat_find_step_resume_breakpoint (bpstat bsp
)
2040 gdb_assert (bsp
!= NULL
);
2042 current_thread
= pid_to_thread_id (inferior_ptid
);
2044 for (; bsp
!= NULL
; bsp
= bsp
->next
)
2046 if ((bsp
->breakpoint_at
!= NULL
) &&
2047 (bsp
->breakpoint_at
->owner
->type
== bp_step_resume
) &&
2048 (bsp
->breakpoint_at
->owner
->thread
== current_thread
||
2049 bsp
->breakpoint_at
->owner
->thread
== -1))
2050 return bsp
->breakpoint_at
->owner
;
2053 internal_error (__FILE__
, __LINE__
, _("No step_resume breakpoint found."));
2057 /* Put in *NUM the breakpoint number of the first breakpoint we are stopped
2058 at. *BSP upon return is a bpstat which points to the remaining
2059 breakpoints stopped at (but which is not guaranteed to be good for
2060 anything but further calls to bpstat_num).
2061 Return 0 if passed a bpstat which does not indicate any breakpoints.
2062 Return -1 if stopped at a breakpoint that has been deleted since
2064 Return 1 otherwise. */
2067 bpstat_num (bpstat
*bsp
, int *num
)
2069 struct breakpoint
*b
;
2072 return 0; /* No more breakpoint values */
2074 /* We assume we'll never have several bpstats that
2075 correspond to a single breakpoint -- otherwise,
2076 this function might return the same number more
2077 than once and this will look ugly. */
2078 b
= (*bsp
)->breakpoint_at
? (*bsp
)->breakpoint_at
->owner
: NULL
;
2079 *bsp
= (*bsp
)->next
;
2081 return -1; /* breakpoint that's been deleted since */
2083 *num
= b
->number
; /* We have its number */
2087 /* Modify BS so that the actions will not be performed. */
2090 bpstat_clear_actions (bpstat bs
)
2092 for (; bs
!= NULL
; bs
= bs
->next
)
2094 free_command_lines (&bs
->commands
);
2095 if (bs
->old_val
!= NULL
)
2097 value_free (bs
->old_val
);
2103 /* Stub for cleaning up our state if we error-out of a breakpoint command */
2105 cleanup_executing_breakpoints (void *ignore
)
2107 executing_breakpoint_commands
= 0;
2110 /* Execute all the commands associated with all the breakpoints at this
2111 location. Any of these commands could cause the process to proceed
2112 beyond this point, etc. We look out for such changes by checking
2113 the global "breakpoint_proceeded" after each command. */
2116 bpstat_do_actions (bpstat
*bsp
)
2119 struct cleanup
*old_chain
;
2121 /* Avoid endless recursion if a `source' command is contained
2123 if (executing_breakpoint_commands
)
2126 executing_breakpoint_commands
= 1;
2127 old_chain
= make_cleanup (cleanup_executing_breakpoints
, 0);
2130 /* Note that (as of this writing), our callers all appear to
2131 be passing us the address of global stop_bpstat. And, if
2132 our calls to execute_control_command cause the inferior to
2133 proceed, that global (and hence, *bsp) will change.
2135 We must be careful to not touch *bsp unless the inferior
2136 has not proceeded. */
2138 /* This pointer will iterate over the list of bpstat's. */
2141 breakpoint_proceeded
= 0;
2142 for (; bs
!= NULL
; bs
= bs
->next
)
2144 struct command_line
*cmd
;
2145 struct cleanup
*this_cmd_tree_chain
;
2147 /* Take ownership of the BSP's command tree, if it has one.
2149 The command tree could legitimately contain commands like
2150 'step' and 'next', which call clear_proceed_status, which
2151 frees stop_bpstat's command tree. To make sure this doesn't
2152 free the tree we're executing out from under us, we need to
2153 take ownership of the tree ourselves. Since a given bpstat's
2154 commands are only executed once, we don't need to copy it; we
2155 can clear the pointer in the bpstat, and make sure we free
2156 the tree when we're done. */
2159 this_cmd_tree_chain
= make_cleanup_free_command_lines (&cmd
);
2163 execute_control_command (cmd
);
2165 if (breakpoint_proceeded
)
2171 /* We can free this command tree now. */
2172 do_cleanups (this_cmd_tree_chain
);
2174 if (breakpoint_proceeded
)
2176 if (target_can_async_p ())
2177 /* If we are in async mode, then the target might
2178 be still running, not stopped at any breakpoint,
2179 so nothing for us to do here -- just return to
2183 /* In sync mode, when execute_control_command returns
2184 we're already standing on the next breakpoint.
2185 Breakpoint commands for that stop were not run,
2186 since execute_command does not run breakpoint
2187 commands -- only command_line_handler does, but
2188 that one is not involved in execution of breakpoint
2189 commands. So, we can now execute breakpoint commands.
2190 There's an implicit assumption that we're called with
2191 stop_bpstat, so our parameter is the new bpstat to
2193 It should be noted that making execute_command do
2194 bpstat actions is not an option -- in this case we'll
2195 have recursive invocation of bpstat for each breakpoint
2196 with a command, and can easily blow up GDB stack. */
2200 do_cleanups (old_chain
);
2203 /* Print out the (old or new) value associated with a watchpoint. */
2206 watchpoint_value_print (struct value
*val
, struct ui_file
*stream
)
2209 fprintf_unfiltered (stream
, _("<unreadable>"));
2211 value_print (val
, stream
, 0, Val_pretty_default
);
2214 /* This is the normal print function for a bpstat. In the future,
2215 much of this logic could (should?) be moved to bpstat_stop_status,
2216 by having it set different print_it values.
2218 Current scheme: When we stop, bpstat_print() is called. It loops
2219 through the bpstat list of things causing this stop, calling the
2220 print_bp_stop_message function on each one. The behavior of the
2221 print_bp_stop_message function depends on the print_it field of
2222 bpstat. If such field so indicates, call this function here.
2224 Return values from this routine (ultimately used by bpstat_print()
2225 and normal_stop() to decide what to do):
2226 PRINT_NOTHING: Means we already printed all we needed to print,
2227 don't print anything else.
2228 PRINT_SRC_ONLY: Means we printed something, and we do *not* desire
2229 that something to be followed by a location.
2230 PRINT_SCR_AND_LOC: Means we printed something, and we *do* desire
2231 that something to be followed by a location.
2232 PRINT_UNKNOWN: Means we printed nothing or we need to do some more
2235 static enum print_stop_action
2236 print_it_typical (bpstat bs
)
2238 struct cleanup
*old_chain
, *ui_out_chain
;
2239 struct breakpoint
*b
;
2240 const struct bp_location
*bl
;
2241 struct ui_stream
*stb
;
2243 stb
= ui_out_stream_new (uiout
);
2244 old_chain
= make_cleanup_ui_out_stream_delete (stb
);
2245 /* bs->breakpoint_at can be NULL if it was a momentary breakpoint
2246 which has since been deleted. */
2247 if (bs
->breakpoint_at
== NULL
)
2248 return PRINT_UNKNOWN
;
2249 bl
= bs
->breakpoint_at
;
2255 case bp_hardware_breakpoint
:
2256 bp_temp
= bs
->breakpoint_at
->owner
->disposition
== disp_del
;
2257 if (bl
->address
!= bl
->requested_address
)
2258 breakpoint_adjustment_warning (bl
->requested_address
,
2261 annotate_breakpoint (b
->number
);
2263 ui_out_text (uiout
, "\nTemporary breakpoint ");
2265 ui_out_text (uiout
, "\nBreakpoint ");
2266 if (ui_out_is_mi_like_p (uiout
))
2268 ui_out_field_string (uiout
, "reason",
2269 async_reason_lookup (EXEC_ASYNC_BREAKPOINT_HIT
));
2270 ui_out_field_string (uiout
, "disp", bpdisp_text (b
->disposition
));
2272 ui_out_field_int (uiout
, "bkptno", b
->number
);
2273 ui_out_text (uiout
, ", ");
2274 return PRINT_SRC_AND_LOC
;
2277 case bp_shlib_event
:
2278 /* Did we stop because the user set the stop_on_solib_events
2279 variable? (If so, we report this as a generic, "Stopped due
2280 to shlib event" message.) */
2281 printf_filtered (_("Stopped due to shared library event\n"));
2282 return PRINT_NOTHING
;
2285 case bp_thread_event
:
2286 /* Not sure how we will get here.
2287 GDB should not stop for these breakpoints. */
2288 printf_filtered (_("Thread Event Breakpoint: gdb should not stop!\n"));
2289 return PRINT_NOTHING
;
2292 case bp_overlay_event
:
2293 /* By analogy with the thread event, GDB should not stop for these. */
2294 printf_filtered (_("Overlay Event Breakpoint: gdb should not stop!\n"));
2295 return PRINT_NOTHING
;
2299 annotate_catchpoint (b
->number
);
2300 printf_filtered (_("\nCatchpoint %d (loaded %s), "),
2302 b
->triggered_dll_pathname
);
2303 return PRINT_SRC_AND_LOC
;
2306 case bp_catch_unload
:
2307 annotate_catchpoint (b
->number
);
2308 printf_filtered (_("\nCatchpoint %d (unloaded %s), "),
2310 b
->triggered_dll_pathname
);
2311 return PRINT_SRC_AND_LOC
;
2315 annotate_catchpoint (b
->number
);
2316 printf_filtered (_("\nCatchpoint %d (forked process %d), "),
2318 ptid_get_pid (b
->forked_inferior_pid
));
2319 return PRINT_SRC_AND_LOC
;
2322 case bp_catch_vfork
:
2323 annotate_catchpoint (b
->number
);
2324 printf_filtered (_("\nCatchpoint %d (vforked process %d), "),
2326 ptid_get_pid (b
->forked_inferior_pid
));
2327 return PRINT_SRC_AND_LOC
;
2331 annotate_catchpoint (b
->number
);
2332 printf_filtered (_("\nCatchpoint %d (exec'd %s), "),
2335 return PRINT_SRC_AND_LOC
;
2339 case bp_hardware_watchpoint
:
2340 annotate_watchpoint (b
->number
);
2341 if (ui_out_is_mi_like_p (uiout
))
2344 async_reason_lookup (EXEC_ASYNC_WATCHPOINT_TRIGGER
));
2346 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "value");
2347 ui_out_text (uiout
, "\nOld value = ");
2348 watchpoint_value_print (bs
->old_val
, stb
->stream
);
2349 ui_out_field_stream (uiout
, "old", stb
);
2350 ui_out_text (uiout
, "\nNew value = ");
2351 watchpoint_value_print (b
->val
, stb
->stream
);
2352 ui_out_field_stream (uiout
, "new", stb
);
2353 do_cleanups (ui_out_chain
);
2354 ui_out_text (uiout
, "\n");
2355 /* More than one watchpoint may have been triggered. */
2356 return PRINT_UNKNOWN
;
2359 case bp_read_watchpoint
:
2360 if (ui_out_is_mi_like_p (uiout
))
2363 async_reason_lookup (EXEC_ASYNC_READ_WATCHPOINT_TRIGGER
));
2365 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "value");
2366 ui_out_text (uiout
, "\nValue = ");
2367 watchpoint_value_print (b
->val
, stb
->stream
);
2368 ui_out_field_stream (uiout
, "value", stb
);
2369 do_cleanups (ui_out_chain
);
2370 ui_out_text (uiout
, "\n");
2371 return PRINT_UNKNOWN
;
2374 case bp_access_watchpoint
:
2375 if (bs
->old_val
!= NULL
)
2377 annotate_watchpoint (b
->number
);
2378 if (ui_out_is_mi_like_p (uiout
))
2381 async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER
));
2383 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "value");
2384 ui_out_text (uiout
, "\nOld value = ");
2385 watchpoint_value_print (bs
->old_val
, stb
->stream
);
2386 ui_out_field_stream (uiout
, "old", stb
);
2387 ui_out_text (uiout
, "\nNew value = ");
2392 if (ui_out_is_mi_like_p (uiout
))
2395 async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER
));
2396 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "value");
2397 ui_out_text (uiout
, "\nValue = ");
2399 watchpoint_value_print (b
->val
, stb
->stream
);
2400 ui_out_field_stream (uiout
, "new", stb
);
2401 do_cleanups (ui_out_chain
);
2402 ui_out_text (uiout
, "\n");
2403 return PRINT_UNKNOWN
;
2406 /* Fall through, we don't deal with these types of breakpoints
2410 if (ui_out_is_mi_like_p (uiout
))
2413 async_reason_lookup (EXEC_ASYNC_FUNCTION_FINISHED
));
2414 return PRINT_UNKNOWN
;
2418 if (ui_out_is_mi_like_p (uiout
))
2421 async_reason_lookup (EXEC_ASYNC_LOCATION_REACHED
));
2422 return PRINT_UNKNOWN
;
2427 case bp_longjmp_resume
:
2428 case bp_step_resume
:
2429 case bp_watchpoint_scope
:
2432 return PRINT_UNKNOWN
;
2436 /* Generic routine for printing messages indicating why we
2437 stopped. The behavior of this function depends on the value
2438 'print_it' in the bpstat structure. Under some circumstances we
2439 may decide not to print anything here and delegate the task to
2442 static enum print_stop_action
2443 print_bp_stop_message (bpstat bs
)
2445 switch (bs
->print_it
)
2448 /* Nothing should be printed for this bpstat entry. */
2449 return PRINT_UNKNOWN
;
2453 /* We still want to print the frame, but we already printed the
2454 relevant messages. */
2455 return PRINT_SRC_AND_LOC
;
2458 case print_it_normal
:
2460 const struct bp_location
*bl
= bs
->breakpoint_at
;
2461 struct breakpoint
*b
= bl
? bl
->owner
: NULL
;
2463 /* Normal case. Call the breakpoint's print_it method, or
2464 print_it_typical. */
2465 /* FIXME: how breakpoint can ever be NULL here? */
2466 if (b
!= NULL
&& b
->ops
!= NULL
&& b
->ops
->print_it
!= NULL
)
2467 return b
->ops
->print_it (b
);
2469 return print_it_typical (bs
);
2474 internal_error (__FILE__
, __LINE__
,
2475 _("print_bp_stop_message: unrecognized enum value"));
2480 /* Print a message indicating what happened. This is called from
2481 normal_stop(). The input to this routine is the head of the bpstat
2482 list - a list of the eventpoints that caused this stop. This
2483 routine calls the generic print routine for printing a message
2484 about reasons for stopping. This will print (for example) the
2485 "Breakpoint n," part of the output. The return value of this
2488 PRINT_UNKNOWN: Means we printed nothing
2489 PRINT_SRC_AND_LOC: Means we printed something, and expect subsequent
2490 code to print the location. An example is
2491 "Breakpoint 1, " which should be followed by
2493 PRINT_SRC_ONLY: Means we printed something, but there is no need
2494 to also print the location part of the message.
2495 An example is the catch/throw messages, which
2496 don't require a location appended to the end.
2497 PRINT_NOTHING: We have done some printing and we don't need any
2498 further info to be printed.*/
2500 enum print_stop_action
2501 bpstat_print (bpstat bs
)
2505 /* Maybe another breakpoint in the chain caused us to stop.
2506 (Currently all watchpoints go on the bpstat whether hit or not.
2507 That probably could (should) be changed, provided care is taken
2508 with respect to bpstat_explains_signal). */
2509 for (; bs
; bs
= bs
->next
)
2511 val
= print_bp_stop_message (bs
);
2512 if (val
== PRINT_SRC_ONLY
2513 || val
== PRINT_SRC_AND_LOC
2514 || val
== PRINT_NOTHING
)
2518 /* We reached the end of the chain, or we got a null BS to start
2519 with and nothing was printed. */
2520 return PRINT_UNKNOWN
;
2523 /* Evaluate the expression EXP and return 1 if value is zero.
2524 This is used inside a catch_errors to evaluate the breakpoint condition.
2525 The argument is a "struct expression *" that has been cast to char * to
2526 make it pass through catch_errors. */
2529 breakpoint_cond_eval (void *exp
)
2531 struct value
*mark
= value_mark ();
2532 int i
= !value_true (evaluate_expression ((struct expression
*) exp
));
2533 value_free_to_mark (mark
);
2537 /* Allocate a new bpstat and chain it to the current one. */
2540 bpstat_alloc (const struct bp_location
*bl
, bpstat cbs
/* Current "bs" value */ )
2544 bs
= (bpstat
) xmalloc (sizeof (*bs
));
2546 bs
->breakpoint_at
= bl
;
2547 /* If the condition is false, etc., don't do the commands. */
2548 bs
->commands
= NULL
;
2550 bs
->print_it
= print_it_normal
;
2554 /* The target has stopped with waitstatus WS. Check if any hardware
2555 watchpoints have triggered, according to the target. */
2558 watchpoints_triggered (struct target_waitstatus
*ws
)
2560 int stopped_by_watchpoint
= STOPPED_BY_WATCHPOINT (*ws
);
2562 struct breakpoint
*b
;
2564 if (!stopped_by_watchpoint
)
2566 /* We were not stopped by a watchpoint. Mark all watchpoints
2567 as not triggered. */
2569 if (b
->type
== bp_hardware_watchpoint
2570 || b
->type
== bp_read_watchpoint
2571 || b
->type
== bp_access_watchpoint
)
2572 b
->watchpoint_triggered
= watch_triggered_no
;
2577 if (!target_stopped_data_address (¤t_target
, &addr
))
2579 /* We were stopped by a watchpoint, but we don't know where.
2580 Mark all watchpoints as unknown. */
2582 if (b
->type
== bp_hardware_watchpoint
2583 || b
->type
== bp_read_watchpoint
2584 || b
->type
== bp_access_watchpoint
)
2585 b
->watchpoint_triggered
= watch_triggered_unknown
;
2587 return stopped_by_watchpoint
;
2590 /* The target could report the data address. Mark watchpoints
2591 affected by this data address as triggered, and all others as not
2595 if (b
->type
== bp_hardware_watchpoint
2596 || b
->type
== bp_read_watchpoint
2597 || b
->type
== bp_access_watchpoint
)
2599 struct bp_location
*loc
;
2602 b
->watchpoint_triggered
= watch_triggered_no
;
2603 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
2604 /* Exact match not required. Within range is
2606 if (target_watchpoint_addr_within_range (¤t_target
,
2610 b
->watchpoint_triggered
= watch_triggered_yes
;
2618 /* Possible return values for watchpoint_check (this can't be an enum
2619 because of check_errors). */
2620 /* The watchpoint has been deleted. */
2621 #define WP_DELETED 1
2622 /* The value has changed. */
2623 #define WP_VALUE_CHANGED 2
2624 /* The value has not changed. */
2625 #define WP_VALUE_NOT_CHANGED 3
2627 #define BP_TEMPFLAG 1
2628 #define BP_HARDWAREFLAG 2
2630 /* Check watchpoint condition. */
2633 watchpoint_check (void *p
)
2635 bpstat bs
= (bpstat
) p
;
2636 struct breakpoint
*b
;
2637 struct frame_info
*fr
;
2638 int within_current_scope
;
2640 b
= bs
->breakpoint_at
->owner
;
2642 if (b
->exp_valid_block
== NULL
)
2643 within_current_scope
= 1;
2646 /* There is no current frame at this moment. If we're going to have
2647 any chance of handling watchpoints on local variables, we'll need
2648 the frame chain (so we can determine if we're in scope). */
2649 reinit_frame_cache ();
2650 fr
= frame_find_by_id (b
->watchpoint_frame
);
2651 within_current_scope
= (fr
!= NULL
);
2653 /* If we've gotten confused in the unwinder, we might have
2654 returned a frame that can't describe this variable. */
2655 if (within_current_scope
2656 && block_function (b
->exp_valid_block
) != get_frame_function (fr
))
2657 within_current_scope
= 0;
2659 /* in_function_epilogue_p() returns a non-zero value if we're still
2660 in the function but the stack frame has already been invalidated.
2661 Since we can't rely on the values of local variables after the
2662 stack has been destroyed, we are treating the watchpoint in that
2663 state as `not changed' without further checking.
2665 vinschen/2003-09-04: The former implementation left out the case
2666 that the watchpoint frame couldn't be found by frame_find_by_id()
2667 because the current PC is currently in an epilogue. Calling
2668 gdbarch_in_function_epilogue_p() also when fr == NULL fixes that. */
2669 if ((!within_current_scope
|| fr
== get_current_frame ())
2670 && gdbarch_in_function_epilogue_p (current_gdbarch
, read_pc ()))
2671 return WP_VALUE_NOT_CHANGED
;
2672 if (fr
&& within_current_scope
)
2673 /* If we end up stopping, the current frame will get selected
2674 in normal_stop. So this call to select_frame won't affect
2679 if (within_current_scope
)
2681 /* We use value_{,free_to_}mark because it could be a
2682 *long* time before we return to the command level and
2683 call free_all_values. We can't call free_all_values because
2684 we might be in the middle of evaluating a function call. */
2686 struct value
*mark
= value_mark ();
2687 struct value
*new_val
;
2689 fetch_watchpoint_value (b
->exp
, &new_val
, NULL
, NULL
);
2690 if ((b
->val
!= NULL
) != (new_val
!= NULL
)
2691 || (b
->val
!= NULL
&& !value_equal (b
->val
, new_val
)))
2693 if (new_val
!= NULL
)
2695 release_value (new_val
);
2696 value_free_to_mark (mark
);
2698 bs
->old_val
= b
->val
;
2701 /* We will stop here */
2702 return WP_VALUE_CHANGED
;
2706 /* Nothing changed, don't do anything. */
2707 value_free_to_mark (mark
);
2708 /* We won't stop here */
2709 return WP_VALUE_NOT_CHANGED
;
2714 /* This seems like the only logical thing to do because
2715 if we temporarily ignored the watchpoint, then when
2716 we reenter the block in which it is valid it contains
2717 garbage (in the case of a function, it may have two
2718 garbage values, one before and one after the prologue).
2719 So we can't even detect the first assignment to it and
2720 watch after that (since the garbage may or may not equal
2721 the first value assigned). */
2722 /* We print all the stop information in print_it_typical(), but
2723 in this case, by the time we call print_it_typical() this bp
2724 will be deleted already. So we have no choice but print the
2725 information here. */
2726 if (ui_out_is_mi_like_p (uiout
))
2728 (uiout
, "reason", async_reason_lookup (EXEC_ASYNC_WATCHPOINT_SCOPE
));
2729 ui_out_text (uiout
, "\nWatchpoint ");
2730 ui_out_field_int (uiout
, "wpnum", b
->number
);
2731 ui_out_text (uiout
, " deleted because the program has left the block in\n\
2732 which its expression is valid.\n");
2734 if (b
->related_breakpoint
)
2735 b
->related_breakpoint
->disposition
= disp_del_at_next_stop
;
2736 b
->disposition
= disp_del_at_next_stop
;
2742 /* Return true if it looks like target has stopped due to hitting
2743 breakpoint location BL. This function does not check if we
2744 should stop, only if BL explains the stop. */
2746 bpstat_check_location (const struct bp_location
*bl
, CORE_ADDR bp_addr
)
2748 struct breakpoint
*b
= bl
->owner
;
2750 if (b
->type
!= bp_watchpoint
2751 && b
->type
!= bp_hardware_watchpoint
2752 && b
->type
!= bp_read_watchpoint
2753 && b
->type
!= bp_access_watchpoint
2754 && b
->type
!= bp_hardware_breakpoint
2755 && b
->type
!= bp_catch_fork
2756 && b
->type
!= bp_catch_vfork
2757 && b
->type
!= bp_catch_exec
) /* a non-watchpoint bp */
2759 if (bl
->address
!= bp_addr
) /* address doesn't match */
2761 if (overlay_debugging
/* unmapped overlay section */
2762 && section_is_overlay (bl
->section
)
2763 && !section_is_mapped (bl
->section
))
2767 /* Continuable hardware watchpoints are treated as non-existent if the
2768 reason we stopped wasn't a hardware watchpoint (we didn't stop on
2769 some data address). Otherwise gdb won't stop on a break instruction
2770 in the code (not from a breakpoint) when a hardware watchpoint has
2771 been defined. Also skip watchpoints which we know did not trigger
2772 (did not match the data address). */
2774 if ((b
->type
== bp_hardware_watchpoint
2775 || b
->type
== bp_read_watchpoint
2776 || b
->type
== bp_access_watchpoint
)
2777 && b
->watchpoint_triggered
== watch_triggered_no
)
2780 if (b
->type
== bp_hardware_breakpoint
)
2782 if (bl
->address
!= bp_addr
)
2784 if (overlay_debugging
/* unmapped overlay section */
2785 && section_is_overlay (bl
->section
)
2786 && !section_is_mapped (bl
->section
))
2790 /* Is this a catchpoint of a load or unload? If so, did we
2791 get a load or unload of the specified library? If not,
2793 if ((b
->type
== bp_catch_load
)
2794 #if defined(SOLIB_HAVE_LOAD_EVENT)
2795 && (!SOLIB_HAVE_LOAD_EVENT (PIDGET (inferior_ptid
))
2796 || ((b
->dll_pathname
!= NULL
)
2797 && (strcmp (b
->dll_pathname
,
2798 SOLIB_LOADED_LIBRARY_PATHNAME (
2799 PIDGET (inferior_ptid
)))
2805 if ((b
->type
== bp_catch_unload
)
2806 #if defined(SOLIB_HAVE_UNLOAD_EVENT)
2807 && (!SOLIB_HAVE_UNLOAD_EVENT (PIDGET (inferior_ptid
))
2808 || ((b
->dll_pathname
!= NULL
)
2809 && (strcmp (b
->dll_pathname
,
2810 SOLIB_UNLOADED_LIBRARY_PATHNAME (
2811 PIDGET (inferior_ptid
)))
2817 if ((b
->type
== bp_catch_fork
)
2818 && !inferior_has_forked (inferior_ptid
,
2819 &b
->forked_inferior_pid
))
2822 if ((b
->type
== bp_catch_vfork
)
2823 && !inferior_has_vforked (inferior_ptid
,
2824 &b
->forked_inferior_pid
))
2827 if ((b
->type
== bp_catch_exec
)
2828 && !inferior_has_execd (inferior_ptid
, &b
->exec_pathname
))
2834 /* If BS refers to a watchpoint, determine if the watched values
2835 has actually changed, and we should stop. If not, set BS->stop
2838 bpstat_check_watchpoint (bpstat bs
)
2840 const struct bp_location
*bl
= bs
->breakpoint_at
;
2841 struct breakpoint
*b
= bl
->owner
;
2843 if (b
->type
== bp_watchpoint
2844 || b
->type
== bp_read_watchpoint
2845 || b
->type
== bp_access_watchpoint
2846 || b
->type
== bp_hardware_watchpoint
)
2850 int must_check_value
= 0;
2852 if (b
->type
== bp_watchpoint
)
2853 /* For a software watchpoint, we must always check the
2855 must_check_value
= 1;
2856 else if (b
->watchpoint_triggered
== watch_triggered_yes
)
2857 /* We have a hardware watchpoint (read, write, or access)
2858 and the target earlier reported an address watched by
2860 must_check_value
= 1;
2861 else if (b
->watchpoint_triggered
== watch_triggered_unknown
2862 && b
->type
== bp_hardware_watchpoint
)
2863 /* We were stopped by a hardware watchpoint, but the target could
2864 not report the data address. We must check the watchpoint's
2865 value. Access and read watchpoints are out of luck; without
2866 a data address, we can't figure it out. */
2867 must_check_value
= 1;
2869 if (must_check_value
)
2871 char *message
= xstrprintf ("Error evaluating expression for watchpoint %d\n",
2873 struct cleanup
*cleanups
= make_cleanup (xfree
, message
);
2874 int e
= catch_errors (watchpoint_check
, bs
, message
,
2876 do_cleanups (cleanups
);
2880 /* We've already printed what needs to be printed. */
2881 bs
->print_it
= print_it_done
;
2884 case WP_VALUE_CHANGED
:
2885 if (b
->type
== bp_read_watchpoint
)
2887 /* Don't stop: read watchpoints shouldn't fire if
2888 the value has changed. This is for targets
2889 which cannot set read-only watchpoints. */
2890 bs
->print_it
= print_it_noop
;
2894 case WP_VALUE_NOT_CHANGED
:
2895 if (b
->type
== bp_hardware_watchpoint
2896 || b
->type
== bp_watchpoint
)
2898 /* Don't stop: write watchpoints shouldn't fire if
2899 the value hasn't changed. */
2900 bs
->print_it
= print_it_noop
;
2908 /* Error from catch_errors. */
2909 printf_filtered (_("Watchpoint %d deleted.\n"), b
->number
);
2910 if (b
->related_breakpoint
)
2911 b
->related_breakpoint
->disposition
= disp_del_at_next_stop
;
2912 b
->disposition
= disp_del_at_next_stop
;
2913 /* We've already printed what needs to be printed. */
2914 bs
->print_it
= print_it_done
;
2918 else /* must_check_value == 0 */
2920 /* This is a case where some watchpoint(s) triggered, but
2921 not at the address of this watchpoint, or else no
2922 watchpoint triggered after all. So don't print
2923 anything for this watchpoint. */
2924 bs
->print_it
= print_it_noop
;
2931 /* Check conditions (condition proper, frame, thread and ignore count)
2932 of breakpoint referred to by BS. If we should not stop for this
2933 breakpoint, set BS->stop to 0. */
2935 bpstat_check_breakpoint_conditions (bpstat bs
, ptid_t ptid
)
2937 int thread_id
= pid_to_thread_id (ptid
);
2938 const struct bp_location
*bl
= bs
->breakpoint_at
;
2939 struct breakpoint
*b
= bl
->owner
;
2941 if (frame_id_p (b
->frame_id
)
2942 && !frame_id_eq (b
->frame_id
, get_frame_id (get_current_frame ())))
2946 int value_is_zero
= 0;
2948 /* If this is a scope breakpoint, mark the associated
2949 watchpoint as triggered so that we will handle the
2950 out-of-scope event. We'll get to the watchpoint next
2952 if (b
->type
== bp_watchpoint_scope
)
2953 b
->related_breakpoint
->watchpoint_triggered
= watch_triggered_yes
;
2955 if (bl
->cond
&& bl
->owner
->disposition
!= disp_del_at_next_stop
)
2957 /* Need to select the frame, with all that implies
2958 so that the conditions will have the right context. */
2959 select_frame (get_current_frame ());
2961 = catch_errors (breakpoint_cond_eval
, (bl
->cond
),
2962 "Error in testing breakpoint condition:\n",
2964 /* FIXME-someday, should give breakpoint # */
2967 if (bl
->cond
&& value_is_zero
)
2971 else if (b
->thread
!= -1 && b
->thread
!= thread_id
)
2975 else if (b
->ignore_count
> 0)
2978 annotate_ignore_count_change ();
2980 /* Increase the hit count even though we don't
2988 /* Get a bpstat associated with having just stopped at address
2989 BP_ADDR in thread PTID.
2991 Determine whether we stopped at a breakpoint, etc, or whether we
2992 don't understand this stop. Result is a chain of bpstat's such that:
2994 if we don't understand the stop, the result is a null pointer.
2996 if we understand why we stopped, the result is not null.
2998 Each element of the chain refers to a particular breakpoint or
2999 watchpoint at which we have stopped. (We may have stopped for
3000 several reasons concurrently.)
3002 Each element of the chain has valid next, breakpoint_at,
3003 commands, FIXME??? fields. */
3006 bpstat_stop_status (CORE_ADDR bp_addr
, ptid_t ptid
)
3008 struct breakpoint
*b
= NULL
;
3009 const struct bp_location
*bl
;
3010 struct bp_location
*loc
;
3011 /* Root of the chain of bpstat's */
3012 struct bpstats root_bs
[1];
3013 /* Pointer to the last thing in the chain currently. */
3014 bpstat bs
= root_bs
;
3017 ALL_BP_LOCATIONS (bl
)
3021 if (!breakpoint_enabled (b
) && b
->enable_state
!= bp_permanent
)
3024 /* For hardware watchpoints, we look only at the first location.
3025 The watchpoint_check function will work on entire expression,
3026 not the individual locations. For read watchopints, the
3027 watchpoints_triggered function have checked all locations
3030 if (b
->type
== bp_hardware_watchpoint
&& bl
!= b
->loc
)
3033 if (!bpstat_check_location (bl
, bp_addr
))
3036 /* Come here if it's a watchpoint, or if the break address matches */
3038 bs
= bpstat_alloc (bl
, bs
); /* Alloc a bpstat to explain stop */
3040 /* Assume we stop. Should we find watchpoint that is not actually
3041 triggered, or if condition of breakpoint is false, we'll reset
3046 bpstat_check_watchpoint (bs
);
3050 if (b
->type
== bp_thread_event
|| b
->type
== bp_overlay_event
)
3051 /* We do not stop for these. */
3054 bpstat_check_breakpoint_conditions (bs
, ptid
);
3060 /* We will stop here */
3061 if (b
->disposition
== disp_disable
)
3063 b
->enable_state
= bp_disabled
;
3064 update_global_location_list (0);
3068 bs
->commands
= b
->commands
;
3070 (strcmp ("silent", bs
->commands
->line
) == 0
3071 || (xdb_commands
&& strcmp ("Q", bs
->commands
->line
) == 0)))
3073 bs
->commands
= bs
->commands
->next
;
3076 bs
->commands
= copy_command_lines (bs
->commands
);
3079 /* Print nothing for this entry if we dont stop or if we dont print. */
3080 if (bs
->stop
== 0 || bs
->print
== 0)
3081 bs
->print_it
= print_it_noop
;
3084 for (ix
= 0; VEC_iterate (bp_location_p
, moribund_locations
, ix
, loc
); ++ix
)
3086 if (loc
->address
== bp_addr
)
3088 bs
= bpstat_alloc (loc
, bs
);
3089 /* For hits of moribund locations, we should just proceed. */
3092 bs
->print_it
= print_it_noop
;
3096 bs
->next
= NULL
; /* Terminate the chain */
3097 bs
= root_bs
->next
; /* Re-grab the head of the chain */
3099 /* If we aren't stopping, the value of some hardware watchpoint may
3100 not have changed, but the intermediate memory locations we are
3101 watching may have. Don't bother if we're stopping; this will get
3103 for (bs
= root_bs
->next
; bs
!= NULL
; bs
= bs
->next
)
3108 for (bs
= root_bs
->next
; bs
!= NULL
; bs
= bs
->next
)
3110 && bs
->breakpoint_at
->owner
3111 && (bs
->breakpoint_at
->owner
->type
== bp_hardware_watchpoint
3112 || bs
->breakpoint_at
->owner
->type
== bp_read_watchpoint
3113 || bs
->breakpoint_at
->owner
->type
== bp_access_watchpoint
))
3115 /* remove/insert can invalidate bs->breakpoint_at, if this
3116 location is no longer used by the watchpoint. Prevent
3117 further code from trying to use it. */
3118 bs
->breakpoint_at
= NULL
;
3119 remove_breakpoints ();
3120 insert_breakpoints ();
3124 return root_bs
->next
;
3127 /* Tell what to do about this bpstat. */
3129 bpstat_what (bpstat bs
)
3131 /* Classify each bpstat as one of the following. */
3134 /* This bpstat element has no effect on the main_action. */
3137 /* There was a watchpoint, stop but don't print. */
3140 /* There was a watchpoint, stop and print. */
3143 /* There was a breakpoint but we're not stopping. */
3146 /* There was a breakpoint, stop but don't print. */
3149 /* There was a breakpoint, stop and print. */
3152 /* We hit the longjmp breakpoint. */
3155 /* We hit the longjmp_resume breakpoint. */
3158 /* We hit the step_resume breakpoint. */
3161 /* We hit the shared library event breakpoint. */
3164 /* We caught a shared library event. */
3167 /* This is just used to count how many enums there are. */
3171 /* Here is the table which drives this routine. So that we can
3172 format it pretty, we define some abbreviations for the
3173 enum bpstat_what codes. */
3174 #define kc BPSTAT_WHAT_KEEP_CHECKING
3175 #define ss BPSTAT_WHAT_STOP_SILENT
3176 #define sn BPSTAT_WHAT_STOP_NOISY
3177 #define sgl BPSTAT_WHAT_SINGLE
3178 #define slr BPSTAT_WHAT_SET_LONGJMP_RESUME
3179 #define clr BPSTAT_WHAT_CLEAR_LONGJMP_RESUME
3180 #define sr BPSTAT_WHAT_STEP_RESUME
3181 #define shl BPSTAT_WHAT_CHECK_SHLIBS
3182 #define shlr BPSTAT_WHAT_CHECK_SHLIBS_RESUME_FROM_HOOK
3184 /* "Can't happen." Might want to print an error message.
3185 abort() is not out of the question, but chances are GDB is just
3186 a bit confused, not unusable. */
3187 #define err BPSTAT_WHAT_STOP_NOISY
3189 /* Given an old action and a class, come up with a new action. */
3190 /* One interesting property of this table is that wp_silent is the same
3191 as bp_silent and wp_noisy is the same as bp_noisy. That is because
3192 after stopping, the check for whether to step over a breakpoint
3193 (BPSTAT_WHAT_SINGLE type stuff) is handled in proceed() without
3194 reference to how we stopped. We retain separate wp_silent and
3195 bp_silent codes in case we want to change that someday.
3197 Another possibly interesting property of this table is that
3198 there's a partial ordering, priority-like, of the actions. Once
3199 you've decided that some action is appropriate, you'll never go
3200 back and decide something of a lower priority is better. The
3203 kc < clr sgl shl shlr slr sn sr ss
3204 sgl < shl shlr slr sn sr ss
3205 slr < err shl shlr sn sr ss
3206 clr < err shl shlr sn sr ss
3213 What I think this means is that we don't need a damned table
3214 here. If you just put the rows and columns in the right order,
3215 it'd look awfully regular. We could simply walk the bpstat list
3216 and choose the highest priority action we find, with a little
3217 logic to handle the 'err' cases. */
3219 /* step_resume entries: a step resume breakpoint overrides another
3220 breakpoint of signal handling (see comment in wait_for_inferior
3221 at where we set the step_resume breakpoint). */
3223 static const enum bpstat_what_main_action
3224 table
[(int) class_last
][(int) BPSTAT_WHAT_LAST
] =
3227 /* kc ss sn sgl slr clr sr shl shlr
3230 {kc
, ss
, sn
, sgl
, slr
, clr
, sr
, shl
, shlr
},
3232 {ss
, ss
, sn
, ss
, ss
, ss
, sr
, shl
, shlr
},
3234 {sn
, sn
, sn
, sn
, sn
, sn
, sr
, shl
, shlr
},
3236 {sgl
, ss
, sn
, sgl
, slr
, slr
, sr
, shl
, shlr
},
3238 {ss
, ss
, sn
, ss
, ss
, ss
, sr
, shl
, shlr
},
3240 {sn
, sn
, sn
, sn
, sn
, sn
, sr
, shl
, shlr
},
3242 {slr
, ss
, sn
, slr
, slr
, err
, sr
, shl
, shlr
},
3244 {clr
, ss
, sn
, err
, err
, err
, sr
, shl
, shlr
},
3246 {sr
, sr
, sr
, sr
, sr
, sr
, sr
, sr
, sr
},
3248 {shl
, shl
, shl
, shl
, shl
, shl
, sr
, shl
, shlr
},
3250 {shlr
, shlr
, shlr
, shlr
, shlr
, shlr
, sr
, shlr
, shlr
}
3264 enum bpstat_what_main_action current_action
= BPSTAT_WHAT_KEEP_CHECKING
;
3265 struct bpstat_what retval
;
3267 retval
.call_dummy
= 0;
3268 for (; bs
!= NULL
; bs
= bs
->next
)
3270 enum class bs_class
= no_effect
;
3271 if (bs
->breakpoint_at
== NULL
)
3272 /* I suspect this can happen if it was a momentary breakpoint
3273 which has since been deleted. */
3275 if (bs
->breakpoint_at
->owner
== NULL
)
3276 bs_class
= bp_nostop
;
3278 switch (bs
->breakpoint_at
->owner
->type
)
3284 case bp_hardware_breakpoint
:
3290 bs_class
= bp_noisy
;
3292 bs_class
= bp_silent
;
3295 bs_class
= bp_nostop
;
3298 case bp_hardware_watchpoint
:
3299 case bp_read_watchpoint
:
3300 case bp_access_watchpoint
:
3304 bs_class
= wp_noisy
;
3306 bs_class
= wp_silent
;
3309 /* There was a watchpoint, but we're not stopping.
3310 This requires no further action. */
3311 bs_class
= no_effect
;
3314 bs_class
= long_jump
;
3316 case bp_longjmp_resume
:
3317 bs_class
= long_resume
;
3319 case bp_step_resume
:
3322 bs_class
= step_resume
;
3325 /* It is for the wrong frame. */
3326 bs_class
= bp_nostop
;
3328 case bp_watchpoint_scope
:
3329 bs_class
= bp_nostop
;
3331 case bp_shlib_event
:
3332 bs_class
= shlib_event
;
3334 case bp_thread_event
:
3335 case bp_overlay_event
:
3336 bs_class
= bp_nostop
;
3339 case bp_catch_unload
:
3340 /* Only if this catchpoint triggered should we cause the
3341 step-out-of-dld behaviour. Otherwise, we ignore this
3344 bs_class
= catch_shlib_event
;
3346 bs_class
= no_effect
;
3349 case bp_catch_vfork
:
3354 bs_class
= bp_noisy
;
3356 bs_class
= bp_silent
;
3359 /* There was a catchpoint, but we're not stopping.
3360 This requires no further action. */
3361 bs_class
= no_effect
;
3364 /* Make sure the action is stop (silent or noisy),
3365 so infrun.c pops the dummy frame. */
3366 bs_class
= bp_silent
;
3367 retval
.call_dummy
= 1;
3370 current_action
= table
[(int) bs_class
][(int) current_action
];
3372 retval
.main_action
= current_action
;
3376 /* Nonzero if we should step constantly (e.g. watchpoints on machines
3377 without hardware support). This isn't related to a specific bpstat,
3378 just to things like whether watchpoints are set. */
3381 bpstat_should_step (void)
3383 struct breakpoint
*b
;
3385 if (breakpoint_enabled (b
) && b
->type
== bp_watchpoint
)
3392 /* Given a bpstat that records zero or more triggered eventpoints, this
3393 function returns another bpstat which contains only the catchpoints
3394 on that first list, if any. */
3396 bpstat_get_triggered_catchpoints (bpstat ep_list
, bpstat
*cp_list
)
3398 struct bpstats root_bs
[1];
3399 bpstat bs
= root_bs
;
3400 struct breakpoint
*ep
;
3403 bpstat_clear (cp_list
);
3404 root_bs
->next
= NULL
;
3406 for (; ep_list
!= NULL
; ep_list
= ep_list
->next
)
3408 /* Is this eventpoint a catchpoint? If not, ignore it. */
3409 ep
= ep_list
->breakpoint_at
->owner
;
3412 if ((ep
->type
!= bp_catch_load
) &&
3413 (ep
->type
!= bp_catch_unload
))
3414 /* pai: (temp) ADD fork/vfork here!! */
3417 /* Yes; add it to the list. */
3418 bs
= bpstat_alloc (ep_list
->breakpoint_at
, bs
);
3423 #if defined(SOLIB_ADD)
3424 /* Also, for each triggered catchpoint, tag it with the name of
3425 the library that caused this trigger. (We copy the name now,
3426 because it's only guaranteed to be available NOW, when the
3427 catchpoint triggers. Clients who may wish to know the name
3428 later must get it from the catchpoint itself.) */
3429 if (ep
->triggered_dll_pathname
!= NULL
)
3430 xfree (ep
->triggered_dll_pathname
);
3431 if (ep
->type
== bp_catch_load
)
3432 dll_pathname
= SOLIB_LOADED_LIBRARY_PATHNAME (
3433 PIDGET (inferior_ptid
));
3435 dll_pathname
= SOLIB_UNLOADED_LIBRARY_PATHNAME (
3436 PIDGET (inferior_ptid
));
3438 dll_pathname
= NULL
;
3442 ep
->triggered_dll_pathname
= (char *)
3443 xmalloc (strlen (dll_pathname
) + 1);
3444 strcpy (ep
->triggered_dll_pathname
, dll_pathname
);
3447 ep
->triggered_dll_pathname
= NULL
;
3453 static void print_breakpoint_location (struct breakpoint
*b
,
3454 struct bp_location
*loc
,
3456 struct ui_stream
*stb
)
3461 = find_pc_sect_function (loc
->address
, loc
->section
);
3464 ui_out_text (uiout
, "in ");
3465 ui_out_field_string (uiout
, "func",
3466 SYMBOL_PRINT_NAME (sym
));
3467 ui_out_wrap_hint (uiout
, wrap_indent
);
3468 ui_out_text (uiout
, " at ");
3470 ui_out_field_string (uiout
, "file", b
->source_file
);
3471 ui_out_text (uiout
, ":");
3473 if (ui_out_is_mi_like_p (uiout
))
3475 struct symtab_and_line sal
= find_pc_line (loc
->address
, 0);
3476 char *fullname
= symtab_to_fullname (sal
.symtab
);
3479 ui_out_field_string (uiout
, "fullname", fullname
);
3482 ui_out_field_int (uiout
, "line", b
->line_number
);
3486 ui_out_field_string (uiout
, "pending", b
->addr_string
);
3490 print_address_symbolic (loc
->address
, stb
->stream
, demangle
, "");
3491 ui_out_field_stream (uiout
, "at", stb
);
3495 /* Print B to gdb_stdout. */
3497 print_one_breakpoint_location (struct breakpoint
*b
,
3498 struct bp_location
*loc
,
3500 CORE_ADDR
*last_addr
)
3502 struct command_line
*l
;
3504 struct ep_type_description
3509 static struct ep_type_description bptypes
[] =
3511 {bp_none
, "?deleted?"},
3512 {bp_breakpoint
, "breakpoint"},
3513 {bp_hardware_breakpoint
, "hw breakpoint"},
3514 {bp_until
, "until"},
3515 {bp_finish
, "finish"},
3516 {bp_watchpoint
, "watchpoint"},
3517 {bp_hardware_watchpoint
, "hw watchpoint"},
3518 {bp_read_watchpoint
, "read watchpoint"},
3519 {bp_access_watchpoint
, "acc watchpoint"},
3520 {bp_longjmp
, "longjmp"},
3521 {bp_longjmp_resume
, "longjmp resume"},
3522 {bp_step_resume
, "step resume"},
3523 {bp_watchpoint_scope
, "watchpoint scope"},
3524 {bp_call_dummy
, "call dummy"},
3525 {bp_shlib_event
, "shlib events"},
3526 {bp_thread_event
, "thread events"},
3527 {bp_overlay_event
, "overlay events"},
3528 {bp_catch_load
, "catch load"},
3529 {bp_catch_unload
, "catch unload"},
3530 {bp_catch_fork
, "catch fork"},
3531 {bp_catch_vfork
, "catch vfork"},
3532 {bp_catch_exec
, "catch exec"}
3535 static char bpenables
[] = "nynny";
3536 char wrap_indent
[80];
3537 struct ui_stream
*stb
= ui_out_stream_new (uiout
);
3538 struct cleanup
*old_chain
= make_cleanup_ui_out_stream_delete (stb
);
3539 struct cleanup
*bkpt_chain
;
3541 int header_of_multiple
= 0;
3542 int part_of_multiple
= (loc
!= NULL
);
3544 gdb_assert (!loc
|| loc_number
!= 0);
3545 /* See comment in print_one_breakpoint concerning
3546 treatment of breakpoints with single disabled
3550 && (b
->loc
->next
!= NULL
|| !b
->loc
->enabled
)))
3551 header_of_multiple
= 1;
3556 bkpt_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "bkpt");
3560 if (part_of_multiple
)
3563 formatted
= xstrprintf ("%d.%d", b
->number
, loc_number
);
3564 ui_out_field_string (uiout
, "number", formatted
);
3569 ui_out_field_int (uiout
, "number", b
->number
);
3574 if (part_of_multiple
)
3575 ui_out_field_skip (uiout
, "type");
3578 if (((int) b
->type
>= (sizeof (bptypes
) / sizeof (bptypes
[0])))
3579 || ((int) b
->type
!= bptypes
[(int) b
->type
].type
))
3580 internal_error (__FILE__
, __LINE__
,
3581 _("bptypes table does not describe type #%d."),
3583 ui_out_field_string (uiout
, "type", bptypes
[(int) b
->type
].description
);
3588 if (part_of_multiple
)
3589 ui_out_field_skip (uiout
, "disp");
3591 ui_out_field_string (uiout
, "disp", bpdisp_text (b
->disposition
));
3596 if (part_of_multiple
)
3597 ui_out_field_string (uiout
, "enabled", loc
->enabled
? "y" : "n");
3599 ui_out_field_fmt (uiout
, "enabled", "%c",
3600 bpenables
[(int) b
->enable_state
]);
3601 ui_out_spaces (uiout
, 2);
3605 strcpy (wrap_indent
, " ");
3608 if (gdbarch_addr_bit (current_gdbarch
) <= 32)
3609 strcat (wrap_indent
, " ");
3611 strcat (wrap_indent
, " ");
3614 if (b
->ops
!= NULL
&& b
->ops
->print_one
!= NULL
)
3616 /* Although the print_one can possibly print
3617 all locations, calling it here is not likely
3618 to get any nice result. So, make sure there's
3619 just one location. */
3620 gdb_assert (b
->loc
== NULL
|| b
->loc
->next
== NULL
);
3621 b
->ops
->print_one (b
, last_addr
);
3627 internal_error (__FILE__
, __LINE__
,
3628 _("print_one_breakpoint: bp_none encountered\n"));
3632 case bp_hardware_watchpoint
:
3633 case bp_read_watchpoint
:
3634 case bp_access_watchpoint
:
3635 /* Field 4, the address, is omitted (which makes the columns
3636 not line up too nicely with the headers, but the effect
3637 is relatively readable). */
3639 ui_out_field_skip (uiout
, "addr");
3641 print_expression (b
->exp
, stb
->stream
);
3642 ui_out_field_stream (uiout
, "what", stb
);
3646 case bp_catch_unload
:
3647 /* Field 4, the address, is omitted (which makes the columns
3648 not line up too nicely with the headers, but the effect
3649 is relatively readable). */
3651 ui_out_field_skip (uiout
, "addr");
3653 if (b
->dll_pathname
== NULL
)
3655 ui_out_field_string (uiout
, "what", "<any library>");
3656 ui_out_spaces (uiout
, 1);
3660 ui_out_text (uiout
, "library \"");
3661 ui_out_field_string (uiout
, "what", b
->dll_pathname
);
3662 ui_out_text (uiout
, "\" ");
3667 case bp_catch_vfork
:
3668 /* Field 4, the address, is omitted (which makes the columns
3669 not line up too nicely with the headers, but the effect
3670 is relatively readable). */
3672 ui_out_field_skip (uiout
, "addr");
3674 if (!ptid_equal (b
->forked_inferior_pid
, null_ptid
))
3676 ui_out_text (uiout
, "process ");
3677 ui_out_field_int (uiout
, "what",
3678 ptid_get_pid (b
->forked_inferior_pid
));
3679 ui_out_spaces (uiout
, 1);
3684 /* Field 4, the address, is omitted (which makes the columns
3685 not line up too nicely with the headers, but the effect
3686 is relatively readable). */
3688 ui_out_field_skip (uiout
, "addr");
3690 if (b
->exec_pathname
!= NULL
)
3692 ui_out_text (uiout
, "program \"");
3693 ui_out_field_string (uiout
, "what", b
->exec_pathname
);
3694 ui_out_text (uiout
, "\" ");
3699 case bp_hardware_breakpoint
:
3703 case bp_longjmp_resume
:
3704 case bp_step_resume
:
3705 case bp_watchpoint_scope
:
3707 case bp_shlib_event
:
3708 case bp_thread_event
:
3709 case bp_overlay_event
:
3713 if (header_of_multiple
)
3714 ui_out_field_string (uiout
, "addr", "<MULTIPLE>");
3715 else if (b
->loc
== NULL
|| loc
->shlib_disabled
)
3716 ui_out_field_string (uiout
, "addr", "<PENDING>");
3718 ui_out_field_core_addr (uiout
, "addr", loc
->address
);
3721 if (!header_of_multiple
)
3722 print_breakpoint_location (b
, loc
, wrap_indent
, stb
);
3724 *last_addr
= b
->loc
->address
;
3728 if (!part_of_multiple
&& b
->thread
!= -1)
3730 /* FIXME: This seems to be redundant and lost here; see the
3731 "stop only in" line a little further down. */
3732 ui_out_text (uiout
, " thread ");
3733 ui_out_field_int (uiout
, "thread", b
->thread
);
3736 ui_out_text (uiout
, "\n");
3738 if (part_of_multiple
&& frame_id_p (b
->frame_id
))
3741 ui_out_text (uiout
, "\tstop only in stack frame at ");
3742 /* FIXME: cagney/2002-12-01: Shouldn't be poeking around inside
3744 ui_out_field_core_addr (uiout
, "frame", b
->frame_id
.stack_addr
);
3745 ui_out_text (uiout
, "\n");
3748 if (!part_of_multiple
&& b
->cond_string
&& !ada_exception_catchpoint_p (b
))
3750 /* We do not print the condition for Ada exception catchpoints
3751 because the condition is an internal implementation detail
3752 that we do not want to expose to the user. */
3754 ui_out_text (uiout
, "\tstop only if ");
3755 ui_out_field_string (uiout
, "cond", b
->cond_string
);
3756 ui_out_text (uiout
, "\n");
3759 if (!part_of_multiple
&& b
->thread
!= -1)
3761 /* FIXME should make an annotation for this */
3762 ui_out_text (uiout
, "\tstop only in thread ");
3763 ui_out_field_int (uiout
, "thread", b
->thread
);
3764 ui_out_text (uiout
, "\n");
3767 if (!part_of_multiple
&& show_breakpoint_hit_counts
&& b
->hit_count
)
3769 /* FIXME should make an annotation for this */
3770 if (ep_is_catchpoint (b
))
3771 ui_out_text (uiout
, "\tcatchpoint");
3773 ui_out_text (uiout
, "\tbreakpoint");
3774 ui_out_text (uiout
, " already hit ");
3775 ui_out_field_int (uiout
, "times", b
->hit_count
);
3776 if (b
->hit_count
== 1)
3777 ui_out_text (uiout
, " time\n");
3779 ui_out_text (uiout
, " times\n");
3782 /* Output the count also if it is zero, but only if this is
3783 mi. FIXME: Should have a better test for this. */
3784 if (ui_out_is_mi_like_p (uiout
))
3785 if (!part_of_multiple
&& show_breakpoint_hit_counts
&& b
->hit_count
== 0)
3786 ui_out_field_int (uiout
, "times", b
->hit_count
);
3788 if (!part_of_multiple
&& b
->ignore_count
)
3791 ui_out_text (uiout
, "\tignore next ");
3792 ui_out_field_int (uiout
, "ignore", b
->ignore_count
);
3793 ui_out_text (uiout
, " hits\n");
3796 if (!part_of_multiple
&& (l
= b
->commands
))
3798 struct cleanup
*script_chain
;
3801 script_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "script");
3802 print_command_lines (uiout
, l
, 4);
3803 do_cleanups (script_chain
);
3806 if (ui_out_is_mi_like_p (uiout
) && !part_of_multiple
)
3809 ui_out_field_string (uiout
, "original-location", b
->addr_string
);
3810 else if (b
->exp_string
)
3811 ui_out_field_string (uiout
, "original-location", b
->exp_string
);
3814 do_cleanups (bkpt_chain
);
3815 do_cleanups (old_chain
);
3819 print_one_breakpoint (struct breakpoint
*b
,
3820 CORE_ADDR
*last_addr
)
3822 print_one_breakpoint_location (b
, NULL
, 0, last_addr
);
3824 /* If this breakpoint has custom print function,
3825 it's already printed. Otherwise, print individual
3826 locations, if any. */
3827 if (b
->ops
== NULL
|| b
->ops
->print_one
== NULL
)
3829 /* If breakpoint has a single location that is
3830 disabled, we print it as if it had
3831 several locations, since otherwise it's hard to
3832 represent "breakpoint enabled, location disabled"
3834 Note that while hardware watchpoints have
3835 several locations internally, that's no a property
3838 && !is_hardware_watchpoint (b
)
3839 && (b
->loc
->next
|| !b
->loc
->enabled
)
3840 && !ui_out_is_mi_like_p (uiout
))
3842 struct bp_location
*loc
;
3844 for (loc
= b
->loc
; loc
; loc
= loc
->next
, ++n
)
3845 print_one_breakpoint_location (b
, loc
, n
, last_addr
);
3851 struct captured_breakpoint_query_args
3857 do_captured_breakpoint_query (struct ui_out
*uiout
, void *data
)
3859 struct captured_breakpoint_query_args
*args
= data
;
3860 struct breakpoint
*b
;
3861 CORE_ADDR dummy_addr
= 0;
3864 if (args
->bnum
== b
->number
)
3866 print_one_breakpoint (b
, &dummy_addr
);
3874 gdb_breakpoint_query (struct ui_out
*uiout
, int bnum
, char **error_message
)
3876 struct captured_breakpoint_query_args args
;
3878 /* For the moment we don't trust print_one_breakpoint() to not throw
3880 if (catch_exceptions_with_msg (uiout
, do_captured_breakpoint_query
, &args
,
3881 error_message
, RETURN_MASK_ALL
) < 0)
3887 /* Return non-zero if B is user settable (breakpoints, watchpoints,
3888 catchpoints, et.al.). */
3891 user_settable_breakpoint (const struct breakpoint
*b
)
3893 return (b
->type
== bp_breakpoint
3894 || b
->type
== bp_catch_load
3895 || b
->type
== bp_catch_unload
3896 || b
->type
== bp_catch_fork
3897 || b
->type
== bp_catch_vfork
3898 || b
->type
== bp_catch_exec
3899 || b
->type
== bp_hardware_breakpoint
3900 || b
->type
== bp_watchpoint
3901 || b
->type
== bp_read_watchpoint
3902 || b
->type
== bp_access_watchpoint
3903 || b
->type
== bp_hardware_watchpoint
);
3906 /* Print information on user settable breakpoint (watchpoint, etc)
3907 number BNUM. If BNUM is -1 print all user settable breakpoints.
3908 If ALLFLAG is non-zero, include non- user settable breakpoints. */
3911 breakpoint_1 (int bnum
, int allflag
)
3913 struct breakpoint
*b
;
3914 CORE_ADDR last_addr
= (CORE_ADDR
) -1;
3915 int nr_printable_breakpoints
;
3916 struct cleanup
*bkpttbl_chain
;
3918 /* Compute the number of rows in the table. */
3919 nr_printable_breakpoints
= 0;
3922 || bnum
== b
->number
)
3924 if (allflag
|| user_settable_breakpoint (b
))
3925 nr_printable_breakpoints
++;
3930 = make_cleanup_ui_out_table_begin_end (uiout
, 6, nr_printable_breakpoints
,
3934 = make_cleanup_ui_out_table_begin_end (uiout
, 5, nr_printable_breakpoints
,
3937 if (nr_printable_breakpoints
> 0)
3938 annotate_breakpoints_headers ();
3939 if (nr_printable_breakpoints
> 0)
3941 ui_out_table_header (uiout
, 7, ui_left
, "number", "Num"); /* 1 */
3942 if (nr_printable_breakpoints
> 0)
3944 ui_out_table_header (uiout
, 14, ui_left
, "type", "Type"); /* 2 */
3945 if (nr_printable_breakpoints
> 0)
3947 ui_out_table_header (uiout
, 4, ui_left
, "disp", "Disp"); /* 3 */
3948 if (nr_printable_breakpoints
> 0)
3950 ui_out_table_header (uiout
, 3, ui_left
, "enabled", "Enb"); /* 4 */
3953 if (nr_printable_breakpoints
> 0)
3955 if (gdbarch_addr_bit (current_gdbarch
) <= 32)
3956 ui_out_table_header (uiout
, 10, ui_left
, "addr", "Address");/* 5 */
3958 ui_out_table_header (uiout
, 18, ui_left
, "addr", "Address");/* 5 */
3960 if (nr_printable_breakpoints
> 0)
3962 ui_out_table_header (uiout
, 40, ui_noalign
, "what", "What"); /* 6 */
3963 ui_out_table_body (uiout
);
3964 if (nr_printable_breakpoints
> 0)
3965 annotate_breakpoints_table ();
3969 || bnum
== b
->number
)
3971 /* We only print out user settable breakpoints unless the
3973 if (allflag
|| user_settable_breakpoint (b
))
3974 print_one_breakpoint (b
, &last_addr
);
3977 do_cleanups (bkpttbl_chain
);
3979 if (nr_printable_breakpoints
== 0)
3982 ui_out_message (uiout
, 0, "No breakpoints or watchpoints.\n");
3984 ui_out_message (uiout
, 0, "No breakpoint or watchpoint number %d.\n",
3989 /* Compare against (CORE_ADDR)-1 in case some compiler decides
3990 that a comparison of an unsigned with -1 is always false. */
3991 if (last_addr
!= (CORE_ADDR
) -1 && !server_command
)
3992 set_next_address (last_addr
);
3995 /* FIXME? Should this be moved up so that it is only called when
3996 there have been breakpoints? */
3997 annotate_breakpoints_table_end ();
4001 breakpoints_info (char *bnum_exp
, int from_tty
)
4006 bnum
= parse_and_eval_long (bnum_exp
);
4008 breakpoint_1 (bnum
, 0);
4012 maintenance_info_breakpoints (char *bnum_exp
, int from_tty
)
4017 bnum
= parse_and_eval_long (bnum_exp
);
4019 breakpoint_1 (bnum
, 1);
4023 breakpoint_has_pc (struct breakpoint
*b
, CORE_ADDR pc
, asection
*section
)
4025 struct bp_location
*bl
= b
->loc
;
4026 for (; bl
; bl
= bl
->next
)
4028 if (bl
->address
== pc
4029 && (!overlay_debugging
|| bl
->section
== section
))
4035 /* Print a message describing any breakpoints set at PC. */
4038 describe_other_breakpoints (CORE_ADDR pc
, asection
*section
, int thread
)
4041 struct breakpoint
*b
;
4044 others
+= breakpoint_has_pc (b
, pc
, section
);
4048 printf_filtered (_("Note: breakpoint "));
4049 else /* if (others == ???) */
4050 printf_filtered (_("Note: breakpoints "));
4052 if (breakpoint_has_pc (b
, pc
, section
))
4055 printf_filtered ("%d", b
->number
);
4056 if (b
->thread
== -1 && thread
!= -1)
4057 printf_filtered (" (all threads)");
4058 else if (b
->thread
!= -1)
4059 printf_filtered (" (thread %d)", b
->thread
);
4060 printf_filtered ("%s%s ",
4061 ((b
->enable_state
== bp_disabled
||
4062 b
->enable_state
== bp_call_disabled
)
4064 : b
->enable_state
== bp_permanent
4068 : ((others
== 1) ? " and" : ""));
4070 printf_filtered (_("also set at pc "));
4071 fputs_filtered (paddress (pc
), gdb_stdout
);
4072 printf_filtered (".\n");
4076 /* Set the default place to put a breakpoint
4077 for the `break' command with no arguments. */
4080 set_default_breakpoint (int valid
, CORE_ADDR addr
, struct symtab
*symtab
,
4083 default_breakpoint_valid
= valid
;
4084 default_breakpoint_address
= addr
;
4085 default_breakpoint_symtab
= symtab
;
4086 default_breakpoint_line
= line
;
4089 /* Return true iff it is meaningful to use the address member of
4090 BPT. For some breakpoint types, the address member is irrelevant
4091 and it makes no sense to attempt to compare it to other addresses
4092 (or use it for any other purpose either).
4094 More specifically, each of the following breakpoint types will always
4095 have a zero valued address and we don't want check_duplicates() to mark
4096 breakpoints of any of these types to be a duplicate of an actual
4097 breakpoint at address zero:
4100 bp_hardware_watchpoint
4102 bp_access_watchpoint
4108 breakpoint_address_is_meaningful (struct breakpoint
*bpt
)
4110 enum bptype type
= bpt
->type
;
4112 return (type
!= bp_watchpoint
4113 && type
!= bp_hardware_watchpoint
4114 && type
!= bp_read_watchpoint
4115 && type
!= bp_access_watchpoint
4116 && type
!= bp_catch_exec
4117 && type
!= bp_catch_fork
4118 && type
!= bp_catch_vfork
);
4121 /* Rescan breakpoints at the same address and section as BPT,
4122 marking the first one as "first" and any others as "duplicates".
4123 This is so that the bpt instruction is only inserted once.
4124 If we have a permanent breakpoint at the same place as BPT, make
4125 that one the official one, and the rest as duplicates. */
4128 check_duplicates_for (CORE_ADDR address
, asection
*section
)
4130 struct bp_location
*b
;
4132 struct bp_location
*perm_bp
= 0;
4134 ALL_BP_LOCATIONS (b
)
4135 if (b
->owner
->enable_state
!= bp_disabled
4136 && b
->owner
->enable_state
!= bp_call_disabled
4138 && !b
->shlib_disabled
4139 && b
->address
== address
/* address / overlay match */
4140 && (!overlay_debugging
|| b
->section
== section
)
4141 && breakpoint_address_is_meaningful (b
->owner
))
4143 /* Have we found a permanent breakpoint? */
4144 if (b
->owner
->enable_state
== bp_permanent
)
4151 b
->duplicate
= count
> 1;
4154 /* If we found a permanent breakpoint at this address, go over the
4155 list again and declare all the other breakpoints there to be the
4159 perm_bp
->duplicate
= 0;
4161 /* Permanent breakpoint should always be inserted. */
4162 if (! perm_bp
->inserted
)
4163 internal_error (__FILE__
, __LINE__
,
4164 _("allegedly permanent breakpoint is not "
4165 "actually inserted"));
4167 ALL_BP_LOCATIONS (b
)
4170 if (b
->owner
->enable_state
!= bp_disabled
4171 && b
->owner
->enable_state
!= bp_call_disabled
4172 && b
->enabled
&& !b
->shlib_disabled
4173 && b
->address
== address
/* address / overlay match */
4174 && (!overlay_debugging
|| b
->section
== section
)
4175 && breakpoint_address_is_meaningful (b
->owner
))
4178 internal_error (__FILE__
, __LINE__
,
4179 _("another breakpoint was inserted on top of "
4180 "a permanent breakpoint"));
4189 check_duplicates (struct breakpoint
*bpt
)
4191 struct bp_location
*bl
= bpt
->loc
;
4193 if (! breakpoint_address_is_meaningful (bpt
))
4196 for (; bl
; bl
= bl
->next
)
4197 check_duplicates_for (bl
->address
, bl
->section
);
4201 breakpoint_adjustment_warning (CORE_ADDR from_addr
, CORE_ADDR to_addr
,
4202 int bnum
, int have_bnum
)
4207 strcpy (astr1
, hex_string_custom ((unsigned long) from_addr
, 8));
4208 strcpy (astr2
, hex_string_custom ((unsigned long) to_addr
, 8));
4210 warning (_("Breakpoint %d address previously adjusted from %s to %s."),
4211 bnum
, astr1
, astr2
);
4213 warning (_("Breakpoint address adjusted from %s to %s."), astr1
, astr2
);
4216 /* Adjust a breakpoint's address to account for architectural constraints
4217 on breakpoint placement. Return the adjusted address. Note: Very
4218 few targets require this kind of adjustment. For most targets,
4219 this function is simply the identity function. */
4222 adjust_breakpoint_address (CORE_ADDR bpaddr
, enum bptype bptype
)
4224 if (!gdbarch_adjust_breakpoint_address_p (current_gdbarch
))
4226 /* Very few targets need any kind of breakpoint adjustment. */
4229 else if (bptype
== bp_watchpoint
4230 || bptype
== bp_hardware_watchpoint
4231 || bptype
== bp_read_watchpoint
4232 || bptype
== bp_access_watchpoint
4233 || bptype
== bp_catch_fork
4234 || bptype
== bp_catch_vfork
4235 || bptype
== bp_catch_exec
)
4237 /* Watchpoints and the various bp_catch_* eventpoints should not
4238 have their addresses modified. */
4243 CORE_ADDR adjusted_bpaddr
;
4245 /* Some targets have architectural constraints on the placement
4246 of breakpoint instructions. Obtain the adjusted address. */
4247 adjusted_bpaddr
= gdbarch_adjust_breakpoint_address (current_gdbarch
,
4250 /* An adjusted breakpoint address can significantly alter
4251 a user's expectations. Print a warning if an adjustment
4253 if (adjusted_bpaddr
!= bpaddr
)
4254 breakpoint_adjustment_warning (bpaddr
, adjusted_bpaddr
, 0, 0);
4256 return adjusted_bpaddr
;
4260 /* Allocate a struct bp_location. */
4262 static struct bp_location
*
4263 allocate_bp_location (struct breakpoint
*bpt
, enum bptype bp_type
)
4265 struct bp_location
*loc
, *loc_p
;
4267 loc
= xmalloc (sizeof (struct bp_location
));
4268 memset (loc
, 0, sizeof (*loc
));
4272 loc
->shlib_disabled
= 0;
4281 case bp_longjmp_resume
:
4282 case bp_step_resume
:
4283 case bp_watchpoint_scope
:
4285 case bp_shlib_event
:
4286 case bp_thread_event
:
4287 case bp_overlay_event
:
4289 case bp_catch_unload
:
4290 loc
->loc_type
= bp_loc_software_breakpoint
;
4292 case bp_hardware_breakpoint
:
4293 loc
->loc_type
= bp_loc_hardware_breakpoint
;
4295 case bp_hardware_watchpoint
:
4296 case bp_read_watchpoint
:
4297 case bp_access_watchpoint
:
4298 loc
->loc_type
= bp_loc_hardware_watchpoint
;
4302 case bp_catch_vfork
:
4304 loc
->loc_type
= bp_loc_other
;
4307 internal_error (__FILE__
, __LINE__
, _("unknown breakpoint type"));
4313 static void free_bp_location (struct bp_location
*loc
)
4318 if (loc
->function_name
)
4319 xfree (loc
->function_name
);
4324 /* Helper to set_raw_breakpoint below. Creates a breakpoint
4325 that has type BPTYPE and has no locations as yet. */
4327 static struct breakpoint
*
4328 set_raw_breakpoint_without_location (enum bptype bptype
)
4330 struct breakpoint
*b
, *b1
;
4332 b
= (struct breakpoint
*) xmalloc (sizeof (struct breakpoint
));
4333 memset (b
, 0, sizeof (*b
));
4336 b
->language
= current_language
->la_language
;
4337 b
->input_radix
= input_radix
;
4339 b
->enable_state
= bp_enabled
;
4342 b
->ignore_count
= 0;
4344 b
->frame_id
= null_frame_id
;
4345 b
->dll_pathname
= NULL
;
4346 b
->triggered_dll_pathname
= NULL
;
4347 b
->forked_inferior_pid
= null_ptid
;
4348 b
->exec_pathname
= NULL
;
4350 b
->condition_not_parsed
= 0;
4352 /* Add this breakpoint to the end of the chain
4353 so that a list of breakpoints will come out in order
4354 of increasing numbers. */
4356 b1
= breakpoint_chain
;
4358 breakpoint_chain
= b
;
4368 /* Initialize loc->function_name. */
4370 set_breakpoint_location_function (struct bp_location
*loc
)
4372 if (loc
->owner
->type
== bp_breakpoint
4373 || loc
->owner
->type
== bp_hardware_breakpoint
)
4375 find_pc_partial_function (loc
->address
, &(loc
->function_name
),
4377 if (loc
->function_name
)
4378 loc
->function_name
= xstrdup (loc
->function_name
);
4382 /* set_raw_breakpoint is a low level routine for allocating and
4383 partially initializing a breakpoint of type BPTYPE. The newly
4384 created breakpoint's address, section, source file name, and line
4385 number are provided by SAL. The newly created and partially
4386 initialized breakpoint is added to the breakpoint chain and
4387 is also returned as the value of this function.
4389 It is expected that the caller will complete the initialization of
4390 the newly created breakpoint struct as well as output any status
4391 information regarding the creation of a new breakpoint. In
4392 particular, set_raw_breakpoint does NOT set the breakpoint
4393 number! Care should be taken to not allow an error to occur
4394 prior to completing the initialization of the breakpoint. If this
4395 should happen, a bogus breakpoint will be left on the chain. */
4398 set_raw_breakpoint (struct symtab_and_line sal
, enum bptype bptype
)
4400 struct breakpoint
*b
= set_raw_breakpoint_without_location (bptype
);
4401 CORE_ADDR adjusted_address
;
4403 /* Adjust the breakpoint's address prior to allocating a location.
4404 Once we call allocate_bp_location(), that mostly uninitialized
4405 location will be placed on the location chain. Adjustment of the
4406 breakpoint may cause target_read_memory() to be called and we do
4407 not want its scan of the location chain to find a breakpoint and
4408 location that's only been partially initialized. */
4409 adjusted_address
= adjust_breakpoint_address (sal
.pc
, bptype
);
4411 b
->loc
= allocate_bp_location (b
, bptype
);
4412 b
->loc
->requested_address
= sal
.pc
;
4413 b
->loc
->address
= adjusted_address
;
4415 if (sal
.symtab
== NULL
)
4416 b
->source_file
= NULL
;
4418 b
->source_file
= savestring (sal
.symtab
->filename
,
4419 strlen (sal
.symtab
->filename
));
4420 b
->loc
->section
= sal
.section
;
4421 b
->line_number
= sal
.line
;
4423 set_breakpoint_location_function (b
->loc
);
4425 breakpoints_changed ();
4431 /* Note that the breakpoint object B describes a permanent breakpoint
4432 instruction, hard-wired into the inferior's code. */
4434 make_breakpoint_permanent (struct breakpoint
*b
)
4436 struct bp_location
*bl
;
4437 b
->enable_state
= bp_permanent
;
4439 /* By definition, permanent breakpoints are already present in the code.
4440 Mark all locations as inserted. For now, make_breakpoint_permanent
4441 is called in just one place, so it's hard to say if it's reasonable
4442 to have permanent breakpoint with multiple locations or not,
4443 but it's easy to implmement. */
4444 for (bl
= b
->loc
; bl
; bl
= bl
->next
)
4448 static struct breakpoint
*
4449 create_internal_breakpoint (CORE_ADDR address
, enum bptype type
)
4451 static int internal_breakpoint_number
= -1;
4452 struct symtab_and_line sal
;
4453 struct breakpoint
*b
;
4455 init_sal (&sal
); /* initialize to zeroes */
4458 sal
.section
= find_pc_overlay (sal
.pc
);
4460 b
= set_raw_breakpoint (sal
, type
);
4461 b
->number
= internal_breakpoint_number
--;
4462 b
->disposition
= disp_donttouch
;
4469 create_longjmp_breakpoint (char *func_name
)
4471 struct breakpoint
*b
;
4472 struct minimal_symbol
*m
;
4474 if ((m
= lookup_minimal_symbol_text (func_name
, NULL
)) == NULL
)
4476 set_momentary_breakpoint_at_pc (SYMBOL_VALUE_ADDRESS (m
), bp_longjmp
);
4477 update_global_location_list (1);
4480 /* Call this routine when stepping and nexting to enable a breakpoint
4481 if we do a longjmp(). When we hit that breakpoint, call
4482 set_longjmp_resume_breakpoint() to figure out where we are going. */
4485 set_longjmp_breakpoint (void)
4487 struct breakpoint
*b
;
4489 if (gdbarch_get_longjmp_target_p (current_gdbarch
))
4491 create_longjmp_breakpoint ("longjmp");
4492 create_longjmp_breakpoint ("_longjmp");
4493 create_longjmp_breakpoint ("siglongjmp");
4494 create_longjmp_breakpoint ("_siglongjmp");
4498 /* Delete all longjmp breakpoints from THREAD. */
4500 delete_longjmp_breakpoint (int thread
)
4502 struct breakpoint
*b
, *temp
;
4504 ALL_BREAKPOINTS_SAFE (b
, temp
)
4505 if (b
->type
== bp_longjmp
)
4507 if (b
->thread
== thread
)
4508 delete_breakpoint (b
);
4513 create_overlay_event_breakpoint (char *func_name
)
4515 struct breakpoint
*b
;
4516 struct minimal_symbol
*m
;
4518 if ((m
= lookup_minimal_symbol_text (func_name
, NULL
)) == NULL
)
4521 b
= create_internal_breakpoint (SYMBOL_VALUE_ADDRESS (m
),
4523 b
->addr_string
= xstrdup (func_name
);
4525 if (overlay_debugging
== ovly_auto
)
4527 b
->enable_state
= bp_enabled
;
4528 overlay_events_enabled
= 1;
4532 b
->enable_state
= bp_disabled
;
4533 overlay_events_enabled
= 0;
4535 update_global_location_list (1);
4539 enable_overlay_breakpoints (void)
4541 struct breakpoint
*b
;
4544 if (b
->type
== bp_overlay_event
)
4546 b
->enable_state
= bp_enabled
;
4547 update_global_location_list (1);
4548 overlay_events_enabled
= 1;
4553 disable_overlay_breakpoints (void)
4555 struct breakpoint
*b
;
4558 if (b
->type
== bp_overlay_event
)
4560 b
->enable_state
= bp_disabled
;
4561 update_global_location_list (0);
4562 overlay_events_enabled
= 0;
4567 create_thread_event_breakpoint (CORE_ADDR address
)
4569 struct breakpoint
*b
;
4571 b
= create_internal_breakpoint (address
, bp_thread_event
);
4573 b
->enable_state
= bp_enabled
;
4574 /* addr_string has to be used or breakpoint_re_set will delete me. */
4575 b
->addr_string
= xstrprintf ("*0x%s", paddr (b
->loc
->address
));
4577 update_global_location_list_nothrow (1);
4583 remove_thread_event_breakpoints (void)
4585 struct breakpoint
*b
, *temp
;
4587 ALL_BREAKPOINTS_SAFE (b
, temp
)
4588 if (b
->type
== bp_thread_event
)
4589 delete_breakpoint (b
);
4592 struct captured_parse_breakpoint_args
4595 struct symtabs_and_lines
*sals_p
;
4596 char ***addr_string_p
;
4600 struct lang_and_radix
4608 remove_solib_event_breakpoints (void)
4610 struct breakpoint
*b
, *temp
;
4612 ALL_BREAKPOINTS_SAFE (b
, temp
)
4613 if (b
->type
== bp_shlib_event
)
4614 delete_breakpoint (b
);
4618 create_solib_event_breakpoint (CORE_ADDR address
)
4620 struct breakpoint
*b
;
4622 b
= create_internal_breakpoint (address
, bp_shlib_event
);
4623 update_global_location_list_nothrow (1);
4627 /* Disable any breakpoints that are on code in shared libraries. Only
4628 apply to enabled breakpoints, disabled ones can just stay disabled. */
4631 disable_breakpoints_in_shlibs (void)
4633 struct bp_location
*loc
;
4634 int disabled_shlib_breaks
= 0;
4636 ALL_BP_LOCATIONS (loc
)
4638 struct breakpoint
*b
= loc
->owner
;
4639 /* We apply the check to all breakpoints, including disabled
4640 for those with loc->duplicate set. This is so that when breakpoint
4641 becomes enabled, or the duplicate is removed, gdb will try to insert
4642 all breakpoints. If we don't set shlib_disabled here, we'll try
4643 to insert those breakpoints and fail. */
4644 if (((b
->type
== bp_breakpoint
) || (b
->type
== bp_hardware_breakpoint
))
4645 && !loc
->shlib_disabled
4647 && PC_SOLIB (loc
->address
)
4649 && solib_address (loc
->address
)
4653 loc
->shlib_disabled
= 1;
4658 /* Disable any breakpoints that are in in an unloaded shared library. Only
4659 apply to enabled breakpoints, disabled ones can just stay disabled. */
4662 disable_breakpoints_in_unloaded_shlib (struct so_list
*solib
)
4664 struct bp_location
*loc
;
4665 int disabled_shlib_breaks
= 0;
4667 ALL_BP_LOCATIONS (loc
)
4669 struct breakpoint
*b
= loc
->owner
;
4670 if ((loc
->loc_type
== bp_loc_hardware_breakpoint
4671 || loc
->loc_type
== bp_loc_software_breakpoint
)
4672 && !loc
->shlib_disabled
)
4675 char *so_name
= PC_SOLIB (loc
->address
);
4677 char *so_name
= solib_address (loc
->address
);
4679 if (so_name
&& !strcmp (so_name
, solib
->so_name
))
4681 loc
->shlib_disabled
= 1;
4682 /* At this point, we cannot rely on remove_breakpoint
4683 succeeding so we must mark the breakpoint as not inserted
4684 to prevent future errors occurring in remove_breakpoints. */
4686 if (!disabled_shlib_breaks
)
4688 target_terminal_ours_for_output ();
4689 warning (_("Temporarily disabling breakpoints for unloaded shared library \"%s\""),
4692 disabled_shlib_breaks
= 1;
4699 create_fork_vfork_event_catchpoint (int tempflag
, char *cond_string
,
4700 enum bptype bp_kind
)
4702 struct symtab_and_line sal
;
4703 struct breakpoint
*b
;
4704 int thread
= -1; /* All threads. */
4711 b
= set_raw_breakpoint (sal
, bp_kind
);
4712 set_breakpoint_count (breakpoint_count
+ 1);
4713 b
->number
= breakpoint_count
;
4714 b
->cond_string
= (cond_string
== NULL
) ?
4715 NULL
: savestring (cond_string
, strlen (cond_string
));
4717 b
->addr_string
= NULL
;
4718 b
->enable_state
= bp_enabled
;
4719 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
4720 b
->forked_inferior_pid
= null_ptid
;
4721 update_global_location_list (1);
4728 create_fork_event_catchpoint (int tempflag
, char *cond_string
)
4730 create_fork_vfork_event_catchpoint (tempflag
, cond_string
, bp_catch_fork
);
4734 create_vfork_event_catchpoint (int tempflag
, char *cond_string
)
4736 create_fork_vfork_event_catchpoint (tempflag
, cond_string
, bp_catch_vfork
);
4740 create_exec_event_catchpoint (int tempflag
, char *cond_string
)
4742 struct symtab_and_line sal
;
4743 struct breakpoint
*b
;
4744 int thread
= -1; /* All threads. */
4751 b
= set_raw_breakpoint (sal
, bp_catch_exec
);
4752 set_breakpoint_count (breakpoint_count
+ 1);
4753 b
->number
= breakpoint_count
;
4754 b
->cond_string
= (cond_string
== NULL
) ?
4755 NULL
: savestring (cond_string
, strlen (cond_string
));
4757 b
->addr_string
= NULL
;
4758 b
->enable_state
= bp_enabled
;
4759 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
4760 update_global_location_list (1);
4766 hw_breakpoint_used_count (void)
4768 struct breakpoint
*b
;
4773 if (b
->type
== bp_hardware_breakpoint
&& b
->enable_state
== bp_enabled
)
4781 hw_watchpoint_used_count (enum bptype type
, int *other_type_used
)
4783 struct breakpoint
*b
;
4786 *other_type_used
= 0;
4789 if (breakpoint_enabled (b
))
4791 if (b
->type
== type
)
4793 else if ((b
->type
== bp_hardware_watchpoint
||
4794 b
->type
== bp_read_watchpoint
||
4795 b
->type
== bp_access_watchpoint
))
4796 *other_type_used
= 1;
4803 disable_watchpoints_before_interactive_call_start (void)
4805 struct breakpoint
*b
;
4809 if (((b
->type
== bp_watchpoint
)
4810 || (b
->type
== bp_hardware_watchpoint
)
4811 || (b
->type
== bp_read_watchpoint
)
4812 || (b
->type
== bp_access_watchpoint
))
4813 && breakpoint_enabled (b
))
4815 b
->enable_state
= bp_call_disabled
;
4816 update_global_location_list (0);
4822 enable_watchpoints_after_interactive_call_stop (void)
4824 struct breakpoint
*b
;
4828 if (((b
->type
== bp_watchpoint
)
4829 || (b
->type
== bp_hardware_watchpoint
)
4830 || (b
->type
== bp_read_watchpoint
)
4831 || (b
->type
== bp_access_watchpoint
))
4832 && (b
->enable_state
== bp_call_disabled
))
4834 b
->enable_state
= bp_enabled
;
4835 update_global_location_list (1);
4841 /* Set a breakpoint that will evaporate an end of command
4842 at address specified by SAL.
4843 Restrict it to frame FRAME if FRAME is nonzero. */
4846 set_momentary_breakpoint (struct symtab_and_line sal
, struct frame_id frame_id
,
4849 struct breakpoint
*b
;
4850 b
= set_raw_breakpoint (sal
, type
);
4851 b
->enable_state
= bp_enabled
;
4852 b
->disposition
= disp_donttouch
;
4853 b
->frame_id
= frame_id
;
4855 /* If we're debugging a multi-threaded program, then we
4856 want momentary breakpoints to be active in only a
4857 single thread of control. */
4858 if (in_thread_list (inferior_ptid
))
4859 b
->thread
= pid_to_thread_id (inferior_ptid
);
4861 update_global_location_list_nothrow (1);
4867 set_momentary_breakpoint_at_pc (CORE_ADDR pc
, enum bptype type
)
4869 struct symtab_and_line sal
;
4871 sal
= find_pc_line (pc
, 0);
4873 sal
.section
= find_pc_overlay (pc
);
4874 sal
.explicit_pc
= 1;
4876 return set_momentary_breakpoint (sal
, null_frame_id
, type
);
4880 /* Tell the user we have just set a breakpoint B. */
4883 mention (struct breakpoint
*b
)
4886 struct cleanup
*old_chain
, *ui_out_chain
;
4887 struct ui_stream
*stb
;
4889 stb
= ui_out_stream_new (uiout
);
4890 old_chain
= make_cleanup_ui_out_stream_delete (stb
);
4892 /* FIXME: This is misplaced; mention() is called by things (like
4893 hitting a watchpoint) other than breakpoint creation. It should
4894 be possible to clean this up and at the same time replace the
4895 random calls to breakpoint_changed with this hook, as has already
4896 been done for deprecated_delete_breakpoint_hook and so on. */
4897 if (deprecated_create_breakpoint_hook
)
4898 deprecated_create_breakpoint_hook (b
);
4899 breakpoint_create_event (b
->number
);
4901 if (b
->ops
!= NULL
&& b
->ops
->print_mention
!= NULL
)
4902 b
->ops
->print_mention (b
);
4907 printf_filtered (_("(apparently deleted?) Eventpoint %d: "), b
->number
);
4910 ui_out_text (uiout
, "Watchpoint ");
4911 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "wpt");
4912 ui_out_field_int (uiout
, "number", b
->number
);
4913 ui_out_text (uiout
, ": ");
4914 print_expression (b
->exp
, stb
->stream
);
4915 ui_out_field_stream (uiout
, "exp", stb
);
4916 do_cleanups (ui_out_chain
);
4918 case bp_hardware_watchpoint
:
4919 ui_out_text (uiout
, "Hardware watchpoint ");
4920 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "wpt");
4921 ui_out_field_int (uiout
, "number", b
->number
);
4922 ui_out_text (uiout
, ": ");
4923 print_expression (b
->exp
, stb
->stream
);
4924 ui_out_field_stream (uiout
, "exp", stb
);
4925 do_cleanups (ui_out_chain
);
4927 case bp_read_watchpoint
:
4928 ui_out_text (uiout
, "Hardware read watchpoint ");
4929 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "hw-rwpt");
4930 ui_out_field_int (uiout
, "number", b
->number
);
4931 ui_out_text (uiout
, ": ");
4932 print_expression (b
->exp
, stb
->stream
);
4933 ui_out_field_stream (uiout
, "exp", stb
);
4934 do_cleanups (ui_out_chain
);
4936 case bp_access_watchpoint
:
4937 ui_out_text (uiout
, "Hardware access (read/write) watchpoint ");
4938 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "hw-awpt");
4939 ui_out_field_int (uiout
, "number", b
->number
);
4940 ui_out_text (uiout
, ": ");
4941 print_expression (b
->exp
, stb
->stream
);
4942 ui_out_field_stream (uiout
, "exp", stb
);
4943 do_cleanups (ui_out_chain
);
4946 if (ui_out_is_mi_like_p (uiout
))
4951 if (b
->disposition
== disp_del
)
4952 printf_filtered (_("Temporary breakpoint"));
4954 printf_filtered (_("Breakpoint"));
4955 printf_filtered (_(" %d"), b
->number
);
4958 case bp_hardware_breakpoint
:
4959 if (ui_out_is_mi_like_p (uiout
))
4964 printf_filtered (_("Hardware assisted breakpoint %d"), b
->number
);
4968 case bp_catch_unload
:
4969 printf_filtered (_("Catchpoint %d (%s %s)"),
4971 (b
->type
== bp_catch_load
) ? "load" : "unload",
4972 (b
->dll_pathname
!= NULL
) ?
4973 b
->dll_pathname
: "<any library>");
4976 case bp_catch_vfork
:
4977 printf_filtered (_("Catchpoint %d (%s)"),
4979 (b
->type
== bp_catch_fork
) ? "fork" : "vfork");
4982 printf_filtered (_("Catchpoint %d (exec)"),
4989 case bp_longjmp_resume
:
4990 case bp_step_resume
:
4992 case bp_watchpoint_scope
:
4993 case bp_shlib_event
:
4994 case bp_thread_event
:
4995 case bp_overlay_event
:
5001 /* i18n: cagney/2005-02-11: Below needs to be merged into a
5005 printf_filtered (_(" (%s) pending."), b
->addr_string
);
5009 if (addressprint
|| b
->source_file
== NULL
)
5011 printf_filtered (" at ");
5012 fputs_filtered (paddress (b
->loc
->address
), gdb_stdout
);
5015 printf_filtered (": file %s, line %d.",
5016 b
->source_file
, b
->line_number
);
5020 struct bp_location
*loc
= b
->loc
;
5022 for (; loc
; loc
= loc
->next
)
5024 printf_filtered (" (%d locations)", n
);
5029 do_cleanups (old_chain
);
5030 if (ui_out_is_mi_like_p (uiout
))
5032 printf_filtered ("\n");
5036 static struct bp_location
*
5037 add_location_to_breakpoint (struct breakpoint
*b
, enum bptype bptype
,
5038 const struct symtab_and_line
*sal
)
5040 struct bp_location
*loc
, **tmp
;
5042 loc
= allocate_bp_location (b
, bptype
);
5043 for (tmp
= &(b
->loc
); *tmp
!= NULL
; tmp
= &((*tmp
)->next
))
5046 loc
->requested_address
= sal
->pc
;
5047 loc
->address
= adjust_breakpoint_address (loc
->requested_address
,
5049 loc
->section
= sal
->section
;
5051 set_breakpoint_location_function (loc
);
5055 /* Create a breakpoint with SAL as location. Use ADDR_STRING
5056 as textual description of the location, and COND_STRING
5057 as condition expression. */
5060 create_breakpoint (struct symtabs_and_lines sals
, char *addr_string
,
5062 enum bptype type
, enum bpdisp disposition
,
5063 int thread
, int ignore_count
,
5064 struct breakpoint_ops
*ops
, int from_tty
)
5066 struct breakpoint
*b
= NULL
;
5069 if (type
== bp_hardware_breakpoint
)
5071 int i
= hw_breakpoint_used_count ();
5072 int target_resources_ok
=
5073 TARGET_CAN_USE_HARDWARE_WATCHPOINT (bp_hardware_breakpoint
,
5075 if (target_resources_ok
== 0)
5076 error (_("No hardware breakpoint support in the target."));
5077 else if (target_resources_ok
< 0)
5078 error (_("Hardware breakpoints used exceeds limit."));
5081 for (i
= 0; i
< sals
.nelts
; ++i
)
5083 struct symtab_and_line sal
= sals
.sals
[i
];
5084 struct bp_location
*loc
;
5087 describe_other_breakpoints (sal
.pc
, sal
.section
, thread
);
5091 b
= set_raw_breakpoint (sal
, type
);
5092 set_breakpoint_count (breakpoint_count
+ 1);
5093 b
->number
= breakpoint_count
;
5096 b
->cond_string
= cond_string
;
5097 b
->ignore_count
= ignore_count
;
5098 b
->enable_state
= bp_enabled
;
5099 b
->disposition
= disposition
;
5105 loc
= add_location_to_breakpoint (b
, type
, &sal
);
5110 char *arg
= b
->cond_string
;
5111 loc
->cond
= parse_exp_1 (&arg
, block_for_pc (loc
->address
), 0);
5113 error (_("Garbage %s follows condition"), arg
);
5118 b
->addr_string
= addr_string
;
5120 /* addr_string has to be used or breakpoint_re_set will delete
5122 b
->addr_string
= xstrprintf ("*0x%s", paddr (b
->loc
->address
));
5128 /* Remove element at INDEX_TO_REMOVE from SAL, shifting other
5129 elements to fill the void space. */
5130 static void remove_sal (struct symtabs_and_lines
*sal
, int index_to_remove
)
5132 int i
= index_to_remove
+1;
5133 int last_index
= sal
->nelts
-1;
5135 for (;i
<= last_index
; ++i
)
5136 sal
->sals
[i
-1] = sal
->sals
[i
];
5141 /* If appropriate, obtains all sals that correspond
5142 to the same file and line as SAL. This is done
5143 only if SAL does not have explicit PC and has
5144 line and file information. If we got just a single
5145 expanded sal, return the original.
5147 Otherwise, if SAL.explicit_line is not set, filter out
5148 all sals for which the name of enclosing function
5149 is different from SAL. This makes sure that if we have
5150 breakpoint originally set in template instantiation, say
5151 foo<int>(), we won't expand SAL to locations at the same
5152 line in all existing instantiations of 'foo'.
5155 struct symtabs_and_lines
5156 expand_line_sal_maybe (struct symtab_and_line sal
)
5158 struct symtabs_and_lines expanded
;
5159 CORE_ADDR original_pc
= sal
.pc
;
5160 char *original_function
= NULL
;
5164 /* If we have explicit pc, don't expand.
5165 If we have no line number, we can't expand. */
5166 if (sal
.explicit_pc
|| sal
.line
== 0 || sal
.symtab
== NULL
)
5169 expanded
.sals
= xmalloc (sizeof (struct symtab_and_line
));
5170 expanded
.sals
[0] = sal
;
5175 find_pc_partial_function (original_pc
, &original_function
, NULL
, NULL
);
5177 expanded
= expand_line_sal (sal
);
5178 if (expanded
.nelts
== 1)
5180 /* We had one sal, we got one sal. Without futher
5181 processing, just return the original sal. */
5182 xfree (expanded
.sals
);
5184 expanded
.sals
= xmalloc (sizeof (struct symtab_and_line
));
5185 sal
.pc
= original_pc
;
5186 expanded
.sals
[0] = sal
;
5190 if (!sal
.explicit_line
)
5192 CORE_ADDR func_addr
, func_end
;
5193 for (i
= 0; i
< expanded
.nelts
; ++i
)
5195 CORE_ADDR pc
= expanded
.sals
[i
].pc
;
5196 char *this_function
;
5197 if (find_pc_partial_function (pc
, &this_function
,
5198 &func_addr
, &func_end
))
5200 if (this_function
&&
5201 strcmp (this_function
, original_function
) != 0)
5203 remove_sal (&expanded
, i
);
5206 else if (func_addr
== pc
)
5208 /* We're at beginning of a function, and should
5210 struct symbol
*sym
= find_pc_function (pc
);
5212 expanded
.sals
[i
] = find_function_start_sal (sym
, 1);
5215 = gdbarch_skip_prologue (current_gdbarch
, pc
);
5222 if (expanded
.nelts
<= 1)
5224 /* This is un ugly workaround. If we get zero
5225 expanded sals then something is really wrong.
5226 Fix that by returnign the original sal. */
5227 xfree (expanded
.sals
);
5229 expanded
.sals
= xmalloc (sizeof (struct symtab_and_line
));
5230 sal
.pc
= original_pc
;
5231 expanded
.sals
[0] = sal
;
5238 for (i
= 0; i
< expanded
.nelts
; ++i
)
5239 if (expanded
.sals
[i
].pc
== original_pc
)
5250 /* Add SALS.nelts breakpoints to the breakpoint table. For each
5251 SALS.sal[i] breakpoint, include the corresponding ADDR_STRING[i]
5252 value. COND_STRING, if not NULL, specified the condition to be
5253 used for all breakpoints. Essentially the only case where
5254 SALS.nelts is not 1 is when we set a breakpoint on an overloaded
5255 function. In that case, it's still not possible to specify
5256 separate conditions for different overloaded functions, so
5257 we take just a single condition string.
5259 NOTE: If the function succeeds, the caller is expected to cleanup
5260 the arrays ADDR_STRING, COND_STRING, and SALS (but not the
5261 array contents). If the function fails (error() is called), the
5262 caller is expected to cleanups both the ADDR_STRING, COND_STRING,
5263 COND and SALS arrays and each of those arrays contents. */
5266 create_breakpoints (struct symtabs_and_lines sals
, char **addr_string
,
5268 enum bptype type
, enum bpdisp disposition
,
5269 int thread
, int ignore_count
,
5270 struct breakpoint_ops
*ops
, int from_tty
)
5273 for (i
= 0; i
< sals
.nelts
; ++i
)
5275 struct symtabs_and_lines expanded
=
5276 expand_line_sal_maybe (sals
.sals
[i
]);
5278 create_breakpoint (expanded
, addr_string
[i
],
5279 cond_string
, type
, disposition
,
5280 thread
, ignore_count
, ops
, from_tty
);
5283 update_global_location_list (1);
5286 /* Parse ARG which is assumed to be a SAL specification possibly
5287 followed by conditionals. On return, SALS contains an array of SAL
5288 addresses found. ADDR_STRING contains a vector of (canonical)
5289 address strings. ARG points to the end of the SAL. */
5292 parse_breakpoint_sals (char **address
,
5293 struct symtabs_and_lines
*sals
,
5294 char ***addr_string
,
5297 char *addr_start
= *address
;
5298 *addr_string
= NULL
;
5299 /* If no arg given, or if first arg is 'if ', use the default
5301 if ((*address
) == NULL
5302 || (strncmp ((*address
), "if", 2) == 0 && isspace ((*address
)[2])))
5304 if (default_breakpoint_valid
)
5306 struct symtab_and_line sal
;
5307 init_sal (&sal
); /* initialize to zeroes */
5308 sals
->sals
= (struct symtab_and_line
*)
5309 xmalloc (sizeof (struct symtab_and_line
));
5310 sal
.pc
= default_breakpoint_address
;
5311 sal
.line
= default_breakpoint_line
;
5312 sal
.symtab
= default_breakpoint_symtab
;
5313 sal
.section
= find_pc_overlay (sal
.pc
);
5314 sals
->sals
[0] = sal
;
5318 error (_("No default breakpoint address now."));
5322 /* Force almost all breakpoints to be in terms of the
5323 current_source_symtab (which is decode_line_1's default). This
5324 should produce the results we want almost all of the time while
5325 leaving default_breakpoint_* alone.
5326 ObjC: However, don't match an Objective-C method name which
5327 may have a '+' or '-' succeeded by a '[' */
5329 struct symtab_and_line cursal
= get_current_source_symtab_and_line ();
5331 if (default_breakpoint_valid
5333 || ((strchr ("+-", (*address
)[0]) != NULL
)
5334 && ((*address
)[1] != '['))))
5335 *sals
= decode_line_1 (address
, 1, default_breakpoint_symtab
,
5336 default_breakpoint_line
, addr_string
,
5339 *sals
= decode_line_1 (address
, 1, (struct symtab
*) NULL
, 0,
5340 addr_string
, not_found_ptr
);
5342 /* For any SAL that didn't have a canonical string, fill one in. */
5343 if (sals
->nelts
> 0 && *addr_string
== NULL
)
5344 *addr_string
= xcalloc (sals
->nelts
, sizeof (char **));
5345 if (addr_start
!= (*address
))
5348 for (i
= 0; i
< sals
->nelts
; i
++)
5350 /* Add the string if not present. */
5351 if ((*addr_string
)[i
] == NULL
)
5352 (*addr_string
)[i
] = savestring (addr_start
, (*address
) - addr_start
);
5358 /* Convert each SAL into a real PC. Verify that the PC can be
5359 inserted as a breakpoint. If it can't throw an error. */
5362 breakpoint_sals_to_pc (struct symtabs_and_lines
*sals
,
5366 for (i
= 0; i
< sals
->nelts
; i
++)
5367 resolve_sal_pc (&sals
->sals
[i
]);
5371 do_captured_parse_breakpoint (struct ui_out
*ui
, void *data
)
5373 struct captured_parse_breakpoint_args
*args
= data
;
5375 parse_breakpoint_sals (args
->arg_p
, args
->sals_p
, args
->addr_string_p
,
5376 args
->not_found_ptr
);
5379 /* Given TOK, a string specification of condition and thread, as
5380 accepted by the 'break' command, extract the condition
5381 string and thread number and set *COND_STRING and *THREAD.
5382 PC identifies the context at which the condition should be parsed.
5383 If no condition is found, *COND_STRING is set to NULL.
5384 If no thread is found, *THREAD is set to -1. */
5386 find_condition_and_thread (char *tok
, CORE_ADDR pc
,
5387 char **cond_string
, int *thread
)
5389 *cond_string
= NULL
;
5395 char *cond_start
= NULL
;
5396 char *cond_end
= NULL
;
5397 while (*tok
== ' ' || *tok
== '\t')
5402 while (*end_tok
!= ' ' && *end_tok
!= '\t' && *end_tok
!= '\000')
5405 toklen
= end_tok
- tok
;
5407 if (toklen
>= 1 && strncmp (tok
, "if", toklen
) == 0)
5409 tok
= cond_start
= end_tok
+ 1;
5410 parse_exp_1 (&tok
, block_for_pc (pc
), 0);
5412 *cond_string
= savestring (cond_start
,
5413 cond_end
- cond_start
);
5415 else if (toklen
>= 1 && strncmp (tok
, "thread", toklen
) == 0)
5421 *thread
= strtol (tok
, &tok
, 0);
5423 error (_("Junk after thread keyword."));
5424 if (!valid_thread_id (*thread
))
5425 error (_("Unknown thread %d."), *thread
);
5428 error (_("Junk at end of arguments."));
5432 /* Set a breakpoint. This function is shared between
5433 CLI and MI functions for setting a breakpoint.
5434 This function has two major modes of operations,
5435 selected by the PARSE_CONDITION_AND_THREAD parameter.
5436 If non-zero, the function will parse arg, extracting
5437 breakpoint location, address and thread. Otherwise,
5438 ARG is just the location of breakpoint, with condition
5439 and thread specified by the COND_STRING and THREAD
5443 break_command_really (char *arg
, char *cond_string
, int thread
,
5444 int parse_condition_and_thread
,
5445 int tempflag
, int hardwareflag
,
5447 enum auto_boolean pending_break_support
,
5448 struct breakpoint_ops
*ops
,
5451 struct gdb_exception e
;
5452 struct symtabs_and_lines sals
;
5453 struct symtab_and_line pending_sal
;
5456 char *addr_start
= arg
;
5458 struct cleanup
*old_chain
;
5459 struct cleanup
*breakpoint_chain
= NULL
;
5460 struct captured_parse_breakpoint_args parse_args
;
5469 parse_args
.arg_p
= &arg
;
5470 parse_args
.sals_p
= &sals
;
5471 parse_args
.addr_string_p
= &addr_string
;
5472 parse_args
.not_found_ptr
= ¬_found
;
5474 e
= catch_exception (uiout
, do_captured_parse_breakpoint
,
5475 &parse_args
, RETURN_MASK_ALL
);
5477 /* If caller is interested in rc value from parse, set value. */
5481 throw_exception (e
);
5485 case NOT_FOUND_ERROR
:
5487 /* If pending breakpoint support is turned off, throw
5490 if (pending_break_support
== AUTO_BOOLEAN_FALSE
)
5491 throw_exception (e
);
5493 exception_print (gdb_stderr
, e
);
5495 /* If pending breakpoint support is auto query and the user
5496 selects no, then simply return the error code. */
5497 if (pending_break_support
== AUTO_BOOLEAN_AUTO
&&
5498 !nquery ("Make breakpoint pending on future shared library load? "))
5501 /* At this point, either the user was queried about setting
5502 a pending breakpoint and selected yes, or pending
5503 breakpoint behavior is on and thus a pending breakpoint
5504 is defaulted on behalf of the user. */
5505 copy_arg
= xstrdup (addr_start
);
5506 addr_string
= ©_arg
;
5508 sals
.sals
= &pending_sal
;
5513 throw_exception (e
);
5520 /* Create a chain of things that always need to be cleaned up. */
5521 old_chain
= make_cleanup (null_cleanup
, 0);
5525 /* Make sure that all storage allocated to SALS gets freed. */
5526 make_cleanup (xfree
, sals
.sals
);
5528 /* Cleanup the addr_string array but not its contents. */
5529 make_cleanup (xfree
, addr_string
);
5532 /* ----------------------------- SNIP -----------------------------
5533 Anything added to the cleanup chain beyond this point is assumed
5534 to be part of a breakpoint. If the breakpoint create succeeds
5535 then the memory is not reclaimed. */
5536 breakpoint_chain
= make_cleanup (null_cleanup
, 0);
5538 /* Mark the contents of the addr_string for cleanup. These go on
5539 the breakpoint_chain and only occure if the breakpoint create
5541 for (i
= 0; i
< sals
.nelts
; i
++)
5543 if (addr_string
[i
] != NULL
)
5544 make_cleanup (xfree
, addr_string
[i
]);
5547 /* Resolve all line numbers to PC's and verify that the addresses
5548 are ok for the target. */
5550 breakpoint_sals_to_pc (&sals
, addr_start
);
5552 /* Verify that condition can be parsed, before setting any
5553 breakpoints. Allocate a separate condition expression for each
5557 if (parse_condition_and_thread
)
5559 /* Here we only parse 'arg' to separate condition
5560 from thread number, so parsing in context of first
5561 sal is OK. When setting the breakpoint we'll
5562 re-parse it in context of each sal. */
5565 find_condition_and_thread (arg
, sals
.sals
[0].pc
, &cond_string
, &thread
);
5567 make_cleanup (xfree
, cond_string
);
5571 /* Create a private copy of condition string. */
5574 cond_string
= xstrdup (cond_string
);
5575 make_cleanup (xfree
, cond_string
);
5578 create_breakpoints (sals
, addr_string
, cond_string
,
5579 hardwareflag
? bp_hardware_breakpoint
5581 tempflag
? disp_del
: disp_donttouch
,
5582 thread
, ignore_count
, ops
, from_tty
);
5586 struct symtab_and_line sal
= {0};
5587 struct breakpoint
*b
;
5589 make_cleanup (xfree
, copy_arg
);
5591 b
= set_raw_breakpoint_without_location (hardwareflag
5592 ? bp_hardware_breakpoint
5594 set_breakpoint_count (breakpoint_count
+ 1);
5595 b
->number
= breakpoint_count
;
5597 b
->addr_string
= addr_string
[0];
5598 b
->cond_string
= NULL
;
5599 b
->ignore_count
= ignore_count
;
5600 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
5601 b
->condition_not_parsed
= 1;
5604 update_global_location_list (1);
5609 warning (_("Multiple breakpoints were set.\n"
5610 "Use the \"delete\" command to delete unwanted breakpoints."));
5611 /* That's it. Discard the cleanups for data inserted into the
5613 discard_cleanups (breakpoint_chain
);
5614 /* But cleanup everything else. */
5615 do_cleanups (old_chain
);
5618 /* Set a breakpoint.
5619 ARG is a string describing breakpoint address,
5620 condition, and thread.
5621 FLAG specifies if a breakpoint is hardware on,
5622 and if breakpoint is temporary, using BP_HARDWARE_FLAG
5626 break_command_1 (char *arg
, int flag
, int from_tty
)
5628 int hardwareflag
= flag
& BP_HARDWAREFLAG
;
5629 int tempflag
= flag
& BP_TEMPFLAG
;
5631 break_command_really (arg
,
5632 NULL
, 0, 1 /* parse arg */,
5633 tempflag
, hardwareflag
,
5634 0 /* Ignore count */,
5635 pending_break_support
,
5636 NULL
/* breakpoint_ops */,
5642 set_breakpoint (char *address
, char *condition
,
5643 int hardwareflag
, int tempflag
,
5644 int thread
, int ignore_count
,
5647 break_command_really (address
, condition
, thread
,
5648 0 /* condition and thread are valid. */,
5649 tempflag
, hardwareflag
,
5652 ? AUTO_BOOLEAN_TRUE
: AUTO_BOOLEAN_FALSE
,
5656 /* Adjust SAL to the first instruction past the function prologue.
5657 The end of the prologue is determined using the line table from
5658 the debugging information.
5660 If SAL is already past the prologue, then do nothing. */
5663 skip_prologue_sal (struct symtab_and_line
*sal
)
5665 struct symbol
*sym
= find_pc_function (sal
->pc
);
5666 struct symtab_and_line start_sal
;
5671 start_sal
= find_function_start_sal (sym
, 1);
5672 if (sal
->pc
< start_sal
.pc
)
5676 /* Helper function for break_command_1 and disassemble_command. */
5679 resolve_sal_pc (struct symtab_and_line
*sal
)
5683 if (sal
->pc
== 0 && sal
->symtab
!= NULL
)
5685 if (!find_line_pc (sal
->symtab
, sal
->line
, &pc
))
5686 error (_("No line %d in file \"%s\"."),
5687 sal
->line
, sal
->symtab
->filename
);
5690 /* If this SAL corresponds to a breakpoint inserted using
5691 a line number, then skip the function prologue if necessary. */
5692 if (sal
->explicit_line
)
5693 skip_prologue_sal (sal
);
5696 if (sal
->section
== 0 && sal
->symtab
!= NULL
)
5698 struct blockvector
*bv
;
5702 bv
= blockvector_for_pc_sect (sal
->pc
, 0, &b
, sal
->symtab
);
5705 sym
= block_function (b
);
5708 fixup_symbol_section (sym
, sal
->symtab
->objfile
);
5709 sal
->section
= SYMBOL_BFD_SECTION (sym
);
5713 /* It really is worthwhile to have the section, so we'll just
5714 have to look harder. This case can be executed if we have
5715 line numbers but no functions (as can happen in assembly
5718 struct minimal_symbol
*msym
;
5720 msym
= lookup_minimal_symbol_by_pc (sal
->pc
);
5722 sal
->section
= SYMBOL_BFD_SECTION (msym
);
5729 break_command (char *arg
, int from_tty
)
5731 break_command_1 (arg
, 0, from_tty
);
5735 tbreak_command (char *arg
, int from_tty
)
5737 break_command_1 (arg
, BP_TEMPFLAG
, from_tty
);
5741 hbreak_command (char *arg
, int from_tty
)
5743 break_command_1 (arg
, BP_HARDWAREFLAG
, from_tty
);
5747 thbreak_command (char *arg
, int from_tty
)
5749 break_command_1 (arg
, (BP_TEMPFLAG
| BP_HARDWAREFLAG
), from_tty
);
5753 stop_command (char *arg
, int from_tty
)
5755 printf_filtered (_("Specify the type of breakpoint to set.\n\
5756 Usage: stop in <function | address>\n\
5757 stop at <line>\n"));
5761 stopin_command (char *arg
, int from_tty
)
5765 if (arg
== (char *) NULL
)
5767 else if (*arg
!= '*')
5772 /* look for a ':'. If this is a line number specification, then
5773 say it is bad, otherwise, it should be an address or
5774 function/method name */
5775 while (*argptr
&& !hasColon
)
5777 hasColon
= (*argptr
== ':');
5782 badInput
= (*argptr
!= ':'); /* Not a class::method */
5784 badInput
= isdigit (*arg
); /* a simple line number */
5788 printf_filtered (_("Usage: stop in <function | address>\n"));
5790 break_command_1 (arg
, 0, from_tty
);
5794 stopat_command (char *arg
, int from_tty
)
5798 if (arg
== (char *) NULL
|| *arg
== '*') /* no line number */
5805 /* look for a ':'. If there is a '::' then get out, otherwise
5806 it is probably a line number. */
5807 while (*argptr
&& !hasColon
)
5809 hasColon
= (*argptr
== ':');
5814 badInput
= (*argptr
== ':'); /* we have class::method */
5816 badInput
= !isdigit (*arg
); /* not a line number */
5820 printf_filtered (_("Usage: stop at <line>\n"));
5822 break_command_1 (arg
, 0, from_tty
);
5825 /* accessflag: hw_write: watch write,
5826 hw_read: watch read,
5827 hw_access: watch access (read or write) */
5829 watch_command_1 (char *arg
, int accessflag
, int from_tty
)
5831 struct breakpoint
*b
, *scope_breakpoint
= NULL
;
5832 struct symtab_and_line sal
;
5833 struct expression
*exp
;
5834 struct block
*exp_valid_block
;
5835 struct value
*val
, *mark
;
5836 struct frame_info
*frame
;
5837 struct frame_info
*prev_frame
= NULL
;
5838 char *exp_start
= NULL
;
5839 char *exp_end
= NULL
;
5840 char *tok
, *id_tok_start
, *end_tok
;
5842 char *cond_start
= NULL
;
5843 char *cond_end
= NULL
;
5844 struct expression
*cond
= NULL
;
5845 int i
, other_type_used
, target_resources_ok
= 0;
5846 enum bptype bp_type
;
5850 init_sal (&sal
); /* initialize to zeroes */
5852 /* Make sure that we actually have parameters to parse. */
5853 if (arg
!= NULL
&& arg
[0] != '\0')
5855 toklen
= strlen (arg
); /* Size of argument list. */
5857 /* Points tok to the end of the argument list. */
5858 tok
= arg
+ toklen
- 1;
5860 /* Go backwards in the parameters list. Skip the last parameter.
5861 If we're expecting a 'thread <thread_num>' parameter, this should
5862 be the thread identifier. */
5863 while (tok
> arg
&& (*tok
== ' ' || *tok
== '\t'))
5865 while (tok
> arg
&& (*tok
!= ' ' && *tok
!= '\t'))
5868 /* Points end_tok to the beginning of the last token. */
5869 id_tok_start
= tok
+ 1;
5871 /* Go backwards in the parameters list. Skip one more parameter.
5872 If we're expecting a 'thread <thread_num>' parameter, we should
5873 reach a "thread" token. */
5874 while (tok
> arg
&& (*tok
== ' ' || *tok
== '\t'))
5879 while (tok
> arg
&& (*tok
!= ' ' && *tok
!= '\t'))
5882 /* Move the pointer forward to skip the whitespace and
5883 calculate the length of the token. */
5885 toklen
= end_tok
- tok
;
5887 if (toklen
>= 1 && strncmp (tok
, "thread", toklen
) == 0)
5889 /* At this point we've found a "thread" token, which means
5890 the user is trying to set a watchpoint that triggers
5891 only in a specific thread. */
5894 /* Extract the thread ID from the next token. */
5895 thread
= strtol (id_tok_start
, &endp
, 0);
5897 /* Check if the user provided a valid numeric value for the
5899 if (*endp
!= ' ' && *endp
!= '\t' && *endp
!= '\0')
5900 error (_("Invalid thread ID specification %s."), id_tok_start
);
5902 /* Check if the thread actually exists. */
5903 if (!valid_thread_id (thread
))
5904 error (_("Unknown thread %d."), thread
);
5906 /* Truncate the string and get rid of the thread <thread_num>
5907 parameter before the parameter list is parsed by the
5908 evaluate_expression() function. */
5913 /* Parse the rest of the arguments. */
5914 innermost_block
= NULL
;
5916 exp
= parse_exp_1 (&arg
, 0, 0);
5918 exp_valid_block
= innermost_block
;
5919 mark
= value_mark ();
5920 fetch_watchpoint_value (exp
, &val
, NULL
, NULL
);
5922 release_value (val
);
5925 while (*tok
== ' ' || *tok
== '\t')
5929 while (*end_tok
!= ' ' && *end_tok
!= '\t' && *end_tok
!= '\000')
5932 toklen
= end_tok
- tok
;
5933 if (toklen
>= 1 && strncmp (tok
, "if", toklen
) == 0)
5935 tok
= cond_start
= end_tok
+ 1;
5936 cond
= parse_exp_1 (&tok
, 0, 0);
5940 error (_("Junk at end of command."));
5942 if (accessflag
== hw_read
)
5943 bp_type
= bp_read_watchpoint
;
5944 else if (accessflag
== hw_access
)
5945 bp_type
= bp_access_watchpoint
;
5947 bp_type
= bp_hardware_watchpoint
;
5949 mem_cnt
= can_use_hardware_watchpoint (val
);
5950 if (mem_cnt
== 0 && bp_type
!= bp_hardware_watchpoint
)
5951 error (_("Expression cannot be implemented with read/access watchpoint."));
5954 i
= hw_watchpoint_used_count (bp_type
, &other_type_used
);
5955 target_resources_ok
=
5956 TARGET_CAN_USE_HARDWARE_WATCHPOINT (bp_type
, i
+ mem_cnt
,
5958 if (target_resources_ok
== 0 && bp_type
!= bp_hardware_watchpoint
)
5959 error (_("Target does not support this type of hardware watchpoint."));
5961 if (target_resources_ok
< 0 && bp_type
!= bp_hardware_watchpoint
)
5962 error (_("Target can only support one kind of HW watchpoint at a time."));
5965 /* Change the type of breakpoint to an ordinary watchpoint if a hardware
5966 watchpoint could not be set. */
5967 if (!mem_cnt
|| target_resources_ok
<= 0)
5968 bp_type
= bp_watchpoint
;
5970 frame
= block_innermost_frame (exp_valid_block
);
5972 prev_frame
= get_prev_frame (frame
);
5976 /* If the expression is "local", then set up a "watchpoint scope"
5977 breakpoint at the point where we've left the scope of the watchpoint
5978 expression. Create the scope breakpoint before the watchpoint, so
5979 that we will encounter it first in bpstat_stop_status. */
5980 if (innermost_block
&& prev_frame
)
5982 scope_breakpoint
= create_internal_breakpoint (get_frame_pc (prev_frame
),
5983 bp_watchpoint_scope
);
5985 scope_breakpoint
->enable_state
= bp_enabled
;
5987 /* Automatically delete the breakpoint when it hits. */
5988 scope_breakpoint
->disposition
= disp_del
;
5990 /* Only break in the proper frame (help with recursion). */
5991 scope_breakpoint
->frame_id
= get_frame_id (prev_frame
);
5993 /* Set the address at which we will stop. */
5994 scope_breakpoint
->loc
->requested_address
5995 = get_frame_pc (prev_frame
);
5996 scope_breakpoint
->loc
->address
5997 = adjust_breakpoint_address (scope_breakpoint
->loc
->requested_address
,
5998 scope_breakpoint
->type
);
6001 /* Now set up the breakpoint. */
6002 b
= set_raw_breakpoint (sal
, bp_type
);
6003 set_breakpoint_count (breakpoint_count
+ 1);
6004 b
->number
= breakpoint_count
;
6006 b
->disposition
= disp_donttouch
;
6008 b
->exp_valid_block
= exp_valid_block
;
6009 b
->exp_string
= savestring (exp_start
, exp_end
- exp_start
);
6012 b
->loc
->cond
= cond
;
6014 b
->cond_string
= savestring (cond_start
, cond_end
- cond_start
);
6019 b
->watchpoint_frame
= get_frame_id (frame
);
6021 b
->watchpoint_frame
= null_frame_id
;
6023 if (scope_breakpoint
!= NULL
)
6025 /* The scope breakpoint is related to the watchpoint. We will
6026 need to act on them together. */
6027 b
->related_breakpoint
= scope_breakpoint
;
6028 scope_breakpoint
->related_breakpoint
= b
;
6031 value_free_to_mark (mark
);
6033 update_global_location_list (1);
6036 /* Return count of locations need to be watched and can be handled
6037 in hardware. If the watchpoint can not be handled
6038 in hardware return zero. */
6041 can_use_hardware_watchpoint (struct value
*v
)
6043 int found_memory_cnt
= 0;
6044 struct value
*head
= v
;
6046 /* Did the user specifically forbid us to use hardware watchpoints? */
6047 if (!can_use_hw_watchpoints
)
6050 /* Make sure that the value of the expression depends only upon
6051 memory contents, and values computed from them within GDB. If we
6052 find any register references or function calls, we can't use a
6053 hardware watchpoint.
6055 The idea here is that evaluating an expression generates a series
6056 of values, one holding the value of every subexpression. (The
6057 expression a*b+c has five subexpressions: a, b, a*b, c, and
6058 a*b+c.) GDB's values hold almost enough information to establish
6059 the criteria given above --- they identify memory lvalues,
6060 register lvalues, computed values, etcetera. So we can evaluate
6061 the expression, and then scan the chain of values that leaves
6062 behind to decide whether we can detect any possible change to the
6063 expression's final value using only hardware watchpoints.
6065 However, I don't think that the values returned by inferior
6066 function calls are special in any way. So this function may not
6067 notice that an expression involving an inferior function call
6068 can't be watched with hardware watchpoints. FIXME. */
6069 for (; v
; v
= value_next (v
))
6071 if (VALUE_LVAL (v
) == lval_memory
)
6074 /* A lazy memory lvalue is one that GDB never needed to fetch;
6075 we either just used its address (e.g., `a' in `a.b') or
6076 we never needed it at all (e.g., `a' in `a,b'). */
6080 /* Ahh, memory we actually used! Check if we can cover
6081 it with hardware watchpoints. */
6082 struct type
*vtype
= check_typedef (value_type (v
));
6084 /* We only watch structs and arrays if user asked for it
6085 explicitly, never if they just happen to appear in a
6086 middle of some value chain. */
6088 || (TYPE_CODE (vtype
) != TYPE_CODE_STRUCT
6089 && TYPE_CODE (vtype
) != TYPE_CODE_ARRAY
))
6091 CORE_ADDR vaddr
= VALUE_ADDRESS (v
) + value_offset (v
);
6092 int len
= TYPE_LENGTH (value_type (v
));
6094 if (!TARGET_REGION_OK_FOR_HW_WATCHPOINT (vaddr
, len
))
6101 else if (VALUE_LVAL (v
) != not_lval
6102 && deprecated_value_modifiable (v
) == 0)
6103 return 0; /* ??? What does this represent? */
6104 else if (VALUE_LVAL (v
) == lval_register
)
6105 return 0; /* cannot watch a register with a HW watchpoint */
6108 /* The expression itself looks suitable for using a hardware
6109 watchpoint, but give the target machine a chance to reject it. */
6110 return found_memory_cnt
;
6114 watch_command_wrapper (char *arg
, int from_tty
)
6116 watch_command (arg
, from_tty
);
6120 watch_command (char *arg
, int from_tty
)
6122 watch_command_1 (arg
, hw_write
, from_tty
);
6126 rwatch_command_wrapper (char *arg
, int from_tty
)
6128 rwatch_command (arg
, from_tty
);
6132 rwatch_command (char *arg
, int from_tty
)
6134 watch_command_1 (arg
, hw_read
, from_tty
);
6138 awatch_command_wrapper (char *arg
, int from_tty
)
6140 awatch_command (arg
, from_tty
);
6144 awatch_command (char *arg
, int from_tty
)
6146 watch_command_1 (arg
, hw_access
, from_tty
);
6150 /* Helper routines for the until_command routine in infcmd.c. Here
6151 because it uses the mechanisms of breakpoints. */
6153 struct until_break_command_continuation_args
6155 struct breakpoint
*breakpoint
;
6156 struct breakpoint
*breakpoint2
;
6159 /* This function is called by fetch_inferior_event via the
6160 cmd_continuation pointer, to complete the until command. It takes
6161 care of cleaning up the temporary breakpoints set up by the until
6164 until_break_command_continuation (void *arg
, int error
)
6166 struct until_break_command_continuation_args
*a
= arg
;
6168 delete_breakpoint (a
->breakpoint
);
6170 delete_breakpoint (a
->breakpoint2
);
6174 until_break_command (char *arg
, int from_tty
, int anywhere
)
6176 struct symtabs_and_lines sals
;
6177 struct symtab_and_line sal
;
6178 struct frame_info
*frame
= get_selected_frame (NULL
);
6179 struct frame_info
*prev_frame
= get_prev_frame (frame
);
6180 struct breakpoint
*breakpoint
;
6181 struct breakpoint
*breakpoint2
= NULL
;
6182 struct cleanup
*old_chain
;
6184 clear_proceed_status ();
6186 /* Set a breakpoint where the user wants it and at return from
6189 if (default_breakpoint_valid
)
6190 sals
= decode_line_1 (&arg
, 1, default_breakpoint_symtab
,
6191 default_breakpoint_line
, (char ***) NULL
, NULL
);
6193 sals
= decode_line_1 (&arg
, 1, (struct symtab
*) NULL
,
6194 0, (char ***) NULL
, NULL
);
6196 if (sals
.nelts
!= 1)
6197 error (_("Couldn't get information on specified line."));
6200 xfree (sals
.sals
); /* malloc'd, so freed */
6203 error (_("Junk at end of arguments."));
6205 resolve_sal_pc (&sal
);
6208 /* If the user told us to continue until a specified location,
6209 we don't specify a frame at which we need to stop. */
6210 breakpoint
= set_momentary_breakpoint (sal
, null_frame_id
, bp_until
);
6212 /* Otherwise, specify the current frame, because we want to stop only
6213 at the very same frame. */
6214 breakpoint
= set_momentary_breakpoint (sal
, get_frame_id (frame
),
6217 old_chain
= make_cleanup_delete_breakpoint (breakpoint
);
6219 /* Keep within the current frame, or in frames called by the current
6223 sal
= find_pc_line (get_frame_pc (prev_frame
), 0);
6224 sal
.pc
= get_frame_pc (prev_frame
);
6225 breakpoint2
= set_momentary_breakpoint (sal
, get_frame_id (prev_frame
),
6227 make_cleanup_delete_breakpoint (breakpoint2
);
6230 proceed (-1, TARGET_SIGNAL_DEFAULT
, 0);
6232 /* If we are running asynchronously, and proceed call above has actually
6233 managed to start the target, arrange for breakpoints to be
6234 deleted when the target stops. Otherwise, we're already stopped and
6235 delete breakpoints via cleanup chain. */
6237 if (target_can_async_p () && is_running (inferior_ptid
))
6239 struct until_break_command_continuation_args
*args
;
6240 args
= xmalloc (sizeof (*args
));
6242 args
->breakpoint
= breakpoint
;
6243 args
->breakpoint2
= breakpoint2
;
6245 discard_cleanups (old_chain
);
6246 add_continuation (until_break_command_continuation
, args
);
6249 do_cleanups (old_chain
);
6253 ep_skip_leading_whitespace (char **s
)
6255 if ((s
== NULL
) || (*s
== NULL
))
6257 while (isspace (**s
))
6261 /* This function examines a string, and attempts to find a token
6262 that might be an event name in the leading characters. If a
6263 possible match is found, a pointer to the last character of
6264 the token is returned. Else, NULL is returned. */
6267 ep_find_event_name_end (char *arg
)
6270 char *event_name_end
= NULL
;
6272 /* If we could depend upon the presense of strrpbrk, we'd use that... */
6276 /* We break out of the loop when we find a token delimiter.
6277 Basically, we're looking for alphanumerics and underscores;
6278 anything else delimites the token. */
6281 if (!isalnum (*s
) && (*s
!= '_'))
6287 return event_name_end
;
6291 /* This function attempts to parse an optional "if <cond>" clause
6292 from the arg string. If one is not found, it returns NULL.
6294 Else, it returns a pointer to the condition string. (It does not
6295 attempt to evaluate the string against a particular block.) And,
6296 it updates arg to point to the first character following the parsed
6297 if clause in the arg string. */
6300 ep_parse_optional_if_clause (char **arg
)
6304 if (((*arg
)[0] != 'i') || ((*arg
)[1] != 'f') || !isspace ((*arg
)[2]))
6307 /* Skip the "if" keyword. */
6310 /* Skip any extra leading whitespace, and record the start of the
6311 condition string. */
6312 ep_skip_leading_whitespace (arg
);
6315 /* Assume that the condition occupies the remainder of the arg string. */
6316 (*arg
) += strlen (cond_string
);
6321 /* This function attempts to parse an optional filename from the arg
6322 string. If one is not found, it returns NULL.
6324 Else, it returns a pointer to the parsed filename. (This function
6325 makes no attempt to verify that a file of that name exists, or is
6326 accessible.) And, it updates arg to point to the first character
6327 following the parsed filename in the arg string.
6329 Note that clients needing to preserve the returned filename for
6330 future access should copy it to their own buffers. */
6332 ep_parse_optional_filename (char **arg
)
6334 static char filename
[1024];
6339 if ((*arg_p
== '\0') || isspace (*arg_p
))
6357 /* Commands to deal with catching events, such as signals, exceptions,
6358 process start/exit, etc. */
6362 catch_fork
, catch_vfork
6367 catch_fork_command_1 (catch_fork_kind fork_kind
, char *arg
, int tempflag
,
6370 char *cond_string
= NULL
;
6372 ep_skip_leading_whitespace (&arg
);
6374 /* The allowed syntax is:
6376 catch [v]fork if <cond>
6378 First, check if there's an if clause. */
6379 cond_string
= ep_parse_optional_if_clause (&arg
);
6381 if ((*arg
!= '\0') && !isspace (*arg
))
6382 error (_("Junk at end of arguments."));
6384 /* If this target supports it, create a fork or vfork catchpoint
6385 and enable reporting of such events. */
6389 create_fork_event_catchpoint (tempflag
, cond_string
);
6392 create_vfork_event_catchpoint (tempflag
, cond_string
);
6395 error (_("unsupported or unknown fork kind; cannot catch it"));
6401 catch_exec_command_1 (char *arg
, int tempflag
, int from_tty
)
6403 char *cond_string
= NULL
;
6405 ep_skip_leading_whitespace (&arg
);
6407 /* The allowed syntax is:
6409 catch exec if <cond>
6411 First, check if there's an if clause. */
6412 cond_string
= ep_parse_optional_if_clause (&arg
);
6414 if ((*arg
!= '\0') && !isspace (*arg
))
6415 error (_("Junk at end of arguments."));
6417 /* If this target supports it, create an exec catchpoint
6418 and enable reporting of such events. */
6419 create_exec_event_catchpoint (tempflag
, cond_string
);
6423 catch_load_command_1 (char *arg
, int tempflag
, int from_tty
)
6425 char *dll_pathname
= NULL
;
6426 char *cond_string
= NULL
;
6428 ep_skip_leading_whitespace (&arg
);
6430 /* The allowed syntax is:
6432 catch load if <cond>
6433 catch load <filename>
6434 catch load <filename> if <cond>
6436 The user is not allowed to specify the <filename> after an
6439 We'll ignore the pathological case of a file named "if".
6441 First, check if there's an if clause. If so, then there
6442 cannot be a filename. */
6443 cond_string
= ep_parse_optional_if_clause (&arg
);
6445 /* If there was an if clause, then there cannot be a filename.
6446 Else, there might be a filename and an if clause. */
6447 if (cond_string
== NULL
)
6449 dll_pathname
= ep_parse_optional_filename (&arg
);
6450 ep_skip_leading_whitespace (&arg
);
6451 cond_string
= ep_parse_optional_if_clause (&arg
);
6454 if ((*arg
!= '\0') && !isspace (*arg
))
6455 error (_("Junk at end of arguments."));
6457 /* Create a load breakpoint that only triggers when a load of
6458 the specified dll (or any dll, if no pathname was specified)
6460 SOLIB_CREATE_CATCH_LOAD_HOOK (PIDGET (inferior_ptid
), tempflag
,
6461 dll_pathname
, cond_string
);
6465 catch_unload_command_1 (char *arg
, int tempflag
, int from_tty
)
6467 char *dll_pathname
= NULL
;
6468 char *cond_string
= NULL
;
6470 ep_skip_leading_whitespace (&arg
);
6472 /* The allowed syntax is:
6474 catch unload if <cond>
6475 catch unload <filename>
6476 catch unload <filename> if <cond>
6478 The user is not allowed to specify the <filename> after an
6481 We'll ignore the pathological case of a file named "if".
6483 First, check if there's an if clause. If so, then there
6484 cannot be a filename. */
6485 cond_string
= ep_parse_optional_if_clause (&arg
);
6487 /* If there was an if clause, then there cannot be a filename.
6488 Else, there might be a filename and an if clause. */
6489 if (cond_string
== NULL
)
6491 dll_pathname
= ep_parse_optional_filename (&arg
);
6492 ep_skip_leading_whitespace (&arg
);
6493 cond_string
= ep_parse_optional_if_clause (&arg
);
6496 if ((*arg
!= '\0') && !isspace (*arg
))
6497 error (_("Junk at end of arguments."));
6499 /* Create an unload breakpoint that only triggers when an unload of
6500 the specified dll (or any dll, if no pathname was specified)
6502 SOLIB_CREATE_CATCH_UNLOAD_HOOK (PIDGET (inferior_ptid
), tempflag
,
6503 dll_pathname
, cond_string
);
6506 static enum print_stop_action
6507 print_exception_catchpoint (struct breakpoint
*b
)
6509 int bp_temp
, bp_throw
;
6511 annotate_catchpoint (b
->number
);
6513 bp_throw
= strstr (b
->addr_string
, "throw") != NULL
;
6514 if (b
->loc
->address
!= b
->loc
->requested_address
)
6515 breakpoint_adjustment_warning (b
->loc
->requested_address
,
6518 bp_temp
= b
->loc
->owner
->disposition
== disp_del
;
6520 bp_temp
? "Temporary catchpoint "
6522 if (!ui_out_is_mi_like_p (uiout
))
6523 ui_out_field_int (uiout
, "bkptno", b
->number
);
6525 bp_throw
? " (exception thrown), "
6526 : " (exception caught), ");
6527 if (ui_out_is_mi_like_p (uiout
))
6529 ui_out_field_string (uiout
, "reason",
6530 async_reason_lookup (EXEC_ASYNC_BREAKPOINT_HIT
));
6531 ui_out_field_string (uiout
, "disp", bpdisp_text (b
->disposition
));
6532 ui_out_field_int (uiout
, "bkptno", b
->number
);
6534 return PRINT_SRC_AND_LOC
;
6538 print_one_exception_catchpoint (struct breakpoint
*b
, CORE_ADDR
*last_addr
)
6543 if (b
->loc
== NULL
|| b
->loc
->shlib_disabled
)
6544 ui_out_field_string (uiout
, "addr", "<PENDING>");
6546 ui_out_field_core_addr (uiout
, "addr", b
->loc
->address
);
6550 *last_addr
= b
->loc
->address
;
6551 if (strstr (b
->addr_string
, "throw") != NULL
)
6552 ui_out_field_string (uiout
, "what", "exception throw");
6554 ui_out_field_string (uiout
, "what", "exception catch");
6558 print_mention_exception_catchpoint (struct breakpoint
*b
)
6563 bp_temp
= b
->loc
->owner
->disposition
== disp_del
;
6564 bp_throw
= strstr (b
->addr_string
, "throw") != NULL
;
6565 ui_out_text (uiout
, bp_temp
? _("Temporary catchpoint ")
6566 : _("Catchpoint "));
6567 ui_out_field_int (uiout
, "bkptno", b
->number
);
6568 ui_out_text (uiout
, bp_throw
? _(" (throw)")
6572 static struct breakpoint_ops gnu_v3_exception_catchpoint_ops
= {
6573 print_exception_catchpoint
,
6574 print_one_exception_catchpoint
,
6575 print_mention_exception_catchpoint
6579 handle_gnu_v3_exceptions (int tempflag
, char *cond_string
,
6580 enum exception_event_kind ex_event
, int from_tty
)
6582 char *trigger_func_name
;
6584 if (ex_event
== EX_EVENT_CATCH
)
6585 trigger_func_name
= "__cxa_begin_catch";
6587 trigger_func_name
= "__cxa_throw";
6589 break_command_really (trigger_func_name
, cond_string
, -1,
6590 0 /* condition and thread are valid. */,
6593 AUTO_BOOLEAN_TRUE
/* pending */,
6594 &gnu_v3_exception_catchpoint_ops
, from_tty
);
6599 /* Deal with "catch catch" and "catch throw" commands */
6602 catch_exception_command_1 (enum exception_event_kind ex_event
, char *arg
,
6603 int tempflag
, int from_tty
)
6605 char *cond_string
= NULL
;
6606 struct symtab_and_line
*sal
= NULL
;
6608 ep_skip_leading_whitespace (&arg
);
6610 cond_string
= ep_parse_optional_if_clause (&arg
);
6612 if ((*arg
!= '\0') && !isspace (*arg
))
6613 error (_("Junk at end of arguments."));
6615 if ((ex_event
!= EX_EVENT_THROW
) &&
6616 (ex_event
!= EX_EVENT_CATCH
))
6617 error (_("Unsupported or unknown exception event; cannot catch it"));
6619 if (handle_gnu_v3_exceptions (tempflag
, cond_string
, ex_event
, from_tty
))
6622 warning (_("Unsupported with this platform/compiler combination."));
6625 /* Create a breakpoint struct for Ada exception catchpoints. */
6628 create_ada_exception_breakpoint (struct symtab_and_line sal
,
6632 struct expression
*cond
,
6633 struct breakpoint_ops
*ops
,
6637 struct breakpoint
*b
;
6641 describe_other_breakpoints (sal
.pc
, sal
.section
, -1);
6642 /* FIXME: brobecker/2006-12-28: Actually, re-implement a special
6643 version for exception catchpoints, because two catchpoints
6644 used for different exception names will use the same address.
6645 In this case, a "breakpoint ... also set at..." warning is
6646 unproductive. Besides. the warning phrasing is also a bit
6647 inapropriate, we should use the word catchpoint, and tell
6648 the user what type of catchpoint it is. The above is good
6649 enough for now, though. */
6652 b
= set_raw_breakpoint (sal
, bp_breakpoint
);
6653 set_breakpoint_count (breakpoint_count
+ 1);
6655 b
->enable_state
= bp_enabled
;
6656 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
6657 b
->number
= breakpoint_count
;
6658 b
->ignore_count
= 0;
6659 b
->loc
->cond
= cond
;
6660 b
->addr_string
= addr_string
;
6661 b
->language
= language_ada
;
6662 b
->cond_string
= cond_string
;
6663 b
->exp_string
= exp_string
;
6668 update_global_location_list (1);
6671 /* Implement the "catch exception" command. */
6674 catch_ada_exception_command (char *arg
, int tempflag
, int from_tty
)
6676 struct symtab_and_line sal
;
6678 char *addr_string
= NULL
;
6679 char *exp_string
= NULL
;
6680 char *cond_string
= NULL
;
6681 struct expression
*cond
= NULL
;
6682 struct breakpoint_ops
*ops
= NULL
;
6684 sal
= ada_decode_exception_location (arg
, &addr_string
, &exp_string
,
6685 &cond_string
, &cond
, &ops
);
6686 create_ada_exception_breakpoint (sal
, addr_string
, exp_string
,
6687 cond_string
, cond
, ops
, tempflag
,
6691 /* Implement the "catch assert" command. */
6694 catch_assert_command (char *arg
, int tempflag
, int from_tty
)
6696 struct symtab_and_line sal
;
6697 char *addr_string
= NULL
;
6698 struct breakpoint_ops
*ops
= NULL
;
6700 sal
= ada_decode_assert_location (arg
, &addr_string
, &ops
);
6701 create_ada_exception_breakpoint (sal
, addr_string
, NULL
, NULL
, NULL
, ops
,
6702 tempflag
, from_tty
);
6706 catch_command_1 (char *arg
, int tempflag
, int from_tty
)
6709 /* The first argument may be an event name, such as "start" or "load".
6710 If so, then handle it as such. If it doesn't match an event name,
6711 then attempt to interpret it as an exception name. (This latter is
6712 the v4.16-and-earlier GDB meaning of the "catch" command.)
6714 First, try to find the bounds of what might be an event name. */
6715 char *arg1_start
= arg
;
6719 if (arg1_start
== NULL
)
6721 /* Old behaviour was to use pre-v-4.16 syntax */
6722 /* catch_throw_command_1 (arg1_start, tempflag, from_tty); */
6724 /* Now, this is not allowed */
6725 error (_("Catch requires an event name."));
6728 arg1_end
= ep_find_event_name_end (arg1_start
);
6729 if (arg1_end
== NULL
)
6730 error (_("catch requires an event"));
6731 arg1_length
= arg1_end
+ 1 - arg1_start
;
6733 /* Try to match what we found against known event names. */
6734 if (strncmp (arg1_start
, "signal", arg1_length
) == 0)
6736 error (_("Catch of signal not yet implemented"));
6738 else if (strncmp (arg1_start
, "catch", arg1_length
) == 0)
6740 catch_exception_command_1 (EX_EVENT_CATCH
, arg1_end
+ 1,
6741 tempflag
, from_tty
);
6743 else if (strncmp (arg1_start
, "throw", arg1_length
) == 0)
6745 catch_exception_command_1 (EX_EVENT_THROW
, arg1_end
+ 1,
6746 tempflag
, from_tty
);
6748 else if (strncmp (arg1_start
, "thread_start", arg1_length
) == 0)
6750 error (_("Catch of thread_start not yet implemented"));
6752 else if (strncmp (arg1_start
, "thread_exit", arg1_length
) == 0)
6754 error (_("Catch of thread_exit not yet implemented"));
6756 else if (strncmp (arg1_start
, "thread_join", arg1_length
) == 0)
6758 error (_("Catch of thread_join not yet implemented"));
6760 else if (strncmp (arg1_start
, "start", arg1_length
) == 0)
6762 error (_("Catch of start not yet implemented"));
6764 else if (strncmp (arg1_start
, "exit", arg1_length
) == 0)
6766 error (_("Catch of exit not yet implemented"));
6768 else if (strncmp (arg1_start
, "fork", arg1_length
) == 0)
6770 catch_fork_command_1 (catch_fork
, arg1_end
+ 1, tempflag
, from_tty
);
6772 else if (strncmp (arg1_start
, "vfork", arg1_length
) == 0)
6774 catch_fork_command_1 (catch_vfork
, arg1_end
+ 1, tempflag
, from_tty
);
6776 else if (strncmp (arg1_start
, "exec", arg1_length
) == 0)
6778 catch_exec_command_1 (arg1_end
+ 1, tempflag
, from_tty
);
6780 else if (strncmp (arg1_start
, "load", arg1_length
) == 0)
6782 catch_load_command_1 (arg1_end
+ 1, tempflag
, from_tty
);
6784 else if (strncmp (arg1_start
, "unload", arg1_length
) == 0)
6786 catch_unload_command_1 (arg1_end
+ 1, tempflag
, from_tty
);
6788 else if (strncmp (arg1_start
, "stop", arg1_length
) == 0)
6790 error (_("Catch of stop not yet implemented"));
6792 else if (strncmp (arg1_start
, "exception", arg1_length
) == 0)
6794 catch_ada_exception_command (arg1_end
+ 1, tempflag
, from_tty
);
6797 else if (strncmp (arg1_start
, "assert", arg1_length
) == 0)
6799 catch_assert_command (arg1_end
+ 1, tempflag
, from_tty
);
6802 /* This doesn't appear to be an event name */
6806 /* Pre-v.4.16 behaviour was to treat the argument
6807 as the name of an exception */
6808 /* catch_throw_command_1 (arg1_start, tempflag, from_tty); */
6809 /* Now this is not allowed */
6810 error (_("Unknown event kind specified for catch"));
6816 catch_command (char *arg
, int from_tty
)
6818 catch_command_1 (arg
, 0, from_tty
);
6823 tcatch_command (char *arg
, int from_tty
)
6825 catch_command_1 (arg
, 1, from_tty
);
6828 /* Delete breakpoints by address or line. */
6831 clear_command (char *arg
, int from_tty
)
6833 struct breakpoint
*b
;
6834 VEC(breakpoint_p
) *found
= 0;
6837 struct symtabs_and_lines sals
;
6838 struct symtab_and_line sal
;
6843 sals
= decode_line_spec (arg
, 1);
6848 sals
.sals
= (struct symtab_and_line
*)
6849 xmalloc (sizeof (struct symtab_and_line
));
6850 make_cleanup (xfree
, sals
.sals
);
6851 init_sal (&sal
); /* initialize to zeroes */
6852 sal
.line
= default_breakpoint_line
;
6853 sal
.symtab
= default_breakpoint_symtab
;
6854 sal
.pc
= default_breakpoint_address
;
6855 if (sal
.symtab
== 0)
6856 error (_("No source file specified."));
6864 /* We don't call resolve_sal_pc here. That's not
6865 as bad as it seems, because all existing breakpoints
6866 typically have both file/line and pc set. So, if
6867 clear is given file/line, we can match this to existing
6868 breakpoint without obtaining pc at all.
6870 We only support clearing given the address explicitly
6871 present in breakpoint table. Say, we've set breakpoint
6872 at file:line. There were several PC values for that file:line,
6873 due to optimization, all in one block.
6874 We've picked one PC value. If "clear" is issued with another
6875 PC corresponding to the same file:line, the breakpoint won't
6876 be cleared. We probably can still clear the breakpoint, but
6877 since the other PC value is never presented to user, user
6878 can only find it by guessing, and it does not seem important
6881 /* For each line spec given, delete bps which correspond
6882 to it. Do it in two passes, solely to preserve the current
6883 behavior that from_tty is forced true if we delete more than
6887 for (i
= 0; i
< sals
.nelts
; i
++)
6889 /* If exact pc given, clear bpts at that pc.
6890 If line given (pc == 0), clear all bpts on specified line.
6891 If defaulting, clear all bpts on default line
6894 defaulting sal.pc != 0 tests to do
6899 1 0 <can't happen> */
6903 /* Find all matching breakpoints and add them to
6908 /* Are we going to delete b? */
6909 if (b
->type
!= bp_none
6910 && b
->type
!= bp_watchpoint
6911 && b
->type
!= bp_hardware_watchpoint
6912 && b
->type
!= bp_read_watchpoint
6913 && b
->type
!= bp_access_watchpoint
)
6915 struct bp_location
*loc
= b
->loc
;
6916 for (; loc
; loc
= loc
->next
)
6918 int pc_match
= sal
.pc
6919 && (loc
->address
== sal
.pc
)
6920 && (!section_is_overlay (loc
->section
)
6921 || loc
->section
== sal
.section
);
6922 int line_match
= ((default_match
|| (0 == sal
.pc
))
6923 && b
->source_file
!= NULL
6924 && sal
.symtab
!= NULL
6925 && strcmp (b
->source_file
, sal
.symtab
->filename
) == 0
6926 && b
->line_number
== sal
.line
);
6927 if (pc_match
|| line_match
)
6936 VEC_safe_push(breakpoint_p
, found
, b
);
6939 /* Now go thru the 'found' chain and delete them. */
6940 if (VEC_empty(breakpoint_p
, found
))
6943 error (_("No breakpoint at %s."), arg
);
6945 error (_("No breakpoint at this line."));
6948 if (VEC_length(breakpoint_p
, found
) > 1)
6949 from_tty
= 1; /* Always report if deleted more than one */
6952 if (VEC_length(breakpoint_p
, found
) == 1)
6953 printf_unfiltered (_("Deleted breakpoint "));
6955 printf_unfiltered (_("Deleted breakpoints "));
6957 breakpoints_changed ();
6959 for (ix
= 0; VEC_iterate(breakpoint_p
, found
, ix
, b
); ix
++)
6962 printf_unfiltered ("%d ", b
->number
);
6963 delete_breakpoint (b
);
6966 putchar_unfiltered ('\n');
6969 /* Delete breakpoint in BS if they are `delete' breakpoints and
6970 all breakpoints that are marked for deletion, whether hit or not.
6971 This is called after any breakpoint is hit, or after errors. */
6974 breakpoint_auto_delete (bpstat bs
)
6976 struct breakpoint
*b
, *temp
;
6978 for (; bs
; bs
= bs
->next
)
6979 if (bs
->breakpoint_at
6980 && bs
->breakpoint_at
->owner
6981 && bs
->breakpoint_at
->owner
->disposition
== disp_del
6983 delete_breakpoint (bs
->breakpoint_at
->owner
);
6985 ALL_BREAKPOINTS_SAFE (b
, temp
)
6987 if (b
->disposition
== disp_del_at_next_stop
)
6988 delete_breakpoint (b
);
6992 /* If SHOULD_INSERT is true, do not insert any breakpoint locations
6993 into the inferior, only remove already-inserted locations that no
6994 longer should be inserted. Functions that delete a breakpoint or
6995 breakpoints should pass false, so that deleting a breakpoint
6996 doesn't have the side effect of inserting the locations of other
6997 breakpoints that are marked not-inserted, but should_be_inserted
6998 returns true on them.
7000 This behaviour is useful is situations close to tear-down -- e.g.,
7001 after an exec, while the target still has execution, but breakpoint
7002 shadows of the previous executable image should *NOT* be restored
7003 to the new image; or before detaching, where the target still has
7004 execution and wants to delete breakpoints from GDB's lists, and all
7005 breakpoints had already been removed from the inferior. */
7008 update_global_location_list (int should_insert
)
7010 struct breakpoint
*b
;
7011 struct bp_location
**next
= &bp_location_chain
;
7012 struct bp_location
*loc
;
7013 struct bp_location
*loc2
;
7014 struct gdb_exception e
;
7015 VEC(bp_location_p
) *old_locations
= NULL
;
7019 /* Store old locations for future reference. */
7020 for (loc
= bp_location_chain
; loc
; loc
= loc
->global_next
)
7021 VEC_safe_push (bp_location_p
, old_locations
, loc
);
7023 bp_location_chain
= NULL
;
7026 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
7029 next
= &(loc
->global_next
);
7034 /* Identify bp_location instances that are no longer present in the new
7035 list, and therefore should be freed. Note that it's not necessary that
7036 those locations should be removed from inferior -- if there's another
7037 location at the same address (previously marked as duplicate),
7038 we don't need to remove/insert the location. */
7039 for (ix
= 0; VEC_iterate(bp_location_p
, old_locations
, ix
, loc
); ++ix
)
7041 /* Tells if 'loc' is found amoung the new locations. If not, we
7043 int found_object
= 0;
7044 /* Tells if the location should remain inserted in the target. */
7045 int keep_in_target
= 0;
7047 for (loc2
= bp_location_chain
; loc2
; loc2
= loc2
->global_next
)
7054 /* If this location is no longer present, and inserted, look if there's
7055 maybe a new location at the same address. If so, mark that one
7056 inserted, and don't remove this one. This is needed so that we
7057 don't have a time window where a breakpoint at certain location is not
7062 /* If the location is inserted now, we might have to remove it. */
7064 if (found_object
&& should_be_inserted (loc
))
7066 /* The location is still present in the location list, and still
7067 should be inserted. Don't do anything. */
7072 /* The location is either no longer present, or got disabled.
7073 See if there's another location at the same address, in which
7074 case we don't need to remove this one from the target. */
7075 if (breakpoint_address_is_meaningful (loc
->owner
))
7076 for (loc2
= bp_location_chain
; loc2
; loc2
= loc2
->global_next
)
7078 /* For the sake of should_insert_location. The
7079 call to check_duplicates will fix up this later. */
7080 loc2
->duplicate
= 0;
7081 if (should_be_inserted (loc2
)
7082 && loc2
!= loc
&& loc2
->address
== loc
->address
)
7085 loc2
->target_info
= loc
->target_info
;
7092 if (!keep_in_target
)
7094 if (remove_breakpoint (loc
, mark_uninserted
))
7096 /* This is just about all we can do. We could keep this
7097 location on the global list, and try to remove it next
7098 time, but there's no particular reason why we will
7101 Note that at this point, loc->owner is still valid,
7102 as delete_breakpoint frees the breakpoint only
7103 after calling us. */
7104 printf_filtered (_("warning: Error removing breakpoint %d\n"),
7105 loc
->owner
->number
);
7115 /* This location was removed from the targets. In non-stop mode,
7116 a race condition is possible where we've removed a breakpoint,
7117 but stop events for that breakpoint are already queued and will
7118 arrive later. To suppress spurious SIGTRAPs reported to user,
7119 we keep this breakpoint location for a bit, and will retire it
7120 after we see 3 * thread_count events.
7121 The theory here is that reporting of events should,
7122 "on the average", be fair, so after that many event we'll see
7123 events from all threads that have anything of interest, and no
7124 longer need to keep this breakpoint. This is just a
7125 heuristic, but if it's wrong, we'll report unexpected SIGTRAP,
7126 which is usability issue, but not a correctness problem. */
7127 loc
->events_till_retirement
= 3 * (thread_count () + 1);
7131 free_bp_location (loc
);
7137 check_duplicates (b
);
7140 if (always_inserted_mode
&& should_insert
&& target_has_execution
)
7141 insert_breakpoint_locations ();
7145 breakpoint_retire_moribund (void)
7147 struct bp_location
*loc
;
7150 for (ix
= 0; VEC_iterate (bp_location_p
, moribund_locations
, ix
, loc
); ++ix
)
7151 if (--(loc
->events_till_retirement
) == 0)
7153 free_bp_location (loc
);
7154 VEC_unordered_remove (bp_location_p
, moribund_locations
, ix
);
7160 update_global_location_list_nothrow (int inserting
)
7162 struct gdb_exception e
;
7163 TRY_CATCH (e
, RETURN_MASK_ERROR
)
7164 update_global_location_list (inserting
);
7167 /* Clear BPT from a BPS. */
7169 bpstat_remove_breakpoint (bpstat bps
, struct breakpoint
*bpt
)
7172 for (bs
= bps
; bs
; bs
= bs
->next
)
7173 if (bs
->breakpoint_at
&& bs
->breakpoint_at
->owner
== bpt
)
7175 bs
->breakpoint_at
= NULL
;
7177 /* bs->commands will be freed later. */
7181 /* Callback for iterate_over_threads. */
7183 bpstat_remove_breakpoint_callback (struct thread_info
*th
, void *data
)
7185 struct breakpoint
*bpt
= data
;
7186 bpstat_remove_breakpoint (th
->stop_bpstat
, bpt
);
7190 /* Delete a breakpoint and clean up all traces of it in the data
7194 delete_breakpoint (struct breakpoint
*bpt
)
7196 struct breakpoint
*b
;
7197 struct bp_location
*loc
, *next
;
7199 gdb_assert (bpt
!= NULL
);
7201 /* Has this bp already been deleted? This can happen because multiple
7202 lists can hold pointers to bp's. bpstat lists are especial culprits.
7204 One example of this happening is a watchpoint's scope bp. When the
7205 scope bp triggers, we notice that the watchpoint is out of scope, and
7206 delete it. We also delete its scope bp. But the scope bp is marked
7207 "auto-deleting", and is already on a bpstat. That bpstat is then
7208 checked for auto-deleting bp's, which are deleted.
7210 A real solution to this problem might involve reference counts in bp's,
7211 and/or giving them pointers back to their referencing bpstat's, and
7212 teaching delete_breakpoint to only free a bp's storage when no more
7213 references were extent. A cheaper bandaid was chosen. */
7214 if (bpt
->type
== bp_none
)
7217 if (deprecated_delete_breakpoint_hook
)
7218 deprecated_delete_breakpoint_hook (bpt
);
7219 breakpoint_delete_event (bpt
->number
);
7221 if (breakpoint_chain
== bpt
)
7222 breakpoint_chain
= bpt
->next
;
7227 b
->next
= bpt
->next
;
7231 free_command_lines (&bpt
->commands
);
7232 if (bpt
->cond_string
!= NULL
)
7233 xfree (bpt
->cond_string
);
7234 if (bpt
->addr_string
!= NULL
)
7235 xfree (bpt
->addr_string
);
7236 if (bpt
->exp
!= NULL
)
7238 if (bpt
->exp_string
!= NULL
)
7239 xfree (bpt
->exp_string
);
7240 if (bpt
->val
!= NULL
)
7241 value_free (bpt
->val
);
7242 if (bpt
->source_file
!= NULL
)
7243 xfree (bpt
->source_file
);
7244 if (bpt
->dll_pathname
!= NULL
)
7245 xfree (bpt
->dll_pathname
);
7246 if (bpt
->triggered_dll_pathname
!= NULL
)
7247 xfree (bpt
->triggered_dll_pathname
);
7248 if (bpt
->exec_pathname
!= NULL
)
7249 xfree (bpt
->exec_pathname
);
7251 /* Be sure no bpstat's are pointing at it after it's been freed. */
7252 /* FIXME, how can we find all bpstat's?
7253 We just check stop_bpstat for now. Note that we cannot just
7254 remove bpstats pointing at bpt from the stop_bpstat list
7255 entirely, as breakpoint commands are associated with the bpstat;
7256 if we remove it here, then the later call to
7257 bpstat_do_actions (&stop_bpstat);
7258 in event-top.c won't do anything, and temporary breakpoints
7259 with commands won't work. */
7261 /* Clear the current context. */
7262 bpstat_remove_breakpoint (stop_bpstat
, bpt
);
7263 /* And from all threads. */
7264 iterate_over_threads (bpstat_remove_breakpoint_callback
, bpt
);
7266 /* Now that breakpoint is removed from breakpoint
7267 list, update the global location list. This
7268 will remove locations that used to belong to
7269 this breakpoint. Do this before freeing
7270 the breakpoint itself, since remove_breakpoint
7271 looks at location's owner. It might be better
7272 design to have location completely self-contained,
7273 but it's not the case now. */
7274 update_global_location_list (0);
7277 /* On the chance that someone will soon try again to delete this same
7278 bp, we mark it as deleted before freeing its storage. */
7279 bpt
->type
= bp_none
;
7285 do_delete_breakpoint_cleanup (void *b
)
7287 delete_breakpoint (b
);
7291 make_cleanup_delete_breakpoint (struct breakpoint
*b
)
7293 return make_cleanup (do_delete_breakpoint_cleanup
, b
);
7297 delete_command (char *arg
, int from_tty
)
7299 struct breakpoint
*b
, *temp
;
7305 int breaks_to_delete
= 0;
7307 /* Delete all breakpoints if no argument.
7308 Do not delete internal or call-dummy breakpoints, these
7309 have to be deleted with an explicit breakpoint number argument. */
7312 if (b
->type
!= bp_call_dummy
&&
7313 b
->type
!= bp_shlib_event
&&
7314 b
->type
!= bp_thread_event
&&
7315 b
->type
!= bp_overlay_event
&&
7318 breaks_to_delete
= 1;
7323 /* Ask user only if there are some breakpoints to delete. */
7325 || (breaks_to_delete
&& query (_("Delete all breakpoints? "))))
7327 ALL_BREAKPOINTS_SAFE (b
, temp
)
7329 if (b
->type
!= bp_call_dummy
&&
7330 b
->type
!= bp_shlib_event
&&
7331 b
->type
!= bp_thread_event
&&
7332 b
->type
!= bp_overlay_event
&&
7334 delete_breakpoint (b
);
7339 map_breakpoint_numbers (arg
, delete_breakpoint
);
7343 all_locations_are_pending (struct bp_location
*loc
)
7345 for (; loc
; loc
= loc
->next
)
7346 if (!loc
->shlib_disabled
)
7351 /* Subroutine of update_breakpoint_locations to simplify it.
7352 Return non-zero if multiple fns in list LOC have the same name.
7353 Null names are ignored. */
7356 ambiguous_names_p (struct bp_location
*loc
)
7358 struct bp_location
*l
;
7359 htab_t htab
= htab_create_alloc (13, htab_hash_string
,
7360 (int (*) (const void *, const void *)) streq
,
7361 NULL
, xcalloc
, xfree
);
7363 for (l
= loc
; l
!= NULL
; l
= l
->next
)
7366 const char *name
= l
->function_name
;
7368 /* Allow for some names to be NULL, ignore them. */
7372 slot
= (const char **) htab_find_slot (htab
, (const void *) name
,
7374 /* NOTE: We can assume slot != NULL here because xcalloc never returns
7389 update_breakpoint_locations (struct breakpoint
*b
,
7390 struct symtabs_and_lines sals
)
7394 struct bp_location
*existing_locations
= b
->loc
;
7396 /* If there's no new locations, and all existing locations
7397 are pending, don't do anything. This optimizes
7398 the common case where all locations are in the same
7399 shared library, that was unloaded. We'd like to
7400 retain the location, so that when the library
7401 is loaded again, we don't loose the enabled/disabled
7402 status of the individual locations. */
7403 if (all_locations_are_pending (existing_locations
) && sals
.nelts
== 0)
7408 for (i
= 0; i
< sals
.nelts
; ++i
)
7410 struct bp_location
*new_loc
=
7411 add_location_to_breakpoint (b
, b
->type
, &(sals
.sals
[i
]));
7413 /* Reparse conditions, they might contain references to the
7415 if (b
->cond_string
!= NULL
)
7417 struct gdb_exception e
;
7420 TRY_CATCH (e
, RETURN_MASK_ERROR
)
7422 new_loc
->cond
= parse_exp_1 (&s
, block_for_pc (sals
.sals
[i
].pc
),
7427 warning (_("failed to reevaluate condition for breakpoint %d: %s"),
7428 b
->number
, e
.message
);
7429 new_loc
->enabled
= 0;
7433 if (b
->source_file
!= NULL
)
7434 xfree (b
->source_file
);
7435 if (sals
.sals
[i
].symtab
== NULL
)
7436 b
->source_file
= NULL
;
7439 savestring (sals
.sals
[i
].symtab
->filename
,
7440 strlen (sals
.sals
[i
].symtab
->filename
));
7442 if (b
->line_number
== 0)
7443 b
->line_number
= sals
.sals
[i
].line
;
7446 /* If possible, carry over 'disable' status from existing breakpoints. */
7448 struct bp_location
*e
= existing_locations
;
7449 /* If there are multiple breakpoints with the same function name,
7450 e.g. for inline functions, comparing function names won't work.
7451 Instead compare pc addresses; this is just a heuristic as things
7452 may have moved, but in practice it gives the correct answer
7453 often enough until a better solution is found. */
7454 int have_ambiguous_names
= ambiguous_names_p (b
->loc
);
7456 for (; e
; e
= e
->next
)
7458 if (!e
->enabled
&& e
->function_name
)
7460 struct bp_location
*l
= b
->loc
;
7461 if (have_ambiguous_names
)
7463 for (; l
; l
= l
->next
)
7464 if (e
->address
== l
->address
)
7472 for (; l
; l
= l
->next
)
7473 if (l
->function_name
7474 && strcmp (e
->function_name
, l
->function_name
) == 0)
7484 update_global_location_list (1);
7488 /* Reset a breakpoint given it's struct breakpoint * BINT.
7489 The value we return ends up being the return value from catch_errors.
7490 Unused in this case. */
7493 breakpoint_re_set_one (void *bint
)
7495 /* get past catch_errs */
7496 struct breakpoint
*b
= (struct breakpoint
*) bint
;
7500 int *not_found_ptr
= ¬_found
;
7501 struct symtabs_and_lines sals
= {};
7502 struct symtabs_and_lines expanded
;
7504 enum enable_state save_enable
;
7505 struct gdb_exception e
;
7511 warning (_("attempted to reset apparently deleted breakpoint #%d?"),
7515 case bp_hardware_breakpoint
:
7517 case bp_catch_unload
:
7518 if (b
->addr_string
== NULL
)
7520 /* Anything without a string can't be re-set. */
7521 delete_breakpoint (b
);
7525 set_language (b
->language
);
7526 input_radix
= b
->input_radix
;
7528 TRY_CATCH (e
, RETURN_MASK_ERROR
)
7530 sals
= decode_line_1 (&s
, 1, (struct symtab
*) NULL
, 0, (char ***) NULL
,
7535 int not_found_and_ok
= 0;
7536 /* For pending breakpoints, it's expected that parsing
7537 will fail until the right shared library is loaded.
7538 User has already told to create pending breakpoints and
7539 don't need extra messages. If breakpoint is in bp_shlib_disabled
7540 state, then user already saw the message about that breakpoint
7541 being disabled, and don't want to see more errors. */
7543 && (b
->condition_not_parsed
7544 || (b
->loc
&& b
->loc
->shlib_disabled
)
7545 || b
->enable_state
== bp_disabled
))
7546 not_found_and_ok
= 1;
7548 if (!not_found_and_ok
)
7550 /* We surely don't want to warn about the same breakpoint
7551 10 times. One solution, implemented here, is disable
7552 the breakpoint on error. Another solution would be to
7553 have separate 'warning emitted' flag. Since this
7554 happens only when a binary has changed, I don't know
7555 which approach is better. */
7556 b
->enable_state
= bp_disabled
;
7557 throw_exception (e
);
7564 gdb_assert (sals
.nelts
== 1);
7565 resolve_sal_pc (&sals
.sals
[0]);
7566 if (b
->condition_not_parsed
&& s
&& s
[0])
7568 char *cond_string
= 0;
7570 find_condition_and_thread (s
, sals
.sals
[0].pc
,
7571 &cond_string
, &thread
);
7573 b
->cond_string
= cond_string
;
7575 b
->condition_not_parsed
= 0;
7577 expanded
= expand_line_sal_maybe (sals
.sals
[0]);
7578 update_breakpoint_locations (b
, expanded
);
7584 case bp_hardware_watchpoint
:
7585 case bp_read_watchpoint
:
7586 case bp_access_watchpoint
:
7587 /* Watchpoint can be either on expression using entirely global variables,
7588 or it can be on local variables.
7590 Watchpoints of the first kind are never auto-deleted, and even persist
7591 across program restarts. Since they can use variables from shared
7592 libraries, we need to reparse expression as libraries are loaded
7595 Watchpoints on local variables can also change meaning as result
7596 of solib event. For example, if a watchpoint uses both a local and
7597 a global variables in expression, it's a local watchpoint, but
7598 unloading of a shared library will make the expression invalid.
7599 This is not a very common use case, but we still re-evaluate
7600 expression, to avoid surprises to the user.
7602 Note that for local watchpoints, we re-evaluate it only if
7603 watchpoints frame id is still valid. If it's not, it means
7604 the watchpoint is out of scope and will be deleted soon. In fact,
7605 I'm not sure we'll ever be called in this case.
7607 If a local watchpoint's frame id is still valid, then
7608 b->exp_valid_block is likewise valid, and we can safely use it.
7610 Don't do anything about disabled watchpoints, since they will
7611 be reevaluated again when enabled. */
7612 update_watchpoint (b
, 1 /* reparse */);
7614 /* We needn't really do anything to reset these, since the mask
7615 that requests them is unaffected by e.g., new libraries being
7618 case bp_catch_vfork
:
7623 printf_filtered (_("Deleting unknown breakpoint type %d\n"), b
->type
);
7625 /* Delete overlay event breakpoints; they will be reset later by
7626 breakpoint_re_set. */
7627 case bp_overlay_event
:
7628 delete_breakpoint (b
);
7631 /* This breakpoint is special, it's set up when the inferior
7632 starts and we really don't want to touch it. */
7633 case bp_shlib_event
:
7635 /* Like bp_shlib_event, this breakpoint type is special.
7636 Once it is set up, we do not want to touch it. */
7637 case bp_thread_event
:
7639 /* Keep temporary breakpoints, which can be encountered when we step
7640 over a dlopen call and SOLIB_ADD is resetting the breakpoints.
7641 Otherwise these should have been blown away via the cleanup chain
7642 or by breakpoint_init_inferior when we rerun the executable. */
7645 case bp_watchpoint_scope
:
7647 case bp_step_resume
:
7649 case bp_longjmp_resume
:
7656 /* Re-set all breakpoints after symbols have been re-loaded. */
7658 breakpoint_re_set (void)
7660 struct breakpoint
*b
, *temp
;
7661 enum language save_language
;
7662 int save_input_radix
;
7664 save_language
= current_language
->la_language
;
7665 save_input_radix
= input_radix
;
7666 ALL_BREAKPOINTS_SAFE (b
, temp
)
7668 /* Format possible error msg */
7669 char *message
= xstrprintf ("Error in re-setting breakpoint %d: ",
7671 struct cleanup
*cleanups
= make_cleanup (xfree
, message
);
7672 catch_errors (breakpoint_re_set_one
, b
, message
, RETURN_MASK_ALL
);
7673 do_cleanups (cleanups
);
7675 set_language (save_language
);
7676 input_radix
= save_input_radix
;
7678 create_overlay_event_breakpoint ("_ovly_debug_event");
7681 /* Reset the thread number of this breakpoint:
7683 - If the breakpoint is for all threads, leave it as-is.
7684 - Else, reset it to the current thread for inferior_ptid. */
7686 breakpoint_re_set_thread (struct breakpoint
*b
)
7688 if (b
->thread
!= -1)
7690 if (in_thread_list (inferior_ptid
))
7691 b
->thread
= pid_to_thread_id (inferior_ptid
);
7695 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
7696 If from_tty is nonzero, it prints a message to that effect,
7697 which ends with a period (no newline). */
7700 set_ignore_count (int bptnum
, int count
, int from_tty
)
7702 struct breakpoint
*b
;
7708 if (b
->number
== bptnum
)
7710 b
->ignore_count
= count
;
7714 printf_filtered (_("Will stop next time breakpoint %d is reached."),
7716 else if (count
== 1)
7717 printf_filtered (_("Will ignore next crossing of breakpoint %d."),
7720 printf_filtered (_("Will ignore next %d crossings of breakpoint %d."),
7723 breakpoints_changed ();
7724 breakpoint_modify_event (b
->number
);
7728 error (_("No breakpoint number %d."), bptnum
);
7731 /* Clear the ignore counts of all breakpoints. */
7733 breakpoint_clear_ignore_counts (void)
7735 struct breakpoint
*b
;
7738 b
->ignore_count
= 0;
7741 /* Command to set ignore-count of breakpoint N to COUNT. */
7744 ignore_command (char *args
, int from_tty
)
7750 error_no_arg (_("a breakpoint number"));
7752 num
= get_number (&p
);
7754 error (_("bad breakpoint number: '%s'"), args
);
7756 error (_("Second argument (specified ignore-count) is missing."));
7758 set_ignore_count (num
,
7759 longest_to_int (value_as_long (parse_and_eval (p
))),
7762 printf_filtered ("\n");
7765 /* Call FUNCTION on each of the breakpoints
7766 whose numbers are given in ARGS. */
7769 map_breakpoint_numbers (char *args
, void (*function
) (struct breakpoint
*))
7774 struct breakpoint
*b
, *tmp
;
7778 error_no_arg (_("one or more breakpoint numbers"));
7785 num
= get_number_or_range (&p1
);
7788 warning (_("bad breakpoint number at or near '%s'"), p
);
7792 ALL_BREAKPOINTS_SAFE (b
, tmp
)
7793 if (b
->number
== num
)
7795 struct breakpoint
*related_breakpoint
= b
->related_breakpoint
;
7798 if (related_breakpoint
)
7799 function (related_breakpoint
);
7803 printf_unfiltered (_("No breakpoint number %d.\n"), num
);
7809 static struct bp_location
*
7810 find_location_by_number (char *number
)
7812 char *dot
= strchr (number
, '.');
7816 struct breakpoint
*b
;
7817 struct bp_location
*loc
;
7822 bp_num
= get_number_or_range (&p1
);
7824 error (_("Bad breakpoint number '%s'"), number
);
7827 if (b
->number
== bp_num
)
7832 if (!b
|| b
->number
!= bp_num
)
7833 error (_("Bad breakpoint number '%s'"), number
);
7836 loc_num
= get_number_or_range (&p1
);
7838 error (_("Bad breakpoint location number '%s'"), number
);
7842 for (;loc_num
&& loc
; --loc_num
, loc
= loc
->next
)
7845 error (_("Bad breakpoint location number '%s'"), dot
+1);
7851 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
7852 If from_tty is nonzero, it prints a message to that effect,
7853 which ends with a period (no newline). */
7856 disable_breakpoint (struct breakpoint
*bpt
)
7858 /* Never disable a watchpoint scope breakpoint; we want to
7859 hit them when we leave scope so we can delete both the
7860 watchpoint and its scope breakpoint at that time. */
7861 if (bpt
->type
== bp_watchpoint_scope
)
7864 /* You can't disable permanent breakpoints. */
7865 if (bpt
->enable_state
== bp_permanent
)
7868 bpt
->enable_state
= bp_disabled
;
7870 update_global_location_list (0);
7872 if (deprecated_modify_breakpoint_hook
)
7873 deprecated_modify_breakpoint_hook (bpt
);
7874 breakpoint_modify_event (bpt
->number
);
7878 disable_command (char *args
, int from_tty
)
7880 struct breakpoint
*bpt
;
7882 ALL_BREAKPOINTS (bpt
)
7886 warning (_("attempted to disable apparently deleted breakpoint #%d?"),
7891 case bp_catch_unload
:
7893 case bp_catch_vfork
:
7895 case bp_hardware_breakpoint
:
7897 case bp_hardware_watchpoint
:
7898 case bp_read_watchpoint
:
7899 case bp_access_watchpoint
:
7900 disable_breakpoint (bpt
);
7904 else if (strchr (args
, '.'))
7906 struct bp_location
*loc
= find_location_by_number (args
);
7909 update_global_location_list (0);
7912 map_breakpoint_numbers (args
, disable_breakpoint
);
7916 do_enable_breakpoint (struct breakpoint
*bpt
, enum bpdisp disposition
)
7918 int target_resources_ok
, other_type_used
;
7921 if (bpt
->type
== bp_hardware_breakpoint
)
7924 i
= hw_breakpoint_used_count ();
7925 target_resources_ok
=
7926 TARGET_CAN_USE_HARDWARE_WATCHPOINT (bp_hardware_breakpoint
,
7928 if (target_resources_ok
== 0)
7929 error (_("No hardware breakpoint support in the target."));
7930 else if (target_resources_ok
< 0)
7931 error (_("Hardware breakpoints used exceeds limit."));
7934 if (bpt
->type
== bp_watchpoint
||
7935 bpt
->type
== bp_hardware_watchpoint
||
7936 bpt
->type
== bp_read_watchpoint
||
7937 bpt
->type
== bp_access_watchpoint
)
7939 struct frame_id saved_frame_id
;
7941 saved_frame_id
= get_frame_id (get_selected_frame (NULL
));
7942 if (bpt
->exp_valid_block
!= NULL
)
7944 struct frame_info
*fr
=
7945 fr
= frame_find_by_id (bpt
->watchpoint_frame
);
7948 printf_filtered (_("\
7949 Cannot enable watchpoint %d because the block in which its expression\n\
7950 is valid is not currently in scope.\n"), bpt
->number
);
7957 value_free (bpt
->val
);
7958 mark
= value_mark ();
7959 fetch_watchpoint_value (bpt
->exp
, &bpt
->val
, NULL
, NULL
);
7961 release_value (bpt
->val
);
7964 if (bpt
->type
== bp_hardware_watchpoint
||
7965 bpt
->type
== bp_read_watchpoint
||
7966 bpt
->type
== bp_access_watchpoint
)
7968 int i
= hw_watchpoint_used_count (bpt
->type
, &other_type_used
);
7969 int mem_cnt
= can_use_hardware_watchpoint (bpt
->val
);
7971 /* Hack around 'unused var' error for some targets here */
7972 (void) mem_cnt
, (void) i
;
7973 target_resources_ok
= TARGET_CAN_USE_HARDWARE_WATCHPOINT (
7974 bpt
->type
, i
+ mem_cnt
, other_type_used
);
7975 /* we can consider of type is bp_hardware_watchpoint, convert to
7976 bp_watchpoint in the following condition */
7977 if (target_resources_ok
< 0)
7979 printf_filtered (_("\
7980 Cannot enable watchpoint %d because target watch resources\n\
7981 have been allocated for other watchpoints.\n"), bpt
->number
);
7982 value_free_to_mark (mark
);
7987 select_frame (frame_find_by_id (saved_frame_id
));
7988 value_free_to_mark (mark
);
7991 if (bpt
->enable_state
!= bp_permanent
)
7992 bpt
->enable_state
= bp_enabled
;
7993 bpt
->disposition
= disposition
;
7994 update_global_location_list (1);
7995 breakpoints_changed ();
7997 if (deprecated_modify_breakpoint_hook
)
7998 deprecated_modify_breakpoint_hook (bpt
);
7999 breakpoint_modify_event (bpt
->number
);
8004 enable_breakpoint (struct breakpoint
*bpt
)
8006 do_enable_breakpoint (bpt
, bpt
->disposition
);
8009 /* The enable command enables the specified breakpoints (or all defined
8010 breakpoints) so they once again become (or continue to be) effective
8011 in stopping the inferior. */
8014 enable_command (char *args
, int from_tty
)
8016 struct breakpoint
*bpt
;
8018 ALL_BREAKPOINTS (bpt
)
8022 warning (_("attempted to enable apparently deleted breakpoint #%d?"),
8027 case bp_catch_unload
:
8029 case bp_catch_vfork
:
8031 case bp_hardware_breakpoint
:
8033 case bp_hardware_watchpoint
:
8034 case bp_read_watchpoint
:
8035 case bp_access_watchpoint
:
8036 enable_breakpoint (bpt
);
8040 else if (strchr (args
, '.'))
8042 struct bp_location
*loc
= find_location_by_number (args
);
8045 update_global_location_list (1);
8048 map_breakpoint_numbers (args
, enable_breakpoint
);
8052 enable_once_breakpoint (struct breakpoint
*bpt
)
8054 do_enable_breakpoint (bpt
, disp_disable
);
8058 enable_once_command (char *args
, int from_tty
)
8060 map_breakpoint_numbers (args
, enable_once_breakpoint
);
8064 enable_delete_breakpoint (struct breakpoint
*bpt
)
8066 do_enable_breakpoint (bpt
, disp_del
);
8070 enable_delete_command (char *args
, int from_tty
)
8072 map_breakpoint_numbers (args
, enable_delete_breakpoint
);
8076 set_breakpoint_cmd (char *args
, int from_tty
)
8081 show_breakpoint_cmd (char *args
, int from_tty
)
8085 /* Use default_breakpoint_'s, or nothing if they aren't valid. */
8087 struct symtabs_and_lines
8088 decode_line_spec_1 (char *string
, int funfirstline
)
8090 struct symtabs_and_lines sals
;
8092 error (_("Empty line specification."));
8093 if (default_breakpoint_valid
)
8094 sals
= decode_line_1 (&string
, funfirstline
,
8095 default_breakpoint_symtab
,
8096 default_breakpoint_line
,
8097 (char ***) NULL
, NULL
);
8099 sals
= decode_line_1 (&string
, funfirstline
,
8100 (struct symtab
*) NULL
, 0, (char ***) NULL
, NULL
);
8102 error (_("Junk at end of line specification: %s"), string
);
8106 /* Create and insert a raw software breakpoint at PC. Return an
8107 identifier, which should be used to remove the breakpoint later.
8108 In general, places which call this should be using something on the
8109 breakpoint chain instead; this function should be eliminated
8113 deprecated_insert_raw_breakpoint (CORE_ADDR pc
)
8115 struct bp_target_info
*bp_tgt
;
8117 bp_tgt
= xmalloc (sizeof (struct bp_target_info
));
8118 memset (bp_tgt
, 0, sizeof (struct bp_target_info
));
8120 bp_tgt
->placed_address
= pc
;
8121 if (target_insert_breakpoint (bp_tgt
) != 0)
8123 /* Could not insert the breakpoint. */
8131 /* Remove a breakpoint BP inserted by deprecated_insert_raw_breakpoint. */
8134 deprecated_remove_raw_breakpoint (void *bp
)
8136 struct bp_target_info
*bp_tgt
= bp
;
8139 ret
= target_remove_breakpoint (bp_tgt
);
8145 /* One (or perhaps two) breakpoints used for software single stepping. */
8147 static void *single_step_breakpoints
[2];
8149 /* Create and insert a breakpoint for software single step. */
8152 insert_single_step_breakpoint (CORE_ADDR next_pc
)
8156 if (single_step_breakpoints
[0] == NULL
)
8157 bpt_p
= &single_step_breakpoints
[0];
8160 gdb_assert (single_step_breakpoints
[1] == NULL
);
8161 bpt_p
= &single_step_breakpoints
[1];
8164 /* NOTE drow/2006-04-11: A future improvement to this function would be
8165 to only create the breakpoints once, and actually put them on the
8166 breakpoint chain. That would let us use set_raw_breakpoint. We could
8167 adjust the addresses each time they were needed. Doing this requires
8168 corresponding changes elsewhere where single step breakpoints are
8169 handled, however. So, for now, we use this. */
8171 *bpt_p
= deprecated_insert_raw_breakpoint (next_pc
);
8173 error (_("Could not insert single-step breakpoint at 0x%s"),
8174 paddr_nz (next_pc
));
8177 /* Remove and delete any breakpoints used for software single step. */
8180 remove_single_step_breakpoints (void)
8182 gdb_assert (single_step_breakpoints
[0] != NULL
);
8184 /* See insert_single_step_breakpoint for more about this deprecated
8186 deprecated_remove_raw_breakpoint (single_step_breakpoints
[0]);
8187 single_step_breakpoints
[0] = NULL
;
8189 if (single_step_breakpoints
[1] != NULL
)
8191 deprecated_remove_raw_breakpoint (single_step_breakpoints
[1]);
8192 single_step_breakpoints
[1] = NULL
;
8196 /* Check whether a software single-step breakpoint is inserted at PC. */
8199 single_step_breakpoint_inserted_here_p (CORE_ADDR pc
)
8203 for (i
= 0; i
< 2; i
++)
8205 struct bp_target_info
*bp_tgt
= single_step_breakpoints
[i
];
8206 if (bp_tgt
&& bp_tgt
->placed_address
== pc
)
8213 int breakpoints_always_inserted_mode (void)
8215 return always_inserted_mode
;
8219 /* This help string is used for the break, hbreak, tbreak and thbreak commands.
8220 It is defined as a macro to prevent duplication.
8221 COMMAND should be a string constant containing the name of the command. */
8222 #define BREAK_ARGS_HELP(command) \
8223 command" [LOCATION] [thread THREADNUM] [if CONDITION]\n\
8224 LOCATION may be a line number, function name, or \"*\" and an address.\n\
8225 If a line number is specified, break at start of code for that line.\n\
8226 If a function is specified, break at start of code for that function.\n\
8227 If an address is specified, break at that exact address.\n\
8228 With no LOCATION, uses current execution address of selected stack frame.\n\
8229 This is useful for breaking on return to a stack frame.\n\
8231 THREADNUM is the number from \"info threads\".\n\
8232 CONDITION is a boolean expression.\n\
8234 Multiple breakpoints at one place are permitted, and useful if conditional.\n\
8236 Do \"help breakpoints\" for info on other commands dealing with breakpoints."
8239 _initialize_breakpoint (void)
8241 static struct cmd_list_element
*breakpoint_set_cmdlist
;
8242 static struct cmd_list_element
*breakpoint_show_cmdlist
;
8243 struct cmd_list_element
*c
;
8245 observer_attach_solib_unloaded (disable_breakpoints_in_unloaded_shlib
);
8247 breakpoint_chain
= 0;
8248 /* Don't bother to call set_breakpoint_count. $bpnum isn't useful
8249 before a breakpoint is set. */
8250 breakpoint_count
= 0;
8252 add_com ("ignore", class_breakpoint
, ignore_command
, _("\
8253 Set ignore-count of breakpoint number N to COUNT.\n\
8254 Usage is `ignore N COUNT'."));
8256 add_com_alias ("bc", "ignore", class_breakpoint
, 1);
8258 add_com ("commands", class_breakpoint
, commands_command
, _("\
8259 Set commands to be executed when a breakpoint is hit.\n\
8260 Give breakpoint number as argument after \"commands\".\n\
8261 With no argument, the targeted breakpoint is the last one set.\n\
8262 The commands themselves follow starting on the next line.\n\
8263 Type a line containing \"end\" to indicate the end of them.\n\
8264 Give \"silent\" as the first line to make the breakpoint silent;\n\
8265 then no output is printed when it is hit, except what the commands print."));
8267 add_com ("condition", class_breakpoint
, condition_command
, _("\
8268 Specify breakpoint number N to break only if COND is true.\n\
8269 Usage is `condition N COND', where N is an integer and COND is an\n\
8270 expression to be evaluated whenever breakpoint N is reached."));
8272 c
= add_com ("tbreak", class_breakpoint
, tbreak_command
, _("\
8273 Set a temporary breakpoint.\n\
8274 Like \"break\" except the breakpoint is only temporary,\n\
8275 so it will be deleted when hit. Equivalent to \"break\" followed\n\
8276 by using \"enable delete\" on the breakpoint number.\n\
8278 BREAK_ARGS_HELP ("tbreak")));
8279 set_cmd_completer (c
, location_completer
);
8281 c
= add_com ("hbreak", class_breakpoint
, hbreak_command
, _("\
8282 Set a hardware assisted breakpoint.\n\
8283 Like \"break\" except the breakpoint requires hardware support,\n\
8284 some target hardware may not have this support.\n\
8286 BREAK_ARGS_HELP ("hbreak")));
8287 set_cmd_completer (c
, location_completer
);
8289 c
= add_com ("thbreak", class_breakpoint
, thbreak_command
, _("\
8290 Set a temporary hardware assisted breakpoint.\n\
8291 Like \"hbreak\" except the breakpoint is only temporary,\n\
8292 so it will be deleted when hit.\n\
8294 BREAK_ARGS_HELP ("thbreak")));
8295 set_cmd_completer (c
, location_completer
);
8297 add_prefix_cmd ("enable", class_breakpoint
, enable_command
, _("\
8298 Enable some breakpoints.\n\
8299 Give breakpoint numbers (separated by spaces) as arguments.\n\
8300 With no subcommand, breakpoints are enabled until you command otherwise.\n\
8301 This is used to cancel the effect of the \"disable\" command.\n\
8302 With a subcommand you can enable temporarily."),
8303 &enablelist
, "enable ", 1, &cmdlist
);
8305 add_com ("ab", class_breakpoint
, enable_command
, _("\
8306 Enable some breakpoints.\n\
8307 Give breakpoint numbers (separated by spaces) as arguments.\n\
8308 With no subcommand, breakpoints are enabled until you command otherwise.\n\
8309 This is used to cancel the effect of the \"disable\" command.\n\
8310 With a subcommand you can enable temporarily."));
8312 add_com_alias ("en", "enable", class_breakpoint
, 1);
8314 add_abbrev_prefix_cmd ("breakpoints", class_breakpoint
, enable_command
, _("\
8315 Enable some breakpoints.\n\
8316 Give breakpoint numbers (separated by spaces) as arguments.\n\
8317 This is used to cancel the effect of the \"disable\" command.\n\
8318 May be abbreviated to simply \"enable\".\n"),
8319 &enablebreaklist
, "enable breakpoints ", 1, &enablelist
);
8321 add_cmd ("once", no_class
, enable_once_command
, _("\
8322 Enable breakpoints for one hit. Give breakpoint numbers.\n\
8323 If a breakpoint is hit while enabled in this fashion, it becomes disabled."),
8326 add_cmd ("delete", no_class
, enable_delete_command
, _("\
8327 Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
8328 If a breakpoint is hit while enabled in this fashion, it is deleted."),
8331 add_cmd ("delete", no_class
, enable_delete_command
, _("\
8332 Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
8333 If a breakpoint is hit while enabled in this fashion, it is deleted."),
8336 add_cmd ("once", no_class
, enable_once_command
, _("\
8337 Enable breakpoints for one hit. Give breakpoint numbers.\n\
8338 If a breakpoint is hit while enabled in this fashion, it becomes disabled."),
8341 add_prefix_cmd ("disable", class_breakpoint
, disable_command
, _("\
8342 Disable some breakpoints.\n\
8343 Arguments are breakpoint numbers with spaces in between.\n\
8344 To disable all breakpoints, give no argument.\n\
8345 A disabled breakpoint is not forgotten, but has no effect until reenabled."),
8346 &disablelist
, "disable ", 1, &cmdlist
);
8347 add_com_alias ("dis", "disable", class_breakpoint
, 1);
8348 add_com_alias ("disa", "disable", class_breakpoint
, 1);
8350 add_com ("sb", class_breakpoint
, disable_command
, _("\
8351 Disable some breakpoints.\n\
8352 Arguments are breakpoint numbers with spaces in between.\n\
8353 To disable all breakpoints, give no argument.\n\
8354 A disabled breakpoint is not forgotten, but has no effect until reenabled."));
8356 add_cmd ("breakpoints", class_alias
, disable_command
, _("\
8357 Disable some breakpoints.\n\
8358 Arguments are breakpoint numbers with spaces in between.\n\
8359 To disable all breakpoints, give no argument.\n\
8360 A disabled breakpoint is not forgotten, but has no effect until reenabled.\n\
8361 This command may be abbreviated \"disable\"."),
8364 add_prefix_cmd ("delete", class_breakpoint
, delete_command
, _("\
8365 Delete some breakpoints or auto-display expressions.\n\
8366 Arguments are breakpoint numbers with spaces in between.\n\
8367 To delete all breakpoints, give no argument.\n\
8369 Also a prefix command for deletion of other GDB objects.\n\
8370 The \"unset\" command is also an alias for \"delete\"."),
8371 &deletelist
, "delete ", 1, &cmdlist
);
8372 add_com_alias ("d", "delete", class_breakpoint
, 1);
8373 add_com_alias ("del", "delete", class_breakpoint
, 1);
8375 add_com ("db", class_breakpoint
, delete_command
, _("\
8376 Delete some breakpoints.\n\
8377 Arguments are breakpoint numbers with spaces in between.\n\
8378 To delete all breakpoints, give no argument.\n"));
8380 add_cmd ("breakpoints", class_alias
, delete_command
, _("\
8381 Delete some breakpoints or auto-display expressions.\n\
8382 Arguments are breakpoint numbers with spaces in between.\n\
8383 To delete all breakpoints, give no argument.\n\
8384 This command may be abbreviated \"delete\"."),
8387 add_com ("clear", class_breakpoint
, clear_command
, _("\
8388 Clear breakpoint at specified line or function.\n\
8389 Argument may be line number, function name, or \"*\" and an address.\n\
8390 If line number is specified, all breakpoints in that line are cleared.\n\
8391 If function is specified, breakpoints at beginning of function are cleared.\n\
8392 If an address is specified, breakpoints at that address are cleared.\n\
8394 With no argument, clears all breakpoints in the line that the selected frame\n\
8397 See also the \"delete\" command which clears breakpoints by number."));
8399 c
= add_com ("break", class_breakpoint
, break_command
, _("\
8400 Set breakpoint at specified line or function.\n"
8401 BREAK_ARGS_HELP ("break")));
8402 set_cmd_completer (c
, location_completer
);
8404 add_com_alias ("b", "break", class_run
, 1);
8405 add_com_alias ("br", "break", class_run
, 1);
8406 add_com_alias ("bre", "break", class_run
, 1);
8407 add_com_alias ("brea", "break", class_run
, 1);
8411 add_com_alias ("ba", "break", class_breakpoint
, 1);
8412 add_com_alias ("bu", "ubreak", class_breakpoint
, 1);
8417 add_abbrev_prefix_cmd ("stop", class_breakpoint
, stop_command
, _("\
8418 Break in function/address or break at a line in the current file."),
8419 &stoplist
, "stop ", 1, &cmdlist
);
8420 add_cmd ("in", class_breakpoint
, stopin_command
,
8421 _("Break in function or address."), &stoplist
);
8422 add_cmd ("at", class_breakpoint
, stopat_command
,
8423 _("Break at a line in the current file."), &stoplist
);
8424 add_com ("status", class_info
, breakpoints_info
, _("\
8425 Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
8426 The \"Type\" column indicates one of:\n\
8427 \tbreakpoint - normal breakpoint\n\
8428 \twatchpoint - watchpoint\n\
8429 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
8430 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
8431 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
8432 address and file/line number respectively.\n\
8434 Convenience variable \"$_\" and default examine address for \"x\"\n\
8435 are set to the address of the last breakpoint listed unless the command\n\
8436 is prefixed with \"server \".\n\n\
8437 Convenience variable \"$bpnum\" contains the number of the last\n\
8441 add_info ("breakpoints", breakpoints_info
, _("\
8442 Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
8443 The \"Type\" column indicates one of:\n\
8444 \tbreakpoint - normal breakpoint\n\
8445 \twatchpoint - watchpoint\n\
8446 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
8447 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
8448 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
8449 address and file/line number respectively.\n\
8451 Convenience variable \"$_\" and default examine address for \"x\"\n\
8452 are set to the address of the last breakpoint listed unless the command\n\
8453 is prefixed with \"server \".\n\n\
8454 Convenience variable \"$bpnum\" contains the number of the last\n\
8458 add_com ("lb", class_breakpoint
, breakpoints_info
, _("\
8459 Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
8460 The \"Type\" column indicates one of:\n\
8461 \tbreakpoint - normal breakpoint\n\
8462 \twatchpoint - watchpoint\n\
8463 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
8464 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
8465 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
8466 address and file/line number respectively.\n\
8468 Convenience variable \"$_\" and default examine address for \"x\"\n\
8469 are set to the address of the last breakpoint listed unless the command\n\
8470 is prefixed with \"server \".\n\n\
8471 Convenience variable \"$bpnum\" contains the number of the last\n\
8474 add_cmd ("breakpoints", class_maintenance
, maintenance_info_breakpoints
, _("\
8475 Status of all breakpoints, or breakpoint number NUMBER.\n\
8476 The \"Type\" column indicates one of:\n\
8477 \tbreakpoint - normal breakpoint\n\
8478 \twatchpoint - watchpoint\n\
8479 \tlongjmp - internal breakpoint used to step through longjmp()\n\
8480 \tlongjmp resume - internal breakpoint at the target of longjmp()\n\
8481 \tuntil - internal breakpoint used by the \"until\" command\n\
8482 \tfinish - internal breakpoint used by the \"finish\" command\n\
8483 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
8484 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
8485 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
8486 address and file/line number respectively.\n\
8488 Convenience variable \"$_\" and default examine address for \"x\"\n\
8489 are set to the address of the last breakpoint listed unless the command\n\
8490 is prefixed with \"server \".\n\n\
8491 Convenience variable \"$bpnum\" contains the number of the last\n\
8493 &maintenanceinfolist
);
8495 add_com ("catch", class_breakpoint
, catch_command
, _("\
8496 Set catchpoints to catch events.\n\
8497 Raised signals may be caught:\n\
8498 \tcatch signal - all signals\n\
8499 \tcatch signal <signame> - a particular signal\n\
8500 Raised exceptions may be caught:\n\
8501 \tcatch throw - all exceptions, when thrown\n\
8502 \tcatch throw <exceptname> - a particular exception, when thrown\n\
8503 \tcatch catch - all exceptions, when caught\n\
8504 \tcatch catch <exceptname> - a particular exception, when caught\n\
8505 Thread or process events may be caught:\n\
8506 \tcatch thread_start - any threads, just after creation\n\
8507 \tcatch thread_exit - any threads, just before expiration\n\
8508 \tcatch thread_join - any threads, just after joins\n\
8509 Process events may be caught:\n\
8510 \tcatch start - any processes, just after creation\n\
8511 \tcatch exit - any processes, just before expiration\n\
8512 \tcatch fork - calls to fork()\n\
8513 \tcatch vfork - calls to vfork()\n\
8514 \tcatch exec - calls to exec()\n\
8515 Dynamically-linked library events may be caught:\n\
8516 \tcatch load - loads of any library\n\
8517 \tcatch load <libname> - loads of a particular library\n\
8518 \tcatch unload - unloads of any library\n\
8519 \tcatch unload <libname> - unloads of a particular library\n\
8520 The act of your program's execution stopping may also be caught:\n\
8522 C++ exceptions may be caught:\n\
8523 \tcatch throw - all exceptions, when thrown\n\
8524 \tcatch catch - all exceptions, when caught\n\
8525 Ada exceptions may be caught:\n\
8526 \tcatch exception - all exceptions, when raised\n\
8527 \tcatch exception <name> - a particular exception, when raised\n\
8528 \tcatch exception unhandled - all unhandled exceptions, when raised\n\
8529 \tcatch assert - all failed assertions, when raised\n\
8531 Do \"help set follow-fork-mode\" for info on debugging your program\n\
8532 after a fork or vfork is caught.\n\n\
8533 Do \"help breakpoints\" for info on other commands dealing with breakpoints."));
8535 add_com ("tcatch", class_breakpoint
, tcatch_command
, _("\
8536 Set temporary catchpoints to catch events.\n\
8537 Args like \"catch\" command.\n\
8538 Like \"catch\" except the catchpoint is only temporary,\n\
8539 so it will be deleted when hit. Equivalent to \"catch\" followed\n\
8540 by using \"enable delete\" on the catchpoint number."));
8542 c
= add_com ("watch", class_breakpoint
, watch_command
, _("\
8543 Set a watchpoint for an expression.\n\
8544 A watchpoint stops execution of your program whenever the value of\n\
8545 an expression changes."));
8546 set_cmd_completer (c
, expression_completer
);
8548 c
= add_com ("rwatch", class_breakpoint
, rwatch_command
, _("\
8549 Set a read watchpoint for an expression.\n\
8550 A watchpoint stops execution of your program whenever the value of\n\
8551 an expression is read."));
8552 set_cmd_completer (c
, expression_completer
);
8554 c
= add_com ("awatch", class_breakpoint
, awatch_command
, _("\
8555 Set a watchpoint for an expression.\n\
8556 A watchpoint stops execution of your program whenever the value of\n\
8557 an expression is either read or written."));
8558 set_cmd_completer (c
, expression_completer
);
8560 add_info ("watchpoints", breakpoints_info
,
8561 _("Synonym for ``info breakpoints''."));
8564 /* XXX: cagney/2005-02-23: This should be a boolean, and should
8565 respond to changes - contrary to the description. */
8566 add_setshow_zinteger_cmd ("can-use-hw-watchpoints", class_support
,
8567 &can_use_hw_watchpoints
, _("\
8568 Set debugger's willingness to use watchpoint hardware."), _("\
8569 Show debugger's willingness to use watchpoint hardware."), _("\
8570 If zero, gdb will not use hardware for new watchpoints, even if\n\
8571 such is available. (However, any hardware watchpoints that were\n\
8572 created before setting this to nonzero, will continue to use watchpoint\n\
8575 show_can_use_hw_watchpoints
,
8576 &setlist
, &showlist
);
8578 can_use_hw_watchpoints
= 1;
8580 add_prefix_cmd ("breakpoint", class_maintenance
, set_breakpoint_cmd
, _("\
8581 Breakpoint specific settings\n\
8582 Configure various breakpoint-specific variables such as\n\
8583 pending breakpoint behavior"),
8584 &breakpoint_set_cmdlist
, "set breakpoint ",
8585 0/*allow-unknown*/, &setlist
);
8586 add_prefix_cmd ("breakpoint", class_maintenance
, show_breakpoint_cmd
, _("\
8587 Breakpoint specific settings\n\
8588 Configure various breakpoint-specific variables such as\n\
8589 pending breakpoint behavior"),
8590 &breakpoint_show_cmdlist
, "show breakpoint ",
8591 0/*allow-unknown*/, &showlist
);
8593 add_setshow_auto_boolean_cmd ("pending", no_class
,
8594 &pending_break_support
, _("\
8595 Set debugger's behavior regarding pending breakpoints."), _("\
8596 Show debugger's behavior regarding pending breakpoints."), _("\
8597 If on, an unrecognized breakpoint location will cause gdb to create a\n\
8598 pending breakpoint. If off, an unrecognized breakpoint location results in\n\
8599 an error. If auto, an unrecognized breakpoint location results in a\n\
8600 user-query to see if a pending breakpoint should be created."),
8602 show_pending_break_support
,
8603 &breakpoint_set_cmdlist
,
8604 &breakpoint_show_cmdlist
);
8606 pending_break_support
= AUTO_BOOLEAN_AUTO
;
8608 add_setshow_boolean_cmd ("auto-hw", no_class
,
8609 &automatic_hardware_breakpoints
, _("\
8610 Set automatic usage of hardware breakpoints."), _("\
8611 Show automatic usage of hardware breakpoints."), _("\
8612 If set, the debugger will automatically use hardware breakpoints for\n\
8613 breakpoints set with \"break\" but falling in read-only memory. If not set,\n\
8614 a warning will be emitted for such breakpoints."),
8616 show_automatic_hardware_breakpoints
,
8617 &breakpoint_set_cmdlist
,
8618 &breakpoint_show_cmdlist
);
8620 add_setshow_boolean_cmd ("always-inserted", class_support
,
8621 &always_inserted_mode
, _("\
8622 Set mode for inserting breakpoints."), _("\
8623 Show mode for inserting breakpoints."), _("\
8624 When this mode is off (which is the default), breakpoints are inserted in\n\
8625 inferior when it is resumed, and removed when execution stops. When this\n\
8626 mode is on, breakpoints are inserted immediately and removed only when\n\
8627 the user deletes the breakpoint."),
8629 &show_always_inserted_mode
,
8630 &breakpoint_set_cmdlist
,
8631 &breakpoint_show_cmdlist
);
8633 automatic_hardware_breakpoints
= 1;