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
,
68 static void catch_command_1 (char *, int, int);
70 static void enable_delete_command (char *, int);
72 static void enable_delete_breakpoint (struct breakpoint
*);
74 static void enable_once_command (char *, int);
76 static void enable_once_breakpoint (struct breakpoint
*);
78 static void disable_command (char *, int);
80 static void enable_command (char *, int);
82 static void map_breakpoint_numbers (char *, void (*)(struct breakpoint
*));
84 static void ignore_command (char *, int);
86 static int breakpoint_re_set_one (void *);
88 static void clear_command (char *, int);
90 static void catch_command (char *, int);
92 static void watch_command (char *, int);
94 static int can_use_hardware_watchpoint (struct value
*);
96 static void break_command_1 (char *, int, int);
98 static void mention (struct breakpoint
*);
100 struct breakpoint
*set_raw_breakpoint (struct symtab_and_line
, enum bptype
);
102 static void check_duplicates (struct breakpoint
*);
104 static void breakpoint_adjustment_warning (CORE_ADDR
, CORE_ADDR
, int, int);
106 static CORE_ADDR
adjust_breakpoint_address (CORE_ADDR bpaddr
,
109 static void describe_other_breakpoints (CORE_ADDR
, asection
*, int);
111 static void breakpoints_info (char *, int);
113 static void breakpoint_1 (int, int);
115 static bpstat
bpstat_alloc (const struct bp_location
*, bpstat
);
117 static int breakpoint_cond_eval (void *);
119 static void cleanup_executing_breakpoints (void *);
121 static void commands_command (char *, int);
123 static void condition_command (char *, int);
125 static int get_number_trailer (char **, int);
127 void set_breakpoint_count (int);
136 static int remove_breakpoint (struct bp_location
*, insertion_state_t
);
138 static enum print_stop_action
print_it_typical (bpstat
);
140 static enum print_stop_action
print_bp_stop_message (bpstat bs
);
142 static int watchpoint_check (void *);
144 static void maintenance_info_breakpoints (char *, int);
146 static void create_overlay_event_breakpoint (char *);
148 static int hw_breakpoint_used_count (void);
150 static int hw_watchpoint_used_count (enum bptype
, int *);
152 static void hbreak_command (char *, int);
154 static void thbreak_command (char *, int);
156 static void watch_command_1 (char *, int, int);
158 static void rwatch_command (char *, int);
160 static void awatch_command (char *, int);
162 static void do_enable_breakpoint (struct breakpoint
*, enum bpdisp
);
164 static void create_fork_vfork_event_catchpoint (int tempflag
,
166 enum bptype bp_kind
);
168 static void stop_command (char *arg
, int from_tty
);
170 static void stopin_command (char *arg
, int from_tty
);
172 static void stopat_command (char *arg
, int from_tty
);
174 static char *ep_find_event_name_end (char *arg
);
176 static char *ep_parse_optional_if_clause (char **arg
);
178 static char *ep_parse_optional_filename (char **arg
);
180 static void catch_exception_command_1 (enum exception_event_kind ex_event
,
181 char *arg
, int tempflag
, int from_tty
);
183 static void tcatch_command (char *arg
, int from_tty
);
185 static void ep_skip_leading_whitespace (char **s
);
187 static int single_step_breakpoint_inserted_here_p (CORE_ADDR pc
);
189 static void free_bp_location (struct bp_location
*loc
);
191 static void mark_breakpoints_out (void);
193 static struct bp_location
*
194 allocate_bp_location (struct breakpoint
*bpt
, enum bptype bp_type
);
196 static void update_global_location_list (void);
198 static void update_global_location_list_nothrow (void);
200 static int is_hardware_watchpoint (struct breakpoint
*bpt
);
202 static void insert_breakpoint_locations (void);
205 bpdisp_text (enum bpdisp disp
)
207 /* NOTE: the following values are a part of MI protocol and represent
208 values of 'disp' field returned when inferior stops at a breakpoint. */
209 static char *bpdisps
[] = {"del", "dstp", "dis", "keep"};
210 return bpdisps
[(int) disp
];
213 /* Prototypes for exported functions. */
214 /* If FALSE, gdb will not use hardware support for watchpoints, even
215 if such is available. */
216 static int can_use_hw_watchpoints
;
219 show_can_use_hw_watchpoints (struct ui_file
*file
, int from_tty
,
220 struct cmd_list_element
*c
,
223 fprintf_filtered (file
, _("\
224 Debugger's willingness to use watchpoint hardware is %s.\n"),
228 /* If AUTO_BOOLEAN_FALSE, gdb will not attempt to create pending breakpoints.
229 If AUTO_BOOLEAN_TRUE, gdb will automatically create pending breakpoints
230 for unrecognized breakpoint locations.
231 If AUTO_BOOLEAN_AUTO, gdb will query when breakpoints are unrecognized. */
232 static enum auto_boolean pending_break_support
;
234 show_pending_break_support (struct ui_file
*file
, int from_tty
,
235 struct cmd_list_element
*c
,
238 fprintf_filtered (file
, _("\
239 Debugger's behavior regarding pending breakpoints is %s.\n"),
243 /* If 1, gdb will automatically use hardware breakpoints for breakpoints
244 set with "break" but falling in read-only memory.
245 If 0, gdb will warn about such breakpoints, but won't automatically
246 use hardware breakpoints. */
247 static int automatic_hardware_breakpoints
;
249 show_automatic_hardware_breakpoints (struct ui_file
*file
, int from_tty
,
250 struct cmd_list_element
*c
,
253 fprintf_filtered (file
, _("\
254 Automatic usage of hardware breakpoints is %s.\n"),
258 /* If 1, gdb will keep breakpoints inserted even as inferior is stopped,
259 and immediately insert any new breakpoints. If 0, gdb will insert
260 breakpoints into inferior only when resuming it, and will remove
261 breakpoints upon stop. */
262 static int always_inserted_mode
= 0;
264 show_always_inserted_mode (struct ui_file
*file
, int from_tty
,
265 struct cmd_list_element
*c
, const char *value
)
267 fprintf_filtered (file
, _("Always inserted breakpoint mode is %s.\n"), value
);
271 void _initialize_breakpoint (void);
273 extern int addressprint
; /* Print machine addresses? */
275 /* Are we executing breakpoint commands? */
276 static int executing_breakpoint_commands
;
278 /* Are overlay event breakpoints enabled? */
279 static int overlay_events_enabled
;
281 /* Walk the following statement or block through all breakpoints.
282 ALL_BREAKPOINTS_SAFE does so even if the statment deletes the current
285 #define ALL_BREAKPOINTS(B) for (B = breakpoint_chain; B; B = B->next)
287 #define ALL_BREAKPOINTS_SAFE(B,TMP) \
288 for (B = breakpoint_chain; \
289 B ? (TMP=B->next, 1): 0; \
292 /* Similar iterators for the low-level breakpoints. */
294 #define ALL_BP_LOCATIONS(B) for (B = bp_location_chain; B; B = B->global_next)
296 #define ALL_BP_LOCATIONS_SAFE(B,TMP) \
297 for (B = bp_location_chain; \
298 B ? (TMP=B->global_next, 1): 0; \
301 /* True if breakpoint hit counts should be displayed in breakpoint info. */
303 int show_breakpoint_hit_counts
= 1;
305 /* Chains of all breakpoints defined. */
307 struct breakpoint
*breakpoint_chain
;
309 struct bp_location
*bp_location_chain
;
311 /* Number of last breakpoint made. */
313 int breakpoint_count
;
315 /* This function returns a pointer to the string representation of the
316 pathname of the dynamically-linked library that has just been
319 This function must be used only when SOLIB_HAVE_LOAD_EVENT is TRUE,
320 or undefined results are guaranteed.
322 This string's contents are only valid immediately after the
323 inferior has stopped in the dynamic linker hook, and becomes
324 invalid as soon as the inferior is continued. Clients should make
325 a copy of this string if they wish to continue the inferior and
326 then access the string. */
328 #ifndef SOLIB_LOADED_LIBRARY_PATHNAME
329 #define SOLIB_LOADED_LIBRARY_PATHNAME(pid) ""
332 /* This function returns a pointer to the string representation of the
333 pathname of the dynamically-linked library that has just been
336 This function must be used only when SOLIB_HAVE_UNLOAD_EVENT is
337 TRUE, or undefined results are guaranteed.
339 This string's contents are only valid immediately after the
340 inferior has stopped in the dynamic linker hook, and becomes
341 invalid as soon as the inferior is continued. Clients should make
342 a copy of this string if they wish to continue the inferior and
343 then access the string. */
345 #ifndef SOLIB_UNLOADED_LIBRARY_PATHNAME
346 #define SOLIB_UNLOADED_LIBRARY_PATHNAME(pid) ""
349 /* This function is called by the "catch load" command. It allows the
350 debugger to be notified by the dynamic linker when a specified
351 library file (or any library file, if filename is NULL) is loaded. */
353 #ifndef SOLIB_CREATE_CATCH_LOAD_HOOK
354 #define SOLIB_CREATE_CATCH_LOAD_HOOK(pid,tempflag,filename,cond_string) \
355 error (_("catch of library loads not yet implemented on this platform"))
358 /* This function is called by the "catch unload" command. It allows
359 the debugger to be notified by the dynamic linker when a specified
360 library file (or any library file, if filename is NULL) is
363 #ifndef SOLIB_CREATE_CATCH_UNLOAD_HOOK
364 #define SOLIB_CREATE_CATCH_UNLOAD_HOOK(pid, tempflag, filename, cond_string) \
365 error (_("catch of library unloads not yet implemented on this platform"))
368 /* Return whether a breakpoint is an active enabled breakpoint. */
370 breakpoint_enabled (struct breakpoint
*b
)
372 return (b
->enable_state
== bp_enabled
);
375 /* Set breakpoint count to NUM. */
378 set_breakpoint_count (int num
)
380 breakpoint_count
= num
;
381 set_internalvar (lookup_internalvar ("bpnum"),
382 value_from_longest (builtin_type_int
, (LONGEST
) num
));
385 /* Used in run_command to zero the hit count when a new run starts. */
388 clear_breakpoint_hit_counts (void)
390 struct breakpoint
*b
;
396 /* Default address, symtab and line to put a breakpoint at
397 for "break" command with no arg.
398 if default_breakpoint_valid is zero, the other three are
399 not valid, and "break" with no arg is an error.
401 This set by print_stack_frame, which calls set_default_breakpoint. */
403 int default_breakpoint_valid
;
404 CORE_ADDR default_breakpoint_address
;
405 struct symtab
*default_breakpoint_symtab
;
406 int default_breakpoint_line
;
408 /* *PP is a string denoting a breakpoint. Get the number of the breakpoint.
409 Advance *PP after the string and any trailing whitespace.
411 Currently the string can either be a number or "$" followed by the name
412 of a convenience variable. Making it an expression wouldn't work well
413 for map_breakpoint_numbers (e.g. "4 + 5 + 6").
415 If the string is a NULL pointer, that denotes the last breakpoint.
417 TRAILER is a character which can be found after the number; most
418 commonly this is `-'. If you don't want a trailer, use \0. */
420 get_number_trailer (char **pp
, int trailer
)
422 int retval
= 0; /* default */
426 /* Empty line means refer to the last breakpoint. */
427 return breakpoint_count
;
430 /* Make a copy of the name, so we can null-terminate it
431 to pass to lookup_internalvar(). */
436 while (isalnum (*p
) || *p
== '_')
438 varname
= (char *) alloca (p
- start
+ 1);
439 strncpy (varname
, start
, p
- start
);
440 varname
[p
- start
] = '\0';
441 val
= value_of_internalvar (lookup_internalvar (varname
));
442 if (TYPE_CODE (value_type (val
)) == TYPE_CODE_INT
)
443 retval
= (int) value_as_long (val
);
446 printf_filtered (_("Convenience variable must have integer value.\n"));
454 while (*p
>= '0' && *p
<= '9')
457 /* There is no number here. (e.g. "cond a == b"). */
459 /* Skip non-numeric token */
460 while (*p
&& !isspace((int) *p
))
462 /* Return zero, which caller must interpret as error. */
468 if (!(isspace (*p
) || *p
== '\0' || *p
== trailer
))
470 /* Trailing junk: return 0 and let caller print error msg. */
471 while (!(isspace (*p
) || *p
== '\0' || *p
== trailer
))
482 /* Like get_number_trailer, but don't allow a trailer. */
484 get_number (char **pp
)
486 return get_number_trailer (pp
, '\0');
489 /* Parse a number or a range.
490 * A number will be of the form handled by get_number.
491 * A range will be of the form <number1> - <number2>, and
492 * will represent all the integers between number1 and number2,
495 * While processing a range, this fuction is called iteratively;
496 * At each call it will return the next value in the range.
498 * At the beginning of parsing a range, the char pointer PP will
499 * be advanced past <number1> and left pointing at the '-' token.
500 * Subsequent calls will not advance the pointer until the range
501 * is completed. The call that completes the range will advance
502 * pointer PP past <number2>.
506 get_number_or_range (char **pp
)
508 static int last_retval
, end_value
;
509 static char *end_ptr
;
510 static int in_range
= 0;
514 /* Default case: pp is pointing either to a solo number,
515 or to the first number of a range. */
516 last_retval
= get_number_trailer (pp
, '-');
521 /* This is the start of a range (<number1> - <number2>).
522 Skip the '-', parse and remember the second number,
523 and also remember the end of the final token. */
527 while (isspace ((int) *end_ptr
))
528 end_ptr
++; /* skip white space */
529 end_value
= get_number (temp
);
530 if (end_value
< last_retval
)
532 error (_("inverted range"));
534 else if (end_value
== last_retval
)
536 /* degenerate range (number1 == number2). Advance the
537 token pointer so that the range will be treated as a
546 error (_("negative value"));
549 /* pp points to the '-' that betokens a range. All
550 number-parsing has already been done. Return the next
551 integer value (one greater than the saved previous value).
552 Do not advance the token pointer 'pp' until the end of range
555 if (++last_retval
== end_value
)
557 /* End of range reached; advance token pointer. */
567 /* condition N EXP -- set break condition of breakpoint N to EXP. */
570 condition_command (char *arg
, int from_tty
)
572 struct breakpoint
*b
;
577 error_no_arg (_("breakpoint number"));
580 bnum
= get_number (&p
);
582 error (_("Bad breakpoint argument: '%s'"), arg
);
585 if (b
->number
== bnum
)
587 struct bp_location
*loc
= b
->loc
;
588 for (; loc
; loc
= loc
->next
)
596 if (b
->cond_string
!= NULL
)
597 xfree (b
->cond_string
);
601 b
->cond_string
= NULL
;
603 printf_filtered (_("Breakpoint %d now unconditional.\n"), bnum
);
608 /* I don't know if it matters whether this is the string the user
609 typed in or the decompiled expression. */
610 b
->cond_string
= savestring (arg
, strlen (arg
));
611 b
->condition_not_parsed
= 0;
612 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
616 parse_exp_1 (&arg
, block_for_pc (loc
->address
), 0);
618 error (_("Junk at end of expression"));
621 breakpoints_changed ();
622 breakpoint_modify_event (b
->number
);
626 error (_("No breakpoint number %d."), bnum
);
630 commands_command (char *arg
, int from_tty
)
632 struct breakpoint
*b
;
635 struct command_line
*l
;
637 /* If we allowed this, we would have problems with when to
638 free the storage, if we change the commands currently
641 if (executing_breakpoint_commands
)
642 error (_("Can't use the \"commands\" command among a breakpoint's commands."));
645 bnum
= get_number (&p
);
648 error (_("Unexpected extra arguments following breakpoint number."));
651 if (b
->number
== bnum
)
653 char *tmpbuf
= xstrprintf ("Type commands for when breakpoint %d is hit, one per line.",
655 struct cleanup
*cleanups
= make_cleanup (xfree
, tmpbuf
);
656 l
= read_command_lines (tmpbuf
, from_tty
);
657 do_cleanups (cleanups
);
658 free_command_lines (&b
->commands
);
660 breakpoints_changed ();
661 breakpoint_modify_event (b
->number
);
664 error (_("No breakpoint number %d."), bnum
);
667 /* Like commands_command, but instead of reading the commands from
668 input stream, takes them from an already parsed command structure.
670 This is used by cli-script.c to DTRT with breakpoint commands
671 that are part of if and while bodies. */
672 enum command_control_type
673 commands_from_control_command (char *arg
, struct command_line
*cmd
)
675 struct breakpoint
*b
;
679 /* If we allowed this, we would have problems with when to
680 free the storage, if we change the commands currently
683 if (executing_breakpoint_commands
)
684 error (_("Can't use the \"commands\" command among a breakpoint's commands."));
686 /* An empty string for the breakpoint number means the last
687 breakpoint, but get_number expects a NULL pointer. */
692 bnum
= get_number (&p
);
695 error (_("Unexpected extra arguments following breakpoint number."));
698 if (b
->number
== bnum
)
700 free_command_lines (&b
->commands
);
701 if (cmd
->body_count
!= 1)
702 error (_("Invalid \"commands\" block structure."));
703 /* We need to copy the commands because if/while will free the
704 list after it finishes execution. */
705 b
->commands
= copy_command_lines (cmd
->body_list
[0]);
706 breakpoints_changed ();
707 breakpoint_modify_event (b
->number
);
708 return simple_control
;
710 error (_("No breakpoint number %d."), bnum
);
713 /* Update BUF, which is LEN bytes read from the target address MEMADDR,
714 by replacing any memory breakpoints with their shadowed contents. */
717 breakpoint_restore_shadows (gdb_byte
*buf
, ULONGEST memaddr
, LONGEST len
)
719 struct bp_location
*b
;
720 CORE_ADDR bp_addr
= 0;
726 if (b
->owner
->type
== bp_none
)
727 warning (_("reading through apparently deleted breakpoint #%d?"),
730 if (b
->loc_type
!= bp_loc_software_breakpoint
)
734 /* Addresses and length of the part of the breakpoint that
736 bp_addr
= b
->target_info
.placed_address
;
737 bp_size
= b
->target_info
.shadow_len
;
739 /* bp isn't valid, or doesn't shadow memory. */
742 if (bp_addr
+ bp_size
<= memaddr
)
743 /* The breakpoint is entirely before the chunk of memory we
747 if (bp_addr
>= memaddr
+ len
)
748 /* The breakpoint is entirely after the chunk of memory we are
752 /* Offset within shadow_contents. */
753 if (bp_addr
< memaddr
)
755 /* Only copy the second part of the breakpoint. */
756 bp_size
-= memaddr
- bp_addr
;
757 bptoffset
= memaddr
- bp_addr
;
761 if (bp_addr
+ bp_size
> memaddr
+ len
)
763 /* Only copy the first part of the breakpoint. */
764 bp_size
-= (bp_addr
+ bp_size
) - (memaddr
+ len
);
767 memcpy (buf
+ bp_addr
- memaddr
,
768 b
->target_info
.shadow_contents
+ bptoffset
, bp_size
);
773 /* A wrapper function for inserting catchpoints. */
775 insert_catchpoint (struct ui_out
*uo
, void *args
)
777 struct breakpoint
*b
= (struct breakpoint
*) args
;
783 target_insert_fork_catchpoint (PIDGET (inferior_ptid
));
786 target_insert_vfork_catchpoint (PIDGET (inferior_ptid
));
789 target_insert_exec_catchpoint (PIDGET (inferior_ptid
));
792 internal_error (__FILE__
, __LINE__
, _("unknown breakpoint type"));
798 is_hardware_watchpoint (struct breakpoint
*bpt
)
800 return (bpt
->type
== bp_hardware_watchpoint
801 || bpt
->type
== bp_read_watchpoint
802 || bpt
->type
== bp_access_watchpoint
);
805 /* Find the current value of a watchpoint on EXP. Return the value in
806 *VALP and *RESULTP and the chain of intermediate and final values
807 in *VAL_CHAIN. RESULTP and VAL_CHAIN may be NULL if the caller does
810 If an error occurs while evaluating the expression, *RESULTP will
811 be set to NULL. *RESULTP may be a lazy value, if the result could
812 not be read from memory. It is used to determine whether a value
813 is user-specified (we should watch the whole value) or intermediate
814 (we should watch only the bit used to locate the final value).
816 If the final value, or any intermediate value, could not be read
817 from memory, *VALP will be set to NULL. *VAL_CHAIN will still be
818 set to any referenced values. *VALP will never be a lazy value.
819 This is the value which we store in struct breakpoint.
821 If VAL_CHAIN is non-NULL, *VAL_CHAIN will be released from the
822 value chain. The caller must free the values individually. If
823 VAL_CHAIN is NULL, all generated values will be left on the value
827 fetch_watchpoint_value (struct expression
*exp
, struct value
**valp
,
828 struct value
**resultp
, struct value
**val_chain
)
830 struct value
*mark
, *new_mark
, *result
;
838 /* Evaluate the expression. */
839 mark
= value_mark ();
841 gdb_evaluate_expression (exp
, &result
);
842 new_mark
= value_mark ();
843 if (mark
== new_mark
)
848 /* Make sure it's not lazy, so that after the target stops again we
849 have a non-lazy previous value to compare with. */
851 && (!value_lazy (result
) || gdb_value_fetch_lazy (result
)))
856 /* Return the chain of intermediate values. We use this to
857 decide which addresses to watch. */
858 *val_chain
= new_mark
;
859 value_release_to_mark (mark
);
863 /* Assuming that B is a hardware watchpoint:
864 - Reparse watchpoint expression, is REPARSE is non-zero
865 - Evaluate expression and store the result in B->val
866 - Update the list of values that must be watched in B->loc.
868 If the watchpoint is disabled, do nothing. If this is
869 local watchpoint that is out of scope, delete it. */
871 update_watchpoint (struct breakpoint
*b
, int reparse
)
873 int within_current_scope
;
874 struct frame_id saved_frame_id
;
875 struct bp_location
*loc
;
878 /* We don't free locations. They are stored in
879 bp_location_chain and update_global_locations will
880 eventually delete them and remove breakpoints if
884 if (b
->disposition
== disp_del_at_next_stop
)
887 /* Save the current frame's ID so we can restore it after
888 evaluating the watchpoint expression on its own frame. */
889 /* FIXME drow/2003-09-09: It would be nice if evaluate_expression
890 took a frame parameter, so that we didn't have to change the
892 saved_frame_id
= get_frame_id (get_selected_frame (NULL
));
894 /* Determine if the watchpoint is within scope. */
895 if (b
->exp_valid_block
== NULL
)
896 within_current_scope
= 1;
899 struct frame_info
*fi
;
900 fi
= frame_find_by_id (b
->watchpoint_frame
);
901 within_current_scope
= (fi
!= NULL
);
902 if (within_current_scope
)
906 if (within_current_scope
&& reparse
)
915 b
->exp
= parse_exp_1 (&s
, b
->exp_valid_block
, 0);
916 /* If the meaning of expression itself changed, the old value is
917 no longer relevant. We don't want to report a watchpoint hit
918 to the user when the old value and the new value may actually
919 be completely different objects. */
925 /* If we failed to parse the expression, for example because
926 it refers to a global variable in a not-yet-loaded shared library,
927 don't try to insert watchpoint. We don't automatically delete
928 such watchpoint, though, since failure to parse expression
929 is different from out-of-scope watchpoint. */
930 if (within_current_scope
&& b
->exp
)
932 struct value
*val_chain
, *v
, *result
, *next
;
934 fetch_watchpoint_value (b
->exp
, &v
, &result
, &val_chain
);
936 /* Avoid setting b->val if it's already set. The meaning of
937 b->val is 'the last value' user saw, and we should update
938 it only if we reported that last value to user. As it
939 happens, the code that reports it updates b->val directly. */
946 /* Look at each value on the value chain. */
947 for (v
= val_chain
; v
; v
= next
)
949 /* If it's a memory location, and GDB actually needed
950 its contents to evaluate the expression, then we
951 must watch it. If the first value returned is
952 still lazy, that means an error occurred reading it;
953 watch it anyway in case it becomes readable. */
954 if (VALUE_LVAL (v
) == lval_memory
955 && (v
== val_chain
|| ! value_lazy (v
)))
957 struct type
*vtype
= check_typedef (value_type (v
));
959 /* We only watch structs and arrays if user asked
960 for it explicitly, never if they just happen to
961 appear in the middle of some value chain. */
963 || (TYPE_CODE (vtype
) != TYPE_CODE_STRUCT
964 && TYPE_CODE (vtype
) != TYPE_CODE_ARRAY
))
968 struct bp_location
*loc
, **tmp
;
970 addr
= VALUE_ADDRESS (v
) + value_offset (v
);
971 len
= TYPE_LENGTH (value_type (v
));
973 if (b
->type
== bp_read_watchpoint
)
975 else if (b
->type
== bp_access_watchpoint
)
978 loc
= allocate_bp_location (b
, bp_hardware_watchpoint
);
979 for (tmp
= &(b
->loc
); *tmp
!= NULL
; tmp
= &((*tmp
)->next
))
984 loc
->watchpoint_type
= type
;
988 next
= value_next (v
);
993 /* We just regenerated the list of breakpoint locations.
994 The new location does not have its condition field set to anything
995 and therefore, we must always reparse the cond_string, independently
996 of the value of the reparse flag. */
997 if (b
->cond_string
!= NULL
)
999 char *s
= b
->cond_string
;
1000 b
->loc
->cond
= parse_exp_1 (&s
, b
->exp_valid_block
, 0);
1003 else if (!within_current_scope
)
1005 printf_filtered (_("\
1006 Hardware watchpoint %d deleted because the program has left the block \n\
1007 in which its expression is valid.\n"),
1009 if (b
->related_breakpoint
)
1010 b
->related_breakpoint
->disposition
= disp_del_at_next_stop
;
1011 b
->disposition
= disp_del_at_next_stop
;
1014 /* Restore the selected frame. */
1015 select_frame (frame_find_by_id (saved_frame_id
));
1019 /* Returns 1 iff breakpoint location should be
1020 inserted in the inferior. */
1022 should_be_inserted (struct bp_location
*bpt
)
1024 if (!breakpoint_enabled (bpt
->owner
))
1027 if (bpt
->owner
->disposition
== disp_del_at_next_stop
)
1030 if (!bpt
->enabled
|| bpt
->shlib_disabled
|| bpt
->duplicate
)
1036 /* Insert a low-level "breakpoint" of some type. BPT is the breakpoint.
1037 Any error messages are printed to TMP_ERROR_STREAM; and DISABLED_BREAKS,
1038 PROCESS_WARNING, and HW_BREAKPOINT_ERROR are used to report problems.
1040 NOTE drow/2003-09-09: This routine could be broken down to an object-style
1041 method for each breakpoint or catchpoint type. */
1043 insert_bp_location (struct bp_location
*bpt
,
1044 struct ui_file
*tmp_error_stream
,
1045 int *disabled_breaks
, int *process_warning
,
1046 int *hw_breakpoint_error
)
1050 if (!should_be_inserted (bpt
) || bpt
->inserted
)
1053 /* Initialize the target-specific information. */
1054 memset (&bpt
->target_info
, 0, sizeof (bpt
->target_info
));
1055 bpt
->target_info
.placed_address
= bpt
->address
;
1057 if (bpt
->loc_type
== bp_loc_software_breakpoint
1058 || bpt
->loc_type
== bp_loc_hardware_breakpoint
)
1060 if (bpt
->owner
->type
!= bp_hardware_breakpoint
)
1062 /* If the explicitly specified breakpoint type
1063 is not hardware breakpoint, check the memory map to see
1064 if the breakpoint address is in read only memory or not.
1065 Two important cases are:
1066 - location type is not hardware breakpoint, memory
1067 is readonly. We change the type of the location to
1068 hardware breakpoint.
1069 - location type is hardware breakpoint, memory is read-write.
1070 This means we've previously made the location hardware one, but
1071 then the memory map changed, so we undo.
1073 When breakpoints are removed, remove_breakpoints will
1074 use location types we've just set here, the only possible
1075 problem is that memory map has changed during running program,
1076 but it's not going to work anyway with current gdb. */
1077 struct mem_region
*mr
1078 = lookup_mem_region (bpt
->target_info
.placed_address
);
1082 if (automatic_hardware_breakpoints
)
1085 enum bp_loc_type new_type
;
1087 if (mr
->attrib
.mode
!= MEM_RW
)
1088 new_type
= bp_loc_hardware_breakpoint
;
1090 new_type
= bp_loc_software_breakpoint
;
1092 if (new_type
!= bpt
->loc_type
)
1094 static int said
= 0;
1095 bpt
->loc_type
= new_type
;
1098 fprintf_filtered (gdb_stdout
, _("\
1099 Note: automatically using hardware breakpoints for read-only addresses.\n"));
1104 else if (bpt
->loc_type
== bp_loc_software_breakpoint
1105 && mr
->attrib
.mode
!= MEM_RW
)
1106 warning (_("cannot set software breakpoint at readonly address %s"),
1107 paddr (bpt
->address
));
1111 /* First check to see if we have to handle an overlay. */
1112 if (overlay_debugging
== ovly_off
1113 || bpt
->section
== NULL
1114 || !(section_is_overlay (bpt
->section
)))
1116 /* No overlay handling: just set the breakpoint. */
1118 if (bpt
->loc_type
== bp_loc_hardware_breakpoint
)
1119 val
= target_insert_hw_breakpoint (&bpt
->target_info
);
1121 val
= target_insert_breakpoint (&bpt
->target_info
);
1125 /* This breakpoint is in an overlay section.
1126 Shall we set a breakpoint at the LMA? */
1127 if (!overlay_events_enabled
)
1129 /* Yes -- overlay event support is not active,
1130 so we must try to set a breakpoint at the LMA.
1131 This will not work for a hardware breakpoint. */
1132 if (bpt
->loc_type
== bp_loc_hardware_breakpoint
)
1133 warning (_("hardware breakpoint %d not supported in overlay!"),
1134 bpt
->owner
->number
);
1137 CORE_ADDR addr
= overlay_unmapped_address (bpt
->address
,
1139 /* Set a software (trap) breakpoint at the LMA. */
1140 bpt
->overlay_target_info
= bpt
->target_info
;
1141 bpt
->overlay_target_info
.placed_address
= addr
;
1142 val
= target_insert_breakpoint (&bpt
->overlay_target_info
);
1144 fprintf_unfiltered (tmp_error_stream
,
1145 "Overlay breakpoint %d failed: in ROM?",
1146 bpt
->owner
->number
);
1149 /* Shall we set a breakpoint at the VMA? */
1150 if (section_is_mapped (bpt
->section
))
1152 /* Yes. This overlay section is mapped into memory. */
1153 if (bpt
->loc_type
== bp_loc_hardware_breakpoint
)
1154 val
= target_insert_hw_breakpoint (&bpt
->target_info
);
1156 val
= target_insert_breakpoint (&bpt
->target_info
);
1160 /* No. This breakpoint will not be inserted.
1161 No error, but do not mark the bp as 'inserted'. */
1168 /* Can't set the breakpoint. */
1169 if (solib_address (bpt
->address
))
1171 /* See also: disable_breakpoints_in_shlibs. */
1173 bpt
->shlib_disabled
= 1;
1174 if (!*disabled_breaks
)
1176 fprintf_unfiltered (tmp_error_stream
,
1177 "Cannot insert breakpoint %d.\n",
1178 bpt
->owner
->number
);
1179 fprintf_unfiltered (tmp_error_stream
,
1180 "Temporarily disabling shared library breakpoints:\n");
1182 *disabled_breaks
= 1;
1183 fprintf_unfiltered (tmp_error_stream
,
1184 "breakpoint #%d\n", bpt
->owner
->number
);
1188 #ifdef ONE_PROCESS_WRITETEXT
1189 *process_warning
= 1;
1191 if (bpt
->loc_type
== bp_loc_hardware_breakpoint
)
1193 *hw_breakpoint_error
= 1;
1194 fprintf_unfiltered (tmp_error_stream
,
1195 "Cannot insert hardware breakpoint %d.\n",
1196 bpt
->owner
->number
);
1200 fprintf_unfiltered (tmp_error_stream
,
1201 "Cannot insert breakpoint %d.\n",
1202 bpt
->owner
->number
);
1203 fprintf_filtered (tmp_error_stream
,
1204 "Error accessing memory address ");
1205 fputs_filtered (paddress (bpt
->address
), tmp_error_stream
);
1206 fprintf_filtered (tmp_error_stream
, ": %s.\n",
1207 safe_strerror (val
));
1218 else if (bpt
->loc_type
== bp_loc_hardware_watchpoint
1219 /* NOTE drow/2003-09-08: This state only exists for removing
1220 watchpoints. It's not clear that it's necessary... */
1221 && bpt
->owner
->disposition
!= disp_del_at_next_stop
)
1223 val
= target_insert_watchpoint (bpt
->address
,
1225 bpt
->watchpoint_type
);
1226 bpt
->inserted
= (val
!= -1);
1229 else if (bpt
->owner
->type
== bp_catch_fork
1230 || bpt
->owner
->type
== bp_catch_vfork
1231 || bpt
->owner
->type
== bp_catch_exec
)
1233 struct gdb_exception e
= catch_exception (uiout
, insert_catchpoint
,
1234 bpt
->owner
, RETURN_MASK_ERROR
);
1235 exception_fprintf (gdb_stderr
, e
, "warning: inserting catchpoint %d: ",
1236 bpt
->owner
->number
);
1238 bpt
->owner
->enable_state
= bp_disabled
;
1242 /* We've already printed an error message if there was a problem
1243 inserting this catchpoint, and we've disabled the catchpoint,
1244 so just return success. */
1251 /* Make sure all breakpoints are inserted in inferior.
1252 Throws exception on any error.
1253 A breakpoint that is already inserted won't be inserted
1254 again, so calling this function twice is safe. */
1256 insert_breakpoints (void)
1258 struct breakpoint
*bpt
;
1260 ALL_BREAKPOINTS (bpt
)
1261 if (is_hardware_watchpoint (bpt
))
1262 update_watchpoint (bpt
, 0 /* don't reparse. */);
1264 update_global_location_list ();
1266 if (!always_inserted_mode
&& target_has_execution
)
1267 /* update_global_location_list does not insert breakpoints
1268 when always_inserted_mode is not enabled. Explicitly
1270 insert_breakpoint_locations ();
1273 /* insert_breakpoints is used when starting or continuing the program.
1274 remove_breakpoints is used when the program stops.
1275 Both return zero if successful,
1276 or an `errno' value if could not write the inferior. */
1279 insert_breakpoint_locations (void)
1281 struct breakpoint
*bpt
;
1282 struct bp_location
*b
, *temp
;
1285 int disabled_breaks
= 0;
1286 int hw_breakpoint_error
= 0;
1287 int process_warning
= 0;
1289 struct ui_file
*tmp_error_stream
= mem_fileopen ();
1290 make_cleanup_ui_file_delete (tmp_error_stream
);
1292 /* Explicitly mark the warning -- this will only be printed if
1293 there was an error. */
1294 fprintf_unfiltered (tmp_error_stream
, "Warning:\n");
1296 ALL_BP_LOCATIONS_SAFE (b
, temp
)
1298 if (!should_be_inserted (b
) || b
->inserted
)
1301 /* There is no point inserting thread-specific breakpoints if the
1302 thread no longer exists. */
1303 if (b
->owner
->thread
!= -1
1304 && !valid_thread_id (b
->owner
->thread
))
1307 val
= insert_bp_location (b
, tmp_error_stream
,
1308 &disabled_breaks
, &process_warning
,
1309 &hw_breakpoint_error
);
1314 /* If we failed to insert all locations of a watchpoint,
1315 remove them, as half-inserted watchpoint is of limited use. */
1316 ALL_BREAKPOINTS (bpt
)
1318 int some_failed
= 0;
1319 struct bp_location
*loc
;
1321 if (!is_hardware_watchpoint (bpt
))
1324 if (bpt
->enable_state
!= bp_enabled
)
1327 if (bpt
->disposition
== disp_del_at_next_stop
)
1330 for (loc
= bpt
->loc
; loc
; loc
= loc
->next
)
1338 for (loc
= bpt
->loc
; loc
; loc
= loc
->next
)
1340 remove_breakpoint (loc
, mark_uninserted
);
1342 hw_breakpoint_error
= 1;
1343 fprintf_unfiltered (tmp_error_stream
,
1344 "Could not insert hardware watchpoint %d.\n",
1352 /* If a hardware breakpoint or watchpoint was inserted, add a
1353 message about possibly exhausted resources. */
1354 if (hw_breakpoint_error
)
1356 fprintf_unfiltered (tmp_error_stream
,
1357 "Could not insert hardware breakpoints:\n\
1358 You may have requested too many hardware breakpoints/watchpoints.\n");
1360 #ifdef ONE_PROCESS_WRITETEXT
1361 if (process_warning
)
1362 fprintf_unfiltered (tmp_error_stream
,
1363 "The same program may be running in another process.");
1365 target_terminal_ours_for_output ();
1366 error_stream (tmp_error_stream
);
1371 remove_breakpoints (void)
1373 struct bp_location
*b
;
1376 ALL_BP_LOCATIONS (b
)
1380 val
= remove_breakpoint (b
, mark_uninserted
);
1389 remove_hw_watchpoints (void)
1391 struct bp_location
*b
;
1394 ALL_BP_LOCATIONS (b
)
1396 if (b
->inserted
&& b
->loc_type
== bp_loc_hardware_watchpoint
)
1398 val
= remove_breakpoint (b
, mark_uninserted
);
1407 reattach_breakpoints (int pid
)
1409 struct bp_location
*b
;
1411 struct cleanup
*old_chain
= save_inferior_ptid ();
1412 struct ui_file
*tmp_error_stream
= mem_fileopen ();
1413 int dummy1
= 0, dummy2
= 0, dummy3
= 0;
1415 make_cleanup_ui_file_delete (tmp_error_stream
);
1417 inferior_ptid
= pid_to_ptid (pid
);
1418 ALL_BP_LOCATIONS (b
)
1423 val
= insert_bp_location (b
, tmp_error_stream
,
1424 &dummy1
, &dummy2
, &dummy3
);
1427 do_cleanups (old_chain
);
1432 do_cleanups (old_chain
);
1437 update_breakpoints_after_exec (void)
1439 struct breakpoint
*b
;
1440 struct breakpoint
*temp
;
1441 struct cleanup
*cleanup
;
1443 /* Doing this first prevents the badness of having delete_breakpoint()
1444 write a breakpoint's current "shadow contents" to lift the bp. That
1445 shadow is NOT valid after an exec()! */
1446 mark_breakpoints_out ();
1448 /* The binary we used to debug is now gone, and we're updating
1449 breakpoints for the new binary. Until we're done, we should not
1450 try to insert breakpoints. */
1451 cleanup
= make_cleanup_restore_integer (&always_inserted_mode
);
1452 always_inserted_mode
= 0;
1454 ALL_BREAKPOINTS_SAFE (b
, temp
)
1456 /* Solib breakpoints must be explicitly reset after an exec(). */
1457 if (b
->type
== bp_shlib_event
)
1459 delete_breakpoint (b
);
1463 /* Thread event breakpoints must be set anew after an exec(),
1464 as must overlay event breakpoints. */
1465 if (b
->type
== bp_thread_event
|| b
->type
== bp_overlay_event
)
1467 delete_breakpoint (b
);
1471 /* Step-resume breakpoints are meaningless after an exec(). */
1472 if (b
->type
== bp_step_resume
)
1474 delete_breakpoint (b
);
1478 /* Longjmp and longjmp-resume breakpoints are also meaningless
1480 if (b
->type
== bp_longjmp
|| b
->type
== bp_longjmp_resume
)
1482 delete_breakpoint (b
);
1486 /* Don't delete an exec catchpoint, because else the inferior
1487 won't stop when it ought!
1489 Similarly, we probably ought to keep vfork catchpoints, 'cause
1490 on this target, we may not be able to stop when the vfork is
1491 seen, but only when the subsequent exec is seen. (And because
1492 deleting fork catchpoints here but not vfork catchpoints will
1493 seem mysterious to users, keep those too.) */
1494 if ((b
->type
== bp_catch_exec
) ||
1495 (b
->type
== bp_catch_vfork
) ||
1496 (b
->type
== bp_catch_fork
))
1501 /* bp_finish is a special case. The only way we ought to be able
1502 to see one of these when an exec() has happened, is if the user
1503 caught a vfork, and then said "finish". Ordinarily a finish just
1504 carries them to the call-site of the current callee, by setting
1505 a temporary bp there and resuming. But in this case, the finish
1506 will carry them entirely through the vfork & exec.
1508 We don't want to allow a bp_finish to remain inserted now. But
1509 we can't safely delete it, 'cause finish_command has a handle to
1510 the bp on a bpstat, and will later want to delete it. There's a
1511 chance (and I've seen it happen) that if we delete the bp_finish
1512 here, that its storage will get reused by the time finish_command
1513 gets 'round to deleting the "use to be a bp_finish" breakpoint.
1514 We really must allow finish_command to delete a bp_finish.
1516 In the absense of a general solution for the "how do we know
1517 it's safe to delete something others may have handles to?"
1518 problem, what we'll do here is just uninsert the bp_finish, and
1519 let finish_command delete it.
1521 (We know the bp_finish is "doomed" in the sense that it's
1522 momentary, and will be deleted as soon as finish_command sees
1523 the inferior stopped. So it doesn't matter that the bp's
1524 address is probably bogus in the new a.out, unlike e.g., the
1525 solib breakpoints.) */
1527 if (b
->type
== bp_finish
)
1532 /* Without a symbolic address, we have little hope of the
1533 pre-exec() address meaning the same thing in the post-exec()
1535 if (b
->addr_string
== NULL
)
1537 delete_breakpoint (b
);
1541 /* FIXME what about longjmp breakpoints? Re-create them here? */
1542 create_overlay_event_breakpoint ("_ovly_debug_event");
1543 do_cleanups (cleanup
);
1547 detach_breakpoints (int pid
)
1549 struct bp_location
*b
;
1551 struct cleanup
*old_chain
= save_inferior_ptid ();
1553 if (pid
== PIDGET (inferior_ptid
))
1554 error (_("Cannot detach breakpoints of inferior_ptid"));
1556 /* Set inferior_ptid; remove_breakpoint uses this global. */
1557 inferior_ptid
= pid_to_ptid (pid
);
1558 ALL_BP_LOCATIONS (b
)
1562 val
= remove_breakpoint (b
, mark_inserted
);
1565 do_cleanups (old_chain
);
1570 do_cleanups (old_chain
);
1575 remove_breakpoint (struct bp_location
*b
, insertion_state_t is
)
1579 if (b
->owner
->enable_state
== bp_permanent
)
1580 /* Permanent breakpoints cannot be inserted or removed. */
1583 /* The type of none suggests that owner is actually deleted.
1584 This should not ever happen. */
1585 gdb_assert (b
->owner
->type
!= bp_none
);
1587 if (b
->loc_type
== bp_loc_software_breakpoint
1588 || b
->loc_type
== bp_loc_hardware_breakpoint
)
1590 /* "Normal" instruction breakpoint: either the standard
1591 trap-instruction bp (bp_breakpoint), or a
1592 bp_hardware_breakpoint. */
1594 /* First check to see if we have to handle an overlay. */
1595 if (overlay_debugging
== ovly_off
1596 || b
->section
== NULL
1597 || !(section_is_overlay (b
->section
)))
1599 /* No overlay handling: just remove the breakpoint. */
1601 if (b
->loc_type
== bp_loc_hardware_breakpoint
)
1602 val
= target_remove_hw_breakpoint (&b
->target_info
);
1604 val
= target_remove_breakpoint (&b
->target_info
);
1608 /* This breakpoint is in an overlay section.
1609 Did we set a breakpoint at the LMA? */
1610 if (!overlay_events_enabled
)
1612 /* Yes -- overlay event support is not active, so we
1613 should have set a breakpoint at the LMA. Remove it.
1615 /* Ignore any failures: if the LMA is in ROM, we will
1616 have already warned when we failed to insert it. */
1617 if (b
->loc_type
== bp_loc_hardware_breakpoint
)
1618 target_remove_hw_breakpoint (&b
->overlay_target_info
);
1620 target_remove_breakpoint (&b
->overlay_target_info
);
1622 /* Did we set a breakpoint at the VMA?
1623 If so, we will have marked the breakpoint 'inserted'. */
1626 /* Yes -- remove it. Previously we did not bother to
1627 remove the breakpoint if the section had been
1628 unmapped, but let's not rely on that being safe. We
1629 don't know what the overlay manager might do. */
1630 if (b
->loc_type
== bp_loc_hardware_breakpoint
)
1631 val
= target_remove_hw_breakpoint (&b
->target_info
);
1633 /* However, we should remove *software* breakpoints only
1634 if the section is still mapped, or else we overwrite
1635 wrong code with the saved shadow contents. */
1636 else if (section_is_mapped (b
->section
))
1637 val
= target_remove_breakpoint (&b
->target_info
);
1643 /* No -- not inserted, so no need to remove. No error. */
1649 b
->inserted
= (is
== mark_inserted
);
1651 else if (b
->loc_type
== bp_loc_hardware_watchpoint
)
1656 b
->inserted
= (is
== mark_inserted
);
1657 val
= target_remove_watchpoint (b
->address
, b
->length
,
1658 b
->watchpoint_type
);
1660 /* Failure to remove any of the hardware watchpoints comes here. */
1661 if ((is
== mark_uninserted
) && (b
->inserted
))
1662 warning (_("Could not remove hardware watchpoint %d."),
1665 else if ((b
->owner
->type
== bp_catch_fork
||
1666 b
->owner
->type
== bp_catch_vfork
||
1667 b
->owner
->type
== bp_catch_exec
)
1668 && breakpoint_enabled (b
->owner
)
1672 switch (b
->owner
->type
)
1675 val
= target_remove_fork_catchpoint (PIDGET (inferior_ptid
));
1677 case bp_catch_vfork
:
1678 val
= target_remove_vfork_catchpoint (PIDGET (inferior_ptid
));
1681 val
= target_remove_exec_catchpoint (PIDGET (inferior_ptid
));
1684 warning (_("Internal error, %s line %d."), __FILE__
, __LINE__
);
1689 b
->inserted
= (is
== mark_inserted
);
1695 /* Clear the "inserted" flag in all breakpoints. */
1698 mark_breakpoints_out (void)
1700 struct bp_location
*bpt
;
1702 ALL_BP_LOCATIONS (bpt
)
1706 /* Clear the "inserted" flag in all breakpoints and delete any
1707 breakpoints which should go away between runs of the program.
1709 Plus other such housekeeping that has to be done for breakpoints
1712 Note: this function gets called at the end of a run (by
1713 generic_mourn_inferior) and when a run begins (by
1714 init_wait_for_inferior). */
1719 breakpoint_init_inferior (enum inf_context context
)
1721 struct breakpoint
*b
, *temp
;
1722 struct bp_location
*bpt
;
1724 ALL_BP_LOCATIONS (bpt
)
1727 ALL_BREAKPOINTS_SAFE (b
, temp
)
1732 case bp_watchpoint_scope
:
1734 /* If the call dummy breakpoint is at the entry point it will
1735 cause problems when the inferior is rerun, so we better
1738 Also get rid of scope breakpoints. */
1739 delete_breakpoint (b
);
1743 case bp_hardware_watchpoint
:
1744 case bp_read_watchpoint
:
1745 case bp_access_watchpoint
:
1747 /* Likewise for watchpoints on local expressions. */
1748 if (b
->exp_valid_block
!= NULL
)
1749 delete_breakpoint (b
);
1750 else if (context
== inf_starting
)
1752 /* Reset val field to force reread of starting value
1753 in insert_breakpoints. */
1755 value_free (b
->val
);
1766 /* breakpoint_here_p (PC) returns non-zero if an enabled breakpoint
1767 exists at PC. It returns ordinary_breakpoint_here if it's an
1768 ordinary breakpoint, or permanent_breakpoint_here if it's a
1769 permanent breakpoint.
1770 - When continuing from a location with an ordinary breakpoint, we
1771 actually single step once before calling insert_breakpoints.
1772 - When continuing from a localion with a permanent breakpoint, we
1773 need to use the `SKIP_PERMANENT_BREAKPOINT' macro, provided by
1774 the target, to advance the PC past the breakpoint. */
1776 enum breakpoint_here
1777 breakpoint_here_p (CORE_ADDR pc
)
1779 const struct bp_location
*bpt
;
1780 int any_breakpoint_here
= 0;
1782 ALL_BP_LOCATIONS (bpt
)
1784 if (bpt
->loc_type
!= bp_loc_software_breakpoint
1785 && bpt
->loc_type
!= bp_loc_hardware_breakpoint
)
1788 if ((breakpoint_enabled (bpt
->owner
)
1789 || bpt
->owner
->enable_state
== bp_permanent
)
1790 && bpt
->address
== pc
) /* bp is enabled and matches pc */
1792 if (overlay_debugging
1793 && section_is_overlay (bpt
->section
)
1794 && !section_is_mapped (bpt
->section
))
1795 continue; /* unmapped overlay -- can't be a match */
1796 else if (bpt
->owner
->enable_state
== bp_permanent
)
1797 return permanent_breakpoint_here
;
1799 any_breakpoint_here
= 1;
1803 return any_breakpoint_here
? ordinary_breakpoint_here
: 0;
1807 /* Returns non-zero if there's a breakpoint inserted at PC, which is
1808 inserted using regular breakpoint_chain/bp_location_chain mechanism.
1809 This does not check for single-step breakpoints, which are
1810 inserted and removed using direct target manipulation. */
1813 regular_breakpoint_inserted_here_p (CORE_ADDR pc
)
1815 const struct bp_location
*bpt
;
1817 ALL_BP_LOCATIONS (bpt
)
1819 if (bpt
->loc_type
!= bp_loc_software_breakpoint
1820 && bpt
->loc_type
!= bp_loc_hardware_breakpoint
)
1824 && bpt
->address
== pc
) /* bp is inserted and matches pc */
1826 if (overlay_debugging
1827 && section_is_overlay (bpt
->section
)
1828 && !section_is_mapped (bpt
->section
))
1829 continue; /* unmapped overlay -- can't be a match */
1837 /* Returns non-zero iff there's either regular breakpoint
1838 or a single step breakpoint inserted at PC. */
1841 breakpoint_inserted_here_p (CORE_ADDR pc
)
1843 if (regular_breakpoint_inserted_here_p (pc
))
1846 if (single_step_breakpoint_inserted_here_p (pc
))
1852 /* This function returns non-zero iff there is a software breakpoint
1856 software_breakpoint_inserted_here_p (CORE_ADDR pc
)
1858 const struct bp_location
*bpt
;
1859 int any_breakpoint_here
= 0;
1861 ALL_BP_LOCATIONS (bpt
)
1863 if (bpt
->loc_type
!= bp_loc_software_breakpoint
)
1867 && bpt
->address
== pc
) /* bp is enabled and matches pc */
1869 if (overlay_debugging
1870 && section_is_overlay (bpt
->section
)
1871 && !section_is_mapped (bpt
->section
))
1872 continue; /* unmapped overlay -- can't be a match */
1878 /* Also check for software single-step breakpoints. */
1879 if (single_step_breakpoint_inserted_here_p (pc
))
1885 /* breakpoint_thread_match (PC, PTID) returns true if the breakpoint at
1886 PC is valid for process/thread PTID. */
1889 breakpoint_thread_match (CORE_ADDR pc
, ptid_t ptid
)
1891 const struct bp_location
*bpt
;
1894 thread
= pid_to_thread_id (ptid
);
1896 ALL_BP_LOCATIONS (bpt
)
1898 if (bpt
->loc_type
!= bp_loc_software_breakpoint
1899 && bpt
->loc_type
!= bp_loc_hardware_breakpoint
)
1902 if ((breakpoint_enabled (bpt
->owner
)
1903 || bpt
->owner
->enable_state
== bp_permanent
)
1904 && bpt
->address
== pc
1905 && (bpt
->owner
->thread
== -1 || bpt
->owner
->thread
== thread
))
1907 if (overlay_debugging
1908 && section_is_overlay (bpt
->section
)
1909 && !section_is_mapped (bpt
->section
))
1910 continue; /* unmapped overlay -- can't be a match */
1920 /* bpstat stuff. External routines' interfaces are documented
1924 ep_is_catchpoint (struct breakpoint
*ep
)
1927 (ep
->type
== bp_catch_load
)
1928 || (ep
->type
== bp_catch_unload
)
1929 || (ep
->type
== bp_catch_fork
)
1930 || (ep
->type
== bp_catch_vfork
)
1931 || (ep
->type
== bp_catch_exec
);
1933 /* ??rehrauer: Add more kinds here, as are implemented... */
1937 ep_is_shlib_catchpoint (struct breakpoint
*ep
)
1940 (ep
->type
== bp_catch_load
)
1941 || (ep
->type
== bp_catch_unload
);
1945 bpstat_free (bpstat bs
)
1947 if (bs
->old_val
!= NULL
)
1948 value_free (bs
->old_val
);
1949 free_command_lines (&bs
->commands
);
1953 /* Clear a bpstat so that it says we are not at any breakpoint.
1954 Also free any storage that is part of a bpstat. */
1957 bpstat_clear (bpstat
*bsp
)
1974 /* Return a copy of a bpstat. Like "bs1 = bs2" but all storage that
1975 is part of the bpstat is copied as well. */
1978 bpstat_copy (bpstat bs
)
1982 bpstat retval
= NULL
;
1987 for (; bs
!= NULL
; bs
= bs
->next
)
1989 tmp
= (bpstat
) xmalloc (sizeof (*tmp
));
1990 memcpy (tmp
, bs
, sizeof (*tmp
));
1991 if (bs
->commands
!= NULL
)
1992 tmp
->commands
= copy_command_lines (bs
->commands
);
1993 if (bs
->old_val
!= NULL
)
1994 tmp
->old_val
= value_copy (bs
->old_val
);
1997 /* This is the first thing in the chain. */
2007 /* Find the bpstat associated with this breakpoint */
2010 bpstat_find_breakpoint (bpstat bsp
, struct breakpoint
*breakpoint
)
2015 for (; bsp
!= NULL
; bsp
= bsp
->next
)
2017 if (bsp
->breakpoint_at
&& bsp
->breakpoint_at
->owner
== breakpoint
)
2023 /* Find a step_resume breakpoint associated with this bpstat.
2024 (If there are multiple step_resume bp's on the list, this function
2025 will arbitrarily pick one.)
2027 It is an error to use this function if BPSTAT doesn't contain a
2028 step_resume breakpoint.
2030 See wait_for_inferior's use of this function. */
2032 bpstat_find_step_resume_breakpoint (bpstat bsp
)
2036 gdb_assert (bsp
!= NULL
);
2038 current_thread
= pid_to_thread_id (inferior_ptid
);
2040 for (; bsp
!= NULL
; bsp
= bsp
->next
)
2042 if ((bsp
->breakpoint_at
!= NULL
) &&
2043 (bsp
->breakpoint_at
->owner
->type
== bp_step_resume
) &&
2044 (bsp
->breakpoint_at
->owner
->thread
== current_thread
||
2045 bsp
->breakpoint_at
->owner
->thread
== -1))
2046 return bsp
->breakpoint_at
->owner
;
2049 internal_error (__FILE__
, __LINE__
, _("No step_resume breakpoint found."));
2053 /* Put in *NUM the breakpoint number of the first breakpoint we are stopped
2054 at. *BSP upon return is a bpstat which points to the remaining
2055 breakpoints stopped at (but which is not guaranteed to be good for
2056 anything but further calls to bpstat_num).
2057 Return 0 if passed a bpstat which does not indicate any breakpoints.
2058 Return -1 if stopped at a breakpoint that has been deleted since
2060 Return 1 otherwise. */
2063 bpstat_num (bpstat
*bsp
, int *num
)
2065 struct breakpoint
*b
;
2068 return 0; /* No more breakpoint values */
2070 /* We assume we'll never have several bpstats that
2071 correspond to a single breakpoint -- otherwise,
2072 this function might return the same number more
2073 than once and this will look ugly. */
2074 b
= (*bsp
)->breakpoint_at
? (*bsp
)->breakpoint_at
->owner
: NULL
;
2075 *bsp
= (*bsp
)->next
;
2077 return -1; /* breakpoint that's been deleted since */
2079 *num
= b
->number
; /* We have its number */
2083 /* Modify BS so that the actions will not be performed. */
2086 bpstat_clear_actions (bpstat bs
)
2088 for (; bs
!= NULL
; bs
= bs
->next
)
2090 free_command_lines (&bs
->commands
);
2091 if (bs
->old_val
!= NULL
)
2093 value_free (bs
->old_val
);
2099 /* Stub for cleaning up our state if we error-out of a breakpoint command */
2101 cleanup_executing_breakpoints (void *ignore
)
2103 executing_breakpoint_commands
= 0;
2106 /* Execute all the commands associated with all the breakpoints at this
2107 location. Any of these commands could cause the process to proceed
2108 beyond this point, etc. We look out for such changes by checking
2109 the global "breakpoint_proceeded" after each command. */
2112 bpstat_do_actions (bpstat
*bsp
)
2115 struct cleanup
*old_chain
;
2117 /* Avoid endless recursion if a `source' command is contained
2119 if (executing_breakpoint_commands
)
2122 executing_breakpoint_commands
= 1;
2123 old_chain
= make_cleanup (cleanup_executing_breakpoints
, 0);
2126 /* Note that (as of this writing), our callers all appear to
2127 be passing us the address of global stop_bpstat. And, if
2128 our calls to execute_control_command cause the inferior to
2129 proceed, that global (and hence, *bsp) will change.
2131 We must be careful to not touch *bsp unless the inferior
2132 has not proceeded. */
2134 /* This pointer will iterate over the list of bpstat's. */
2137 breakpoint_proceeded
= 0;
2138 for (; bs
!= NULL
; bs
= bs
->next
)
2140 struct command_line
*cmd
;
2141 struct cleanup
*this_cmd_tree_chain
;
2143 /* Take ownership of the BSP's command tree, if it has one.
2145 The command tree could legitimately contain commands like
2146 'step' and 'next', which call clear_proceed_status, which
2147 frees stop_bpstat's command tree. To make sure this doesn't
2148 free the tree we're executing out from under us, we need to
2149 take ownership of the tree ourselves. Since a given bpstat's
2150 commands are only executed once, we don't need to copy it; we
2151 can clear the pointer in the bpstat, and make sure we free
2152 the tree when we're done. */
2155 this_cmd_tree_chain
= make_cleanup_free_command_lines (&cmd
);
2159 execute_control_command (cmd
);
2161 if (breakpoint_proceeded
)
2167 /* We can free this command tree now. */
2168 do_cleanups (this_cmd_tree_chain
);
2170 if (breakpoint_proceeded
)
2172 if (target_can_async_p ())
2173 /* If we are in async mode, then the target might
2174 be still running, not stopped at any breakpoint,
2175 so nothing for us to do here -- just return to
2179 /* In sync mode, when execute_control_command returns
2180 we're already standing on the next breakpoint.
2181 Breakpoint commands for that stop were not run,
2182 since execute_command does not run breakpoint
2183 commands -- only command_line_handler does, but
2184 that one is not involved in execution of breakpoint
2185 commands. So, we can now execute breakpoint commands.
2186 There's an implicit assumption that we're called with
2187 stop_bpstat, so our parameter is the new bpstat to
2189 It should be noted that making execute_command do
2190 bpstat actions is not an option -- in this case we'll
2191 have recursive invocation of bpstat for each breakpoint
2192 with a command, and can easily blow up GDB stack. */
2196 do_cleanups (old_chain
);
2199 /* Print out the (old or new) value associated with a watchpoint. */
2202 watchpoint_value_print (struct value
*val
, struct ui_file
*stream
)
2205 fprintf_unfiltered (stream
, _("<unreadable>"));
2207 value_print (val
, stream
, 0, Val_pretty_default
);
2210 /* This is the normal print function for a bpstat. In the future,
2211 much of this logic could (should?) be moved to bpstat_stop_status,
2212 by having it set different print_it values.
2214 Current scheme: When we stop, bpstat_print() is called. It loops
2215 through the bpstat list of things causing this stop, calling the
2216 print_bp_stop_message function on each one. The behavior of the
2217 print_bp_stop_message function depends on the print_it field of
2218 bpstat. If such field so indicates, call this function here.
2220 Return values from this routine (ultimately used by bpstat_print()
2221 and normal_stop() to decide what to do):
2222 PRINT_NOTHING: Means we already printed all we needed to print,
2223 don't print anything else.
2224 PRINT_SRC_ONLY: Means we printed something, and we do *not* desire
2225 that something to be followed by a location.
2226 PRINT_SCR_AND_LOC: Means we printed something, and we *do* desire
2227 that something to be followed by a location.
2228 PRINT_UNKNOWN: Means we printed nothing or we need to do some more
2231 static enum print_stop_action
2232 print_it_typical (bpstat bs
)
2234 struct cleanup
*old_chain
, *ui_out_chain
;
2235 struct breakpoint
*b
;
2236 const struct bp_location
*bl
;
2237 struct ui_stream
*stb
;
2239 stb
= ui_out_stream_new (uiout
);
2240 old_chain
= make_cleanup_ui_out_stream_delete (stb
);
2241 /* bs->breakpoint_at can be NULL if it was a momentary breakpoint
2242 which has since been deleted. */
2243 if (bs
->breakpoint_at
== NULL
)
2244 return PRINT_UNKNOWN
;
2245 bl
= bs
->breakpoint_at
;
2251 case bp_hardware_breakpoint
:
2252 bp_temp
= bs
->breakpoint_at
->owner
->disposition
== disp_del
;
2253 if (bl
->address
!= bl
->requested_address
)
2254 breakpoint_adjustment_warning (bl
->requested_address
,
2257 annotate_breakpoint (b
->number
);
2259 ui_out_text (uiout
, "\nTemporary breakpoint ");
2261 ui_out_text (uiout
, "\nBreakpoint ");
2262 if (ui_out_is_mi_like_p (uiout
))
2264 ui_out_field_string (uiout
, "reason",
2265 async_reason_lookup (EXEC_ASYNC_BREAKPOINT_HIT
));
2266 ui_out_field_string (uiout
, "disp", bpdisp_text (b
->disposition
));
2268 ui_out_field_int (uiout
, "bkptno", b
->number
);
2269 ui_out_text (uiout
, ", ");
2270 return PRINT_SRC_AND_LOC
;
2273 case bp_shlib_event
:
2274 /* Did we stop because the user set the stop_on_solib_events
2275 variable? (If so, we report this as a generic, "Stopped due
2276 to shlib event" message.) */
2277 printf_filtered (_("Stopped due to shared library event\n"));
2278 return PRINT_NOTHING
;
2281 case bp_thread_event
:
2282 /* Not sure how we will get here.
2283 GDB should not stop for these breakpoints. */
2284 printf_filtered (_("Thread Event Breakpoint: gdb should not stop!\n"));
2285 return PRINT_NOTHING
;
2288 case bp_overlay_event
:
2289 /* By analogy with the thread event, GDB should not stop for these. */
2290 printf_filtered (_("Overlay Event Breakpoint: gdb should not stop!\n"));
2291 return PRINT_NOTHING
;
2295 annotate_catchpoint (b
->number
);
2296 printf_filtered (_("\nCatchpoint %d (loaded %s), "),
2298 b
->triggered_dll_pathname
);
2299 return PRINT_SRC_AND_LOC
;
2302 case bp_catch_unload
:
2303 annotate_catchpoint (b
->number
);
2304 printf_filtered (_("\nCatchpoint %d (unloaded %s), "),
2306 b
->triggered_dll_pathname
);
2307 return PRINT_SRC_AND_LOC
;
2311 annotate_catchpoint (b
->number
);
2312 printf_filtered (_("\nCatchpoint %d (forked process %d), "),
2314 b
->forked_inferior_pid
);
2315 return PRINT_SRC_AND_LOC
;
2318 case bp_catch_vfork
:
2319 annotate_catchpoint (b
->number
);
2320 printf_filtered (_("\nCatchpoint %d (vforked process %d), "),
2322 b
->forked_inferior_pid
);
2323 return PRINT_SRC_AND_LOC
;
2327 annotate_catchpoint (b
->number
);
2328 printf_filtered (_("\nCatchpoint %d (exec'd %s), "),
2331 return PRINT_SRC_AND_LOC
;
2335 case bp_hardware_watchpoint
:
2336 annotate_watchpoint (b
->number
);
2337 if (ui_out_is_mi_like_p (uiout
))
2340 async_reason_lookup (EXEC_ASYNC_WATCHPOINT_TRIGGER
));
2342 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "value");
2343 ui_out_text (uiout
, "\nOld value = ");
2344 watchpoint_value_print (bs
->old_val
, stb
->stream
);
2345 ui_out_field_stream (uiout
, "old", stb
);
2346 ui_out_text (uiout
, "\nNew value = ");
2347 watchpoint_value_print (b
->val
, stb
->stream
);
2348 ui_out_field_stream (uiout
, "new", stb
);
2349 do_cleanups (ui_out_chain
);
2350 ui_out_text (uiout
, "\n");
2351 /* More than one watchpoint may have been triggered. */
2352 return PRINT_UNKNOWN
;
2355 case bp_read_watchpoint
:
2356 if (ui_out_is_mi_like_p (uiout
))
2359 async_reason_lookup (EXEC_ASYNC_READ_WATCHPOINT_TRIGGER
));
2361 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "value");
2362 ui_out_text (uiout
, "\nValue = ");
2363 watchpoint_value_print (b
->val
, stb
->stream
);
2364 ui_out_field_stream (uiout
, "value", stb
);
2365 do_cleanups (ui_out_chain
);
2366 ui_out_text (uiout
, "\n");
2367 return PRINT_UNKNOWN
;
2370 case bp_access_watchpoint
:
2371 if (bs
->old_val
!= NULL
)
2373 annotate_watchpoint (b
->number
);
2374 if (ui_out_is_mi_like_p (uiout
))
2377 async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER
));
2379 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "value");
2380 ui_out_text (uiout
, "\nOld value = ");
2381 watchpoint_value_print (bs
->old_val
, stb
->stream
);
2382 ui_out_field_stream (uiout
, "old", stb
);
2383 ui_out_text (uiout
, "\nNew value = ");
2388 if (ui_out_is_mi_like_p (uiout
))
2391 async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER
));
2392 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "value");
2393 ui_out_text (uiout
, "\nValue = ");
2395 watchpoint_value_print (b
->val
, stb
->stream
);
2396 ui_out_field_stream (uiout
, "new", stb
);
2397 do_cleanups (ui_out_chain
);
2398 ui_out_text (uiout
, "\n");
2399 return PRINT_UNKNOWN
;
2402 /* Fall through, we don't deal with these types of breakpoints
2406 if (ui_out_is_mi_like_p (uiout
))
2409 async_reason_lookup (EXEC_ASYNC_FUNCTION_FINISHED
));
2410 return PRINT_UNKNOWN
;
2414 if (ui_out_is_mi_like_p (uiout
))
2417 async_reason_lookup (EXEC_ASYNC_LOCATION_REACHED
));
2418 return PRINT_UNKNOWN
;
2423 case bp_longjmp_resume
:
2424 case bp_step_resume
:
2425 case bp_watchpoint_scope
:
2428 return PRINT_UNKNOWN
;
2432 /* Generic routine for printing messages indicating why we
2433 stopped. The behavior of this function depends on the value
2434 'print_it' in the bpstat structure. Under some circumstances we
2435 may decide not to print anything here and delegate the task to
2438 static enum print_stop_action
2439 print_bp_stop_message (bpstat bs
)
2441 switch (bs
->print_it
)
2444 /* Nothing should be printed for this bpstat entry. */
2445 return PRINT_UNKNOWN
;
2449 /* We still want to print the frame, but we already printed the
2450 relevant messages. */
2451 return PRINT_SRC_AND_LOC
;
2454 case print_it_normal
:
2456 const struct bp_location
*bl
= bs
->breakpoint_at
;
2457 struct breakpoint
*b
= bl
? bl
->owner
: NULL
;
2459 /* Normal case. Call the breakpoint's print_it method, or
2460 print_it_typical. */
2461 /* FIXME: how breakpoint can ever be NULL here? */
2462 if (b
!= NULL
&& b
->ops
!= NULL
&& b
->ops
->print_it
!= NULL
)
2463 return b
->ops
->print_it (b
);
2465 return print_it_typical (bs
);
2470 internal_error (__FILE__
, __LINE__
,
2471 _("print_bp_stop_message: unrecognized enum value"));
2476 /* Print a message indicating what happened. This is called from
2477 normal_stop(). The input to this routine is the head of the bpstat
2478 list - a list of the eventpoints that caused this stop. This
2479 routine calls the generic print routine for printing a message
2480 about reasons for stopping. This will print (for example) the
2481 "Breakpoint n," part of the output. The return value of this
2484 PRINT_UNKNOWN: Means we printed nothing
2485 PRINT_SRC_AND_LOC: Means we printed something, and expect subsequent
2486 code to print the location. An example is
2487 "Breakpoint 1, " which should be followed by
2489 PRINT_SRC_ONLY: Means we printed something, but there is no need
2490 to also print the location part of the message.
2491 An example is the catch/throw messages, which
2492 don't require a location appended to the end.
2493 PRINT_NOTHING: We have done some printing and we don't need any
2494 further info to be printed.*/
2496 enum print_stop_action
2497 bpstat_print (bpstat bs
)
2501 /* Maybe another breakpoint in the chain caused us to stop.
2502 (Currently all watchpoints go on the bpstat whether hit or not.
2503 That probably could (should) be changed, provided care is taken
2504 with respect to bpstat_explains_signal). */
2505 for (; bs
; bs
= bs
->next
)
2507 val
= print_bp_stop_message (bs
);
2508 if (val
== PRINT_SRC_ONLY
2509 || val
== PRINT_SRC_AND_LOC
2510 || val
== PRINT_NOTHING
)
2514 /* We reached the end of the chain, or we got a null BS to start
2515 with and nothing was printed. */
2516 return PRINT_UNKNOWN
;
2519 /* Evaluate the expression EXP and return 1 if value is zero.
2520 This is used inside a catch_errors to evaluate the breakpoint condition.
2521 The argument is a "struct expression *" that has been cast to char * to
2522 make it pass through catch_errors. */
2525 breakpoint_cond_eval (void *exp
)
2527 struct value
*mark
= value_mark ();
2528 int i
= !value_true (evaluate_expression ((struct expression
*) exp
));
2529 value_free_to_mark (mark
);
2533 /* Allocate a new bpstat and chain it to the current one. */
2536 bpstat_alloc (const struct bp_location
*bl
, bpstat cbs
/* Current "bs" value */ )
2540 bs
= (bpstat
) xmalloc (sizeof (*bs
));
2542 bs
->breakpoint_at
= bl
;
2543 /* If the condition is false, etc., don't do the commands. */
2544 bs
->commands
= NULL
;
2546 bs
->print_it
= print_it_normal
;
2550 /* The target has stopped with waitstatus WS. Check if any hardware
2551 watchpoints have triggered, according to the target. */
2554 watchpoints_triggered (struct target_waitstatus
*ws
)
2556 int stopped_by_watchpoint
= STOPPED_BY_WATCHPOINT (*ws
);
2558 struct breakpoint
*b
;
2560 if (!stopped_by_watchpoint
)
2562 /* We were not stopped by a watchpoint. Mark all watchpoints
2563 as not triggered. */
2565 if (b
->type
== bp_hardware_watchpoint
2566 || b
->type
== bp_read_watchpoint
2567 || b
->type
== bp_access_watchpoint
)
2568 b
->watchpoint_triggered
= watch_triggered_no
;
2573 if (!target_stopped_data_address (¤t_target
, &addr
))
2575 /* We were stopped by a watchpoint, but we don't know where.
2576 Mark all watchpoints as unknown. */
2578 if (b
->type
== bp_hardware_watchpoint
2579 || b
->type
== bp_read_watchpoint
2580 || b
->type
== bp_access_watchpoint
)
2581 b
->watchpoint_triggered
= watch_triggered_unknown
;
2583 return stopped_by_watchpoint
;
2586 /* The target could report the data address. Mark watchpoints
2587 affected by this data address as triggered, and all others as not
2591 if (b
->type
== bp_hardware_watchpoint
2592 || b
->type
== bp_read_watchpoint
2593 || b
->type
== bp_access_watchpoint
)
2595 struct bp_location
*loc
;
2598 b
->watchpoint_triggered
= watch_triggered_no
;
2599 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
2600 /* Exact match not required. Within range is
2602 if (target_watchpoint_addr_within_range (¤t_target
,
2606 b
->watchpoint_triggered
= watch_triggered_yes
;
2614 /* Possible return values for watchpoint_check (this can't be an enum
2615 because of check_errors). */
2616 /* The watchpoint has been deleted. */
2617 #define WP_DELETED 1
2618 /* The value has changed. */
2619 #define WP_VALUE_CHANGED 2
2620 /* The value has not changed. */
2621 #define WP_VALUE_NOT_CHANGED 3
2623 #define BP_TEMPFLAG 1
2624 #define BP_HARDWAREFLAG 2
2626 /* Check watchpoint condition. */
2629 watchpoint_check (void *p
)
2631 bpstat bs
= (bpstat
) p
;
2632 struct breakpoint
*b
;
2633 struct frame_info
*fr
;
2634 int within_current_scope
;
2636 b
= bs
->breakpoint_at
->owner
;
2638 if (b
->exp_valid_block
== NULL
)
2639 within_current_scope
= 1;
2642 /* There is no current frame at this moment. If we're going to have
2643 any chance of handling watchpoints on local variables, we'll need
2644 the frame chain (so we can determine if we're in scope). */
2645 reinit_frame_cache ();
2646 fr
= frame_find_by_id (b
->watchpoint_frame
);
2647 within_current_scope
= (fr
!= NULL
);
2649 /* If we've gotten confused in the unwinder, we might have
2650 returned a frame that can't describe this variable. */
2651 if (within_current_scope
2652 && block_function (b
->exp_valid_block
) != get_frame_function (fr
))
2653 within_current_scope
= 0;
2655 /* in_function_epilogue_p() returns a non-zero value if we're still
2656 in the function but the stack frame has already been invalidated.
2657 Since we can't rely on the values of local variables after the
2658 stack has been destroyed, we are treating the watchpoint in that
2659 state as `not changed' without further checking.
2661 vinschen/2003-09-04: The former implementation left out the case
2662 that the watchpoint frame couldn't be found by frame_find_by_id()
2663 because the current PC is currently in an epilogue. Calling
2664 gdbarch_in_function_epilogue_p() also when fr == NULL fixes that. */
2665 if ((!within_current_scope
|| fr
== get_current_frame ())
2666 && gdbarch_in_function_epilogue_p (current_gdbarch
, read_pc ()))
2667 return WP_VALUE_NOT_CHANGED
;
2668 if (fr
&& within_current_scope
)
2669 /* If we end up stopping, the current frame will get selected
2670 in normal_stop. So this call to select_frame won't affect
2675 if (within_current_scope
)
2677 /* We use value_{,free_to_}mark because it could be a
2678 *long* time before we return to the command level and
2679 call free_all_values. We can't call free_all_values because
2680 we might be in the middle of evaluating a function call. */
2682 struct value
*mark
= value_mark ();
2683 struct value
*new_val
;
2685 fetch_watchpoint_value (b
->exp
, &new_val
, NULL
, NULL
);
2686 if ((b
->val
!= NULL
) != (new_val
!= NULL
)
2687 || (b
->val
!= NULL
&& !value_equal (b
->val
, new_val
)))
2689 if (new_val
!= NULL
)
2691 release_value (new_val
);
2692 value_free_to_mark (mark
);
2694 bs
->old_val
= b
->val
;
2697 /* We will stop here */
2698 return WP_VALUE_CHANGED
;
2702 /* Nothing changed, don't do anything. */
2703 value_free_to_mark (mark
);
2704 /* We won't stop here */
2705 return WP_VALUE_NOT_CHANGED
;
2710 /* This seems like the only logical thing to do because
2711 if we temporarily ignored the watchpoint, then when
2712 we reenter the block in which it is valid it contains
2713 garbage (in the case of a function, it may have two
2714 garbage values, one before and one after the prologue).
2715 So we can't even detect the first assignment to it and
2716 watch after that (since the garbage may or may not equal
2717 the first value assigned). */
2718 /* We print all the stop information in print_it_typical(), but
2719 in this case, by the time we call print_it_typical() this bp
2720 will be deleted already. So we have no choice but print the
2721 information here. */
2722 if (ui_out_is_mi_like_p (uiout
))
2724 (uiout
, "reason", async_reason_lookup (EXEC_ASYNC_WATCHPOINT_SCOPE
));
2725 ui_out_text (uiout
, "\nWatchpoint ");
2726 ui_out_field_int (uiout
, "wpnum", b
->number
);
2727 ui_out_text (uiout
, " deleted because the program has left the block in\n\
2728 which its expression is valid.\n");
2730 if (b
->related_breakpoint
)
2731 b
->related_breakpoint
->disposition
= disp_del_at_next_stop
;
2732 b
->disposition
= disp_del_at_next_stop
;
2738 /* Return true if it looks like target has stopped due to hitting
2739 breakpoint location BL. This function does not check if we
2740 should stop, only if BL explains the stop. */
2742 bpstat_check_location (const struct bp_location
*bl
, CORE_ADDR bp_addr
)
2744 struct breakpoint
*b
= bl
->owner
;
2746 if (b
->type
!= bp_watchpoint
2747 && b
->type
!= bp_hardware_watchpoint
2748 && b
->type
!= bp_read_watchpoint
2749 && b
->type
!= bp_access_watchpoint
2750 && b
->type
!= bp_hardware_breakpoint
2751 && b
->type
!= bp_catch_fork
2752 && b
->type
!= bp_catch_vfork
2753 && b
->type
!= bp_catch_exec
) /* a non-watchpoint bp */
2755 if (bl
->address
!= bp_addr
) /* address doesn't match */
2757 if (overlay_debugging
/* unmapped overlay section */
2758 && section_is_overlay (bl
->section
)
2759 && !section_is_mapped (bl
->section
))
2763 /* Continuable hardware watchpoints are treated as non-existent if the
2764 reason we stopped wasn't a hardware watchpoint (we didn't stop on
2765 some data address). Otherwise gdb won't stop on a break instruction
2766 in the code (not from a breakpoint) when a hardware watchpoint has
2767 been defined. Also skip watchpoints which we know did not trigger
2768 (did not match the data address). */
2770 if ((b
->type
== bp_hardware_watchpoint
2771 || b
->type
== bp_read_watchpoint
2772 || b
->type
== bp_access_watchpoint
)
2773 && b
->watchpoint_triggered
== watch_triggered_no
)
2776 if (b
->type
== bp_hardware_breakpoint
)
2778 if (bl
->address
!= bp_addr
)
2780 if (overlay_debugging
/* unmapped overlay section */
2781 && section_is_overlay (bl
->section
)
2782 && !section_is_mapped (bl
->section
))
2786 /* Is this a catchpoint of a load or unload? If so, did we
2787 get a load or unload of the specified library? If not,
2789 if ((b
->type
== bp_catch_load
)
2790 #if defined(SOLIB_HAVE_LOAD_EVENT)
2791 && (!SOLIB_HAVE_LOAD_EVENT (PIDGET (inferior_ptid
))
2792 || ((b
->dll_pathname
!= NULL
)
2793 && (strcmp (b
->dll_pathname
,
2794 SOLIB_LOADED_LIBRARY_PATHNAME (
2795 PIDGET (inferior_ptid
)))
2801 if ((b
->type
== bp_catch_unload
)
2802 #if defined(SOLIB_HAVE_UNLOAD_EVENT)
2803 && (!SOLIB_HAVE_UNLOAD_EVENT (PIDGET (inferior_ptid
))
2804 || ((b
->dll_pathname
!= NULL
)
2805 && (strcmp (b
->dll_pathname
,
2806 SOLIB_UNLOADED_LIBRARY_PATHNAME (
2807 PIDGET (inferior_ptid
)))
2813 if ((b
->type
== bp_catch_fork
)
2814 && !inferior_has_forked (PIDGET (inferior_ptid
),
2815 &b
->forked_inferior_pid
))
2818 if ((b
->type
== bp_catch_vfork
)
2819 && !inferior_has_vforked (PIDGET (inferior_ptid
),
2820 &b
->forked_inferior_pid
))
2823 if ((b
->type
== bp_catch_exec
)
2824 && !inferior_has_execd (PIDGET (inferior_ptid
), &b
->exec_pathname
))
2830 /* If BS refers to a watchpoint, determine if the watched values
2831 has actually changed, and we should stop. If not, set BS->stop
2834 bpstat_check_watchpoint (bpstat bs
)
2836 const struct bp_location
*bl
= bs
->breakpoint_at
;
2837 struct breakpoint
*b
= bl
->owner
;
2839 if (b
->type
== bp_watchpoint
2840 || b
->type
== bp_read_watchpoint
2841 || b
->type
== bp_access_watchpoint
2842 || b
->type
== bp_hardware_watchpoint
)
2846 int must_check_value
= 0;
2848 if (b
->type
== bp_watchpoint
)
2849 /* For a software watchpoint, we must always check the
2851 must_check_value
= 1;
2852 else if (b
->watchpoint_triggered
== watch_triggered_yes
)
2853 /* We have a hardware watchpoint (read, write, or access)
2854 and the target earlier reported an address watched by
2856 must_check_value
= 1;
2857 else if (b
->watchpoint_triggered
== watch_triggered_unknown
2858 && b
->type
== bp_hardware_watchpoint
)
2859 /* We were stopped by a hardware watchpoint, but the target could
2860 not report the data address. We must check the watchpoint's
2861 value. Access and read watchpoints are out of luck; without
2862 a data address, we can't figure it out. */
2863 must_check_value
= 1;
2865 if (must_check_value
)
2867 char *message
= xstrprintf ("Error evaluating expression for watchpoint %d\n",
2869 struct cleanup
*cleanups
= make_cleanup (xfree
, message
);
2870 int e
= catch_errors (watchpoint_check
, bs
, message
,
2872 do_cleanups (cleanups
);
2876 /* We've already printed what needs to be printed. */
2877 bs
->print_it
= print_it_done
;
2880 case WP_VALUE_CHANGED
:
2881 if (b
->type
== bp_read_watchpoint
)
2883 /* Don't stop: read watchpoints shouldn't fire if
2884 the value has changed. This is for targets
2885 which cannot set read-only watchpoints. */
2886 bs
->print_it
= print_it_noop
;
2890 case WP_VALUE_NOT_CHANGED
:
2891 if (b
->type
== bp_hardware_watchpoint
2892 || b
->type
== bp_watchpoint
)
2894 /* Don't stop: write watchpoints shouldn't fire if
2895 the value hasn't changed. */
2896 bs
->print_it
= print_it_noop
;
2904 /* Error from catch_errors. */
2905 printf_filtered (_("Watchpoint %d deleted.\n"), b
->number
);
2906 if (b
->related_breakpoint
)
2907 b
->related_breakpoint
->disposition
= disp_del_at_next_stop
;
2908 b
->disposition
= disp_del_at_next_stop
;
2909 /* We've already printed what needs to be printed. */
2910 bs
->print_it
= print_it_done
;
2914 else /* must_check_value == 0 */
2916 /* This is a case where some watchpoint(s) triggered, but
2917 not at the address of this watchpoint, or else no
2918 watchpoint triggered after all. So don't print
2919 anything for this watchpoint. */
2920 bs
->print_it
= print_it_noop
;
2927 /* Check conditions (condition proper, frame, thread and ignore count)
2928 of breakpoint referred to by BS. If we should not stop for this
2929 breakpoint, set BS->stop to 0. */
2931 bpstat_check_breakpoint_conditions (bpstat bs
, ptid_t ptid
)
2933 int thread_id
= pid_to_thread_id (ptid
);
2934 const struct bp_location
*bl
= bs
->breakpoint_at
;
2935 struct breakpoint
*b
= bl
->owner
;
2937 if (frame_id_p (b
->frame_id
)
2938 && !frame_id_eq (b
->frame_id
, get_frame_id (get_current_frame ())))
2942 int value_is_zero
= 0;
2944 /* If this is a scope breakpoint, mark the associated
2945 watchpoint as triggered so that we will handle the
2946 out-of-scope event. We'll get to the watchpoint next
2948 if (b
->type
== bp_watchpoint_scope
)
2949 b
->related_breakpoint
->watchpoint_triggered
= watch_triggered_yes
;
2951 if (bl
->cond
&& bl
->owner
->disposition
!= disp_del_at_next_stop
)
2953 /* Need to select the frame, with all that implies
2954 so that the conditions will have the right context. */
2955 select_frame (get_current_frame ());
2957 = catch_errors (breakpoint_cond_eval
, (bl
->cond
),
2958 "Error in testing breakpoint condition:\n",
2960 /* FIXME-someday, should give breakpoint # */
2963 if (bl
->cond
&& value_is_zero
)
2967 else if (b
->thread
!= -1 && b
->thread
!= thread_id
)
2971 else if (b
->ignore_count
> 0)
2974 annotate_ignore_count_change ();
2976 /* Increase the hit count even though we don't
2984 /* Get a bpstat associated with having just stopped at address
2985 BP_ADDR in thread PTID.
2987 Determine whether we stopped at a breakpoint, etc, or whether we
2988 don't understand this stop. Result is a chain of bpstat's such that:
2990 if we don't understand the stop, the result is a null pointer.
2992 if we understand why we stopped, the result is not null.
2994 Each element of the chain refers to a particular breakpoint or
2995 watchpoint at which we have stopped. (We may have stopped for
2996 several reasons concurrently.)
2998 Each element of the chain has valid next, breakpoint_at,
2999 commands, FIXME??? fields. */
3002 bpstat_stop_status (CORE_ADDR bp_addr
, ptid_t ptid
)
3004 struct breakpoint
*b
= NULL
;
3005 const struct bp_location
*bl
;
3006 /* Root of the chain of bpstat's */
3007 struct bpstats root_bs
[1];
3008 /* Pointer to the last thing in the chain currently. */
3009 bpstat bs
= root_bs
;
3011 ALL_BP_LOCATIONS (bl
)
3015 if (!breakpoint_enabled (b
) && b
->enable_state
!= bp_permanent
)
3018 /* For hardware watchpoints, we look only at the first location.
3019 The watchpoint_check function will work on entire expression,
3020 not the individual locations. For read watchopints, the
3021 watchpoints_triggered function have checked all locations
3024 if (b
->type
== bp_hardware_watchpoint
&& bl
!= b
->loc
)
3027 if (!bpstat_check_location (bl
, bp_addr
))
3030 /* Come here if it's a watchpoint, or if the break address matches */
3032 bs
= bpstat_alloc (bl
, bs
); /* Alloc a bpstat to explain stop */
3034 /* Assume we stop. Should we find watchpoint that is not actually
3035 triggered, or if condition of breakpoint is false, we'll reset
3040 bpstat_check_watchpoint (bs
);
3044 if (b
->type
== bp_thread_event
|| b
->type
== bp_overlay_event
)
3045 /* We do not stop for these. */
3048 bpstat_check_breakpoint_conditions (bs
, ptid
);
3054 /* We will stop here */
3055 if (b
->disposition
== disp_disable
)
3057 b
->enable_state
= bp_disabled
;
3058 update_global_location_list ();
3062 bs
->commands
= b
->commands
;
3064 (strcmp ("silent", bs
->commands
->line
) == 0
3065 || (xdb_commands
&& strcmp ("Q", bs
->commands
->line
) == 0)))
3067 bs
->commands
= bs
->commands
->next
;
3070 bs
->commands
= copy_command_lines (bs
->commands
);
3073 /* Print nothing for this entry if we dont stop or if we dont print. */
3074 if (bs
->stop
== 0 || bs
->print
== 0)
3075 bs
->print_it
= print_it_noop
;
3078 bs
->next
= NULL
; /* Terminate the chain */
3079 bs
= root_bs
->next
; /* Re-grab the head of the chain */
3081 /* If we aren't stopping, the value of some hardware watchpoint may
3082 not have changed, but the intermediate memory locations we are
3083 watching may have. Don't bother if we're stopping; this will get
3085 for (bs
= root_bs
->next
; bs
!= NULL
; bs
= bs
->next
)
3090 for (bs
= root_bs
->next
; bs
!= NULL
; bs
= bs
->next
)
3092 && (bs
->breakpoint_at
->owner
->type
== bp_hardware_watchpoint
3093 || bs
->breakpoint_at
->owner
->type
== bp_read_watchpoint
3094 || bs
->breakpoint_at
->owner
->type
== bp_access_watchpoint
))
3096 /* remove/insert can invalidate bs->breakpoint_at, if this
3097 location is no longer used by the watchpoint. Prevent
3098 further code from trying to use it. */
3099 bs
->breakpoint_at
= NULL
;
3100 remove_breakpoints ();
3101 insert_breakpoints ();
3105 return root_bs
->next
;
3108 /* Tell what to do about this bpstat. */
3110 bpstat_what (bpstat bs
)
3112 /* Classify each bpstat as one of the following. */
3115 /* This bpstat element has no effect on the main_action. */
3118 /* There was a watchpoint, stop but don't print. */
3121 /* There was a watchpoint, stop and print. */
3124 /* There was a breakpoint but we're not stopping. */
3127 /* There was a breakpoint, stop but don't print. */
3130 /* There was a breakpoint, stop and print. */
3133 /* We hit the longjmp breakpoint. */
3136 /* We hit the longjmp_resume breakpoint. */
3139 /* We hit the step_resume breakpoint. */
3142 /* We hit the shared library event breakpoint. */
3145 /* We caught a shared library event. */
3148 /* This is just used to count how many enums there are. */
3152 /* Here is the table which drives this routine. So that we can
3153 format it pretty, we define some abbreviations for the
3154 enum bpstat_what codes. */
3155 #define kc BPSTAT_WHAT_KEEP_CHECKING
3156 #define ss BPSTAT_WHAT_STOP_SILENT
3157 #define sn BPSTAT_WHAT_STOP_NOISY
3158 #define sgl BPSTAT_WHAT_SINGLE
3159 #define slr BPSTAT_WHAT_SET_LONGJMP_RESUME
3160 #define clr BPSTAT_WHAT_CLEAR_LONGJMP_RESUME
3161 #define sr BPSTAT_WHAT_STEP_RESUME
3162 #define shl BPSTAT_WHAT_CHECK_SHLIBS
3163 #define shlr BPSTAT_WHAT_CHECK_SHLIBS_RESUME_FROM_HOOK
3165 /* "Can't happen." Might want to print an error message.
3166 abort() is not out of the question, but chances are GDB is just
3167 a bit confused, not unusable. */
3168 #define err BPSTAT_WHAT_STOP_NOISY
3170 /* Given an old action and a class, come up with a new action. */
3171 /* One interesting property of this table is that wp_silent is the same
3172 as bp_silent and wp_noisy is the same as bp_noisy. That is because
3173 after stopping, the check for whether to step over a breakpoint
3174 (BPSTAT_WHAT_SINGLE type stuff) is handled in proceed() without
3175 reference to how we stopped. We retain separate wp_silent and
3176 bp_silent codes in case we want to change that someday.
3178 Another possibly interesting property of this table is that
3179 there's a partial ordering, priority-like, of the actions. Once
3180 you've decided that some action is appropriate, you'll never go
3181 back and decide something of a lower priority is better. The
3184 kc < clr sgl shl shlr slr sn sr ss
3185 sgl < shl shlr slr sn sr ss
3186 slr < err shl shlr sn sr ss
3187 clr < err shl shlr sn sr ss
3194 What I think this means is that we don't need a damned table
3195 here. If you just put the rows and columns in the right order,
3196 it'd look awfully regular. We could simply walk the bpstat list
3197 and choose the highest priority action we find, with a little
3198 logic to handle the 'err' cases. */
3200 /* step_resume entries: a step resume breakpoint overrides another
3201 breakpoint of signal handling (see comment in wait_for_inferior
3202 at where we set the step_resume breakpoint). */
3204 static const enum bpstat_what_main_action
3205 table
[(int) class_last
][(int) BPSTAT_WHAT_LAST
] =
3208 /* kc ss sn sgl slr clr sr shl shlr
3211 {kc
, ss
, sn
, sgl
, slr
, clr
, sr
, shl
, shlr
},
3213 {ss
, ss
, sn
, ss
, ss
, ss
, sr
, shl
, shlr
},
3215 {sn
, sn
, sn
, sn
, sn
, sn
, sr
, shl
, shlr
},
3217 {sgl
, ss
, sn
, sgl
, slr
, slr
, sr
, shl
, shlr
},
3219 {ss
, ss
, sn
, ss
, ss
, ss
, sr
, shl
, shlr
},
3221 {sn
, sn
, sn
, sn
, sn
, sn
, sr
, shl
, shlr
},
3223 {slr
, ss
, sn
, slr
, slr
, err
, sr
, shl
, shlr
},
3225 {clr
, ss
, sn
, err
, err
, err
, sr
, shl
, shlr
},
3227 {sr
, sr
, sr
, sr
, sr
, sr
, sr
, sr
, sr
},
3229 {shl
, shl
, shl
, shl
, shl
, shl
, sr
, shl
, shlr
},
3231 {shlr
, shlr
, shlr
, shlr
, shlr
, shlr
, sr
, shlr
, shlr
}
3245 enum bpstat_what_main_action current_action
= BPSTAT_WHAT_KEEP_CHECKING
;
3246 struct bpstat_what retval
;
3248 retval
.call_dummy
= 0;
3249 for (; bs
!= NULL
; bs
= bs
->next
)
3251 enum class bs_class
= no_effect
;
3252 if (bs
->breakpoint_at
== NULL
)
3253 /* I suspect this can happen if it was a momentary breakpoint
3254 which has since been deleted. */
3256 switch (bs
->breakpoint_at
->owner
->type
)
3262 case bp_hardware_breakpoint
:
3268 bs_class
= bp_noisy
;
3270 bs_class
= bp_silent
;
3273 bs_class
= bp_nostop
;
3276 case bp_hardware_watchpoint
:
3277 case bp_read_watchpoint
:
3278 case bp_access_watchpoint
:
3282 bs_class
= wp_noisy
;
3284 bs_class
= wp_silent
;
3287 /* There was a watchpoint, but we're not stopping.
3288 This requires no further action. */
3289 bs_class
= no_effect
;
3292 bs_class
= long_jump
;
3294 case bp_longjmp_resume
:
3295 bs_class
= long_resume
;
3297 case bp_step_resume
:
3300 bs_class
= step_resume
;
3303 /* It is for the wrong frame. */
3304 bs_class
= bp_nostop
;
3306 case bp_watchpoint_scope
:
3307 bs_class
= bp_nostop
;
3309 case bp_shlib_event
:
3310 bs_class
= shlib_event
;
3312 case bp_thread_event
:
3313 case bp_overlay_event
:
3314 bs_class
= bp_nostop
;
3317 case bp_catch_unload
:
3318 /* Only if this catchpoint triggered should we cause the
3319 step-out-of-dld behaviour. Otherwise, we ignore this
3322 bs_class
= catch_shlib_event
;
3324 bs_class
= no_effect
;
3327 case bp_catch_vfork
:
3332 bs_class
= bp_noisy
;
3334 bs_class
= bp_silent
;
3337 /* There was a catchpoint, but we're not stopping.
3338 This requires no further action. */
3339 bs_class
= no_effect
;
3342 /* Make sure the action is stop (silent or noisy),
3343 so infrun.c pops the dummy frame. */
3344 bs_class
= bp_silent
;
3345 retval
.call_dummy
= 1;
3348 current_action
= table
[(int) bs_class
][(int) current_action
];
3350 retval
.main_action
= current_action
;
3354 /* Nonzero if we should step constantly (e.g. watchpoints on machines
3355 without hardware support). This isn't related to a specific bpstat,
3356 just to things like whether watchpoints are set. */
3359 bpstat_should_step (void)
3361 struct breakpoint
*b
;
3363 if (breakpoint_enabled (b
) && b
->type
== bp_watchpoint
)
3370 /* Given a bpstat that records zero or more triggered eventpoints, this
3371 function returns another bpstat which contains only the catchpoints
3372 on that first list, if any. */
3374 bpstat_get_triggered_catchpoints (bpstat ep_list
, bpstat
*cp_list
)
3376 struct bpstats root_bs
[1];
3377 bpstat bs
= root_bs
;
3378 struct breakpoint
*ep
;
3381 bpstat_clear (cp_list
);
3382 root_bs
->next
= NULL
;
3384 for (; ep_list
!= NULL
; ep_list
= ep_list
->next
)
3386 /* Is this eventpoint a catchpoint? If not, ignore it. */
3387 ep
= ep_list
->breakpoint_at
->owner
;
3390 if ((ep
->type
!= bp_catch_load
) &&
3391 (ep
->type
!= bp_catch_unload
))
3392 /* pai: (temp) ADD fork/vfork here!! */
3395 /* Yes; add it to the list. */
3396 bs
= bpstat_alloc (ep_list
->breakpoint_at
, bs
);
3401 #if defined(SOLIB_ADD)
3402 /* Also, for each triggered catchpoint, tag it with the name of
3403 the library that caused this trigger. (We copy the name now,
3404 because it's only guaranteed to be available NOW, when the
3405 catchpoint triggers. Clients who may wish to know the name
3406 later must get it from the catchpoint itself.) */
3407 if (ep
->triggered_dll_pathname
!= NULL
)
3408 xfree (ep
->triggered_dll_pathname
);
3409 if (ep
->type
== bp_catch_load
)
3410 dll_pathname
= SOLIB_LOADED_LIBRARY_PATHNAME (
3411 PIDGET (inferior_ptid
));
3413 dll_pathname
= SOLIB_UNLOADED_LIBRARY_PATHNAME (
3414 PIDGET (inferior_ptid
));
3416 dll_pathname
= NULL
;
3420 ep
->triggered_dll_pathname
= (char *)
3421 xmalloc (strlen (dll_pathname
) + 1);
3422 strcpy (ep
->triggered_dll_pathname
, dll_pathname
);
3425 ep
->triggered_dll_pathname
= NULL
;
3431 static void print_breakpoint_location (struct breakpoint
*b
,
3432 struct bp_location
*loc
,
3434 struct ui_stream
*stb
)
3439 = find_pc_sect_function (loc
->address
, loc
->section
);
3442 ui_out_text (uiout
, "in ");
3443 ui_out_field_string (uiout
, "func",
3444 SYMBOL_PRINT_NAME (sym
));
3445 ui_out_wrap_hint (uiout
, wrap_indent
);
3446 ui_out_text (uiout
, " at ");
3448 ui_out_field_string (uiout
, "file", b
->source_file
);
3449 ui_out_text (uiout
, ":");
3451 if (ui_out_is_mi_like_p (uiout
))
3453 struct symtab_and_line sal
= find_pc_line (loc
->address
, 0);
3454 char *fullname
= symtab_to_fullname (sal
.symtab
);
3457 ui_out_field_string (uiout
, "fullname", fullname
);
3460 ui_out_field_int (uiout
, "line", b
->line_number
);
3464 ui_out_field_string (uiout
, "pending", b
->addr_string
);
3468 print_address_symbolic (loc
->address
, stb
->stream
, demangle
, "");
3469 ui_out_field_stream (uiout
, "at", stb
);
3473 /* Print B to gdb_stdout. */
3475 print_one_breakpoint_location (struct breakpoint
*b
,
3476 struct bp_location
*loc
,
3478 CORE_ADDR
*last_addr
)
3480 struct command_line
*l
;
3482 struct ep_type_description
3487 static struct ep_type_description bptypes
[] =
3489 {bp_none
, "?deleted?"},
3490 {bp_breakpoint
, "breakpoint"},
3491 {bp_hardware_breakpoint
, "hw breakpoint"},
3492 {bp_until
, "until"},
3493 {bp_finish
, "finish"},
3494 {bp_watchpoint
, "watchpoint"},
3495 {bp_hardware_watchpoint
, "hw watchpoint"},
3496 {bp_read_watchpoint
, "read watchpoint"},
3497 {bp_access_watchpoint
, "acc watchpoint"},
3498 {bp_longjmp
, "longjmp"},
3499 {bp_longjmp_resume
, "longjmp resume"},
3500 {bp_step_resume
, "step resume"},
3501 {bp_watchpoint_scope
, "watchpoint scope"},
3502 {bp_call_dummy
, "call dummy"},
3503 {bp_shlib_event
, "shlib events"},
3504 {bp_thread_event
, "thread events"},
3505 {bp_overlay_event
, "overlay events"},
3506 {bp_catch_load
, "catch load"},
3507 {bp_catch_unload
, "catch unload"},
3508 {bp_catch_fork
, "catch fork"},
3509 {bp_catch_vfork
, "catch vfork"},
3510 {bp_catch_exec
, "catch exec"}
3513 static char bpenables
[] = "nynny";
3514 char wrap_indent
[80];
3515 struct ui_stream
*stb
= ui_out_stream_new (uiout
);
3516 struct cleanup
*old_chain
= make_cleanup_ui_out_stream_delete (stb
);
3517 struct cleanup
*bkpt_chain
;
3519 int header_of_multiple
= 0;
3520 int part_of_multiple
= (loc
!= NULL
);
3522 gdb_assert (!loc
|| loc_number
!= 0);
3523 /* See comment in print_one_breakpoint concerning
3524 treatment of breakpoints with single disabled
3528 && (b
->loc
->next
!= NULL
|| !b
->loc
->enabled
)))
3529 header_of_multiple
= 1;
3534 bkpt_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "bkpt");
3538 if (part_of_multiple
)
3541 formatted
= xstrprintf ("%d.%d", b
->number
, loc_number
);
3542 ui_out_field_string (uiout
, "number", formatted
);
3547 ui_out_field_int (uiout
, "number", b
->number
);
3552 if (part_of_multiple
)
3553 ui_out_field_skip (uiout
, "type");
3556 if (((int) b
->type
>= (sizeof (bptypes
) / sizeof (bptypes
[0])))
3557 || ((int) b
->type
!= bptypes
[(int) b
->type
].type
))
3558 internal_error (__FILE__
, __LINE__
,
3559 _("bptypes table does not describe type #%d."),
3561 ui_out_field_string (uiout
, "type", bptypes
[(int) b
->type
].description
);
3566 if (part_of_multiple
)
3567 ui_out_field_skip (uiout
, "disp");
3569 ui_out_field_string (uiout
, "disp", bpdisp_text (b
->disposition
));
3574 if (part_of_multiple
)
3575 ui_out_field_string (uiout
, "enabled", loc
->enabled
? "y" : "n");
3577 ui_out_field_fmt (uiout
, "enabled", "%c",
3578 bpenables
[(int) b
->enable_state
]);
3579 ui_out_spaces (uiout
, 2);
3583 strcpy (wrap_indent
, " ");
3586 if (gdbarch_addr_bit (current_gdbarch
) <= 32)
3587 strcat (wrap_indent
, " ");
3589 strcat (wrap_indent
, " ");
3592 if (b
->ops
!= NULL
&& b
->ops
->print_one
!= NULL
)
3594 /* Although the print_one can possibly print
3595 all locations, calling it here is not likely
3596 to get any nice result. So, make sure there's
3597 just one location. */
3598 gdb_assert (b
->loc
== NULL
|| b
->loc
->next
== NULL
);
3599 b
->ops
->print_one (b
, last_addr
);
3605 internal_error (__FILE__
, __LINE__
,
3606 _("print_one_breakpoint: bp_none encountered\n"));
3610 case bp_hardware_watchpoint
:
3611 case bp_read_watchpoint
:
3612 case bp_access_watchpoint
:
3613 /* Field 4, the address, is omitted (which makes the columns
3614 not line up too nicely with the headers, but the effect
3615 is relatively readable). */
3617 ui_out_field_skip (uiout
, "addr");
3619 print_expression (b
->exp
, stb
->stream
);
3620 ui_out_field_stream (uiout
, "what", stb
);
3624 case bp_catch_unload
:
3625 /* Field 4, the address, is omitted (which makes the columns
3626 not line up too nicely with the headers, but the effect
3627 is relatively readable). */
3629 ui_out_field_skip (uiout
, "addr");
3631 if (b
->dll_pathname
== NULL
)
3633 ui_out_field_string (uiout
, "what", "<any library>");
3634 ui_out_spaces (uiout
, 1);
3638 ui_out_text (uiout
, "library \"");
3639 ui_out_field_string (uiout
, "what", b
->dll_pathname
);
3640 ui_out_text (uiout
, "\" ");
3645 case bp_catch_vfork
:
3646 /* Field 4, the address, is omitted (which makes the columns
3647 not line up too nicely with the headers, but the effect
3648 is relatively readable). */
3650 ui_out_field_skip (uiout
, "addr");
3652 if (b
->forked_inferior_pid
!= 0)
3654 ui_out_text (uiout
, "process ");
3655 ui_out_field_int (uiout
, "what", b
->forked_inferior_pid
);
3656 ui_out_spaces (uiout
, 1);
3661 /* Field 4, the address, is omitted (which makes the columns
3662 not line up too nicely with the headers, but the effect
3663 is relatively readable). */
3665 ui_out_field_skip (uiout
, "addr");
3667 if (b
->exec_pathname
!= NULL
)
3669 ui_out_text (uiout
, "program \"");
3670 ui_out_field_string (uiout
, "what", b
->exec_pathname
);
3671 ui_out_text (uiout
, "\" ");
3676 case bp_hardware_breakpoint
:
3680 case bp_longjmp_resume
:
3681 case bp_step_resume
:
3682 case bp_watchpoint_scope
:
3684 case bp_shlib_event
:
3685 case bp_thread_event
:
3686 case bp_overlay_event
:
3690 if (header_of_multiple
)
3691 ui_out_field_string (uiout
, "addr", "<MULTIPLE>");
3692 else if (b
->loc
== NULL
|| loc
->shlib_disabled
)
3693 ui_out_field_string (uiout
, "addr", "<PENDING>");
3695 ui_out_field_core_addr (uiout
, "addr", loc
->address
);
3698 if (!header_of_multiple
)
3699 print_breakpoint_location (b
, loc
, wrap_indent
, stb
);
3701 *last_addr
= b
->loc
->address
;
3705 if (!part_of_multiple
&& b
->thread
!= -1)
3707 /* FIXME: This seems to be redundant and lost here; see the
3708 "stop only in" line a little further down. */
3709 ui_out_text (uiout
, " thread ");
3710 ui_out_field_int (uiout
, "thread", b
->thread
);
3713 ui_out_text (uiout
, "\n");
3715 if (part_of_multiple
&& frame_id_p (b
->frame_id
))
3718 ui_out_text (uiout
, "\tstop only in stack frame at ");
3719 /* FIXME: cagney/2002-12-01: Shouldn't be poeking around inside
3721 ui_out_field_core_addr (uiout
, "frame", b
->frame_id
.stack_addr
);
3722 ui_out_text (uiout
, "\n");
3725 if (!part_of_multiple
&& b
->cond_string
&& !ada_exception_catchpoint_p (b
))
3727 /* We do not print the condition for Ada exception catchpoints
3728 because the condition is an internal implementation detail
3729 that we do not want to expose to the user. */
3731 ui_out_text (uiout
, "\tstop only if ");
3732 ui_out_field_string (uiout
, "cond", b
->cond_string
);
3733 ui_out_text (uiout
, "\n");
3736 if (!part_of_multiple
&& b
->thread
!= -1)
3738 /* FIXME should make an annotation for this */
3739 ui_out_text (uiout
, "\tstop only in thread ");
3740 ui_out_field_int (uiout
, "thread", b
->thread
);
3741 ui_out_text (uiout
, "\n");
3744 if (!part_of_multiple
&& show_breakpoint_hit_counts
&& b
->hit_count
)
3746 /* FIXME should make an annotation for this */
3747 if (ep_is_catchpoint (b
))
3748 ui_out_text (uiout
, "\tcatchpoint");
3750 ui_out_text (uiout
, "\tbreakpoint");
3751 ui_out_text (uiout
, " already hit ");
3752 ui_out_field_int (uiout
, "times", b
->hit_count
);
3753 if (b
->hit_count
== 1)
3754 ui_out_text (uiout
, " time\n");
3756 ui_out_text (uiout
, " times\n");
3759 /* Output the count also if it is zero, but only if this is
3760 mi. FIXME: Should have a better test for this. */
3761 if (ui_out_is_mi_like_p (uiout
))
3762 if (!part_of_multiple
&& show_breakpoint_hit_counts
&& b
->hit_count
== 0)
3763 ui_out_field_int (uiout
, "times", b
->hit_count
);
3765 if (!part_of_multiple
&& b
->ignore_count
)
3768 ui_out_text (uiout
, "\tignore next ");
3769 ui_out_field_int (uiout
, "ignore", b
->ignore_count
);
3770 ui_out_text (uiout
, " hits\n");
3773 if (!part_of_multiple
&& (l
= b
->commands
))
3775 struct cleanup
*script_chain
;
3778 script_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "script");
3779 print_command_lines (uiout
, l
, 4);
3780 do_cleanups (script_chain
);
3783 if (ui_out_is_mi_like_p (uiout
) && !part_of_multiple
)
3786 ui_out_field_string (uiout
, "original-location", b
->addr_string
);
3787 else if (b
->exp_string
)
3788 ui_out_field_string (uiout
, "original-location", b
->exp_string
);
3791 do_cleanups (bkpt_chain
);
3792 do_cleanups (old_chain
);
3796 print_one_breakpoint (struct breakpoint
*b
,
3797 CORE_ADDR
*last_addr
)
3799 print_one_breakpoint_location (b
, NULL
, 0, last_addr
);
3801 /* If this breakpoint has custom print function,
3802 it's already printed. Otherwise, print individual
3803 locations, if any. */
3804 if (b
->ops
== NULL
|| b
->ops
->print_one
== NULL
)
3806 /* If breakpoint has a single location that is
3807 disabled, we print it as if it had
3808 several locations, since otherwise it's hard to
3809 represent "breakpoint enabled, location disabled"
3811 Note that while hardware watchpoints have
3812 several locations internally, that's no a property
3815 && !is_hardware_watchpoint (b
)
3816 && (b
->loc
->next
|| !b
->loc
->enabled
)
3817 && !ui_out_is_mi_like_p (uiout
))
3819 struct bp_location
*loc
;
3821 for (loc
= b
->loc
; loc
; loc
= loc
->next
, ++n
)
3822 print_one_breakpoint_location (b
, loc
, n
, last_addr
);
3828 struct captured_breakpoint_query_args
3834 do_captured_breakpoint_query (struct ui_out
*uiout
, void *data
)
3836 struct captured_breakpoint_query_args
*args
= data
;
3837 struct breakpoint
*b
;
3838 CORE_ADDR dummy_addr
= 0;
3841 if (args
->bnum
== b
->number
)
3843 print_one_breakpoint (b
, &dummy_addr
);
3851 gdb_breakpoint_query (struct ui_out
*uiout
, int bnum
, char **error_message
)
3853 struct captured_breakpoint_query_args args
;
3855 /* For the moment we don't trust print_one_breakpoint() to not throw
3857 if (catch_exceptions_with_msg (uiout
, do_captured_breakpoint_query
, &args
,
3858 error_message
, RETURN_MASK_ALL
) < 0)
3864 /* Return non-zero if B is user settable (breakpoints, watchpoints,
3865 catchpoints, et.al.). */
3868 user_settable_breakpoint (const struct breakpoint
*b
)
3870 return (b
->type
== bp_breakpoint
3871 || b
->type
== bp_catch_load
3872 || b
->type
== bp_catch_unload
3873 || b
->type
== bp_catch_fork
3874 || b
->type
== bp_catch_vfork
3875 || b
->type
== bp_catch_exec
3876 || b
->type
== bp_hardware_breakpoint
3877 || b
->type
== bp_watchpoint
3878 || b
->type
== bp_read_watchpoint
3879 || b
->type
== bp_access_watchpoint
3880 || b
->type
== bp_hardware_watchpoint
);
3883 /* Print information on user settable breakpoint (watchpoint, etc)
3884 number BNUM. If BNUM is -1 print all user settable breakpoints.
3885 If ALLFLAG is non-zero, include non- user settable breakpoints. */
3888 breakpoint_1 (int bnum
, int allflag
)
3890 struct breakpoint
*b
;
3891 CORE_ADDR last_addr
= (CORE_ADDR
) -1;
3892 int nr_printable_breakpoints
;
3893 struct cleanup
*bkpttbl_chain
;
3895 /* Compute the number of rows in the table. */
3896 nr_printable_breakpoints
= 0;
3899 || bnum
== b
->number
)
3901 if (allflag
|| user_settable_breakpoint (b
))
3902 nr_printable_breakpoints
++;
3907 = make_cleanup_ui_out_table_begin_end (uiout
, 6, nr_printable_breakpoints
,
3911 = make_cleanup_ui_out_table_begin_end (uiout
, 5, nr_printable_breakpoints
,
3914 if (nr_printable_breakpoints
> 0)
3915 annotate_breakpoints_headers ();
3916 if (nr_printable_breakpoints
> 0)
3918 ui_out_table_header (uiout
, 7, ui_left
, "number", "Num"); /* 1 */
3919 if (nr_printable_breakpoints
> 0)
3921 ui_out_table_header (uiout
, 14, ui_left
, "type", "Type"); /* 2 */
3922 if (nr_printable_breakpoints
> 0)
3924 ui_out_table_header (uiout
, 4, ui_left
, "disp", "Disp"); /* 3 */
3925 if (nr_printable_breakpoints
> 0)
3927 ui_out_table_header (uiout
, 3, ui_left
, "enabled", "Enb"); /* 4 */
3930 if (nr_printable_breakpoints
> 0)
3932 if (gdbarch_addr_bit (current_gdbarch
) <= 32)
3933 ui_out_table_header (uiout
, 10, ui_left
, "addr", "Address");/* 5 */
3935 ui_out_table_header (uiout
, 18, ui_left
, "addr", "Address");/* 5 */
3937 if (nr_printable_breakpoints
> 0)
3939 ui_out_table_header (uiout
, 40, ui_noalign
, "what", "What"); /* 6 */
3940 ui_out_table_body (uiout
);
3941 if (nr_printable_breakpoints
> 0)
3942 annotate_breakpoints_table ();
3946 || bnum
== b
->number
)
3948 /* We only print out user settable breakpoints unless the
3950 if (allflag
|| user_settable_breakpoint (b
))
3951 print_one_breakpoint (b
, &last_addr
);
3954 do_cleanups (bkpttbl_chain
);
3956 if (nr_printable_breakpoints
== 0)
3959 ui_out_message (uiout
, 0, "No breakpoints or watchpoints.\n");
3961 ui_out_message (uiout
, 0, "No breakpoint or watchpoint number %d.\n",
3966 /* Compare against (CORE_ADDR)-1 in case some compiler decides
3967 that a comparison of an unsigned with -1 is always false. */
3968 if (last_addr
!= (CORE_ADDR
) -1 && !server_command
)
3969 set_next_address (last_addr
);
3972 /* FIXME? Should this be moved up so that it is only called when
3973 there have been breakpoints? */
3974 annotate_breakpoints_table_end ();
3978 breakpoints_info (char *bnum_exp
, int from_tty
)
3983 bnum
= parse_and_eval_long (bnum_exp
);
3985 breakpoint_1 (bnum
, 0);
3989 maintenance_info_breakpoints (char *bnum_exp
, int from_tty
)
3994 bnum
= parse_and_eval_long (bnum_exp
);
3996 breakpoint_1 (bnum
, 1);
4000 breakpoint_has_pc (struct breakpoint
*b
, CORE_ADDR pc
, asection
*section
)
4002 struct bp_location
*bl
= b
->loc
;
4003 for (; bl
; bl
= bl
->next
)
4005 if (bl
->address
== pc
4006 && (!overlay_debugging
|| bl
->section
== section
))
4012 /* Print a message describing any breakpoints set at PC. */
4015 describe_other_breakpoints (CORE_ADDR pc
, asection
*section
, int thread
)
4018 struct breakpoint
*b
;
4021 others
+= breakpoint_has_pc (b
, pc
, section
);
4025 printf_filtered (_("Note: breakpoint "));
4026 else /* if (others == ???) */
4027 printf_filtered (_("Note: breakpoints "));
4029 if (breakpoint_has_pc (b
, pc
, section
))
4032 printf_filtered ("%d", b
->number
);
4033 if (b
->thread
== -1 && thread
!= -1)
4034 printf_filtered (" (all threads)");
4035 else if (b
->thread
!= -1)
4036 printf_filtered (" (thread %d)", b
->thread
);
4037 printf_filtered ("%s%s ",
4038 ((b
->enable_state
== bp_disabled
||
4039 b
->enable_state
== bp_call_disabled
)
4041 : b
->enable_state
== bp_permanent
4045 : ((others
== 1) ? " and" : ""));
4047 printf_filtered (_("also set at pc "));
4048 fputs_filtered (paddress (pc
), gdb_stdout
);
4049 printf_filtered (".\n");
4053 /* Set the default place to put a breakpoint
4054 for the `break' command with no arguments. */
4057 set_default_breakpoint (int valid
, CORE_ADDR addr
, struct symtab
*symtab
,
4060 default_breakpoint_valid
= valid
;
4061 default_breakpoint_address
= addr
;
4062 default_breakpoint_symtab
= symtab
;
4063 default_breakpoint_line
= line
;
4066 /* Return true iff it is meaningful to use the address member of
4067 BPT. For some breakpoint types, the address member is irrelevant
4068 and it makes no sense to attempt to compare it to other addresses
4069 (or use it for any other purpose either).
4071 More specifically, each of the following breakpoint types will always
4072 have a zero valued address and we don't want check_duplicates() to mark
4073 breakpoints of any of these types to be a duplicate of an actual
4074 breakpoint at address zero:
4077 bp_hardware_watchpoint
4079 bp_access_watchpoint
4085 breakpoint_address_is_meaningful (struct breakpoint
*bpt
)
4087 enum bptype type
= bpt
->type
;
4089 return (type
!= bp_watchpoint
4090 && type
!= bp_hardware_watchpoint
4091 && type
!= bp_read_watchpoint
4092 && type
!= bp_access_watchpoint
4093 && type
!= bp_catch_exec
4094 && type
!= bp_catch_fork
4095 && type
!= bp_catch_vfork
);
4098 /* Rescan breakpoints at the same address and section as BPT,
4099 marking the first one as "first" and any others as "duplicates".
4100 This is so that the bpt instruction is only inserted once.
4101 If we have a permanent breakpoint at the same place as BPT, make
4102 that one the official one, and the rest as duplicates. */
4105 check_duplicates_for (CORE_ADDR address
, asection
*section
)
4107 struct bp_location
*b
;
4109 struct bp_location
*perm_bp
= 0;
4111 ALL_BP_LOCATIONS (b
)
4112 if (b
->owner
->enable_state
!= bp_disabled
4113 && b
->owner
->enable_state
!= bp_call_disabled
4115 && !b
->shlib_disabled
4116 && b
->address
== address
/* address / overlay match */
4117 && (!overlay_debugging
|| b
->section
== section
)
4118 && breakpoint_address_is_meaningful (b
->owner
))
4120 /* Have we found a permanent breakpoint? */
4121 if (b
->owner
->enable_state
== bp_permanent
)
4128 b
->duplicate
= count
> 1;
4131 /* If we found a permanent breakpoint at this address, go over the
4132 list again and declare all the other breakpoints there to be the
4136 perm_bp
->duplicate
= 0;
4138 /* Permanent breakpoint should always be inserted. */
4139 if (! perm_bp
->inserted
)
4140 internal_error (__FILE__
, __LINE__
,
4141 _("allegedly permanent breakpoint is not "
4142 "actually inserted"));
4144 ALL_BP_LOCATIONS (b
)
4147 if (b
->owner
->enable_state
!= bp_disabled
4148 && b
->owner
->enable_state
!= bp_call_disabled
4149 && b
->enabled
&& !b
->shlib_disabled
4150 && b
->address
== address
/* address / overlay match */
4151 && (!overlay_debugging
|| b
->section
== section
)
4152 && breakpoint_address_is_meaningful (b
->owner
))
4155 internal_error (__FILE__
, __LINE__
,
4156 _("another breakpoint was inserted on top of "
4157 "a permanent breakpoint"));
4166 check_duplicates (struct breakpoint
*bpt
)
4168 struct bp_location
*bl
= bpt
->loc
;
4170 if (! breakpoint_address_is_meaningful (bpt
))
4173 for (; bl
; bl
= bl
->next
)
4174 check_duplicates_for (bl
->address
, bl
->section
);
4178 breakpoint_adjustment_warning (CORE_ADDR from_addr
, CORE_ADDR to_addr
,
4179 int bnum
, int have_bnum
)
4184 strcpy (astr1
, hex_string_custom ((unsigned long) from_addr
, 8));
4185 strcpy (astr2
, hex_string_custom ((unsigned long) to_addr
, 8));
4187 warning (_("Breakpoint %d address previously adjusted from %s to %s."),
4188 bnum
, astr1
, astr2
);
4190 warning (_("Breakpoint address adjusted from %s to %s."), astr1
, astr2
);
4193 /* Adjust a breakpoint's address to account for architectural constraints
4194 on breakpoint placement. Return the adjusted address. Note: Very
4195 few targets require this kind of adjustment. For most targets,
4196 this function is simply the identity function. */
4199 adjust_breakpoint_address (CORE_ADDR bpaddr
, enum bptype bptype
)
4201 if (!gdbarch_adjust_breakpoint_address_p (current_gdbarch
))
4203 /* Very few targets need any kind of breakpoint adjustment. */
4206 else if (bptype
== bp_watchpoint
4207 || bptype
== bp_hardware_watchpoint
4208 || bptype
== bp_read_watchpoint
4209 || bptype
== bp_access_watchpoint
4210 || bptype
== bp_catch_fork
4211 || bptype
== bp_catch_vfork
4212 || bptype
== bp_catch_exec
)
4214 /* Watchpoints and the various bp_catch_* eventpoints should not
4215 have their addresses modified. */
4220 CORE_ADDR adjusted_bpaddr
;
4222 /* Some targets have architectural constraints on the placement
4223 of breakpoint instructions. Obtain the adjusted address. */
4224 adjusted_bpaddr
= gdbarch_adjust_breakpoint_address (current_gdbarch
,
4227 /* An adjusted breakpoint address can significantly alter
4228 a user's expectations. Print a warning if an adjustment
4230 if (adjusted_bpaddr
!= bpaddr
)
4231 breakpoint_adjustment_warning (bpaddr
, adjusted_bpaddr
, 0, 0);
4233 return adjusted_bpaddr
;
4237 /* Allocate a struct bp_location. */
4239 static struct bp_location
*
4240 allocate_bp_location (struct breakpoint
*bpt
, enum bptype bp_type
)
4242 struct bp_location
*loc
, *loc_p
;
4244 loc
= xmalloc (sizeof (struct bp_location
));
4245 memset (loc
, 0, sizeof (*loc
));
4249 loc
->shlib_disabled
= 0;
4258 case bp_longjmp_resume
:
4259 case bp_step_resume
:
4260 case bp_watchpoint_scope
:
4262 case bp_shlib_event
:
4263 case bp_thread_event
:
4264 case bp_overlay_event
:
4266 case bp_catch_unload
:
4267 loc
->loc_type
= bp_loc_software_breakpoint
;
4269 case bp_hardware_breakpoint
:
4270 loc
->loc_type
= bp_loc_hardware_breakpoint
;
4272 case bp_hardware_watchpoint
:
4273 case bp_read_watchpoint
:
4274 case bp_access_watchpoint
:
4275 loc
->loc_type
= bp_loc_hardware_watchpoint
;
4279 case bp_catch_vfork
:
4281 loc
->loc_type
= bp_loc_other
;
4284 internal_error (__FILE__
, __LINE__
, _("unknown breakpoint type"));
4290 static void free_bp_location (struct bp_location
*loc
)
4295 if (loc
->function_name
)
4296 xfree (loc
->function_name
);
4301 /* Helper to set_raw_breakpoint below. Creates a breakpoint
4302 that has type BPTYPE and has no locations as yet. */
4304 static struct breakpoint
*
4305 set_raw_breakpoint_without_location (enum bptype bptype
)
4307 struct breakpoint
*b
, *b1
;
4309 b
= (struct breakpoint
*) xmalloc (sizeof (struct breakpoint
));
4310 memset (b
, 0, sizeof (*b
));
4313 b
->language
= current_language
->la_language
;
4314 b
->input_radix
= input_radix
;
4316 b
->enable_state
= bp_enabled
;
4319 b
->ignore_count
= 0;
4321 b
->frame_id
= null_frame_id
;
4322 b
->dll_pathname
= NULL
;
4323 b
->triggered_dll_pathname
= NULL
;
4324 b
->forked_inferior_pid
= 0;
4325 b
->exec_pathname
= NULL
;
4327 b
->condition_not_parsed
= 0;
4329 /* Add this breakpoint to the end of the chain
4330 so that a list of breakpoints will come out in order
4331 of increasing numbers. */
4333 b1
= breakpoint_chain
;
4335 breakpoint_chain
= b
;
4345 /* Initialize loc->function_name. */
4347 set_breakpoint_location_function (struct bp_location
*loc
)
4349 if (loc
->owner
->type
== bp_breakpoint
4350 || loc
->owner
->type
== bp_hardware_breakpoint
)
4352 find_pc_partial_function (loc
->address
, &(loc
->function_name
),
4354 if (loc
->function_name
)
4355 loc
->function_name
= xstrdup (loc
->function_name
);
4359 /* set_raw_breakpoint is a low level routine for allocating and
4360 partially initializing a breakpoint of type BPTYPE. The newly
4361 created breakpoint's address, section, source file name, and line
4362 number are provided by SAL. The newly created and partially
4363 initialized breakpoint is added to the breakpoint chain and
4364 is also returned as the value of this function.
4366 It is expected that the caller will complete the initialization of
4367 the newly created breakpoint struct as well as output any status
4368 information regarding the creation of a new breakpoint. In
4369 particular, set_raw_breakpoint does NOT set the breakpoint
4370 number! Care should be taken to not allow an error to occur
4371 prior to completing the initialization of the breakpoint. If this
4372 should happen, a bogus breakpoint will be left on the chain. */
4375 set_raw_breakpoint (struct symtab_and_line sal
, enum bptype bptype
)
4377 struct breakpoint
*b
= set_raw_breakpoint_without_location (bptype
);
4378 CORE_ADDR adjusted_address
;
4380 /* Adjust the breakpoint's address prior to allocating a location.
4381 Once we call allocate_bp_location(), that mostly uninitialized
4382 location will be placed on the location chain. Adjustment of the
4383 breakpoint may cause target_read_memory() to be called and we do
4384 not want its scan of the location chain to find a breakpoint and
4385 location that's only been partially initialized. */
4386 adjusted_address
= adjust_breakpoint_address (sal
.pc
, bptype
);
4388 b
->loc
= allocate_bp_location (b
, bptype
);
4389 b
->loc
->requested_address
= sal
.pc
;
4390 b
->loc
->address
= adjusted_address
;
4392 if (sal
.symtab
== NULL
)
4393 b
->source_file
= NULL
;
4395 b
->source_file
= savestring (sal
.symtab
->filename
,
4396 strlen (sal
.symtab
->filename
));
4397 b
->loc
->section
= sal
.section
;
4398 b
->line_number
= sal
.line
;
4400 set_breakpoint_location_function (b
->loc
);
4402 breakpoints_changed ();
4408 /* Note that the breakpoint object B describes a permanent breakpoint
4409 instruction, hard-wired into the inferior's code. */
4411 make_breakpoint_permanent (struct breakpoint
*b
)
4413 struct bp_location
*bl
;
4414 b
->enable_state
= bp_permanent
;
4416 /* By definition, permanent breakpoints are already present in the code.
4417 Mark all locations as inserted. For now, make_breakpoint_permanent
4418 is called in just one place, so it's hard to say if it's reasonable
4419 to have permanent breakpoint with multiple locations or not,
4420 but it's easy to implmement. */
4421 for (bl
= b
->loc
; bl
; bl
= bl
->next
)
4425 static struct breakpoint
*
4426 create_internal_breakpoint (CORE_ADDR address
, enum bptype type
)
4428 static int internal_breakpoint_number
= -1;
4429 struct symtab_and_line sal
;
4430 struct breakpoint
*b
;
4432 init_sal (&sal
); /* initialize to zeroes */
4435 sal
.section
= find_pc_overlay (sal
.pc
);
4437 b
= set_raw_breakpoint (sal
, type
);
4438 b
->number
= internal_breakpoint_number
--;
4439 b
->disposition
= disp_donttouch
;
4446 create_longjmp_breakpoint (char *func_name
)
4448 struct breakpoint
*b
;
4449 struct minimal_symbol
*m
;
4451 if ((m
= lookup_minimal_symbol_text (func_name
, NULL
)) == NULL
)
4453 set_momentary_breakpoint_at_pc (SYMBOL_VALUE_ADDRESS (m
), bp_longjmp
);
4454 update_global_location_list ();
4457 /* Call this routine when stepping and nexting to enable a breakpoint
4458 if we do a longjmp(). When we hit that breakpoint, call
4459 set_longjmp_resume_breakpoint() to figure out where we are going. */
4462 set_longjmp_breakpoint (void)
4464 struct breakpoint
*b
;
4466 if (gdbarch_get_longjmp_target_p (current_gdbarch
))
4468 create_longjmp_breakpoint ("longjmp");
4469 create_longjmp_breakpoint ("_longjmp");
4470 create_longjmp_breakpoint ("siglongjmp");
4471 create_longjmp_breakpoint ("_siglongjmp");
4475 /* Delete all longjmp breakpoints from THREAD. */
4477 delete_longjmp_breakpoint (int thread
)
4479 struct breakpoint
*b
, *temp
;
4481 ALL_BREAKPOINTS_SAFE (b
, temp
)
4482 if (b
->type
== bp_longjmp
)
4484 if (b
->thread
== thread
)
4485 delete_breakpoint (b
);
4490 create_overlay_event_breakpoint (char *func_name
)
4492 struct breakpoint
*b
;
4493 struct minimal_symbol
*m
;
4495 if ((m
= lookup_minimal_symbol_text (func_name
, NULL
)) == NULL
)
4498 b
= create_internal_breakpoint (SYMBOL_VALUE_ADDRESS (m
),
4500 b
->addr_string
= xstrdup (func_name
);
4502 if (overlay_debugging
== ovly_auto
)
4504 b
->enable_state
= bp_enabled
;
4505 overlay_events_enabled
= 1;
4509 b
->enable_state
= bp_disabled
;
4510 overlay_events_enabled
= 0;
4512 update_global_location_list ();
4516 enable_overlay_breakpoints (void)
4518 struct breakpoint
*b
;
4521 if (b
->type
== bp_overlay_event
)
4523 b
->enable_state
= bp_enabled
;
4524 update_global_location_list ();
4525 overlay_events_enabled
= 1;
4530 disable_overlay_breakpoints (void)
4532 struct breakpoint
*b
;
4535 if (b
->type
== bp_overlay_event
)
4537 b
->enable_state
= bp_disabled
;
4538 update_global_location_list ();
4539 overlay_events_enabled
= 0;
4544 create_thread_event_breakpoint (CORE_ADDR address
)
4546 struct breakpoint
*b
;
4548 b
= create_internal_breakpoint (address
, bp_thread_event
);
4550 b
->enable_state
= bp_enabled
;
4551 /* addr_string has to be used or breakpoint_re_set will delete me. */
4552 b
->addr_string
= xstrprintf ("*0x%s", paddr (b
->loc
->address
));
4554 update_global_location_list_nothrow ();
4560 remove_thread_event_breakpoints (void)
4562 struct breakpoint
*b
, *temp
;
4564 ALL_BREAKPOINTS_SAFE (b
, temp
)
4565 if (b
->type
== bp_thread_event
)
4566 delete_breakpoint (b
);
4569 struct captured_parse_breakpoint_args
4572 struct symtabs_and_lines
*sals_p
;
4573 char ***addr_string_p
;
4577 struct lang_and_radix
4585 remove_solib_event_breakpoints (void)
4587 struct breakpoint
*b
, *temp
;
4589 ALL_BREAKPOINTS_SAFE (b
, temp
)
4590 if (b
->type
== bp_shlib_event
)
4591 delete_breakpoint (b
);
4595 create_solib_event_breakpoint (CORE_ADDR address
)
4597 struct breakpoint
*b
;
4599 b
= create_internal_breakpoint (address
, bp_shlib_event
);
4600 update_global_location_list_nothrow ();
4604 /* Disable any breakpoints that are on code in shared libraries. Only
4605 apply to enabled breakpoints, disabled ones can just stay disabled. */
4608 disable_breakpoints_in_shlibs (void)
4610 struct bp_location
*loc
;
4611 int disabled_shlib_breaks
= 0;
4613 ALL_BP_LOCATIONS (loc
)
4615 struct breakpoint
*b
= loc
->owner
;
4616 /* We apply the check to all breakpoints, including disabled
4617 for those with loc->duplicate set. This is so that when breakpoint
4618 becomes enabled, or the duplicate is removed, gdb will try to insert
4619 all breakpoints. If we don't set shlib_disabled here, we'll try
4620 to insert those breakpoints and fail. */
4621 if (((b
->type
== bp_breakpoint
) || (b
->type
== bp_hardware_breakpoint
))
4622 && !loc
->shlib_disabled
4624 && PC_SOLIB (loc
->address
)
4626 && solib_address (loc
->address
)
4630 loc
->shlib_disabled
= 1;
4635 /* Disable any breakpoints that are in in an unloaded shared library. Only
4636 apply to enabled breakpoints, disabled ones can just stay disabled. */
4639 disable_breakpoints_in_unloaded_shlib (struct so_list
*solib
)
4641 struct bp_location
*loc
;
4642 int disabled_shlib_breaks
= 0;
4644 ALL_BP_LOCATIONS (loc
)
4646 struct breakpoint
*b
= loc
->owner
;
4647 if ((loc
->loc_type
== bp_loc_hardware_breakpoint
4648 || loc
->loc_type
== bp_loc_software_breakpoint
)
4649 && !loc
->shlib_disabled
)
4652 char *so_name
= PC_SOLIB (loc
->address
);
4654 char *so_name
= solib_address (loc
->address
);
4656 if (so_name
&& !strcmp (so_name
, solib
->so_name
))
4658 loc
->shlib_disabled
= 1;
4659 /* At this point, we cannot rely on remove_breakpoint
4660 succeeding so we must mark the breakpoint as not inserted
4661 to prevent future errors occurring in remove_breakpoints. */
4663 if (!disabled_shlib_breaks
)
4665 target_terminal_ours_for_output ();
4666 warning (_("Temporarily disabling breakpoints for unloaded shared library \"%s\""),
4669 disabled_shlib_breaks
= 1;
4676 create_fork_vfork_event_catchpoint (int tempflag
, char *cond_string
,
4677 enum bptype bp_kind
)
4679 struct symtab_and_line sal
;
4680 struct breakpoint
*b
;
4681 int thread
= -1; /* All threads. */
4688 b
= set_raw_breakpoint (sal
, bp_kind
);
4689 set_breakpoint_count (breakpoint_count
+ 1);
4690 b
->number
= breakpoint_count
;
4691 b
->cond_string
= (cond_string
== NULL
) ?
4692 NULL
: savestring (cond_string
, strlen (cond_string
));
4694 b
->addr_string
= NULL
;
4695 b
->enable_state
= bp_enabled
;
4696 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
4697 b
->forked_inferior_pid
= 0;
4698 update_global_location_list ();
4705 create_fork_event_catchpoint (int tempflag
, char *cond_string
)
4707 create_fork_vfork_event_catchpoint (tempflag
, cond_string
, bp_catch_fork
);
4711 create_vfork_event_catchpoint (int tempflag
, char *cond_string
)
4713 create_fork_vfork_event_catchpoint (tempflag
, cond_string
, bp_catch_vfork
);
4717 create_exec_event_catchpoint (int tempflag
, char *cond_string
)
4719 struct symtab_and_line sal
;
4720 struct breakpoint
*b
;
4721 int thread
= -1; /* All threads. */
4728 b
= set_raw_breakpoint (sal
, bp_catch_exec
);
4729 set_breakpoint_count (breakpoint_count
+ 1);
4730 b
->number
= breakpoint_count
;
4731 b
->cond_string
= (cond_string
== NULL
) ?
4732 NULL
: savestring (cond_string
, strlen (cond_string
));
4734 b
->addr_string
= NULL
;
4735 b
->enable_state
= bp_enabled
;
4736 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
4737 update_global_location_list ();
4743 hw_breakpoint_used_count (void)
4745 struct breakpoint
*b
;
4750 if (b
->type
== bp_hardware_breakpoint
&& b
->enable_state
== bp_enabled
)
4758 hw_watchpoint_used_count (enum bptype type
, int *other_type_used
)
4760 struct breakpoint
*b
;
4763 *other_type_used
= 0;
4766 if (breakpoint_enabled (b
))
4768 if (b
->type
== type
)
4770 else if ((b
->type
== bp_hardware_watchpoint
||
4771 b
->type
== bp_read_watchpoint
||
4772 b
->type
== bp_access_watchpoint
))
4773 *other_type_used
= 1;
4780 disable_watchpoints_before_interactive_call_start (void)
4782 struct breakpoint
*b
;
4786 if (((b
->type
== bp_watchpoint
)
4787 || (b
->type
== bp_hardware_watchpoint
)
4788 || (b
->type
== bp_read_watchpoint
)
4789 || (b
->type
== bp_access_watchpoint
))
4790 && breakpoint_enabled (b
))
4792 b
->enable_state
= bp_call_disabled
;
4793 update_global_location_list ();
4799 enable_watchpoints_after_interactive_call_stop (void)
4801 struct breakpoint
*b
;
4805 if (((b
->type
== bp_watchpoint
)
4806 || (b
->type
== bp_hardware_watchpoint
)
4807 || (b
->type
== bp_read_watchpoint
)
4808 || (b
->type
== bp_access_watchpoint
))
4809 && (b
->enable_state
== bp_call_disabled
))
4811 b
->enable_state
= bp_enabled
;
4812 update_global_location_list ();
4818 /* Set a breakpoint that will evaporate an end of command
4819 at address specified by SAL.
4820 Restrict it to frame FRAME if FRAME is nonzero. */
4823 set_momentary_breakpoint (struct symtab_and_line sal
, struct frame_id frame_id
,
4826 struct breakpoint
*b
;
4827 b
= set_raw_breakpoint (sal
, type
);
4828 b
->enable_state
= bp_enabled
;
4829 b
->disposition
= disp_donttouch
;
4830 b
->frame_id
= frame_id
;
4832 /* If we're debugging a multi-threaded program, then we
4833 want momentary breakpoints to be active in only a
4834 single thread of control. */
4835 if (in_thread_list (inferior_ptid
))
4836 b
->thread
= pid_to_thread_id (inferior_ptid
);
4838 update_global_location_list_nothrow ();
4844 set_momentary_breakpoint_at_pc (CORE_ADDR pc
, enum bptype type
)
4846 struct symtab_and_line sal
;
4848 sal
= find_pc_line (pc
, 0);
4850 sal
.section
= find_pc_overlay (pc
);
4851 sal
.explicit_pc
= 1;
4853 return set_momentary_breakpoint (sal
, null_frame_id
, type
);
4857 /* Tell the user we have just set a breakpoint B. */
4860 mention (struct breakpoint
*b
)
4863 struct cleanup
*old_chain
, *ui_out_chain
;
4864 struct ui_stream
*stb
;
4866 stb
= ui_out_stream_new (uiout
);
4867 old_chain
= make_cleanup_ui_out_stream_delete (stb
);
4869 /* FIXME: This is misplaced; mention() is called by things (like
4870 hitting a watchpoint) other than breakpoint creation. It should
4871 be possible to clean this up and at the same time replace the
4872 random calls to breakpoint_changed with this hook, as has already
4873 been done for deprecated_delete_breakpoint_hook and so on. */
4874 if (deprecated_create_breakpoint_hook
)
4875 deprecated_create_breakpoint_hook (b
);
4876 breakpoint_create_event (b
->number
);
4878 if (b
->ops
!= NULL
&& b
->ops
->print_mention
!= NULL
)
4879 b
->ops
->print_mention (b
);
4884 printf_filtered (_("(apparently deleted?) Eventpoint %d: "), b
->number
);
4887 ui_out_text (uiout
, "Watchpoint ");
4888 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "wpt");
4889 ui_out_field_int (uiout
, "number", b
->number
);
4890 ui_out_text (uiout
, ": ");
4891 print_expression (b
->exp
, stb
->stream
);
4892 ui_out_field_stream (uiout
, "exp", stb
);
4893 do_cleanups (ui_out_chain
);
4895 case bp_hardware_watchpoint
:
4896 ui_out_text (uiout
, "Hardware watchpoint ");
4897 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "wpt");
4898 ui_out_field_int (uiout
, "number", b
->number
);
4899 ui_out_text (uiout
, ": ");
4900 print_expression (b
->exp
, stb
->stream
);
4901 ui_out_field_stream (uiout
, "exp", stb
);
4902 do_cleanups (ui_out_chain
);
4904 case bp_read_watchpoint
:
4905 ui_out_text (uiout
, "Hardware read watchpoint ");
4906 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "hw-rwpt");
4907 ui_out_field_int (uiout
, "number", b
->number
);
4908 ui_out_text (uiout
, ": ");
4909 print_expression (b
->exp
, stb
->stream
);
4910 ui_out_field_stream (uiout
, "exp", stb
);
4911 do_cleanups (ui_out_chain
);
4913 case bp_access_watchpoint
:
4914 ui_out_text (uiout
, "Hardware access (read/write) watchpoint ");
4915 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "hw-awpt");
4916 ui_out_field_int (uiout
, "number", b
->number
);
4917 ui_out_text (uiout
, ": ");
4918 print_expression (b
->exp
, stb
->stream
);
4919 ui_out_field_stream (uiout
, "exp", stb
);
4920 do_cleanups (ui_out_chain
);
4923 if (ui_out_is_mi_like_p (uiout
))
4928 if (b
->disposition
== disp_del
)
4929 printf_filtered (_("Temporary breakpoint"));
4931 printf_filtered (_("Breakpoint"));
4932 printf_filtered (_(" %d"), b
->number
);
4935 case bp_hardware_breakpoint
:
4936 if (ui_out_is_mi_like_p (uiout
))
4941 printf_filtered (_("Hardware assisted breakpoint %d"), b
->number
);
4945 case bp_catch_unload
:
4946 printf_filtered (_("Catchpoint %d (%s %s)"),
4948 (b
->type
== bp_catch_load
) ? "load" : "unload",
4949 (b
->dll_pathname
!= NULL
) ?
4950 b
->dll_pathname
: "<any library>");
4953 case bp_catch_vfork
:
4954 printf_filtered (_("Catchpoint %d (%s)"),
4956 (b
->type
== bp_catch_fork
) ? "fork" : "vfork");
4959 printf_filtered (_("Catchpoint %d (exec)"),
4966 case bp_longjmp_resume
:
4967 case bp_step_resume
:
4969 case bp_watchpoint_scope
:
4970 case bp_shlib_event
:
4971 case bp_thread_event
:
4972 case bp_overlay_event
:
4978 /* i18n: cagney/2005-02-11: Below needs to be merged into a
4982 printf_filtered (_(" (%s) pending."), b
->addr_string
);
4986 if (addressprint
|| b
->source_file
== NULL
)
4988 printf_filtered (" at ");
4989 fputs_filtered (paddress (b
->loc
->address
), gdb_stdout
);
4992 printf_filtered (": file %s, line %d.",
4993 b
->source_file
, b
->line_number
);
4997 struct bp_location
*loc
= b
->loc
;
4999 for (; loc
; loc
= loc
->next
)
5001 printf_filtered (" (%d locations)", n
);
5006 do_cleanups (old_chain
);
5007 if (ui_out_is_mi_like_p (uiout
))
5009 printf_filtered ("\n");
5013 static struct bp_location
*
5014 add_location_to_breakpoint (struct breakpoint
*b
, enum bptype bptype
,
5015 const struct symtab_and_line
*sal
)
5017 struct bp_location
*loc
, **tmp
;
5019 loc
= allocate_bp_location (b
, bptype
);
5020 for (tmp
= &(b
->loc
); *tmp
!= NULL
; tmp
= &((*tmp
)->next
))
5023 loc
->requested_address
= sal
->pc
;
5024 loc
->address
= adjust_breakpoint_address (loc
->requested_address
,
5026 loc
->section
= sal
->section
;
5028 set_breakpoint_location_function (loc
);
5032 /* Create a breakpoint with SAL as location. Use ADDR_STRING
5033 as textual description of the location, and COND_STRING
5034 as condition expression. */
5037 create_breakpoint (struct symtabs_and_lines sals
, char *addr_string
,
5039 enum bptype type
, enum bpdisp disposition
,
5040 int thread
, int ignore_count
,
5041 struct breakpoint_ops
*ops
, int from_tty
)
5043 struct breakpoint
*b
= NULL
;
5046 if (type
== bp_hardware_breakpoint
)
5048 int i
= hw_breakpoint_used_count ();
5049 int target_resources_ok
=
5050 TARGET_CAN_USE_HARDWARE_WATCHPOINT (bp_hardware_breakpoint
,
5052 if (target_resources_ok
== 0)
5053 error (_("No hardware breakpoint support in the target."));
5054 else if (target_resources_ok
< 0)
5055 error (_("Hardware breakpoints used exceeds limit."));
5058 for (i
= 0; i
< sals
.nelts
; ++i
)
5060 struct symtab_and_line sal
= sals
.sals
[i
];
5061 struct bp_location
*loc
;
5064 describe_other_breakpoints (sal
.pc
, sal
.section
, thread
);
5068 b
= set_raw_breakpoint (sal
, type
);
5069 set_breakpoint_count (breakpoint_count
+ 1);
5070 b
->number
= breakpoint_count
;
5073 b
->cond_string
= cond_string
;
5074 b
->ignore_count
= ignore_count
;
5075 b
->enable_state
= bp_enabled
;
5076 b
->disposition
= disposition
;
5082 loc
= add_location_to_breakpoint (b
, type
, &sal
);
5087 char *arg
= b
->cond_string
;
5088 loc
->cond
= parse_exp_1 (&arg
, block_for_pc (loc
->address
), 0);
5090 error (_("Garbage %s follows condition"), arg
);
5095 b
->addr_string
= addr_string
;
5097 /* addr_string has to be used or breakpoint_re_set will delete
5099 b
->addr_string
= xstrprintf ("*0x%s", paddr (b
->loc
->address
));
5105 /* Remove element at INDEX_TO_REMOVE from SAL, shifting other
5106 elements to fill the void space. */
5107 static void remove_sal (struct symtabs_and_lines
*sal
, int index_to_remove
)
5109 int i
= index_to_remove
+1;
5110 int last_index
= sal
->nelts
-1;
5112 for (;i
<= last_index
; ++i
)
5113 sal
->sals
[i
-1] = sal
->sals
[i
];
5118 /* If appropriate, obtains all sals that correspond
5119 to the same file and line as SAL. This is done
5120 only if SAL does not have explicit PC and has
5121 line and file information. If we got just a single
5122 expanded sal, return the original.
5124 Otherwise, if SAL.explicit_line is not set, filter out
5125 all sals for which the name of enclosing function
5126 is different from SAL. This makes sure that if we have
5127 breakpoint originally set in template instantiation, say
5128 foo<int>(), we won't expand SAL to locations at the same
5129 line in all existing instantiations of 'foo'.
5132 struct symtabs_and_lines
5133 expand_line_sal_maybe (struct symtab_and_line sal
)
5135 struct symtabs_and_lines expanded
;
5136 CORE_ADDR original_pc
= sal
.pc
;
5137 char *original_function
= NULL
;
5141 /* If we have explicit pc, don't expand.
5142 If we have no line number, we can't expand. */
5143 if (sal
.explicit_pc
|| sal
.line
== 0 || sal
.symtab
== NULL
)
5146 expanded
.sals
= xmalloc (sizeof (struct symtab_and_line
));
5147 expanded
.sals
[0] = sal
;
5152 find_pc_partial_function (original_pc
, &original_function
, NULL
, NULL
);
5154 expanded
= expand_line_sal (sal
);
5155 if (expanded
.nelts
== 1)
5157 /* We had one sal, we got one sal. Without futher
5158 processing, just return the original sal. */
5159 xfree (expanded
.sals
);
5161 expanded
.sals
= xmalloc (sizeof (struct symtab_and_line
));
5162 sal
.pc
= original_pc
;
5163 expanded
.sals
[0] = sal
;
5167 if (!sal
.explicit_line
)
5169 CORE_ADDR func_addr
, func_end
;
5170 for (i
= 0; i
< expanded
.nelts
; ++i
)
5172 CORE_ADDR pc
= expanded
.sals
[i
].pc
;
5173 char *this_function
;
5174 if (find_pc_partial_function (pc
, &this_function
,
5175 &func_addr
, &func_end
))
5177 if (this_function
&&
5178 strcmp (this_function
, original_function
) != 0)
5180 remove_sal (&expanded
, i
);
5183 else if (func_addr
== pc
)
5185 /* We're at beginning of a function, and should
5187 struct symbol
*sym
= find_pc_function (pc
);
5189 expanded
.sals
[i
] = find_function_start_sal (sym
, 1);
5192 = gdbarch_skip_prologue (current_gdbarch
, pc
);
5199 if (expanded
.nelts
<= 1)
5201 /* This is un ugly workaround. If we get zero
5202 expanded sals then something is really wrong.
5203 Fix that by returnign the original sal. */
5204 xfree (expanded
.sals
);
5206 expanded
.sals
= xmalloc (sizeof (struct symtab_and_line
));
5207 sal
.pc
= original_pc
;
5208 expanded
.sals
[0] = sal
;
5215 for (i
= 0; i
< expanded
.nelts
; ++i
)
5216 if (expanded
.sals
[i
].pc
== original_pc
)
5227 /* Add SALS.nelts breakpoints to the breakpoint table. For each
5228 SALS.sal[i] breakpoint, include the corresponding ADDR_STRING[i]
5229 value. COND_STRING, if not NULL, specified the condition to be
5230 used for all breakpoints. Essentially the only case where
5231 SALS.nelts is not 1 is when we set a breakpoint on an overloaded
5232 function. In that case, it's still not possible to specify
5233 separate conditions for different overloaded functions, so
5234 we take just a single condition string.
5236 NOTE: If the function succeeds, the caller is expected to cleanup
5237 the arrays ADDR_STRING, COND_STRING, and SALS (but not the
5238 array contents). If the function fails (error() is called), the
5239 caller is expected to cleanups both the ADDR_STRING, COND_STRING,
5240 COND and SALS arrays and each of those arrays contents. */
5243 create_breakpoints (struct symtabs_and_lines sals
, char **addr_string
,
5245 enum bptype type
, enum bpdisp disposition
,
5246 int thread
, int ignore_count
,
5247 struct breakpoint_ops
*ops
, int from_tty
)
5250 for (i
= 0; i
< sals
.nelts
; ++i
)
5252 struct symtabs_and_lines expanded
=
5253 expand_line_sal_maybe (sals
.sals
[i
]);
5255 create_breakpoint (expanded
, addr_string
[i
],
5256 cond_string
, type
, disposition
,
5257 thread
, ignore_count
, ops
, from_tty
);
5260 update_global_location_list ();
5263 /* Parse ARG which is assumed to be a SAL specification possibly
5264 followed by conditionals. On return, SALS contains an array of SAL
5265 addresses found. ADDR_STRING contains a vector of (canonical)
5266 address strings. ARG points to the end of the SAL. */
5269 parse_breakpoint_sals (char **address
,
5270 struct symtabs_and_lines
*sals
,
5271 char ***addr_string
,
5274 char *addr_start
= *address
;
5275 *addr_string
= NULL
;
5276 /* If no arg given, or if first arg is 'if ', use the default
5278 if ((*address
) == NULL
5279 || (strncmp ((*address
), "if", 2) == 0 && isspace ((*address
)[2])))
5281 if (default_breakpoint_valid
)
5283 struct symtab_and_line sal
;
5284 init_sal (&sal
); /* initialize to zeroes */
5285 sals
->sals
= (struct symtab_and_line
*)
5286 xmalloc (sizeof (struct symtab_and_line
));
5287 sal
.pc
= default_breakpoint_address
;
5288 sal
.line
= default_breakpoint_line
;
5289 sal
.symtab
= default_breakpoint_symtab
;
5290 sal
.section
= find_pc_overlay (sal
.pc
);
5291 sals
->sals
[0] = sal
;
5295 error (_("No default breakpoint address now."));
5299 /* Force almost all breakpoints to be in terms of the
5300 current_source_symtab (which is decode_line_1's default). This
5301 should produce the results we want almost all of the time while
5302 leaving default_breakpoint_* alone.
5303 ObjC: However, don't match an Objective-C method name which
5304 may have a '+' or '-' succeeded by a '[' */
5306 struct symtab_and_line cursal
= get_current_source_symtab_and_line ();
5308 if (default_breakpoint_valid
5310 || ((strchr ("+-", (*address
)[0]) != NULL
)
5311 && ((*address
)[1] != '['))))
5312 *sals
= decode_line_1 (address
, 1, default_breakpoint_symtab
,
5313 default_breakpoint_line
, addr_string
,
5316 *sals
= decode_line_1 (address
, 1, (struct symtab
*) NULL
, 0,
5317 addr_string
, not_found_ptr
);
5319 /* For any SAL that didn't have a canonical string, fill one in. */
5320 if (sals
->nelts
> 0 && *addr_string
== NULL
)
5321 *addr_string
= xcalloc (sals
->nelts
, sizeof (char **));
5322 if (addr_start
!= (*address
))
5325 for (i
= 0; i
< sals
->nelts
; i
++)
5327 /* Add the string if not present. */
5328 if ((*addr_string
)[i
] == NULL
)
5329 (*addr_string
)[i
] = savestring (addr_start
, (*address
) - addr_start
);
5335 /* Convert each SAL into a real PC. Verify that the PC can be
5336 inserted as a breakpoint. If it can't throw an error. */
5339 breakpoint_sals_to_pc (struct symtabs_and_lines
*sals
,
5343 for (i
= 0; i
< sals
->nelts
; i
++)
5344 resolve_sal_pc (&sals
->sals
[i
]);
5348 do_captured_parse_breakpoint (struct ui_out
*ui
, void *data
)
5350 struct captured_parse_breakpoint_args
*args
= data
;
5352 parse_breakpoint_sals (args
->arg_p
, args
->sals_p
, args
->addr_string_p
,
5353 args
->not_found_ptr
);
5356 /* Given TOK, a string specification of condition and thread, as
5357 accepted by the 'break' command, extract the condition
5358 string and thread number and set *COND_STRING and *THREAD.
5359 PC identifies the context at which the condition should be parsed.
5360 If no condition is found, *COND_STRING is set to NULL.
5361 If no thread is found, *THREAD is set to -1. */
5363 find_condition_and_thread (char *tok
, CORE_ADDR pc
,
5364 char **cond_string
, int *thread
)
5366 *cond_string
= NULL
;
5372 char *cond_start
= NULL
;
5373 char *cond_end
= NULL
;
5374 while (*tok
== ' ' || *tok
== '\t')
5379 while (*end_tok
!= ' ' && *end_tok
!= '\t' && *end_tok
!= '\000')
5382 toklen
= end_tok
- tok
;
5384 if (toklen
>= 1 && strncmp (tok
, "if", toklen
) == 0)
5386 tok
= cond_start
= end_tok
+ 1;
5387 parse_exp_1 (&tok
, block_for_pc (pc
), 0);
5389 *cond_string
= savestring (cond_start
,
5390 cond_end
- cond_start
);
5392 else if (toklen
>= 1 && strncmp (tok
, "thread", toklen
) == 0)
5398 *thread
= strtol (tok
, &tok
, 0);
5400 error (_("Junk after thread keyword."));
5401 if (!valid_thread_id (*thread
))
5402 error (_("Unknown thread %d."), *thread
);
5405 error (_("Junk at end of arguments."));
5409 /* Set a breakpoint. This function is shared between
5410 CLI and MI functions for setting a breakpoint.
5411 This function has two major modes of operations,
5412 selected by the PARSE_CONDITION_AND_THREAD parameter.
5413 If non-zero, the function will parse arg, extracting
5414 breakpoint location, address and thread. Otherwise,
5415 ARG is just the location of breakpoint, with condition
5416 and thread specified by the COND_STRING and THREAD
5420 break_command_really (char *arg
, char *cond_string
, int thread
,
5421 int parse_condition_and_thread
,
5422 int tempflag
, int hardwareflag
,
5424 enum auto_boolean pending_break_support
,
5425 struct breakpoint_ops
*ops
,
5428 struct gdb_exception e
;
5429 struct symtabs_and_lines sals
;
5430 struct symtab_and_line pending_sal
;
5433 char *addr_start
= arg
;
5435 struct cleanup
*old_chain
;
5436 struct cleanup
*breakpoint_chain
= NULL
;
5437 struct captured_parse_breakpoint_args parse_args
;
5446 parse_args
.arg_p
= &arg
;
5447 parse_args
.sals_p
= &sals
;
5448 parse_args
.addr_string_p
= &addr_string
;
5449 parse_args
.not_found_ptr
= ¬_found
;
5451 e
= catch_exception (uiout
, do_captured_parse_breakpoint
,
5452 &parse_args
, RETURN_MASK_ALL
);
5454 /* If caller is interested in rc value from parse, set value. */
5458 throw_exception (e
);
5462 case NOT_FOUND_ERROR
:
5464 /* If pending breakpoint support is turned off, throw
5467 if (pending_break_support
== AUTO_BOOLEAN_FALSE
)
5468 throw_exception (e
);
5470 exception_print (gdb_stderr
, e
);
5472 /* If pending breakpoint support is auto query and the user
5473 selects no, then simply return the error code. */
5474 if (pending_break_support
== AUTO_BOOLEAN_AUTO
&&
5475 !nquery ("Make breakpoint pending on future shared library load? "))
5478 /* At this point, either the user was queried about setting
5479 a pending breakpoint and selected yes, or pending
5480 breakpoint behavior is on and thus a pending breakpoint
5481 is defaulted on behalf of the user. */
5482 copy_arg
= xstrdup (addr_start
);
5483 addr_string
= ©_arg
;
5485 sals
.sals
= &pending_sal
;
5490 throw_exception (e
);
5497 /* Create a chain of things that always need to be cleaned up. */
5498 old_chain
= make_cleanup (null_cleanup
, 0);
5502 /* Make sure that all storage allocated to SALS gets freed. */
5503 make_cleanup (xfree
, sals
.sals
);
5505 /* Cleanup the addr_string array but not its contents. */
5506 make_cleanup (xfree
, addr_string
);
5509 /* ----------------------------- SNIP -----------------------------
5510 Anything added to the cleanup chain beyond this point is assumed
5511 to be part of a breakpoint. If the breakpoint create succeeds
5512 then the memory is not reclaimed. */
5513 breakpoint_chain
= make_cleanup (null_cleanup
, 0);
5515 /* Mark the contents of the addr_string for cleanup. These go on
5516 the breakpoint_chain and only occure if the breakpoint create
5518 for (i
= 0; i
< sals
.nelts
; i
++)
5520 if (addr_string
[i
] != NULL
)
5521 make_cleanup (xfree
, addr_string
[i
]);
5524 /* Resolve all line numbers to PC's and verify that the addresses
5525 are ok for the target. */
5527 breakpoint_sals_to_pc (&sals
, addr_start
);
5529 /* Verify that condition can be parsed, before setting any
5530 breakpoints. Allocate a separate condition expression for each
5534 if (parse_condition_and_thread
)
5536 /* Here we only parse 'arg' to separate condition
5537 from thread number, so parsing in context of first
5538 sal is OK. When setting the breakpoint we'll
5539 re-parse it in context of each sal. */
5542 find_condition_and_thread (arg
, sals
.sals
[0].pc
, &cond_string
, &thread
);
5544 make_cleanup (xfree
, cond_string
);
5548 /* Create a private copy of condition string. */
5551 cond_string
= xstrdup (cond_string
);
5552 make_cleanup (xfree
, cond_string
);
5555 create_breakpoints (sals
, addr_string
, cond_string
,
5556 hardwareflag
? bp_hardware_breakpoint
5558 tempflag
? disp_del
: disp_donttouch
,
5559 thread
, ignore_count
, ops
, from_tty
);
5563 struct symtab_and_line sal
= {0};
5564 struct breakpoint
*b
;
5566 make_cleanup (xfree
, copy_arg
);
5568 b
= set_raw_breakpoint_without_location (hardwareflag
5569 ? bp_hardware_breakpoint
5571 set_breakpoint_count (breakpoint_count
+ 1);
5572 b
->number
= breakpoint_count
;
5574 b
->addr_string
= addr_string
[0];
5575 b
->cond_string
= NULL
;
5576 b
->ignore_count
= ignore_count
;
5577 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
5578 b
->condition_not_parsed
= 1;
5581 update_global_location_list ();
5586 warning (_("Multiple breakpoints were set.\n"
5587 "Use the \"delete\" command to delete unwanted breakpoints."));
5588 /* That's it. Discard the cleanups for data inserted into the
5590 discard_cleanups (breakpoint_chain
);
5591 /* But cleanup everything else. */
5592 do_cleanups (old_chain
);
5595 /* Set a breakpoint.
5596 ARG is a string describing breakpoint address,
5597 condition, and thread.
5598 FLAG specifies if a breakpoint is hardware on,
5599 and if breakpoint is temporary, using BP_HARDWARE_FLAG
5603 break_command_1 (char *arg
, int flag
, int from_tty
)
5605 int hardwareflag
= flag
& BP_HARDWAREFLAG
;
5606 int tempflag
= flag
& BP_TEMPFLAG
;
5608 break_command_really (arg
,
5609 NULL
, 0, 1 /* parse arg */,
5610 tempflag
, hardwareflag
,
5611 0 /* Ignore count */,
5612 pending_break_support
,
5613 NULL
/* breakpoint_ops */,
5619 set_breakpoint (char *address
, char *condition
,
5620 int hardwareflag
, int tempflag
,
5621 int thread
, int ignore_count
,
5624 break_command_really (address
, condition
, thread
,
5625 0 /* condition and thread are valid. */,
5626 tempflag
, hardwareflag
,
5629 ? AUTO_BOOLEAN_TRUE
: AUTO_BOOLEAN_FALSE
,
5633 /* Adjust SAL to the first instruction past the function prologue.
5634 The end of the prologue is determined using the line table from
5635 the debugging information.
5637 If SAL is already past the prologue, then do nothing. */
5640 skip_prologue_sal (struct symtab_and_line
*sal
)
5642 struct symbol
*sym
= find_pc_function (sal
->pc
);
5643 struct symtab_and_line start_sal
;
5648 start_sal
= find_function_start_sal (sym
, 1);
5649 if (sal
->pc
< start_sal
.pc
)
5653 /* Helper function for break_command_1 and disassemble_command. */
5656 resolve_sal_pc (struct symtab_and_line
*sal
)
5660 if (sal
->pc
== 0 && sal
->symtab
!= NULL
)
5662 if (!find_line_pc (sal
->symtab
, sal
->line
, &pc
))
5663 error (_("No line %d in file \"%s\"."),
5664 sal
->line
, sal
->symtab
->filename
);
5667 /* If this SAL corresponds to a breakpoint inserted using
5668 a line number, then skip the function prologue if necessary. */
5669 if (sal
->explicit_line
)
5670 skip_prologue_sal (sal
);
5673 if (sal
->section
== 0 && sal
->symtab
!= NULL
)
5675 struct blockvector
*bv
;
5679 bv
= blockvector_for_pc_sect (sal
->pc
, 0, &b
, sal
->symtab
);
5682 sym
= block_function (b
);
5685 fixup_symbol_section (sym
, sal
->symtab
->objfile
);
5686 sal
->section
= SYMBOL_BFD_SECTION (sym
);
5690 /* It really is worthwhile to have the section, so we'll just
5691 have to look harder. This case can be executed if we have
5692 line numbers but no functions (as can happen in assembly
5695 struct minimal_symbol
*msym
;
5697 msym
= lookup_minimal_symbol_by_pc (sal
->pc
);
5699 sal
->section
= SYMBOL_BFD_SECTION (msym
);
5706 break_command (char *arg
, int from_tty
)
5708 break_command_1 (arg
, 0, from_tty
);
5712 tbreak_command (char *arg
, int from_tty
)
5714 break_command_1 (arg
, BP_TEMPFLAG
, from_tty
);
5718 hbreak_command (char *arg
, int from_tty
)
5720 break_command_1 (arg
, BP_HARDWAREFLAG
, from_tty
);
5724 thbreak_command (char *arg
, int from_tty
)
5726 break_command_1 (arg
, (BP_TEMPFLAG
| BP_HARDWAREFLAG
), from_tty
);
5730 stop_command (char *arg
, int from_tty
)
5732 printf_filtered (_("Specify the type of breakpoint to set.\n\
5733 Usage: stop in <function | address>\n\
5734 stop at <line>\n"));
5738 stopin_command (char *arg
, int from_tty
)
5742 if (arg
== (char *) NULL
)
5744 else if (*arg
!= '*')
5749 /* look for a ':'. If this is a line number specification, then
5750 say it is bad, otherwise, it should be an address or
5751 function/method name */
5752 while (*argptr
&& !hasColon
)
5754 hasColon
= (*argptr
== ':');
5759 badInput
= (*argptr
!= ':'); /* Not a class::method */
5761 badInput
= isdigit (*arg
); /* a simple line number */
5765 printf_filtered (_("Usage: stop in <function | address>\n"));
5767 break_command_1 (arg
, 0, from_tty
);
5771 stopat_command (char *arg
, int from_tty
)
5775 if (arg
== (char *) NULL
|| *arg
== '*') /* no line number */
5782 /* look for a ':'. If there is a '::' then get out, otherwise
5783 it is probably a line number. */
5784 while (*argptr
&& !hasColon
)
5786 hasColon
= (*argptr
== ':');
5791 badInput
= (*argptr
== ':'); /* we have class::method */
5793 badInput
= !isdigit (*arg
); /* not a line number */
5797 printf_filtered (_("Usage: stop at <line>\n"));
5799 break_command_1 (arg
, 0, from_tty
);
5802 /* accessflag: hw_write: watch write,
5803 hw_read: watch read,
5804 hw_access: watch access (read or write) */
5806 watch_command_1 (char *arg
, int accessflag
, int from_tty
)
5808 struct breakpoint
*b
, *scope_breakpoint
= NULL
;
5809 struct symtab_and_line sal
;
5810 struct expression
*exp
;
5811 struct block
*exp_valid_block
;
5812 struct value
*val
, *mark
;
5813 struct frame_info
*frame
;
5814 struct frame_info
*prev_frame
= NULL
;
5815 char *exp_start
= NULL
;
5816 char *exp_end
= NULL
;
5817 char *tok
, *id_tok_start
, *end_tok
;
5819 char *cond_start
= NULL
;
5820 char *cond_end
= NULL
;
5821 struct expression
*cond
= NULL
;
5822 int i
, other_type_used
, target_resources_ok
= 0;
5823 enum bptype bp_type
;
5827 init_sal (&sal
); /* initialize to zeroes */
5829 /* Make sure that we actually have parameters to parse. */
5830 if (arg
!= NULL
&& arg
[0] != '\0')
5832 toklen
= strlen (arg
); /* Size of argument list. */
5834 /* Points tok to the end of the argument list. */
5835 tok
= arg
+ toklen
- 1;
5837 /* Go backwards in the parameters list. Skip the last parameter.
5838 If we're expecting a 'thread <thread_num>' parameter, this should
5839 be the thread identifier. */
5840 while (tok
> arg
&& (*tok
== ' ' || *tok
== '\t'))
5842 while (tok
> arg
&& (*tok
!= ' ' && *tok
!= '\t'))
5845 /* Points end_tok to the beginning of the last token. */
5846 id_tok_start
= tok
+ 1;
5848 /* Go backwards in the parameters list. Skip one more parameter.
5849 If we're expecting a 'thread <thread_num>' parameter, we should
5850 reach a "thread" token. */
5851 while (tok
> arg
&& (*tok
== ' ' || *tok
== '\t'))
5856 while (tok
> arg
&& (*tok
!= ' ' && *tok
!= '\t'))
5859 /* Move the pointer forward to skip the whitespace and
5860 calculate the length of the token. */
5862 toklen
= end_tok
- tok
;
5864 if (toklen
>= 1 && strncmp (tok
, "thread", toklen
) == 0)
5866 /* At this point we've found a "thread" token, which means
5867 the user is trying to set a watchpoint that triggers
5868 only in a specific thread. */
5871 /* Extract the thread ID from the next token. */
5872 thread
= strtol (id_tok_start
, &endp
, 0);
5874 /* Check if the user provided a valid numeric value for the
5876 if (*endp
!= ' ' && *endp
!= '\t' && *endp
!= '\0')
5877 error (_("Invalid thread ID specification %s."), id_tok_start
);
5879 /* Check if the thread actually exists. */
5880 if (!valid_thread_id (thread
))
5881 error (_("Unknown thread %d."), thread
);
5883 /* Truncate the string and get rid of the thread <thread_num>
5884 parameter before the parameter list is parsed by the
5885 evaluate_expression() function. */
5890 /* Parse the rest of the arguments. */
5891 innermost_block
= NULL
;
5893 exp
= parse_exp_1 (&arg
, 0, 0);
5895 exp_valid_block
= innermost_block
;
5896 mark
= value_mark ();
5897 fetch_watchpoint_value (exp
, &val
, NULL
, NULL
);
5899 release_value (val
);
5902 while (*tok
== ' ' || *tok
== '\t')
5906 while (*end_tok
!= ' ' && *end_tok
!= '\t' && *end_tok
!= '\000')
5909 toklen
= end_tok
- tok
;
5910 if (toklen
>= 1 && strncmp (tok
, "if", toklen
) == 0)
5912 tok
= cond_start
= end_tok
+ 1;
5913 cond
= parse_exp_1 (&tok
, 0, 0);
5917 error (_("Junk at end of command."));
5919 if (accessflag
== hw_read
)
5920 bp_type
= bp_read_watchpoint
;
5921 else if (accessflag
== hw_access
)
5922 bp_type
= bp_access_watchpoint
;
5924 bp_type
= bp_hardware_watchpoint
;
5926 mem_cnt
= can_use_hardware_watchpoint (val
);
5927 if (mem_cnt
== 0 && bp_type
!= bp_hardware_watchpoint
)
5928 error (_("Expression cannot be implemented with read/access watchpoint."));
5931 i
= hw_watchpoint_used_count (bp_type
, &other_type_used
);
5932 target_resources_ok
=
5933 TARGET_CAN_USE_HARDWARE_WATCHPOINT (bp_type
, i
+ mem_cnt
,
5935 if (target_resources_ok
== 0 && bp_type
!= bp_hardware_watchpoint
)
5936 error (_("Target does not support this type of hardware watchpoint."));
5938 if (target_resources_ok
< 0 && bp_type
!= bp_hardware_watchpoint
)
5939 error (_("Target can only support one kind of HW watchpoint at a time."));
5942 /* Change the type of breakpoint to an ordinary watchpoint if a hardware
5943 watchpoint could not be set. */
5944 if (!mem_cnt
|| target_resources_ok
<= 0)
5945 bp_type
= bp_watchpoint
;
5947 frame
= block_innermost_frame (exp_valid_block
);
5949 prev_frame
= get_prev_frame (frame
);
5953 /* If the expression is "local", then set up a "watchpoint scope"
5954 breakpoint at the point where we've left the scope of the watchpoint
5955 expression. Create the scope breakpoint before the watchpoint, so
5956 that we will encounter it first in bpstat_stop_status. */
5957 if (innermost_block
&& prev_frame
)
5959 scope_breakpoint
= create_internal_breakpoint (get_frame_pc (prev_frame
),
5960 bp_watchpoint_scope
);
5962 scope_breakpoint
->enable_state
= bp_enabled
;
5964 /* Automatically delete the breakpoint when it hits. */
5965 scope_breakpoint
->disposition
= disp_del
;
5967 /* Only break in the proper frame (help with recursion). */
5968 scope_breakpoint
->frame_id
= get_frame_id (prev_frame
);
5970 /* Set the address at which we will stop. */
5971 scope_breakpoint
->loc
->requested_address
5972 = get_frame_pc (prev_frame
);
5973 scope_breakpoint
->loc
->address
5974 = adjust_breakpoint_address (scope_breakpoint
->loc
->requested_address
,
5975 scope_breakpoint
->type
);
5978 /* Now set up the breakpoint. */
5979 b
= set_raw_breakpoint (sal
, bp_type
);
5980 set_breakpoint_count (breakpoint_count
+ 1);
5981 b
->number
= breakpoint_count
;
5983 b
->disposition
= disp_donttouch
;
5985 b
->exp_valid_block
= exp_valid_block
;
5986 b
->exp_string
= savestring (exp_start
, exp_end
- exp_start
);
5989 b
->loc
->cond
= cond
;
5991 b
->cond_string
= savestring (cond_start
, cond_end
- cond_start
);
5996 b
->watchpoint_frame
= get_frame_id (frame
);
5998 b
->watchpoint_frame
= null_frame_id
;
6000 if (scope_breakpoint
!= NULL
)
6002 /* The scope breakpoint is related to the watchpoint. We will
6003 need to act on them together. */
6004 b
->related_breakpoint
= scope_breakpoint
;
6005 scope_breakpoint
->related_breakpoint
= b
;
6008 value_free_to_mark (mark
);
6010 update_global_location_list ();
6013 /* Return count of locations need to be watched and can be handled
6014 in hardware. If the watchpoint can not be handled
6015 in hardware return zero. */
6018 can_use_hardware_watchpoint (struct value
*v
)
6020 int found_memory_cnt
= 0;
6021 struct value
*head
= v
;
6023 /* Did the user specifically forbid us to use hardware watchpoints? */
6024 if (!can_use_hw_watchpoints
)
6027 /* Make sure that the value of the expression depends only upon
6028 memory contents, and values computed from them within GDB. If we
6029 find any register references or function calls, we can't use a
6030 hardware watchpoint.
6032 The idea here is that evaluating an expression generates a series
6033 of values, one holding the value of every subexpression. (The
6034 expression a*b+c has five subexpressions: a, b, a*b, c, and
6035 a*b+c.) GDB's values hold almost enough information to establish
6036 the criteria given above --- they identify memory lvalues,
6037 register lvalues, computed values, etcetera. So we can evaluate
6038 the expression, and then scan the chain of values that leaves
6039 behind to decide whether we can detect any possible change to the
6040 expression's final value using only hardware watchpoints.
6042 However, I don't think that the values returned by inferior
6043 function calls are special in any way. So this function may not
6044 notice that an expression involving an inferior function call
6045 can't be watched with hardware watchpoints. FIXME. */
6046 for (; v
; v
= value_next (v
))
6048 if (VALUE_LVAL (v
) == lval_memory
)
6051 /* A lazy memory lvalue is one that GDB never needed to fetch;
6052 we either just used its address (e.g., `a' in `a.b') or
6053 we never needed it at all (e.g., `a' in `a,b'). */
6057 /* Ahh, memory we actually used! Check if we can cover
6058 it with hardware watchpoints. */
6059 struct type
*vtype
= check_typedef (value_type (v
));
6061 /* We only watch structs and arrays if user asked for it
6062 explicitly, never if they just happen to appear in a
6063 middle of some value chain. */
6065 || (TYPE_CODE (vtype
) != TYPE_CODE_STRUCT
6066 && TYPE_CODE (vtype
) != TYPE_CODE_ARRAY
))
6068 CORE_ADDR vaddr
= VALUE_ADDRESS (v
) + value_offset (v
);
6069 int len
= TYPE_LENGTH (value_type (v
));
6071 if (!TARGET_REGION_OK_FOR_HW_WATCHPOINT (vaddr
, len
))
6078 else if (VALUE_LVAL (v
) != not_lval
6079 && deprecated_value_modifiable (v
) == 0)
6080 return 0; /* ??? What does this represent? */
6081 else if (VALUE_LVAL (v
) == lval_register
)
6082 return 0; /* cannot watch a register with a HW watchpoint */
6085 /* The expression itself looks suitable for using a hardware
6086 watchpoint, but give the target machine a chance to reject it. */
6087 return found_memory_cnt
;
6091 watch_command_wrapper (char *arg
, int from_tty
)
6093 watch_command (arg
, from_tty
);
6097 watch_command (char *arg
, int from_tty
)
6099 watch_command_1 (arg
, hw_write
, from_tty
);
6103 rwatch_command_wrapper (char *arg
, int from_tty
)
6105 rwatch_command (arg
, from_tty
);
6109 rwatch_command (char *arg
, int from_tty
)
6111 watch_command_1 (arg
, hw_read
, from_tty
);
6115 awatch_command_wrapper (char *arg
, int from_tty
)
6117 awatch_command (arg
, from_tty
);
6121 awatch_command (char *arg
, int from_tty
)
6123 watch_command_1 (arg
, hw_access
, from_tty
);
6127 /* Helper routines for the until_command routine in infcmd.c. Here
6128 because it uses the mechanisms of breakpoints. */
6130 /* This function is called by fetch_inferior_event via the
6131 cmd_continuation pointer, to complete the until command. It takes
6132 care of cleaning up the temporary breakpoints set up by the until
6135 until_break_command_continuation (struct continuation_arg
*arg
, int error
)
6137 delete_breakpoint ((struct breakpoint
*)(arg
->data
.pointer
));
6139 delete_breakpoint ((struct breakpoint
*)(arg
->next
->data
.pointer
));
6143 until_break_command (char *arg
, int from_tty
, int anywhere
)
6145 struct symtabs_and_lines sals
;
6146 struct symtab_and_line sal
;
6147 struct frame_info
*frame
= get_selected_frame (NULL
);
6148 struct frame_info
*prev_frame
= get_prev_frame (frame
);
6149 struct breakpoint
*breakpoint
;
6150 struct breakpoint
*breakpoint2
= NULL
;
6151 struct cleanup
*old_chain
;
6152 struct continuation_arg
*arg1
;
6153 struct continuation_arg
*arg2
;
6156 clear_proceed_status ();
6158 /* Set a breakpoint where the user wants it and at return from
6161 if (default_breakpoint_valid
)
6162 sals
= decode_line_1 (&arg
, 1, default_breakpoint_symtab
,
6163 default_breakpoint_line
, (char ***) NULL
, NULL
);
6165 sals
= decode_line_1 (&arg
, 1, (struct symtab
*) NULL
,
6166 0, (char ***) NULL
, NULL
);
6168 if (sals
.nelts
!= 1)
6169 error (_("Couldn't get information on specified line."));
6172 xfree (sals
.sals
); /* malloc'd, so freed */
6175 error (_("Junk at end of arguments."));
6177 resolve_sal_pc (&sal
);
6180 /* If the user told us to continue until a specified location,
6181 we don't specify a frame at which we need to stop. */
6182 breakpoint
= set_momentary_breakpoint (sal
, null_frame_id
, bp_until
);
6184 /* Otherwise, specify the current frame, because we want to stop only
6185 at the very same frame. */
6186 breakpoint
= set_momentary_breakpoint (sal
, get_frame_id (frame
),
6189 old_chain
= make_cleanup_delete_breakpoint (breakpoint
);
6191 /* Keep within the current frame, or in frames called by the current
6195 sal
= find_pc_line (get_frame_pc (prev_frame
), 0);
6196 sal
.pc
= get_frame_pc (prev_frame
);
6197 breakpoint2
= set_momentary_breakpoint (sal
, get_frame_id (prev_frame
),
6199 make_cleanup_delete_breakpoint (breakpoint2
);
6202 proceed (-1, TARGET_SIGNAL_DEFAULT
, 0);
6204 /* If we are running asynchronously, and proceed call above has actually
6205 managed to start the target, arrange for breakpoints to be
6206 deleted when the target stops. Otherwise, we're already stopped and
6207 delete breakpoints via cleanup chain. */
6209 if (target_can_async_p () && target_executing
)
6212 (struct continuation_arg
*) xmalloc (sizeof (struct continuation_arg
));
6214 arg1
->data
.pointer
= breakpoint
;
6218 arg2
= (struct continuation_arg
*)
6219 xmalloc ( sizeof (struct continuation_arg
));
6221 arg2
->data
.pointer
= breakpoint2
;
6225 discard_cleanups (old_chain
);
6226 add_continuation (until_break_command_continuation
, arg1
);
6229 do_cleanups (old_chain
);
6233 ep_skip_leading_whitespace (char **s
)
6235 if ((s
== NULL
) || (*s
== NULL
))
6237 while (isspace (**s
))
6241 /* This function examines a string, and attempts to find a token
6242 that might be an event name in the leading characters. If a
6243 possible match is found, a pointer to the last character of
6244 the token is returned. Else, NULL is returned. */
6247 ep_find_event_name_end (char *arg
)
6250 char *event_name_end
= NULL
;
6252 /* If we could depend upon the presense of strrpbrk, we'd use that... */
6256 /* We break out of the loop when we find a token delimiter.
6257 Basically, we're looking for alphanumerics and underscores;
6258 anything else delimites the token. */
6261 if (!isalnum (*s
) && (*s
!= '_'))
6267 return event_name_end
;
6271 /* This function attempts to parse an optional "if <cond>" clause
6272 from the arg string. If one is not found, it returns NULL.
6274 Else, it returns a pointer to the condition string. (It does not
6275 attempt to evaluate the string against a particular block.) And,
6276 it updates arg to point to the first character following the parsed
6277 if clause in the arg string. */
6280 ep_parse_optional_if_clause (char **arg
)
6284 if (((*arg
)[0] != 'i') || ((*arg
)[1] != 'f') || !isspace ((*arg
)[2]))
6287 /* Skip the "if" keyword. */
6290 /* Skip any extra leading whitespace, and record the start of the
6291 condition string. */
6292 ep_skip_leading_whitespace (arg
);
6295 /* Assume that the condition occupies the remainder of the arg string. */
6296 (*arg
) += strlen (cond_string
);
6301 /* This function attempts to parse an optional filename from the arg
6302 string. If one is not found, it returns NULL.
6304 Else, it returns a pointer to the parsed filename. (This function
6305 makes no attempt to verify that a file of that name exists, or is
6306 accessible.) And, it updates arg to point to the first character
6307 following the parsed filename in the arg string.
6309 Note that clients needing to preserve the returned filename for
6310 future access should copy it to their own buffers. */
6312 ep_parse_optional_filename (char **arg
)
6314 static char filename
[1024];
6319 if ((*arg_p
== '\0') || isspace (*arg_p
))
6337 /* Commands to deal with catching events, such as signals, exceptions,
6338 process start/exit, etc. */
6342 catch_fork
, catch_vfork
6347 catch_fork_command_1 (catch_fork_kind fork_kind
, char *arg
, int tempflag
,
6350 char *cond_string
= NULL
;
6352 ep_skip_leading_whitespace (&arg
);
6354 /* The allowed syntax is:
6356 catch [v]fork if <cond>
6358 First, check if there's an if clause. */
6359 cond_string
= ep_parse_optional_if_clause (&arg
);
6361 if ((*arg
!= '\0') && !isspace (*arg
))
6362 error (_("Junk at end of arguments."));
6364 /* If this target supports it, create a fork or vfork catchpoint
6365 and enable reporting of such events. */
6369 create_fork_event_catchpoint (tempflag
, cond_string
);
6372 create_vfork_event_catchpoint (tempflag
, cond_string
);
6375 error (_("unsupported or unknown fork kind; cannot catch it"));
6381 catch_exec_command_1 (char *arg
, int tempflag
, int from_tty
)
6383 char *cond_string
= NULL
;
6385 ep_skip_leading_whitespace (&arg
);
6387 /* The allowed syntax is:
6389 catch exec if <cond>
6391 First, check if there's an if clause. */
6392 cond_string
= ep_parse_optional_if_clause (&arg
);
6394 if ((*arg
!= '\0') && !isspace (*arg
))
6395 error (_("Junk at end of arguments."));
6397 /* If this target supports it, create an exec catchpoint
6398 and enable reporting of such events. */
6399 create_exec_event_catchpoint (tempflag
, cond_string
);
6403 catch_load_command_1 (char *arg
, int tempflag
, int from_tty
)
6405 char *dll_pathname
= NULL
;
6406 char *cond_string
= NULL
;
6408 ep_skip_leading_whitespace (&arg
);
6410 /* The allowed syntax is:
6412 catch load if <cond>
6413 catch load <filename>
6414 catch load <filename> if <cond>
6416 The user is not allowed to specify the <filename> after an
6419 We'll ignore the pathological case of a file named "if".
6421 First, check if there's an if clause. If so, then there
6422 cannot be a filename. */
6423 cond_string
= ep_parse_optional_if_clause (&arg
);
6425 /* If there was an if clause, then there cannot be a filename.
6426 Else, there might be a filename and an if clause. */
6427 if (cond_string
== NULL
)
6429 dll_pathname
= ep_parse_optional_filename (&arg
);
6430 ep_skip_leading_whitespace (&arg
);
6431 cond_string
= ep_parse_optional_if_clause (&arg
);
6434 if ((*arg
!= '\0') && !isspace (*arg
))
6435 error (_("Junk at end of arguments."));
6437 /* Create a load breakpoint that only triggers when a load of
6438 the specified dll (or any dll, if no pathname was specified)
6440 SOLIB_CREATE_CATCH_LOAD_HOOK (PIDGET (inferior_ptid
), tempflag
,
6441 dll_pathname
, cond_string
);
6445 catch_unload_command_1 (char *arg
, int tempflag
, int from_tty
)
6447 char *dll_pathname
= NULL
;
6448 char *cond_string
= NULL
;
6450 ep_skip_leading_whitespace (&arg
);
6452 /* The allowed syntax is:
6454 catch unload if <cond>
6455 catch unload <filename>
6456 catch unload <filename> if <cond>
6458 The user is not allowed to specify the <filename> after an
6461 We'll ignore the pathological case of a file named "if".
6463 First, check if there's an if clause. If so, then there
6464 cannot be a filename. */
6465 cond_string
= ep_parse_optional_if_clause (&arg
);
6467 /* If there was an if clause, then there cannot be a filename.
6468 Else, there might be a filename and an if clause. */
6469 if (cond_string
== NULL
)
6471 dll_pathname
= ep_parse_optional_filename (&arg
);
6472 ep_skip_leading_whitespace (&arg
);
6473 cond_string
= ep_parse_optional_if_clause (&arg
);
6476 if ((*arg
!= '\0') && !isspace (*arg
))
6477 error (_("Junk at end of arguments."));
6479 /* Create an unload breakpoint that only triggers when an unload of
6480 the specified dll (or any dll, if no pathname was specified)
6482 SOLIB_CREATE_CATCH_UNLOAD_HOOK (PIDGET (inferior_ptid
), tempflag
,
6483 dll_pathname
, cond_string
);
6486 static enum print_stop_action
6487 print_exception_catchpoint (struct breakpoint
*b
)
6489 int bp_temp
, bp_throw
;
6491 annotate_catchpoint (b
->number
);
6493 bp_throw
= strstr (b
->addr_string
, "throw") != NULL
;
6494 if (b
->loc
->address
!= b
->loc
->requested_address
)
6495 breakpoint_adjustment_warning (b
->loc
->requested_address
,
6498 bp_temp
= b
->loc
->owner
->disposition
== disp_del
;
6500 bp_temp
? "Temporary catchpoint "
6502 if (!ui_out_is_mi_like_p (uiout
))
6503 ui_out_field_int (uiout
, "bkptno", b
->number
);
6505 bp_throw
? " (exception thrown), "
6506 : " (exception caught), ");
6507 if (ui_out_is_mi_like_p (uiout
))
6509 ui_out_field_string (uiout
, "reason",
6510 async_reason_lookup (EXEC_ASYNC_BREAKPOINT_HIT
));
6511 ui_out_field_string (uiout
, "disp", bpdisp_text (b
->disposition
));
6512 ui_out_field_int (uiout
, "bkptno", b
->number
);
6514 return PRINT_SRC_AND_LOC
;
6518 print_one_exception_catchpoint (struct breakpoint
*b
, CORE_ADDR
*last_addr
)
6523 if (b
->loc
== NULL
|| b
->loc
->shlib_disabled
)
6524 ui_out_field_string (uiout
, "addr", "<PENDING>");
6526 ui_out_field_core_addr (uiout
, "addr", b
->loc
->address
);
6530 *last_addr
= b
->loc
->address
;
6531 if (strstr (b
->addr_string
, "throw") != NULL
)
6532 ui_out_field_string (uiout
, "what", "exception throw");
6534 ui_out_field_string (uiout
, "what", "exception catch");
6538 print_mention_exception_catchpoint (struct breakpoint
*b
)
6543 bp_temp
= b
->loc
->owner
->disposition
== disp_del
;
6544 bp_throw
= strstr (b
->addr_string
, "throw") != NULL
;
6545 ui_out_text (uiout
, bp_temp
? _("Temporary catchpoint ")
6546 : _("Catchpoint "));
6547 ui_out_field_int (uiout
, "bkptno", b
->number
);
6548 ui_out_text (uiout
, bp_throw
? _(" (throw)")
6552 static struct breakpoint_ops gnu_v3_exception_catchpoint_ops
= {
6553 print_exception_catchpoint
,
6554 print_one_exception_catchpoint
,
6555 print_mention_exception_catchpoint
6559 handle_gnu_v3_exceptions (int tempflag
, char *cond_string
,
6560 enum exception_event_kind ex_event
, int from_tty
)
6562 char *trigger_func_name
;
6564 if (ex_event
== EX_EVENT_CATCH
)
6565 trigger_func_name
= "__cxa_begin_catch";
6567 trigger_func_name
= "__cxa_throw";
6569 break_command_really (trigger_func_name
, cond_string
, -1,
6570 0 /* condition and thread are valid. */,
6573 AUTO_BOOLEAN_TRUE
/* pending */,
6574 &gnu_v3_exception_catchpoint_ops
, from_tty
);
6579 /* Deal with "catch catch" and "catch throw" commands */
6582 catch_exception_command_1 (enum exception_event_kind ex_event
, char *arg
,
6583 int tempflag
, int from_tty
)
6585 char *cond_string
= NULL
;
6586 struct symtab_and_line
*sal
= NULL
;
6588 ep_skip_leading_whitespace (&arg
);
6590 cond_string
= ep_parse_optional_if_clause (&arg
);
6592 if ((*arg
!= '\0') && !isspace (*arg
))
6593 error (_("Junk at end of arguments."));
6595 if ((ex_event
!= EX_EVENT_THROW
) &&
6596 (ex_event
!= EX_EVENT_CATCH
))
6597 error (_("Unsupported or unknown exception event; cannot catch it"));
6599 if (handle_gnu_v3_exceptions (tempflag
, cond_string
, ex_event
, from_tty
))
6602 warning (_("Unsupported with this platform/compiler combination."));
6605 /* Create a breakpoint struct for Ada exception catchpoints. */
6608 create_ada_exception_breakpoint (struct symtab_and_line sal
,
6612 struct expression
*cond
,
6613 struct breakpoint_ops
*ops
,
6617 struct breakpoint
*b
;
6621 describe_other_breakpoints (sal
.pc
, sal
.section
, -1);
6622 /* FIXME: brobecker/2006-12-28: Actually, re-implement a special
6623 version for exception catchpoints, because two catchpoints
6624 used for different exception names will use the same address.
6625 In this case, a "breakpoint ... also set at..." warning is
6626 unproductive. Besides. the warning phrasing is also a bit
6627 inapropriate, we should use the word catchpoint, and tell
6628 the user what type of catchpoint it is. The above is good
6629 enough for now, though. */
6632 b
= set_raw_breakpoint (sal
, bp_breakpoint
);
6633 set_breakpoint_count (breakpoint_count
+ 1);
6635 b
->enable_state
= bp_enabled
;
6636 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
6637 b
->number
= breakpoint_count
;
6638 b
->ignore_count
= 0;
6639 b
->loc
->cond
= cond
;
6640 b
->addr_string
= addr_string
;
6641 b
->language
= language_ada
;
6642 b
->cond_string
= cond_string
;
6643 b
->exp_string
= exp_string
;
6648 update_global_location_list ();
6651 /* Implement the "catch exception" command. */
6654 catch_ada_exception_command (char *arg
, int tempflag
, int from_tty
)
6656 struct symtab_and_line sal
;
6658 char *addr_string
= NULL
;
6659 char *exp_string
= NULL
;
6660 char *cond_string
= NULL
;
6661 struct expression
*cond
= NULL
;
6662 struct breakpoint_ops
*ops
= NULL
;
6664 sal
= ada_decode_exception_location (arg
, &addr_string
, &exp_string
,
6665 &cond_string
, &cond
, &ops
);
6666 create_ada_exception_breakpoint (sal
, addr_string
, exp_string
,
6667 cond_string
, cond
, ops
, tempflag
,
6671 /* Implement the "catch assert" command. */
6674 catch_assert_command (char *arg
, int tempflag
, int from_tty
)
6676 struct symtab_and_line sal
;
6677 char *addr_string
= NULL
;
6678 struct breakpoint_ops
*ops
= NULL
;
6680 sal
= ada_decode_assert_location (arg
, &addr_string
, &ops
);
6681 create_ada_exception_breakpoint (sal
, addr_string
, NULL
, NULL
, NULL
, ops
,
6682 tempflag
, from_tty
);
6686 catch_command_1 (char *arg
, int tempflag
, int from_tty
)
6689 /* The first argument may be an event name, such as "start" or "load".
6690 If so, then handle it as such. If it doesn't match an event name,
6691 then attempt to interpret it as an exception name. (This latter is
6692 the v4.16-and-earlier GDB meaning of the "catch" command.)
6694 First, try to find the bounds of what might be an event name. */
6695 char *arg1_start
= arg
;
6699 if (arg1_start
== NULL
)
6701 /* Old behaviour was to use pre-v-4.16 syntax */
6702 /* catch_throw_command_1 (arg1_start, tempflag, from_tty); */
6704 /* Now, this is not allowed */
6705 error (_("Catch requires an event name."));
6708 arg1_end
= ep_find_event_name_end (arg1_start
);
6709 if (arg1_end
== NULL
)
6710 error (_("catch requires an event"));
6711 arg1_length
= arg1_end
+ 1 - arg1_start
;
6713 /* Try to match what we found against known event names. */
6714 if (strncmp (arg1_start
, "signal", arg1_length
) == 0)
6716 error (_("Catch of signal not yet implemented"));
6718 else if (strncmp (arg1_start
, "catch", arg1_length
) == 0)
6720 catch_exception_command_1 (EX_EVENT_CATCH
, arg1_end
+ 1,
6721 tempflag
, from_tty
);
6723 else if (strncmp (arg1_start
, "throw", arg1_length
) == 0)
6725 catch_exception_command_1 (EX_EVENT_THROW
, arg1_end
+ 1,
6726 tempflag
, from_tty
);
6728 else if (strncmp (arg1_start
, "thread_start", arg1_length
) == 0)
6730 error (_("Catch of thread_start not yet implemented"));
6732 else if (strncmp (arg1_start
, "thread_exit", arg1_length
) == 0)
6734 error (_("Catch of thread_exit not yet implemented"));
6736 else if (strncmp (arg1_start
, "thread_join", arg1_length
) == 0)
6738 error (_("Catch of thread_join not yet implemented"));
6740 else if (strncmp (arg1_start
, "start", arg1_length
) == 0)
6742 error (_("Catch of start not yet implemented"));
6744 else if (strncmp (arg1_start
, "exit", arg1_length
) == 0)
6746 error (_("Catch of exit not yet implemented"));
6748 else if (strncmp (arg1_start
, "fork", arg1_length
) == 0)
6750 catch_fork_command_1 (catch_fork
, arg1_end
+ 1, tempflag
, from_tty
);
6752 else if (strncmp (arg1_start
, "vfork", arg1_length
) == 0)
6754 catch_fork_command_1 (catch_vfork
, arg1_end
+ 1, tempflag
, from_tty
);
6756 else if (strncmp (arg1_start
, "exec", arg1_length
) == 0)
6758 catch_exec_command_1 (arg1_end
+ 1, tempflag
, from_tty
);
6760 else if (strncmp (arg1_start
, "load", arg1_length
) == 0)
6762 catch_load_command_1 (arg1_end
+ 1, tempflag
, from_tty
);
6764 else if (strncmp (arg1_start
, "unload", arg1_length
) == 0)
6766 catch_unload_command_1 (arg1_end
+ 1, tempflag
, from_tty
);
6768 else if (strncmp (arg1_start
, "stop", arg1_length
) == 0)
6770 error (_("Catch of stop not yet implemented"));
6772 else if (strncmp (arg1_start
, "exception", arg1_length
) == 0)
6774 catch_ada_exception_command (arg1_end
+ 1, tempflag
, from_tty
);
6777 else if (strncmp (arg1_start
, "assert", arg1_length
) == 0)
6779 catch_assert_command (arg1_end
+ 1, tempflag
, from_tty
);
6782 /* This doesn't appear to be an event name */
6786 /* Pre-v.4.16 behaviour was to treat the argument
6787 as the name of an exception */
6788 /* catch_throw_command_1 (arg1_start, tempflag, from_tty); */
6789 /* Now this is not allowed */
6790 error (_("Unknown event kind specified for catch"));
6796 catch_command (char *arg
, int from_tty
)
6798 catch_command_1 (arg
, 0, from_tty
);
6803 tcatch_command (char *arg
, int from_tty
)
6805 catch_command_1 (arg
, 1, from_tty
);
6808 /* Delete breakpoints by address or line. */
6811 clear_command (char *arg
, int from_tty
)
6813 struct breakpoint
*b
;
6814 VEC(breakpoint_p
) *found
= 0;
6817 struct symtabs_and_lines sals
;
6818 struct symtab_and_line sal
;
6823 sals
= decode_line_spec (arg
, 1);
6828 sals
.sals
= (struct symtab_and_line
*)
6829 xmalloc (sizeof (struct symtab_and_line
));
6830 make_cleanup (xfree
, sals
.sals
);
6831 init_sal (&sal
); /* initialize to zeroes */
6832 sal
.line
= default_breakpoint_line
;
6833 sal
.symtab
= default_breakpoint_symtab
;
6834 sal
.pc
= default_breakpoint_address
;
6835 if (sal
.symtab
== 0)
6836 error (_("No source file specified."));
6844 /* We don't call resolve_sal_pc here. That's not
6845 as bad as it seems, because all existing breakpoints
6846 typically have both file/line and pc set. So, if
6847 clear is given file/line, we can match this to existing
6848 breakpoint without obtaining pc at all.
6850 We only support clearing given the address explicitly
6851 present in breakpoint table. Say, we've set breakpoint
6852 at file:line. There were several PC values for that file:line,
6853 due to optimization, all in one block.
6854 We've picked one PC value. If "clear" is issued with another
6855 PC corresponding to the same file:line, the breakpoint won't
6856 be cleared. We probably can still clear the breakpoint, but
6857 since the other PC value is never presented to user, user
6858 can only find it by guessing, and it does not seem important
6861 /* For each line spec given, delete bps which correspond
6862 to it. Do it in two passes, solely to preserve the current
6863 behavior that from_tty is forced true if we delete more than
6867 for (i
= 0; i
< sals
.nelts
; i
++)
6869 /* If exact pc given, clear bpts at that pc.
6870 If line given (pc == 0), clear all bpts on specified line.
6871 If defaulting, clear all bpts on default line
6874 defaulting sal.pc != 0 tests to do
6879 1 0 <can't happen> */
6883 /* Find all matching breakpoints and add them to
6888 /* Are we going to delete b? */
6889 if (b
->type
!= bp_none
6890 && b
->type
!= bp_watchpoint
6891 && b
->type
!= bp_hardware_watchpoint
6892 && b
->type
!= bp_read_watchpoint
6893 && b
->type
!= bp_access_watchpoint
)
6895 struct bp_location
*loc
= b
->loc
;
6896 for (; loc
; loc
= loc
->next
)
6898 int pc_match
= sal
.pc
6899 && (loc
->address
== sal
.pc
)
6900 && (!section_is_overlay (loc
->section
)
6901 || loc
->section
== sal
.section
);
6902 int line_match
= ((default_match
|| (0 == sal
.pc
))
6903 && b
->source_file
!= NULL
6904 && sal
.symtab
!= NULL
6905 && strcmp (b
->source_file
, sal
.symtab
->filename
) == 0
6906 && b
->line_number
== sal
.line
);
6907 if (pc_match
|| line_match
)
6916 VEC_safe_push(breakpoint_p
, found
, b
);
6919 /* Now go thru the 'found' chain and delete them. */
6920 if (VEC_empty(breakpoint_p
, found
))
6923 error (_("No breakpoint at %s."), arg
);
6925 error (_("No breakpoint at this line."));
6928 if (VEC_length(breakpoint_p
, found
) > 1)
6929 from_tty
= 1; /* Always report if deleted more than one */
6932 if (VEC_length(breakpoint_p
, found
) == 1)
6933 printf_unfiltered (_("Deleted breakpoint "));
6935 printf_unfiltered (_("Deleted breakpoints "));
6937 breakpoints_changed ();
6939 for (ix
= 0; VEC_iterate(breakpoint_p
, found
, ix
, b
); ix
++)
6942 printf_unfiltered ("%d ", b
->number
);
6943 delete_breakpoint (b
);
6946 putchar_unfiltered ('\n');
6949 /* Delete breakpoint in BS if they are `delete' breakpoints and
6950 all breakpoints that are marked for deletion, whether hit or not.
6951 This is called after any breakpoint is hit, or after errors. */
6954 breakpoint_auto_delete (bpstat bs
)
6956 struct breakpoint
*b
, *temp
;
6958 for (; bs
; bs
= bs
->next
)
6959 if (bs
->breakpoint_at
&& bs
->breakpoint_at
->owner
->disposition
== disp_del
6961 delete_breakpoint (bs
->breakpoint_at
->owner
);
6963 ALL_BREAKPOINTS_SAFE (b
, temp
)
6965 if (b
->disposition
== disp_del_at_next_stop
)
6966 delete_breakpoint (b
);
6971 update_global_location_list (void)
6973 struct breakpoint
*b
;
6974 struct bp_location
**next
= &bp_location_chain
;
6975 struct bp_location
*loc
;
6976 struct bp_location
*loc2
;
6977 struct gdb_exception e
;
6978 VEC(bp_location_p
) *old_locations
= NULL
;
6982 /* Store old locations for future reference. */
6983 for (loc
= bp_location_chain
; loc
; loc
= loc
->global_next
)
6984 VEC_safe_push (bp_location_p
, old_locations
, loc
);
6986 bp_location_chain
= NULL
;
6989 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
6992 next
= &(loc
->global_next
);
6997 /* Identify bp_location instances that are no longer present in the new
6998 list, and therefore should be freed. Note that it's not necessary that
6999 those locations should be removed from inferior -- if there's another
7000 location at the same address (previously marked as duplicate),
7001 we don't need to remove/insert the location. */
7002 for (ix
= 0; VEC_iterate(bp_location_p
, old_locations
, ix
, loc
); ++ix
)
7004 /* Tells if 'loc' is found amoung the new locations. If not, we
7006 int found_object
= 0;
7007 for (loc2
= bp_location_chain
; loc2
; loc2
= loc2
->global_next
)
7014 /* If this location is no longer present, and inserted, look if there's
7015 maybe a new location at the same address. If so, mark that one
7016 inserted, and don't remove this one. This is needed so that we
7017 don't have a time window where a breakpoint at certain location is not
7022 /* If the location is inserted now, we might have to remove it. */
7025 if (found_object
&& should_be_inserted (loc
))
7027 /* The location is still present in the location list, and still
7028 should be inserted. Don't do anything. */
7033 /* The location is either no longer present, or got disabled.
7034 See if there's another location at the same address, in which
7035 case we don't need to remove this one from the target. */
7036 if (breakpoint_address_is_meaningful (loc
->owner
))
7037 for (loc2
= bp_location_chain
; loc2
; loc2
= loc2
->global_next
)
7039 /* For the sake of should_insert_location. The
7040 call to check_duplicates will fix up this later. */
7041 loc2
->duplicate
= 0;
7042 if (should_be_inserted (loc2
)
7043 && loc2
!= loc
&& loc2
->address
== loc
->address
)
7046 loc2
->target_info
= loc
->target_info
;
7054 if (remove_breakpoint (loc
, mark_uninserted
))
7056 /* This is just about all we can do. We could keep this
7057 location on the global list, and try to remove it next
7058 time, but there's no particular reason why we will
7061 Note that at this point, loc->owner is still valid,
7062 as delete_breakpoint frees the breakpoint only
7063 after calling us. */
7064 printf_filtered (_("warning: Error removing breakpoint %d\n"),
7065 loc
->owner
->number
);
7070 free_bp_location (loc
);
7075 check_duplicates (b
);
7078 if (always_inserted_mode
&& target_has_execution
)
7079 insert_breakpoint_locations ();
7083 update_global_location_list_nothrow (void)
7085 struct gdb_exception e
;
7086 TRY_CATCH (e
, RETURN_MASK_ERROR
)
7087 update_global_location_list ();
7090 /* Delete a breakpoint and clean up all traces of it in the data
7094 delete_breakpoint (struct breakpoint
*bpt
)
7096 struct breakpoint
*b
;
7098 struct bp_location
*loc
, *next
;
7100 gdb_assert (bpt
!= NULL
);
7102 /* Has this bp already been deleted? This can happen because multiple
7103 lists can hold pointers to bp's. bpstat lists are especial culprits.
7105 One example of this happening is a watchpoint's scope bp. When the
7106 scope bp triggers, we notice that the watchpoint is out of scope, and
7107 delete it. We also delete its scope bp. But the scope bp is marked
7108 "auto-deleting", and is already on a bpstat. That bpstat is then
7109 checked for auto-deleting bp's, which are deleted.
7111 A real solution to this problem might involve reference counts in bp's,
7112 and/or giving them pointers back to their referencing bpstat's, and
7113 teaching delete_breakpoint to only free a bp's storage when no more
7114 references were extent. A cheaper bandaid was chosen. */
7115 if (bpt
->type
== bp_none
)
7118 if (deprecated_delete_breakpoint_hook
)
7119 deprecated_delete_breakpoint_hook (bpt
);
7120 breakpoint_delete_event (bpt
->number
);
7122 if (breakpoint_chain
== bpt
)
7123 breakpoint_chain
= bpt
->next
;
7128 b
->next
= bpt
->next
;
7132 free_command_lines (&bpt
->commands
);
7133 if (bpt
->cond_string
!= NULL
)
7134 xfree (bpt
->cond_string
);
7135 if (bpt
->addr_string
!= NULL
)
7136 xfree (bpt
->addr_string
);
7137 if (bpt
->exp
!= NULL
)
7139 if (bpt
->exp_string
!= NULL
)
7140 xfree (bpt
->exp_string
);
7141 if (bpt
->val
!= NULL
)
7142 value_free (bpt
->val
);
7143 if (bpt
->source_file
!= NULL
)
7144 xfree (bpt
->source_file
);
7145 if (bpt
->dll_pathname
!= NULL
)
7146 xfree (bpt
->dll_pathname
);
7147 if (bpt
->triggered_dll_pathname
!= NULL
)
7148 xfree (bpt
->triggered_dll_pathname
);
7149 if (bpt
->exec_pathname
!= NULL
)
7150 xfree (bpt
->exec_pathname
);
7152 /* Be sure no bpstat's are pointing at it after it's been freed. */
7153 /* FIXME, how can we find all bpstat's?
7154 We just check stop_bpstat for now. Note that we cannot just
7155 remove bpstats pointing at bpt from the stop_bpstat list
7156 entirely, as breakpoint commands are associated with the bpstat;
7157 if we remove it here, then the later call to
7158 bpstat_do_actions (&stop_bpstat);
7159 in event-top.c won't do anything, and temporary breakpoints
7160 with commands won't work. */
7161 for (bs
= stop_bpstat
; bs
; bs
= bs
->next
)
7162 if (bs
->breakpoint_at
&& bs
->breakpoint_at
->owner
== bpt
)
7164 bs
->breakpoint_at
= NULL
;
7166 /* bs->commands will be freed later. */
7169 /* Now that breakpoint is removed from breakpoint
7170 list, update the global location list. This
7171 will remove locations that used to belong to
7172 this breakpoint. Do this before freeing
7173 the breakpoint itself, since remove_breakpoint
7174 looks at location's owner. It might be better
7175 design to have location completely self-contained,
7176 but it's not the case now. */
7177 update_global_location_list ();
7180 /* On the chance that someone will soon try again to delete this same
7181 bp, we mark it as deleted before freeing its storage. */
7182 bpt
->type
= bp_none
;
7188 do_delete_breakpoint_cleanup (void *b
)
7190 delete_breakpoint (b
);
7194 make_cleanup_delete_breakpoint (struct breakpoint
*b
)
7196 return make_cleanup (do_delete_breakpoint_cleanup
, b
);
7200 delete_command (char *arg
, int from_tty
)
7202 struct breakpoint
*b
, *temp
;
7208 int breaks_to_delete
= 0;
7210 /* Delete all breakpoints if no argument.
7211 Do not delete internal or call-dummy breakpoints, these
7212 have to be deleted with an explicit breakpoint number argument. */
7215 if (b
->type
!= bp_call_dummy
&&
7216 b
->type
!= bp_shlib_event
&&
7217 b
->type
!= bp_thread_event
&&
7218 b
->type
!= bp_overlay_event
&&
7221 breaks_to_delete
= 1;
7226 /* Ask user only if there are some breakpoints to delete. */
7228 || (breaks_to_delete
&& query (_("Delete all breakpoints? "))))
7230 ALL_BREAKPOINTS_SAFE (b
, temp
)
7232 if (b
->type
!= bp_call_dummy
&&
7233 b
->type
!= bp_shlib_event
&&
7234 b
->type
!= bp_thread_event
&&
7235 b
->type
!= bp_overlay_event
&&
7237 delete_breakpoint (b
);
7242 map_breakpoint_numbers (arg
, delete_breakpoint
);
7246 all_locations_are_pending (struct bp_location
*loc
)
7248 for (; loc
; loc
= loc
->next
)
7249 if (!loc
->shlib_disabled
)
7254 /* Subroutine of update_breakpoint_locations to simplify it.
7255 Return non-zero if multiple fns in list LOC have the same name.
7256 Null names are ignored. */
7259 ambiguous_names_p (struct bp_location
*loc
)
7261 struct bp_location
*l
;
7262 htab_t htab
= htab_create_alloc (13, htab_hash_string
,
7263 (int (*) (const void *, const void *)) streq
,
7264 NULL
, xcalloc
, xfree
);
7266 for (l
= loc
; l
!= NULL
; l
= l
->next
)
7269 const char *name
= l
->function_name
;
7271 /* Allow for some names to be NULL, ignore them. */
7275 slot
= (const char **) htab_find_slot (htab
, (const void *) name
,
7277 /* NOTE: We can assume slot != NULL here because xcalloc never returns
7292 update_breakpoint_locations (struct breakpoint
*b
,
7293 struct symtabs_and_lines sals
)
7297 struct bp_location
*existing_locations
= b
->loc
;
7299 /* If there's no new locations, and all existing locations
7300 are pending, don't do anything. This optimizes
7301 the common case where all locations are in the same
7302 shared library, that was unloaded. We'd like to
7303 retain the location, so that when the library
7304 is loaded again, we don't loose the enabled/disabled
7305 status of the individual locations. */
7306 if (all_locations_are_pending (existing_locations
) && sals
.nelts
== 0)
7311 for (i
= 0; i
< sals
.nelts
; ++i
)
7313 struct bp_location
*new_loc
=
7314 add_location_to_breakpoint (b
, b
->type
, &(sals
.sals
[i
]));
7316 /* Reparse conditions, they might contain references to the
7318 if (b
->cond_string
!= NULL
)
7320 struct gdb_exception e
;
7323 TRY_CATCH (e
, RETURN_MASK_ERROR
)
7325 new_loc
->cond
= parse_exp_1 (&s
, block_for_pc (sals
.sals
[i
].pc
),
7330 warning (_("failed to reevaluate condition for breakpoint %d: %s"),
7331 b
->number
, e
.message
);
7332 new_loc
->enabled
= 0;
7336 if (b
->source_file
!= NULL
)
7337 xfree (b
->source_file
);
7338 if (sals
.sals
[i
].symtab
== NULL
)
7339 b
->source_file
= NULL
;
7342 savestring (sals
.sals
[i
].symtab
->filename
,
7343 strlen (sals
.sals
[i
].symtab
->filename
));
7345 if (b
->line_number
== 0)
7346 b
->line_number
= sals
.sals
[i
].line
;
7349 /* If possible, carry over 'disable' status from existing breakpoints. */
7351 struct bp_location
*e
= existing_locations
;
7352 /* If there are multiple breakpoints with the same function name,
7353 e.g. for inline functions, comparing function names won't work.
7354 Instead compare pc addresses; this is just a heuristic as things
7355 may have moved, but in practice it gives the correct answer
7356 often enough until a better solution is found. */
7357 int have_ambiguous_names
= ambiguous_names_p (b
->loc
);
7359 for (; e
; e
= e
->next
)
7361 if (!e
->enabled
&& e
->function_name
)
7363 struct bp_location
*l
= b
->loc
;
7364 if (have_ambiguous_names
)
7366 for (; l
; l
= l
->next
)
7367 if (e
->address
== l
->address
)
7375 for (; l
; l
= l
->next
)
7376 if (l
->function_name
7377 && strcmp (e
->function_name
, l
->function_name
) == 0)
7387 update_global_location_list ();
7391 /* Reset a breakpoint given it's struct breakpoint * BINT.
7392 The value we return ends up being the return value from catch_errors.
7393 Unused in this case. */
7396 breakpoint_re_set_one (void *bint
)
7398 /* get past catch_errs */
7399 struct breakpoint
*b
= (struct breakpoint
*) bint
;
7403 int *not_found_ptr
= ¬_found
;
7404 struct symtabs_and_lines sals
= {};
7405 struct symtabs_and_lines expanded
;
7407 enum enable_state save_enable
;
7408 struct gdb_exception e
;
7414 warning (_("attempted to reset apparently deleted breakpoint #%d?"),
7418 case bp_hardware_breakpoint
:
7420 case bp_catch_unload
:
7421 if (b
->addr_string
== NULL
)
7423 /* Anything without a string can't be re-set. */
7424 delete_breakpoint (b
);
7428 set_language (b
->language
);
7429 input_radix
= b
->input_radix
;
7431 TRY_CATCH (e
, RETURN_MASK_ERROR
)
7433 sals
= decode_line_1 (&s
, 1, (struct symtab
*) NULL
, 0, (char ***) NULL
,
7438 int not_found_and_ok
= 0;
7439 /* For pending breakpoints, it's expected that parsing
7440 will fail until the right shared library is loaded.
7441 User has already told to create pending breakpoints and
7442 don't need extra messages. If breakpoint is in bp_shlib_disabled
7443 state, then user already saw the message about that breakpoint
7444 being disabled, and don't want to see more errors. */
7446 && (b
->condition_not_parsed
7447 || (b
->loc
&& b
->loc
->shlib_disabled
)
7448 || b
->enable_state
== bp_disabled
))
7449 not_found_and_ok
= 1;
7451 if (!not_found_and_ok
)
7453 /* We surely don't want to warn about the same breakpoint
7454 10 times. One solution, implemented here, is disable
7455 the breakpoint on error. Another solution would be to
7456 have separate 'warning emitted' flag. Since this
7457 happens only when a binary has changed, I don't know
7458 which approach is better. */
7459 b
->enable_state
= bp_disabled
;
7460 throw_exception (e
);
7467 gdb_assert (sals
.nelts
== 1);
7468 resolve_sal_pc (&sals
.sals
[0]);
7469 if (b
->condition_not_parsed
&& s
&& s
[0])
7471 char *cond_string
= 0;
7473 find_condition_and_thread (s
, sals
.sals
[0].pc
,
7474 &cond_string
, &thread
);
7476 b
->cond_string
= cond_string
;
7478 b
->condition_not_parsed
= 0;
7480 expanded
= expand_line_sal_maybe (sals
.sals
[0]);
7481 update_breakpoint_locations (b
, expanded
);
7487 case bp_hardware_watchpoint
:
7488 case bp_read_watchpoint
:
7489 case bp_access_watchpoint
:
7490 /* Watchpoint can be either on expression using entirely global variables,
7491 or it can be on local variables.
7493 Watchpoints of the first kind are never auto-deleted, and even persist
7494 across program restarts. Since they can use variables from shared
7495 libraries, we need to reparse expression as libraries are loaded
7498 Watchpoints on local variables can also change meaning as result
7499 of solib event. For example, if a watchpoint uses both a local and
7500 a global variables in expression, it's a local watchpoint, but
7501 unloading of a shared library will make the expression invalid.
7502 This is not a very common use case, but we still re-evaluate
7503 expression, to avoid surprises to the user.
7505 Note that for local watchpoints, we re-evaluate it only if
7506 watchpoints frame id is still valid. If it's not, it means
7507 the watchpoint is out of scope and will be deleted soon. In fact,
7508 I'm not sure we'll ever be called in this case.
7510 If a local watchpoint's frame id is still valid, then
7511 b->exp_valid_block is likewise valid, and we can safely use it.
7513 Don't do anything about disabled watchpoints, since they will
7514 be reevaluated again when enabled. */
7515 update_watchpoint (b
, 1 /* reparse */);
7517 /* We needn't really do anything to reset these, since the mask
7518 that requests them is unaffected by e.g., new libraries being
7521 case bp_catch_vfork
:
7526 printf_filtered (_("Deleting unknown breakpoint type %d\n"), b
->type
);
7528 /* Delete overlay event breakpoints; they will be reset later by
7529 breakpoint_re_set. */
7530 case bp_overlay_event
:
7531 delete_breakpoint (b
);
7534 /* This breakpoint is special, it's set up when the inferior
7535 starts and we really don't want to touch it. */
7536 case bp_shlib_event
:
7538 /* Like bp_shlib_event, this breakpoint type is special.
7539 Once it is set up, we do not want to touch it. */
7540 case bp_thread_event
:
7542 /* Keep temporary breakpoints, which can be encountered when we step
7543 over a dlopen call and SOLIB_ADD is resetting the breakpoints.
7544 Otherwise these should have been blown away via the cleanup chain
7545 or by breakpoint_init_inferior when we rerun the executable. */
7548 case bp_watchpoint_scope
:
7550 case bp_step_resume
:
7552 case bp_longjmp_resume
:
7559 /* Re-set all breakpoints after symbols have been re-loaded. */
7561 breakpoint_re_set (void)
7563 struct breakpoint
*b
, *temp
;
7564 enum language save_language
;
7565 int save_input_radix
;
7567 save_language
= current_language
->la_language
;
7568 save_input_radix
= input_radix
;
7569 ALL_BREAKPOINTS_SAFE (b
, temp
)
7571 /* Format possible error msg */
7572 char *message
= xstrprintf ("Error in re-setting breakpoint %d: ",
7574 struct cleanup
*cleanups
= make_cleanup (xfree
, message
);
7575 catch_errors (breakpoint_re_set_one
, b
, message
, RETURN_MASK_ALL
);
7576 do_cleanups (cleanups
);
7578 set_language (save_language
);
7579 input_radix
= save_input_radix
;
7581 create_overlay_event_breakpoint ("_ovly_debug_event");
7584 /* Reset the thread number of this breakpoint:
7586 - If the breakpoint is for all threads, leave it as-is.
7587 - Else, reset it to the current thread for inferior_ptid. */
7589 breakpoint_re_set_thread (struct breakpoint
*b
)
7591 if (b
->thread
!= -1)
7593 if (in_thread_list (inferior_ptid
))
7594 b
->thread
= pid_to_thread_id (inferior_ptid
);
7598 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
7599 If from_tty is nonzero, it prints a message to that effect,
7600 which ends with a period (no newline). */
7603 set_ignore_count (int bptnum
, int count
, int from_tty
)
7605 struct breakpoint
*b
;
7611 if (b
->number
== bptnum
)
7613 b
->ignore_count
= count
;
7617 printf_filtered (_("Will stop next time breakpoint %d is reached."),
7619 else if (count
== 1)
7620 printf_filtered (_("Will ignore next crossing of breakpoint %d."),
7623 printf_filtered (_("Will ignore next %d crossings of breakpoint %d."),
7626 breakpoints_changed ();
7627 breakpoint_modify_event (b
->number
);
7631 error (_("No breakpoint number %d."), bptnum
);
7634 /* Clear the ignore counts of all breakpoints. */
7636 breakpoint_clear_ignore_counts (void)
7638 struct breakpoint
*b
;
7641 b
->ignore_count
= 0;
7644 /* Command to set ignore-count of breakpoint N to COUNT. */
7647 ignore_command (char *args
, int from_tty
)
7653 error_no_arg (_("a breakpoint number"));
7655 num
= get_number (&p
);
7657 error (_("bad breakpoint number: '%s'"), args
);
7659 error (_("Second argument (specified ignore-count) is missing."));
7661 set_ignore_count (num
,
7662 longest_to_int (value_as_long (parse_and_eval (p
))),
7665 printf_filtered ("\n");
7668 /* Call FUNCTION on each of the breakpoints
7669 whose numbers are given in ARGS. */
7672 map_breakpoint_numbers (char *args
, void (*function
) (struct breakpoint
*))
7677 struct breakpoint
*b
, *tmp
;
7681 error_no_arg (_("one or more breakpoint numbers"));
7688 num
= get_number_or_range (&p1
);
7691 warning (_("bad breakpoint number at or near '%s'"), p
);
7695 ALL_BREAKPOINTS_SAFE (b
, tmp
)
7696 if (b
->number
== num
)
7698 struct breakpoint
*related_breakpoint
= b
->related_breakpoint
;
7701 if (related_breakpoint
)
7702 function (related_breakpoint
);
7706 printf_unfiltered (_("No breakpoint number %d.\n"), num
);
7712 static struct bp_location
*
7713 find_location_by_number (char *number
)
7715 char *dot
= strchr (number
, '.');
7719 struct breakpoint
*b
;
7720 struct bp_location
*loc
;
7725 bp_num
= get_number_or_range (&p1
);
7727 error (_("Bad breakpoint number '%s'"), number
);
7730 if (b
->number
== bp_num
)
7735 if (!b
|| b
->number
!= bp_num
)
7736 error (_("Bad breakpoint number '%s'"), number
);
7739 loc_num
= get_number_or_range (&p1
);
7741 error (_("Bad breakpoint location number '%s'"), number
);
7745 for (;loc_num
&& loc
; --loc_num
, loc
= loc
->next
)
7748 error (_("Bad breakpoint location number '%s'"), dot
+1);
7754 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
7755 If from_tty is nonzero, it prints a message to that effect,
7756 which ends with a period (no newline). */
7759 disable_breakpoint (struct breakpoint
*bpt
)
7761 /* Never disable a watchpoint scope breakpoint; we want to
7762 hit them when we leave scope so we can delete both the
7763 watchpoint and its scope breakpoint at that time. */
7764 if (bpt
->type
== bp_watchpoint_scope
)
7767 /* You can't disable permanent breakpoints. */
7768 if (bpt
->enable_state
== bp_permanent
)
7771 bpt
->enable_state
= bp_disabled
;
7773 update_global_location_list ();
7775 if (deprecated_modify_breakpoint_hook
)
7776 deprecated_modify_breakpoint_hook (bpt
);
7777 breakpoint_modify_event (bpt
->number
);
7781 disable_command (char *args
, int from_tty
)
7783 struct breakpoint
*bpt
;
7785 ALL_BREAKPOINTS (bpt
)
7789 warning (_("attempted to disable apparently deleted breakpoint #%d?"),
7794 case bp_catch_unload
:
7796 case bp_catch_vfork
:
7798 case bp_hardware_breakpoint
:
7800 case bp_hardware_watchpoint
:
7801 case bp_read_watchpoint
:
7802 case bp_access_watchpoint
:
7803 disable_breakpoint (bpt
);
7807 else if (strchr (args
, '.'))
7809 struct bp_location
*loc
= find_location_by_number (args
);
7812 update_global_location_list ();
7815 map_breakpoint_numbers (args
, disable_breakpoint
);
7819 do_enable_breakpoint (struct breakpoint
*bpt
, enum bpdisp disposition
)
7821 int target_resources_ok
, other_type_used
;
7824 if (bpt
->type
== bp_hardware_breakpoint
)
7827 i
= hw_breakpoint_used_count ();
7828 target_resources_ok
=
7829 TARGET_CAN_USE_HARDWARE_WATCHPOINT (bp_hardware_breakpoint
,
7831 if (target_resources_ok
== 0)
7832 error (_("No hardware breakpoint support in the target."));
7833 else if (target_resources_ok
< 0)
7834 error (_("Hardware breakpoints used exceeds limit."));
7837 if (bpt
->type
== bp_watchpoint
||
7838 bpt
->type
== bp_hardware_watchpoint
||
7839 bpt
->type
== bp_read_watchpoint
||
7840 bpt
->type
== bp_access_watchpoint
)
7842 struct frame_id saved_frame_id
;
7844 saved_frame_id
= get_frame_id (get_selected_frame (NULL
));
7845 if (bpt
->exp_valid_block
!= NULL
)
7847 struct frame_info
*fr
=
7848 fr
= frame_find_by_id (bpt
->watchpoint_frame
);
7851 printf_filtered (_("\
7852 Cannot enable watchpoint %d because the block in which its expression\n\
7853 is valid is not currently in scope.\n"), bpt
->number
);
7860 value_free (bpt
->val
);
7861 mark
= value_mark ();
7862 fetch_watchpoint_value (bpt
->exp
, &bpt
->val
, NULL
, NULL
);
7864 release_value (bpt
->val
);
7867 if (bpt
->type
== bp_hardware_watchpoint
||
7868 bpt
->type
== bp_read_watchpoint
||
7869 bpt
->type
== bp_access_watchpoint
)
7871 int i
= hw_watchpoint_used_count (bpt
->type
, &other_type_used
);
7872 int mem_cnt
= can_use_hardware_watchpoint (bpt
->val
);
7874 /* Hack around 'unused var' error for some targets here */
7875 (void) mem_cnt
, (void) i
;
7876 target_resources_ok
= TARGET_CAN_USE_HARDWARE_WATCHPOINT (
7877 bpt
->type
, i
+ mem_cnt
, other_type_used
);
7878 /* we can consider of type is bp_hardware_watchpoint, convert to
7879 bp_watchpoint in the following condition */
7880 if (target_resources_ok
< 0)
7882 printf_filtered (_("\
7883 Cannot enable watchpoint %d because target watch resources\n\
7884 have been allocated for other watchpoints.\n"), bpt
->number
);
7885 value_free_to_mark (mark
);
7890 select_frame (frame_find_by_id (saved_frame_id
));
7891 value_free_to_mark (mark
);
7894 if (bpt
->enable_state
!= bp_permanent
)
7895 bpt
->enable_state
= bp_enabled
;
7896 bpt
->disposition
= disposition
;
7897 update_global_location_list ();
7898 breakpoints_changed ();
7900 if (deprecated_modify_breakpoint_hook
)
7901 deprecated_modify_breakpoint_hook (bpt
);
7902 breakpoint_modify_event (bpt
->number
);
7907 enable_breakpoint (struct breakpoint
*bpt
)
7909 do_enable_breakpoint (bpt
, bpt
->disposition
);
7912 /* The enable command enables the specified breakpoints (or all defined
7913 breakpoints) so they once again become (or continue to be) effective
7914 in stopping the inferior. */
7917 enable_command (char *args
, int from_tty
)
7919 struct breakpoint
*bpt
;
7921 ALL_BREAKPOINTS (bpt
)
7925 warning (_("attempted to enable apparently deleted breakpoint #%d?"),
7930 case bp_catch_unload
:
7932 case bp_catch_vfork
:
7934 case bp_hardware_breakpoint
:
7936 case bp_hardware_watchpoint
:
7937 case bp_read_watchpoint
:
7938 case bp_access_watchpoint
:
7939 enable_breakpoint (bpt
);
7943 else if (strchr (args
, '.'))
7945 struct bp_location
*loc
= find_location_by_number (args
);
7948 update_global_location_list ();
7951 map_breakpoint_numbers (args
, enable_breakpoint
);
7955 enable_once_breakpoint (struct breakpoint
*bpt
)
7957 do_enable_breakpoint (bpt
, disp_disable
);
7961 enable_once_command (char *args
, int from_tty
)
7963 map_breakpoint_numbers (args
, enable_once_breakpoint
);
7967 enable_delete_breakpoint (struct breakpoint
*bpt
)
7969 do_enable_breakpoint (bpt
, disp_del
);
7973 enable_delete_command (char *args
, int from_tty
)
7975 map_breakpoint_numbers (args
, enable_delete_breakpoint
);
7979 set_breakpoint_cmd (char *args
, int from_tty
)
7984 show_breakpoint_cmd (char *args
, int from_tty
)
7988 /* Use default_breakpoint_'s, or nothing if they aren't valid. */
7990 struct symtabs_and_lines
7991 decode_line_spec_1 (char *string
, int funfirstline
)
7993 struct symtabs_and_lines sals
;
7995 error (_("Empty line specification."));
7996 if (default_breakpoint_valid
)
7997 sals
= decode_line_1 (&string
, funfirstline
,
7998 default_breakpoint_symtab
,
7999 default_breakpoint_line
,
8000 (char ***) NULL
, NULL
);
8002 sals
= decode_line_1 (&string
, funfirstline
,
8003 (struct symtab
*) NULL
, 0, (char ***) NULL
, NULL
);
8005 error (_("Junk at end of line specification: %s"), string
);
8009 /* Create and insert a raw software breakpoint at PC. Return an
8010 identifier, which should be used to remove the breakpoint later.
8011 In general, places which call this should be using something on the
8012 breakpoint chain instead; this function should be eliminated
8016 deprecated_insert_raw_breakpoint (CORE_ADDR pc
)
8018 struct bp_target_info
*bp_tgt
;
8020 bp_tgt
= xmalloc (sizeof (struct bp_target_info
));
8021 memset (bp_tgt
, 0, sizeof (struct bp_target_info
));
8023 bp_tgt
->placed_address
= pc
;
8024 if (target_insert_breakpoint (bp_tgt
) != 0)
8026 /* Could not insert the breakpoint. */
8034 /* Remove a breakpoint BP inserted by deprecated_insert_raw_breakpoint. */
8037 deprecated_remove_raw_breakpoint (void *bp
)
8039 struct bp_target_info
*bp_tgt
= bp
;
8042 ret
= target_remove_breakpoint (bp_tgt
);
8048 /* One (or perhaps two) breakpoints used for software single stepping. */
8050 static void *single_step_breakpoints
[2];
8052 /* Create and insert a breakpoint for software single step. */
8055 insert_single_step_breakpoint (CORE_ADDR next_pc
)
8059 if (single_step_breakpoints
[0] == NULL
)
8060 bpt_p
= &single_step_breakpoints
[0];
8063 gdb_assert (single_step_breakpoints
[1] == NULL
);
8064 bpt_p
= &single_step_breakpoints
[1];
8067 /* NOTE drow/2006-04-11: A future improvement to this function would be
8068 to only create the breakpoints once, and actually put them on the
8069 breakpoint chain. That would let us use set_raw_breakpoint. We could
8070 adjust the addresses each time they were needed. Doing this requires
8071 corresponding changes elsewhere where single step breakpoints are
8072 handled, however. So, for now, we use this. */
8074 *bpt_p
= deprecated_insert_raw_breakpoint (next_pc
);
8076 error (_("Could not insert single-step breakpoint at 0x%s"),
8077 paddr_nz (next_pc
));
8080 /* Remove and delete any breakpoints used for software single step. */
8083 remove_single_step_breakpoints (void)
8085 gdb_assert (single_step_breakpoints
[0] != NULL
);
8087 /* See insert_single_step_breakpoint for more about this deprecated
8089 deprecated_remove_raw_breakpoint (single_step_breakpoints
[0]);
8090 single_step_breakpoints
[0] = NULL
;
8092 if (single_step_breakpoints
[1] != NULL
)
8094 deprecated_remove_raw_breakpoint (single_step_breakpoints
[1]);
8095 single_step_breakpoints
[1] = NULL
;
8099 /* Check whether a software single-step breakpoint is inserted at PC. */
8102 single_step_breakpoint_inserted_here_p (CORE_ADDR pc
)
8106 for (i
= 0; i
< 2; i
++)
8108 struct bp_target_info
*bp_tgt
= single_step_breakpoints
[i
];
8109 if (bp_tgt
&& bp_tgt
->placed_address
== pc
)
8116 int breakpoints_always_inserted_mode (void)
8118 return always_inserted_mode
;
8122 /* This help string is used for the break, hbreak, tbreak and thbreak commands.
8123 It is defined as a macro to prevent duplication.
8124 COMMAND should be a string constant containing the name of the command. */
8125 #define BREAK_ARGS_HELP(command) \
8126 command" [LOCATION] [thread THREADNUM] [if CONDITION]\n\
8127 LOCATION may be a line number, function name, or \"*\" and an address.\n\
8128 If a line number is specified, break at start of code for that line.\n\
8129 If a function is specified, break at start of code for that function.\n\
8130 If an address is specified, break at that exact address.\n\
8131 With no LOCATION, uses current execution address of selected stack frame.\n\
8132 This is useful for breaking on return to a stack frame.\n\
8134 THREADNUM is the number from \"info threads\".\n\
8135 CONDITION is a boolean expression.\n\
8137 Multiple breakpoints at one place are permitted, and useful if conditional.\n\
8139 Do \"help breakpoints\" for info on other commands dealing with breakpoints."
8142 _initialize_breakpoint (void)
8144 static struct cmd_list_element
*breakpoint_set_cmdlist
;
8145 static struct cmd_list_element
*breakpoint_show_cmdlist
;
8146 struct cmd_list_element
*c
;
8148 observer_attach_solib_unloaded (disable_breakpoints_in_unloaded_shlib
);
8150 breakpoint_chain
= 0;
8151 /* Don't bother to call set_breakpoint_count. $bpnum isn't useful
8152 before a breakpoint is set. */
8153 breakpoint_count
= 0;
8155 add_com ("ignore", class_breakpoint
, ignore_command
, _("\
8156 Set ignore-count of breakpoint number N to COUNT.\n\
8157 Usage is `ignore N COUNT'."));
8159 add_com_alias ("bc", "ignore", class_breakpoint
, 1);
8161 add_com ("commands", class_breakpoint
, commands_command
, _("\
8162 Set commands to be executed when a breakpoint is hit.\n\
8163 Give breakpoint number as argument after \"commands\".\n\
8164 With no argument, the targeted breakpoint is the last one set.\n\
8165 The commands themselves follow starting on the next line.\n\
8166 Type a line containing \"end\" to indicate the end of them.\n\
8167 Give \"silent\" as the first line to make the breakpoint silent;\n\
8168 then no output is printed when it is hit, except what the commands print."));
8170 add_com ("condition", class_breakpoint
, condition_command
, _("\
8171 Specify breakpoint number N to break only if COND is true.\n\
8172 Usage is `condition N COND', where N is an integer and COND is an\n\
8173 expression to be evaluated whenever breakpoint N is reached."));
8175 c
= add_com ("tbreak", class_breakpoint
, tbreak_command
, _("\
8176 Set a temporary breakpoint.\n\
8177 Like \"break\" except the breakpoint is only temporary,\n\
8178 so it will be deleted when hit. Equivalent to \"break\" followed\n\
8179 by using \"enable delete\" on the breakpoint number.\n\
8181 BREAK_ARGS_HELP ("tbreak")));
8182 set_cmd_completer (c
, location_completer
);
8184 c
= add_com ("hbreak", class_breakpoint
, hbreak_command
, _("\
8185 Set a hardware assisted breakpoint.\n\
8186 Like \"break\" except the breakpoint requires hardware support,\n\
8187 some target hardware may not have this support.\n\
8189 BREAK_ARGS_HELP ("hbreak")));
8190 set_cmd_completer (c
, location_completer
);
8192 c
= add_com ("thbreak", class_breakpoint
, thbreak_command
, _("\
8193 Set a temporary hardware assisted breakpoint.\n\
8194 Like \"hbreak\" except the breakpoint is only temporary,\n\
8195 so it will be deleted when hit.\n\
8197 BREAK_ARGS_HELP ("thbreak")));
8198 set_cmd_completer (c
, location_completer
);
8200 add_prefix_cmd ("enable", class_breakpoint
, enable_command
, _("\
8201 Enable some breakpoints.\n\
8202 Give breakpoint numbers (separated by spaces) as arguments.\n\
8203 With no subcommand, breakpoints are enabled until you command otherwise.\n\
8204 This is used to cancel the effect of the \"disable\" command.\n\
8205 With a subcommand you can enable temporarily."),
8206 &enablelist
, "enable ", 1, &cmdlist
);
8208 add_com ("ab", class_breakpoint
, enable_command
, _("\
8209 Enable some breakpoints.\n\
8210 Give breakpoint numbers (separated by spaces) as arguments.\n\
8211 With no subcommand, breakpoints are enabled until you command otherwise.\n\
8212 This is used to cancel the effect of the \"disable\" command.\n\
8213 With a subcommand you can enable temporarily."));
8215 add_com_alias ("en", "enable", class_breakpoint
, 1);
8217 add_abbrev_prefix_cmd ("breakpoints", class_breakpoint
, enable_command
, _("\
8218 Enable some breakpoints.\n\
8219 Give breakpoint numbers (separated by spaces) as arguments.\n\
8220 This is used to cancel the effect of the \"disable\" command.\n\
8221 May be abbreviated to simply \"enable\".\n"),
8222 &enablebreaklist
, "enable breakpoints ", 1, &enablelist
);
8224 add_cmd ("once", no_class
, enable_once_command
, _("\
8225 Enable breakpoints for one hit. Give breakpoint numbers.\n\
8226 If a breakpoint is hit while enabled in this fashion, it becomes disabled."),
8229 add_cmd ("delete", no_class
, enable_delete_command
, _("\
8230 Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
8231 If a breakpoint is hit while enabled in this fashion, it is deleted."),
8234 add_cmd ("delete", no_class
, enable_delete_command
, _("\
8235 Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
8236 If a breakpoint is hit while enabled in this fashion, it is deleted."),
8239 add_cmd ("once", no_class
, enable_once_command
, _("\
8240 Enable breakpoints for one hit. Give breakpoint numbers.\n\
8241 If a breakpoint is hit while enabled in this fashion, it becomes disabled."),
8244 add_prefix_cmd ("disable", class_breakpoint
, disable_command
, _("\
8245 Disable some breakpoints.\n\
8246 Arguments are breakpoint numbers with spaces in between.\n\
8247 To disable all breakpoints, give no argument.\n\
8248 A disabled breakpoint is not forgotten, but has no effect until reenabled."),
8249 &disablelist
, "disable ", 1, &cmdlist
);
8250 add_com_alias ("dis", "disable", class_breakpoint
, 1);
8251 add_com_alias ("disa", "disable", class_breakpoint
, 1);
8253 add_com ("sb", class_breakpoint
, disable_command
, _("\
8254 Disable some breakpoints.\n\
8255 Arguments are breakpoint numbers with spaces in between.\n\
8256 To disable all breakpoints, give no argument.\n\
8257 A disabled breakpoint is not forgotten, but has no effect until reenabled."));
8259 add_cmd ("breakpoints", class_alias
, disable_command
, _("\
8260 Disable some breakpoints.\n\
8261 Arguments are breakpoint numbers with spaces in between.\n\
8262 To disable all breakpoints, give no argument.\n\
8263 A disabled breakpoint is not forgotten, but has no effect until reenabled.\n\
8264 This command may be abbreviated \"disable\"."),
8267 add_prefix_cmd ("delete", class_breakpoint
, delete_command
, _("\
8268 Delete some breakpoints or auto-display expressions.\n\
8269 Arguments are breakpoint numbers with spaces in between.\n\
8270 To delete all breakpoints, give no argument.\n\
8272 Also a prefix command for deletion of other GDB objects.\n\
8273 The \"unset\" command is also an alias for \"delete\"."),
8274 &deletelist
, "delete ", 1, &cmdlist
);
8275 add_com_alias ("d", "delete", class_breakpoint
, 1);
8276 add_com_alias ("del", "delete", class_breakpoint
, 1);
8278 add_com ("db", class_breakpoint
, delete_command
, _("\
8279 Delete some breakpoints.\n\
8280 Arguments are breakpoint numbers with spaces in between.\n\
8281 To delete all breakpoints, give no argument.\n"));
8283 add_cmd ("breakpoints", class_alias
, delete_command
, _("\
8284 Delete some breakpoints or auto-display expressions.\n\
8285 Arguments are breakpoint numbers with spaces in between.\n\
8286 To delete all breakpoints, give no argument.\n\
8287 This command may be abbreviated \"delete\"."),
8290 add_com ("clear", class_breakpoint
, clear_command
, _("\
8291 Clear breakpoint at specified line or function.\n\
8292 Argument may be line number, function name, or \"*\" and an address.\n\
8293 If line number is specified, all breakpoints in that line are cleared.\n\
8294 If function is specified, breakpoints at beginning of function are cleared.\n\
8295 If an address is specified, breakpoints at that address are cleared.\n\
8297 With no argument, clears all breakpoints in the line that the selected frame\n\
8300 See also the \"delete\" command which clears breakpoints by number."));
8302 c
= add_com ("break", class_breakpoint
, break_command
, _("\
8303 Set breakpoint at specified line or function.\n"
8304 BREAK_ARGS_HELP ("break")));
8305 set_cmd_completer (c
, location_completer
);
8307 add_com_alias ("b", "break", class_run
, 1);
8308 add_com_alias ("br", "break", class_run
, 1);
8309 add_com_alias ("bre", "break", class_run
, 1);
8310 add_com_alias ("brea", "break", class_run
, 1);
8314 add_com_alias ("ba", "break", class_breakpoint
, 1);
8315 add_com_alias ("bu", "ubreak", class_breakpoint
, 1);
8320 add_abbrev_prefix_cmd ("stop", class_breakpoint
, stop_command
, _("\
8321 Break in function/address or break at a line in the current file."),
8322 &stoplist
, "stop ", 1, &cmdlist
);
8323 add_cmd ("in", class_breakpoint
, stopin_command
,
8324 _("Break in function or address."), &stoplist
);
8325 add_cmd ("at", class_breakpoint
, stopat_command
,
8326 _("Break at a line in the current file."), &stoplist
);
8327 add_com ("status", class_info
, breakpoints_info
, _("\
8328 Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
8329 The \"Type\" column indicates one of:\n\
8330 \tbreakpoint - normal breakpoint\n\
8331 \twatchpoint - watchpoint\n\
8332 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
8333 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
8334 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
8335 address and file/line number respectively.\n\
8337 Convenience variable \"$_\" and default examine address for \"x\"\n\
8338 are set to the address of the last breakpoint listed unless the command\n\
8339 is prefixed with \"server \".\n\n\
8340 Convenience variable \"$bpnum\" contains the number of the last\n\
8344 add_info ("breakpoints", breakpoints_info
, _("\
8345 Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
8346 The \"Type\" column indicates one of:\n\
8347 \tbreakpoint - normal breakpoint\n\
8348 \twatchpoint - watchpoint\n\
8349 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
8350 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
8351 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
8352 address and file/line number respectively.\n\
8354 Convenience variable \"$_\" and default examine address for \"x\"\n\
8355 are set to the address of the last breakpoint listed unless the command\n\
8356 is prefixed with \"server \".\n\n\
8357 Convenience variable \"$bpnum\" contains the number of the last\n\
8361 add_com ("lb", class_breakpoint
, breakpoints_info
, _("\
8362 Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
8363 The \"Type\" column indicates one of:\n\
8364 \tbreakpoint - normal breakpoint\n\
8365 \twatchpoint - watchpoint\n\
8366 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
8367 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
8368 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
8369 address and file/line number respectively.\n\
8371 Convenience variable \"$_\" and default examine address for \"x\"\n\
8372 are set to the address of the last breakpoint listed unless the command\n\
8373 is prefixed with \"server \".\n\n\
8374 Convenience variable \"$bpnum\" contains the number of the last\n\
8377 add_cmd ("breakpoints", class_maintenance
, maintenance_info_breakpoints
, _("\
8378 Status of all breakpoints, or breakpoint number NUMBER.\n\
8379 The \"Type\" column indicates one of:\n\
8380 \tbreakpoint - normal breakpoint\n\
8381 \twatchpoint - watchpoint\n\
8382 \tlongjmp - internal breakpoint used to step through longjmp()\n\
8383 \tlongjmp resume - internal breakpoint at the target of longjmp()\n\
8384 \tuntil - internal breakpoint used by the \"until\" command\n\
8385 \tfinish - internal breakpoint used by the \"finish\" command\n\
8386 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
8387 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
8388 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
8389 address and file/line number respectively.\n\
8391 Convenience variable \"$_\" and default examine address for \"x\"\n\
8392 are set to the address of the last breakpoint listed unless the command\n\
8393 is prefixed with \"server \".\n\n\
8394 Convenience variable \"$bpnum\" contains the number of the last\n\
8396 &maintenanceinfolist
);
8398 add_com ("catch", class_breakpoint
, catch_command
, _("\
8399 Set catchpoints to catch events.\n\
8400 Raised signals may be caught:\n\
8401 \tcatch signal - all signals\n\
8402 \tcatch signal <signame> - a particular signal\n\
8403 Raised exceptions may be caught:\n\
8404 \tcatch throw - all exceptions, when thrown\n\
8405 \tcatch throw <exceptname> - a particular exception, when thrown\n\
8406 \tcatch catch - all exceptions, when caught\n\
8407 \tcatch catch <exceptname> - a particular exception, when caught\n\
8408 Thread or process events may be caught:\n\
8409 \tcatch thread_start - any threads, just after creation\n\
8410 \tcatch thread_exit - any threads, just before expiration\n\
8411 \tcatch thread_join - any threads, just after joins\n\
8412 Process events may be caught:\n\
8413 \tcatch start - any processes, just after creation\n\
8414 \tcatch exit - any processes, just before expiration\n\
8415 \tcatch fork - calls to fork()\n\
8416 \tcatch vfork - calls to vfork()\n\
8417 \tcatch exec - calls to exec()\n\
8418 Dynamically-linked library events may be caught:\n\
8419 \tcatch load - loads of any library\n\
8420 \tcatch load <libname> - loads of a particular library\n\
8421 \tcatch unload - unloads of any library\n\
8422 \tcatch unload <libname> - unloads of a particular library\n\
8423 The act of your program's execution stopping may also be caught:\n\
8425 C++ exceptions may be caught:\n\
8426 \tcatch throw - all exceptions, when thrown\n\
8427 \tcatch catch - all exceptions, when caught\n\
8428 Ada exceptions may be caught:\n\
8429 \tcatch exception - all exceptions, when raised\n\
8430 \tcatch exception <name> - a particular exception, when raised\n\
8431 \tcatch exception unhandled - all unhandled exceptions, when raised\n\
8432 \tcatch assert - all failed assertions, when raised\n\
8434 Do \"help set follow-fork-mode\" for info on debugging your program\n\
8435 after a fork or vfork is caught.\n\n\
8436 Do \"help breakpoints\" for info on other commands dealing with breakpoints."));
8438 add_com ("tcatch", class_breakpoint
, tcatch_command
, _("\
8439 Set temporary catchpoints to catch events.\n\
8440 Args like \"catch\" command.\n\
8441 Like \"catch\" except the catchpoint is only temporary,\n\
8442 so it will be deleted when hit. Equivalent to \"catch\" followed\n\
8443 by using \"enable delete\" on the catchpoint number."));
8445 c
= add_com ("watch", class_breakpoint
, watch_command
, _("\
8446 Set a watchpoint for an expression.\n\
8447 A watchpoint stops execution of your program whenever the value of\n\
8448 an expression changes."));
8449 set_cmd_completer (c
, expression_completer
);
8451 c
= add_com ("rwatch", class_breakpoint
, rwatch_command
, _("\
8452 Set a read watchpoint for an expression.\n\
8453 A watchpoint stops execution of your program whenever the value of\n\
8454 an expression is read."));
8455 set_cmd_completer (c
, expression_completer
);
8457 c
= add_com ("awatch", class_breakpoint
, awatch_command
, _("\
8458 Set a watchpoint for an expression.\n\
8459 A watchpoint stops execution of your program whenever the value of\n\
8460 an expression is either read or written."));
8461 set_cmd_completer (c
, expression_completer
);
8463 add_info ("watchpoints", breakpoints_info
,
8464 _("Synonym for ``info breakpoints''."));
8467 /* XXX: cagney/2005-02-23: This should be a boolean, and should
8468 respond to changes - contrary to the description. */
8469 add_setshow_zinteger_cmd ("can-use-hw-watchpoints", class_support
,
8470 &can_use_hw_watchpoints
, _("\
8471 Set debugger's willingness to use watchpoint hardware."), _("\
8472 Show debugger's willingness to use watchpoint hardware."), _("\
8473 If zero, gdb will not use hardware for new watchpoints, even if\n\
8474 such is available. (However, any hardware watchpoints that were\n\
8475 created before setting this to nonzero, will continue to use watchpoint\n\
8478 show_can_use_hw_watchpoints
,
8479 &setlist
, &showlist
);
8481 can_use_hw_watchpoints
= 1;
8483 add_prefix_cmd ("breakpoint", class_maintenance
, set_breakpoint_cmd
, _("\
8484 Breakpoint specific settings\n\
8485 Configure various breakpoint-specific variables such as\n\
8486 pending breakpoint behavior"),
8487 &breakpoint_set_cmdlist
, "set breakpoint ",
8488 0/*allow-unknown*/, &setlist
);
8489 add_prefix_cmd ("breakpoint", class_maintenance
, show_breakpoint_cmd
, _("\
8490 Breakpoint specific settings\n\
8491 Configure various breakpoint-specific variables such as\n\
8492 pending breakpoint behavior"),
8493 &breakpoint_show_cmdlist
, "show breakpoint ",
8494 0/*allow-unknown*/, &showlist
);
8496 add_setshow_auto_boolean_cmd ("pending", no_class
,
8497 &pending_break_support
, _("\
8498 Set debugger's behavior regarding pending breakpoints."), _("\
8499 Show debugger's behavior regarding pending breakpoints."), _("\
8500 If on, an unrecognized breakpoint location will cause gdb to create a\n\
8501 pending breakpoint. If off, an unrecognized breakpoint location results in\n\
8502 an error. If auto, an unrecognized breakpoint location results in a\n\
8503 user-query to see if a pending breakpoint should be created."),
8505 show_pending_break_support
,
8506 &breakpoint_set_cmdlist
,
8507 &breakpoint_show_cmdlist
);
8509 pending_break_support
= AUTO_BOOLEAN_AUTO
;
8511 add_setshow_boolean_cmd ("auto-hw", no_class
,
8512 &automatic_hardware_breakpoints
, _("\
8513 Set automatic usage of hardware breakpoints."), _("\
8514 Show automatic usage of hardware breakpoints."), _("\
8515 If set, the debugger will automatically use hardware breakpoints for\n\
8516 breakpoints set with \"break\" but falling in read-only memory. If not set,\n\
8517 a warning will be emitted for such breakpoints."),
8519 show_automatic_hardware_breakpoints
,
8520 &breakpoint_set_cmdlist
,
8521 &breakpoint_show_cmdlist
);
8523 add_setshow_boolean_cmd ("always-inserted", class_support
,
8524 &always_inserted_mode
, _("\
8525 Set mode for inserting breakpoints."), _("\
8526 Show mode for inserting breakpoints."), _("\
8527 When this mode is off (which is the default), breakpoints are inserted in\n\
8528 inferior when it is resumed, and removed when execution stops. When this\n\
8529 mode is on, breakpoints are inserted immediately and removed only when\n\
8530 the user deletes the breakpoint."),
8532 &show_always_inserted_mode
,
8533 &breakpoint_set_cmdlist
,
8534 &breakpoint_show_cmdlist
);
8536 automatic_hardware_breakpoints
= 1;