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 (struct continuation_arg
*arg
);
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
);
143 enum exception_event_kind kind
;
146 args_for_catchpoint_enable
;
148 static int watchpoint_check (void *);
150 static void maintenance_info_breakpoints (char *, int);
152 static void create_longjmp_breakpoint (char *);
154 static void create_overlay_event_breakpoint (char *);
156 static int hw_breakpoint_used_count (void);
158 static int hw_watchpoint_used_count (enum bptype
, int *);
160 static void hbreak_command (char *, int);
162 static void thbreak_command (char *, int);
164 static void watch_command_1 (char *, int, int);
166 static void rwatch_command (char *, int);
168 static void awatch_command (char *, int);
170 static void do_enable_breakpoint (struct breakpoint
*, enum bpdisp
);
172 static void create_fork_vfork_event_catchpoint (int tempflag
,
174 enum bptype bp_kind
);
176 static void stop_command (char *arg
, int from_tty
);
178 static void stopin_command (char *arg
, int from_tty
);
180 static void stopat_command (char *arg
, int from_tty
);
182 static char *ep_find_event_name_end (char *arg
);
184 static char *ep_parse_optional_if_clause (char **arg
);
186 static char *ep_parse_optional_filename (char **arg
);
188 static void create_exception_catchpoint (int tempflag
, char *cond_string
,
189 enum exception_event_kind ex_event
,
190 struct symtab_and_line
*sal
);
192 static void catch_exception_command_1 (enum exception_event_kind ex_event
,
193 char *arg
, int tempflag
, int from_tty
);
195 static void tcatch_command (char *arg
, int from_tty
);
197 static void ep_skip_leading_whitespace (char **s
);
199 static int single_step_breakpoint_inserted_here_p (CORE_ADDR pc
);
201 static void free_bp_location (struct bp_location
*loc
);
203 static void mark_breakpoints_out (void);
205 static struct bp_location
*
206 allocate_bp_location (struct breakpoint
*bpt
, enum bptype bp_type
);
209 unlink_locations_from_global_list (struct breakpoint
*bpt
);
212 is_hardware_watchpoint (struct breakpoint
*bpt
);
214 /* Prototypes for exported functions. */
216 /* If FALSE, gdb will not use hardware support for watchpoints, even
217 if such is available. */
218 static int can_use_hw_watchpoints
;
221 show_can_use_hw_watchpoints (struct ui_file
*file
, int from_tty
,
222 struct cmd_list_element
*c
,
225 fprintf_filtered (file
, _("\
226 Debugger's willingness to use watchpoint hardware is %s.\n"),
230 /* If AUTO_BOOLEAN_FALSE, gdb will not attempt to create pending breakpoints.
231 If AUTO_BOOLEAN_TRUE, gdb will automatically create pending breakpoints
232 for unrecognized breakpoint locations.
233 If AUTO_BOOLEAN_AUTO, gdb will query when breakpoints are unrecognized. */
234 static enum auto_boolean pending_break_support
;
236 show_pending_break_support (struct ui_file
*file
, int from_tty
,
237 struct cmd_list_element
*c
,
240 fprintf_filtered (file
, _("\
241 Debugger's behavior regarding pending breakpoints is %s.\n"),
245 /* If 1, gdb will automatically use hardware breakpoints for breakpoints
246 set with "break" but falling in read-only memory.
247 If 0, gdb will warn about such breakpoints, but won't automatically
248 use hardware breakpoints. */
249 static int automatic_hardware_breakpoints
;
251 show_automatic_hardware_breakpoints (struct ui_file
*file
, int from_tty
,
252 struct cmd_list_element
*c
,
255 fprintf_filtered (file
, _("\
256 Automatic usage of hardware breakpoints is %s.\n"),
261 void _initialize_breakpoint (void);
263 extern int addressprint
; /* Print machine addresses? */
265 /* Are we executing breakpoint commands? */
266 static int executing_breakpoint_commands
;
268 /* Are overlay event breakpoints enabled? */
269 static int overlay_events_enabled
;
271 /* Walk the following statement or block through all breakpoints.
272 ALL_BREAKPOINTS_SAFE does so even if the statment deletes the current
275 #define ALL_BREAKPOINTS(B) for (B = breakpoint_chain; B; B = B->next)
277 #define ALL_BREAKPOINTS_SAFE(B,TMP) \
278 for (B = breakpoint_chain; \
279 B ? (TMP=B->next, 1): 0; \
282 /* Similar iterators for the low-level breakpoints. */
284 #define ALL_BP_LOCATIONS(B) for (B = bp_location_chain; B; B = B->global_next)
286 #define ALL_BP_LOCATIONS_SAFE(B,TMP) \
287 for (B = bp_location_chain; \
288 B ? (TMP=B->global_next, 1): 0; \
291 /* True if breakpoint hit counts should be displayed in breakpoint info. */
293 int show_breakpoint_hit_counts
= 1;
295 /* Chains of all breakpoints defined. */
297 struct breakpoint
*breakpoint_chain
;
299 struct bp_location
*bp_location_chain
;
301 /* Number of last breakpoint made. */
303 int breakpoint_count
;
305 /* Pointer to current exception event record */
306 static struct exception_event_record
*current_exception_event
;
308 /* This function returns a pointer to the string representation of the
309 pathname of the dynamically-linked library that has just been
312 This function must be used only when SOLIB_HAVE_LOAD_EVENT is TRUE,
313 or undefined results are guaranteed.
315 This string's contents are only valid immediately after the
316 inferior has stopped in the dynamic linker hook, and becomes
317 invalid as soon as the inferior is continued. Clients should make
318 a copy of this string if they wish to continue the inferior and
319 then access the string. */
321 #ifndef SOLIB_LOADED_LIBRARY_PATHNAME
322 #define SOLIB_LOADED_LIBRARY_PATHNAME(pid) ""
325 /* This function returns a pointer to the string representation of the
326 pathname of the dynamically-linked library that has just been
329 This function must be used only when SOLIB_HAVE_UNLOAD_EVENT is
330 TRUE, or undefined results are guaranteed.
332 This string's contents are only valid immediately after the
333 inferior has stopped in the dynamic linker hook, and becomes
334 invalid as soon as the inferior is continued. Clients should make
335 a copy of this string if they wish to continue the inferior and
336 then access the string. */
338 #ifndef SOLIB_UNLOADED_LIBRARY_PATHNAME
339 #define SOLIB_UNLOADED_LIBRARY_PATHNAME(pid) ""
342 /* This function is called by the "catch load" command. It allows the
343 debugger to be notified by the dynamic linker when a specified
344 library file (or any library file, if filename is NULL) is loaded. */
346 #ifndef SOLIB_CREATE_CATCH_LOAD_HOOK
347 #define SOLIB_CREATE_CATCH_LOAD_HOOK(pid,tempflag,filename,cond_string) \
348 error (_("catch of library loads not yet implemented on this platform"))
351 /* This function is called by the "catch unload" command. It allows
352 the debugger to be notified by the dynamic linker when a specified
353 library file (or any library file, if filename is NULL) is
356 #ifndef SOLIB_CREATE_CATCH_UNLOAD_HOOK
357 #define SOLIB_CREATE_CATCH_UNLOAD_HOOK(pid, tempflag, filename, cond_string) \
358 error (_("catch of library unloads not yet implemented on this platform"))
361 /* Return whether a breakpoint is an active enabled breakpoint. */
363 breakpoint_enabled (struct breakpoint
*b
)
365 return (b
->enable_state
== bp_enabled
);
368 /* Set breakpoint count to NUM. */
371 set_breakpoint_count (int num
)
373 breakpoint_count
= num
;
374 set_internalvar (lookup_internalvar ("bpnum"),
375 value_from_longest (builtin_type_int
, (LONGEST
) num
));
378 /* Used in run_command to zero the hit count when a new run starts. */
381 clear_breakpoint_hit_counts (void)
383 struct breakpoint
*b
;
389 /* Default address, symtab and line to put a breakpoint at
390 for "break" command with no arg.
391 if default_breakpoint_valid is zero, the other three are
392 not valid, and "break" with no arg is an error.
394 This set by print_stack_frame, which calls set_default_breakpoint. */
396 int default_breakpoint_valid
;
397 CORE_ADDR default_breakpoint_address
;
398 struct symtab
*default_breakpoint_symtab
;
399 int default_breakpoint_line
;
401 /* *PP is a string denoting a breakpoint. Get the number of the breakpoint.
402 Advance *PP after the string and any trailing whitespace.
404 Currently the string can either be a number or "$" followed by the name
405 of a convenience variable. Making it an expression wouldn't work well
406 for map_breakpoint_numbers (e.g. "4 + 5 + 6").
408 If the string is a NULL pointer, that denotes the last breakpoint.
410 TRAILER is a character which can be found after the number; most
411 commonly this is `-'. If you don't want a trailer, use \0. */
413 get_number_trailer (char **pp
, int trailer
)
415 int retval
= 0; /* default */
419 /* Empty line means refer to the last breakpoint. */
420 return breakpoint_count
;
423 /* Make a copy of the name, so we can null-terminate it
424 to pass to lookup_internalvar(). */
429 while (isalnum (*p
) || *p
== '_')
431 varname
= (char *) alloca (p
- start
+ 1);
432 strncpy (varname
, start
, p
- start
);
433 varname
[p
- start
] = '\0';
434 val
= value_of_internalvar (lookup_internalvar (varname
));
435 if (TYPE_CODE (value_type (val
)) == TYPE_CODE_INT
)
436 retval
= (int) value_as_long (val
);
439 printf_filtered (_("Convenience variable must have integer value.\n"));
447 while (*p
>= '0' && *p
<= '9')
450 /* There is no number here. (e.g. "cond a == b"). */
452 /* Skip non-numeric token */
453 while (*p
&& !isspace((int) *p
))
455 /* Return zero, which caller must interpret as error. */
461 if (!(isspace (*p
) || *p
== '\0' || *p
== trailer
))
463 /* Trailing junk: return 0 and let caller print error msg. */
464 while (!(isspace (*p
) || *p
== '\0' || *p
== trailer
))
475 /* Like get_number_trailer, but don't allow a trailer. */
477 get_number (char **pp
)
479 return get_number_trailer (pp
, '\0');
482 /* Parse a number or a range.
483 * A number will be of the form handled by get_number.
484 * A range will be of the form <number1> - <number2>, and
485 * will represent all the integers between number1 and number2,
488 * While processing a range, this fuction is called iteratively;
489 * At each call it will return the next value in the range.
491 * At the beginning of parsing a range, the char pointer PP will
492 * be advanced past <number1> and left pointing at the '-' token.
493 * Subsequent calls will not advance the pointer until the range
494 * is completed. The call that completes the range will advance
495 * pointer PP past <number2>.
499 get_number_or_range (char **pp
)
501 static int last_retval
, end_value
;
502 static char *end_ptr
;
503 static int in_range
= 0;
507 /* Default case: pp is pointing either to a solo number,
508 or to the first number of a range. */
509 last_retval
= get_number_trailer (pp
, '-');
514 /* This is the start of a range (<number1> - <number2>).
515 Skip the '-', parse and remember the second number,
516 and also remember the end of the final token. */
520 while (isspace ((int) *end_ptr
))
521 end_ptr
++; /* skip white space */
522 end_value
= get_number (temp
);
523 if (end_value
< last_retval
)
525 error (_("inverted range"));
527 else if (end_value
== last_retval
)
529 /* degenerate range (number1 == number2). Advance the
530 token pointer so that the range will be treated as a
539 error (_("negative value"));
542 /* pp points to the '-' that betokens a range. All
543 number-parsing has already been done. Return the next
544 integer value (one greater than the saved previous value).
545 Do not advance the token pointer 'pp' until the end of range
548 if (++last_retval
== end_value
)
550 /* End of range reached; advance token pointer. */
560 /* condition N EXP -- set break condition of breakpoint N to EXP. */
563 condition_command (char *arg
, int from_tty
)
565 struct breakpoint
*b
;
570 error_no_arg (_("breakpoint number"));
573 bnum
= get_number (&p
);
575 error (_("Bad breakpoint argument: '%s'"), arg
);
578 if (b
->number
== bnum
)
580 struct bp_location
*loc
= b
->loc
;
581 for (; loc
; loc
= loc
->next
)
589 if (b
->cond_string
!= NULL
)
590 xfree (b
->cond_string
);
594 b
->cond_string
= NULL
;
596 printf_filtered (_("Breakpoint %d now unconditional.\n"), bnum
);
601 /* I don't know if it matters whether this is the string the user
602 typed in or the decompiled expression. */
603 b
->cond_string
= savestring (arg
, strlen (arg
));
604 b
->condition_not_parsed
= 0;
605 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
608 loc
->cond
= parse_exp_1 (&arg
, block_for_pc (loc
->address
), 0);
610 error (_("Junk at end of expression"));
613 breakpoints_changed ();
614 breakpoint_modify_event (b
->number
);
618 error (_("No breakpoint number %d."), bnum
);
622 commands_command (char *arg
, int from_tty
)
624 struct breakpoint
*b
;
627 struct command_line
*l
;
629 /* If we allowed this, we would have problems with when to
630 free the storage, if we change the commands currently
633 if (executing_breakpoint_commands
)
634 error (_("Can't use the \"commands\" command among a breakpoint's commands."));
637 bnum
= get_number (&p
);
640 error (_("Unexpected extra arguments following breakpoint number."));
643 if (b
->number
== bnum
)
645 char *tmpbuf
= xstrprintf ("Type commands for when breakpoint %d is hit, one per line.",
647 struct cleanup
*cleanups
= make_cleanup (xfree
, tmpbuf
);
648 l
= read_command_lines (tmpbuf
, from_tty
);
649 do_cleanups (cleanups
);
650 free_command_lines (&b
->commands
);
652 breakpoints_changed ();
653 breakpoint_modify_event (b
->number
);
656 error (_("No breakpoint number %d."), bnum
);
659 /* Like commands_command, but instead of reading the commands from
660 input stream, takes them from an already parsed command structure.
662 This is used by cli-script.c to DTRT with breakpoint commands
663 that are part of if and while bodies. */
664 enum command_control_type
665 commands_from_control_command (char *arg
, struct command_line
*cmd
)
667 struct breakpoint
*b
;
671 /* If we allowed this, we would have problems with when to
672 free the storage, if we change the commands currently
675 if (executing_breakpoint_commands
)
676 error (_("Can't use the \"commands\" command among a breakpoint's commands."));
678 /* An empty string for the breakpoint number means the last
679 breakpoint, but get_number expects a NULL pointer. */
684 bnum
= get_number (&p
);
687 error (_("Unexpected extra arguments following breakpoint number."));
690 if (b
->number
== bnum
)
692 free_command_lines (&b
->commands
);
693 if (cmd
->body_count
!= 1)
694 error (_("Invalid \"commands\" block structure."));
695 /* We need to copy the commands because if/while will free the
696 list after it finishes execution. */
697 b
->commands
= copy_command_lines (cmd
->body_list
[0]);
698 breakpoints_changed ();
699 breakpoint_modify_event (b
->number
);
700 return simple_control
;
702 error (_("No breakpoint number %d."), bnum
);
705 /* Update BUF, which is LEN bytes read from the target address MEMADDR,
706 by replacing any memory breakpoints with their shadowed contents. */
709 breakpoint_restore_shadows (gdb_byte
*buf
, ULONGEST memaddr
, LONGEST len
)
711 struct bp_location
*b
;
712 CORE_ADDR bp_addr
= 0;
718 if (b
->owner
->type
== bp_none
)
719 warning (_("reading through apparently deleted breakpoint #%d?"),
722 if (b
->loc_type
!= bp_loc_software_breakpoint
)
726 /* Addresses and length of the part of the breakpoint that
728 bp_addr
= b
->target_info
.placed_address
;
729 bp_size
= b
->target_info
.shadow_len
;
731 /* bp isn't valid, or doesn't shadow memory. */
734 if (bp_addr
+ bp_size
<= memaddr
)
735 /* The breakpoint is entirely before the chunk of memory we
739 if (bp_addr
>= memaddr
+ len
)
740 /* The breakpoint is entirely after the chunk of memory we are
744 /* Offset within shadow_contents. */
745 if (bp_addr
< memaddr
)
747 /* Only copy the second part of the breakpoint. */
748 bp_size
-= memaddr
- bp_addr
;
749 bptoffset
= memaddr
- bp_addr
;
753 if (bp_addr
+ bp_size
> memaddr
+ len
)
755 /* Only copy the first part of the breakpoint. */
756 bp_size
-= (bp_addr
+ bp_size
) - (memaddr
+ len
);
759 memcpy (buf
+ bp_addr
- memaddr
,
760 b
->target_info
.shadow_contents
+ bptoffset
, bp_size
);
765 /* A wrapper function for inserting catchpoints. */
767 insert_catchpoint (struct ui_out
*uo
, void *args
)
769 struct breakpoint
*b
= (struct breakpoint
*) args
;
775 target_insert_fork_catchpoint (PIDGET (inferior_ptid
));
778 target_insert_vfork_catchpoint (PIDGET (inferior_ptid
));
781 target_insert_exec_catchpoint (PIDGET (inferior_ptid
));
784 internal_error (__FILE__
, __LINE__
, _("unknown breakpoint type"));
790 is_hardware_watchpoint (struct breakpoint
*bpt
)
792 return (bpt
->type
== bp_hardware_watchpoint
793 || bpt
->type
== bp_read_watchpoint
794 || bpt
->type
== bp_access_watchpoint
);
797 /* Find the current value of a watchpoint on EXP. Return the value in
798 *VALP and *RESULTP and the chain of intermediate and final values
799 in *VAL_CHAIN. RESULTP and VAL_CHAIN may be NULL if the caller does
802 If an error occurs while evaluating the expression, *RESULTP will
803 be set to NULL. *RESULTP may be a lazy value, if the result could
804 not be read from memory. It is used to determine whether a value
805 is user-specified (we should watch the whole value) or intermediate
806 (we should watch only the bit used to locate the final value).
808 If the final value, or any intermediate value, could not be read
809 from memory, *VALP will be set to NULL. *VAL_CHAIN will still be
810 set to any referenced values. *VALP will never be a lazy value.
811 This is the value which we store in struct breakpoint.
813 If VAL_CHAIN is non-NULL, *VAL_CHAIN will be released from the
814 value chain. The caller must free the values individually. If
815 VAL_CHAIN is NULL, all generated values will be left on the value
819 fetch_watchpoint_value (struct expression
*exp
, struct value
**valp
,
820 struct value
**resultp
, struct value
**val_chain
)
822 struct value
*mark
, *new_mark
, *result
;
830 /* Evaluate the expression. */
831 mark
= value_mark ();
833 gdb_evaluate_expression (exp
, &result
);
834 new_mark
= value_mark ();
835 if (mark
== new_mark
)
840 /* Make sure it's not lazy, so that after the target stops again we
841 have a non-lazy previous value to compare with. */
843 && (!value_lazy (result
) || gdb_value_fetch_lazy (result
)))
848 /* Return the chain of intermediate values. We use this to
849 decide which addresses to watch. */
850 *val_chain
= new_mark
;
851 value_release_to_mark (mark
);
855 /* Assuming that B is a hardware watchpoint:
856 - Reparse watchpoint expression, is REPARSE is non-zero
857 - Evaluate expression and store the result in B->val
858 - Update the list of values that must be watched in B->loc.
860 If the watchpoint is disabled, do nothing. If this is
861 local watchpoint that is out of scope, delete it. */
863 update_watchpoint (struct breakpoint
*b
, int reparse
)
865 int within_current_scope
;
866 struct frame_id saved_frame_id
;
867 struct bp_location
*loc
;
870 unlink_locations_from_global_list (b
);
871 for (loc
= b
->loc
; loc
;)
873 struct bp_location
*loc_next
= loc
->next
;
874 remove_breakpoint (loc
, mark_uninserted
);
880 if (b
->disposition
== disp_del_at_next_stop
)
883 /* Save the current frame's ID so we can restore it after
884 evaluating the watchpoint expression on its own frame. */
885 /* FIXME drow/2003-09-09: It would be nice if evaluate_expression
886 took a frame parameter, so that we didn't have to change the
888 saved_frame_id
= get_frame_id (get_selected_frame (NULL
));
890 /* Determine if the watchpoint is within scope. */
891 if (b
->exp_valid_block
== NULL
)
892 within_current_scope
= 1;
895 struct frame_info
*fi
;
896 fi
= frame_find_by_id (b
->watchpoint_frame
);
897 within_current_scope
= (fi
!= NULL
);
898 if (within_current_scope
)
902 if (within_current_scope
&& reparse
)
911 b
->exp
= parse_exp_1 (&s
, b
->exp_valid_block
, 0);
912 /* If the meaning of expression itself changed, the old value is
913 no longer relevant. We don't want to report a watchpoint hit
914 to the user when the old value and the new value may actually
915 be completely different objects. */
921 /* If we failed to parse the expression, for example because
922 it refers to a global variable in a not-yet-loaded shared library,
923 don't try to insert watchpoint. We don't automatically delete
924 such watchpoint, though, since failure to parse expression
925 is different from out-of-scope watchpoint. */
926 if (within_current_scope
&& b
->exp
)
928 struct value
*val_chain
, *v
, *result
, *next
;
930 fetch_watchpoint_value (b
->exp
, &v
, &result
, &val_chain
);
932 /* Avoid setting b->val if it's already set. The meaning of
933 b->val is 'the last value' user saw, and we should update
934 it only if we reported that last value to user. As it
935 happens, the code that reports it updates b->val directly. */
942 /* Look at each value on the value chain. */
943 for (v
= val_chain
; v
; v
= next
)
945 /* If it's a memory location, and GDB actually needed
946 its contents to evaluate the expression, then we
947 must watch it. If the first value returned is
948 still lazy, that means an error occurred reading it;
949 watch it anyway in case it becomes readable. */
950 if (VALUE_LVAL (v
) == lval_memory
951 && (v
== val_chain
|| ! value_lazy (v
)))
953 struct type
*vtype
= check_typedef (value_type (v
));
955 /* We only watch structs and arrays if user asked
956 for it explicitly, never if they just happen to
957 appear in the middle of some value chain. */
959 || (TYPE_CODE (vtype
) != TYPE_CODE_STRUCT
960 && TYPE_CODE (vtype
) != TYPE_CODE_ARRAY
))
964 struct bp_location
*loc
, **tmp
;
966 addr
= VALUE_ADDRESS (v
) + value_offset (v
);
967 len
= TYPE_LENGTH (value_type (v
));
969 if (b
->type
== bp_read_watchpoint
)
971 else if (b
->type
== bp_access_watchpoint
)
974 loc
= allocate_bp_location (b
, bp_hardware_watchpoint
);
975 for (tmp
= &(b
->loc
); *tmp
!= NULL
; tmp
= &((*tmp
)->next
))
980 loc
->watchpoint_type
= type
;
984 next
= value_next (v
);
989 if (reparse
&& b
->cond_string
!= NULL
)
991 char *s
= b
->cond_string
;
994 xfree (b
->loc
->cond
);
997 b
->loc
->cond
= parse_exp_1 (&s
, b
->exp_valid_block
, 0);
1000 else if (!within_current_scope
)
1002 printf_filtered (_("\
1003 Hardware watchpoint %d deleted because the program has left the block \n\
1004 in which its expression is valid.\n"),
1006 if (b
->related_breakpoint
)
1007 b
->related_breakpoint
->disposition
= disp_del_at_next_stop
;
1008 b
->disposition
= disp_del_at_next_stop
;
1011 /* Restore the selected frame. */
1012 select_frame (frame_find_by_id (saved_frame_id
));
1016 /* Insert a low-level "breakpoint" of some type. BPT is the breakpoint.
1017 Any error messages are printed to TMP_ERROR_STREAM; and DISABLED_BREAKS,
1018 PROCESS_WARNING, and HW_BREAKPOINT_ERROR are used to report problems.
1020 NOTE drow/2003-09-09: This routine could be broken down to an object-style
1021 method for each breakpoint or catchpoint type. */
1023 insert_bp_location (struct bp_location
*bpt
,
1024 struct ui_file
*tmp_error_stream
,
1025 int *disabled_breaks
, int *process_warning
,
1026 int *hw_breakpoint_error
)
1030 if (!breakpoint_enabled (bpt
->owner
))
1033 if (!bpt
->enabled
|| bpt
->shlib_disabled
|| bpt
->inserted
|| bpt
->duplicate
)
1036 /* Initialize the target-specific information. */
1037 memset (&bpt
->target_info
, 0, sizeof (bpt
->target_info
));
1038 bpt
->target_info
.placed_address
= bpt
->address
;
1040 if (bpt
->loc_type
== bp_loc_software_breakpoint
1041 || bpt
->loc_type
== bp_loc_hardware_breakpoint
)
1043 if (bpt
->owner
->type
!= bp_hardware_breakpoint
)
1045 /* If the explicitly specified breakpoint type
1046 is not hardware breakpoint, check the memory map to see
1047 if the breakpoint address is in read only memory or not.
1048 Two important cases are:
1049 - location type is not hardware breakpoint, memory
1050 is readonly. We change the type of the location to
1051 hardware breakpoint.
1052 - location type is hardware breakpoint, memory is read-write.
1053 This means we've previously made the location hardware one, but
1054 then the memory map changed, so we undo.
1056 When breakpoints are removed, remove_breakpoints will
1057 use location types we've just set here, the only possible
1058 problem is that memory map has changed during running program,
1059 but it's not going to work anyway with current gdb. */
1060 struct mem_region
*mr
1061 = lookup_mem_region (bpt
->target_info
.placed_address
);
1065 if (automatic_hardware_breakpoints
)
1068 enum bp_loc_type new_type
;
1070 if (mr
->attrib
.mode
!= MEM_RW
)
1071 new_type
= bp_loc_hardware_breakpoint
;
1073 new_type
= bp_loc_software_breakpoint
;
1075 if (new_type
!= bpt
->loc_type
)
1077 static int said
= 0;
1078 bpt
->loc_type
= new_type
;
1081 fprintf_filtered (gdb_stdout
, _("\
1082 Note: automatically using hardware breakpoints for read-only addresses.\n"));
1087 else if (bpt
->loc_type
== bp_loc_software_breakpoint
1088 && mr
->attrib
.mode
!= MEM_RW
)
1089 warning (_("cannot set software breakpoint at readonly address %s"),
1090 paddr (bpt
->address
));
1094 /* First check to see if we have to handle an overlay. */
1095 if (overlay_debugging
== ovly_off
1096 || bpt
->section
== NULL
1097 || !(section_is_overlay (bpt
->section
)))
1099 /* No overlay handling: just set the breakpoint. */
1101 if (bpt
->loc_type
== bp_loc_hardware_breakpoint
)
1102 val
= target_insert_hw_breakpoint (&bpt
->target_info
);
1104 val
= target_insert_breakpoint (&bpt
->target_info
);
1108 /* This breakpoint is in an overlay section.
1109 Shall we set a breakpoint at the LMA? */
1110 if (!overlay_events_enabled
)
1112 /* Yes -- overlay event support is not active,
1113 so we must try to set a breakpoint at the LMA.
1114 This will not work for a hardware breakpoint. */
1115 if (bpt
->loc_type
== bp_loc_hardware_breakpoint
)
1116 warning (_("hardware breakpoint %d not supported in overlay!"),
1117 bpt
->owner
->number
);
1120 CORE_ADDR addr
= overlay_unmapped_address (bpt
->address
,
1122 /* Set a software (trap) breakpoint at the LMA. */
1123 bpt
->overlay_target_info
= bpt
->target_info
;
1124 bpt
->overlay_target_info
.placed_address
= addr
;
1125 val
= target_insert_breakpoint (&bpt
->overlay_target_info
);
1127 fprintf_unfiltered (tmp_error_stream
,
1128 "Overlay breakpoint %d failed: in ROM?",
1129 bpt
->owner
->number
);
1132 /* Shall we set a breakpoint at the VMA? */
1133 if (section_is_mapped (bpt
->section
))
1135 /* Yes. This overlay section is mapped into memory. */
1136 if (bpt
->loc_type
== bp_loc_hardware_breakpoint
)
1137 val
= target_insert_hw_breakpoint (&bpt
->target_info
);
1139 val
= target_insert_breakpoint (&bpt
->target_info
);
1143 /* No. This breakpoint will not be inserted.
1144 No error, but do not mark the bp as 'inserted'. */
1151 /* Can't set the breakpoint. */
1152 if (solib_address (bpt
->address
))
1154 /* See also: disable_breakpoints_in_shlibs. */
1156 bpt
->shlib_disabled
= 1;
1157 if (!*disabled_breaks
)
1159 fprintf_unfiltered (tmp_error_stream
,
1160 "Cannot insert breakpoint %d.\n",
1161 bpt
->owner
->number
);
1162 fprintf_unfiltered (tmp_error_stream
,
1163 "Temporarily disabling shared library breakpoints:\n");
1165 *disabled_breaks
= 1;
1166 fprintf_unfiltered (tmp_error_stream
,
1167 "breakpoint #%d\n", bpt
->owner
->number
);
1171 #ifdef ONE_PROCESS_WRITETEXT
1172 *process_warning
= 1;
1174 if (bpt
->loc_type
== bp_loc_hardware_breakpoint
)
1176 *hw_breakpoint_error
= 1;
1177 fprintf_unfiltered (tmp_error_stream
,
1178 "Cannot insert hardware breakpoint %d.\n",
1179 bpt
->owner
->number
);
1183 fprintf_unfiltered (tmp_error_stream
,
1184 "Cannot insert breakpoint %d.\n",
1185 bpt
->owner
->number
);
1186 fprintf_filtered (tmp_error_stream
,
1187 "Error accessing memory address ");
1188 fputs_filtered (paddress (bpt
->address
), tmp_error_stream
);
1189 fprintf_filtered (tmp_error_stream
, ": %s.\n",
1190 safe_strerror (val
));
1201 else if (bpt
->loc_type
== bp_loc_hardware_watchpoint
1202 /* NOTE drow/2003-09-08: This state only exists for removing
1203 watchpoints. It's not clear that it's necessary... */
1204 && bpt
->owner
->disposition
!= disp_del_at_next_stop
)
1206 val
= target_insert_watchpoint (bpt
->address
,
1208 bpt
->watchpoint_type
);
1209 bpt
->inserted
= (val
!= -1);
1212 else if (bpt
->owner
->type
== bp_catch_fork
1213 || bpt
->owner
->type
== bp_catch_vfork
1214 || bpt
->owner
->type
== bp_catch_exec
)
1216 struct gdb_exception e
= catch_exception (uiout
, insert_catchpoint
,
1217 bpt
->owner
, RETURN_MASK_ERROR
);
1218 exception_fprintf (gdb_stderr
, e
, "warning: inserting catchpoint %d: ",
1219 bpt
->owner
->number
);
1221 bpt
->owner
->enable_state
= bp_disabled
;
1225 /* We've already printed an error message if there was a problem
1226 inserting this catchpoint, and we've disabled the catchpoint,
1227 so just return success. */
1234 /* insert_breakpoints is used when starting or continuing the program.
1235 remove_breakpoints is used when the program stops.
1236 Both return zero if successful,
1237 or an `errno' value if could not write the inferior. */
1240 insert_breakpoints (void)
1242 struct breakpoint
*bpt
;
1243 struct bp_location
*b
, *temp
;
1246 int disabled_breaks
= 0;
1247 int hw_breakpoint_error
= 0;
1248 int process_warning
= 0;
1250 struct ui_file
*tmp_error_stream
= mem_fileopen ();
1251 make_cleanup_ui_file_delete (tmp_error_stream
);
1253 /* Explicitly mark the warning -- this will only be printed if
1254 there was an error. */
1255 fprintf_unfiltered (tmp_error_stream
, "Warning:\n");
1257 ALL_BREAKPOINTS (bpt
)
1258 if (is_hardware_watchpoint (bpt
))
1259 update_watchpoint (bpt
, 0 /* don't reparse */);
1261 ALL_BP_LOCATIONS_SAFE (b
, temp
)
1263 if (!breakpoint_enabled (b
->owner
))
1266 /* There is no point inserting thread-specific breakpoints if the
1267 thread no longer exists. */
1268 if (b
->owner
->thread
!= -1
1269 && !valid_thread_id (b
->owner
->thread
))
1272 val
= insert_bp_location (b
, tmp_error_stream
,
1273 &disabled_breaks
, &process_warning
,
1274 &hw_breakpoint_error
);
1279 /* If we failed to insert all locations of a watchpoint,
1280 remove them, as half-inserted watchpoint is of limited use. */
1281 ALL_BREAKPOINTS (bpt
)
1283 int some_failed
= 0;
1284 struct bp_location
*loc
;
1286 if (!is_hardware_watchpoint (bpt
))
1289 if (bpt
->enable_state
!= bp_enabled
)
1292 for (loc
= bpt
->loc
; loc
; loc
= loc
->next
)
1300 for (loc
= bpt
->loc
; loc
; loc
= loc
->next
)
1302 remove_breakpoint (loc
, mark_uninserted
);
1304 hw_breakpoint_error
= 1;
1305 fprintf_unfiltered (tmp_error_stream
,
1306 "Could not insert hardware watchpoint %d.\n",
1314 /* If a hardware breakpoint or watchpoint was inserted, add a
1315 message about possibly exhausted resources. */
1316 if (hw_breakpoint_error
)
1318 fprintf_unfiltered (tmp_error_stream
,
1319 "Could not insert hardware breakpoints:\n\
1320 You may have requested too many hardware breakpoints/watchpoints.\n");
1322 #ifdef ONE_PROCESS_WRITETEXT
1323 if (process_warning
)
1324 fprintf_unfiltered (tmp_error_stream
,
1325 "The same program may be running in another process.");
1327 target_terminal_ours_for_output ();
1328 error_stream (tmp_error_stream
);
1333 remove_breakpoints (void)
1335 struct bp_location
*b
;
1338 ALL_BP_LOCATIONS (b
)
1342 val
= remove_breakpoint (b
, mark_uninserted
);
1351 remove_hw_watchpoints (void)
1353 struct bp_location
*b
;
1356 ALL_BP_LOCATIONS (b
)
1358 if (b
->inserted
&& b
->loc_type
== bp_loc_hardware_watchpoint
)
1360 val
= remove_breakpoint (b
, mark_uninserted
);
1369 reattach_breakpoints (int pid
)
1371 struct bp_location
*b
;
1373 struct cleanup
*old_chain
= save_inferior_ptid ();
1374 struct ui_file
*tmp_error_stream
= mem_fileopen ();
1375 int dummy1
= 0, dummy2
= 0, dummy3
= 0;
1377 make_cleanup_ui_file_delete (tmp_error_stream
);
1379 inferior_ptid
= pid_to_ptid (pid
);
1380 ALL_BP_LOCATIONS (b
)
1385 val
= insert_bp_location (b
, tmp_error_stream
,
1386 &dummy1
, &dummy2
, &dummy3
);
1389 do_cleanups (old_chain
);
1394 do_cleanups (old_chain
);
1399 update_breakpoints_after_exec (void)
1401 struct breakpoint
*b
;
1402 struct breakpoint
*temp
;
1404 /* Doing this first prevents the badness of having delete_breakpoint()
1405 write a breakpoint's current "shadow contents" to lift the bp. That
1406 shadow is NOT valid after an exec()! */
1407 mark_breakpoints_out ();
1409 ALL_BREAKPOINTS_SAFE (b
, temp
)
1411 /* Solib breakpoints must be explicitly reset after an exec(). */
1412 if (b
->type
== bp_shlib_event
)
1414 delete_breakpoint (b
);
1418 /* Thread event breakpoints must be set anew after an exec(),
1419 as must overlay event breakpoints. */
1420 if (b
->type
== bp_thread_event
|| b
->type
== bp_overlay_event
)
1422 delete_breakpoint (b
);
1426 /* Step-resume breakpoints are meaningless after an exec(). */
1427 if (b
->type
== bp_step_resume
)
1429 delete_breakpoint (b
);
1433 /* Don't delete an exec catchpoint, because else the inferior
1434 won't stop when it ought!
1436 Similarly, we probably ought to keep vfork catchpoints, 'cause
1437 on this target, we may not be able to stop when the vfork is
1438 seen, but only when the subsequent exec is seen. (And because
1439 deleting fork catchpoints here but not vfork catchpoints will
1440 seem mysterious to users, keep those too.) */
1441 if ((b
->type
== bp_catch_exec
) ||
1442 (b
->type
== bp_catch_vfork
) ||
1443 (b
->type
== bp_catch_fork
))
1448 /* bp_finish is a special case. The only way we ought to be able
1449 to see one of these when an exec() has happened, is if the user
1450 caught a vfork, and then said "finish". Ordinarily a finish just
1451 carries them to the call-site of the current callee, by setting
1452 a temporary bp there and resuming. But in this case, the finish
1453 will carry them entirely through the vfork & exec.
1455 We don't want to allow a bp_finish to remain inserted now. But
1456 we can't safely delete it, 'cause finish_command has a handle to
1457 the bp on a bpstat, and will later want to delete it. There's a
1458 chance (and I've seen it happen) that if we delete the bp_finish
1459 here, that its storage will get reused by the time finish_command
1460 gets 'round to deleting the "use to be a bp_finish" breakpoint.
1461 We really must allow finish_command to delete a bp_finish.
1463 In the absense of a general solution for the "how do we know
1464 it's safe to delete something others may have handles to?"
1465 problem, what we'll do here is just uninsert the bp_finish, and
1466 let finish_command delete it.
1468 (We know the bp_finish is "doomed" in the sense that it's
1469 momentary, and will be deleted as soon as finish_command sees
1470 the inferior stopped. So it doesn't matter that the bp's
1471 address is probably bogus in the new a.out, unlike e.g., the
1472 solib breakpoints.) */
1474 if (b
->type
== bp_finish
)
1479 /* Without a symbolic address, we have little hope of the
1480 pre-exec() address meaning the same thing in the post-exec()
1482 if (b
->addr_string
== NULL
)
1484 delete_breakpoint (b
);
1488 /* FIXME what about longjmp breakpoints? Re-create them here? */
1489 create_overlay_event_breakpoint ("_ovly_debug_event");
1493 detach_breakpoints (int pid
)
1495 struct bp_location
*b
;
1497 struct cleanup
*old_chain
= save_inferior_ptid ();
1499 if (pid
== PIDGET (inferior_ptid
))
1500 error (_("Cannot detach breakpoints of inferior_ptid"));
1502 /* Set inferior_ptid; remove_breakpoint uses this global. */
1503 inferior_ptid
= pid_to_ptid (pid
);
1504 ALL_BP_LOCATIONS (b
)
1508 val
= remove_breakpoint (b
, mark_inserted
);
1511 do_cleanups (old_chain
);
1516 do_cleanups (old_chain
);
1521 remove_breakpoint (struct bp_location
*b
, insertion_state_t is
)
1525 if (b
->owner
->enable_state
== bp_permanent
)
1526 /* Permanent breakpoints cannot be inserted or removed. */
1529 if (b
->owner
->type
== bp_none
)
1530 warning (_("attempted to remove apparently deleted breakpoint #%d?"),
1533 if (b
->loc_type
== bp_loc_software_breakpoint
1534 || b
->loc_type
== bp_loc_hardware_breakpoint
)
1536 /* "Normal" instruction breakpoint: either the standard
1537 trap-instruction bp (bp_breakpoint), or a
1538 bp_hardware_breakpoint. */
1540 /* First check to see if we have to handle an overlay. */
1541 if (overlay_debugging
== ovly_off
1542 || b
->section
== NULL
1543 || !(section_is_overlay (b
->section
)))
1545 /* No overlay handling: just remove the breakpoint. */
1547 if (b
->loc_type
== bp_loc_hardware_breakpoint
)
1548 val
= target_remove_hw_breakpoint (&b
->target_info
);
1550 val
= target_remove_breakpoint (&b
->target_info
);
1554 /* This breakpoint is in an overlay section.
1555 Did we set a breakpoint at the LMA? */
1556 if (!overlay_events_enabled
)
1558 /* Yes -- overlay event support is not active, so we
1559 should have set a breakpoint at the LMA. Remove it.
1561 /* Ignore any failures: if the LMA is in ROM, we will
1562 have already warned when we failed to insert it. */
1563 if (b
->loc_type
== bp_loc_hardware_breakpoint
)
1564 target_remove_hw_breakpoint (&b
->overlay_target_info
);
1566 target_remove_breakpoint (&b
->overlay_target_info
);
1568 /* Did we set a breakpoint at the VMA?
1569 If so, we will have marked the breakpoint 'inserted'. */
1572 /* Yes -- remove it. Previously we did not bother to
1573 remove the breakpoint if the section had been
1574 unmapped, but let's not rely on that being safe. We
1575 don't know what the overlay manager might do. */
1576 if (b
->loc_type
== bp_loc_hardware_breakpoint
)
1577 val
= target_remove_hw_breakpoint (&b
->target_info
);
1579 /* However, we should remove *software* breakpoints only
1580 if the section is still mapped, or else we overwrite
1581 wrong code with the saved shadow contents. */
1582 else if (section_is_mapped (b
->section
))
1583 val
= target_remove_breakpoint (&b
->target_info
);
1589 /* No -- not inserted, so no need to remove. No error. */
1595 b
->inserted
= (is
== mark_inserted
);
1597 else if (b
->loc_type
== bp_loc_hardware_watchpoint
)
1602 b
->inserted
= (is
== mark_inserted
);
1603 val
= target_remove_watchpoint (b
->address
, b
->length
,
1604 b
->watchpoint_type
);
1606 /* Failure to remove any of the hardware watchpoints comes here. */
1607 if ((is
== mark_uninserted
) && (b
->inserted
))
1608 warning (_("Could not remove hardware watchpoint %d."),
1611 else if ((b
->owner
->type
== bp_catch_fork
||
1612 b
->owner
->type
== bp_catch_vfork
||
1613 b
->owner
->type
== bp_catch_exec
)
1614 && breakpoint_enabled (b
->owner
)
1618 switch (b
->owner
->type
)
1621 val
= target_remove_fork_catchpoint (PIDGET (inferior_ptid
));
1623 case bp_catch_vfork
:
1624 val
= target_remove_vfork_catchpoint (PIDGET (inferior_ptid
));
1627 val
= target_remove_exec_catchpoint (PIDGET (inferior_ptid
));
1630 warning (_("Internal error, %s line %d."), __FILE__
, __LINE__
);
1635 b
->inserted
= (is
== mark_inserted
);
1641 /* Clear the "inserted" flag in all breakpoints. */
1644 mark_breakpoints_out (void)
1646 struct bp_location
*bpt
;
1648 ALL_BP_LOCATIONS (bpt
)
1652 /* Clear the "inserted" flag in all breakpoints and delete any
1653 breakpoints which should go away between runs of the program.
1655 Plus other such housekeeping that has to be done for breakpoints
1658 Note: this function gets called at the end of a run (by
1659 generic_mourn_inferior) and when a run begins (by
1660 init_wait_for_inferior). */
1665 breakpoint_init_inferior (enum inf_context context
)
1667 struct breakpoint
*b
, *temp
;
1668 struct bp_location
*bpt
;
1670 ALL_BP_LOCATIONS (bpt
)
1673 ALL_BREAKPOINTS_SAFE (b
, temp
)
1678 case bp_watchpoint_scope
:
1680 /* If the call dummy breakpoint is at the entry point it will
1681 cause problems when the inferior is rerun, so we better
1684 Also get rid of scope breakpoints. */
1685 delete_breakpoint (b
);
1689 case bp_hardware_watchpoint
:
1690 case bp_read_watchpoint
:
1691 case bp_access_watchpoint
:
1693 /* Likewise for watchpoints on local expressions. */
1694 if (b
->exp_valid_block
!= NULL
)
1695 delete_breakpoint (b
);
1696 else if (context
== inf_starting
)
1698 /* Reset val field to force reread of starting value
1699 in insert_breakpoints. */
1701 value_free (b
->val
);
1712 /* breakpoint_here_p (PC) returns non-zero if an enabled breakpoint
1713 exists at PC. It returns ordinary_breakpoint_here if it's an
1714 ordinary breakpoint, or permanent_breakpoint_here if it's a
1715 permanent breakpoint.
1716 - When continuing from a location with an ordinary breakpoint, we
1717 actually single step once before calling insert_breakpoints.
1718 - When continuing from a localion with a permanent breakpoint, we
1719 need to use the `SKIP_PERMANENT_BREAKPOINT' macro, provided by
1720 the target, to advance the PC past the breakpoint. */
1722 enum breakpoint_here
1723 breakpoint_here_p (CORE_ADDR pc
)
1725 const struct bp_location
*bpt
;
1726 int any_breakpoint_here
= 0;
1728 ALL_BP_LOCATIONS (bpt
)
1730 if (bpt
->loc_type
!= bp_loc_software_breakpoint
1731 && bpt
->loc_type
!= bp_loc_hardware_breakpoint
)
1734 if ((breakpoint_enabled (bpt
->owner
)
1735 || bpt
->owner
->enable_state
== bp_permanent
)
1736 && bpt
->address
== pc
) /* bp is enabled and matches pc */
1738 if (overlay_debugging
1739 && section_is_overlay (bpt
->section
)
1740 && !section_is_mapped (bpt
->section
))
1741 continue; /* unmapped overlay -- can't be a match */
1742 else if (bpt
->owner
->enable_state
== bp_permanent
)
1743 return permanent_breakpoint_here
;
1745 any_breakpoint_here
= 1;
1749 return any_breakpoint_here
? ordinary_breakpoint_here
: 0;
1753 /* Returns non-zero if there's a breakpoint inserted at PC, which is
1754 inserted using regular breakpoint_chain/bp_location_chain mechanism.
1755 This does not check for single-step breakpoints, which are
1756 inserted and removed using direct target manipulation. */
1759 regular_breakpoint_inserted_here_p (CORE_ADDR pc
)
1761 const struct bp_location
*bpt
;
1763 ALL_BP_LOCATIONS (bpt
)
1765 if (bpt
->loc_type
!= bp_loc_software_breakpoint
1766 && bpt
->loc_type
!= bp_loc_hardware_breakpoint
)
1770 && bpt
->address
== pc
) /* bp is inserted and matches pc */
1772 if (overlay_debugging
1773 && section_is_overlay (bpt
->section
)
1774 && !section_is_mapped (bpt
->section
))
1775 continue; /* unmapped overlay -- can't be a match */
1783 /* Returns non-zero iff there's either regular breakpoint
1784 or a single step breakpoint inserted at PC. */
1787 breakpoint_inserted_here_p (CORE_ADDR pc
)
1789 if (regular_breakpoint_inserted_here_p (pc
))
1792 if (single_step_breakpoint_inserted_here_p (pc
))
1798 /* This function returns non-zero iff there is a software breakpoint
1802 software_breakpoint_inserted_here_p (CORE_ADDR pc
)
1804 const struct bp_location
*bpt
;
1805 int any_breakpoint_here
= 0;
1807 ALL_BP_LOCATIONS (bpt
)
1809 if (bpt
->loc_type
!= bp_loc_software_breakpoint
)
1813 && bpt
->address
== pc
) /* bp is enabled and matches pc */
1815 if (overlay_debugging
1816 && section_is_overlay (bpt
->section
)
1817 && !section_is_mapped (bpt
->section
))
1818 continue; /* unmapped overlay -- can't be a match */
1824 /* Also check for software single-step breakpoints. */
1825 if (single_step_breakpoint_inserted_here_p (pc
))
1831 /* breakpoint_thread_match (PC, PTID) returns true if the breakpoint at
1832 PC is valid for process/thread PTID. */
1835 breakpoint_thread_match (CORE_ADDR pc
, ptid_t ptid
)
1837 const struct bp_location
*bpt
;
1840 thread
= pid_to_thread_id (ptid
);
1842 ALL_BP_LOCATIONS (bpt
)
1844 if (bpt
->loc_type
!= bp_loc_software_breakpoint
1845 && bpt
->loc_type
!= bp_loc_hardware_breakpoint
)
1848 if ((breakpoint_enabled (bpt
->owner
)
1849 || bpt
->owner
->enable_state
== bp_permanent
)
1850 && bpt
->address
== pc
1851 && (bpt
->owner
->thread
== -1 || bpt
->owner
->thread
== thread
))
1853 if (overlay_debugging
1854 && section_is_overlay (bpt
->section
)
1855 && !section_is_mapped (bpt
->section
))
1856 continue; /* unmapped overlay -- can't be a match */
1866 /* bpstat stuff. External routines' interfaces are documented
1870 ep_is_catchpoint (struct breakpoint
*ep
)
1873 (ep
->type
== bp_catch_load
)
1874 || (ep
->type
== bp_catch_unload
)
1875 || (ep
->type
== bp_catch_fork
)
1876 || (ep
->type
== bp_catch_vfork
)
1877 || (ep
->type
== bp_catch_exec
);
1879 /* ??rehrauer: Add more kinds here, as are implemented... */
1883 ep_is_shlib_catchpoint (struct breakpoint
*ep
)
1886 (ep
->type
== bp_catch_load
)
1887 || (ep
->type
== bp_catch_unload
);
1891 bpstat_free (bpstat bs
)
1893 if (bs
->old_val
!= NULL
)
1894 value_free (bs
->old_val
);
1895 free_command_lines (&bs
->commands
);
1899 /* Clear a bpstat so that it says we are not at any breakpoint.
1900 Also free any storage that is part of a bpstat. */
1903 bpstat_clear (bpstat
*bsp
)
1920 /* Return a copy of a bpstat. Like "bs1 = bs2" but all storage that
1921 is part of the bpstat is copied as well. */
1924 bpstat_copy (bpstat bs
)
1928 bpstat retval
= NULL
;
1933 for (; bs
!= NULL
; bs
= bs
->next
)
1935 tmp
= (bpstat
) xmalloc (sizeof (*tmp
));
1936 memcpy (tmp
, bs
, sizeof (*tmp
));
1937 if (bs
->commands
!= NULL
)
1938 tmp
->commands
= copy_command_lines (bs
->commands
);
1939 if (bs
->old_val
!= NULL
)
1940 tmp
->old_val
= value_copy (bs
->old_val
);
1943 /* This is the first thing in the chain. */
1953 /* Find the bpstat associated with this breakpoint */
1956 bpstat_find_breakpoint (bpstat bsp
, struct breakpoint
*breakpoint
)
1961 for (; bsp
!= NULL
; bsp
= bsp
->next
)
1963 if (bsp
->breakpoint_at
&& bsp
->breakpoint_at
->owner
== breakpoint
)
1969 /* Find a step_resume breakpoint associated with this bpstat.
1970 (If there are multiple step_resume bp's on the list, this function
1971 will arbitrarily pick one.)
1973 It is an error to use this function if BPSTAT doesn't contain a
1974 step_resume breakpoint.
1976 See wait_for_inferior's use of this function. */
1978 bpstat_find_step_resume_breakpoint (bpstat bsp
)
1982 gdb_assert (bsp
!= NULL
);
1984 current_thread
= pid_to_thread_id (inferior_ptid
);
1986 for (; bsp
!= NULL
; bsp
= bsp
->next
)
1988 if ((bsp
->breakpoint_at
!= NULL
) &&
1989 (bsp
->breakpoint_at
->owner
->type
== bp_step_resume
) &&
1990 (bsp
->breakpoint_at
->owner
->thread
== current_thread
||
1991 bsp
->breakpoint_at
->owner
->thread
== -1))
1992 return bsp
->breakpoint_at
->owner
;
1995 internal_error (__FILE__
, __LINE__
, _("No step_resume breakpoint found."));
1999 /* Put in *NUM the breakpoint number of the first breakpoint we are stopped
2000 at. *BSP upon return is a bpstat which points to the remaining
2001 breakpoints stopped at (but which is not guaranteed to be good for
2002 anything but further calls to bpstat_num).
2003 Return 0 if passed a bpstat which does not indicate any breakpoints.
2004 Return -1 if stopped at a breakpoint that has been deleted since
2006 Return 1 otherwise. */
2009 bpstat_num (bpstat
*bsp
, int *num
)
2011 struct breakpoint
*b
;
2014 return 0; /* No more breakpoint values */
2016 /* We assume we'll never have several bpstats that
2017 correspond to a single breakpoint -- otherwise,
2018 this function might return the same number more
2019 than once and this will look ugly. */
2020 b
= (*bsp
)->breakpoint_at
? (*bsp
)->breakpoint_at
->owner
: NULL
;
2021 *bsp
= (*bsp
)->next
;
2023 return -1; /* breakpoint that's been deleted since */
2025 *num
= b
->number
; /* We have its number */
2029 /* Modify BS so that the actions will not be performed. */
2032 bpstat_clear_actions (bpstat bs
)
2034 for (; bs
!= NULL
; bs
= bs
->next
)
2036 free_command_lines (&bs
->commands
);
2037 if (bs
->old_val
!= NULL
)
2039 value_free (bs
->old_val
);
2045 /* Stub for cleaning up our state if we error-out of a breakpoint command */
2047 cleanup_executing_breakpoints (void *ignore
)
2049 executing_breakpoint_commands
= 0;
2052 /* Execute all the commands associated with all the breakpoints at this
2053 location. Any of these commands could cause the process to proceed
2054 beyond this point, etc. We look out for such changes by checking
2055 the global "breakpoint_proceeded" after each command. */
2058 bpstat_do_actions (bpstat
*bsp
)
2061 struct cleanup
*old_chain
;
2063 /* Avoid endless recursion if a `source' command is contained
2065 if (executing_breakpoint_commands
)
2068 executing_breakpoint_commands
= 1;
2069 old_chain
= make_cleanup (cleanup_executing_breakpoints
, 0);
2072 /* Note that (as of this writing), our callers all appear to
2073 be passing us the address of global stop_bpstat. And, if
2074 our calls to execute_control_command cause the inferior to
2075 proceed, that global (and hence, *bsp) will change.
2077 We must be careful to not touch *bsp unless the inferior
2078 has not proceeded. */
2080 /* This pointer will iterate over the list of bpstat's. */
2083 breakpoint_proceeded
= 0;
2084 for (; bs
!= NULL
; bs
= bs
->next
)
2086 struct command_line
*cmd
;
2087 struct cleanup
*this_cmd_tree_chain
;
2089 /* Take ownership of the BSP's command tree, if it has one.
2091 The command tree could legitimately contain commands like
2092 'step' and 'next', which call clear_proceed_status, which
2093 frees stop_bpstat's command tree. To make sure this doesn't
2094 free the tree we're executing out from under us, we need to
2095 take ownership of the tree ourselves. Since a given bpstat's
2096 commands are only executed once, we don't need to copy it; we
2097 can clear the pointer in the bpstat, and make sure we free
2098 the tree when we're done. */
2101 this_cmd_tree_chain
= make_cleanup_free_command_lines (&cmd
);
2105 execute_control_command (cmd
);
2107 if (breakpoint_proceeded
)
2113 /* We can free this command tree now. */
2114 do_cleanups (this_cmd_tree_chain
);
2116 if (breakpoint_proceeded
)
2117 /* The inferior is proceeded by the command; bomb out now.
2118 The bpstat chain has been blown away by wait_for_inferior.
2119 But since execution has stopped again, there is a new bpstat
2120 to look at, so start over. */
2123 do_cleanups (old_chain
);
2126 /* Print out the (old or new) value associated with a watchpoint. */
2129 watchpoint_value_print (struct value
*val
, struct ui_file
*stream
)
2132 fprintf_unfiltered (stream
, _("<unreadable>"));
2134 value_print (val
, stream
, 0, Val_pretty_default
);
2137 /* This is the normal print function for a bpstat. In the future,
2138 much of this logic could (should?) be moved to bpstat_stop_status,
2139 by having it set different print_it values.
2141 Current scheme: When we stop, bpstat_print() is called. It loops
2142 through the bpstat list of things causing this stop, calling the
2143 print_bp_stop_message function on each one. The behavior of the
2144 print_bp_stop_message function depends on the print_it field of
2145 bpstat. If such field so indicates, call this function here.
2147 Return values from this routine (ultimately used by bpstat_print()
2148 and normal_stop() to decide what to do):
2149 PRINT_NOTHING: Means we already printed all we needed to print,
2150 don't print anything else.
2151 PRINT_SRC_ONLY: Means we printed something, and we do *not* desire
2152 that something to be followed by a location.
2153 PRINT_SCR_AND_LOC: Means we printed something, and we *do* desire
2154 that something to be followed by a location.
2155 PRINT_UNKNOWN: Means we printed nothing or we need to do some more
2158 static enum print_stop_action
2159 print_it_typical (bpstat bs
)
2161 struct cleanup
*old_chain
, *ui_out_chain
;
2162 struct breakpoint
*b
;
2163 const struct bp_location
*bl
;
2164 struct ui_stream
*stb
;
2165 stb
= ui_out_stream_new (uiout
);
2166 old_chain
= make_cleanup_ui_out_stream_delete (stb
);
2167 /* bs->breakpoint_at can be NULL if it was a momentary breakpoint
2168 which has since been deleted. */
2169 if (bs
->breakpoint_at
== NULL
)
2170 return PRINT_UNKNOWN
;
2171 bl
= bs
->breakpoint_at
;
2177 case bp_hardware_breakpoint
:
2178 if (bl
->address
!= bl
->requested_address
)
2179 breakpoint_adjustment_warning (bl
->requested_address
,
2182 annotate_breakpoint (b
->number
);
2183 ui_out_text (uiout
, "\nBreakpoint ");
2184 if (ui_out_is_mi_like_p (uiout
))
2185 ui_out_field_string (uiout
, "reason",
2186 async_reason_lookup (EXEC_ASYNC_BREAKPOINT_HIT
));
2187 ui_out_field_int (uiout
, "bkptno", b
->number
);
2188 ui_out_text (uiout
, ", ");
2189 return PRINT_SRC_AND_LOC
;
2192 case bp_shlib_event
:
2193 /* Did we stop because the user set the stop_on_solib_events
2194 variable? (If so, we report this as a generic, "Stopped due
2195 to shlib event" message.) */
2196 printf_filtered (_("Stopped due to shared library event\n"));
2197 return PRINT_NOTHING
;
2200 case bp_thread_event
:
2201 /* Not sure how we will get here.
2202 GDB should not stop for these breakpoints. */
2203 printf_filtered (_("Thread Event Breakpoint: gdb should not stop!\n"));
2204 return PRINT_NOTHING
;
2207 case bp_overlay_event
:
2208 /* By analogy with the thread event, GDB should not stop for these. */
2209 printf_filtered (_("Overlay Event Breakpoint: gdb should not stop!\n"));
2210 return PRINT_NOTHING
;
2214 annotate_catchpoint (b
->number
);
2215 printf_filtered (_("\nCatchpoint %d (loaded %s), "),
2217 b
->triggered_dll_pathname
);
2218 return PRINT_SRC_AND_LOC
;
2221 case bp_catch_unload
:
2222 annotate_catchpoint (b
->number
);
2223 printf_filtered (_("\nCatchpoint %d (unloaded %s), "),
2225 b
->triggered_dll_pathname
);
2226 return PRINT_SRC_AND_LOC
;
2230 annotate_catchpoint (b
->number
);
2231 printf_filtered (_("\nCatchpoint %d (forked process %d), "),
2233 b
->forked_inferior_pid
);
2234 return PRINT_SRC_AND_LOC
;
2237 case bp_catch_vfork
:
2238 annotate_catchpoint (b
->number
);
2239 printf_filtered (_("\nCatchpoint %d (vforked process %d), "),
2241 b
->forked_inferior_pid
);
2242 return PRINT_SRC_AND_LOC
;
2246 annotate_catchpoint (b
->number
);
2247 printf_filtered (_("\nCatchpoint %d (exec'd %s), "),
2250 return PRINT_SRC_AND_LOC
;
2254 case bp_hardware_watchpoint
:
2255 annotate_watchpoint (b
->number
);
2256 if (ui_out_is_mi_like_p (uiout
))
2259 async_reason_lookup (EXEC_ASYNC_WATCHPOINT_TRIGGER
));
2261 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "value");
2262 ui_out_text (uiout
, "\nOld value = ");
2263 watchpoint_value_print (bs
->old_val
, stb
->stream
);
2264 ui_out_field_stream (uiout
, "old", stb
);
2265 ui_out_text (uiout
, "\nNew value = ");
2266 watchpoint_value_print (b
->val
, stb
->stream
);
2267 ui_out_field_stream (uiout
, "new", stb
);
2268 do_cleanups (ui_out_chain
);
2269 ui_out_text (uiout
, "\n");
2270 /* More than one watchpoint may have been triggered. */
2271 return PRINT_UNKNOWN
;
2274 case bp_read_watchpoint
:
2275 if (ui_out_is_mi_like_p (uiout
))
2278 async_reason_lookup (EXEC_ASYNC_READ_WATCHPOINT_TRIGGER
));
2280 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "value");
2281 ui_out_text (uiout
, "\nValue = ");
2282 watchpoint_value_print (b
->val
, stb
->stream
);
2283 ui_out_field_stream (uiout
, "value", stb
);
2284 do_cleanups (ui_out_chain
);
2285 ui_out_text (uiout
, "\n");
2286 return PRINT_UNKNOWN
;
2289 case bp_access_watchpoint
:
2290 if (bs
->old_val
!= NULL
)
2292 annotate_watchpoint (b
->number
);
2293 if (ui_out_is_mi_like_p (uiout
))
2296 async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER
));
2298 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "value");
2299 ui_out_text (uiout
, "\nOld value = ");
2300 watchpoint_value_print (bs
->old_val
, stb
->stream
);
2301 ui_out_field_stream (uiout
, "old", stb
);
2302 ui_out_text (uiout
, "\nNew value = ");
2307 if (ui_out_is_mi_like_p (uiout
))
2310 async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER
));
2311 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "value");
2312 ui_out_text (uiout
, "\nValue = ");
2314 watchpoint_value_print (b
->val
, stb
->stream
);
2315 ui_out_field_stream (uiout
, "new", stb
);
2316 do_cleanups (ui_out_chain
);
2317 ui_out_text (uiout
, "\n");
2318 return PRINT_UNKNOWN
;
2321 /* Fall through, we don't deal with these types of breakpoints
2325 if (ui_out_is_mi_like_p (uiout
))
2328 async_reason_lookup (EXEC_ASYNC_FUNCTION_FINISHED
));
2329 return PRINT_UNKNOWN
;
2333 if (ui_out_is_mi_like_p (uiout
))
2336 async_reason_lookup (EXEC_ASYNC_LOCATION_REACHED
));
2337 return PRINT_UNKNOWN
;
2342 case bp_longjmp_resume
:
2343 case bp_step_resume
:
2344 case bp_watchpoint_scope
:
2347 return PRINT_UNKNOWN
;
2351 /* Generic routine for printing messages indicating why we
2352 stopped. The behavior of this function depends on the value
2353 'print_it' in the bpstat structure. Under some circumstances we
2354 may decide not to print anything here and delegate the task to
2357 static enum print_stop_action
2358 print_bp_stop_message (bpstat bs
)
2360 switch (bs
->print_it
)
2363 /* Nothing should be printed for this bpstat entry. */
2364 return PRINT_UNKNOWN
;
2368 /* We still want to print the frame, but we already printed the
2369 relevant messages. */
2370 return PRINT_SRC_AND_LOC
;
2373 case print_it_normal
:
2375 const struct bp_location
*bl
= bs
->breakpoint_at
;
2376 struct breakpoint
*b
= bl
? bl
->owner
: NULL
;
2378 /* Normal case. Call the breakpoint's print_it method, or
2379 print_it_typical. */
2380 /* FIXME: how breakpoint can ever be NULL here? */
2381 if (b
!= NULL
&& b
->ops
!= NULL
&& b
->ops
->print_it
!= NULL
)
2382 return b
->ops
->print_it (b
);
2384 return print_it_typical (bs
);
2389 internal_error (__FILE__
, __LINE__
,
2390 _("print_bp_stop_message: unrecognized enum value"));
2395 /* Print a message indicating what happened. This is called from
2396 normal_stop(). The input to this routine is the head of the bpstat
2397 list - a list of the eventpoints that caused this stop. This
2398 routine calls the generic print routine for printing a message
2399 about reasons for stopping. This will print (for example) the
2400 "Breakpoint n," part of the output. The return value of this
2403 PRINT_UNKNOWN: Means we printed nothing
2404 PRINT_SRC_AND_LOC: Means we printed something, and expect subsequent
2405 code to print the location. An example is
2406 "Breakpoint 1, " which should be followed by
2408 PRINT_SRC_ONLY: Means we printed something, but there is no need
2409 to also print the location part of the message.
2410 An example is the catch/throw messages, which
2411 don't require a location appended to the end.
2412 PRINT_NOTHING: We have done some printing and we don't need any
2413 further info to be printed.*/
2415 enum print_stop_action
2416 bpstat_print (bpstat bs
)
2420 /* Maybe another breakpoint in the chain caused us to stop.
2421 (Currently all watchpoints go on the bpstat whether hit or not.
2422 That probably could (should) be changed, provided care is taken
2423 with respect to bpstat_explains_signal). */
2424 for (; bs
; bs
= bs
->next
)
2426 val
= print_bp_stop_message (bs
);
2427 if (val
== PRINT_SRC_ONLY
2428 || val
== PRINT_SRC_AND_LOC
2429 || val
== PRINT_NOTHING
)
2433 /* We reached the end of the chain, or we got a null BS to start
2434 with and nothing was printed. */
2435 return PRINT_UNKNOWN
;
2438 /* Evaluate the expression EXP and return 1 if value is zero.
2439 This is used inside a catch_errors to evaluate the breakpoint condition.
2440 The argument is a "struct expression *" that has been cast to char * to
2441 make it pass through catch_errors. */
2444 breakpoint_cond_eval (void *exp
)
2446 struct value
*mark
= value_mark ();
2447 int i
= !value_true (evaluate_expression ((struct expression
*) exp
));
2448 value_free_to_mark (mark
);
2452 /* Allocate a new bpstat and chain it to the current one. */
2455 bpstat_alloc (const struct bp_location
*bl
, bpstat cbs
/* Current "bs" value */ )
2459 bs
= (bpstat
) xmalloc (sizeof (*bs
));
2461 bs
->breakpoint_at
= bl
;
2462 /* If the condition is false, etc., don't do the commands. */
2463 bs
->commands
= NULL
;
2465 bs
->print_it
= print_it_normal
;
2469 /* The target has stopped with waitstatus WS. Check if any hardware
2470 watchpoints have triggered, according to the target. */
2473 watchpoints_triggered (struct target_waitstatus
*ws
)
2475 int stopped_by_watchpoint
= STOPPED_BY_WATCHPOINT (*ws
);
2477 struct breakpoint
*b
;
2479 if (!stopped_by_watchpoint
)
2481 /* We were not stopped by a watchpoint. Mark all watchpoints
2482 as not triggered. */
2484 if (b
->type
== bp_hardware_watchpoint
2485 || b
->type
== bp_read_watchpoint
2486 || b
->type
== bp_access_watchpoint
)
2487 b
->watchpoint_triggered
= watch_triggered_no
;
2492 if (!target_stopped_data_address (¤t_target
, &addr
))
2494 /* We were stopped by a watchpoint, but we don't know where.
2495 Mark all watchpoints as unknown. */
2497 if (b
->type
== bp_hardware_watchpoint
2498 || b
->type
== bp_read_watchpoint
2499 || b
->type
== bp_access_watchpoint
)
2500 b
->watchpoint_triggered
= watch_triggered_unknown
;
2502 return stopped_by_watchpoint
;
2505 /* The target could report the data address. Mark watchpoints
2506 affected by this data address as triggered, and all others as not
2510 if (b
->type
== bp_hardware_watchpoint
2511 || b
->type
== bp_read_watchpoint
2512 || b
->type
== bp_access_watchpoint
)
2514 struct bp_location
*loc
;
2517 b
->watchpoint_triggered
= watch_triggered_no
;
2518 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
2519 /* Exact match not required. Within range is
2521 if (addr
>= loc
->address
2522 && addr
< loc
->address
+ loc
->length
)
2524 b
->watchpoint_triggered
= watch_triggered_yes
;
2532 /* Possible return values for watchpoint_check (this can't be an enum
2533 because of check_errors). */
2534 /* The watchpoint has been deleted. */
2535 #define WP_DELETED 1
2536 /* The value has changed. */
2537 #define WP_VALUE_CHANGED 2
2538 /* The value has not changed. */
2539 #define WP_VALUE_NOT_CHANGED 3
2541 #define BP_TEMPFLAG 1
2542 #define BP_HARDWAREFLAG 2
2544 /* Check watchpoint condition. */
2547 watchpoint_check (void *p
)
2549 bpstat bs
= (bpstat
) p
;
2550 struct breakpoint
*b
;
2551 struct frame_info
*fr
;
2552 int within_current_scope
;
2554 b
= bs
->breakpoint_at
->owner
;
2556 if (b
->exp_valid_block
== NULL
)
2557 within_current_scope
= 1;
2560 /* There is no current frame at this moment. If we're going to have
2561 any chance of handling watchpoints on local variables, we'll need
2562 the frame chain (so we can determine if we're in scope). */
2563 reinit_frame_cache ();
2564 fr
= frame_find_by_id (b
->watchpoint_frame
);
2565 within_current_scope
= (fr
!= NULL
);
2567 /* If we've gotten confused in the unwinder, we might have
2568 returned a frame that can't describe this variable. */
2569 if (within_current_scope
2570 && block_function (b
->exp_valid_block
) != get_frame_function (fr
))
2571 within_current_scope
= 0;
2573 /* in_function_epilogue_p() returns a non-zero value if we're still
2574 in the function but the stack frame has already been invalidated.
2575 Since we can't rely on the values of local variables after the
2576 stack has been destroyed, we are treating the watchpoint in that
2577 state as `not changed' without further checking.
2579 vinschen/2003-09-04: The former implementation left out the case
2580 that the watchpoint frame couldn't be found by frame_find_by_id()
2581 because the current PC is currently in an epilogue. Calling
2582 gdbarch_in_function_epilogue_p() also when fr == NULL fixes that. */
2583 if ((!within_current_scope
|| fr
== get_current_frame ())
2584 && gdbarch_in_function_epilogue_p (current_gdbarch
, read_pc ()))
2585 return WP_VALUE_NOT_CHANGED
;
2586 if (fr
&& within_current_scope
)
2587 /* If we end up stopping, the current frame will get selected
2588 in normal_stop. So this call to select_frame won't affect
2593 if (within_current_scope
)
2595 /* We use value_{,free_to_}mark because it could be a
2596 *long* time before we return to the command level and
2597 call free_all_values. We can't call free_all_values because
2598 we might be in the middle of evaluating a function call. */
2600 struct value
*mark
= value_mark ();
2601 struct value
*new_val
;
2603 fetch_watchpoint_value (b
->exp
, &new_val
, NULL
, NULL
);
2604 if ((b
->val
!= NULL
) != (new_val
!= NULL
)
2605 || (b
->val
!= NULL
&& !value_equal (b
->val
, new_val
)))
2607 if (new_val
!= NULL
)
2609 release_value (new_val
);
2610 value_free_to_mark (mark
);
2612 bs
->old_val
= b
->val
;
2615 /* We will stop here */
2616 return WP_VALUE_CHANGED
;
2620 /* Nothing changed, don't do anything. */
2621 value_free_to_mark (mark
);
2622 /* We won't stop here */
2623 return WP_VALUE_NOT_CHANGED
;
2628 /* This seems like the only logical thing to do because
2629 if we temporarily ignored the watchpoint, then when
2630 we reenter the block in which it is valid it contains
2631 garbage (in the case of a function, it may have two
2632 garbage values, one before and one after the prologue).
2633 So we can't even detect the first assignment to it and
2634 watch after that (since the garbage may or may not equal
2635 the first value assigned). */
2636 /* We print all the stop information in print_it_typical(), but
2637 in this case, by the time we call print_it_typical() this bp
2638 will be deleted already. So we have no choice but print the
2639 information here. */
2640 if (ui_out_is_mi_like_p (uiout
))
2642 (uiout
, "reason", async_reason_lookup (EXEC_ASYNC_WATCHPOINT_SCOPE
));
2643 ui_out_text (uiout
, "\nWatchpoint ");
2644 ui_out_field_int (uiout
, "wpnum", b
->number
);
2645 ui_out_text (uiout
, " deleted because the program has left the block in\n\
2646 which its expression is valid.\n");
2648 if (b
->related_breakpoint
)
2649 b
->related_breakpoint
->disposition
= disp_del_at_next_stop
;
2650 b
->disposition
= disp_del_at_next_stop
;
2656 /* Get a bpstat associated with having just stopped at address
2657 BP_ADDR in thread PTID.
2659 Determine whether we stopped at a breakpoint, etc, or whether we
2660 don't understand this stop. Result is a chain of bpstat's such that:
2662 if we don't understand the stop, the result is a null pointer.
2664 if we understand why we stopped, the result is not null.
2666 Each element of the chain refers to a particular breakpoint or
2667 watchpoint at which we have stopped. (We may have stopped for
2668 several reasons concurrently.)
2670 Each element of the chain has valid next, breakpoint_at,
2671 commands, FIXME??? fields. */
2674 bpstat_stop_status (CORE_ADDR bp_addr
, ptid_t ptid
)
2676 struct breakpoint
*b
= NULL
;
2677 const struct bp_location
*bl
;
2678 /* Root of the chain of bpstat's */
2679 struct bpstats root_bs
[1];
2680 /* Pointer to the last thing in the chain currently. */
2681 bpstat bs
= root_bs
;
2682 int thread_id
= pid_to_thread_id (ptid
);
2684 ALL_BP_LOCATIONS (bl
)
2688 if (!breakpoint_enabled (b
) && b
->enable_state
!= bp_permanent
)
2691 if (b
->type
!= bp_watchpoint
2692 && b
->type
!= bp_hardware_watchpoint
2693 && b
->type
!= bp_read_watchpoint
2694 && b
->type
!= bp_access_watchpoint
2695 && b
->type
!= bp_hardware_breakpoint
2696 && b
->type
!= bp_catch_fork
2697 && b
->type
!= bp_catch_vfork
2698 && b
->type
!= bp_catch_exec
) /* a non-watchpoint bp */
2700 if (bl
->address
!= bp_addr
) /* address doesn't match */
2702 if (overlay_debugging
/* unmapped overlay section */
2703 && section_is_overlay (bl
->section
)
2704 && !section_is_mapped (bl
->section
))
2708 /* Continuable hardware watchpoints are treated as non-existent if the
2709 reason we stopped wasn't a hardware watchpoint (we didn't stop on
2710 some data address). Otherwise gdb won't stop on a break instruction
2711 in the code (not from a breakpoint) when a hardware watchpoint has
2712 been defined. Also skip watchpoints which we know did not trigger
2713 (did not match the data address). */
2715 if ((b
->type
== bp_hardware_watchpoint
2716 || b
->type
== bp_read_watchpoint
2717 || b
->type
== bp_access_watchpoint
)
2718 && b
->watchpoint_triggered
== watch_triggered_no
)
2721 if (b
->type
== bp_hardware_breakpoint
)
2723 if (bl
->address
!= bp_addr
)
2725 if (overlay_debugging
/* unmapped overlay section */
2726 && section_is_overlay (bl
->section
)
2727 && !section_is_mapped (bl
->section
))
2731 /* Is this a catchpoint of a load or unload? If so, did we
2732 get a load or unload of the specified library? If not,
2734 if ((b
->type
== bp_catch_load
)
2735 #if defined(SOLIB_HAVE_LOAD_EVENT)
2736 && (!SOLIB_HAVE_LOAD_EVENT (PIDGET (inferior_ptid
))
2737 || ((b
->dll_pathname
!= NULL
)
2738 && (strcmp (b
->dll_pathname
,
2739 SOLIB_LOADED_LIBRARY_PATHNAME (
2740 PIDGET (inferior_ptid
)))
2746 if ((b
->type
== bp_catch_unload
)
2747 #if defined(SOLIB_HAVE_UNLOAD_EVENT)
2748 && (!SOLIB_HAVE_UNLOAD_EVENT (PIDGET (inferior_ptid
))
2749 || ((b
->dll_pathname
!= NULL
)
2750 && (strcmp (b
->dll_pathname
,
2751 SOLIB_UNLOADED_LIBRARY_PATHNAME (
2752 PIDGET (inferior_ptid
)))
2758 if ((b
->type
== bp_catch_fork
)
2759 && !inferior_has_forked (PIDGET (inferior_ptid
),
2760 &b
->forked_inferior_pid
))
2763 if ((b
->type
== bp_catch_vfork
)
2764 && !inferior_has_vforked (PIDGET (inferior_ptid
),
2765 &b
->forked_inferior_pid
))
2768 if ((b
->type
== bp_catch_exec
)
2769 && !inferior_has_execd (PIDGET (inferior_ptid
), &b
->exec_pathname
))
2772 /* For hardware watchpoints, we look only at the first location.
2773 The watchpoint_check function will work on entire expression,
2774 not the individual locations. For read watchopints, the
2775 watchpoints_triggered function have checked all locations
2778 if (b
->type
== bp_hardware_watchpoint
&& bl
!= b
->loc
)
2781 /* Come here if it's a watchpoint, or if the break address matches */
2783 bs
= bpstat_alloc (bl
, bs
); /* Alloc a bpstat to explain stop */
2785 /* Watchpoints may change this, if not found to have triggered. */
2789 if (b
->type
== bp_watchpoint
2790 || b
->type
== bp_read_watchpoint
2791 || b
->type
== bp_access_watchpoint
2792 || b
->type
== bp_hardware_watchpoint
)
2796 int must_check_value
= 0;
2798 if (b
->type
== bp_watchpoint
)
2799 /* For a software watchpoint, we must always check the
2801 must_check_value
= 1;
2802 else if (b
->watchpoint_triggered
== watch_triggered_yes
)
2803 /* We have a hardware watchpoint (read, write, or access)
2804 and the target earlier reported an address watched by
2806 must_check_value
= 1;
2807 else if (b
->watchpoint_triggered
== watch_triggered_unknown
2808 && b
->type
== bp_hardware_watchpoint
)
2809 /* We were stopped by a hardware watchpoint, but the target could
2810 not report the data address. We must check the watchpoint's
2811 value. Access and read watchpoints are out of luck; without
2812 a data address, we can't figure it out. */
2813 must_check_value
= 1;
2815 if (must_check_value
)
2817 char *message
= xstrprintf ("Error evaluating expression for watchpoint %d\n",
2819 struct cleanup
*cleanups
= make_cleanup (xfree
, message
);
2820 int e
= catch_errors (watchpoint_check
, bs
, message
,
2822 do_cleanups (cleanups
);
2826 /* We've already printed what needs to be printed. */
2827 bs
->print_it
= print_it_done
;
2830 case WP_VALUE_CHANGED
:
2831 if (b
->type
== bp_read_watchpoint
)
2833 /* Don't stop: read watchpoints shouldn't fire if
2834 the value has changed. This is for targets
2835 which cannot set read-only watchpoints. */
2836 bs
->print_it
= print_it_noop
;
2842 case WP_VALUE_NOT_CHANGED
:
2843 if (b
->type
== bp_hardware_watchpoint
2844 || b
->type
== bp_watchpoint
)
2846 /* Don't stop: write watchpoints shouldn't fire if
2847 the value hasn't changed. */
2848 bs
->print_it
= print_it_noop
;
2858 /* Error from catch_errors. */
2859 printf_filtered (_("Watchpoint %d deleted.\n"), b
->number
);
2860 if (b
->related_breakpoint
)
2861 b
->related_breakpoint
->disposition
= disp_del_at_next_stop
;
2862 b
->disposition
= disp_del_at_next_stop
;
2863 /* We've already printed what needs to be printed. */
2864 bs
->print_it
= print_it_done
;
2868 else /* must_check_value == 0 */
2870 /* This is a case where some watchpoint(s) triggered, but
2871 not at the address of this watchpoint, or else no
2872 watchpoint triggered after all. So don't print
2873 anything for this watchpoint. */
2874 bs
->print_it
= print_it_noop
;
2881 /* By definition, an encountered breakpoint is a triggered
2886 if (frame_id_p (b
->frame_id
)
2887 && !frame_id_eq (b
->frame_id
, get_frame_id (get_current_frame ())))
2891 int value_is_zero
= 0;
2893 /* If this is a scope breakpoint, mark the associated
2894 watchpoint as triggered so that we will handle the
2895 out-of-scope event. We'll get to the watchpoint next
2897 if (b
->type
== bp_watchpoint_scope
)
2898 b
->related_breakpoint
->watchpoint_triggered
= watch_triggered_yes
;
2900 if (bl
->cond
&& bl
->owner
->disposition
!= disp_del_at_next_stop
)
2902 /* Need to select the frame, with all that implies
2903 so that the conditions will have the right context. */
2904 select_frame (get_current_frame ());
2906 = catch_errors (breakpoint_cond_eval
, (bl
->cond
),
2907 "Error in testing breakpoint condition:\n",
2909 /* FIXME-someday, should give breakpoint # */
2912 if (bl
->cond
&& value_is_zero
)
2915 /* Don't consider this a hit. */
2918 else if (b
->thread
!= -1 && b
->thread
!= thread_id
)
2921 /* Don't consider this a hit. */
2924 else if (b
->ignore_count
> 0)
2927 annotate_ignore_count_change ();
2930 else if (b
->type
== bp_thread_event
|| b
->type
== bp_overlay_event
)
2931 /* We do not stop for these. */
2935 /* We will stop here */
2936 if (b
->disposition
== disp_disable
)
2937 b
->enable_state
= bp_disabled
;
2940 bs
->commands
= b
->commands
;
2942 (strcmp ("silent", bs
->commands
->line
) == 0
2943 || (xdb_commands
&& strcmp ("Q", bs
->commands
->line
) == 0)))
2945 bs
->commands
= bs
->commands
->next
;
2948 bs
->commands
= copy_command_lines (bs
->commands
);
2951 /* Print nothing for this entry if we dont stop or if we dont print. */
2952 if (bs
->stop
== 0 || bs
->print
== 0)
2953 bs
->print_it
= print_it_noop
;
2956 bs
->next
= NULL
; /* Terminate the chain */
2957 bs
= root_bs
->next
; /* Re-grab the head of the chain */
2959 /* If we aren't stopping, the value of some hardware watchpoint may
2960 not have changed, but the intermediate memory locations we are
2961 watching may have. Don't bother if we're stopping; this will get
2963 for (bs
= root_bs
->next
; bs
!= NULL
; bs
= bs
->next
)
2968 for (bs
= root_bs
->next
; bs
!= NULL
; bs
= bs
->next
)
2970 && (bs
->breakpoint_at
->owner
->type
== bp_hardware_watchpoint
2971 || bs
->breakpoint_at
->owner
->type
== bp_read_watchpoint
2972 || bs
->breakpoint_at
->owner
->type
== bp_access_watchpoint
))
2974 /* remove/insert can invalidate bs->breakpoint_at, if this
2975 location is no longer used by the watchpoint. Prevent
2976 further code from trying to use it. */
2977 bs
->breakpoint_at
= NULL
;
2978 remove_breakpoints ();
2979 insert_breakpoints ();
2983 return root_bs
->next
;
2986 /* Tell what to do about this bpstat. */
2988 bpstat_what (bpstat bs
)
2990 /* Classify each bpstat as one of the following. */
2993 /* This bpstat element has no effect on the main_action. */
2996 /* There was a watchpoint, stop but don't print. */
2999 /* There was a watchpoint, stop and print. */
3002 /* There was a breakpoint but we're not stopping. */
3005 /* There was a breakpoint, stop but don't print. */
3008 /* There was a breakpoint, stop and print. */
3011 /* We hit the longjmp breakpoint. */
3014 /* We hit the longjmp_resume breakpoint. */
3017 /* We hit the step_resume breakpoint. */
3020 /* We hit the shared library event breakpoint. */
3023 /* We caught a shared library event. */
3026 /* This is just used to count how many enums there are. */
3030 /* Here is the table which drives this routine. So that we can
3031 format it pretty, we define some abbreviations for the
3032 enum bpstat_what codes. */
3033 #define kc BPSTAT_WHAT_KEEP_CHECKING
3034 #define ss BPSTAT_WHAT_STOP_SILENT
3035 #define sn BPSTAT_WHAT_STOP_NOISY
3036 #define sgl BPSTAT_WHAT_SINGLE
3037 #define slr BPSTAT_WHAT_SET_LONGJMP_RESUME
3038 #define clr BPSTAT_WHAT_CLEAR_LONGJMP_RESUME
3039 #define clrs BPSTAT_WHAT_CLEAR_LONGJMP_RESUME_SINGLE
3040 #define sr BPSTAT_WHAT_STEP_RESUME
3041 #define shl BPSTAT_WHAT_CHECK_SHLIBS
3042 #define shlr BPSTAT_WHAT_CHECK_SHLIBS_RESUME_FROM_HOOK
3044 /* "Can't happen." Might want to print an error message.
3045 abort() is not out of the question, but chances are GDB is just
3046 a bit confused, not unusable. */
3047 #define err BPSTAT_WHAT_STOP_NOISY
3049 /* Given an old action and a class, come up with a new action. */
3050 /* One interesting property of this table is that wp_silent is the same
3051 as bp_silent and wp_noisy is the same as bp_noisy. That is because
3052 after stopping, the check for whether to step over a breakpoint
3053 (BPSTAT_WHAT_SINGLE type stuff) is handled in proceed() without
3054 reference to how we stopped. We retain separate wp_silent and
3055 bp_silent codes in case we want to change that someday.
3057 Another possibly interesting property of this table is that
3058 there's a partial ordering, priority-like, of the actions. Once
3059 you've decided that some action is appropriate, you'll never go
3060 back and decide something of a lower priority is better. The
3063 kc < clr sgl shl shlr slr sn sr ss
3064 sgl < clrs shl shlr slr sn sr ss
3065 slr < err shl shlr sn sr ss
3066 clr < clrs err shl shlr sn sr ss
3067 clrs < err shl shlr sn sr ss
3074 What I think this means is that we don't need a damned table
3075 here. If you just put the rows and columns in the right order,
3076 it'd look awfully regular. We could simply walk the bpstat list
3077 and choose the highest priority action we find, with a little
3078 logic to handle the 'err' cases, and the CLEAR_LONGJMP_RESUME/
3079 CLEAR_LONGJMP_RESUME_SINGLE distinction (which breakpoint.h says
3080 is messy anyway). */
3082 /* step_resume entries: a step resume breakpoint overrides another
3083 breakpoint of signal handling (see comment in wait_for_inferior
3084 at where we set the step_resume breakpoint). */
3086 static const enum bpstat_what_main_action
3087 table
[(int) class_last
][(int) BPSTAT_WHAT_LAST
] =
3090 /* kc ss sn sgl slr clr clrs sr shl shlr
3093 {kc
, ss
, sn
, sgl
, slr
, clr
, clrs
, sr
, shl
, shlr
},
3095 {ss
, ss
, sn
, ss
, ss
, ss
, ss
, sr
, shl
, shlr
},
3097 {sn
, sn
, sn
, sn
, sn
, sn
, sn
, sr
, shl
, shlr
},
3099 {sgl
, ss
, sn
, sgl
, slr
, clrs
, clrs
, sr
, shl
, shlr
},
3101 {ss
, ss
, sn
, ss
, ss
, ss
, ss
, sr
, shl
, shlr
},
3103 {sn
, sn
, sn
, sn
, sn
, sn
, sn
, sr
, shl
, shlr
},
3105 {slr
, ss
, sn
, slr
, slr
, err
, err
, sr
, shl
, shlr
},
3107 {clr
, ss
, sn
, clrs
, err
, err
, err
, sr
, shl
, shlr
},
3109 {sr
, sr
, sr
, sr
, sr
, sr
, sr
, sr
, sr
, sr
},
3111 {shl
, shl
, shl
, shl
, shl
, shl
, shl
, sr
, shl
, shlr
},
3113 {shlr
, shlr
, shlr
, shlr
, shlr
, shlr
, shlr
, sr
, shlr
, shlr
}
3128 enum bpstat_what_main_action current_action
= BPSTAT_WHAT_KEEP_CHECKING
;
3129 struct bpstat_what retval
;
3131 retval
.call_dummy
= 0;
3132 for (; bs
!= NULL
; bs
= bs
->next
)
3134 enum class bs_class
= no_effect
;
3135 if (bs
->breakpoint_at
== NULL
)
3136 /* I suspect this can happen if it was a momentary breakpoint
3137 which has since been deleted. */
3139 switch (bs
->breakpoint_at
->owner
->type
)
3145 case bp_hardware_breakpoint
:
3151 bs_class
= bp_noisy
;
3153 bs_class
= bp_silent
;
3156 bs_class
= bp_nostop
;
3159 case bp_hardware_watchpoint
:
3160 case bp_read_watchpoint
:
3161 case bp_access_watchpoint
:
3165 bs_class
= wp_noisy
;
3167 bs_class
= wp_silent
;
3170 /* There was a watchpoint, but we're not stopping.
3171 This requires no further action. */
3172 bs_class
= no_effect
;
3175 bs_class
= long_jump
;
3177 case bp_longjmp_resume
:
3178 bs_class
= long_resume
;
3180 case bp_step_resume
:
3183 bs_class
= step_resume
;
3186 /* It is for the wrong frame. */
3187 bs_class
= bp_nostop
;
3189 case bp_watchpoint_scope
:
3190 bs_class
= bp_nostop
;
3192 case bp_shlib_event
:
3193 bs_class
= shlib_event
;
3195 case bp_thread_event
:
3196 case bp_overlay_event
:
3197 bs_class
= bp_nostop
;
3200 case bp_catch_unload
:
3201 /* Only if this catchpoint triggered should we cause the
3202 step-out-of-dld behaviour. Otherwise, we ignore this
3205 bs_class
= catch_shlib_event
;
3207 bs_class
= no_effect
;
3210 case bp_catch_vfork
:
3215 bs_class
= bp_noisy
;
3217 bs_class
= bp_silent
;
3220 /* There was a catchpoint, but we're not stopping.
3221 This requires no further action. */
3222 bs_class
= no_effect
;
3225 /* Make sure the action is stop (silent or noisy),
3226 so infrun.c pops the dummy frame. */
3227 bs_class
= bp_silent
;
3228 retval
.call_dummy
= 1;
3231 current_action
= table
[(int) bs_class
][(int) current_action
];
3233 retval
.main_action
= current_action
;
3237 /* Nonzero if we should step constantly (e.g. watchpoints on machines
3238 without hardware support). This isn't related to a specific bpstat,
3239 just to things like whether watchpoints are set. */
3242 bpstat_should_step (void)
3244 struct breakpoint
*b
;
3246 if (breakpoint_enabled (b
) && b
->type
== bp_watchpoint
)
3253 /* Given a bpstat that records zero or more triggered eventpoints, this
3254 function returns another bpstat which contains only the catchpoints
3255 on that first list, if any. */
3257 bpstat_get_triggered_catchpoints (bpstat ep_list
, bpstat
*cp_list
)
3259 struct bpstats root_bs
[1];
3260 bpstat bs
= root_bs
;
3261 struct breakpoint
*ep
;
3264 bpstat_clear (cp_list
);
3265 root_bs
->next
= NULL
;
3267 for (; ep_list
!= NULL
; ep_list
= ep_list
->next
)
3269 /* Is this eventpoint a catchpoint? If not, ignore it. */
3270 ep
= ep_list
->breakpoint_at
->owner
;
3273 if ((ep
->type
!= bp_catch_load
) &&
3274 (ep
->type
!= bp_catch_unload
))
3275 /* pai: (temp) ADD fork/vfork here!! */
3278 /* Yes; add it to the list. */
3279 bs
= bpstat_alloc (ep_list
->breakpoint_at
, bs
);
3284 #if defined(SOLIB_ADD)
3285 /* Also, for each triggered catchpoint, tag it with the name of
3286 the library that caused this trigger. (We copy the name now,
3287 because it's only guaranteed to be available NOW, when the
3288 catchpoint triggers. Clients who may wish to know the name
3289 later must get it from the catchpoint itself.) */
3290 if (ep
->triggered_dll_pathname
!= NULL
)
3291 xfree (ep
->triggered_dll_pathname
);
3292 if (ep
->type
== bp_catch_load
)
3293 dll_pathname
= SOLIB_LOADED_LIBRARY_PATHNAME (
3294 PIDGET (inferior_ptid
));
3296 dll_pathname
= SOLIB_UNLOADED_LIBRARY_PATHNAME (
3297 PIDGET (inferior_ptid
));
3299 dll_pathname
= NULL
;
3303 ep
->triggered_dll_pathname
= (char *)
3304 xmalloc (strlen (dll_pathname
) + 1);
3305 strcpy (ep
->triggered_dll_pathname
, dll_pathname
);
3308 ep
->triggered_dll_pathname
= NULL
;
3314 static void print_breakpoint_location (struct breakpoint
*b
,
3315 struct bp_location
*loc
,
3317 struct ui_stream
*stb
)
3322 = find_pc_sect_function (loc
->address
, loc
->section
);
3325 ui_out_text (uiout
, "in ");
3326 ui_out_field_string (uiout
, "func",
3327 SYMBOL_PRINT_NAME (sym
));
3328 ui_out_wrap_hint (uiout
, wrap_indent
);
3329 ui_out_text (uiout
, " at ");
3331 ui_out_field_string (uiout
, "file", b
->source_file
);
3332 ui_out_text (uiout
, ":");
3334 if (ui_out_is_mi_like_p (uiout
))
3336 struct symtab_and_line sal
= find_pc_line (loc
->address
, 0);
3337 char *fullname
= symtab_to_fullname (sal
.symtab
);
3340 ui_out_field_string (uiout
, "fullname", fullname
);
3343 ui_out_field_int (uiout
, "line", b
->line_number
);
3347 ui_out_field_string (uiout
, "pending", b
->addr_string
);
3351 print_address_symbolic (loc
->address
, stb
->stream
, demangle
, "");
3352 ui_out_field_stream (uiout
, "at", stb
);
3356 /* Print B to gdb_stdout. */
3358 print_one_breakpoint_location (struct breakpoint
*b
,
3359 struct bp_location
*loc
,
3361 CORE_ADDR
*last_addr
)
3363 struct command_line
*l
;
3365 struct ep_type_description
3370 static struct ep_type_description bptypes
[] =
3372 {bp_none
, "?deleted?"},
3373 {bp_breakpoint
, "breakpoint"},
3374 {bp_hardware_breakpoint
, "hw breakpoint"},
3375 {bp_until
, "until"},
3376 {bp_finish
, "finish"},
3377 {bp_watchpoint
, "watchpoint"},
3378 {bp_hardware_watchpoint
, "hw watchpoint"},
3379 {bp_read_watchpoint
, "read watchpoint"},
3380 {bp_access_watchpoint
, "acc watchpoint"},
3381 {bp_longjmp
, "longjmp"},
3382 {bp_longjmp_resume
, "longjmp resume"},
3383 {bp_step_resume
, "step resume"},
3384 {bp_watchpoint_scope
, "watchpoint scope"},
3385 {bp_call_dummy
, "call dummy"},
3386 {bp_shlib_event
, "shlib events"},
3387 {bp_thread_event
, "thread events"},
3388 {bp_overlay_event
, "overlay events"},
3389 {bp_catch_load
, "catch load"},
3390 {bp_catch_unload
, "catch unload"},
3391 {bp_catch_fork
, "catch fork"},
3392 {bp_catch_vfork
, "catch vfork"},
3393 {bp_catch_exec
, "catch exec"}
3396 static char *bpdisps
[] =
3397 {"del", "dstp", "dis", "keep"};
3398 static char bpenables
[] = "nynny";
3399 char wrap_indent
[80];
3400 struct ui_stream
*stb
= ui_out_stream_new (uiout
);
3401 struct cleanup
*old_chain
= make_cleanup_ui_out_stream_delete (stb
);
3402 struct cleanup
*bkpt_chain
;
3404 int header_of_multiple
= 0;
3405 int part_of_multiple
= (loc
!= NULL
);
3407 gdb_assert (!loc
|| loc_number
!= 0);
3408 /* See comment in print_one_breakpoint concerning
3409 treatment of breakpoints with single disabled
3413 && (b
->loc
->next
!= NULL
|| !b
->loc
->enabled
)))
3414 header_of_multiple
= 1;
3419 bkpt_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "bkpt");
3423 if (part_of_multiple
)
3426 formatted
= xstrprintf ("%d.%d", b
->number
, loc_number
);
3427 ui_out_field_string (uiout
, "number", formatted
);
3432 ui_out_field_int (uiout
, "number", b
->number
);
3437 if (part_of_multiple
)
3438 ui_out_field_skip (uiout
, "type");
3441 if (((int) b
->type
>= (sizeof (bptypes
) / sizeof (bptypes
[0])))
3442 || ((int) b
->type
!= bptypes
[(int) b
->type
].type
))
3443 internal_error (__FILE__
, __LINE__
,
3444 _("bptypes table does not describe type #%d."),
3446 ui_out_field_string (uiout
, "type", bptypes
[(int) b
->type
].description
);
3451 if (part_of_multiple
)
3452 ui_out_field_skip (uiout
, "disp");
3454 ui_out_field_string (uiout
, "disp", bpdisps
[(int) b
->disposition
]);
3459 if (part_of_multiple
)
3460 ui_out_field_string (uiout
, "enabled", loc
->enabled
? "y" : "n");
3462 ui_out_field_fmt (uiout
, "enabled", "%c",
3463 bpenables
[(int) b
->enable_state
]);
3464 ui_out_spaces (uiout
, 2);
3468 strcpy (wrap_indent
, " ");
3471 if (gdbarch_addr_bit (current_gdbarch
) <= 32)
3472 strcat (wrap_indent
, " ");
3474 strcat (wrap_indent
, " ");
3477 if (b
->ops
!= NULL
&& b
->ops
->print_one
!= NULL
)
3479 /* Although the print_one can possibly print
3480 all locations, calling it here is not likely
3481 to get any nice result. So, make sure there's
3482 just one location. */
3483 gdb_assert (b
->loc
== NULL
|| b
->loc
->next
== NULL
);
3484 b
->ops
->print_one (b
, last_addr
);
3490 internal_error (__FILE__
, __LINE__
,
3491 _("print_one_breakpoint: bp_none encountered\n"));
3495 case bp_hardware_watchpoint
:
3496 case bp_read_watchpoint
:
3497 case bp_access_watchpoint
:
3498 /* Field 4, the address, is omitted (which makes the columns
3499 not line up too nicely with the headers, but the effect
3500 is relatively readable). */
3502 ui_out_field_skip (uiout
, "addr");
3504 print_expression (b
->exp
, stb
->stream
);
3505 ui_out_field_stream (uiout
, "what", stb
);
3509 case bp_catch_unload
:
3510 /* Field 4, the address, is omitted (which makes the columns
3511 not line up too nicely with the headers, but the effect
3512 is relatively readable). */
3514 ui_out_field_skip (uiout
, "addr");
3516 if (b
->dll_pathname
== NULL
)
3518 ui_out_field_string (uiout
, "what", "<any library>");
3519 ui_out_spaces (uiout
, 1);
3523 ui_out_text (uiout
, "library \"");
3524 ui_out_field_string (uiout
, "what", b
->dll_pathname
);
3525 ui_out_text (uiout
, "\" ");
3530 case bp_catch_vfork
:
3531 /* Field 4, the address, is omitted (which makes the columns
3532 not line up too nicely with the headers, but the effect
3533 is relatively readable). */
3535 ui_out_field_skip (uiout
, "addr");
3537 if (b
->forked_inferior_pid
!= 0)
3539 ui_out_text (uiout
, "process ");
3540 ui_out_field_int (uiout
, "what", b
->forked_inferior_pid
);
3541 ui_out_spaces (uiout
, 1);
3546 /* Field 4, the address, is omitted (which makes the columns
3547 not line up too nicely with the headers, but the effect
3548 is relatively readable). */
3550 ui_out_field_skip (uiout
, "addr");
3552 if (b
->exec_pathname
!= NULL
)
3554 ui_out_text (uiout
, "program \"");
3555 ui_out_field_string (uiout
, "what", b
->exec_pathname
);
3556 ui_out_text (uiout
, "\" ");
3561 case bp_hardware_breakpoint
:
3565 case bp_longjmp_resume
:
3566 case bp_step_resume
:
3567 case bp_watchpoint_scope
:
3569 case bp_shlib_event
:
3570 case bp_thread_event
:
3571 case bp_overlay_event
:
3575 if (header_of_multiple
)
3576 ui_out_field_string (uiout
, "addr", "<MULTIPLE>");
3577 if (b
->loc
== NULL
|| loc
->shlib_disabled
)
3578 ui_out_field_string (uiout
, "addr", "<PENDING>");
3580 ui_out_field_core_addr (uiout
, "addr", loc
->address
);
3583 if (!header_of_multiple
)
3584 print_breakpoint_location (b
, loc
, wrap_indent
, stb
);
3586 *last_addr
= b
->loc
->address
;
3590 if (!part_of_multiple
&& b
->thread
!= -1)
3592 /* FIXME: This seems to be redundant and lost here; see the
3593 "stop only in" line a little further down. */
3594 ui_out_text (uiout
, " thread ");
3595 ui_out_field_int (uiout
, "thread", b
->thread
);
3598 ui_out_text (uiout
, "\n");
3600 if (part_of_multiple
&& frame_id_p (b
->frame_id
))
3603 ui_out_text (uiout
, "\tstop only in stack frame at ");
3604 /* FIXME: cagney/2002-12-01: Shouldn't be poeking around inside
3606 ui_out_field_core_addr (uiout
, "frame", b
->frame_id
.stack_addr
);
3607 ui_out_text (uiout
, "\n");
3610 if (!part_of_multiple
&& b
->cond_string
&& !ada_exception_catchpoint_p (b
))
3612 /* We do not print the condition for Ada exception catchpoints
3613 because the condition is an internal implementation detail
3614 that we do not want to expose to the user. */
3616 ui_out_text (uiout
, "\tstop only if ");
3617 ui_out_field_string (uiout
, "cond", b
->cond_string
);
3618 ui_out_text (uiout
, "\n");
3621 if (!part_of_multiple
&& b
->thread
!= -1)
3623 /* FIXME should make an annotation for this */
3624 ui_out_text (uiout
, "\tstop only in thread ");
3625 ui_out_field_int (uiout
, "thread", b
->thread
);
3626 ui_out_text (uiout
, "\n");
3629 if (!part_of_multiple
&& show_breakpoint_hit_counts
&& b
->hit_count
)
3631 /* FIXME should make an annotation for this */
3632 if (ep_is_catchpoint (b
))
3633 ui_out_text (uiout
, "\tcatchpoint");
3635 ui_out_text (uiout
, "\tbreakpoint");
3636 ui_out_text (uiout
, " already hit ");
3637 ui_out_field_int (uiout
, "times", b
->hit_count
);
3638 if (b
->hit_count
== 1)
3639 ui_out_text (uiout
, " time\n");
3641 ui_out_text (uiout
, " times\n");
3644 /* Output the count also if it is zero, but only if this is
3645 mi. FIXME: Should have a better test for this. */
3646 if (ui_out_is_mi_like_p (uiout
))
3647 if (!part_of_multiple
&& show_breakpoint_hit_counts
&& b
->hit_count
== 0)
3648 ui_out_field_int (uiout
, "times", b
->hit_count
);
3650 if (!part_of_multiple
&& b
->ignore_count
)
3653 ui_out_text (uiout
, "\tignore next ");
3654 ui_out_field_int (uiout
, "ignore", b
->ignore_count
);
3655 ui_out_text (uiout
, " hits\n");
3658 if (!part_of_multiple
&& (l
= b
->commands
))
3660 struct cleanup
*script_chain
;
3663 script_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "script");
3664 print_command_lines (uiout
, l
, 4);
3665 do_cleanups (script_chain
);
3667 do_cleanups (bkpt_chain
);
3668 do_cleanups (old_chain
);
3672 print_one_breakpoint (struct breakpoint
*b
,
3673 CORE_ADDR
*last_addr
)
3675 print_one_breakpoint_location (b
, NULL
, 0, last_addr
);
3677 /* If this breakpoint has custom print function,
3678 it's already printed. Otherwise, print individual
3679 locations, if any. */
3680 if (b
->ops
== NULL
|| b
->ops
->print_one
== NULL
)
3682 /* If breakpoint has a single location that is
3683 disabled, we print it as if it had
3684 several locations, since otherwise it's hard to
3685 represent "breakpoint enabled, location disabled"
3687 Note that while hardware watchpoints have
3688 several locations internally, that's no a property
3691 && !is_hardware_watchpoint (b
)
3692 && (b
->loc
->next
|| !b
->loc
->enabled
)
3693 && !ui_out_is_mi_like_p (uiout
))
3695 struct bp_location
*loc
;
3697 for (loc
= b
->loc
; loc
; loc
= loc
->next
, ++n
)
3698 print_one_breakpoint_location (b
, loc
, n
, last_addr
);
3704 struct captured_breakpoint_query_args
3710 do_captured_breakpoint_query (struct ui_out
*uiout
, void *data
)
3712 struct captured_breakpoint_query_args
*args
= data
;
3713 struct breakpoint
*b
;
3714 CORE_ADDR dummy_addr
= 0;
3717 if (args
->bnum
== b
->number
)
3719 print_one_breakpoint (b
, &dummy_addr
);
3727 gdb_breakpoint_query (struct ui_out
*uiout
, int bnum
, char **error_message
)
3729 struct captured_breakpoint_query_args args
;
3731 /* For the moment we don't trust print_one_breakpoint() to not throw
3733 if (catch_exceptions_with_msg (uiout
, do_captured_breakpoint_query
, &args
,
3734 error_message
, RETURN_MASK_ALL
) < 0)
3740 /* Return non-zero if B is user settable (breakpoints, watchpoints,
3741 catchpoints, et.al.). */
3744 user_settable_breakpoint (const struct breakpoint
*b
)
3746 return (b
->type
== bp_breakpoint
3747 || b
->type
== bp_catch_load
3748 || b
->type
== bp_catch_unload
3749 || b
->type
== bp_catch_fork
3750 || b
->type
== bp_catch_vfork
3751 || b
->type
== bp_catch_exec
3752 || b
->type
== bp_hardware_breakpoint
3753 || b
->type
== bp_watchpoint
3754 || b
->type
== bp_read_watchpoint
3755 || b
->type
== bp_access_watchpoint
3756 || b
->type
== bp_hardware_watchpoint
);
3759 /* Print information on user settable breakpoint (watchpoint, etc)
3760 number BNUM. If BNUM is -1 print all user settable breakpoints.
3761 If ALLFLAG is non-zero, include non- user settable breakpoints. */
3764 breakpoint_1 (int bnum
, int allflag
)
3766 struct breakpoint
*b
;
3767 CORE_ADDR last_addr
= (CORE_ADDR
) -1;
3768 int nr_printable_breakpoints
;
3769 struct cleanup
*bkpttbl_chain
;
3771 /* Compute the number of rows in the table. */
3772 nr_printable_breakpoints
= 0;
3775 || bnum
== b
->number
)
3777 if (allflag
|| user_settable_breakpoint (b
))
3778 nr_printable_breakpoints
++;
3783 = make_cleanup_ui_out_table_begin_end (uiout
, 6, nr_printable_breakpoints
,
3787 = make_cleanup_ui_out_table_begin_end (uiout
, 5, nr_printable_breakpoints
,
3790 if (nr_printable_breakpoints
> 0)
3791 annotate_breakpoints_headers ();
3792 if (nr_printable_breakpoints
> 0)
3794 ui_out_table_header (uiout
, 7, ui_left
, "number", "Num"); /* 1 */
3795 if (nr_printable_breakpoints
> 0)
3797 ui_out_table_header (uiout
, 14, ui_left
, "type", "Type"); /* 2 */
3798 if (nr_printable_breakpoints
> 0)
3800 ui_out_table_header (uiout
, 4, ui_left
, "disp", "Disp"); /* 3 */
3801 if (nr_printable_breakpoints
> 0)
3803 ui_out_table_header (uiout
, 3, ui_left
, "enabled", "Enb"); /* 4 */
3806 if (nr_printable_breakpoints
> 0)
3808 if (gdbarch_addr_bit (current_gdbarch
) <= 32)
3809 ui_out_table_header (uiout
, 10, ui_left
, "addr", "Address");/* 5 */
3811 ui_out_table_header (uiout
, 18, ui_left
, "addr", "Address");/* 5 */
3813 if (nr_printable_breakpoints
> 0)
3815 ui_out_table_header (uiout
, 40, ui_noalign
, "what", "What"); /* 6 */
3816 ui_out_table_body (uiout
);
3817 if (nr_printable_breakpoints
> 0)
3818 annotate_breakpoints_table ();
3822 || bnum
== b
->number
)
3824 /* We only print out user settable breakpoints unless the
3826 if (allflag
|| user_settable_breakpoint (b
))
3827 print_one_breakpoint (b
, &last_addr
);
3830 do_cleanups (bkpttbl_chain
);
3832 if (nr_printable_breakpoints
== 0)
3835 ui_out_message (uiout
, 0, "No breakpoints or watchpoints.\n");
3837 ui_out_message (uiout
, 0, "No breakpoint or watchpoint number %d.\n",
3842 /* Compare against (CORE_ADDR)-1 in case some compiler decides
3843 that a comparison of an unsigned with -1 is always false. */
3844 if (last_addr
!= (CORE_ADDR
) -1 && !server_command
)
3845 set_next_address (last_addr
);
3848 /* FIXME? Should this be moved up so that it is only called when
3849 there have been breakpoints? */
3850 annotate_breakpoints_table_end ();
3854 breakpoints_info (char *bnum_exp
, int from_tty
)
3859 bnum
= parse_and_eval_long (bnum_exp
);
3861 breakpoint_1 (bnum
, 0);
3865 maintenance_info_breakpoints (char *bnum_exp
, int from_tty
)
3870 bnum
= parse_and_eval_long (bnum_exp
);
3872 breakpoint_1 (bnum
, 1);
3876 breakpoint_has_pc (struct breakpoint
*b
, CORE_ADDR pc
, asection
*section
)
3878 struct bp_location
*bl
= b
->loc
;
3879 for (; bl
; bl
= bl
->next
)
3881 if (bl
->address
== pc
3882 && (!overlay_debugging
|| bl
->section
== section
))
3888 /* Print a message describing any breakpoints set at PC. */
3891 describe_other_breakpoints (CORE_ADDR pc
, asection
*section
, int thread
)
3894 struct breakpoint
*b
;
3897 others
+= breakpoint_has_pc (b
, pc
, section
);
3901 printf_filtered (_("Note: breakpoint "));
3902 else /* if (others == ???) */
3903 printf_filtered (_("Note: breakpoints "));
3905 if (breakpoint_has_pc (b
, pc
, section
))
3908 printf_filtered ("%d", b
->number
);
3909 if (b
->thread
== -1 && thread
!= -1)
3910 printf_filtered (" (all threads)");
3911 else if (b
->thread
!= -1)
3912 printf_filtered (" (thread %d)", b
->thread
);
3913 printf_filtered ("%s%s ",
3914 ((b
->enable_state
== bp_disabled
||
3915 b
->enable_state
== bp_call_disabled
)
3917 : b
->enable_state
== bp_permanent
3921 : ((others
== 1) ? " and" : ""));
3923 printf_filtered (_("also set at pc "));
3924 fputs_filtered (paddress (pc
), gdb_stdout
);
3925 printf_filtered (".\n");
3929 /* Set the default place to put a breakpoint
3930 for the `break' command with no arguments. */
3933 set_default_breakpoint (int valid
, CORE_ADDR addr
, struct symtab
*symtab
,
3936 default_breakpoint_valid
= valid
;
3937 default_breakpoint_address
= addr
;
3938 default_breakpoint_symtab
= symtab
;
3939 default_breakpoint_line
= line
;
3942 /* Return true iff it is meaningful to use the address member of
3943 BPT. For some breakpoint types, the address member is irrelevant
3944 and it makes no sense to attempt to compare it to other addresses
3945 (or use it for any other purpose either).
3947 More specifically, each of the following breakpoint types will always
3948 have a zero valued address and we don't want check_duplicates() to mark
3949 breakpoints of any of these types to be a duplicate of an actual
3950 breakpoint at address zero:
3953 bp_hardware_watchpoint
3955 bp_access_watchpoint
3962 breakpoint_address_is_meaningful (struct breakpoint
*bpt
)
3964 enum bptype type
= bpt
->type
;
3966 return (type
!= bp_watchpoint
3967 && type
!= bp_hardware_watchpoint
3968 && type
!= bp_read_watchpoint
3969 && type
!= bp_access_watchpoint
3970 && type
!= bp_catch_exec
3971 && type
!= bp_longjmp_resume
3972 && type
!= bp_catch_fork
3973 && type
!= bp_catch_vfork
);
3976 /* Rescan breakpoints at the same address and section as BPT,
3977 marking the first one as "first" and any others as "duplicates".
3978 This is so that the bpt instruction is only inserted once.
3979 If we have a permanent breakpoint at the same place as BPT, make
3980 that one the official one, and the rest as duplicates. */
3983 check_duplicates_for (CORE_ADDR address
, asection
*section
)
3985 struct bp_location
*b
;
3987 struct bp_location
*perm_bp
= 0;
3989 ALL_BP_LOCATIONS (b
)
3990 if (b
->owner
->enable_state
!= bp_disabled
3991 && b
->owner
->enable_state
!= bp_call_disabled
3993 && !b
->shlib_disabled
3994 && b
->address
== address
/* address / overlay match */
3995 && (!overlay_debugging
|| b
->section
== section
)
3996 && breakpoint_address_is_meaningful (b
->owner
))
3998 /* Have we found a permanent breakpoint? */
3999 if (b
->owner
->enable_state
== bp_permanent
)
4006 b
->duplicate
= count
> 1;
4009 /* If we found a permanent breakpoint at this address, go over the
4010 list again and declare all the other breakpoints there to be the
4014 perm_bp
->duplicate
= 0;
4016 /* Permanent breakpoint should always be inserted. */
4017 if (! perm_bp
->inserted
)
4018 internal_error (__FILE__
, __LINE__
,
4019 _("allegedly permanent breakpoint is not "
4020 "actually inserted"));
4022 ALL_BP_LOCATIONS (b
)
4025 if (b
->owner
->enable_state
!= bp_disabled
4026 && b
->owner
->enable_state
!= bp_call_disabled
4027 && b
->enabled
&& !b
->shlib_disabled
4028 && b
->address
== address
/* address / overlay match */
4029 && (!overlay_debugging
|| b
->section
== section
)
4030 && breakpoint_address_is_meaningful (b
->owner
))
4033 internal_error (__FILE__
, __LINE__
,
4034 _("another breakpoint was inserted on top of "
4035 "a permanent breakpoint"));
4044 check_duplicates (struct breakpoint
*bpt
)
4046 struct bp_location
*bl
= bpt
->loc
;
4048 if (! breakpoint_address_is_meaningful (bpt
))
4051 for (; bl
; bl
= bl
->next
)
4052 check_duplicates_for (bl
->address
, bl
->section
);
4056 breakpoint_adjustment_warning (CORE_ADDR from_addr
, CORE_ADDR to_addr
,
4057 int bnum
, int have_bnum
)
4062 strcpy (astr1
, hex_string_custom ((unsigned long) from_addr
, 8));
4063 strcpy (astr2
, hex_string_custom ((unsigned long) to_addr
, 8));
4065 warning (_("Breakpoint %d address previously adjusted from %s to %s."),
4066 bnum
, astr1
, astr2
);
4068 warning (_("Breakpoint address adjusted from %s to %s."), astr1
, astr2
);
4071 /* Adjust a breakpoint's address to account for architectural constraints
4072 on breakpoint placement. Return the adjusted address. Note: Very
4073 few targets require this kind of adjustment. For most targets,
4074 this function is simply the identity function. */
4077 adjust_breakpoint_address (CORE_ADDR bpaddr
, enum bptype bptype
)
4079 if (!gdbarch_adjust_breakpoint_address_p (current_gdbarch
))
4081 /* Very few targets need any kind of breakpoint adjustment. */
4084 else if (bptype
== bp_watchpoint
4085 || bptype
== bp_hardware_watchpoint
4086 || bptype
== bp_read_watchpoint
4087 || bptype
== bp_access_watchpoint
4088 || bptype
== bp_catch_fork
4089 || bptype
== bp_catch_vfork
4090 || bptype
== bp_catch_exec
)
4092 /* Watchpoints and the various bp_catch_* eventpoints should not
4093 have their addresses modified. */
4098 CORE_ADDR adjusted_bpaddr
;
4100 /* Some targets have architectural constraints on the placement
4101 of breakpoint instructions. Obtain the adjusted address. */
4102 adjusted_bpaddr
= gdbarch_adjust_breakpoint_address (current_gdbarch
,
4105 /* An adjusted breakpoint address can significantly alter
4106 a user's expectations. Print a warning if an adjustment
4108 if (adjusted_bpaddr
!= bpaddr
)
4109 breakpoint_adjustment_warning (bpaddr
, adjusted_bpaddr
, 0, 0);
4111 return adjusted_bpaddr
;
4115 /* Allocate a struct bp_location. */
4117 static struct bp_location
*
4118 allocate_bp_location (struct breakpoint
*bpt
, enum bptype bp_type
)
4120 struct bp_location
*loc
, *loc_p
;
4122 loc
= xmalloc (sizeof (struct bp_location
));
4123 memset (loc
, 0, sizeof (*loc
));
4127 loc
->shlib_disabled
= 0;
4136 case bp_longjmp_resume
:
4137 case bp_step_resume
:
4138 case bp_watchpoint_scope
:
4140 case bp_shlib_event
:
4141 case bp_thread_event
:
4142 case bp_overlay_event
:
4144 case bp_catch_unload
:
4145 loc
->loc_type
= bp_loc_software_breakpoint
;
4147 case bp_hardware_breakpoint
:
4148 loc
->loc_type
= bp_loc_hardware_breakpoint
;
4150 case bp_hardware_watchpoint
:
4151 case bp_read_watchpoint
:
4152 case bp_access_watchpoint
:
4153 loc
->loc_type
= bp_loc_hardware_watchpoint
;
4157 case bp_catch_vfork
:
4159 loc
->loc_type
= bp_loc_other
;
4162 internal_error (__FILE__
, __LINE__
, _("unknown breakpoint type"));
4165 /* Add this breakpoint to the end of the chain. */
4167 loc_p
= bp_location_chain
;
4169 bp_location_chain
= loc
;
4172 while (loc_p
->global_next
)
4173 loc_p
= loc_p
->global_next
;
4174 loc_p
->global_next
= loc
;
4180 static void free_bp_location (struct bp_location
*loc
)
4187 /* Helper to set_raw_breakpoint below. Creates a breakpoint
4188 that has type BPTYPE and has no locations as yet. */
4190 static struct breakpoint
*
4191 set_raw_breakpoint_without_location (enum bptype bptype
)
4193 struct breakpoint
*b
, *b1
;
4195 b
= (struct breakpoint
*) xmalloc (sizeof (struct breakpoint
));
4196 memset (b
, 0, sizeof (*b
));
4199 b
->language
= current_language
->la_language
;
4200 b
->input_radix
= input_radix
;
4202 b
->enable_state
= bp_enabled
;
4205 b
->ignore_count
= 0;
4207 b
->frame_id
= null_frame_id
;
4208 b
->dll_pathname
= NULL
;
4209 b
->triggered_dll_pathname
= NULL
;
4210 b
->forked_inferior_pid
= 0;
4211 b
->exec_pathname
= NULL
;
4213 b
->condition_not_parsed
= 0;
4215 /* Add this breakpoint to the end of the chain
4216 so that a list of breakpoints will come out in order
4217 of increasing numbers. */
4219 b1
= breakpoint_chain
;
4221 breakpoint_chain
= b
;
4231 /* Initialize loc->function_name. */
4233 set_breakpoint_location_function (struct bp_location
*loc
)
4235 if (loc
->owner
->type
== bp_breakpoint
4236 || loc
->owner
->type
== bp_hardware_breakpoint
)
4238 find_pc_partial_function (loc
->address
, &(loc
->function_name
),
4240 if (loc
->function_name
)
4241 loc
->function_name
= xstrdup (loc
->function_name
);
4245 /* set_raw_breakpoint is a low level routine for allocating and
4246 partially initializing a breakpoint of type BPTYPE. The newly
4247 created breakpoint's address, section, source file name, and line
4248 number are provided by SAL. The newly created and partially
4249 initialized breakpoint is added to the breakpoint chain and
4250 is also returned as the value of this function.
4252 It is expected that the caller will complete the initialization of
4253 the newly created breakpoint struct as well as output any status
4254 information regarding the creation of a new breakpoint. In
4255 particular, set_raw_breakpoint does NOT set the breakpoint
4256 number! Care should be taken to not allow an error to occur
4257 prior to completing the initialization of the breakpoint. If this
4258 should happen, a bogus breakpoint will be left on the chain. */
4261 set_raw_breakpoint (struct symtab_and_line sal
, enum bptype bptype
)
4263 struct breakpoint
*b
= set_raw_breakpoint_without_location (bptype
);
4264 CORE_ADDR adjusted_address
;
4266 /* Adjust the breakpoint's address prior to allocating a location.
4267 Once we call allocate_bp_location(), that mostly uninitialized
4268 location will be placed on the location chain. Adjustment of the
4269 breakpoint may cause target_read_memory() to be called and we do
4270 not want its scan of the location chain to find a breakpoint and
4271 location that's only been partially initialized. */
4272 adjusted_address
= adjust_breakpoint_address (sal
.pc
, bptype
);
4274 b
->loc
= allocate_bp_location (b
, bptype
);
4275 b
->loc
->requested_address
= sal
.pc
;
4276 b
->loc
->address
= adjusted_address
;
4278 if (sal
.symtab
== NULL
)
4279 b
->source_file
= NULL
;
4281 b
->source_file
= savestring (sal
.symtab
->filename
,
4282 strlen (sal
.symtab
->filename
));
4283 b
->loc
->section
= sal
.section
;
4284 b
->line_number
= sal
.line
;
4286 set_breakpoint_location_function (b
->loc
);
4288 check_duplicates (b
);
4289 breakpoints_changed ();
4295 /* Note that the breakpoint object B describes a permanent breakpoint
4296 instruction, hard-wired into the inferior's code. */
4298 make_breakpoint_permanent (struct breakpoint
*b
)
4300 struct bp_location
*bl
;
4301 b
->enable_state
= bp_permanent
;
4303 /* By definition, permanent breakpoints are already present in the code.
4304 Mark all locations as inserted. For now, make_breakpoint_permanent
4305 is called in just one place, so it's hard to say if it's reasonable
4306 to have permanent breakpoint with multiple locations or not,
4307 but it's easy to implmement. */
4308 for (bl
= b
->loc
; bl
; bl
= bl
->next
)
4312 static struct breakpoint
*
4313 create_internal_breakpoint (CORE_ADDR address
, enum bptype type
)
4315 static int internal_breakpoint_number
= -1;
4316 struct symtab_and_line sal
;
4317 struct breakpoint
*b
;
4319 init_sal (&sal
); /* initialize to zeroes */
4322 sal
.section
= find_pc_overlay (sal
.pc
);
4324 b
= set_raw_breakpoint (sal
, type
);
4325 b
->number
= internal_breakpoint_number
--;
4326 b
->disposition
= disp_donttouch
;
4333 create_longjmp_breakpoint (char *func_name
)
4335 struct breakpoint
*b
;
4336 struct minimal_symbol
*m
;
4338 if (func_name
== NULL
)
4339 b
= create_internal_breakpoint (0, bp_longjmp_resume
);
4342 if ((m
= lookup_minimal_symbol_text (func_name
, NULL
)) == NULL
)
4345 b
= create_internal_breakpoint (SYMBOL_VALUE_ADDRESS (m
), bp_longjmp
);
4348 b
->enable_state
= bp_disabled
;
4351 b
->addr_string
= xstrdup (func_name
);
4354 /* Call this routine when stepping and nexting to enable a breakpoint
4355 if we do a longjmp(). When we hit that breakpoint, call
4356 set_longjmp_resume_breakpoint() to figure out where we are going. */
4359 enable_longjmp_breakpoint (void)
4361 struct breakpoint
*b
;
4364 if (b
->type
== bp_longjmp
)
4366 b
->enable_state
= bp_enabled
;
4367 check_duplicates (b
);
4372 disable_longjmp_breakpoint (void)
4374 struct breakpoint
*b
;
4377 if (b
->type
== bp_longjmp
4378 || b
->type
== bp_longjmp_resume
)
4380 b
->enable_state
= bp_disabled
;
4381 check_duplicates (b
);
4386 create_overlay_event_breakpoint (char *func_name
)
4388 struct breakpoint
*b
;
4389 struct minimal_symbol
*m
;
4391 if ((m
= lookup_minimal_symbol_text (func_name
, NULL
)) == NULL
)
4394 b
= create_internal_breakpoint (SYMBOL_VALUE_ADDRESS (m
),
4396 b
->addr_string
= xstrdup (func_name
);
4398 if (overlay_debugging
== ovly_auto
)
4400 b
->enable_state
= bp_enabled
;
4401 overlay_events_enabled
= 1;
4405 b
->enable_state
= bp_disabled
;
4406 overlay_events_enabled
= 0;
4411 enable_overlay_breakpoints (void)
4413 struct breakpoint
*b
;
4416 if (b
->type
== bp_overlay_event
)
4418 b
->enable_state
= bp_enabled
;
4419 check_duplicates (b
);
4420 overlay_events_enabled
= 1;
4425 disable_overlay_breakpoints (void)
4427 struct breakpoint
*b
;
4430 if (b
->type
== bp_overlay_event
)
4432 b
->enable_state
= bp_disabled
;
4433 check_duplicates (b
);
4434 overlay_events_enabled
= 0;
4439 create_thread_event_breakpoint (CORE_ADDR address
)
4441 struct breakpoint
*b
;
4443 b
= create_internal_breakpoint (address
, bp_thread_event
);
4445 b
->enable_state
= bp_enabled
;
4446 /* addr_string has to be used or breakpoint_re_set will delete me. */
4447 b
->addr_string
= xstrprintf ("*0x%s", paddr (b
->loc
->address
));
4453 remove_thread_event_breakpoints (void)
4455 struct breakpoint
*b
, *temp
;
4457 ALL_BREAKPOINTS_SAFE (b
, temp
)
4458 if (b
->type
== bp_thread_event
)
4459 delete_breakpoint (b
);
4462 struct captured_parse_breakpoint_args
4465 struct symtabs_and_lines
*sals_p
;
4466 char ***addr_string_p
;
4470 struct lang_and_radix
4478 remove_solib_event_breakpoints (void)
4480 struct breakpoint
*b
, *temp
;
4482 ALL_BREAKPOINTS_SAFE (b
, temp
)
4483 if (b
->type
== bp_shlib_event
)
4484 delete_breakpoint (b
);
4488 create_solib_event_breakpoint (CORE_ADDR address
)
4490 struct breakpoint
*b
;
4492 b
= create_internal_breakpoint (address
, bp_shlib_event
);
4496 /* Disable any breakpoints that are on code in shared libraries. Only
4497 apply to enabled breakpoints, disabled ones can just stay disabled. */
4500 disable_breakpoints_in_shlibs (void)
4502 struct bp_location
*loc
;
4503 int disabled_shlib_breaks
= 0;
4505 ALL_BP_LOCATIONS (loc
)
4507 struct breakpoint
*b
= loc
->owner
;
4508 /* We apply the check to all breakpoints, including disabled
4509 for those with loc->duplicate set. This is so that when breakpoint
4510 becomes enabled, or the duplicate is removed, gdb will try to insert
4511 all breakpoints. If we don't set shlib_disabled here, we'll try
4512 to insert those breakpoints and fail. */
4513 if (((b
->type
== bp_breakpoint
) || (b
->type
== bp_hardware_breakpoint
))
4514 && !loc
->shlib_disabled
4516 && PC_SOLIB (loc
->address
)
4518 && solib_address (loc
->address
)
4522 loc
->shlib_disabled
= 1;
4527 /* Disable any breakpoints that are in in an unloaded shared library. Only
4528 apply to enabled breakpoints, disabled ones can just stay disabled. */
4531 disable_breakpoints_in_unloaded_shlib (struct so_list
*solib
)
4533 struct bp_location
*loc
;
4534 int disabled_shlib_breaks
= 0;
4536 ALL_BP_LOCATIONS (loc
)
4538 struct breakpoint
*b
= loc
->owner
;
4539 if ((loc
->loc_type
== bp_loc_hardware_breakpoint
4540 || loc
->loc_type
== bp_loc_software_breakpoint
)
4541 && !loc
->shlib_disabled
)
4544 char *so_name
= PC_SOLIB (loc
->address
);
4546 char *so_name
= solib_address (loc
->address
);
4548 if (so_name
&& !strcmp (so_name
, solib
->so_name
))
4550 loc
->shlib_disabled
= 1;
4551 /* At this point, we cannot rely on remove_breakpoint
4552 succeeding so we must mark the breakpoint as not inserted
4553 to prevent future errors occurring in remove_breakpoints. */
4555 if (!disabled_shlib_breaks
)
4557 target_terminal_ours_for_output ();
4558 warning (_("Temporarily disabling breakpoints for unloaded shared library \"%s\""),
4561 disabled_shlib_breaks
= 1;
4568 create_fork_vfork_event_catchpoint (int tempflag
, char *cond_string
,
4569 enum bptype bp_kind
)
4571 struct symtab_and_line sal
;
4572 struct breakpoint
*b
;
4573 int thread
= -1; /* All threads. */
4580 b
= set_raw_breakpoint (sal
, bp_kind
);
4581 set_breakpoint_count (breakpoint_count
+ 1);
4582 b
->number
= breakpoint_count
;
4583 b
->cond_string
= (cond_string
== NULL
) ?
4584 NULL
: savestring (cond_string
, strlen (cond_string
));
4586 b
->addr_string
= NULL
;
4587 b
->enable_state
= bp_enabled
;
4588 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
4589 b
->forked_inferior_pid
= 0;
4595 create_fork_event_catchpoint (int tempflag
, char *cond_string
)
4597 create_fork_vfork_event_catchpoint (tempflag
, cond_string
, bp_catch_fork
);
4601 create_vfork_event_catchpoint (int tempflag
, char *cond_string
)
4603 create_fork_vfork_event_catchpoint (tempflag
, cond_string
, bp_catch_vfork
);
4607 create_exec_event_catchpoint (int tempflag
, char *cond_string
)
4609 struct symtab_and_line sal
;
4610 struct breakpoint
*b
;
4611 int thread
= -1; /* All threads. */
4618 b
= set_raw_breakpoint (sal
, bp_catch_exec
);
4619 set_breakpoint_count (breakpoint_count
+ 1);
4620 b
->number
= breakpoint_count
;
4621 b
->cond_string
= (cond_string
== NULL
) ?
4622 NULL
: savestring (cond_string
, strlen (cond_string
));
4624 b
->addr_string
= NULL
;
4625 b
->enable_state
= bp_enabled
;
4626 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
4632 hw_breakpoint_used_count (void)
4634 struct breakpoint
*b
;
4639 if (b
->type
== bp_hardware_breakpoint
&& b
->enable_state
== bp_enabled
)
4647 hw_watchpoint_used_count (enum bptype type
, int *other_type_used
)
4649 struct breakpoint
*b
;
4652 *other_type_used
= 0;
4655 if (breakpoint_enabled (b
))
4657 if (b
->type
== type
)
4659 else if ((b
->type
== bp_hardware_watchpoint
||
4660 b
->type
== bp_read_watchpoint
||
4661 b
->type
== bp_access_watchpoint
))
4662 *other_type_used
= 1;
4668 /* Call this after hitting the longjmp() breakpoint. Use this to set
4669 a new breakpoint at the target of the jmp_buf.
4671 FIXME - This ought to be done by setting a temporary breakpoint
4672 that gets deleted automatically... */
4675 set_longjmp_resume_breakpoint (CORE_ADDR pc
, struct frame_id frame_id
)
4677 struct breakpoint
*b
;
4680 if (b
->type
== bp_longjmp_resume
)
4682 b
->loc
->requested_address
= pc
;
4683 b
->loc
->address
= adjust_breakpoint_address (b
->loc
->requested_address
,
4685 b
->enable_state
= bp_enabled
;
4686 b
->frame_id
= frame_id
;
4687 check_duplicates (b
);
4693 disable_watchpoints_before_interactive_call_start (void)
4695 struct breakpoint
*b
;
4699 if (((b
->type
== bp_watchpoint
)
4700 || (b
->type
== bp_hardware_watchpoint
)
4701 || (b
->type
== bp_read_watchpoint
)
4702 || (b
->type
== bp_access_watchpoint
))
4703 && breakpoint_enabled (b
))
4705 b
->enable_state
= bp_call_disabled
;
4706 check_duplicates (b
);
4712 enable_watchpoints_after_interactive_call_stop (void)
4714 struct breakpoint
*b
;
4718 if (((b
->type
== bp_watchpoint
)
4719 || (b
->type
== bp_hardware_watchpoint
)
4720 || (b
->type
== bp_read_watchpoint
)
4721 || (b
->type
== bp_access_watchpoint
))
4722 && (b
->enable_state
== bp_call_disabled
))
4724 b
->enable_state
= bp_enabled
;
4725 check_duplicates (b
);
4731 /* Set a breakpoint that will evaporate an end of command
4732 at address specified by SAL.
4733 Restrict it to frame FRAME if FRAME is nonzero. */
4736 set_momentary_breakpoint (struct symtab_and_line sal
, struct frame_id frame_id
,
4739 struct breakpoint
*b
;
4740 b
= set_raw_breakpoint (sal
, type
);
4741 b
->enable_state
= bp_enabled
;
4742 b
->disposition
= disp_donttouch
;
4743 b
->frame_id
= frame_id
;
4745 /* If we're debugging a multi-threaded program, then we
4746 want momentary breakpoints to be active in only a
4747 single thread of control. */
4748 if (in_thread_list (inferior_ptid
))
4749 b
->thread
= pid_to_thread_id (inferior_ptid
);
4755 /* Tell the user we have just set a breakpoint B. */
4758 mention (struct breakpoint
*b
)
4761 struct cleanup
*old_chain
, *ui_out_chain
;
4762 struct ui_stream
*stb
;
4764 stb
= ui_out_stream_new (uiout
);
4765 old_chain
= make_cleanup_ui_out_stream_delete (stb
);
4767 /* FIXME: This is misplaced; mention() is called by things (like
4768 hitting a watchpoint) other than breakpoint creation. It should
4769 be possible to clean this up and at the same time replace the
4770 random calls to breakpoint_changed with this hook, as has already
4771 been done for deprecated_delete_breakpoint_hook and so on. */
4772 if (deprecated_create_breakpoint_hook
)
4773 deprecated_create_breakpoint_hook (b
);
4774 breakpoint_create_event (b
->number
);
4776 if (b
->ops
!= NULL
&& b
->ops
->print_mention
!= NULL
)
4777 b
->ops
->print_mention (b
);
4782 printf_filtered (_("(apparently deleted?) Eventpoint %d: "), b
->number
);
4785 ui_out_text (uiout
, "Watchpoint ");
4786 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "wpt");
4787 ui_out_field_int (uiout
, "number", b
->number
);
4788 ui_out_text (uiout
, ": ");
4789 print_expression (b
->exp
, stb
->stream
);
4790 ui_out_field_stream (uiout
, "exp", stb
);
4791 do_cleanups (ui_out_chain
);
4793 case bp_hardware_watchpoint
:
4794 ui_out_text (uiout
, "Hardware watchpoint ");
4795 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "wpt");
4796 ui_out_field_int (uiout
, "number", b
->number
);
4797 ui_out_text (uiout
, ": ");
4798 print_expression (b
->exp
, stb
->stream
);
4799 ui_out_field_stream (uiout
, "exp", stb
);
4800 do_cleanups (ui_out_chain
);
4802 case bp_read_watchpoint
:
4803 ui_out_text (uiout
, "Hardware read watchpoint ");
4804 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "hw-rwpt");
4805 ui_out_field_int (uiout
, "number", b
->number
);
4806 ui_out_text (uiout
, ": ");
4807 print_expression (b
->exp
, stb
->stream
);
4808 ui_out_field_stream (uiout
, "exp", stb
);
4809 do_cleanups (ui_out_chain
);
4811 case bp_access_watchpoint
:
4812 ui_out_text (uiout
, "Hardware access (read/write) watchpoint ");
4813 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "hw-awpt");
4814 ui_out_field_int (uiout
, "number", b
->number
);
4815 ui_out_text (uiout
, ": ");
4816 print_expression (b
->exp
, stb
->stream
);
4817 ui_out_field_stream (uiout
, "exp", stb
);
4818 do_cleanups (ui_out_chain
);
4821 if (ui_out_is_mi_like_p (uiout
))
4826 printf_filtered (_("Breakpoint %d"), b
->number
);
4829 case bp_hardware_breakpoint
:
4830 if (ui_out_is_mi_like_p (uiout
))
4835 printf_filtered (_("Hardware assisted breakpoint %d"), b
->number
);
4839 case bp_catch_unload
:
4840 printf_filtered (_("Catchpoint %d (%s %s)"),
4842 (b
->type
== bp_catch_load
) ? "load" : "unload",
4843 (b
->dll_pathname
!= NULL
) ?
4844 b
->dll_pathname
: "<any library>");
4847 case bp_catch_vfork
:
4848 printf_filtered (_("Catchpoint %d (%s)"),
4850 (b
->type
== bp_catch_fork
) ? "fork" : "vfork");
4853 printf_filtered (_("Catchpoint %d (exec)"),
4860 case bp_longjmp_resume
:
4861 case bp_step_resume
:
4863 case bp_watchpoint_scope
:
4864 case bp_shlib_event
:
4865 case bp_thread_event
:
4866 case bp_overlay_event
:
4872 /* i18n: cagney/2005-02-11: Below needs to be merged into a
4876 printf_filtered (_(" (%s) pending."), b
->addr_string
);
4880 if (addressprint
|| b
->source_file
== NULL
)
4882 printf_filtered (" at ");
4883 fputs_filtered (paddress (b
->loc
->address
), gdb_stdout
);
4886 printf_filtered (": file %s, line %d.",
4887 b
->source_file
, b
->line_number
);
4891 struct bp_location
*loc
= b
->loc
;
4893 for (; loc
; loc
= loc
->next
)
4895 printf_filtered (" (%d locations)", n
);
4900 do_cleanups (old_chain
);
4901 if (ui_out_is_mi_like_p (uiout
))
4903 printf_filtered ("\n");
4907 static struct bp_location
*
4908 add_location_to_breakpoint (struct breakpoint
*b
, enum bptype bptype
,
4909 const struct symtab_and_line
*sal
)
4911 struct bp_location
*loc
, **tmp
;
4913 loc
= allocate_bp_location (b
, bptype
);
4914 for (tmp
= &(b
->loc
); *tmp
!= NULL
; tmp
= &((*tmp
)->next
))
4917 loc
->requested_address
= sal
->pc
;
4918 loc
->address
= adjust_breakpoint_address (loc
->requested_address
,
4920 loc
->section
= sal
->section
;
4922 set_breakpoint_location_function (loc
);
4926 /* Create a breakpoint with SAL as location. Use ADDR_STRING
4927 as textual description of the location, and COND_STRING
4928 as condition expression. */
4931 create_breakpoint (struct symtabs_and_lines sals
, char *addr_string
,
4933 enum bptype type
, enum bpdisp disposition
,
4934 int thread
, int ignore_count
, int from_tty
)
4936 struct breakpoint
*b
= NULL
;
4939 if (type
== bp_hardware_breakpoint
)
4941 int i
= hw_breakpoint_used_count ();
4942 int target_resources_ok
=
4943 TARGET_CAN_USE_HARDWARE_WATCHPOINT (bp_hardware_breakpoint
,
4945 if (target_resources_ok
== 0)
4946 error (_("No hardware breakpoint support in the target."));
4947 else if (target_resources_ok
< 0)
4948 error (_("Hardware breakpoints used exceeds limit."));
4951 for (i
= 0; i
< sals
.nelts
; ++i
)
4953 struct symtab_and_line sal
= sals
.sals
[i
];
4954 struct bp_location
*loc
;
4957 describe_other_breakpoints (sal
.pc
, sal
.section
, thread
);
4961 b
= set_raw_breakpoint (sal
, type
);
4962 set_breakpoint_count (breakpoint_count
+ 1);
4963 b
->number
= breakpoint_count
;
4966 b
->cond_string
= cond_string
;
4967 b
->ignore_count
= ignore_count
;
4968 b
->enable_state
= bp_enabled
;
4969 b
->disposition
= disposition
;
4975 loc
= add_location_to_breakpoint (b
, type
, &sal
);
4980 char *arg
= b
->cond_string
;
4981 loc
->cond
= parse_exp_1 (&arg
, block_for_pc (loc
->address
), 0);
4983 error (_("Garbage %s follows condition"), arg
);
4988 b
->addr_string
= addr_string
;
4990 /* addr_string has to be used or breakpoint_re_set will delete
4992 b
->addr_string
= xstrprintf ("*0x%s", paddr (b
->loc
->address
));
4997 /* Remove element at INDEX_TO_REMOVE from SAL, shifting other
4998 elements to fill the void space. */
4999 static void remove_sal (struct symtabs_and_lines
*sal
, int index_to_remove
)
5001 int i
= index_to_remove
+1;
5002 int last_index
= sal
->nelts
-1;
5004 for (;i
<= last_index
; ++i
)
5005 sal
->sals
[i
-1] = sal
->sals
[i
];
5010 /* If appropriate, obtains all sals that correspond
5011 to the same file and line as SAL. This is done
5012 only if SAL does not have explicit PC and has
5013 line and file information. If we got just a single
5014 expanded sal, return the original.
5016 Otherwise, if SAL.explicit_line is not set, filter out
5017 all sals for which the name of enclosing function
5018 is different from SAL. This makes sure that if we have
5019 breakpoint originally set in template instantiation, say
5020 foo<int>(), we won't expand SAL to locations at the same
5021 line in all existing instantiations of 'foo'.
5024 struct symtabs_and_lines
5025 expand_line_sal_maybe (struct symtab_and_line sal
)
5027 struct symtabs_and_lines expanded
;
5028 CORE_ADDR original_pc
= sal
.pc
;
5029 char *original_function
= NULL
;
5033 /* If we have explicit pc, don't expand.
5034 If we have no line number, we can't expand. */
5035 if (sal
.explicit_pc
|| sal
.line
== 0 || sal
.symtab
== NULL
)
5038 expanded
.sals
= xmalloc (sizeof (struct symtab_and_line
));
5039 expanded
.sals
[0] = sal
;
5044 find_pc_partial_function (original_pc
, &original_function
, NULL
, NULL
);
5046 expanded
= expand_line_sal (sal
);
5047 if (expanded
.nelts
== 1)
5049 /* We had one sal, we got one sal. Without futher
5050 processing, just return the original sal. */
5051 xfree (expanded
.sals
);
5053 expanded
.sals
= xmalloc (sizeof (struct symtab_and_line
));
5054 sal
.pc
= original_pc
;
5055 expanded
.sals
[0] = sal
;
5059 if (!sal
.explicit_line
)
5061 CORE_ADDR func_addr
, func_end
;
5062 for (i
= 0; i
< expanded
.nelts
; ++i
)
5064 CORE_ADDR pc
= expanded
.sals
[i
].pc
;
5065 char *this_function
;
5066 if (find_pc_partial_function (pc
, &this_function
,
5067 &func_addr
, &func_end
))
5069 if (this_function
&&
5070 strcmp (this_function
, original_function
) != 0)
5072 remove_sal (&expanded
, i
);
5075 else if (func_addr
== pc
)
5077 /* We're at beginning of a function, and should
5079 struct symbol
*sym
= find_pc_function (pc
);
5081 expanded
.sals
[i
] = find_function_start_sal (sym
, 1);
5084 = gdbarch_skip_prologue (current_gdbarch
, pc
);
5091 if (expanded
.nelts
<= 1)
5093 /* This is un ugly workaround. If we get zero
5094 expanded sals then something is really wrong.
5095 Fix that by returnign the original sal. */
5096 xfree (expanded
.sals
);
5098 expanded
.sals
= xmalloc (sizeof (struct symtab_and_line
));
5099 sal
.pc
= original_pc
;
5100 expanded
.sals
[0] = sal
;
5107 for (i
= 0; i
< expanded
.nelts
; ++i
)
5108 if (expanded
.sals
[i
].pc
== original_pc
)
5119 /* Add SALS.nelts breakpoints to the breakpoint table. For each
5120 SALS.sal[i] breakpoint, include the corresponding ADDR_STRING[i]
5121 value. COND_STRING, if not NULL, specified the condition to be
5122 used for all breakpoints. Essentially the only case where
5123 SALS.nelts is not 1 is when we set a breakpoint on an overloaded
5124 function. In that case, it's still not possible to specify
5125 separate conditions for different overloaded functions, so
5126 we take just a single condition string.
5128 NOTE: If the function succeeds, the caller is expected to cleanup
5129 the arrays ADDR_STRING, COND_STRING, and SALS (but not the
5130 array contents). If the function fails (error() is called), the
5131 caller is expected to cleanups both the ADDR_STRING, COND_STRING,
5132 COND and SALS arrays and each of those arrays contents. */
5135 create_breakpoints (struct symtabs_and_lines sals
, char **addr_string
,
5137 enum bptype type
, enum bpdisp disposition
,
5138 int thread
, int ignore_count
, int from_tty
)
5141 for (i
= 0; i
< sals
.nelts
; ++i
)
5143 struct symtabs_and_lines expanded
=
5144 expand_line_sal_maybe (sals
.sals
[i
]);
5146 create_breakpoint (expanded
, addr_string
[i
],
5147 cond_string
, type
, disposition
,
5148 thread
, ignore_count
, from_tty
);
5152 /* Parse ARG which is assumed to be a SAL specification possibly
5153 followed by conditionals. On return, SALS contains an array of SAL
5154 addresses found. ADDR_STRING contains a vector of (canonical)
5155 address strings. ARG points to the end of the SAL. */
5158 parse_breakpoint_sals (char **address
,
5159 struct symtabs_and_lines
*sals
,
5160 char ***addr_string
,
5163 char *addr_start
= *address
;
5164 *addr_string
= NULL
;
5165 /* If no arg given, or if first arg is 'if ', use the default
5167 if ((*address
) == NULL
5168 || (strncmp ((*address
), "if", 2) == 0 && isspace ((*address
)[2])))
5170 if (default_breakpoint_valid
)
5172 struct symtab_and_line sal
;
5173 init_sal (&sal
); /* initialize to zeroes */
5174 sals
->sals
= (struct symtab_and_line
*)
5175 xmalloc (sizeof (struct symtab_and_line
));
5176 sal
.pc
= default_breakpoint_address
;
5177 sal
.line
= default_breakpoint_line
;
5178 sal
.symtab
= default_breakpoint_symtab
;
5179 sal
.section
= find_pc_overlay (sal
.pc
);
5180 sals
->sals
[0] = sal
;
5184 error (_("No default breakpoint address now."));
5188 /* Force almost all breakpoints to be in terms of the
5189 current_source_symtab (which is decode_line_1's default). This
5190 should produce the results we want almost all of the time while
5191 leaving default_breakpoint_* alone.
5192 ObjC: However, don't match an Objective-C method name which
5193 may have a '+' or '-' succeeded by a '[' */
5195 struct symtab_and_line cursal
= get_current_source_symtab_and_line ();
5197 if (default_breakpoint_valid
5199 || ((strchr ("+-", (*address
)[0]) != NULL
)
5200 && ((*address
)[1] != '['))))
5201 *sals
= decode_line_1 (address
, 1, default_breakpoint_symtab
,
5202 default_breakpoint_line
, addr_string
,
5205 *sals
= decode_line_1 (address
, 1, (struct symtab
*) NULL
, 0,
5206 addr_string
, not_found_ptr
);
5208 /* For any SAL that didn't have a canonical string, fill one in. */
5209 if (sals
->nelts
> 0 && *addr_string
== NULL
)
5210 *addr_string
= xcalloc (sals
->nelts
, sizeof (char **));
5211 if (addr_start
!= (*address
))
5214 for (i
= 0; i
< sals
->nelts
; i
++)
5216 /* Add the string if not present. */
5217 if ((*addr_string
)[i
] == NULL
)
5218 (*addr_string
)[i
] = savestring (addr_start
, (*address
) - addr_start
);
5224 /* Convert each SAL into a real PC. Verify that the PC can be
5225 inserted as a breakpoint. If it can't throw an error. */
5228 breakpoint_sals_to_pc (struct symtabs_and_lines
*sals
,
5232 for (i
= 0; i
< sals
->nelts
; i
++)
5233 resolve_sal_pc (&sals
->sals
[i
]);
5237 do_captured_parse_breakpoint (struct ui_out
*ui
, void *data
)
5239 struct captured_parse_breakpoint_args
*args
= data
;
5241 parse_breakpoint_sals (args
->arg_p
, args
->sals_p
, args
->addr_string_p
,
5242 args
->not_found_ptr
);
5245 /* Given TOK, a string specification of condition and thread, as
5246 accepted by the 'break' command, extract the condition
5247 string and thread number and set *COND_STRING and *THREAD.
5248 PC identifies the context at which the condition should be parsed.
5249 If no condition is found, *COND_STRING is set to NULL.
5250 If no thread is found, *THREAD is set to -1. */
5252 find_condition_and_thread (char *tok
, CORE_ADDR pc
,
5253 char **cond_string
, int *thread
)
5255 *cond_string
= NULL
;
5261 char *cond_start
= NULL
;
5262 char *cond_end
= NULL
;
5263 while (*tok
== ' ' || *tok
== '\t')
5268 while (*end_tok
!= ' ' && *end_tok
!= '\t' && *end_tok
!= '\000')
5271 toklen
= end_tok
- tok
;
5273 if (toklen
>= 1 && strncmp (tok
, "if", toklen
) == 0)
5275 tok
= cond_start
= end_tok
+ 1;
5276 parse_exp_1 (&tok
, block_for_pc (pc
), 0);
5278 *cond_string
= savestring (cond_start
,
5279 cond_end
- cond_start
);
5281 else if (toklen
>= 1 && strncmp (tok
, "thread", toklen
) == 0)
5287 *thread
= strtol (tok
, &tok
, 0);
5289 error (_("Junk after thread keyword."));
5290 if (!valid_thread_id (*thread
))
5291 error (_("Unknown thread %d."), *thread
);
5294 error (_("Junk at end of arguments."));
5298 /* Set a breakpoint. This function is shared between
5299 CLI and MI functions for setting a breakpoint.
5300 This function has two major modes of operations,
5301 selected by the PARSE_CONDITION_AND_THREAD parameter.
5302 If non-zero, the function will parse arg, extracting
5303 breakpoint location, address and thread. Otherwise,
5304 ARG is just the location of breakpoint, with condition
5305 and thread specified by the COND_STRING and THREAD
5309 break_command_really (char *arg
, char *cond_string
, int thread
,
5310 int parse_condition_and_thread
,
5311 int tempflag
, int hardwareflag
,
5313 enum auto_boolean pending_break_support
,
5316 struct gdb_exception e
;
5317 struct symtabs_and_lines sals
;
5318 struct symtab_and_line pending_sal
;
5321 char *addr_start
= arg
;
5323 struct cleanup
*old_chain
;
5324 struct cleanup
*breakpoint_chain
= NULL
;
5325 struct captured_parse_breakpoint_args parse_args
;
5334 parse_args
.arg_p
= &arg
;
5335 parse_args
.sals_p
= &sals
;
5336 parse_args
.addr_string_p
= &addr_string
;
5337 parse_args
.not_found_ptr
= ¬_found
;
5339 e
= catch_exception (uiout
, do_captured_parse_breakpoint
,
5340 &parse_args
, RETURN_MASK_ALL
);
5342 /* If caller is interested in rc value from parse, set value. */
5346 throw_exception (e
);
5350 case NOT_FOUND_ERROR
:
5352 /* If pending breakpoint support is turned off, throw
5355 if (pending_break_support
== AUTO_BOOLEAN_FALSE
)
5356 throw_exception (e
);
5358 exception_print (gdb_stderr
, e
);
5360 /* If pending breakpoint support is auto query and the user
5361 selects no, then simply return the error code. */
5362 if (pending_break_support
== AUTO_BOOLEAN_AUTO
&&
5363 !nquery ("Make breakpoint pending on future shared library load? "))
5366 /* At this point, either the user was queried about setting
5367 a pending breakpoint and selected yes, or pending
5368 breakpoint behavior is on and thus a pending breakpoint
5369 is defaulted on behalf of the user. */
5370 copy_arg
= xstrdup (addr_start
);
5371 addr_string
= ©_arg
;
5373 sals
.sals
= &pending_sal
;
5378 throw_exception (e
);
5385 /* Create a chain of things that always need to be cleaned up. */
5386 old_chain
= make_cleanup (null_cleanup
, 0);
5390 /* Make sure that all storage allocated to SALS gets freed. */
5391 make_cleanup (xfree
, sals
.sals
);
5393 /* Cleanup the addr_string array but not its contents. */
5394 make_cleanup (xfree
, addr_string
);
5397 /* ----------------------------- SNIP -----------------------------
5398 Anything added to the cleanup chain beyond this point is assumed
5399 to be part of a breakpoint. If the breakpoint create succeeds
5400 then the memory is not reclaimed. */
5401 breakpoint_chain
= make_cleanup (null_cleanup
, 0);
5403 /* Mark the contents of the addr_string for cleanup. These go on
5404 the breakpoint_chain and only occure if the breakpoint create
5406 for (i
= 0; i
< sals
.nelts
; i
++)
5408 if (addr_string
[i
] != NULL
)
5409 make_cleanup (xfree
, addr_string
[i
]);
5412 /* Resolve all line numbers to PC's and verify that the addresses
5413 are ok for the target. */
5415 breakpoint_sals_to_pc (&sals
, addr_start
);
5417 /* Verify that condition can be parsed, before setting any
5418 breakpoints. Allocate a separate condition expression for each
5422 if (parse_condition_and_thread
)
5424 /* Here we only parse 'arg' to separate condition
5425 from thread number, so parsing in context of first
5426 sal is OK. When setting the breakpoint we'll
5427 re-parse it in context of each sal. */
5430 find_condition_and_thread (arg
, sals
.sals
[0].pc
, &cond_string
, &thread
);
5432 make_cleanup (xfree
, cond_string
);
5436 /* Create a private copy of condition string. */
5439 cond_string
= xstrdup (cond_string
);
5440 make_cleanup (xfree
, cond_string
);
5443 create_breakpoints (sals
, addr_string
, cond_string
,
5444 hardwareflag
? bp_hardware_breakpoint
5446 tempflag
? disp_del
: disp_donttouch
,
5447 thread
, ignore_count
, from_tty
);
5451 struct symtab_and_line sal
= {0};
5452 struct breakpoint
*b
;
5454 make_cleanup (xfree
, copy_arg
);
5456 b
= set_raw_breakpoint_without_location (hardwareflag
5457 ? bp_hardware_breakpoint
5459 set_breakpoint_count (breakpoint_count
+ 1);
5460 b
->number
= breakpoint_count
;
5462 b
->addr_string
= addr_string
[0];
5463 b
->cond_string
= NULL
;
5464 b
->ignore_count
= ignore_count
;
5465 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
5466 b
->condition_not_parsed
= 1;
5471 warning (_("Multiple breakpoints were set.\n"
5472 "Use the \"delete\" command to delete unwanted breakpoints."));
5473 /* That's it. Discard the cleanups for data inserted into the
5475 discard_cleanups (breakpoint_chain
);
5476 /* But cleanup everything else. */
5477 do_cleanups (old_chain
);
5480 /* Set a breakpoint.
5481 ARG is a string describing breakpoint address,
5482 condition, and thread.
5483 FLAG specifies if a breakpoint is hardware on,
5484 and if breakpoint is temporary, using BP_HARDWARE_FLAG
5488 break_command_1 (char *arg
, int flag
, int from_tty
)
5490 int hardwareflag
= flag
& BP_HARDWAREFLAG
;
5491 int tempflag
= flag
& BP_TEMPFLAG
;
5493 break_command_really (arg
,
5494 NULL
, 0, 1 /* parse arg */,
5495 tempflag
, hardwareflag
,
5496 0 /* Ignore count */,
5497 pending_break_support
, from_tty
);
5502 set_breakpoint (char *address
, char *condition
,
5503 int hardwareflag
, int tempflag
,
5504 int thread
, int ignore_count
,
5507 break_command_really (address
, condition
, thread
,
5508 0 /* condition and thread are valid. */,
5509 tempflag
, hardwareflag
,
5512 ? AUTO_BOOLEAN_TRUE
: AUTO_BOOLEAN_FALSE
,
5516 /* Adjust SAL to the first instruction past the function prologue.
5517 The end of the prologue is determined using the line table from
5518 the debugging information.
5520 If SAL is already past the prologue, then do nothing. */
5523 skip_prologue_sal (struct symtab_and_line
*sal
)
5525 struct symbol
*sym
= find_pc_function (sal
->pc
);
5526 struct symtab_and_line start_sal
;
5531 start_sal
= find_function_start_sal (sym
, 1);
5532 if (sal
->pc
< start_sal
.pc
)
5536 /* Helper function for break_command_1 and disassemble_command. */
5539 resolve_sal_pc (struct symtab_and_line
*sal
)
5543 if (sal
->pc
== 0 && sal
->symtab
!= NULL
)
5545 if (!find_line_pc (sal
->symtab
, sal
->line
, &pc
))
5546 error (_("No line %d in file \"%s\"."),
5547 sal
->line
, sal
->symtab
->filename
);
5550 /* If this SAL corresponds to a breakpoint inserted using
5551 a line number, then skip the function prologue if necessary. */
5552 if (sal
->explicit_line
)
5553 skip_prologue_sal (sal
);
5556 if (sal
->section
== 0 && sal
->symtab
!= NULL
)
5558 struct blockvector
*bv
;
5562 bv
= blockvector_for_pc_sect (sal
->pc
, 0, &b
, sal
->symtab
);
5565 sym
= block_function (b
);
5568 fixup_symbol_section (sym
, sal
->symtab
->objfile
);
5569 sal
->section
= SYMBOL_BFD_SECTION (sym
);
5573 /* It really is worthwhile to have the section, so we'll just
5574 have to look harder. This case can be executed if we have
5575 line numbers but no functions (as can happen in assembly
5578 struct minimal_symbol
*msym
;
5580 msym
= lookup_minimal_symbol_by_pc (sal
->pc
);
5582 sal
->section
= SYMBOL_BFD_SECTION (msym
);
5589 break_command (char *arg
, int from_tty
)
5591 break_command_1 (arg
, 0, from_tty
);
5595 tbreak_command (char *arg
, int from_tty
)
5597 break_command_1 (arg
, BP_TEMPFLAG
, from_tty
);
5601 hbreak_command (char *arg
, int from_tty
)
5603 break_command_1 (arg
, BP_HARDWAREFLAG
, from_tty
);
5607 thbreak_command (char *arg
, int from_tty
)
5609 break_command_1 (arg
, (BP_TEMPFLAG
| BP_HARDWAREFLAG
), from_tty
);
5613 stop_command (char *arg
, int from_tty
)
5615 printf_filtered (_("Specify the type of breakpoint to set.\n\
5616 Usage: stop in <function | address>\n\
5617 stop at <line>\n"));
5621 stopin_command (char *arg
, int from_tty
)
5625 if (arg
== (char *) NULL
)
5627 else if (*arg
!= '*')
5632 /* look for a ':'. If this is a line number specification, then
5633 say it is bad, otherwise, it should be an address or
5634 function/method name */
5635 while (*argptr
&& !hasColon
)
5637 hasColon
= (*argptr
== ':');
5642 badInput
= (*argptr
!= ':'); /* Not a class::method */
5644 badInput
= isdigit (*arg
); /* a simple line number */
5648 printf_filtered (_("Usage: stop in <function | address>\n"));
5650 break_command_1 (arg
, 0, from_tty
);
5654 stopat_command (char *arg
, int from_tty
)
5658 if (arg
== (char *) NULL
|| *arg
== '*') /* no line number */
5665 /* look for a ':'. If there is a '::' then get out, otherwise
5666 it is probably a line number. */
5667 while (*argptr
&& !hasColon
)
5669 hasColon
= (*argptr
== ':');
5674 badInput
= (*argptr
== ':'); /* we have class::method */
5676 badInput
= !isdigit (*arg
); /* not a line number */
5680 printf_filtered (_("Usage: stop at <line>\n"));
5682 break_command_1 (arg
, 0, from_tty
);
5685 /* accessflag: hw_write: watch write,
5686 hw_read: watch read,
5687 hw_access: watch access (read or write) */
5689 watch_command_1 (char *arg
, int accessflag
, int from_tty
)
5691 struct breakpoint
*b
, *scope_breakpoint
= NULL
;
5692 struct symtab_and_line sal
;
5693 struct expression
*exp
;
5694 struct block
*exp_valid_block
;
5695 struct value
*val
, *mark
;
5696 struct frame_info
*frame
;
5697 struct frame_info
*prev_frame
= NULL
;
5698 char *exp_start
= NULL
;
5699 char *exp_end
= NULL
;
5700 char *tok
, *id_tok_start
, *end_tok
;
5702 char *cond_start
= NULL
;
5703 char *cond_end
= NULL
;
5704 struct expression
*cond
= NULL
;
5705 int i
, other_type_used
, target_resources_ok
= 0;
5706 enum bptype bp_type
;
5710 init_sal (&sal
); /* initialize to zeroes */
5712 /* Make sure that we actually have parameters to parse. */
5713 if (arg
!= NULL
&& arg
[0] != '\0')
5715 toklen
= strlen (arg
); /* Size of argument list. */
5717 /* Points tok to the end of the argument list. */
5718 tok
= arg
+ toklen
- 1;
5720 /* Go backwards in the parameters list. Skip the last parameter.
5721 If we're expecting a 'thread <thread_num>' parameter, this should
5722 be the thread identifier. */
5723 while (tok
> arg
&& (*tok
== ' ' || *tok
== '\t'))
5725 while (tok
> arg
&& (*tok
!= ' ' && *tok
!= '\t'))
5728 /* Points end_tok to the beginning of the last token. */
5729 id_tok_start
= tok
+ 1;
5731 /* Go backwards in the parameters list. Skip one more parameter.
5732 If we're expecting a 'thread <thread_num>' parameter, we should
5733 reach a "thread" token. */
5734 while (tok
> arg
&& (*tok
== ' ' || *tok
== '\t'))
5739 while (tok
> arg
&& (*tok
!= ' ' && *tok
!= '\t'))
5742 /* Move the pointer forward to skip the whitespace and
5743 calculate the length of the token. */
5745 toklen
= end_tok
- tok
;
5747 if (toklen
>= 1 && strncmp (tok
, "thread", toklen
) == 0)
5749 /* At this point we've found a "thread" token, which means
5750 the user is trying to set a watchpoint that triggers
5751 only in a specific thread. */
5754 /* Extract the thread ID from the next token. */
5755 thread
= strtol (id_tok_start
, &endp
, 0);
5757 /* Check if the user provided a valid numeric value for the
5759 if (*endp
!= ' ' && *endp
!= '\t' && *endp
!= '\0')
5760 error (_("Invalid thread ID specification %s."), id_tok_start
);
5762 /* Check if the thread actually exists. */
5763 if (!valid_thread_id (thread
))
5764 error (_("Unknown thread %d."), thread
);
5766 /* Truncate the string and get rid of the thread <thread_num>
5767 parameter before the parameter list is parsed by the
5768 evaluate_expression() function. */
5773 /* Parse the rest of the arguments. */
5774 innermost_block
= NULL
;
5776 exp
= parse_exp_1 (&arg
, 0, 0);
5778 exp_valid_block
= innermost_block
;
5779 mark
= value_mark ();
5780 fetch_watchpoint_value (exp
, &val
, NULL
, NULL
);
5782 release_value (val
);
5785 while (*tok
== ' ' || *tok
== '\t')
5789 while (*end_tok
!= ' ' && *end_tok
!= '\t' && *end_tok
!= '\000')
5792 toklen
= end_tok
- tok
;
5793 if (toklen
>= 1 && strncmp (tok
, "if", toklen
) == 0)
5795 tok
= cond_start
= end_tok
+ 1;
5796 cond
= parse_exp_1 (&tok
, 0, 0);
5800 error (_("Junk at end of command."));
5802 if (accessflag
== hw_read
)
5803 bp_type
= bp_read_watchpoint
;
5804 else if (accessflag
== hw_access
)
5805 bp_type
= bp_access_watchpoint
;
5807 bp_type
= bp_hardware_watchpoint
;
5809 mem_cnt
= can_use_hardware_watchpoint (val
);
5810 if (mem_cnt
== 0 && bp_type
!= bp_hardware_watchpoint
)
5811 error (_("Expression cannot be implemented with read/access watchpoint."));
5814 i
= hw_watchpoint_used_count (bp_type
, &other_type_used
);
5815 target_resources_ok
=
5816 TARGET_CAN_USE_HARDWARE_WATCHPOINT (bp_type
, i
+ mem_cnt
,
5818 if (target_resources_ok
== 0 && bp_type
!= bp_hardware_watchpoint
)
5819 error (_("Target does not support this type of hardware watchpoint."));
5821 if (target_resources_ok
< 0 && bp_type
!= bp_hardware_watchpoint
)
5822 error (_("Target can only support one kind of HW watchpoint at a time."));
5825 /* Change the type of breakpoint to an ordinary watchpoint if a hardware
5826 watchpoint could not be set. */
5827 if (!mem_cnt
|| target_resources_ok
<= 0)
5828 bp_type
= bp_watchpoint
;
5830 frame
= block_innermost_frame (exp_valid_block
);
5832 prev_frame
= get_prev_frame (frame
);
5836 /* If the expression is "local", then set up a "watchpoint scope"
5837 breakpoint at the point where we've left the scope of the watchpoint
5838 expression. Create the scope breakpoint before the watchpoint, so
5839 that we will encounter it first in bpstat_stop_status. */
5840 if (innermost_block
&& prev_frame
)
5842 scope_breakpoint
= create_internal_breakpoint (get_frame_pc (prev_frame
),
5843 bp_watchpoint_scope
);
5845 scope_breakpoint
->enable_state
= bp_enabled
;
5847 /* Automatically delete the breakpoint when it hits. */
5848 scope_breakpoint
->disposition
= disp_del
;
5850 /* Only break in the proper frame (help with recursion). */
5851 scope_breakpoint
->frame_id
= get_frame_id (prev_frame
);
5853 /* Set the address at which we will stop. */
5854 scope_breakpoint
->loc
->requested_address
5855 = get_frame_pc (prev_frame
);
5856 scope_breakpoint
->loc
->address
5857 = adjust_breakpoint_address (scope_breakpoint
->loc
->requested_address
,
5858 scope_breakpoint
->type
);
5861 /* Now set up the breakpoint. */
5862 b
= set_raw_breakpoint (sal
, bp_type
);
5863 set_breakpoint_count (breakpoint_count
+ 1);
5864 b
->number
= breakpoint_count
;
5866 b
->disposition
= disp_donttouch
;
5868 b
->exp_valid_block
= exp_valid_block
;
5869 b
->exp_string
= savestring (exp_start
, exp_end
- exp_start
);
5872 b
->loc
->cond
= cond
;
5874 b
->cond_string
= savestring (cond_start
, cond_end
- cond_start
);
5879 b
->watchpoint_frame
= get_frame_id (frame
);
5881 b
->watchpoint_frame
= null_frame_id
;
5883 if (scope_breakpoint
!= NULL
)
5885 /* The scope breakpoint is related to the watchpoint. We will
5886 need to act on them together. */
5887 b
->related_breakpoint
= scope_breakpoint
;
5888 scope_breakpoint
->related_breakpoint
= b
;
5891 value_free_to_mark (mark
);
5895 /* Return count of locations need to be watched and can be handled
5896 in hardware. If the watchpoint can not be handled
5897 in hardware return zero. */
5900 can_use_hardware_watchpoint (struct value
*v
)
5902 int found_memory_cnt
= 0;
5903 struct value
*head
= v
;
5905 /* Did the user specifically forbid us to use hardware watchpoints? */
5906 if (!can_use_hw_watchpoints
)
5909 /* Make sure that the value of the expression depends only upon
5910 memory contents, and values computed from them within GDB. If we
5911 find any register references or function calls, we can't use a
5912 hardware watchpoint.
5914 The idea here is that evaluating an expression generates a series
5915 of values, one holding the value of every subexpression. (The
5916 expression a*b+c has five subexpressions: a, b, a*b, c, and
5917 a*b+c.) GDB's values hold almost enough information to establish
5918 the criteria given above --- they identify memory lvalues,
5919 register lvalues, computed values, etcetera. So we can evaluate
5920 the expression, and then scan the chain of values that leaves
5921 behind to decide whether we can detect any possible change to the
5922 expression's final value using only hardware watchpoints.
5924 However, I don't think that the values returned by inferior
5925 function calls are special in any way. So this function may not
5926 notice that an expression involving an inferior function call
5927 can't be watched with hardware watchpoints. FIXME. */
5928 for (; v
; v
= value_next (v
))
5930 if (VALUE_LVAL (v
) == lval_memory
)
5933 /* A lazy memory lvalue is one that GDB never needed to fetch;
5934 we either just used its address (e.g., `a' in `a.b') or
5935 we never needed it at all (e.g., `a' in `a,b'). */
5939 /* Ahh, memory we actually used! Check if we can cover
5940 it with hardware watchpoints. */
5941 struct type
*vtype
= check_typedef (value_type (v
));
5943 /* We only watch structs and arrays if user asked for it
5944 explicitly, never if they just happen to appear in a
5945 middle of some value chain. */
5947 || (TYPE_CODE (vtype
) != TYPE_CODE_STRUCT
5948 && TYPE_CODE (vtype
) != TYPE_CODE_ARRAY
))
5950 CORE_ADDR vaddr
= VALUE_ADDRESS (v
) + value_offset (v
);
5951 int len
= TYPE_LENGTH (value_type (v
));
5953 if (!TARGET_REGION_OK_FOR_HW_WATCHPOINT (vaddr
, len
))
5960 else if (VALUE_LVAL (v
) != not_lval
5961 && deprecated_value_modifiable (v
) == 0)
5962 return 0; /* ??? What does this represent? */
5963 else if (VALUE_LVAL (v
) == lval_register
)
5964 return 0; /* cannot watch a register with a HW watchpoint */
5967 /* The expression itself looks suitable for using a hardware
5968 watchpoint, but give the target machine a chance to reject it. */
5969 return found_memory_cnt
;
5973 watch_command_wrapper (char *arg
, int from_tty
)
5975 watch_command (arg
, from_tty
);
5979 watch_command (char *arg
, int from_tty
)
5981 watch_command_1 (arg
, hw_write
, from_tty
);
5985 rwatch_command_wrapper (char *arg
, int from_tty
)
5987 rwatch_command (arg
, from_tty
);
5991 rwatch_command (char *arg
, int from_tty
)
5993 watch_command_1 (arg
, hw_read
, from_tty
);
5997 awatch_command_wrapper (char *arg
, int from_tty
)
5999 awatch_command (arg
, from_tty
);
6003 awatch_command (char *arg
, int from_tty
)
6005 watch_command_1 (arg
, hw_access
, from_tty
);
6009 /* Helper routines for the until_command routine in infcmd.c. Here
6010 because it uses the mechanisms of breakpoints. */
6012 /* This function is called by fetch_inferior_event via the
6013 cmd_continuation pointer, to complete the until command. It takes
6014 care of cleaning up the temporary breakpoints set up by the until
6017 until_break_command_continuation (struct continuation_arg
*arg
)
6019 struct cleanup
*cleanups
;
6021 cleanups
= (struct cleanup
*) arg
->data
.pointer
;
6022 do_exec_cleanups (cleanups
);
6026 until_break_command (char *arg
, int from_tty
, int anywhere
)
6028 struct symtabs_and_lines sals
;
6029 struct symtab_and_line sal
;
6030 struct frame_info
*frame
= get_selected_frame (NULL
);
6031 struct frame_info
*prev_frame
= get_prev_frame (frame
);
6032 struct breakpoint
*breakpoint
;
6033 struct cleanup
*old_chain
;
6034 struct continuation_arg
*arg1
;
6037 clear_proceed_status ();
6039 /* Set a breakpoint where the user wants it and at return from
6042 if (default_breakpoint_valid
)
6043 sals
= decode_line_1 (&arg
, 1, default_breakpoint_symtab
,
6044 default_breakpoint_line
, (char ***) NULL
, NULL
);
6046 sals
= decode_line_1 (&arg
, 1, (struct symtab
*) NULL
,
6047 0, (char ***) NULL
, NULL
);
6049 if (sals
.nelts
!= 1)
6050 error (_("Couldn't get information on specified line."));
6053 xfree (sals
.sals
); /* malloc'd, so freed */
6056 error (_("Junk at end of arguments."));
6058 resolve_sal_pc (&sal
);
6061 /* If the user told us to continue until a specified location,
6062 we don't specify a frame at which we need to stop. */
6063 breakpoint
= set_momentary_breakpoint (sal
, null_frame_id
, bp_until
);
6065 /* Otherwise, specify the current frame, because we want to stop only
6066 at the very same frame. */
6067 breakpoint
= set_momentary_breakpoint (sal
, get_frame_id (frame
),
6070 if (!target_can_async_p ())
6071 old_chain
= make_cleanup_delete_breakpoint (breakpoint
);
6073 old_chain
= make_exec_cleanup_delete_breakpoint (breakpoint
);
6075 /* If we are running asynchronously, and the target supports async
6076 execution, we are not waiting for the target to stop, in the call
6077 tp proceed, below. This means that we cannot delete the
6078 brekpoints until the target has actually stopped. The only place
6079 where we get a chance to do that is in fetch_inferior_event, so
6080 we must set things up for that. */
6082 if (target_can_async_p ())
6084 /* In this case the arg for the continuation is just the point
6085 in the exec_cleanups chain from where to start doing
6086 cleanups, because all the continuation does is the cleanups in
6087 the exec_cleanup_chain. */
6089 (struct continuation_arg
*) xmalloc (sizeof (struct continuation_arg
));
6091 arg1
->data
.pointer
= old_chain
;
6093 add_continuation (until_break_command_continuation
, arg1
);
6096 /* Keep within the current frame, or in frames called by the current
6100 sal
= find_pc_line (get_frame_pc (prev_frame
), 0);
6101 sal
.pc
= get_frame_pc (prev_frame
);
6102 breakpoint
= set_momentary_breakpoint (sal
, get_frame_id (prev_frame
),
6104 if (!target_can_async_p ())
6105 make_cleanup_delete_breakpoint (breakpoint
);
6107 make_exec_cleanup_delete_breakpoint (breakpoint
);
6110 proceed (-1, TARGET_SIGNAL_DEFAULT
, 0);
6111 /* Do the cleanups now, anly if we are not running asynchronously,
6112 of if we are, but the target is still synchronous. */
6113 if (!target_can_async_p ())
6114 do_cleanups (old_chain
);
6118 ep_skip_leading_whitespace (char **s
)
6120 if ((s
== NULL
) || (*s
== NULL
))
6122 while (isspace (**s
))
6126 /* This function examines a string, and attempts to find a token
6127 that might be an event name in the leading characters. If a
6128 possible match is found, a pointer to the last character of
6129 the token is returned. Else, NULL is returned. */
6132 ep_find_event_name_end (char *arg
)
6135 char *event_name_end
= NULL
;
6137 /* If we could depend upon the presense of strrpbrk, we'd use that... */
6141 /* We break out of the loop when we find a token delimiter.
6142 Basically, we're looking for alphanumerics and underscores;
6143 anything else delimites the token. */
6146 if (!isalnum (*s
) && (*s
!= '_'))
6152 return event_name_end
;
6156 /* This function attempts to parse an optional "if <cond>" clause
6157 from the arg string. If one is not found, it returns NULL.
6159 Else, it returns a pointer to the condition string. (It does not
6160 attempt to evaluate the string against a particular block.) And,
6161 it updates arg to point to the first character following the parsed
6162 if clause in the arg string. */
6165 ep_parse_optional_if_clause (char **arg
)
6169 if (((*arg
)[0] != 'i') || ((*arg
)[1] != 'f') || !isspace ((*arg
)[2]))
6172 /* Skip the "if" keyword. */
6175 /* Skip any extra leading whitespace, and record the start of the
6176 condition string. */
6177 ep_skip_leading_whitespace (arg
);
6180 /* Assume that the condition occupies the remainder of the arg string. */
6181 (*arg
) += strlen (cond_string
);
6186 /* This function attempts to parse an optional filename from the arg
6187 string. If one is not found, it returns NULL.
6189 Else, it returns a pointer to the parsed filename. (This function
6190 makes no attempt to verify that a file of that name exists, or is
6191 accessible.) And, it updates arg to point to the first character
6192 following the parsed filename in the arg string.
6194 Note that clients needing to preserve the returned filename for
6195 future access should copy it to their own buffers. */
6197 ep_parse_optional_filename (char **arg
)
6199 static char filename
[1024];
6204 if ((*arg_p
== '\0') || isspace (*arg_p
))
6222 /* Commands to deal with catching events, such as signals, exceptions,
6223 process start/exit, etc. */
6227 catch_fork
, catch_vfork
6232 catch_fork_command_1 (catch_fork_kind fork_kind
, char *arg
, int tempflag
,
6235 char *cond_string
= NULL
;
6237 ep_skip_leading_whitespace (&arg
);
6239 /* The allowed syntax is:
6241 catch [v]fork if <cond>
6243 First, check if there's an if clause. */
6244 cond_string
= ep_parse_optional_if_clause (&arg
);
6246 if ((*arg
!= '\0') && !isspace (*arg
))
6247 error (_("Junk at end of arguments."));
6249 /* If this target supports it, create a fork or vfork catchpoint
6250 and enable reporting of such events. */
6254 create_fork_event_catchpoint (tempflag
, cond_string
);
6257 create_vfork_event_catchpoint (tempflag
, cond_string
);
6260 error (_("unsupported or unknown fork kind; cannot catch it"));
6266 catch_exec_command_1 (char *arg
, int tempflag
, int from_tty
)
6268 char *cond_string
= NULL
;
6270 ep_skip_leading_whitespace (&arg
);
6272 /* The allowed syntax is:
6274 catch exec if <cond>
6276 First, check if there's an if clause. */
6277 cond_string
= ep_parse_optional_if_clause (&arg
);
6279 if ((*arg
!= '\0') && !isspace (*arg
))
6280 error (_("Junk at end of arguments."));
6282 /* If this target supports it, create an exec catchpoint
6283 and enable reporting of such events. */
6284 create_exec_event_catchpoint (tempflag
, cond_string
);
6288 catch_load_command_1 (char *arg
, int tempflag
, int from_tty
)
6290 char *dll_pathname
= NULL
;
6291 char *cond_string
= NULL
;
6293 ep_skip_leading_whitespace (&arg
);
6295 /* The allowed syntax is:
6297 catch load if <cond>
6298 catch load <filename>
6299 catch load <filename> if <cond>
6301 The user is not allowed to specify the <filename> after an
6304 We'll ignore the pathological case of a file named "if".
6306 First, check if there's an if clause. If so, then there
6307 cannot be a filename. */
6308 cond_string
= ep_parse_optional_if_clause (&arg
);
6310 /* If there was an if clause, then there cannot be a filename.
6311 Else, there might be a filename and an if clause. */
6312 if (cond_string
== NULL
)
6314 dll_pathname
= ep_parse_optional_filename (&arg
);
6315 ep_skip_leading_whitespace (&arg
);
6316 cond_string
= ep_parse_optional_if_clause (&arg
);
6319 if ((*arg
!= '\0') && !isspace (*arg
))
6320 error (_("Junk at end of arguments."));
6322 /* Create a load breakpoint that only triggers when a load of
6323 the specified dll (or any dll, if no pathname was specified)
6325 SOLIB_CREATE_CATCH_LOAD_HOOK (PIDGET (inferior_ptid
), tempflag
,
6326 dll_pathname
, cond_string
);
6330 catch_unload_command_1 (char *arg
, int tempflag
, int from_tty
)
6332 char *dll_pathname
= NULL
;
6333 char *cond_string
= NULL
;
6335 ep_skip_leading_whitespace (&arg
);
6337 /* The allowed syntax is:
6339 catch unload if <cond>
6340 catch unload <filename>
6341 catch unload <filename> if <cond>
6343 The user is not allowed to specify the <filename> after an
6346 We'll ignore the pathological case of a file named "if".
6348 First, check if there's an if clause. If so, then there
6349 cannot be a filename. */
6350 cond_string
= ep_parse_optional_if_clause (&arg
);
6352 /* If there was an if clause, then there cannot be a filename.
6353 Else, there might be a filename and an if clause. */
6354 if (cond_string
== NULL
)
6356 dll_pathname
= ep_parse_optional_filename (&arg
);
6357 ep_skip_leading_whitespace (&arg
);
6358 cond_string
= ep_parse_optional_if_clause (&arg
);
6361 if ((*arg
!= '\0') && !isspace (*arg
))
6362 error (_("Junk at end of arguments."));
6364 /* Create an unload breakpoint that only triggers when an unload of
6365 the specified dll (or any dll, if no pathname was specified)
6367 SOLIB_CREATE_CATCH_UNLOAD_HOOK (PIDGET (inferior_ptid
), tempflag
,
6368 dll_pathname
, cond_string
);
6371 static enum print_stop_action
6372 print_exception_catchpoint (struct breakpoint
*b
)
6374 annotate_catchpoint (b
->number
);
6376 if (strstr (b
->addr_string
, "throw") != NULL
)
6377 printf_filtered (_("\nCatchpoint %d (exception thrown)\n"),
6380 printf_filtered (_("\nCatchpoint %d (exception caught)\n"),
6383 return PRINT_SRC_AND_LOC
;
6387 print_one_exception_catchpoint (struct breakpoint
*b
, CORE_ADDR
*last_addr
)
6392 ui_out_field_core_addr (uiout
, "addr", b
->loc
->address
);
6395 *last_addr
= b
->loc
->address
;
6396 if (strstr (b
->addr_string
, "throw") != NULL
)
6397 ui_out_field_string (uiout
, "what", "exception throw");
6399 ui_out_field_string (uiout
, "what", "exception catch");
6403 print_mention_exception_catchpoint (struct breakpoint
*b
)
6405 if (strstr (b
->addr_string
, "throw") != NULL
)
6406 printf_filtered (_("Catchpoint %d (throw)"), b
->number
);
6408 printf_filtered (_("Catchpoint %d (catch)"), b
->number
);
6411 static struct breakpoint_ops gnu_v3_exception_catchpoint_ops
= {
6412 print_exception_catchpoint
,
6413 print_one_exception_catchpoint
,
6414 print_mention_exception_catchpoint
6418 handle_gnu_v3_exceptions (int tempflag
, char *cond_string
,
6419 enum exception_event_kind ex_event
, int from_tty
)
6421 char *trigger_func_name
, *nameptr
;
6422 struct symtabs_and_lines sals
;
6423 struct breakpoint
*b
;
6425 if (ex_event
== EX_EVENT_CATCH
)
6426 trigger_func_name
= xstrdup ("__cxa_begin_catch");
6428 trigger_func_name
= xstrdup ("__cxa_throw");
6430 nameptr
= trigger_func_name
;
6431 sals
= decode_line_1 (&nameptr
, 1, NULL
, 0, NULL
, NULL
);
6432 if (sals
.nelts
== 0)
6434 xfree (trigger_func_name
);
6438 b
= set_raw_breakpoint (sals
.sals
[0], bp_breakpoint
);
6439 set_breakpoint_count (breakpoint_count
+ 1);
6440 b
->number
= breakpoint_count
;
6441 b
->cond_string
= (cond_string
== NULL
) ?
6442 NULL
: savestring (cond_string
, strlen (cond_string
));
6444 b
->addr_string
= trigger_func_name
;
6445 b
->enable_state
= bp_enabled
;
6446 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
6447 b
->ops
= &gnu_v3_exception_catchpoint_ops
;
6454 /* Deal with "catch catch" and "catch throw" commands */
6457 catch_exception_command_1 (enum exception_event_kind ex_event
, char *arg
,
6458 int tempflag
, int from_tty
)
6460 char *cond_string
= NULL
;
6461 struct symtab_and_line
*sal
= NULL
;
6463 ep_skip_leading_whitespace (&arg
);
6465 cond_string
= ep_parse_optional_if_clause (&arg
);
6467 if ((*arg
!= '\0') && !isspace (*arg
))
6468 error (_("Junk at end of arguments."));
6470 if ((ex_event
!= EX_EVENT_THROW
) &&
6471 (ex_event
!= EX_EVENT_CATCH
))
6472 error (_("Unsupported or unknown exception event; cannot catch it"));
6474 if (handle_gnu_v3_exceptions (tempflag
, cond_string
, ex_event
, from_tty
))
6477 warning (_("Unsupported with this platform/compiler combination."));
6480 /* Create a breakpoint struct for Ada exception catchpoints. */
6483 create_ada_exception_breakpoint (struct symtab_and_line sal
,
6487 struct expression
*cond
,
6488 struct breakpoint_ops
*ops
,
6492 struct breakpoint
*b
;
6496 describe_other_breakpoints (sal
.pc
, sal
.section
, -1);
6497 /* FIXME: brobecker/2006-12-28: Actually, re-implement a special
6498 version for exception catchpoints, because two catchpoints
6499 used for different exception names will use the same address.
6500 In this case, a "breakpoint ... also set at..." warning is
6501 unproductive. Besides. the warning phrasing is also a bit
6502 inapropriate, we should use the word catchpoint, and tell
6503 the user what type of catchpoint it is. The above is good
6504 enough for now, though. */
6507 b
= set_raw_breakpoint (sal
, bp_breakpoint
);
6508 set_breakpoint_count (breakpoint_count
+ 1);
6510 b
->enable_state
= bp_enabled
;
6511 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
6512 b
->number
= breakpoint_count
;
6513 b
->ignore_count
= 0;
6514 b
->loc
->cond
= cond
;
6515 b
->addr_string
= addr_string
;
6516 b
->language
= language_ada
;
6517 b
->cond_string
= cond_string
;
6518 b
->exp_string
= exp_string
;
6525 /* Implement the "catch exception" command. */
6528 catch_ada_exception_command (char *arg
, int tempflag
, int from_tty
)
6530 struct symtab_and_line sal
;
6532 char *addr_string
= NULL
;
6533 char *exp_string
= NULL
;
6534 char *cond_string
= NULL
;
6535 struct expression
*cond
= NULL
;
6536 struct breakpoint_ops
*ops
= NULL
;
6538 sal
= ada_decode_exception_location (arg
, &addr_string
, &exp_string
,
6539 &cond_string
, &cond
, &ops
);
6540 create_ada_exception_breakpoint (sal
, addr_string
, exp_string
,
6541 cond_string
, cond
, ops
, tempflag
,
6545 /* Implement the "catch assert" command. */
6548 catch_assert_command (char *arg
, int tempflag
, int from_tty
)
6550 struct symtab_and_line sal
;
6551 char *addr_string
= NULL
;
6552 struct breakpoint_ops
*ops
= NULL
;
6554 sal
= ada_decode_assert_location (arg
, &addr_string
, &ops
);
6555 create_ada_exception_breakpoint (sal
, addr_string
, NULL
, NULL
, NULL
, ops
,
6556 tempflag
, from_tty
);
6560 catch_command_1 (char *arg
, int tempflag
, int from_tty
)
6563 /* The first argument may be an event name, such as "start" or "load".
6564 If so, then handle it as such. If it doesn't match an event name,
6565 then attempt to interpret it as an exception name. (This latter is
6566 the v4.16-and-earlier GDB meaning of the "catch" command.)
6568 First, try to find the bounds of what might be an event name. */
6569 char *arg1_start
= arg
;
6573 if (arg1_start
== NULL
)
6575 /* Old behaviour was to use pre-v-4.16 syntax */
6576 /* catch_throw_command_1 (arg1_start, tempflag, from_tty); */
6578 /* Now, this is not allowed */
6579 error (_("Catch requires an event name."));
6582 arg1_end
= ep_find_event_name_end (arg1_start
);
6583 if (arg1_end
== NULL
)
6584 error (_("catch requires an event"));
6585 arg1_length
= arg1_end
+ 1 - arg1_start
;
6587 /* Try to match what we found against known event names. */
6588 if (strncmp (arg1_start
, "signal", arg1_length
) == 0)
6590 error (_("Catch of signal not yet implemented"));
6592 else if (strncmp (arg1_start
, "catch", arg1_length
) == 0)
6594 catch_exception_command_1 (EX_EVENT_CATCH
, arg1_end
+ 1,
6595 tempflag
, from_tty
);
6597 else if (strncmp (arg1_start
, "throw", arg1_length
) == 0)
6599 catch_exception_command_1 (EX_EVENT_THROW
, arg1_end
+ 1,
6600 tempflag
, from_tty
);
6602 else if (strncmp (arg1_start
, "thread_start", arg1_length
) == 0)
6604 error (_("Catch of thread_start not yet implemented"));
6606 else if (strncmp (arg1_start
, "thread_exit", arg1_length
) == 0)
6608 error (_("Catch of thread_exit not yet implemented"));
6610 else if (strncmp (arg1_start
, "thread_join", arg1_length
) == 0)
6612 error (_("Catch of thread_join not yet implemented"));
6614 else if (strncmp (arg1_start
, "start", arg1_length
) == 0)
6616 error (_("Catch of start not yet implemented"));
6618 else if (strncmp (arg1_start
, "exit", arg1_length
) == 0)
6620 error (_("Catch of exit not yet implemented"));
6622 else if (strncmp (arg1_start
, "fork", arg1_length
) == 0)
6624 catch_fork_command_1 (catch_fork
, arg1_end
+ 1, tempflag
, from_tty
);
6626 else if (strncmp (arg1_start
, "vfork", arg1_length
) == 0)
6628 catch_fork_command_1 (catch_vfork
, arg1_end
+ 1, tempflag
, from_tty
);
6630 else if (strncmp (arg1_start
, "exec", arg1_length
) == 0)
6632 catch_exec_command_1 (arg1_end
+ 1, tempflag
, from_tty
);
6634 else if (strncmp (arg1_start
, "load", arg1_length
) == 0)
6636 catch_load_command_1 (arg1_end
+ 1, tempflag
, from_tty
);
6638 else if (strncmp (arg1_start
, "unload", arg1_length
) == 0)
6640 catch_unload_command_1 (arg1_end
+ 1, tempflag
, from_tty
);
6642 else if (strncmp (arg1_start
, "stop", arg1_length
) == 0)
6644 error (_("Catch of stop not yet implemented"));
6646 else if (strncmp (arg1_start
, "exception", arg1_length
) == 0)
6648 catch_ada_exception_command (arg1_end
+ 1, tempflag
, from_tty
);
6651 else if (strncmp (arg1_start
, "assert", arg1_length
) == 0)
6653 catch_assert_command (arg1_end
+ 1, tempflag
, from_tty
);
6656 /* This doesn't appear to be an event name */
6660 /* Pre-v.4.16 behaviour was to treat the argument
6661 as the name of an exception */
6662 /* catch_throw_command_1 (arg1_start, tempflag, from_tty); */
6663 /* Now this is not allowed */
6664 error (_("Unknown event kind specified for catch"));
6670 catch_command (char *arg
, int from_tty
)
6672 catch_command_1 (arg
, 0, from_tty
);
6677 tcatch_command (char *arg
, int from_tty
)
6679 catch_command_1 (arg
, 1, from_tty
);
6682 /* Delete breakpoints by address or line. */
6685 clear_command (char *arg
, int from_tty
)
6687 struct breakpoint
*b
;
6688 VEC(breakpoint_p
) *found
= 0;
6691 struct symtabs_and_lines sals
;
6692 struct symtab_and_line sal
;
6697 sals
= decode_line_spec (arg
, 1);
6702 sals
.sals
= (struct symtab_and_line
*)
6703 xmalloc (sizeof (struct symtab_and_line
));
6704 make_cleanup (xfree
, sals
.sals
);
6705 init_sal (&sal
); /* initialize to zeroes */
6706 sal
.line
= default_breakpoint_line
;
6707 sal
.symtab
= default_breakpoint_symtab
;
6708 sal
.pc
= default_breakpoint_address
;
6709 if (sal
.symtab
== 0)
6710 error (_("No source file specified."));
6718 /* We don't call resolve_sal_pc here. That's not
6719 as bad as it seems, because all existing breakpoints
6720 typically have both file/line and pc set. So, if
6721 clear is given file/line, we can match this to existing
6722 breakpoint without obtaining pc at all.
6724 We only support clearing given the address explicitly
6725 present in breakpoint table. Say, we've set breakpoint
6726 at file:line. There were several PC values for that file:line,
6727 due to optimization, all in one block.
6728 We've picked one PC value. If "clear" is issued with another
6729 PC corresponding to the same file:line, the breakpoint won't
6730 be cleared. We probably can still clear the breakpoint, but
6731 since the other PC value is never presented to user, user
6732 can only find it by guessing, and it does not seem important
6735 /* For each line spec given, delete bps which correspond
6736 to it. Do it in two passes, solely to preserve the current
6737 behavior that from_tty is forced true if we delete more than
6741 for (i
= 0; i
< sals
.nelts
; i
++)
6743 /* If exact pc given, clear bpts at that pc.
6744 If line given (pc == 0), clear all bpts on specified line.
6745 If defaulting, clear all bpts on default line
6748 defaulting sal.pc != 0 tests to do
6753 1 0 <can't happen> */
6757 /* Find all matching breakpoints and add them to
6762 /* Are we going to delete b? */
6763 if (b
->type
!= bp_none
6764 && b
->type
!= bp_watchpoint
6765 && b
->type
!= bp_hardware_watchpoint
6766 && b
->type
!= bp_read_watchpoint
6767 && b
->type
!= bp_access_watchpoint
)
6769 struct bp_location
*loc
= b
->loc
;
6770 for (; loc
; loc
= loc
->next
)
6772 int pc_match
= sal
.pc
6773 && (loc
->address
== sal
.pc
)
6774 && (!section_is_overlay (loc
->section
)
6775 || loc
->section
== sal
.section
);
6776 int line_match
= ((default_match
|| (0 == sal
.pc
))
6777 && b
->source_file
!= NULL
6778 && sal
.symtab
!= NULL
6779 && strcmp (b
->source_file
, sal
.symtab
->filename
) == 0
6780 && b
->line_number
== sal
.line
);
6781 if (pc_match
|| line_match
)
6790 VEC_safe_push(breakpoint_p
, found
, b
);
6793 /* Now go thru the 'found' chain and delete them. */
6794 if (VEC_empty(breakpoint_p
, found
))
6797 error (_("No breakpoint at %s."), arg
);
6799 error (_("No breakpoint at this line."));
6802 if (VEC_length(breakpoint_p
, found
) > 1)
6803 from_tty
= 1; /* Always report if deleted more than one */
6806 if (VEC_length(breakpoint_p
, found
) == 1)
6807 printf_unfiltered (_("Deleted breakpoint "));
6809 printf_unfiltered (_("Deleted breakpoints "));
6811 breakpoints_changed ();
6813 for (ix
= 0; VEC_iterate(breakpoint_p
, found
, ix
, b
); ix
++)
6816 printf_unfiltered ("%d ", b
->number
);
6817 delete_breakpoint (b
);
6820 putchar_unfiltered ('\n');
6823 /* Delete breakpoint in BS if they are `delete' breakpoints and
6824 all breakpoints that are marked for deletion, whether hit or not.
6825 This is called after any breakpoint is hit, or after errors. */
6828 breakpoint_auto_delete (bpstat bs
)
6830 struct breakpoint
*b
, *temp
;
6832 for (; bs
; bs
= bs
->next
)
6833 if (bs
->breakpoint_at
&& bs
->breakpoint_at
->owner
->disposition
== disp_del
6835 delete_breakpoint (bs
->breakpoint_at
->owner
);
6837 ALL_BREAKPOINTS_SAFE (b
, temp
)
6839 if (b
->disposition
== disp_del_at_next_stop
)
6840 delete_breakpoint (b
);
6844 /* Remove locations of breakpoint BPT from
6845 the global list of breakpoint locations. */
6848 unlink_locations_from_global_list (struct breakpoint
*bpt
)
6850 /* This code assumes that the locations
6851 of a breakpoint are found in the global list
6852 in the same order, but not necessary adjacent. */
6853 struct bp_location
**tmp
= &bp_location_chain
;
6854 struct bp_location
*here
= bpt
->loc
;
6859 for (; *tmp
&& here
;)
6863 *tmp
= here
->global_next
;
6868 tmp
= &((*tmp
)->global_next
);
6873 /* Delete a breakpoint and clean up all traces of it in the data
6877 delete_breakpoint (struct breakpoint
*bpt
)
6879 struct breakpoint
*b
;
6881 struct bp_location
*loc
;
6883 gdb_assert (bpt
!= NULL
);
6885 /* Has this bp already been deleted? This can happen because multiple
6886 lists can hold pointers to bp's. bpstat lists are especial culprits.
6888 One example of this happening is a watchpoint's scope bp. When the
6889 scope bp triggers, we notice that the watchpoint is out of scope, and
6890 delete it. We also delete its scope bp. But the scope bp is marked
6891 "auto-deleting", and is already on a bpstat. That bpstat is then
6892 checked for auto-deleting bp's, which are deleted.
6894 A real solution to this problem might involve reference counts in bp's,
6895 and/or giving them pointers back to their referencing bpstat's, and
6896 teaching delete_breakpoint to only free a bp's storage when no more
6897 references were extent. A cheaper bandaid was chosen. */
6898 if (bpt
->type
== bp_none
)
6901 if (deprecated_delete_breakpoint_hook
)
6902 deprecated_delete_breakpoint_hook (bpt
);
6903 breakpoint_delete_event (bpt
->number
);
6905 for (loc
= bpt
->loc
; loc
; loc
= loc
->next
)
6908 remove_breakpoint (loc
, mark_inserted
);
6913 if (loc
->function_name
)
6914 xfree (loc
->function_name
);
6917 if (breakpoint_chain
== bpt
)
6918 breakpoint_chain
= bpt
->next
;
6923 b
->next
= bpt
->next
;
6927 unlink_locations_from_global_list (bpt
);
6929 check_duplicates (bpt
);
6931 if (bpt
->type
!= bp_hardware_watchpoint
6932 && bpt
->type
!= bp_read_watchpoint
6933 && bpt
->type
!= bp_access_watchpoint
6934 && bpt
->type
!= bp_catch_fork
6935 && bpt
->type
!= bp_catch_vfork
6936 && bpt
->type
!= bp_catch_exec
)
6937 for (loc
= bpt
->loc
; loc
; loc
= loc
->next
)
6939 /* If this breakpoint location was inserted, and there is
6940 another breakpoint at the same address, we need to
6941 insert the other breakpoint. */
6944 struct bp_location
*loc2
;
6945 ALL_BP_LOCATIONS (loc2
)
6946 if (loc2
->address
== loc
->address
6947 && loc2
->section
== loc
->section
6949 && loc2
->owner
->enable_state
!= bp_disabled
6951 && !loc2
->shlib_disabled
6952 && loc2
->owner
->enable_state
!= bp_call_disabled
)
6956 /* We should never reach this point if there is a permanent
6957 breakpoint at the same address as the one being deleted.
6958 If there is a permanent breakpoint somewhere, it should
6959 always be the only one inserted. */
6960 if (loc2
->owner
->enable_state
== bp_permanent
)
6961 internal_error (__FILE__
, __LINE__
,
6962 _("another breakpoint was inserted on top of "
6963 "a permanent breakpoint"));
6965 memset (&loc2
->target_info
, 0, sizeof (loc2
->target_info
));
6966 loc2
->target_info
.placed_address
= loc2
->address
;
6967 if (b
->type
== bp_hardware_breakpoint
)
6968 val
= target_insert_hw_breakpoint (&loc2
->target_info
);
6970 val
= target_insert_breakpoint (&loc2
->target_info
);
6972 /* If there was an error in the insert, print a message, then stop execution. */
6975 struct ui_file
*tmp_error_stream
= mem_fileopen ();
6976 make_cleanup_ui_file_delete (tmp_error_stream
);
6979 if (b
->type
== bp_hardware_breakpoint
)
6981 fprintf_unfiltered (tmp_error_stream
,
6982 "Cannot insert hardware breakpoint %d.\n"
6983 "You may have requested too many hardware breakpoints.\n",
6988 fprintf_unfiltered (tmp_error_stream
, "Cannot insert breakpoint %d.\n", b
->number
);
6989 fprintf_filtered (tmp_error_stream
, "Error accessing memory address ");
6990 fputs_filtered (paddress (loc2
->address
),
6992 fprintf_filtered (tmp_error_stream
, ": %s.\n",
6993 safe_strerror (val
));
6996 fprintf_unfiltered (tmp_error_stream
,"The same program may be running in another process.");
6997 target_terminal_ours_for_output ();
6998 error_stream(tmp_error_stream
);
7006 free_command_lines (&bpt
->commands
);
7007 if (bpt
->cond_string
!= NULL
)
7008 xfree (bpt
->cond_string
);
7009 if (bpt
->addr_string
!= NULL
)
7010 xfree (bpt
->addr_string
);
7011 if (bpt
->exp
!= NULL
)
7013 if (bpt
->exp_string
!= NULL
)
7014 xfree (bpt
->exp_string
);
7015 if (bpt
->val
!= NULL
)
7016 value_free (bpt
->val
);
7017 if (bpt
->source_file
!= NULL
)
7018 xfree (bpt
->source_file
);
7019 if (bpt
->dll_pathname
!= NULL
)
7020 xfree (bpt
->dll_pathname
);
7021 if (bpt
->triggered_dll_pathname
!= NULL
)
7022 xfree (bpt
->triggered_dll_pathname
);
7023 if (bpt
->exec_pathname
!= NULL
)
7024 xfree (bpt
->exec_pathname
);
7026 /* Be sure no bpstat's are pointing at it after it's been freed. */
7027 /* FIXME, how can we find all bpstat's?
7028 We just check stop_bpstat for now. Note that we cannot just
7029 remove bpstats pointing at bpt from the stop_bpstat list
7030 entirely, as breakpoint commands are associated with the bpstat;
7031 if we remove it here, then the later call to
7032 bpstat_do_actions (&stop_bpstat);
7033 in event-top.c won't do anything, and temporary breakpoints
7034 with commands won't work. */
7035 for (bs
= stop_bpstat
; bs
; bs
= bs
->next
)
7036 if (bs
->breakpoint_at
&& bs
->breakpoint_at
->owner
== bpt
)
7038 bs
->breakpoint_at
= NULL
;
7040 /* bs->commands will be freed later. */
7042 /* On the chance that someone will soon try again to delete this same
7043 bp, we mark it as deleted before freeing its storage. */
7044 bpt
->type
= bp_none
;
7046 for (loc
= bpt
->loc
; loc
;)
7048 struct bp_location
*loc_next
= loc
->next
;
7056 do_delete_breakpoint_cleanup (void *b
)
7058 delete_breakpoint (b
);
7062 make_cleanup_delete_breakpoint (struct breakpoint
*b
)
7064 return make_cleanup (do_delete_breakpoint_cleanup
, b
);
7068 make_exec_cleanup_delete_breakpoint (struct breakpoint
*b
)
7070 return make_exec_cleanup (do_delete_breakpoint_cleanup
, b
);
7074 delete_command (char *arg
, int from_tty
)
7076 struct breakpoint
*b
, *temp
;
7082 int breaks_to_delete
= 0;
7084 /* Delete all breakpoints if no argument.
7085 Do not delete internal or call-dummy breakpoints, these
7086 have to be deleted with an explicit breakpoint number argument. */
7089 if (b
->type
!= bp_call_dummy
&&
7090 b
->type
!= bp_shlib_event
&&
7091 b
->type
!= bp_thread_event
&&
7092 b
->type
!= bp_overlay_event
&&
7095 breaks_to_delete
= 1;
7100 /* Ask user only if there are some breakpoints to delete. */
7102 || (breaks_to_delete
&& query (_("Delete all breakpoints? "))))
7104 ALL_BREAKPOINTS_SAFE (b
, temp
)
7106 if (b
->type
!= bp_call_dummy
&&
7107 b
->type
!= bp_shlib_event
&&
7108 b
->type
!= bp_thread_event
&&
7109 b
->type
!= bp_overlay_event
&&
7111 delete_breakpoint (b
);
7116 map_breakpoint_numbers (arg
, delete_breakpoint
);
7120 all_locations_are_pending (struct bp_location
*loc
)
7122 for (; loc
; loc
= loc
->next
)
7123 if (!loc
->shlib_disabled
)
7128 /* Subroutine of update_breakpoint_locations to simplify it.
7129 Return non-zero if multiple fns in list LOC have the same name.
7130 Null names are ignored. */
7133 ambiguous_names_p (struct bp_location
*loc
)
7135 struct bp_location
*l
;
7136 htab_t htab
= htab_create_alloc (13, htab_hash_string
,
7137 (int (*) (const void *, const void *)) streq
,
7138 NULL
, xcalloc
, xfree
);
7140 for (l
= loc
; l
!= NULL
; l
= l
->next
)
7143 const char *name
= l
->function_name
;
7145 /* Allow for some names to be NULL, ignore them. */
7149 slot
= (const char **) htab_find_slot (htab
, (const void *) name
,
7151 /* NOTE: We can assume slot != NULL here because xcalloc never returns
7166 update_breakpoint_locations (struct breakpoint
*b
,
7167 struct symtabs_and_lines sals
)
7171 struct bp_location
*existing_locations
= b
->loc
;
7173 /* If there's no new locations, and all existing locations
7174 are pending, don't do anything. This optimizes
7175 the common case where all locations are in the same
7176 shared library, that was unloaded. We'd like to
7177 retain the location, so that when the library
7178 is loaded again, we don't loose the enabled/disabled
7179 status of the individual locations. */
7180 if (all_locations_are_pending (existing_locations
) && sals
.nelts
== 0)
7183 unlink_locations_from_global_list (b
);
7186 for (i
= 0; i
< sals
.nelts
; ++i
)
7188 struct bp_location
*new_loc
=
7189 add_location_to_breakpoint (b
, b
->type
, &(sals
.sals
[i
]));
7191 /* Reparse conditions, they might contain references to the
7193 if (b
->cond_string
!= NULL
)
7195 struct gdb_exception e
;
7198 TRY_CATCH (e
, RETURN_MASK_ERROR
)
7200 new_loc
->cond
= parse_exp_1 (&s
, block_for_pc (sals
.sals
[i
].pc
),
7205 warning (_("failed to reevaluate condition for breakpoint %d: %s"),
7206 b
->number
, e
.message
);
7207 new_loc
->enabled
= 0;
7211 if (b
->source_file
!= NULL
)
7212 xfree (b
->source_file
);
7213 if (sals
.sals
[i
].symtab
== NULL
)
7214 b
->source_file
= NULL
;
7217 savestring (sals
.sals
[i
].symtab
->filename
,
7218 strlen (sals
.sals
[i
].symtab
->filename
));
7220 if (b
->line_number
== 0)
7221 b
->line_number
= sals
.sals
[i
].line
;
7224 /* If possible, carry over 'disable' status from existing breakpoints. */
7226 struct bp_location
*e
= existing_locations
;
7227 /* If there are multiple breakpoints with the same function name,
7228 e.g. for inline functions, comparing function names won't work.
7229 Instead compare pc addresses; this is just a heuristic as things
7230 may have moved, but in practice it gives the correct answer
7231 often enough until a better solution is found. */
7232 int have_ambiguous_names
= ambiguous_names_p (b
->loc
);
7234 for (; e
; e
= e
->next
)
7236 if (!e
->enabled
&& e
->function_name
)
7238 struct bp_location
*l
= b
->loc
;
7239 if (have_ambiguous_names
)
7241 for (; l
; l
= l
->next
)
7242 if (e
->address
== l
->address
)
7250 for (; l
; l
= l
->next
)
7251 if (l
->function_name
7252 && strcmp (e
->function_name
, l
->function_name
) == 0)
7262 while (existing_locations
)
7264 struct bp_location
*next
= existing_locations
->next
;
7265 free_bp_location (existing_locations
);
7266 existing_locations
= next
;
7271 /* Reset a breakpoint given it's struct breakpoint * BINT.
7272 The value we return ends up being the return value from catch_errors.
7273 Unused in this case. */
7276 breakpoint_re_set_one (void *bint
)
7278 /* get past catch_errs */
7279 struct breakpoint
*b
= (struct breakpoint
*) bint
;
7283 int *not_found_ptr
= ¬_found
;
7284 struct symtabs_and_lines sals
= {};
7285 struct symtabs_and_lines expanded
;
7287 enum enable_state save_enable
;
7288 struct gdb_exception e
;
7294 warning (_("attempted to reset apparently deleted breakpoint #%d?"),
7298 case bp_hardware_breakpoint
:
7300 case bp_catch_unload
:
7301 if (b
->addr_string
== NULL
)
7303 /* Anything without a string can't be re-set. */
7304 delete_breakpoint (b
);
7308 set_language (b
->language
);
7309 input_radix
= b
->input_radix
;
7311 TRY_CATCH (e
, RETURN_MASK_ERROR
)
7313 sals
= decode_line_1 (&s
, 1, (struct symtab
*) NULL
, 0, (char ***) NULL
,
7318 int not_found_and_ok
= 0;
7319 /* For pending breakpoints, it's expected that parsing
7320 will fail until the right shared library is loaded.
7321 User has already told to create pending breakpoints and
7322 don't need extra messages. If breakpoint is in bp_shlib_disabled
7323 state, then user already saw the message about that breakpoint
7324 being disabled, and don't want to see more errors. */
7326 && (b
->condition_not_parsed
7327 || (b
->loc
&& b
->loc
->shlib_disabled
)
7328 || b
->enable_state
== bp_disabled
))
7329 not_found_and_ok
= 1;
7331 if (!not_found_and_ok
)
7333 /* We surely don't want to warn about the same breakpoint
7334 10 times. One solution, implemented here, is disable
7335 the breakpoint on error. Another solution would be to
7336 have separate 'warning emitted' flag. Since this
7337 happens only when a binary has changed, I don't know
7338 which approach is better. */
7339 b
->enable_state
= bp_disabled
;
7340 throw_exception (e
);
7347 gdb_assert (sals
.nelts
== 1);
7348 resolve_sal_pc (&sals
.sals
[0]);
7349 if (b
->condition_not_parsed
&& s
&& s
[0])
7351 char *cond_string
= 0;
7353 find_condition_and_thread (s
, sals
.sals
[0].pc
,
7354 &cond_string
, &thread
);
7356 b
->cond_string
= cond_string
;
7358 b
->condition_not_parsed
= 0;
7360 expanded
= expand_line_sal_maybe (sals
.sals
[0]);
7361 update_breakpoint_locations (b
, expanded
);
7363 /* Now that this is re-enabled, check_duplicates
7365 check_duplicates (b
);
7371 case bp_hardware_watchpoint
:
7372 case bp_read_watchpoint
:
7373 case bp_access_watchpoint
:
7374 /* Watchpoint can be either on expression using entirely global variables,
7375 or it can be on local variables.
7377 Watchpoints of the first kind are never auto-deleted, and even persist
7378 across program restarts. Since they can use variables from shared
7379 libraries, we need to reparse expression as libraries are loaded
7382 Watchpoints on local variables can also change meaning as result
7383 of solib event. For example, if a watchpoint uses both a local and
7384 a global variables in expression, it's a local watchpoint, but
7385 unloading of a shared library will make the expression invalid.
7386 This is not a very common use case, but we still re-evaluate
7387 expression, to avoid surprises to the user.
7389 Note that for local watchpoints, we re-evaluate it only if
7390 watchpoints frame id is still valid. If it's not, it means
7391 the watchpoint is out of scope and will be deleted soon. In fact,
7392 I'm not sure we'll ever be called in this case.
7394 If a local watchpoint's frame id is still valid, then
7395 b->exp_valid_block is likewise valid, and we can safely use it.
7397 Don't do anything about disabled watchpoints, since they will
7398 be reevaluated again when enabled. */
7399 update_watchpoint (b
, 1 /* reparse */);
7401 /* We needn't really do anything to reset these, since the mask
7402 that requests them is unaffected by e.g., new libraries being
7405 case bp_catch_vfork
:
7410 printf_filtered (_("Deleting unknown breakpoint type %d\n"), b
->type
);
7412 /* Delete longjmp and overlay event breakpoints; they will be
7413 reset later by breakpoint_re_set. */
7415 case bp_longjmp_resume
:
7416 case bp_overlay_event
:
7417 delete_breakpoint (b
);
7420 /* This breakpoint is special, it's set up when the inferior
7421 starts and we really don't want to touch it. */
7422 case bp_shlib_event
:
7424 /* Like bp_shlib_event, this breakpoint type is special.
7425 Once it is set up, we do not want to touch it. */
7426 case bp_thread_event
:
7428 /* Keep temporary breakpoints, which can be encountered when we step
7429 over a dlopen call and SOLIB_ADD is resetting the breakpoints.
7430 Otherwise these should have been blown away via the cleanup chain
7431 or by breakpoint_init_inferior when we rerun the executable. */
7434 case bp_watchpoint_scope
:
7436 case bp_step_resume
:
7443 /* Re-set all breakpoints after symbols have been re-loaded. */
7445 breakpoint_re_set (void)
7447 struct breakpoint
*b
, *temp
;
7448 enum language save_language
;
7449 int save_input_radix
;
7451 save_language
= current_language
->la_language
;
7452 save_input_radix
= input_radix
;
7453 ALL_BREAKPOINTS_SAFE (b
, temp
)
7455 /* Format possible error msg */
7456 char *message
= xstrprintf ("Error in re-setting breakpoint %d: ",
7458 struct cleanup
*cleanups
= make_cleanup (xfree
, message
);
7459 catch_errors (breakpoint_re_set_one
, b
, message
, RETURN_MASK_ALL
);
7460 do_cleanups (cleanups
);
7462 set_language (save_language
);
7463 input_radix
= save_input_radix
;
7465 if (gdbarch_get_longjmp_target_p (current_gdbarch
))
7467 create_longjmp_breakpoint ("longjmp");
7468 create_longjmp_breakpoint ("_longjmp");
7469 create_longjmp_breakpoint ("siglongjmp");
7470 create_longjmp_breakpoint ("_siglongjmp");
7471 create_longjmp_breakpoint (NULL
);
7474 create_overlay_event_breakpoint ("_ovly_debug_event");
7477 /* Reset the thread number of this breakpoint:
7479 - If the breakpoint is for all threads, leave it as-is.
7480 - Else, reset it to the current thread for inferior_ptid. */
7482 breakpoint_re_set_thread (struct breakpoint
*b
)
7484 if (b
->thread
!= -1)
7486 if (in_thread_list (inferior_ptid
))
7487 b
->thread
= pid_to_thread_id (inferior_ptid
);
7491 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
7492 If from_tty is nonzero, it prints a message to that effect,
7493 which ends with a period (no newline). */
7496 set_ignore_count (int bptnum
, int count
, int from_tty
)
7498 struct breakpoint
*b
;
7504 if (b
->number
== bptnum
)
7506 b
->ignore_count
= count
;
7510 printf_filtered (_("Will stop next time breakpoint %d is reached."),
7512 else if (count
== 1)
7513 printf_filtered (_("Will ignore next crossing of breakpoint %d."),
7516 printf_filtered (_("Will ignore next %d crossings of breakpoint %d."),
7519 breakpoints_changed ();
7520 breakpoint_modify_event (b
->number
);
7524 error (_("No breakpoint number %d."), bptnum
);
7527 /* Clear the ignore counts of all breakpoints. */
7529 breakpoint_clear_ignore_counts (void)
7531 struct breakpoint
*b
;
7534 b
->ignore_count
= 0;
7537 /* Command to set ignore-count of breakpoint N to COUNT. */
7540 ignore_command (char *args
, int from_tty
)
7546 error_no_arg (_("a breakpoint number"));
7548 num
= get_number (&p
);
7550 error (_("bad breakpoint number: '%s'"), args
);
7552 error (_("Second argument (specified ignore-count) is missing."));
7554 set_ignore_count (num
,
7555 longest_to_int (value_as_long (parse_and_eval (p
))),
7558 printf_filtered ("\n");
7561 /* Call FUNCTION on each of the breakpoints
7562 whose numbers are given in ARGS. */
7565 map_breakpoint_numbers (char *args
, void (*function
) (struct breakpoint
*))
7570 struct breakpoint
*b
, *tmp
;
7574 error_no_arg (_("one or more breakpoint numbers"));
7581 num
= get_number_or_range (&p1
);
7584 warning (_("bad breakpoint number at or near '%s'"), p
);
7588 ALL_BREAKPOINTS_SAFE (b
, tmp
)
7589 if (b
->number
== num
)
7591 struct breakpoint
*related_breakpoint
= b
->related_breakpoint
;
7594 if (related_breakpoint
)
7595 function (related_breakpoint
);
7599 printf_unfiltered (_("No breakpoint number %d.\n"), num
);
7605 static struct bp_location
*
7606 find_location_by_number (char *number
)
7608 char *dot
= strchr (number
, '.');
7612 struct breakpoint
*b
;
7613 struct bp_location
*loc
;
7618 bp_num
= get_number_or_range (&p1
);
7620 error (_("Bad breakpoint number '%s'"), number
);
7623 if (b
->number
== bp_num
)
7628 if (!b
|| b
->number
!= bp_num
)
7629 error (_("Bad breakpoint number '%s'"), number
);
7632 loc_num
= get_number_or_range (&p1
);
7634 error (_("Bad breakpoint location number '%s'"), number
);
7638 for (;loc_num
&& loc
; --loc_num
, loc
= loc
->next
)
7641 error (_("Bad breakpoint location number '%s'"), dot
+1);
7647 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
7648 If from_tty is nonzero, it prints a message to that effect,
7649 which ends with a period (no newline). */
7652 disable_breakpoint (struct breakpoint
*bpt
)
7654 /* Never disable a watchpoint scope breakpoint; we want to
7655 hit them when we leave scope so we can delete both the
7656 watchpoint and its scope breakpoint at that time. */
7657 if (bpt
->type
== bp_watchpoint_scope
)
7660 /* You can't disable permanent breakpoints. */
7661 if (bpt
->enable_state
== bp_permanent
)
7664 bpt
->enable_state
= bp_disabled
;
7666 check_duplicates (bpt
);
7668 if (deprecated_modify_breakpoint_hook
)
7669 deprecated_modify_breakpoint_hook (bpt
);
7670 breakpoint_modify_event (bpt
->number
);
7674 disable_command (char *args
, int from_tty
)
7676 struct breakpoint
*bpt
;
7678 ALL_BREAKPOINTS (bpt
)
7682 warning (_("attempted to disable apparently deleted breakpoint #%d?"),
7687 case bp_catch_unload
:
7689 case bp_catch_vfork
:
7691 case bp_hardware_breakpoint
:
7693 case bp_hardware_watchpoint
:
7694 case bp_read_watchpoint
:
7695 case bp_access_watchpoint
:
7696 disable_breakpoint (bpt
);
7700 else if (strchr (args
, '.'))
7702 struct bp_location
*loc
= find_location_by_number (args
);
7705 check_duplicates (loc
->owner
);
7708 map_breakpoint_numbers (args
, disable_breakpoint
);
7712 do_enable_breakpoint (struct breakpoint
*bpt
, enum bpdisp disposition
)
7714 int target_resources_ok
, other_type_used
;
7717 if (bpt
->type
== bp_hardware_breakpoint
)
7720 i
= hw_breakpoint_used_count ();
7721 target_resources_ok
=
7722 TARGET_CAN_USE_HARDWARE_WATCHPOINT (bp_hardware_breakpoint
,
7724 if (target_resources_ok
== 0)
7725 error (_("No hardware breakpoint support in the target."));
7726 else if (target_resources_ok
< 0)
7727 error (_("Hardware breakpoints used exceeds limit."));
7730 if (bpt
->type
== bp_watchpoint
||
7731 bpt
->type
== bp_hardware_watchpoint
||
7732 bpt
->type
== bp_read_watchpoint
||
7733 bpt
->type
== bp_access_watchpoint
)
7735 struct frame_id saved_frame_id
;
7737 saved_frame_id
= get_frame_id (get_selected_frame (NULL
));
7738 if (bpt
->exp_valid_block
!= NULL
)
7740 struct frame_info
*fr
=
7741 fr
= frame_find_by_id (bpt
->watchpoint_frame
);
7744 printf_filtered (_("\
7745 Cannot enable watchpoint %d because the block in which its expression\n\
7746 is valid is not currently in scope.\n"), bpt
->number
);
7753 value_free (bpt
->val
);
7754 mark
= value_mark ();
7755 fetch_watchpoint_value (bpt
->exp
, &bpt
->val
, NULL
, NULL
);
7757 release_value (bpt
->val
);
7760 if (bpt
->type
== bp_hardware_watchpoint
||
7761 bpt
->type
== bp_read_watchpoint
||
7762 bpt
->type
== bp_access_watchpoint
)
7764 int i
= hw_watchpoint_used_count (bpt
->type
, &other_type_used
);
7765 int mem_cnt
= can_use_hardware_watchpoint (bpt
->val
);
7767 /* Hack around 'unused var' error for some targets here */
7768 (void) mem_cnt
, (void) i
;
7769 target_resources_ok
= TARGET_CAN_USE_HARDWARE_WATCHPOINT (
7770 bpt
->type
, i
+ mem_cnt
, other_type_used
);
7771 /* we can consider of type is bp_hardware_watchpoint, convert to
7772 bp_watchpoint in the following condition */
7773 if (target_resources_ok
< 0)
7775 printf_filtered (_("\
7776 Cannot enable watchpoint %d because target watch resources\n\
7777 have been allocated for other watchpoints.\n"), bpt
->number
);
7778 value_free_to_mark (mark
);
7783 select_frame (frame_find_by_id (saved_frame_id
));
7784 value_free_to_mark (mark
);
7787 if (bpt
->enable_state
!= bp_permanent
)
7788 bpt
->enable_state
= bp_enabled
;
7789 bpt
->disposition
= disposition
;
7790 check_duplicates (bpt
);
7791 breakpoints_changed ();
7793 if (deprecated_modify_breakpoint_hook
)
7794 deprecated_modify_breakpoint_hook (bpt
);
7795 breakpoint_modify_event (bpt
->number
);
7800 enable_breakpoint (struct breakpoint
*bpt
)
7802 do_enable_breakpoint (bpt
, bpt
->disposition
);
7805 /* The enable command enables the specified breakpoints (or all defined
7806 breakpoints) so they once again become (or continue to be) effective
7807 in stopping the inferior. */
7810 enable_command (char *args
, int from_tty
)
7812 struct breakpoint
*bpt
;
7814 ALL_BREAKPOINTS (bpt
)
7818 warning (_("attempted to enable apparently deleted breakpoint #%d?"),
7823 case bp_catch_unload
:
7825 case bp_catch_vfork
:
7827 case bp_hardware_breakpoint
:
7829 case bp_hardware_watchpoint
:
7830 case bp_read_watchpoint
:
7831 case bp_access_watchpoint
:
7832 enable_breakpoint (bpt
);
7836 else if (strchr (args
, '.'))
7838 struct bp_location
*loc
= find_location_by_number (args
);
7841 check_duplicates (loc
->owner
);
7844 map_breakpoint_numbers (args
, enable_breakpoint
);
7848 enable_once_breakpoint (struct breakpoint
*bpt
)
7850 do_enable_breakpoint (bpt
, disp_disable
);
7854 enable_once_command (char *args
, int from_tty
)
7856 map_breakpoint_numbers (args
, enable_once_breakpoint
);
7860 enable_delete_breakpoint (struct breakpoint
*bpt
)
7862 do_enable_breakpoint (bpt
, disp_del
);
7866 enable_delete_command (char *args
, int from_tty
)
7868 map_breakpoint_numbers (args
, enable_delete_breakpoint
);
7872 set_breakpoint_cmd (char *args
, int from_tty
)
7877 show_breakpoint_cmd (char *args
, int from_tty
)
7881 /* Use default_breakpoint_'s, or nothing if they aren't valid. */
7883 struct symtabs_and_lines
7884 decode_line_spec_1 (char *string
, int funfirstline
)
7886 struct symtabs_and_lines sals
;
7888 error (_("Empty line specification."));
7889 if (default_breakpoint_valid
)
7890 sals
= decode_line_1 (&string
, funfirstline
,
7891 default_breakpoint_symtab
,
7892 default_breakpoint_line
,
7893 (char ***) NULL
, NULL
);
7895 sals
= decode_line_1 (&string
, funfirstline
,
7896 (struct symtab
*) NULL
, 0, (char ***) NULL
, NULL
);
7898 error (_("Junk at end of line specification: %s"), string
);
7902 /* Create and insert a raw software breakpoint at PC. Return an
7903 identifier, which should be used to remove the breakpoint later.
7904 In general, places which call this should be using something on the
7905 breakpoint chain instead; this function should be eliminated
7909 deprecated_insert_raw_breakpoint (CORE_ADDR pc
)
7911 struct bp_target_info
*bp_tgt
;
7913 bp_tgt
= xmalloc (sizeof (struct bp_target_info
));
7914 memset (bp_tgt
, 0, sizeof (struct bp_target_info
));
7916 bp_tgt
->placed_address
= pc
;
7917 if (target_insert_breakpoint (bp_tgt
) != 0)
7919 /* Could not insert the breakpoint. */
7927 /* Remove a breakpoint BP inserted by deprecated_insert_raw_breakpoint. */
7930 deprecated_remove_raw_breakpoint (void *bp
)
7932 struct bp_target_info
*bp_tgt
= bp
;
7935 ret
= target_remove_breakpoint (bp_tgt
);
7941 /* One (or perhaps two) breakpoints used for software single stepping. */
7943 static void *single_step_breakpoints
[2];
7945 /* Create and insert a breakpoint for software single step. */
7948 insert_single_step_breakpoint (CORE_ADDR next_pc
)
7952 if (single_step_breakpoints
[0] == NULL
)
7953 bpt_p
= &single_step_breakpoints
[0];
7956 gdb_assert (single_step_breakpoints
[1] == NULL
);
7957 bpt_p
= &single_step_breakpoints
[1];
7960 /* NOTE drow/2006-04-11: A future improvement to this function would be
7961 to only create the breakpoints once, and actually put them on the
7962 breakpoint chain. That would let us use set_raw_breakpoint. We could
7963 adjust the addresses each time they were needed. Doing this requires
7964 corresponding changes elsewhere where single step breakpoints are
7965 handled, however. So, for now, we use this. */
7967 *bpt_p
= deprecated_insert_raw_breakpoint (next_pc
);
7969 error (_("Could not insert single-step breakpoint at 0x%s"),
7970 paddr_nz (next_pc
));
7973 /* Remove and delete any breakpoints used for software single step. */
7976 remove_single_step_breakpoints (void)
7978 gdb_assert (single_step_breakpoints
[0] != NULL
);
7980 /* See insert_single_step_breakpoint for more about this deprecated
7982 deprecated_remove_raw_breakpoint (single_step_breakpoints
[0]);
7983 single_step_breakpoints
[0] = NULL
;
7985 if (single_step_breakpoints
[1] != NULL
)
7987 deprecated_remove_raw_breakpoint (single_step_breakpoints
[1]);
7988 single_step_breakpoints
[1] = NULL
;
7992 /* Check whether a software single-step breakpoint is inserted at PC. */
7995 single_step_breakpoint_inserted_here_p (CORE_ADDR pc
)
7999 for (i
= 0; i
< 2; i
++)
8001 struct bp_target_info
*bp_tgt
= single_step_breakpoints
[i
];
8002 if (bp_tgt
&& bp_tgt
->placed_address
== pc
)
8010 /* This help string is used for the break, hbreak, tbreak and thbreak commands.
8011 It is defined as a macro to prevent duplication.
8012 COMMAND should be a string constant containing the name of the command. */
8013 #define BREAK_ARGS_HELP(command) \
8014 command" [LOCATION] [thread THREADNUM] [if CONDITION]\n\
8015 LOCATION may be a line number, function name, or \"*\" and an address.\n\
8016 If a line number is specified, break at start of code for that line.\n\
8017 If a function is specified, break at start of code for that function.\n\
8018 If an address is specified, break at that exact address.\n\
8019 With no LOCATION, uses current execution address of selected stack frame.\n\
8020 This is useful for breaking on return to a stack frame.\n\
8022 THREADNUM is the number from \"info threads\".\n\
8023 CONDITION is a boolean expression.\n\
8025 Multiple breakpoints at one place are permitted, and useful if conditional.\n\
8027 Do \"help breakpoints\" for info on other commands dealing with breakpoints."
8030 _initialize_breakpoint (void)
8032 static struct cmd_list_element
*breakpoint_set_cmdlist
;
8033 static struct cmd_list_element
*breakpoint_show_cmdlist
;
8034 struct cmd_list_element
*c
;
8036 observer_attach_solib_unloaded (disable_breakpoints_in_unloaded_shlib
);
8038 breakpoint_chain
= 0;
8039 /* Don't bother to call set_breakpoint_count. $bpnum isn't useful
8040 before a breakpoint is set. */
8041 breakpoint_count
= 0;
8043 add_com ("ignore", class_breakpoint
, ignore_command
, _("\
8044 Set ignore-count of breakpoint number N to COUNT.\n\
8045 Usage is `ignore N COUNT'."));
8047 add_com_alias ("bc", "ignore", class_breakpoint
, 1);
8049 add_com ("commands", class_breakpoint
, commands_command
, _("\
8050 Set commands to be executed when a breakpoint is hit.\n\
8051 Give breakpoint number as argument after \"commands\".\n\
8052 With no argument, the targeted breakpoint is the last one set.\n\
8053 The commands themselves follow starting on the next line.\n\
8054 Type a line containing \"end\" to indicate the end of them.\n\
8055 Give \"silent\" as the first line to make the breakpoint silent;\n\
8056 then no output is printed when it is hit, except what the commands print."));
8058 add_com ("condition", class_breakpoint
, condition_command
, _("\
8059 Specify breakpoint number N to break only if COND is true.\n\
8060 Usage is `condition N COND', where N is an integer and COND is an\n\
8061 expression to be evaluated whenever breakpoint N is reached."));
8063 c
= add_com ("tbreak", class_breakpoint
, tbreak_command
, _("\
8064 Set a temporary breakpoint.\n\
8065 Like \"break\" except the breakpoint is only temporary,\n\
8066 so it will be deleted when hit. Equivalent to \"break\" followed\n\
8067 by using \"enable delete\" on the breakpoint number.\n\
8069 BREAK_ARGS_HELP ("tbreak")));
8070 set_cmd_completer (c
, location_completer
);
8072 c
= add_com ("hbreak", class_breakpoint
, hbreak_command
, _("\
8073 Set a hardware assisted breakpoint.\n\
8074 Like \"break\" except the breakpoint requires hardware support,\n\
8075 some target hardware may not have this support.\n\
8077 BREAK_ARGS_HELP ("hbreak")));
8078 set_cmd_completer (c
, location_completer
);
8080 c
= add_com ("thbreak", class_breakpoint
, thbreak_command
, _("\
8081 Set a temporary hardware assisted breakpoint.\n\
8082 Like \"hbreak\" except the breakpoint is only temporary,\n\
8083 so it will be deleted when hit.\n\
8085 BREAK_ARGS_HELP ("thbreak")));
8086 set_cmd_completer (c
, location_completer
);
8088 add_prefix_cmd ("enable", class_breakpoint
, enable_command
, _("\
8089 Enable some breakpoints.\n\
8090 Give breakpoint numbers (separated by spaces) as arguments.\n\
8091 With no subcommand, breakpoints are enabled until you command otherwise.\n\
8092 This is used to cancel the effect of the \"disable\" command.\n\
8093 With a subcommand you can enable temporarily."),
8094 &enablelist
, "enable ", 1, &cmdlist
);
8096 add_com ("ab", class_breakpoint
, enable_command
, _("\
8097 Enable some breakpoints.\n\
8098 Give breakpoint numbers (separated by spaces) as arguments.\n\
8099 With no subcommand, breakpoints are enabled until you command otherwise.\n\
8100 This is used to cancel the effect of the \"disable\" command.\n\
8101 With a subcommand you can enable temporarily."));
8103 add_com_alias ("en", "enable", class_breakpoint
, 1);
8105 add_abbrev_prefix_cmd ("breakpoints", class_breakpoint
, enable_command
, _("\
8106 Enable some breakpoints.\n\
8107 Give breakpoint numbers (separated by spaces) as arguments.\n\
8108 This is used to cancel the effect of the \"disable\" command.\n\
8109 May be abbreviated to simply \"enable\".\n"),
8110 &enablebreaklist
, "enable breakpoints ", 1, &enablelist
);
8112 add_cmd ("once", no_class
, enable_once_command
, _("\
8113 Enable breakpoints for one hit. Give breakpoint numbers.\n\
8114 If a breakpoint is hit while enabled in this fashion, it becomes disabled."),
8117 add_cmd ("delete", no_class
, enable_delete_command
, _("\
8118 Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
8119 If a breakpoint is hit while enabled in this fashion, it is deleted."),
8122 add_cmd ("delete", no_class
, enable_delete_command
, _("\
8123 Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
8124 If a breakpoint is hit while enabled in this fashion, it is deleted."),
8127 add_cmd ("once", no_class
, enable_once_command
, _("\
8128 Enable breakpoints for one hit. Give breakpoint numbers.\n\
8129 If a breakpoint is hit while enabled in this fashion, it becomes disabled."),
8132 add_prefix_cmd ("disable", class_breakpoint
, disable_command
, _("\
8133 Disable some breakpoints.\n\
8134 Arguments are breakpoint numbers with spaces in between.\n\
8135 To disable all breakpoints, give no argument.\n\
8136 A disabled breakpoint is not forgotten, but has no effect until reenabled."),
8137 &disablelist
, "disable ", 1, &cmdlist
);
8138 add_com_alias ("dis", "disable", class_breakpoint
, 1);
8139 add_com_alias ("disa", "disable", class_breakpoint
, 1);
8141 add_com ("sb", class_breakpoint
, disable_command
, _("\
8142 Disable some breakpoints.\n\
8143 Arguments are breakpoint numbers with spaces in between.\n\
8144 To disable all breakpoints, give no argument.\n\
8145 A disabled breakpoint is not forgotten, but has no effect until reenabled."));
8147 add_cmd ("breakpoints", class_alias
, disable_command
, _("\
8148 Disable some breakpoints.\n\
8149 Arguments are breakpoint numbers with spaces in between.\n\
8150 To disable all breakpoints, give no argument.\n\
8151 A disabled breakpoint is not forgotten, but has no effect until reenabled.\n\
8152 This command may be abbreviated \"disable\"."),
8155 add_prefix_cmd ("delete", class_breakpoint
, delete_command
, _("\
8156 Delete some breakpoints or auto-display expressions.\n\
8157 Arguments are breakpoint numbers with spaces in between.\n\
8158 To delete all breakpoints, give no argument.\n\
8160 Also a prefix command for deletion of other GDB objects.\n\
8161 The \"unset\" command is also an alias for \"delete\"."),
8162 &deletelist
, "delete ", 1, &cmdlist
);
8163 add_com_alias ("d", "delete", class_breakpoint
, 1);
8164 add_com_alias ("del", "delete", class_breakpoint
, 1);
8166 add_com ("db", class_breakpoint
, delete_command
, _("\
8167 Delete some breakpoints.\n\
8168 Arguments are breakpoint numbers with spaces in between.\n\
8169 To delete all breakpoints, give no argument.\n"));
8171 add_cmd ("breakpoints", class_alias
, delete_command
, _("\
8172 Delete some breakpoints or auto-display expressions.\n\
8173 Arguments are breakpoint numbers with spaces in between.\n\
8174 To delete all breakpoints, give no argument.\n\
8175 This command may be abbreviated \"delete\"."),
8178 add_com ("clear", class_breakpoint
, clear_command
, _("\
8179 Clear breakpoint at specified line or function.\n\
8180 Argument may be line number, function name, or \"*\" and an address.\n\
8181 If line number is specified, all breakpoints in that line are cleared.\n\
8182 If function is specified, breakpoints at beginning of function are cleared.\n\
8183 If an address is specified, breakpoints at that address are cleared.\n\
8185 With no argument, clears all breakpoints in the line that the selected frame\n\
8188 See also the \"delete\" command which clears breakpoints by number."));
8190 c
= add_com ("break", class_breakpoint
, break_command
, _("\
8191 Set breakpoint at specified line or function.\n"
8192 BREAK_ARGS_HELP ("break")));
8193 set_cmd_completer (c
, location_completer
);
8195 add_com_alias ("b", "break", class_run
, 1);
8196 add_com_alias ("br", "break", class_run
, 1);
8197 add_com_alias ("bre", "break", class_run
, 1);
8198 add_com_alias ("brea", "break", class_run
, 1);
8202 add_com_alias ("ba", "break", class_breakpoint
, 1);
8203 add_com_alias ("bu", "ubreak", class_breakpoint
, 1);
8208 add_abbrev_prefix_cmd ("stop", class_breakpoint
, stop_command
, _("\
8209 Break in function/address or break at a line in the current file."),
8210 &stoplist
, "stop ", 1, &cmdlist
);
8211 add_cmd ("in", class_breakpoint
, stopin_command
,
8212 _("Break in function or address."), &stoplist
);
8213 add_cmd ("at", class_breakpoint
, stopat_command
,
8214 _("Break at a line in the current file."), &stoplist
);
8215 add_com ("status", class_info
, breakpoints_info
, _("\
8216 Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
8217 The \"Type\" column indicates one of:\n\
8218 \tbreakpoint - normal breakpoint\n\
8219 \twatchpoint - watchpoint\n\
8220 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
8221 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
8222 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
8223 address and file/line number respectively.\n\
8225 Convenience variable \"$_\" and default examine address for \"x\"\n\
8226 are set to the address of the last breakpoint listed unless the command\n\
8227 is prefixed with \"server \".\n\n\
8228 Convenience variable \"$bpnum\" contains the number of the last\n\
8232 add_info ("breakpoints", breakpoints_info
, _("\
8233 Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
8234 The \"Type\" column indicates one of:\n\
8235 \tbreakpoint - normal breakpoint\n\
8236 \twatchpoint - watchpoint\n\
8237 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
8238 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
8239 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
8240 address and file/line number respectively.\n\
8242 Convenience variable \"$_\" and default examine address for \"x\"\n\
8243 are set to the address of the last breakpoint listed unless the command\n\
8244 is prefixed with \"server \".\n\n\
8245 Convenience variable \"$bpnum\" contains the number of the last\n\
8249 add_com ("lb", class_breakpoint
, breakpoints_info
, _("\
8250 Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
8251 The \"Type\" column indicates one of:\n\
8252 \tbreakpoint - normal breakpoint\n\
8253 \twatchpoint - watchpoint\n\
8254 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
8255 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
8256 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
8257 address and file/line number respectively.\n\
8259 Convenience variable \"$_\" and default examine address for \"x\"\n\
8260 are set to the address of the last breakpoint listed unless the command\n\
8261 is prefixed with \"server \".\n\n\
8262 Convenience variable \"$bpnum\" contains the number of the last\n\
8265 add_cmd ("breakpoints", class_maintenance
, maintenance_info_breakpoints
, _("\
8266 Status of all breakpoints, or breakpoint number NUMBER.\n\
8267 The \"Type\" column indicates one of:\n\
8268 \tbreakpoint - normal breakpoint\n\
8269 \twatchpoint - watchpoint\n\
8270 \tlongjmp - internal breakpoint used to step through longjmp()\n\
8271 \tlongjmp resume - internal breakpoint at the target of longjmp()\n\
8272 \tuntil - internal breakpoint used by the \"until\" command\n\
8273 \tfinish - internal breakpoint used by the \"finish\" command\n\
8274 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
8275 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
8276 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
8277 address and file/line number respectively.\n\
8279 Convenience variable \"$_\" and default examine address for \"x\"\n\
8280 are set to the address of the last breakpoint listed unless the command\n\
8281 is prefixed with \"server \".\n\n\
8282 Convenience variable \"$bpnum\" contains the number of the last\n\
8284 &maintenanceinfolist
);
8286 add_com ("catch", class_breakpoint
, catch_command
, _("\
8287 Set catchpoints to catch events.\n\
8288 Raised signals may be caught:\n\
8289 \tcatch signal - all signals\n\
8290 \tcatch signal <signame> - a particular signal\n\
8291 Raised exceptions may be caught:\n\
8292 \tcatch throw - all exceptions, when thrown\n\
8293 \tcatch throw <exceptname> - a particular exception, when thrown\n\
8294 \tcatch catch - all exceptions, when caught\n\
8295 \tcatch catch <exceptname> - a particular exception, when caught\n\
8296 Thread or process events may be caught:\n\
8297 \tcatch thread_start - any threads, just after creation\n\
8298 \tcatch thread_exit - any threads, just before expiration\n\
8299 \tcatch thread_join - any threads, just after joins\n\
8300 Process events may be caught:\n\
8301 \tcatch start - any processes, just after creation\n\
8302 \tcatch exit - any processes, just before expiration\n\
8303 \tcatch fork - calls to fork()\n\
8304 \tcatch vfork - calls to vfork()\n\
8305 \tcatch exec - calls to exec()\n\
8306 Dynamically-linked library events may be caught:\n\
8307 \tcatch load - loads of any library\n\
8308 \tcatch load <libname> - loads of a particular library\n\
8309 \tcatch unload - unloads of any library\n\
8310 \tcatch unload <libname> - unloads of a particular library\n\
8311 The act of your program's execution stopping may also be caught:\n\
8313 C++ exceptions may be caught:\n\
8314 \tcatch throw - all exceptions, when thrown\n\
8315 \tcatch catch - all exceptions, when caught\n\
8316 Ada exceptions may be caught:\n\
8317 \tcatch exception - all exceptions, when raised\n\
8318 \tcatch exception <name> - a particular exception, when raised\n\
8319 \tcatch exception unhandled - all unhandled exceptions, when raised\n\
8320 \tcatch assert - all failed assertions, when raised\n\
8322 Do \"help set follow-fork-mode\" for info on debugging your program\n\
8323 after a fork or vfork is caught.\n\n\
8324 Do \"help breakpoints\" for info on other commands dealing with breakpoints."));
8326 add_com ("tcatch", class_breakpoint
, tcatch_command
, _("\
8327 Set temporary catchpoints to catch events.\n\
8328 Args like \"catch\" command.\n\
8329 Like \"catch\" except the catchpoint is only temporary,\n\
8330 so it will be deleted when hit. Equivalent to \"catch\" followed\n\
8331 by using \"enable delete\" on the catchpoint number."));
8333 c
= add_com ("watch", class_breakpoint
, watch_command
, _("\
8334 Set a watchpoint for an expression.\n\
8335 A watchpoint stops execution of your program whenever the value of\n\
8336 an expression changes."));
8337 set_cmd_completer (c
, location_completer
);
8339 c
= add_com ("rwatch", class_breakpoint
, rwatch_command
, _("\
8340 Set a read watchpoint for an expression.\n\
8341 A watchpoint stops execution of your program whenever the value of\n\
8342 an expression is read."));
8343 set_cmd_completer (c
, location_completer
);
8345 c
= add_com ("awatch", class_breakpoint
, awatch_command
, _("\
8346 Set a watchpoint for an expression.\n\
8347 A watchpoint stops execution of your program whenever the value of\n\
8348 an expression is either read or written."));
8349 set_cmd_completer (c
, location_completer
);
8351 add_info ("watchpoints", breakpoints_info
,
8352 _("Synonym for ``info breakpoints''."));
8355 /* XXX: cagney/2005-02-23: This should be a boolean, and should
8356 respond to changes - contrary to the description. */
8357 add_setshow_zinteger_cmd ("can-use-hw-watchpoints", class_support
,
8358 &can_use_hw_watchpoints
, _("\
8359 Set debugger's willingness to use watchpoint hardware."), _("\
8360 Show debugger's willingness to use watchpoint hardware."), _("\
8361 If zero, gdb will not use hardware for new watchpoints, even if\n\
8362 such is available. (However, any hardware watchpoints that were\n\
8363 created before setting this to nonzero, will continue to use watchpoint\n\
8366 show_can_use_hw_watchpoints
,
8367 &setlist
, &showlist
);
8369 can_use_hw_watchpoints
= 1;
8371 add_prefix_cmd ("breakpoint", class_maintenance
, set_breakpoint_cmd
, _("\
8372 Breakpoint specific settings\n\
8373 Configure various breakpoint-specific variables such as\n\
8374 pending breakpoint behavior"),
8375 &breakpoint_set_cmdlist
, "set breakpoint ",
8376 0/*allow-unknown*/, &setlist
);
8377 add_prefix_cmd ("breakpoint", class_maintenance
, show_breakpoint_cmd
, _("\
8378 Breakpoint specific settings\n\
8379 Configure various breakpoint-specific variables such as\n\
8380 pending breakpoint behavior"),
8381 &breakpoint_show_cmdlist
, "show breakpoint ",
8382 0/*allow-unknown*/, &showlist
);
8384 add_setshow_auto_boolean_cmd ("pending", no_class
,
8385 &pending_break_support
, _("\
8386 Set debugger's behavior regarding pending breakpoints."), _("\
8387 Show debugger's behavior regarding pending breakpoints."), _("\
8388 If on, an unrecognized breakpoint location will cause gdb to create a\n\
8389 pending breakpoint. If off, an unrecognized breakpoint location results in\n\
8390 an error. If auto, an unrecognized breakpoint location results in a\n\
8391 user-query to see if a pending breakpoint should be created."),
8393 show_pending_break_support
,
8394 &breakpoint_set_cmdlist
,
8395 &breakpoint_show_cmdlist
);
8397 pending_break_support
= AUTO_BOOLEAN_AUTO
;
8399 add_setshow_boolean_cmd ("auto-hw", no_class
,
8400 &automatic_hardware_breakpoints
, _("\
8401 Set automatic usage of hardware breakpoints."), _("\
8402 Show automatic usage of hardware breakpoints."), _("\
8403 If set, the debugger will automatically use hardware breakpoints for\n\
8404 breakpoints set with \"break\" but falling in read-only memory. If not set,\n\
8405 a warning will be emitted for such breakpoints."),
8407 show_automatic_hardware_breakpoints
,
8408 &breakpoint_set_cmdlist
,
8409 &breakpoint_show_cmdlist
);
8411 automatic_hardware_breakpoints
= 1;