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"
59 #include "gdb-events.h"
60 #include "mi/mi-common.h"
62 /* Prototypes for local functions. */
64 static void until_break_command_continuation (struct continuation_arg
*arg
);
66 static void catch_command_1 (char *, int, int);
68 static void enable_delete_command (char *, int);
70 static void enable_delete_breakpoint (struct breakpoint
*);
72 static void enable_once_command (char *, int);
74 static void enable_once_breakpoint (struct breakpoint
*);
76 static void disable_command (char *, int);
78 static void enable_command (char *, int);
80 static void map_breakpoint_numbers (char *, void (*)(struct breakpoint
*));
82 static void ignore_command (char *, int);
84 static int breakpoint_re_set_one (void *);
86 static void clear_command (char *, int);
88 static void catch_command (char *, int);
90 static void watch_command (char *, int);
92 static int can_use_hardware_watchpoint (struct value
*);
94 static void break_command_1 (char *, int, int);
96 static void mention (struct breakpoint
*);
98 struct breakpoint
*set_raw_breakpoint (struct symtab_and_line
, enum bptype
);
100 static void check_duplicates (struct breakpoint
*);
102 static void breakpoint_adjustment_warning (CORE_ADDR
, CORE_ADDR
, int, int);
104 static CORE_ADDR
adjust_breakpoint_address (CORE_ADDR bpaddr
,
107 static void describe_other_breakpoints (CORE_ADDR
, asection
*, int);
109 static void breakpoints_info (char *, int);
111 static void breakpoint_1 (int, int);
113 static bpstat
bpstat_alloc (const struct bp_location
*, bpstat
);
115 static int breakpoint_cond_eval (void *);
117 static void cleanup_executing_breakpoints (void *);
119 static void commands_command (char *, int);
121 static void condition_command (char *, int);
123 static int get_number_trailer (char **, int);
125 void set_breakpoint_count (int);
134 static int remove_breakpoint (struct bp_location
*, insertion_state_t
);
136 static enum print_stop_action
print_it_typical (bpstat
);
138 static enum print_stop_action
print_bp_stop_message (bpstat bs
);
142 enum exception_event_kind kind
;
145 args_for_catchpoint_enable
;
147 static int watchpoint_check (void *);
149 static void maintenance_info_breakpoints (char *, int);
151 static void create_longjmp_breakpoint (char *);
153 static void create_overlay_event_breakpoint (char *);
155 static int hw_breakpoint_used_count (void);
157 static int hw_watchpoint_used_count (enum bptype
, int *);
159 static void hbreak_command (char *, int);
161 static void thbreak_command (char *, int);
163 static void watch_command_1 (char *, int, int);
165 static void rwatch_command (char *, int);
167 static void awatch_command (char *, int);
169 static void do_enable_breakpoint (struct breakpoint
*, enum bpdisp
);
171 static void create_fork_vfork_event_catchpoint (int tempflag
,
173 enum bptype bp_kind
);
175 static void stop_command (char *arg
, int from_tty
);
177 static void stopin_command (char *arg
, int from_tty
);
179 static void stopat_command (char *arg
, int from_tty
);
181 static char *ep_find_event_name_end (char *arg
);
183 static char *ep_parse_optional_if_clause (char **arg
);
185 static char *ep_parse_optional_filename (char **arg
);
187 static void create_exception_catchpoint (int tempflag
, char *cond_string
,
188 enum exception_event_kind ex_event
,
189 struct symtab_and_line
*sal
);
191 static void catch_exception_command_1 (enum exception_event_kind ex_event
,
192 char *arg
, int tempflag
, int from_tty
);
194 static void tcatch_command (char *arg
, int from_tty
);
196 static void ep_skip_leading_whitespace (char **s
);
198 static int single_step_breakpoint_inserted_here_p (CORE_ADDR pc
);
200 static void free_bp_location (struct bp_location
*loc
);
202 static void mark_breakpoints_out (void);
204 static struct bp_location
*
205 allocate_bp_location (struct breakpoint
*bpt
, enum bptype bp_type
);
208 unlink_locations_from_global_list (struct breakpoint
*bpt
);
211 is_hardware_watchpoint (struct breakpoint
*bpt
);
213 /* Prototypes for exported functions. */
215 /* If FALSE, gdb will not use hardware support for watchpoints, even
216 if such is available. */
217 static int can_use_hw_watchpoints
;
220 show_can_use_hw_watchpoints (struct ui_file
*file
, int from_tty
,
221 struct cmd_list_element
*c
,
224 fprintf_filtered (file
, _("\
225 Debugger's willingness to use watchpoint hardware is %s.\n"),
229 /* If AUTO_BOOLEAN_FALSE, gdb will not attempt to create pending breakpoints.
230 If AUTO_BOOLEAN_TRUE, gdb will automatically create pending breakpoints
231 for unrecognized breakpoint locations.
232 If AUTO_BOOLEAN_AUTO, gdb will query when breakpoints are unrecognized. */
233 static enum auto_boolean pending_break_support
;
235 show_pending_break_support (struct ui_file
*file
, int from_tty
,
236 struct cmd_list_element
*c
,
239 fprintf_filtered (file
, _("\
240 Debugger's behavior regarding pending breakpoints is %s.\n"),
244 /* If 1, gdb will automatically use hardware breakpoints for breakpoints
245 set with "break" but falling in read-only memory.
246 If 0, gdb will warn about such breakpoints, but won't automatically
247 use hardware breakpoints. */
248 static int automatic_hardware_breakpoints
;
250 show_automatic_hardware_breakpoints (struct ui_file
*file
, int from_tty
,
251 struct cmd_list_element
*c
,
254 fprintf_filtered (file
, _("\
255 Automatic usage of hardware breakpoints is %s.\n"),
260 void _initialize_breakpoint (void);
262 extern int addressprint
; /* Print machine addresses? */
264 /* Are we executing breakpoint commands? */
265 static int executing_breakpoint_commands
;
267 /* Are overlay event breakpoints enabled? */
268 static int overlay_events_enabled
;
270 /* Walk the following statement or block through all breakpoints.
271 ALL_BREAKPOINTS_SAFE does so even if the statment deletes the current
274 #define ALL_BREAKPOINTS(B) for (B = breakpoint_chain; B; B = B->next)
276 #define ALL_BREAKPOINTS_SAFE(B,TMP) \
277 for (B = breakpoint_chain; \
278 B ? (TMP=B->next, 1): 0; \
281 /* Similar iterators for the low-level breakpoints. */
283 #define ALL_BP_LOCATIONS(B) for (B = bp_location_chain; B; B = B->global_next)
285 #define ALL_BP_LOCATIONS_SAFE(B,TMP) \
286 for (B = bp_location_chain; \
287 B ? (TMP=B->global_next, 1): 0; \
290 /* True if breakpoint hit counts should be displayed in breakpoint info. */
292 int show_breakpoint_hit_counts
= 1;
294 /* Chains of all breakpoints defined. */
296 struct breakpoint
*breakpoint_chain
;
298 struct bp_location
*bp_location_chain
;
300 /* Number of last breakpoint made. */
302 int breakpoint_count
;
304 /* Pointer to current exception event record */
305 static struct exception_event_record
*current_exception_event
;
307 /* This function returns a pointer to the string representation of the
308 pathname of the dynamically-linked library that has just been
311 This function must be used only when SOLIB_HAVE_LOAD_EVENT is TRUE,
312 or undefined results are guaranteed.
314 This string's contents are only valid immediately after the
315 inferior has stopped in the dynamic linker hook, and becomes
316 invalid as soon as the inferior is continued. Clients should make
317 a copy of this string if they wish to continue the inferior and
318 then access the string. */
320 #ifndef SOLIB_LOADED_LIBRARY_PATHNAME
321 #define SOLIB_LOADED_LIBRARY_PATHNAME(pid) ""
324 /* This function returns a pointer to the string representation of the
325 pathname of the dynamically-linked library that has just been
328 This function must be used only when SOLIB_HAVE_UNLOAD_EVENT is
329 TRUE, or undefined results are guaranteed.
331 This string's contents are only valid immediately after the
332 inferior has stopped in the dynamic linker hook, and becomes
333 invalid as soon as the inferior is continued. Clients should make
334 a copy of this string if they wish to continue the inferior and
335 then access the string. */
337 #ifndef SOLIB_UNLOADED_LIBRARY_PATHNAME
338 #define SOLIB_UNLOADED_LIBRARY_PATHNAME(pid) ""
341 /* This function is called by the "catch load" command. It allows the
342 debugger to be notified by the dynamic linker when a specified
343 library file (or any library file, if filename is NULL) is loaded. */
345 #ifndef SOLIB_CREATE_CATCH_LOAD_HOOK
346 #define SOLIB_CREATE_CATCH_LOAD_HOOK(pid,tempflag,filename,cond_string) \
347 error (_("catch of library loads not yet implemented on this platform"))
350 /* This function is called by the "catch unload" command. It allows
351 the debugger to be notified by the dynamic linker when a specified
352 library file (or any library file, if filename is NULL) is
355 #ifndef SOLIB_CREATE_CATCH_UNLOAD_HOOK
356 #define SOLIB_CREATE_CATCH_UNLOAD_HOOK(pid, tempflag, filename, cond_string) \
357 error (_("catch of library unloads not yet implemented on this platform"))
360 /* Return whether a breakpoint is an active enabled breakpoint. */
362 breakpoint_enabled (struct breakpoint
*b
)
364 return (b
->enable_state
== bp_enabled
);
367 /* Set breakpoint count to NUM. */
370 set_breakpoint_count (int num
)
372 breakpoint_count
= num
;
373 set_internalvar (lookup_internalvar ("bpnum"),
374 value_from_longest (builtin_type_int
, (LONGEST
) num
));
377 /* Used in run_command to zero the hit count when a new run starts. */
380 clear_breakpoint_hit_counts (void)
382 struct breakpoint
*b
;
388 /* Default address, symtab and line to put a breakpoint at
389 for "break" command with no arg.
390 if default_breakpoint_valid is zero, the other three are
391 not valid, and "break" with no arg is an error.
393 This set by print_stack_frame, which calls set_default_breakpoint. */
395 int default_breakpoint_valid
;
396 CORE_ADDR default_breakpoint_address
;
397 struct symtab
*default_breakpoint_symtab
;
398 int default_breakpoint_line
;
400 /* *PP is a string denoting a breakpoint. Get the number of the breakpoint.
401 Advance *PP after the string and any trailing whitespace.
403 Currently the string can either be a number or "$" followed by the name
404 of a convenience variable. Making it an expression wouldn't work well
405 for map_breakpoint_numbers (e.g. "4 + 5 + 6").
407 If the string is a NULL pointer, that denotes the last breakpoint.
409 TRAILER is a character which can be found after the number; most
410 commonly this is `-'. If you don't want a trailer, use \0. */
412 get_number_trailer (char **pp
, int trailer
)
414 int retval
= 0; /* default */
418 /* Empty line means refer to the last breakpoint. */
419 return breakpoint_count
;
422 /* Make a copy of the name, so we can null-terminate it
423 to pass to lookup_internalvar(). */
428 while (isalnum (*p
) || *p
== '_')
430 varname
= (char *) alloca (p
- start
+ 1);
431 strncpy (varname
, start
, p
- start
);
432 varname
[p
- start
] = '\0';
433 val
= value_of_internalvar (lookup_internalvar (varname
));
434 if (TYPE_CODE (value_type (val
)) == TYPE_CODE_INT
)
435 retval
= (int) value_as_long (val
);
438 printf_filtered (_("Convenience variable must have integer value.\n"));
446 while (*p
>= '0' && *p
<= '9')
449 /* There is no number here. (e.g. "cond a == b"). */
451 /* Skip non-numeric token */
452 while (*p
&& !isspace((int) *p
))
454 /* Return zero, which caller must interpret as error. */
460 if (!(isspace (*p
) || *p
== '\0' || *p
== trailer
))
462 /* Trailing junk: return 0 and let caller print error msg. */
463 while (!(isspace (*p
) || *p
== '\0' || *p
== trailer
))
474 /* Like get_number_trailer, but don't allow a trailer. */
476 get_number (char **pp
)
478 return get_number_trailer (pp
, '\0');
481 /* Parse a number or a range.
482 * A number will be of the form handled by get_number.
483 * A range will be of the form <number1> - <number2>, and
484 * will represent all the integers between number1 and number2,
487 * While processing a range, this fuction is called iteratively;
488 * At each call it will return the next value in the range.
490 * At the beginning of parsing a range, the char pointer PP will
491 * be advanced past <number1> and left pointing at the '-' token.
492 * Subsequent calls will not advance the pointer until the range
493 * is completed. The call that completes the range will advance
494 * pointer PP past <number2>.
498 get_number_or_range (char **pp
)
500 static int last_retval
, end_value
;
501 static char *end_ptr
;
502 static int in_range
= 0;
506 /* Default case: pp is pointing either to a solo number,
507 or to the first number of a range. */
508 last_retval
= get_number_trailer (pp
, '-');
513 /* This is the start of a range (<number1> - <number2>).
514 Skip the '-', parse and remember the second number,
515 and also remember the end of the final token. */
519 while (isspace ((int) *end_ptr
))
520 end_ptr
++; /* skip white space */
521 end_value
= get_number (temp
);
522 if (end_value
< last_retval
)
524 error (_("inverted range"));
526 else if (end_value
== last_retval
)
528 /* degenerate range (number1 == number2). Advance the
529 token pointer so that the range will be treated as a
538 error (_("negative value"));
541 /* pp points to the '-' that betokens a range. All
542 number-parsing has already been done. Return the next
543 integer value (one greater than the saved previous value).
544 Do not advance the token pointer 'pp' until the end of range
547 if (++last_retval
== end_value
)
549 /* End of range reached; advance token pointer. */
559 /* condition N EXP -- set break condition of breakpoint N to EXP. */
562 condition_command (char *arg
, int from_tty
)
564 struct breakpoint
*b
;
569 error_no_arg (_("breakpoint number"));
572 bnum
= get_number (&p
);
574 error (_("Bad breakpoint argument: '%s'"), arg
);
577 if (b
->number
== bnum
)
579 struct bp_location
*loc
= b
->loc
;
580 for (; loc
; loc
= loc
->next
)
588 if (b
->cond_string
!= NULL
)
589 xfree (b
->cond_string
);
593 b
->cond_string
= NULL
;
595 printf_filtered (_("Breakpoint %d now unconditional.\n"), bnum
);
600 /* I don't know if it matters whether this is the string the user
601 typed in or the decompiled expression. */
602 b
->cond_string
= savestring (arg
, strlen (arg
));
603 b
->condition_not_parsed
= 0;
604 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
607 loc
->cond
= parse_exp_1 (&arg
, block_for_pc (loc
->address
), 0);
609 error (_("Junk at end of expression"));
612 breakpoints_changed ();
613 breakpoint_modify_event (b
->number
);
617 error (_("No breakpoint number %d."), bnum
);
621 commands_command (char *arg
, int from_tty
)
623 struct breakpoint
*b
;
626 struct command_line
*l
;
628 /* If we allowed this, we would have problems with when to
629 free the storage, if we change the commands currently
632 if (executing_breakpoint_commands
)
633 error (_("Can't use the \"commands\" command among a breakpoint's commands."));
636 bnum
= get_number (&p
);
639 error (_("Unexpected extra arguments following breakpoint number."));
642 if (b
->number
== bnum
)
644 char *tmpbuf
= xstrprintf ("Type commands for when breakpoint %d is hit, one per line.",
646 struct cleanup
*cleanups
= make_cleanup (xfree
, tmpbuf
);
647 l
= read_command_lines (tmpbuf
, from_tty
);
648 do_cleanups (cleanups
);
649 free_command_lines (&b
->commands
);
651 breakpoints_changed ();
652 breakpoint_modify_event (b
->number
);
655 error (_("No breakpoint number %d."), bnum
);
658 /* Like commands_command, but instead of reading the commands from
659 input stream, takes them from an already parsed command structure.
661 This is used by cli-script.c to DTRT with breakpoint commands
662 that are part of if and while bodies. */
663 enum command_control_type
664 commands_from_control_command (char *arg
, struct command_line
*cmd
)
666 struct breakpoint
*b
;
670 /* If we allowed this, we would have problems with when to
671 free the storage, if we change the commands currently
674 if (executing_breakpoint_commands
)
675 error (_("Can't use the \"commands\" command among a breakpoint's commands."));
677 /* An empty string for the breakpoint number means the last
678 breakpoint, but get_number expects a NULL pointer. */
683 bnum
= get_number (&p
);
686 error (_("Unexpected extra arguments following breakpoint number."));
689 if (b
->number
== bnum
)
691 free_command_lines (&b
->commands
);
692 if (cmd
->body_count
!= 1)
693 error (_("Invalid \"commands\" block structure."));
694 /* We need to copy the commands because if/while will free the
695 list after it finishes execution. */
696 b
->commands
= copy_command_lines (cmd
->body_list
[0]);
697 breakpoints_changed ();
698 breakpoint_modify_event (b
->number
);
699 return simple_control
;
701 error (_("No breakpoint number %d."), bnum
);
704 /* Like target_read_memory() but if breakpoints are inserted, return
705 the shadow contents instead of the breakpoints themselves.
707 Read "memory data" from whatever target or inferior we have.
708 Returns zero if successful, errno value if not. EIO is used
709 for address out of bounds. If breakpoints are inserted, returns
710 shadow contents, not the breakpoints themselves. From breakpoint.c. */
713 read_memory_nobpt (CORE_ADDR memaddr
, gdb_byte
*myaddr
, unsigned len
)
716 const struct bp_location
*b
;
717 CORE_ADDR bp_addr
= 0;
720 if (gdbarch_breakpoint_from_pc (current_gdbarch
, &bp_addr
, &bp_size
) == NULL
)
721 /* No breakpoints on this machine. */
722 return target_read_memory (memaddr
, myaddr
, len
);
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. */
741 if (bp_addr
+ bp_size
<= memaddr
)
742 /* The breakpoint is entirely before the chunk of memory we
745 if (bp_addr
>= memaddr
+ len
)
746 /* The breakpoint is entirely after the chunk of memory we are
749 /* Copy the breakpoint from the shadow contents, and recurse for
750 the things before and after. */
752 /* Offset within shadow_contents. */
755 if (bp_addr
< memaddr
)
757 /* Only copy the second part of the breakpoint. */
758 bp_size
-= memaddr
- bp_addr
;
759 bptoffset
= memaddr
- bp_addr
;
763 if (bp_addr
+ bp_size
> memaddr
+ len
)
765 /* Only copy the first part of the breakpoint. */
766 bp_size
-= (bp_addr
+ bp_size
) - (memaddr
+ len
);
769 memcpy (myaddr
+ bp_addr
- memaddr
,
770 b
->target_info
.shadow_contents
+ bptoffset
, bp_size
);
772 if (bp_addr
> memaddr
)
774 /* Copy the section of memory before the breakpoint. */
775 status
= read_memory_nobpt (memaddr
, myaddr
, bp_addr
- memaddr
);
780 if (bp_addr
+ bp_size
< memaddr
+ len
)
782 /* Copy the section of memory after the breakpoint. */
783 status
= read_memory_nobpt (bp_addr
+ bp_size
,
784 myaddr
+ bp_addr
+ bp_size
- memaddr
,
785 memaddr
+ len
- (bp_addr
+ bp_size
));
792 /* Nothing overlaps. Just call read_memory_noerr. */
793 return target_read_memory (memaddr
, myaddr
, len
);
797 /* A wrapper function for inserting catchpoints. */
799 insert_catchpoint (struct ui_out
*uo
, void *args
)
801 struct breakpoint
*b
= (struct breakpoint
*) args
;
807 target_insert_fork_catchpoint (PIDGET (inferior_ptid
));
810 target_insert_vfork_catchpoint (PIDGET (inferior_ptid
));
813 target_insert_exec_catchpoint (PIDGET (inferior_ptid
));
816 internal_error (__FILE__
, __LINE__
, _("unknown breakpoint type"));
822 is_hardware_watchpoint (struct breakpoint
*bpt
)
824 return (bpt
->type
== bp_hardware_watchpoint
825 || bpt
->type
== bp_read_watchpoint
826 || bpt
->type
== bp_access_watchpoint
);
829 /* Assuming that B is a hardware breakpoint:
830 - Reparse watchpoint expression, is REPARSE is non-zero
831 - Evaluate expression and store the result in B->val
832 - Update the list of values that must be watched in B->loc.
834 If the watchpoint is disabled, do nothing. If this is
835 local watchpoint that is out of scope, delete it. */
837 update_watchpoint (struct breakpoint
*b
, int reparse
)
839 int within_current_scope
;
840 struct value
*mark
= value_mark ();
841 struct frame_id saved_frame_id
;
842 struct bp_location
*loc
;
845 unlink_locations_from_global_list (b
);
846 for (loc
= b
->loc
; loc
;)
848 struct bp_location
*loc_next
= loc
->next
;
849 remove_breakpoint (loc
, mark_uninserted
);
855 if (b
->disposition
== disp_del_at_next_stop
)
858 /* Save the current frame's ID so we can restore it after
859 evaluating the watchpoint expression on its own frame. */
860 /* FIXME drow/2003-09-09: It would be nice if evaluate_expression
861 took a frame parameter, so that we didn't have to change the
863 saved_frame_id
= get_frame_id (get_selected_frame (NULL
));
865 /* Determine if the watchpoint is within scope. */
866 if (b
->exp_valid_block
== NULL
)
867 within_current_scope
= 1;
870 struct frame_info
*fi
;
871 fi
= frame_find_by_id (b
->watchpoint_frame
);
872 within_current_scope
= (fi
!= NULL
);
873 if (within_current_scope
)
877 if (within_current_scope
&& reparse
)
886 b
->exp
= parse_exp_1 (&s
, b
->exp_valid_block
, 0);
887 /* If the meaning of expression itself changed, the old value is
888 no longer relevant. We don't want to report a watchpoint hit
889 to the user when the old value and the new value may actually
890 be completely different objects. */
896 /* If we failed to parse the expression, for example because
897 it refers to a global variable in a not-yet-loaded shared library,
898 don't try to insert watchpoint. We don't automatically delete
899 such watchpoint, though, since failure to parse expression
900 is different from out-of-scope watchpoint. */
901 if (within_current_scope
&& b
->exp
)
903 struct value
*v
, *next
;
905 /* Evaluate the expression and make sure it's not lazy, so that
906 after target stops again, we have a non-lazy previous value
907 to compare with. Also, making the value non-lazy will fetch
908 intermediate values as needed, which we use to decide which
911 The value returned by evaluate_expression is stored in b->val.
912 In addition, we look at all values which were created
913 during evaluation, and set watchoints at addresses as needed.
914 Those values are explicitly deleted here. */
915 v
= evaluate_expression (b
->exp
);
916 /* Avoid setting b->val if it's already set. The meaning of
917 b->val is 'the last value' user saw, and we should update
918 it only if we reported that last value to user. As it
919 happens, the code that reports it updates b->val directly. */
923 value_release_to_mark (mark
);
925 /* Look at each value on the value chain. */
928 /* If it's a memory location, and GDB actually needed
929 its contents to evaluate the expression, then we
931 if (VALUE_LVAL (v
) == lval_memory
934 struct type
*vtype
= check_typedef (value_type (v
));
936 /* We only watch structs and arrays if user asked
937 for it explicitly, never if they just happen to
938 appear in the middle of some value chain. */
940 || (TYPE_CODE (vtype
) != TYPE_CODE_STRUCT
941 && TYPE_CODE (vtype
) != TYPE_CODE_ARRAY
))
945 struct bp_location
*loc
, **tmp
;
947 addr
= VALUE_ADDRESS (v
) + value_offset (v
);
948 len
= TYPE_LENGTH (value_type (v
));
950 if (b
->type
== bp_read_watchpoint
)
952 else if (b
->type
== bp_access_watchpoint
)
955 loc
= allocate_bp_location (b
, bp_hardware_watchpoint
);
956 for (tmp
= &(b
->loc
); *tmp
!= NULL
; tmp
= &((*tmp
)->next
))
961 loc
->watchpoint_type
= type
;
965 next
= value_next (v
);
970 if (reparse
&& b
->cond_string
!= NULL
)
972 char *s
= b
->cond_string
;
975 xfree (b
->loc
->cond
);
978 b
->loc
->cond
= parse_exp_1 (&s
, b
->exp_valid_block
, 0);
981 else if (!within_current_scope
)
983 printf_filtered (_("\
984 Hardware watchpoint %d deleted because the program has left the block \n\
985 in which its expression is valid.\n"),
987 if (b
->related_breakpoint
)
988 b
->related_breakpoint
->disposition
= disp_del_at_next_stop
;
989 b
->disposition
= disp_del_at_next_stop
;
992 /* Restore the selected frame. */
993 select_frame (frame_find_by_id (saved_frame_id
));
997 /* Insert a low-level "breakpoint" of some type. BPT is the breakpoint.
998 Any error messages are printed to TMP_ERROR_STREAM; and DISABLED_BREAKS,
999 PROCESS_WARNING, and HW_BREAKPOINT_ERROR are used to report problems.
1001 NOTE drow/2003-09-09: This routine could be broken down to an object-style
1002 method for each breakpoint or catchpoint type. */
1004 insert_bp_location (struct bp_location
*bpt
,
1005 struct ui_file
*tmp_error_stream
,
1006 int *disabled_breaks
, int *process_warning
,
1007 int *hw_breakpoint_error
)
1011 if (!breakpoint_enabled (bpt
->owner
))
1014 if (!bpt
->enabled
|| bpt
->shlib_disabled
|| bpt
->inserted
|| bpt
->duplicate
)
1017 /* Initialize the target-specific information. */
1018 memset (&bpt
->target_info
, 0, sizeof (bpt
->target_info
));
1019 bpt
->target_info
.placed_address
= bpt
->address
;
1021 if (bpt
->loc_type
== bp_loc_software_breakpoint
1022 || bpt
->loc_type
== bp_loc_hardware_breakpoint
)
1024 if (bpt
->owner
->type
!= bp_hardware_breakpoint
)
1026 /* If the explicitly specified breakpoint type
1027 is not hardware breakpoint, check the memory map to see
1028 if the breakpoint address is in read only memory or not.
1029 Two important cases are:
1030 - location type is not hardware breakpoint, memory
1031 is readonly. We change the type of the location to
1032 hardware breakpoint.
1033 - location type is hardware breakpoint, memory is read-write.
1034 This means we've previously made the location hardware one, but
1035 then the memory map changed, so we undo.
1037 When breakpoints are removed, remove_breakpoints will
1038 use location types we've just set here, the only possible
1039 problem is that memory map has changed during running program,
1040 but it's not going to work anyway with current gdb. */
1041 struct mem_region
*mr
1042 = lookup_mem_region (bpt
->target_info
.placed_address
);
1046 if (automatic_hardware_breakpoints
)
1049 enum bp_loc_type new_type
;
1051 if (mr
->attrib
.mode
!= MEM_RW
)
1052 new_type
= bp_loc_hardware_breakpoint
;
1054 new_type
= bp_loc_software_breakpoint
;
1056 if (new_type
!= bpt
->loc_type
)
1058 static int said
= 0;
1059 bpt
->loc_type
= new_type
;
1062 fprintf_filtered (gdb_stdout
, _("\
1063 Note: automatically using hardware breakpoints for read-only addresses.\n"));
1068 else if (bpt
->loc_type
== bp_loc_software_breakpoint
1069 && mr
->attrib
.mode
!= MEM_RW
)
1070 warning (_("cannot set software breakpoint at readonly address %s"),
1071 paddr (bpt
->address
));
1075 /* First check to see if we have to handle an overlay. */
1076 if (overlay_debugging
== ovly_off
1077 || bpt
->section
== NULL
1078 || !(section_is_overlay (bpt
->section
)))
1080 /* No overlay handling: just set the breakpoint. */
1082 if (bpt
->loc_type
== bp_loc_hardware_breakpoint
)
1083 val
= target_insert_hw_breakpoint (&bpt
->target_info
);
1085 val
= target_insert_breakpoint (&bpt
->target_info
);
1089 /* This breakpoint is in an overlay section.
1090 Shall we set a breakpoint at the LMA? */
1091 if (!overlay_events_enabled
)
1093 /* Yes -- overlay event support is not active,
1094 so we must try to set a breakpoint at the LMA.
1095 This will not work for a hardware breakpoint. */
1096 if (bpt
->loc_type
== bp_loc_hardware_breakpoint
)
1097 warning (_("hardware breakpoint %d not supported in overlay!"),
1098 bpt
->owner
->number
);
1101 CORE_ADDR addr
= overlay_unmapped_address (bpt
->address
,
1103 /* Set a software (trap) breakpoint at the LMA. */
1104 bpt
->overlay_target_info
= bpt
->target_info
;
1105 bpt
->overlay_target_info
.placed_address
= addr
;
1106 val
= target_insert_breakpoint (&bpt
->overlay_target_info
);
1108 fprintf_unfiltered (tmp_error_stream
,
1109 "Overlay breakpoint %d failed: in ROM?",
1110 bpt
->owner
->number
);
1113 /* Shall we set a breakpoint at the VMA? */
1114 if (section_is_mapped (bpt
->section
))
1116 /* Yes. This overlay section is mapped into memory. */
1117 if (bpt
->loc_type
== bp_loc_hardware_breakpoint
)
1118 val
= target_insert_hw_breakpoint (&bpt
->target_info
);
1120 val
= target_insert_breakpoint (&bpt
->target_info
);
1124 /* No. This breakpoint will not be inserted.
1125 No error, but do not mark the bp as 'inserted'. */
1132 /* Can't set the breakpoint. */
1133 if (solib_address (bpt
->address
))
1135 /* See also: disable_breakpoints_in_shlibs. */
1137 bpt
->shlib_disabled
= 1;
1138 if (!*disabled_breaks
)
1140 fprintf_unfiltered (tmp_error_stream
,
1141 "Cannot insert breakpoint %d.\n",
1142 bpt
->owner
->number
);
1143 fprintf_unfiltered (tmp_error_stream
,
1144 "Temporarily disabling shared library breakpoints:\n");
1146 *disabled_breaks
= 1;
1147 fprintf_unfiltered (tmp_error_stream
,
1148 "breakpoint #%d\n", bpt
->owner
->number
);
1152 #ifdef ONE_PROCESS_WRITETEXT
1153 *process_warning
= 1;
1155 if (bpt
->loc_type
== bp_loc_hardware_breakpoint
)
1157 *hw_breakpoint_error
= 1;
1158 fprintf_unfiltered (tmp_error_stream
,
1159 "Cannot insert hardware breakpoint %d.\n",
1160 bpt
->owner
->number
);
1164 fprintf_unfiltered (tmp_error_stream
,
1165 "Cannot insert breakpoint %d.\n",
1166 bpt
->owner
->number
);
1167 fprintf_filtered (tmp_error_stream
,
1168 "Error accessing memory address ");
1169 fputs_filtered (paddress (bpt
->address
), tmp_error_stream
);
1170 fprintf_filtered (tmp_error_stream
, ": %s.\n",
1171 safe_strerror (val
));
1182 else if (bpt
->loc_type
== bp_loc_hardware_watchpoint
1183 /* NOTE drow/2003-09-08: This state only exists for removing
1184 watchpoints. It's not clear that it's necessary... */
1185 && bpt
->owner
->disposition
!= disp_del_at_next_stop
)
1187 val
= target_insert_watchpoint (bpt
->address
,
1189 bpt
->watchpoint_type
);
1190 bpt
->inserted
= (val
!= -1);
1193 else if (bpt
->owner
->type
== bp_catch_fork
1194 || bpt
->owner
->type
== bp_catch_vfork
1195 || bpt
->owner
->type
== bp_catch_exec
)
1197 struct gdb_exception e
= catch_exception (uiout
, insert_catchpoint
,
1198 bpt
->owner
, RETURN_MASK_ERROR
);
1199 exception_fprintf (gdb_stderr
, e
, "warning: inserting catchpoint %d: ",
1200 bpt
->owner
->number
);
1202 bpt
->owner
->enable_state
= bp_disabled
;
1206 /* We've already printed an error message if there was a problem
1207 inserting this catchpoint, and we've disabled the catchpoint,
1208 so just return success. */
1215 /* insert_breakpoints is used when starting or continuing the program.
1216 remove_breakpoints is used when the program stops.
1217 Both return zero if successful,
1218 or an `errno' value if could not write the inferior. */
1221 insert_breakpoints (void)
1223 struct breakpoint
*bpt
;
1224 struct bp_location
*b
, *temp
;
1227 int disabled_breaks
= 0;
1228 int hw_breakpoint_error
= 0;
1229 int process_warning
= 0;
1231 struct ui_file
*tmp_error_stream
= mem_fileopen ();
1232 make_cleanup_ui_file_delete (tmp_error_stream
);
1234 /* Explicitly mark the warning -- this will only be printed if
1235 there was an error. */
1236 fprintf_unfiltered (tmp_error_stream
, "Warning:\n");
1238 ALL_BREAKPOINTS (bpt
)
1239 if (is_hardware_watchpoint (bpt
))
1240 update_watchpoint (bpt
, 0 /* don't reparse */);
1242 ALL_BP_LOCATIONS_SAFE (b
, temp
)
1244 if (!breakpoint_enabled (b
->owner
))
1247 /* There is no point inserting thread-specific breakpoints if the
1248 thread no longer exists. */
1249 if (b
->owner
->thread
!= -1
1250 && !valid_thread_id (b
->owner
->thread
))
1253 val
= insert_bp_location (b
, tmp_error_stream
,
1254 &disabled_breaks
, &process_warning
,
1255 &hw_breakpoint_error
);
1260 /* If we failed to insert all locations of a watchpoint,
1261 remove them, as half-inserted watchpoint is of limited use. */
1262 ALL_BREAKPOINTS (bpt
)
1264 int some_failed
= 0;
1265 struct bp_location
*loc
;
1267 if (!is_hardware_watchpoint (bpt
))
1270 if (bpt
->enable_state
!= bp_enabled
)
1273 for (loc
= bpt
->loc
; loc
; loc
= loc
->next
)
1281 for (loc
= bpt
->loc
; loc
; loc
= loc
->next
)
1283 remove_breakpoint (loc
, mark_uninserted
);
1285 hw_breakpoint_error
= 1;
1286 fprintf_unfiltered (tmp_error_stream
,
1287 "Could not insert hardware watchpoint %d.\n",
1295 /* If a hardware breakpoint or watchpoint was inserted, add a
1296 message about possibly exhausted resources. */
1297 if (hw_breakpoint_error
)
1299 fprintf_unfiltered (tmp_error_stream
,
1300 "Could not insert hardware breakpoints:\n\
1301 You may have requested too many hardware breakpoints/watchpoints.\n");
1303 #ifdef ONE_PROCESS_WRITETEXT
1304 if (process_warning
)
1305 fprintf_unfiltered (tmp_error_stream
,
1306 "The same program may be running in another process.");
1308 target_terminal_ours_for_output ();
1309 error_stream (tmp_error_stream
);
1314 remove_breakpoints (void)
1316 struct bp_location
*b
;
1319 ALL_BP_LOCATIONS (b
)
1323 val
= remove_breakpoint (b
, mark_uninserted
);
1332 remove_hw_watchpoints (void)
1334 struct bp_location
*b
;
1337 ALL_BP_LOCATIONS (b
)
1339 if (b
->inserted
&& b
->loc_type
== bp_loc_hardware_watchpoint
)
1341 val
= remove_breakpoint (b
, mark_uninserted
);
1350 reattach_breakpoints (int pid
)
1352 struct bp_location
*b
;
1354 struct cleanup
*old_chain
= save_inferior_ptid ();
1355 struct ui_file
*tmp_error_stream
= mem_fileopen ();
1356 int dummy1
= 0, dummy2
= 0, dummy3
= 0;
1358 make_cleanup_ui_file_delete (tmp_error_stream
);
1360 inferior_ptid
= pid_to_ptid (pid
);
1361 ALL_BP_LOCATIONS (b
)
1366 val
= insert_bp_location (b
, tmp_error_stream
,
1367 &dummy1
, &dummy2
, &dummy3
);
1370 do_cleanups (old_chain
);
1375 do_cleanups (old_chain
);
1380 update_breakpoints_after_exec (void)
1382 struct breakpoint
*b
;
1383 struct breakpoint
*temp
;
1385 /* Doing this first prevents the badness of having delete_breakpoint()
1386 write a breakpoint's current "shadow contents" to lift the bp. That
1387 shadow is NOT valid after an exec()! */
1388 mark_breakpoints_out ();
1390 ALL_BREAKPOINTS_SAFE (b
, temp
)
1392 /* Solib breakpoints must be explicitly reset after an exec(). */
1393 if (b
->type
== bp_shlib_event
)
1395 delete_breakpoint (b
);
1399 /* Thread event breakpoints must be set anew after an exec(),
1400 as must overlay event breakpoints. */
1401 if (b
->type
== bp_thread_event
|| b
->type
== bp_overlay_event
)
1403 delete_breakpoint (b
);
1407 /* Step-resume breakpoints are meaningless after an exec(). */
1408 if (b
->type
== bp_step_resume
)
1410 delete_breakpoint (b
);
1414 /* Don't delete an exec catchpoint, because else the inferior
1415 won't stop when it ought!
1417 Similarly, we probably ought to keep vfork catchpoints, 'cause
1418 on this target, we may not be able to stop when the vfork is
1419 seen, but only when the subsequent exec is seen. (And because
1420 deleting fork catchpoints here but not vfork catchpoints will
1421 seem mysterious to users, keep those too.) */
1422 if ((b
->type
== bp_catch_exec
) ||
1423 (b
->type
== bp_catch_vfork
) ||
1424 (b
->type
== bp_catch_fork
))
1429 /* bp_finish is a special case. The only way we ought to be able
1430 to see one of these when an exec() has happened, is if the user
1431 caught a vfork, and then said "finish". Ordinarily a finish just
1432 carries them to the call-site of the current callee, by setting
1433 a temporary bp there and resuming. But in this case, the finish
1434 will carry them entirely through the vfork & exec.
1436 We don't want to allow a bp_finish to remain inserted now. But
1437 we can't safely delete it, 'cause finish_command has a handle to
1438 the bp on a bpstat, and will later want to delete it. There's a
1439 chance (and I've seen it happen) that if we delete the bp_finish
1440 here, that its storage will get reused by the time finish_command
1441 gets 'round to deleting the "use to be a bp_finish" breakpoint.
1442 We really must allow finish_command to delete a bp_finish.
1444 In the absense of a general solution for the "how do we know
1445 it's safe to delete something others may have handles to?"
1446 problem, what we'll do here is just uninsert the bp_finish, and
1447 let finish_command delete it.
1449 (We know the bp_finish is "doomed" in the sense that it's
1450 momentary, and will be deleted as soon as finish_command sees
1451 the inferior stopped. So it doesn't matter that the bp's
1452 address is probably bogus in the new a.out, unlike e.g., the
1453 solib breakpoints.) */
1455 if (b
->type
== bp_finish
)
1460 /* Without a symbolic address, we have little hope of the
1461 pre-exec() address meaning the same thing in the post-exec()
1463 if (b
->addr_string
== NULL
)
1465 delete_breakpoint (b
);
1469 /* FIXME what about longjmp breakpoints? Re-create them here? */
1470 create_overlay_event_breakpoint ("_ovly_debug_event");
1474 detach_breakpoints (int pid
)
1476 struct bp_location
*b
;
1478 struct cleanup
*old_chain
= save_inferior_ptid ();
1480 if (pid
== PIDGET (inferior_ptid
))
1481 error (_("Cannot detach breakpoints of inferior_ptid"));
1483 /* Set inferior_ptid; remove_breakpoint uses this global. */
1484 inferior_ptid
= pid_to_ptid (pid
);
1485 ALL_BP_LOCATIONS (b
)
1489 val
= remove_breakpoint (b
, mark_inserted
);
1492 do_cleanups (old_chain
);
1497 do_cleanups (old_chain
);
1502 remove_breakpoint (struct bp_location
*b
, insertion_state_t is
)
1506 if (b
->owner
->enable_state
== bp_permanent
)
1507 /* Permanent breakpoints cannot be inserted or removed. */
1510 if (b
->owner
->type
== bp_none
)
1511 warning (_("attempted to remove apparently deleted breakpoint #%d?"),
1514 if (b
->loc_type
== bp_loc_software_breakpoint
1515 || b
->loc_type
== bp_loc_hardware_breakpoint
)
1517 /* "Normal" instruction breakpoint: either the standard
1518 trap-instruction bp (bp_breakpoint), or a
1519 bp_hardware_breakpoint. */
1521 /* First check to see if we have to handle an overlay. */
1522 if (overlay_debugging
== ovly_off
1523 || b
->section
== NULL
1524 || !(section_is_overlay (b
->section
)))
1526 /* No overlay handling: just remove the breakpoint. */
1528 if (b
->loc_type
== bp_loc_hardware_breakpoint
)
1529 val
= target_remove_hw_breakpoint (&b
->target_info
);
1531 val
= target_remove_breakpoint (&b
->target_info
);
1535 /* This breakpoint is in an overlay section.
1536 Did we set a breakpoint at the LMA? */
1537 if (!overlay_events_enabled
)
1539 /* Yes -- overlay event support is not active, so we
1540 should have set a breakpoint at the LMA. Remove it.
1542 /* Ignore any failures: if the LMA is in ROM, we will
1543 have already warned when we failed to insert it. */
1544 if (b
->loc_type
== bp_loc_hardware_breakpoint
)
1545 target_remove_hw_breakpoint (&b
->overlay_target_info
);
1547 target_remove_breakpoint (&b
->overlay_target_info
);
1549 /* Did we set a breakpoint at the VMA?
1550 If so, we will have marked the breakpoint 'inserted'. */
1553 /* Yes -- remove it. Previously we did not bother to
1554 remove the breakpoint if the section had been
1555 unmapped, but let's not rely on that being safe. We
1556 don't know what the overlay manager might do. */
1557 if (b
->loc_type
== bp_loc_hardware_breakpoint
)
1558 val
= target_remove_hw_breakpoint (&b
->target_info
);
1560 /* However, we should remove *software* breakpoints only
1561 if the section is still mapped, or else we overwrite
1562 wrong code with the saved shadow contents. */
1563 else if (section_is_mapped (b
->section
))
1564 val
= target_remove_breakpoint (&b
->target_info
);
1570 /* No -- not inserted, so no need to remove. No error. */
1576 b
->inserted
= (is
== mark_inserted
);
1578 else if (b
->loc_type
== bp_loc_hardware_watchpoint
)
1583 b
->inserted
= (is
== mark_inserted
);
1584 val
= target_remove_watchpoint (b
->address
, b
->length
,
1585 b
->watchpoint_type
);
1587 /* Failure to remove any of the hardware watchpoints comes here. */
1588 if ((is
== mark_uninserted
) && (b
->inserted
))
1589 warning (_("Could not remove hardware watchpoint %d."),
1592 else if ((b
->owner
->type
== bp_catch_fork
||
1593 b
->owner
->type
== bp_catch_vfork
||
1594 b
->owner
->type
== bp_catch_exec
)
1595 && breakpoint_enabled (b
->owner
)
1599 switch (b
->owner
->type
)
1602 val
= target_remove_fork_catchpoint (PIDGET (inferior_ptid
));
1604 case bp_catch_vfork
:
1605 val
= target_remove_vfork_catchpoint (PIDGET (inferior_ptid
));
1608 val
= target_remove_exec_catchpoint (PIDGET (inferior_ptid
));
1611 warning (_("Internal error, %s line %d."), __FILE__
, __LINE__
);
1616 b
->inserted
= (is
== mark_inserted
);
1622 /* Clear the "inserted" flag in all breakpoints. */
1625 mark_breakpoints_out (void)
1627 struct bp_location
*bpt
;
1629 ALL_BP_LOCATIONS (bpt
)
1633 /* Clear the "inserted" flag in all breakpoints and delete any
1634 breakpoints which should go away between runs of the program.
1636 Plus other such housekeeping that has to be done for breakpoints
1639 Note: this function gets called at the end of a run (by
1640 generic_mourn_inferior) and when a run begins (by
1641 init_wait_for_inferior). */
1646 breakpoint_init_inferior (enum inf_context context
)
1648 struct breakpoint
*b
, *temp
;
1649 struct bp_location
*bpt
;
1651 ALL_BP_LOCATIONS (bpt
)
1654 ALL_BREAKPOINTS_SAFE (b
, temp
)
1659 case bp_watchpoint_scope
:
1661 /* If the call dummy breakpoint is at the entry point it will
1662 cause problems when the inferior is rerun, so we better
1665 Also get rid of scope breakpoints. */
1666 delete_breakpoint (b
);
1670 case bp_hardware_watchpoint
:
1671 case bp_read_watchpoint
:
1672 case bp_access_watchpoint
:
1674 /* Likewise for watchpoints on local expressions. */
1675 if (b
->exp_valid_block
!= NULL
)
1676 delete_breakpoint (b
);
1677 else if (context
== inf_starting
)
1679 /* Reset val field to force reread of starting value
1680 in insert_breakpoints. */
1682 value_free (b
->val
);
1692 /* breakpoint_here_p (PC) returns non-zero if an enabled breakpoint
1693 exists at PC. It returns ordinary_breakpoint_here if it's an
1694 ordinary breakpoint, or permanent_breakpoint_here if it's a
1695 permanent breakpoint.
1696 - When continuing from a location with an ordinary breakpoint, we
1697 actually single step once before calling insert_breakpoints.
1698 - When continuing from a localion with a permanent breakpoint, we
1699 need to use the `SKIP_PERMANENT_BREAKPOINT' macro, provided by
1700 the target, to advance the PC past the breakpoint. */
1702 enum breakpoint_here
1703 breakpoint_here_p (CORE_ADDR pc
)
1705 const struct bp_location
*bpt
;
1706 int any_breakpoint_here
= 0;
1708 ALL_BP_LOCATIONS (bpt
)
1710 if (bpt
->loc_type
!= bp_loc_software_breakpoint
1711 && bpt
->loc_type
!= bp_loc_hardware_breakpoint
)
1714 if ((breakpoint_enabled (bpt
->owner
)
1715 || bpt
->owner
->enable_state
== bp_permanent
)
1716 && bpt
->address
== pc
) /* bp is enabled and matches pc */
1718 if (overlay_debugging
1719 && section_is_overlay (bpt
->section
)
1720 && !section_is_mapped (bpt
->section
))
1721 continue; /* unmapped overlay -- can't be a match */
1722 else if (bpt
->owner
->enable_state
== bp_permanent
)
1723 return permanent_breakpoint_here
;
1725 any_breakpoint_here
= 1;
1729 return any_breakpoint_here
? ordinary_breakpoint_here
: 0;
1733 /* Returns non-zero if there's a breakpoint inserted at PC, which is
1734 inserted using regular breakpoint_chain/bp_location_chain mechanism.
1735 This does not check for single-step breakpoints, which are
1736 inserted and removed using direct target manipulation. */
1739 regular_breakpoint_inserted_here_p (CORE_ADDR pc
)
1741 const struct bp_location
*bpt
;
1743 ALL_BP_LOCATIONS (bpt
)
1745 if (bpt
->loc_type
!= bp_loc_software_breakpoint
1746 && bpt
->loc_type
!= bp_loc_hardware_breakpoint
)
1750 && bpt
->address
== pc
) /* bp is inserted and matches pc */
1752 if (overlay_debugging
1753 && section_is_overlay (bpt
->section
)
1754 && !section_is_mapped (bpt
->section
))
1755 continue; /* unmapped overlay -- can't be a match */
1763 /* Returns non-zero iff there's either regular breakpoint
1764 or a single step breakpoint inserted at PC. */
1767 breakpoint_inserted_here_p (CORE_ADDR pc
)
1769 if (regular_breakpoint_inserted_here_p (pc
))
1772 if (single_step_breakpoint_inserted_here_p (pc
))
1778 /* This function returns non-zero iff there is a software breakpoint
1782 software_breakpoint_inserted_here_p (CORE_ADDR pc
)
1784 const struct bp_location
*bpt
;
1785 int any_breakpoint_here
= 0;
1787 ALL_BP_LOCATIONS (bpt
)
1789 if (bpt
->loc_type
!= bp_loc_software_breakpoint
)
1793 && bpt
->address
== pc
) /* bp is enabled and matches pc */
1795 if (overlay_debugging
1796 && section_is_overlay (bpt
->section
)
1797 && !section_is_mapped (bpt
->section
))
1798 continue; /* unmapped overlay -- can't be a match */
1804 /* Also check for software single-step breakpoints. */
1805 if (single_step_breakpoint_inserted_here_p (pc
))
1811 /* breakpoint_thread_match (PC, PTID) returns true if the breakpoint at
1812 PC is valid for process/thread PTID. */
1815 breakpoint_thread_match (CORE_ADDR pc
, ptid_t ptid
)
1817 const struct bp_location
*bpt
;
1820 thread
= pid_to_thread_id (ptid
);
1822 ALL_BP_LOCATIONS (bpt
)
1824 if (bpt
->loc_type
!= bp_loc_software_breakpoint
1825 && bpt
->loc_type
!= bp_loc_hardware_breakpoint
)
1828 if ((breakpoint_enabled (bpt
->owner
)
1829 || bpt
->owner
->enable_state
== bp_permanent
)
1830 && bpt
->address
== pc
1831 && (bpt
->owner
->thread
== -1 || bpt
->owner
->thread
== thread
))
1833 if (overlay_debugging
1834 && section_is_overlay (bpt
->section
)
1835 && !section_is_mapped (bpt
->section
))
1836 continue; /* unmapped overlay -- can't be a match */
1846 /* bpstat stuff. External routines' interfaces are documented
1850 ep_is_catchpoint (struct breakpoint
*ep
)
1853 (ep
->type
== bp_catch_load
)
1854 || (ep
->type
== bp_catch_unload
)
1855 || (ep
->type
== bp_catch_fork
)
1856 || (ep
->type
== bp_catch_vfork
)
1857 || (ep
->type
== bp_catch_exec
);
1859 /* ??rehrauer: Add more kinds here, as are implemented... */
1863 ep_is_shlib_catchpoint (struct breakpoint
*ep
)
1866 (ep
->type
== bp_catch_load
)
1867 || (ep
->type
== bp_catch_unload
);
1871 bpstat_free (bpstat bs
)
1873 if (bs
->old_val
!= NULL
)
1874 value_free (bs
->old_val
);
1875 free_command_lines (&bs
->commands
);
1879 /* Clear a bpstat so that it says we are not at any breakpoint.
1880 Also free any storage that is part of a bpstat. */
1883 bpstat_clear (bpstat
*bsp
)
1900 /* Return a copy of a bpstat. Like "bs1 = bs2" but all storage that
1901 is part of the bpstat is copied as well. */
1904 bpstat_copy (bpstat bs
)
1908 bpstat retval
= NULL
;
1913 for (; bs
!= NULL
; bs
= bs
->next
)
1915 tmp
= (bpstat
) xmalloc (sizeof (*tmp
));
1916 memcpy (tmp
, bs
, sizeof (*tmp
));
1917 if (bs
->commands
!= NULL
)
1918 tmp
->commands
= copy_command_lines (bs
->commands
);
1919 if (bs
->old_val
!= NULL
)
1920 tmp
->old_val
= value_copy (bs
->old_val
);
1923 /* This is the first thing in the chain. */
1933 /* Find the bpstat associated with this breakpoint */
1936 bpstat_find_breakpoint (bpstat bsp
, struct breakpoint
*breakpoint
)
1941 for (; bsp
!= NULL
; bsp
= bsp
->next
)
1943 if (bsp
->breakpoint_at
&& bsp
->breakpoint_at
->owner
== breakpoint
)
1949 /* Find a step_resume breakpoint associated with this bpstat.
1950 (If there are multiple step_resume bp's on the list, this function
1951 will arbitrarily pick one.)
1953 It is an error to use this function if BPSTAT doesn't contain a
1954 step_resume breakpoint.
1956 See wait_for_inferior's use of this function. */
1958 bpstat_find_step_resume_breakpoint (bpstat bsp
)
1962 gdb_assert (bsp
!= NULL
);
1964 current_thread
= pid_to_thread_id (inferior_ptid
);
1966 for (; bsp
!= NULL
; bsp
= bsp
->next
)
1968 if ((bsp
->breakpoint_at
!= NULL
) &&
1969 (bsp
->breakpoint_at
->owner
->type
== bp_step_resume
) &&
1970 (bsp
->breakpoint_at
->owner
->thread
== current_thread
||
1971 bsp
->breakpoint_at
->owner
->thread
== -1))
1972 return bsp
->breakpoint_at
->owner
;
1975 internal_error (__FILE__
, __LINE__
, _("No step_resume breakpoint found."));
1979 /* Put in *NUM the breakpoint number of the first breakpoint we are stopped
1980 at. *BSP upon return is a bpstat which points to the remaining
1981 breakpoints stopped at (but which is not guaranteed to be good for
1982 anything but further calls to bpstat_num).
1983 Return 0 if passed a bpstat which does not indicate any breakpoints.
1984 Return -1 if stopped at a breakpoint that has been deleted since
1986 Return 1 otherwise. */
1989 bpstat_num (bpstat
*bsp
, int *num
)
1991 struct breakpoint
*b
;
1994 return 0; /* No more breakpoint values */
1996 /* We assume we'll never have several bpstats that
1997 correspond to a single breakpoint -- otherwise,
1998 this function might return the same number more
1999 than once and this will look ugly. */
2000 b
= (*bsp
)->breakpoint_at
? (*bsp
)->breakpoint_at
->owner
: NULL
;
2001 *bsp
= (*bsp
)->next
;
2003 return -1; /* breakpoint that's been deleted since */
2005 *num
= b
->number
; /* We have its number */
2009 /* Modify BS so that the actions will not be performed. */
2012 bpstat_clear_actions (bpstat bs
)
2014 for (; bs
!= NULL
; bs
= bs
->next
)
2016 free_command_lines (&bs
->commands
);
2017 if (bs
->old_val
!= NULL
)
2019 value_free (bs
->old_val
);
2025 /* Stub for cleaning up our state if we error-out of a breakpoint command */
2027 cleanup_executing_breakpoints (void *ignore
)
2029 executing_breakpoint_commands
= 0;
2032 /* Execute all the commands associated with all the breakpoints at this
2033 location. Any of these commands could cause the process to proceed
2034 beyond this point, etc. We look out for such changes by checking
2035 the global "breakpoint_proceeded" after each command. */
2038 bpstat_do_actions (bpstat
*bsp
)
2041 struct cleanup
*old_chain
;
2043 /* Avoid endless recursion if a `source' command is contained
2045 if (executing_breakpoint_commands
)
2048 executing_breakpoint_commands
= 1;
2049 old_chain
= make_cleanup (cleanup_executing_breakpoints
, 0);
2052 /* Note that (as of this writing), our callers all appear to
2053 be passing us the address of global stop_bpstat. And, if
2054 our calls to execute_control_command cause the inferior to
2055 proceed, that global (and hence, *bsp) will change.
2057 We must be careful to not touch *bsp unless the inferior
2058 has not proceeded. */
2060 /* This pointer will iterate over the list of bpstat's. */
2063 breakpoint_proceeded
= 0;
2064 for (; bs
!= NULL
; bs
= bs
->next
)
2066 struct command_line
*cmd
;
2067 struct cleanup
*this_cmd_tree_chain
;
2069 /* Take ownership of the BSP's command tree, if it has one.
2071 The command tree could legitimately contain commands like
2072 'step' and 'next', which call clear_proceed_status, which
2073 frees stop_bpstat's command tree. To make sure this doesn't
2074 free the tree we're executing out from under us, we need to
2075 take ownership of the tree ourselves. Since a given bpstat's
2076 commands are only executed once, we don't need to copy it; we
2077 can clear the pointer in the bpstat, and make sure we free
2078 the tree when we're done. */
2081 this_cmd_tree_chain
= make_cleanup_free_command_lines (&cmd
);
2085 execute_control_command (cmd
);
2087 if (breakpoint_proceeded
)
2093 /* We can free this command tree now. */
2094 do_cleanups (this_cmd_tree_chain
);
2096 if (breakpoint_proceeded
)
2097 /* The inferior is proceeded by the command; bomb out now.
2098 The bpstat chain has been blown away by wait_for_inferior.
2099 But since execution has stopped again, there is a new bpstat
2100 to look at, so start over. */
2103 do_cleanups (old_chain
);
2106 /* This is the normal print function for a bpstat. In the future,
2107 much of this logic could (should?) be moved to bpstat_stop_status,
2108 by having it set different print_it values.
2110 Current scheme: When we stop, bpstat_print() is called. It loops
2111 through the bpstat list of things causing this stop, calling the
2112 print_bp_stop_message function on each one. The behavior of the
2113 print_bp_stop_message function depends on the print_it field of
2114 bpstat. If such field so indicates, call this function here.
2116 Return values from this routine (ultimately used by bpstat_print()
2117 and normal_stop() to decide what to do):
2118 PRINT_NOTHING: Means we already printed all we needed to print,
2119 don't print anything else.
2120 PRINT_SRC_ONLY: Means we printed something, and we do *not* desire
2121 that something to be followed by a location.
2122 PRINT_SCR_AND_LOC: Means we printed something, and we *do* desire
2123 that something to be followed by a location.
2124 PRINT_UNKNOWN: Means we printed nothing or we need to do some more
2127 static enum print_stop_action
2128 print_it_typical (bpstat bs
)
2130 struct cleanup
*old_chain
, *ui_out_chain
;
2131 struct breakpoint
*b
;
2132 const struct bp_location
*bl
;
2133 struct ui_stream
*stb
;
2134 stb
= ui_out_stream_new (uiout
);
2135 old_chain
= make_cleanup_ui_out_stream_delete (stb
);
2136 /* bs->breakpoint_at can be NULL if it was a momentary breakpoint
2137 which has since been deleted. */
2138 if (bs
->breakpoint_at
== NULL
)
2139 return PRINT_UNKNOWN
;
2140 bl
= bs
->breakpoint_at
;
2146 case bp_hardware_breakpoint
:
2147 if (bl
->address
!= bl
->requested_address
)
2148 breakpoint_adjustment_warning (bl
->requested_address
,
2151 annotate_breakpoint (b
->number
);
2152 ui_out_text (uiout
, "\nBreakpoint ");
2153 if (ui_out_is_mi_like_p (uiout
))
2154 ui_out_field_string (uiout
, "reason",
2155 async_reason_lookup (EXEC_ASYNC_BREAKPOINT_HIT
));
2156 ui_out_field_int (uiout
, "bkptno", b
->number
);
2157 ui_out_text (uiout
, ", ");
2158 return PRINT_SRC_AND_LOC
;
2161 case bp_shlib_event
:
2162 /* Did we stop because the user set the stop_on_solib_events
2163 variable? (If so, we report this as a generic, "Stopped due
2164 to shlib event" message.) */
2165 printf_filtered (_("Stopped due to shared library event\n"));
2166 return PRINT_NOTHING
;
2169 case bp_thread_event
:
2170 /* Not sure how we will get here.
2171 GDB should not stop for these breakpoints. */
2172 printf_filtered (_("Thread Event Breakpoint: gdb should not stop!\n"));
2173 return PRINT_NOTHING
;
2176 case bp_overlay_event
:
2177 /* By analogy with the thread event, GDB should not stop for these. */
2178 printf_filtered (_("Overlay Event Breakpoint: gdb should not stop!\n"));
2179 return PRINT_NOTHING
;
2183 annotate_catchpoint (b
->number
);
2184 printf_filtered (_("\nCatchpoint %d (loaded %s), "),
2186 b
->triggered_dll_pathname
);
2187 return PRINT_SRC_AND_LOC
;
2190 case bp_catch_unload
:
2191 annotate_catchpoint (b
->number
);
2192 printf_filtered (_("\nCatchpoint %d (unloaded %s), "),
2194 b
->triggered_dll_pathname
);
2195 return PRINT_SRC_AND_LOC
;
2199 annotate_catchpoint (b
->number
);
2200 printf_filtered (_("\nCatchpoint %d (forked process %d), "),
2202 b
->forked_inferior_pid
);
2203 return PRINT_SRC_AND_LOC
;
2206 case bp_catch_vfork
:
2207 annotate_catchpoint (b
->number
);
2208 printf_filtered (_("\nCatchpoint %d (vforked process %d), "),
2210 b
->forked_inferior_pid
);
2211 return PRINT_SRC_AND_LOC
;
2215 annotate_catchpoint (b
->number
);
2216 printf_filtered (_("\nCatchpoint %d (exec'd %s), "),
2219 return PRINT_SRC_AND_LOC
;
2223 case bp_hardware_watchpoint
:
2224 if (bs
->old_val
!= NULL
)
2226 annotate_watchpoint (b
->number
);
2227 if (ui_out_is_mi_like_p (uiout
))
2230 async_reason_lookup (EXEC_ASYNC_WATCHPOINT_TRIGGER
));
2232 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "value");
2233 ui_out_text (uiout
, "\nOld value = ");
2234 value_print (bs
->old_val
, stb
->stream
, 0, Val_pretty_default
);
2235 ui_out_field_stream (uiout
, "old", stb
);
2236 ui_out_text (uiout
, "\nNew value = ");
2237 value_print (b
->val
, stb
->stream
, 0, Val_pretty_default
);
2238 ui_out_field_stream (uiout
, "new", stb
);
2239 do_cleanups (ui_out_chain
);
2240 ui_out_text (uiout
, "\n");
2241 value_free (bs
->old_val
);
2244 /* More than one watchpoint may have been triggered. */
2245 return PRINT_UNKNOWN
;
2248 case bp_read_watchpoint
:
2249 if (ui_out_is_mi_like_p (uiout
))
2252 async_reason_lookup (EXEC_ASYNC_READ_WATCHPOINT_TRIGGER
));
2254 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "value");
2255 ui_out_text (uiout
, "\nValue = ");
2256 value_print (b
->val
, stb
->stream
, 0, Val_pretty_default
);
2257 ui_out_field_stream (uiout
, "value", stb
);
2258 do_cleanups (ui_out_chain
);
2259 ui_out_text (uiout
, "\n");
2260 return PRINT_UNKNOWN
;
2263 case bp_access_watchpoint
:
2264 if (bs
->old_val
!= NULL
)
2266 annotate_watchpoint (b
->number
);
2267 if (ui_out_is_mi_like_p (uiout
))
2270 async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER
));
2272 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "value");
2273 ui_out_text (uiout
, "\nOld value = ");
2274 value_print (bs
->old_val
, stb
->stream
, 0, Val_pretty_default
);
2275 ui_out_field_stream (uiout
, "old", stb
);
2276 value_free (bs
->old_val
);
2278 ui_out_text (uiout
, "\nNew value = ");
2283 if (ui_out_is_mi_like_p (uiout
))
2286 async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER
));
2287 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "value");
2288 ui_out_text (uiout
, "\nValue = ");
2290 value_print (b
->val
, stb
->stream
, 0,Val_pretty_default
);
2291 ui_out_field_stream (uiout
, "new", stb
);
2292 do_cleanups (ui_out_chain
);
2293 ui_out_text (uiout
, "\n");
2294 return PRINT_UNKNOWN
;
2297 /* Fall through, we don't deal with these types of breakpoints
2301 if (ui_out_is_mi_like_p (uiout
))
2304 async_reason_lookup (EXEC_ASYNC_FUNCTION_FINISHED
));
2305 return PRINT_UNKNOWN
;
2309 if (ui_out_is_mi_like_p (uiout
))
2312 async_reason_lookup (EXEC_ASYNC_LOCATION_REACHED
));
2313 return PRINT_UNKNOWN
;
2318 case bp_longjmp_resume
:
2319 case bp_step_resume
:
2320 case bp_watchpoint_scope
:
2323 return PRINT_UNKNOWN
;
2327 /* Generic routine for printing messages indicating why we
2328 stopped. The behavior of this function depends on the value
2329 'print_it' in the bpstat structure. Under some circumstances we
2330 may decide not to print anything here and delegate the task to
2333 static enum print_stop_action
2334 print_bp_stop_message (bpstat bs
)
2336 switch (bs
->print_it
)
2339 /* Nothing should be printed for this bpstat entry. */
2340 return PRINT_UNKNOWN
;
2344 /* We still want to print the frame, but we already printed the
2345 relevant messages. */
2346 return PRINT_SRC_AND_LOC
;
2349 case print_it_normal
:
2351 const struct bp_location
*bl
= bs
->breakpoint_at
;
2352 struct breakpoint
*b
= bl
? bl
->owner
: NULL
;
2354 /* Normal case. Call the breakpoint's print_it method, or
2355 print_it_typical. */
2356 /* FIXME: how breakpoint can ever be NULL here? */
2357 if (b
!= NULL
&& b
->ops
!= NULL
&& b
->ops
->print_it
!= NULL
)
2358 return b
->ops
->print_it (b
);
2360 return print_it_typical (bs
);
2365 internal_error (__FILE__
, __LINE__
,
2366 _("print_bp_stop_message: unrecognized enum value"));
2371 /* Print a message indicating what happened. This is called from
2372 normal_stop(). The input to this routine is the head of the bpstat
2373 list - a list of the eventpoints that caused this stop. This
2374 routine calls the generic print routine for printing a message
2375 about reasons for stopping. This will print (for example) the
2376 "Breakpoint n," part of the output. The return value of this
2379 PRINT_UNKNOWN: Means we printed nothing
2380 PRINT_SRC_AND_LOC: Means we printed something, and expect subsequent
2381 code to print the location. An example is
2382 "Breakpoint 1, " which should be followed by
2384 PRINT_SRC_ONLY: Means we printed something, but there is no need
2385 to also print the location part of the message.
2386 An example is the catch/throw messages, which
2387 don't require a location appended to the end.
2388 PRINT_NOTHING: We have done some printing and we don't need any
2389 further info to be printed.*/
2391 enum print_stop_action
2392 bpstat_print (bpstat bs
)
2396 /* Maybe another breakpoint in the chain caused us to stop.
2397 (Currently all watchpoints go on the bpstat whether hit or not.
2398 That probably could (should) be changed, provided care is taken
2399 with respect to bpstat_explains_signal). */
2400 for (; bs
; bs
= bs
->next
)
2402 val
= print_bp_stop_message (bs
);
2403 if (val
== PRINT_SRC_ONLY
2404 || val
== PRINT_SRC_AND_LOC
2405 || val
== PRINT_NOTHING
)
2409 /* We reached the end of the chain, or we got a null BS to start
2410 with and nothing was printed. */
2411 return PRINT_UNKNOWN
;
2414 /* Evaluate the expression EXP and return 1 if value is zero.
2415 This is used inside a catch_errors to evaluate the breakpoint condition.
2416 The argument is a "struct expression *" that has been cast to char * to
2417 make it pass through catch_errors. */
2420 breakpoint_cond_eval (void *exp
)
2422 struct value
*mark
= value_mark ();
2423 int i
= !value_true (evaluate_expression ((struct expression
*) exp
));
2424 value_free_to_mark (mark
);
2428 /* Allocate a new bpstat and chain it to the current one. */
2431 bpstat_alloc (const struct bp_location
*bl
, bpstat cbs
/* Current "bs" value */ )
2435 bs
= (bpstat
) xmalloc (sizeof (*bs
));
2437 bs
->breakpoint_at
= bl
;
2438 /* If the condition is false, etc., don't do the commands. */
2439 bs
->commands
= NULL
;
2441 bs
->print_it
= print_it_normal
;
2445 /* The target has stopped with waitstatus WS. Check if any hardware
2446 watchpoints have triggered, according to the target. */
2449 watchpoints_triggered (struct target_waitstatus
*ws
)
2451 int stopped_by_watchpoint
= STOPPED_BY_WATCHPOINT (*ws
);
2453 struct breakpoint
*b
;
2455 if (!stopped_by_watchpoint
)
2457 /* We were not stopped by a watchpoint. Mark all watchpoints
2458 as not triggered. */
2460 if (b
->type
== bp_hardware_watchpoint
2461 || b
->type
== bp_read_watchpoint
2462 || b
->type
== bp_access_watchpoint
)
2463 b
->watchpoint_triggered
= watch_triggered_no
;
2468 if (!target_stopped_data_address (¤t_target
, &addr
))
2470 /* We were stopped by a watchpoint, but we don't know where.
2471 Mark all watchpoints as unknown. */
2473 if (b
->type
== bp_hardware_watchpoint
2474 || b
->type
== bp_read_watchpoint
2475 || b
->type
== bp_access_watchpoint
)
2476 b
->watchpoint_triggered
= watch_triggered_unknown
;
2478 return stopped_by_watchpoint
;
2481 /* The target could report the data address. Mark watchpoints
2482 affected by this data address as triggered, and all others as not
2486 if (b
->type
== bp_hardware_watchpoint
2487 || b
->type
== bp_read_watchpoint
2488 || b
->type
== bp_access_watchpoint
)
2490 struct bp_location
*loc
;
2493 b
->watchpoint_triggered
= watch_triggered_no
;
2494 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
2495 /* Exact match not required. Within range is
2497 if (addr
>= loc
->address
2498 && addr
< loc
->address
+ loc
->length
)
2500 b
->watchpoint_triggered
= watch_triggered_yes
;
2508 /* Possible return values for watchpoint_check (this can't be an enum
2509 because of check_errors). */
2510 /* The watchpoint has been deleted. */
2511 #define WP_DELETED 1
2512 /* The value has changed. */
2513 #define WP_VALUE_CHANGED 2
2514 /* The value has not changed. */
2515 #define WP_VALUE_NOT_CHANGED 3
2517 #define BP_TEMPFLAG 1
2518 #define BP_HARDWAREFLAG 2
2520 /* Check watchpoint condition. */
2523 watchpoint_check (void *p
)
2525 bpstat bs
= (bpstat
) p
;
2526 struct breakpoint
*b
;
2527 struct frame_info
*fr
;
2528 int within_current_scope
;
2530 b
= bs
->breakpoint_at
->owner
;
2532 if (b
->exp_valid_block
== NULL
)
2533 within_current_scope
= 1;
2536 /* There is no current frame at this moment. If we're going to have
2537 any chance of handling watchpoints on local variables, we'll need
2538 the frame chain (so we can determine if we're in scope). */
2539 reinit_frame_cache ();
2540 fr
= frame_find_by_id (b
->watchpoint_frame
);
2541 within_current_scope
= (fr
!= NULL
);
2543 /* If we've gotten confused in the unwinder, we might have
2544 returned a frame that can't describe this variable. */
2545 if (within_current_scope
2546 && block_function (b
->exp_valid_block
) != get_frame_function (fr
))
2547 within_current_scope
= 0;
2549 /* in_function_epilogue_p() returns a non-zero value if we're still
2550 in the function but the stack frame has already been invalidated.
2551 Since we can't rely on the values of local variables after the
2552 stack has been destroyed, we are treating the watchpoint in that
2553 state as `not changed' without further checking.
2555 vinschen/2003-09-04: The former implementation left out the case
2556 that the watchpoint frame couldn't be found by frame_find_by_id()
2557 because the current PC is currently in an epilogue. Calling
2558 gdbarch_in_function_epilogue_p() also when fr == NULL fixes that. */
2559 if ((!within_current_scope
|| fr
== get_current_frame ())
2560 && gdbarch_in_function_epilogue_p (current_gdbarch
, read_pc ()))
2561 return WP_VALUE_NOT_CHANGED
;
2562 if (fr
&& within_current_scope
)
2563 /* If we end up stopping, the current frame will get selected
2564 in normal_stop. So this call to select_frame won't affect
2569 if (within_current_scope
)
2571 /* We use value_{,free_to_}mark because it could be a
2572 *long* time before we return to the command level and
2573 call free_all_values. We can't call free_all_values because
2574 we might be in the middle of evaluating a function call. */
2576 struct value
*mark
= value_mark ();
2577 struct value
*new_val
= evaluate_expression (b
->exp
);
2578 if (!value_equal (b
->val
, new_val
))
2580 release_value (new_val
);
2581 value_free_to_mark (mark
);
2582 bs
->old_val
= b
->val
;
2584 /* We will stop here */
2585 return WP_VALUE_CHANGED
;
2589 /* Nothing changed, don't do anything. */
2590 value_free_to_mark (mark
);
2591 /* We won't stop here */
2592 return WP_VALUE_NOT_CHANGED
;
2597 /* This seems like the only logical thing to do because
2598 if we temporarily ignored the watchpoint, then when
2599 we reenter the block in which it is valid it contains
2600 garbage (in the case of a function, it may have two
2601 garbage values, one before and one after the prologue).
2602 So we can't even detect the first assignment to it and
2603 watch after that (since the garbage may or may not equal
2604 the first value assigned). */
2605 /* We print all the stop information in print_it_typical(), but
2606 in this case, by the time we call print_it_typical() this bp
2607 will be deleted already. So we have no choice but print the
2608 information here. */
2609 if (ui_out_is_mi_like_p (uiout
))
2611 (uiout
, "reason", async_reason_lookup (EXEC_ASYNC_WATCHPOINT_SCOPE
));
2612 ui_out_text (uiout
, "\nWatchpoint ");
2613 ui_out_field_int (uiout
, "wpnum", b
->number
);
2614 ui_out_text (uiout
, " deleted because the program has left the block in\n\
2615 which its expression is valid.\n");
2617 if (b
->related_breakpoint
)
2618 b
->related_breakpoint
->disposition
= disp_del_at_next_stop
;
2619 b
->disposition
= disp_del_at_next_stop
;
2625 /* Get a bpstat associated with having just stopped at address
2626 BP_ADDR in thread PTID.
2628 Determine whether we stopped at a breakpoint, etc, or whether we
2629 don't understand this stop. Result is a chain of bpstat's such that:
2631 if we don't understand the stop, the result is a null pointer.
2633 if we understand why we stopped, the result is not null.
2635 Each element of the chain refers to a particular breakpoint or
2636 watchpoint at which we have stopped. (We may have stopped for
2637 several reasons concurrently.)
2639 Each element of the chain has valid next, breakpoint_at,
2640 commands, FIXME??? fields. */
2643 bpstat_stop_status (CORE_ADDR bp_addr
, ptid_t ptid
)
2645 struct breakpoint
*b
= NULL
;
2646 const struct bp_location
*bl
;
2647 /* Root of the chain of bpstat's */
2648 struct bpstats root_bs
[1];
2649 /* Pointer to the last thing in the chain currently. */
2650 bpstat bs
= root_bs
;
2651 int thread_id
= pid_to_thread_id (ptid
);
2653 ALL_BP_LOCATIONS (bl
)
2657 if (!breakpoint_enabled (b
) && b
->enable_state
!= bp_permanent
)
2660 if (b
->type
!= bp_watchpoint
2661 && b
->type
!= bp_hardware_watchpoint
2662 && b
->type
!= bp_read_watchpoint
2663 && b
->type
!= bp_access_watchpoint
2664 && b
->type
!= bp_hardware_breakpoint
2665 && b
->type
!= bp_catch_fork
2666 && b
->type
!= bp_catch_vfork
2667 && b
->type
!= bp_catch_exec
) /* a non-watchpoint bp */
2669 if (bl
->address
!= bp_addr
) /* address doesn't match */
2671 if (overlay_debugging
/* unmapped overlay section */
2672 && section_is_overlay (bl
->section
)
2673 && !section_is_mapped (bl
->section
))
2677 /* Continuable hardware watchpoints are treated as non-existent if the
2678 reason we stopped wasn't a hardware watchpoint (we didn't stop on
2679 some data address). Otherwise gdb won't stop on a break instruction
2680 in the code (not from a breakpoint) when a hardware watchpoint has
2681 been defined. Also skip watchpoints which we know did not trigger
2682 (did not match the data address). */
2684 if ((b
->type
== bp_hardware_watchpoint
2685 || b
->type
== bp_read_watchpoint
2686 || b
->type
== bp_access_watchpoint
)
2687 && b
->watchpoint_triggered
== watch_triggered_no
)
2690 if (b
->type
== bp_hardware_breakpoint
)
2692 if (bl
->address
!= bp_addr
)
2694 if (overlay_debugging
/* unmapped overlay section */
2695 && section_is_overlay (bl
->section
)
2696 && !section_is_mapped (bl
->section
))
2700 /* Is this a catchpoint of a load or unload? If so, did we
2701 get a load or unload of the specified library? If not,
2703 if ((b
->type
== bp_catch_load
)
2704 #if defined(SOLIB_HAVE_LOAD_EVENT)
2705 && (!SOLIB_HAVE_LOAD_EVENT (PIDGET (inferior_ptid
))
2706 || ((b
->dll_pathname
!= NULL
)
2707 && (strcmp (b
->dll_pathname
,
2708 SOLIB_LOADED_LIBRARY_PATHNAME (
2709 PIDGET (inferior_ptid
)))
2715 if ((b
->type
== bp_catch_unload
)
2716 #if defined(SOLIB_HAVE_UNLOAD_EVENT)
2717 && (!SOLIB_HAVE_UNLOAD_EVENT (PIDGET (inferior_ptid
))
2718 || ((b
->dll_pathname
!= NULL
)
2719 && (strcmp (b
->dll_pathname
,
2720 SOLIB_UNLOADED_LIBRARY_PATHNAME (
2721 PIDGET (inferior_ptid
)))
2727 if ((b
->type
== bp_catch_fork
)
2728 && !inferior_has_forked (PIDGET (inferior_ptid
),
2729 &b
->forked_inferior_pid
))
2732 if ((b
->type
== bp_catch_vfork
)
2733 && !inferior_has_vforked (PIDGET (inferior_ptid
),
2734 &b
->forked_inferior_pid
))
2737 if ((b
->type
== bp_catch_exec
)
2738 && !inferior_has_execd (PIDGET (inferior_ptid
), &b
->exec_pathname
))
2741 /* For hardware watchpoints, we look only at the first location.
2742 The watchpoint_check function will work on entire expression,
2743 not the individual locations. For read watchopints, the
2744 watchpoints_triggered function have checked all locations
2747 if (b
->type
== bp_hardware_watchpoint
&& bl
!= b
->loc
)
2750 /* Come here if it's a watchpoint, or if the break address matches */
2752 bs
= bpstat_alloc (bl
, bs
); /* Alloc a bpstat to explain stop */
2754 /* Watchpoints may change this, if not found to have triggered. */
2758 if (b
->type
== bp_watchpoint
2759 || b
->type
== bp_read_watchpoint
2760 || b
->type
== bp_access_watchpoint
2761 || b
->type
== bp_hardware_watchpoint
)
2765 int must_check_value
= 0;
2767 if (b
->type
== bp_watchpoint
)
2768 /* For a software watchpoint, we must always check the
2770 must_check_value
= 1;
2771 else if (b
->watchpoint_triggered
== watch_triggered_yes
)
2772 /* We have a hardware watchpoint (read, write, or access)
2773 and the target earlier reported an address watched by
2775 must_check_value
= 1;
2776 else if (b
->watchpoint_triggered
== watch_triggered_unknown
2777 && b
->type
== bp_hardware_watchpoint
)
2778 /* We were stopped by a hardware watchpoint, but the target could
2779 not report the data address. We must check the watchpoint's
2780 value. Access and read watchpoints are out of luck; without
2781 a data address, we can't figure it out. */
2782 must_check_value
= 1;
2784 if (must_check_value
)
2786 char *message
= xstrprintf ("Error evaluating expression for watchpoint %d\n",
2788 struct cleanup
*cleanups
= make_cleanup (xfree
, message
);
2789 int e
= catch_errors (watchpoint_check
, bs
, message
,
2791 do_cleanups (cleanups
);
2795 /* We've already printed what needs to be printed. */
2796 bs
->print_it
= print_it_done
;
2799 case WP_VALUE_CHANGED
:
2800 if (b
->type
== bp_read_watchpoint
)
2802 /* Don't stop: read watchpoints shouldn't fire if
2803 the value has changed. This is for targets
2804 which cannot set read-only watchpoints. */
2805 bs
->print_it
= print_it_noop
;
2811 case WP_VALUE_NOT_CHANGED
:
2812 if (b
->type
== bp_hardware_watchpoint
2813 || b
->type
== bp_watchpoint
)
2815 /* Don't stop: write watchpoints shouldn't fire if
2816 the value hasn't changed. */
2817 bs
->print_it
= print_it_noop
;
2827 /* Error from catch_errors. */
2828 printf_filtered (_("Watchpoint %d deleted.\n"), b
->number
);
2829 if (b
->related_breakpoint
)
2830 b
->related_breakpoint
->disposition
= disp_del_at_next_stop
;
2831 b
->disposition
= disp_del_at_next_stop
;
2832 /* We've already printed what needs to be printed. */
2833 bs
->print_it
= print_it_done
;
2837 else /* must_check_value == 0 */
2839 /* This is a case where some watchpoint(s) triggered, but
2840 not at the address of this watchpoint, or else no
2841 watchpoint triggered after all. So don't print
2842 anything for this watchpoint. */
2843 bs
->print_it
= print_it_noop
;
2850 /* By definition, an encountered breakpoint is a triggered
2855 if (frame_id_p (b
->frame_id
)
2856 && !frame_id_eq (b
->frame_id
, get_frame_id (get_current_frame ())))
2860 int value_is_zero
= 0;
2862 /* If this is a scope breakpoint, mark the associated
2863 watchpoint as triggered so that we will handle the
2864 out-of-scope event. We'll get to the watchpoint next
2866 if (b
->type
== bp_watchpoint_scope
)
2867 b
->related_breakpoint
->watchpoint_triggered
= watch_triggered_yes
;
2869 if (bl
->cond
&& bl
->owner
->disposition
!= disp_del_at_next_stop
)
2871 /* Need to select the frame, with all that implies
2872 so that the conditions will have the right context. */
2873 select_frame (get_current_frame ());
2875 = catch_errors (breakpoint_cond_eval
, (bl
->cond
),
2876 "Error in testing breakpoint condition:\n",
2878 /* FIXME-someday, should give breakpoint # */
2881 if (bl
->cond
&& value_is_zero
)
2884 /* Don't consider this a hit. */
2887 else if (b
->thread
!= -1 && b
->thread
!= thread_id
)
2890 /* Don't consider this a hit. */
2893 else if (b
->ignore_count
> 0)
2896 annotate_ignore_count_change ();
2899 else if (b
->type
== bp_thread_event
|| b
->type
== bp_overlay_event
)
2900 /* We do not stop for these. */
2904 /* We will stop here */
2905 if (b
->disposition
== disp_disable
)
2906 b
->enable_state
= bp_disabled
;
2909 bs
->commands
= b
->commands
;
2911 (strcmp ("silent", bs
->commands
->line
) == 0
2912 || (xdb_commands
&& strcmp ("Q", bs
->commands
->line
) == 0)))
2914 bs
->commands
= bs
->commands
->next
;
2917 bs
->commands
= copy_command_lines (bs
->commands
);
2920 /* Print nothing for this entry if we dont stop or if we dont print. */
2921 if (bs
->stop
== 0 || bs
->print
== 0)
2922 bs
->print_it
= print_it_noop
;
2925 bs
->next
= NULL
; /* Terminate the chain */
2926 bs
= root_bs
->next
; /* Re-grab the head of the chain */
2928 /* If we aren't stopping, the value of some hardware watchpoint may
2929 not have changed, but the intermediate memory locations we are
2930 watching may have. Don't bother if we're stopping; this will get
2932 for (bs
= root_bs
->next
; bs
!= NULL
; bs
= bs
->next
)
2937 for (bs
= root_bs
->next
; bs
!= NULL
; bs
= bs
->next
)
2939 && (bs
->breakpoint_at
->owner
->type
== bp_hardware_watchpoint
2940 || bs
->breakpoint_at
->owner
->type
== bp_read_watchpoint
2941 || bs
->breakpoint_at
->owner
->type
== bp_access_watchpoint
))
2943 /* remove/insert can invalidate bs->breakpoint_at, if this
2944 location is no longer used by the watchpoint. Prevent
2945 further code from trying to use it. */
2946 bs
->breakpoint_at
= NULL
;
2947 remove_breakpoints ();
2948 insert_breakpoints ();
2952 return root_bs
->next
;
2955 /* Tell what to do about this bpstat. */
2957 bpstat_what (bpstat bs
)
2959 /* Classify each bpstat as one of the following. */
2962 /* This bpstat element has no effect on the main_action. */
2965 /* There was a watchpoint, stop but don't print. */
2968 /* There was a watchpoint, stop and print. */
2971 /* There was a breakpoint but we're not stopping. */
2974 /* There was a breakpoint, stop but don't print. */
2977 /* There was a breakpoint, stop and print. */
2980 /* We hit the longjmp breakpoint. */
2983 /* We hit the longjmp_resume breakpoint. */
2986 /* We hit the step_resume breakpoint. */
2989 /* We hit the shared library event breakpoint. */
2992 /* We caught a shared library event. */
2995 /* This is just used to count how many enums there are. */
2999 /* Here is the table which drives this routine. So that we can
3000 format it pretty, we define some abbreviations for the
3001 enum bpstat_what codes. */
3002 #define kc BPSTAT_WHAT_KEEP_CHECKING
3003 #define ss BPSTAT_WHAT_STOP_SILENT
3004 #define sn BPSTAT_WHAT_STOP_NOISY
3005 #define sgl BPSTAT_WHAT_SINGLE
3006 #define slr BPSTAT_WHAT_SET_LONGJMP_RESUME
3007 #define clr BPSTAT_WHAT_CLEAR_LONGJMP_RESUME
3008 #define clrs BPSTAT_WHAT_CLEAR_LONGJMP_RESUME_SINGLE
3009 #define sr BPSTAT_WHAT_STEP_RESUME
3010 #define shl BPSTAT_WHAT_CHECK_SHLIBS
3011 #define shlr BPSTAT_WHAT_CHECK_SHLIBS_RESUME_FROM_HOOK
3013 /* "Can't happen." Might want to print an error message.
3014 abort() is not out of the question, but chances are GDB is just
3015 a bit confused, not unusable. */
3016 #define err BPSTAT_WHAT_STOP_NOISY
3018 /* Given an old action and a class, come up with a new action. */
3019 /* One interesting property of this table is that wp_silent is the same
3020 as bp_silent and wp_noisy is the same as bp_noisy. That is because
3021 after stopping, the check for whether to step over a breakpoint
3022 (BPSTAT_WHAT_SINGLE type stuff) is handled in proceed() without
3023 reference to how we stopped. We retain separate wp_silent and
3024 bp_silent codes in case we want to change that someday.
3026 Another possibly interesting property of this table is that
3027 there's a partial ordering, priority-like, of the actions. Once
3028 you've decided that some action is appropriate, you'll never go
3029 back and decide something of a lower priority is better. The
3032 kc < clr sgl shl shlr slr sn sr ss
3033 sgl < clrs shl shlr slr sn sr ss
3034 slr < err shl shlr sn sr ss
3035 clr < clrs err shl shlr sn sr ss
3036 clrs < err shl shlr sn sr ss
3043 What I think this means is that we don't need a damned table
3044 here. If you just put the rows and columns in the right order,
3045 it'd look awfully regular. We could simply walk the bpstat list
3046 and choose the highest priority action we find, with a little
3047 logic to handle the 'err' cases, and the CLEAR_LONGJMP_RESUME/
3048 CLEAR_LONGJMP_RESUME_SINGLE distinction (which breakpoint.h says
3049 is messy anyway). */
3051 /* step_resume entries: a step resume breakpoint overrides another
3052 breakpoint of signal handling (see comment in wait_for_inferior
3053 at where we set the step_resume breakpoint). */
3055 static const enum bpstat_what_main_action
3056 table
[(int) class_last
][(int) BPSTAT_WHAT_LAST
] =
3059 /* kc ss sn sgl slr clr clrs sr shl shlr
3062 {kc
, ss
, sn
, sgl
, slr
, clr
, clrs
, sr
, shl
, shlr
},
3064 {ss
, ss
, sn
, ss
, ss
, ss
, ss
, sr
, shl
, shlr
},
3066 {sn
, sn
, sn
, sn
, sn
, sn
, sn
, sr
, shl
, shlr
},
3068 {sgl
, ss
, sn
, sgl
, slr
, clrs
, clrs
, sr
, shl
, shlr
},
3070 {ss
, ss
, sn
, ss
, ss
, ss
, ss
, sr
, shl
, shlr
},
3072 {sn
, sn
, sn
, sn
, sn
, sn
, sn
, sr
, shl
, shlr
},
3074 {slr
, ss
, sn
, slr
, slr
, err
, err
, sr
, shl
, shlr
},
3076 {clr
, ss
, sn
, clrs
, err
, err
, err
, sr
, shl
, shlr
},
3078 {sr
, sr
, sr
, sr
, sr
, sr
, sr
, sr
, sr
, sr
},
3080 {shl
, shl
, shl
, shl
, shl
, shl
, shl
, sr
, shl
, shlr
},
3082 {shlr
, shlr
, shlr
, shlr
, shlr
, shlr
, shlr
, sr
, shlr
, shlr
}
3097 enum bpstat_what_main_action current_action
= BPSTAT_WHAT_KEEP_CHECKING
;
3098 struct bpstat_what retval
;
3100 retval
.call_dummy
= 0;
3101 for (; bs
!= NULL
; bs
= bs
->next
)
3103 enum class bs_class
= no_effect
;
3104 if (bs
->breakpoint_at
== NULL
)
3105 /* I suspect this can happen if it was a momentary breakpoint
3106 which has since been deleted. */
3108 switch (bs
->breakpoint_at
->owner
->type
)
3114 case bp_hardware_breakpoint
:
3120 bs_class
= bp_noisy
;
3122 bs_class
= bp_silent
;
3125 bs_class
= bp_nostop
;
3128 case bp_hardware_watchpoint
:
3129 case bp_read_watchpoint
:
3130 case bp_access_watchpoint
:
3134 bs_class
= wp_noisy
;
3136 bs_class
= wp_silent
;
3139 /* There was a watchpoint, but we're not stopping.
3140 This requires no further action. */
3141 bs_class
= no_effect
;
3144 bs_class
= long_jump
;
3146 case bp_longjmp_resume
:
3147 bs_class
= long_resume
;
3149 case bp_step_resume
:
3152 bs_class
= step_resume
;
3155 /* It is for the wrong frame. */
3156 bs_class
= bp_nostop
;
3158 case bp_watchpoint_scope
:
3159 bs_class
= bp_nostop
;
3161 case bp_shlib_event
:
3162 bs_class
= shlib_event
;
3164 case bp_thread_event
:
3165 case bp_overlay_event
:
3166 bs_class
= bp_nostop
;
3169 case bp_catch_unload
:
3170 /* Only if this catchpoint triggered should we cause the
3171 step-out-of-dld behaviour. Otherwise, we ignore this
3174 bs_class
= catch_shlib_event
;
3176 bs_class
= no_effect
;
3179 case bp_catch_vfork
:
3184 bs_class
= bp_noisy
;
3186 bs_class
= bp_silent
;
3189 /* There was a catchpoint, but we're not stopping.
3190 This requires no further action. */
3191 bs_class
= no_effect
;
3194 /* Make sure the action is stop (silent or noisy),
3195 so infrun.c pops the dummy frame. */
3196 bs_class
= bp_silent
;
3197 retval
.call_dummy
= 1;
3200 current_action
= table
[(int) bs_class
][(int) current_action
];
3202 retval
.main_action
= current_action
;
3206 /* Nonzero if we should step constantly (e.g. watchpoints on machines
3207 without hardware support). This isn't related to a specific bpstat,
3208 just to things like whether watchpoints are set. */
3211 bpstat_should_step (void)
3213 struct breakpoint
*b
;
3215 if (breakpoint_enabled (b
) && b
->type
== bp_watchpoint
)
3222 /* Given a bpstat that records zero or more triggered eventpoints, this
3223 function returns another bpstat which contains only the catchpoints
3224 on that first list, if any. */
3226 bpstat_get_triggered_catchpoints (bpstat ep_list
, bpstat
*cp_list
)
3228 struct bpstats root_bs
[1];
3229 bpstat bs
= root_bs
;
3230 struct breakpoint
*ep
;
3233 bpstat_clear (cp_list
);
3234 root_bs
->next
= NULL
;
3236 for (; ep_list
!= NULL
; ep_list
= ep_list
->next
)
3238 /* Is this eventpoint a catchpoint? If not, ignore it. */
3239 ep
= ep_list
->breakpoint_at
->owner
;
3242 if ((ep
->type
!= bp_catch_load
) &&
3243 (ep
->type
!= bp_catch_unload
))
3244 /* pai: (temp) ADD fork/vfork here!! */
3247 /* Yes; add it to the list. */
3248 bs
= bpstat_alloc (ep_list
->breakpoint_at
, bs
);
3253 #if defined(SOLIB_ADD)
3254 /* Also, for each triggered catchpoint, tag it with the name of
3255 the library that caused this trigger. (We copy the name now,
3256 because it's only guaranteed to be available NOW, when the
3257 catchpoint triggers. Clients who may wish to know the name
3258 later must get it from the catchpoint itself.) */
3259 if (ep
->triggered_dll_pathname
!= NULL
)
3260 xfree (ep
->triggered_dll_pathname
);
3261 if (ep
->type
== bp_catch_load
)
3262 dll_pathname
= SOLIB_LOADED_LIBRARY_PATHNAME (
3263 PIDGET (inferior_ptid
));
3265 dll_pathname
= SOLIB_UNLOADED_LIBRARY_PATHNAME (
3266 PIDGET (inferior_ptid
));
3268 dll_pathname
= NULL
;
3272 ep
->triggered_dll_pathname
= (char *)
3273 xmalloc (strlen (dll_pathname
) + 1);
3274 strcpy (ep
->triggered_dll_pathname
, dll_pathname
);
3277 ep
->triggered_dll_pathname
= NULL
;
3283 static void print_breakpoint_location (struct breakpoint
*b
,
3284 struct bp_location
*loc
,
3286 struct ui_stream
*stb
)
3291 = find_pc_sect_function (loc
->address
, loc
->section
);
3294 ui_out_text (uiout
, "in ");
3295 ui_out_field_string (uiout
, "func",
3296 SYMBOL_PRINT_NAME (sym
));
3297 ui_out_wrap_hint (uiout
, wrap_indent
);
3298 ui_out_text (uiout
, " at ");
3300 ui_out_field_string (uiout
, "file", b
->source_file
);
3301 ui_out_text (uiout
, ":");
3303 if (ui_out_is_mi_like_p (uiout
))
3305 struct symtab_and_line sal
= find_pc_line (loc
->address
, 0);
3306 char *fullname
= symtab_to_fullname (sal
.symtab
);
3309 ui_out_field_string (uiout
, "fullname", fullname
);
3312 ui_out_field_int (uiout
, "line", b
->line_number
);
3316 ui_out_field_string (uiout
, "pending", b
->addr_string
);
3320 print_address_symbolic (loc
->address
, stb
->stream
, demangle
, "");
3321 ui_out_field_stream (uiout
, "at", stb
);
3325 /* Print B to gdb_stdout. */
3327 print_one_breakpoint_location (struct breakpoint
*b
,
3328 struct bp_location
*loc
,
3330 CORE_ADDR
*last_addr
)
3332 struct command_line
*l
;
3334 struct ep_type_description
3339 static struct ep_type_description bptypes
[] =
3341 {bp_none
, "?deleted?"},
3342 {bp_breakpoint
, "breakpoint"},
3343 {bp_hardware_breakpoint
, "hw breakpoint"},
3344 {bp_until
, "until"},
3345 {bp_finish
, "finish"},
3346 {bp_watchpoint
, "watchpoint"},
3347 {bp_hardware_watchpoint
, "hw watchpoint"},
3348 {bp_read_watchpoint
, "read watchpoint"},
3349 {bp_access_watchpoint
, "acc watchpoint"},
3350 {bp_longjmp
, "longjmp"},
3351 {bp_longjmp_resume
, "longjmp resume"},
3352 {bp_step_resume
, "step resume"},
3353 {bp_watchpoint_scope
, "watchpoint scope"},
3354 {bp_call_dummy
, "call dummy"},
3355 {bp_shlib_event
, "shlib events"},
3356 {bp_thread_event
, "thread events"},
3357 {bp_overlay_event
, "overlay events"},
3358 {bp_catch_load
, "catch load"},
3359 {bp_catch_unload
, "catch unload"},
3360 {bp_catch_fork
, "catch fork"},
3361 {bp_catch_vfork
, "catch vfork"},
3362 {bp_catch_exec
, "catch exec"}
3365 static char *bpdisps
[] =
3366 {"del", "dstp", "dis", "keep"};
3367 static char bpenables
[] = "nynny";
3368 char wrap_indent
[80];
3369 struct ui_stream
*stb
= ui_out_stream_new (uiout
);
3370 struct cleanup
*old_chain
= make_cleanup_ui_out_stream_delete (stb
);
3371 struct cleanup
*bkpt_chain
;
3373 int header_of_multiple
= 0;
3374 int part_of_multiple
= (loc
!= NULL
);
3376 gdb_assert (!loc
|| loc_number
!= 0);
3377 /* See comment in print_one_breakpoint concerning
3378 treatment of breakpoints with single disabled
3382 && (b
->loc
->next
!= NULL
|| !b
->loc
->enabled
)))
3383 header_of_multiple
= 1;
3388 bkpt_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "bkpt");
3392 if (part_of_multiple
)
3395 formatted
= xstrprintf ("%d.%d", b
->number
, loc_number
);
3396 ui_out_field_string (uiout
, "number", formatted
);
3401 ui_out_field_int (uiout
, "number", b
->number
);
3406 if (part_of_multiple
)
3407 ui_out_field_skip (uiout
, "type");
3410 if (((int) b
->type
>= (sizeof (bptypes
) / sizeof (bptypes
[0])))
3411 || ((int) b
->type
!= bptypes
[(int) b
->type
].type
))
3412 internal_error (__FILE__
, __LINE__
,
3413 _("bptypes table does not describe type #%d."),
3415 ui_out_field_string (uiout
, "type", bptypes
[(int) b
->type
].description
);
3420 if (part_of_multiple
)
3421 ui_out_field_skip (uiout
, "disp");
3423 ui_out_field_string (uiout
, "disp", bpdisps
[(int) b
->disposition
]);
3428 if (part_of_multiple
)
3429 ui_out_field_string (uiout
, "enabled", loc
->enabled
? "y" : "n");
3431 ui_out_field_fmt (uiout
, "enabled", "%c",
3432 bpenables
[(int) b
->enable_state
]);
3433 ui_out_spaces (uiout
, 2);
3437 strcpy (wrap_indent
, " ");
3440 if (gdbarch_addr_bit (current_gdbarch
) <= 32)
3441 strcat (wrap_indent
, " ");
3443 strcat (wrap_indent
, " ");
3446 if (b
->ops
!= NULL
&& b
->ops
->print_one
!= NULL
)
3448 /* Although the print_one can possibly print
3449 all locations, calling it here is not likely
3450 to get any nice result. So, make sure there's
3451 just one location. */
3452 gdb_assert (b
->loc
== NULL
|| b
->loc
->next
== NULL
);
3453 b
->ops
->print_one (b
, last_addr
);
3459 internal_error (__FILE__
, __LINE__
,
3460 _("print_one_breakpoint: bp_none encountered\n"));
3464 case bp_hardware_watchpoint
:
3465 case bp_read_watchpoint
:
3466 case bp_access_watchpoint
:
3467 /* Field 4, the address, is omitted (which makes the columns
3468 not line up too nicely with the headers, but the effect
3469 is relatively readable). */
3471 ui_out_field_skip (uiout
, "addr");
3473 print_expression (b
->exp
, stb
->stream
);
3474 ui_out_field_stream (uiout
, "what", stb
);
3478 case bp_catch_unload
:
3479 /* Field 4, the address, is omitted (which makes the columns
3480 not line up too nicely with the headers, but the effect
3481 is relatively readable). */
3483 ui_out_field_skip (uiout
, "addr");
3485 if (b
->dll_pathname
== NULL
)
3487 ui_out_field_string (uiout
, "what", "<any library>");
3488 ui_out_spaces (uiout
, 1);
3492 ui_out_text (uiout
, "library \"");
3493 ui_out_field_string (uiout
, "what", b
->dll_pathname
);
3494 ui_out_text (uiout
, "\" ");
3499 case bp_catch_vfork
:
3500 /* Field 4, the address, is omitted (which makes the columns
3501 not line up too nicely with the headers, but the effect
3502 is relatively readable). */
3504 ui_out_field_skip (uiout
, "addr");
3506 if (b
->forked_inferior_pid
!= 0)
3508 ui_out_text (uiout
, "process ");
3509 ui_out_field_int (uiout
, "what", b
->forked_inferior_pid
);
3510 ui_out_spaces (uiout
, 1);
3515 /* Field 4, the address, is omitted (which makes the columns
3516 not line up too nicely with the headers, but the effect
3517 is relatively readable). */
3519 ui_out_field_skip (uiout
, "addr");
3521 if (b
->exec_pathname
!= NULL
)
3523 ui_out_text (uiout
, "program \"");
3524 ui_out_field_string (uiout
, "what", b
->exec_pathname
);
3525 ui_out_text (uiout
, "\" ");
3530 case bp_hardware_breakpoint
:
3534 case bp_longjmp_resume
:
3535 case bp_step_resume
:
3536 case bp_watchpoint_scope
:
3538 case bp_shlib_event
:
3539 case bp_thread_event
:
3540 case bp_overlay_event
:
3544 if (header_of_multiple
)
3545 ui_out_field_string (uiout
, "addr", "<MULTIPLE>");
3546 if (b
->loc
== NULL
|| loc
->shlib_disabled
)
3547 ui_out_field_string (uiout
, "addr", "<PENDING>");
3549 ui_out_field_core_addr (uiout
, "addr", loc
->address
);
3552 if (!header_of_multiple
)
3553 print_breakpoint_location (b
, loc
, wrap_indent
, stb
);
3555 *last_addr
= b
->loc
->address
;
3559 if (!part_of_multiple
&& b
->thread
!= -1)
3561 /* FIXME: This seems to be redundant and lost here; see the
3562 "stop only in" line a little further down. */
3563 ui_out_text (uiout
, " thread ");
3564 ui_out_field_int (uiout
, "thread", b
->thread
);
3567 ui_out_text (uiout
, "\n");
3569 if (part_of_multiple
&& frame_id_p (b
->frame_id
))
3572 ui_out_text (uiout
, "\tstop only in stack frame at ");
3573 /* FIXME: cagney/2002-12-01: Shouldn't be poeking around inside
3575 ui_out_field_core_addr (uiout
, "frame", b
->frame_id
.stack_addr
);
3576 ui_out_text (uiout
, "\n");
3579 if (!part_of_multiple
&& b
->cond_string
&& !ada_exception_catchpoint_p (b
))
3581 /* We do not print the condition for Ada exception catchpoints
3582 because the condition is an internal implementation detail
3583 that we do not want to expose to the user. */
3585 ui_out_text (uiout
, "\tstop only if ");
3586 ui_out_field_string (uiout
, "cond", b
->cond_string
);
3587 ui_out_text (uiout
, "\n");
3590 if (!part_of_multiple
&& b
->thread
!= -1)
3592 /* FIXME should make an annotation for this */
3593 ui_out_text (uiout
, "\tstop only in thread ");
3594 ui_out_field_int (uiout
, "thread", b
->thread
);
3595 ui_out_text (uiout
, "\n");
3598 if (!part_of_multiple
&& show_breakpoint_hit_counts
&& b
->hit_count
)
3600 /* FIXME should make an annotation for this */
3601 if (ep_is_catchpoint (b
))
3602 ui_out_text (uiout
, "\tcatchpoint");
3604 ui_out_text (uiout
, "\tbreakpoint");
3605 ui_out_text (uiout
, " already hit ");
3606 ui_out_field_int (uiout
, "times", b
->hit_count
);
3607 if (b
->hit_count
== 1)
3608 ui_out_text (uiout
, " time\n");
3610 ui_out_text (uiout
, " times\n");
3613 /* Output the count also if it is zero, but only if this is
3614 mi. FIXME: Should have a better test for this. */
3615 if (ui_out_is_mi_like_p (uiout
))
3616 if (!part_of_multiple
&& show_breakpoint_hit_counts
&& b
->hit_count
== 0)
3617 ui_out_field_int (uiout
, "times", b
->hit_count
);
3619 if (!part_of_multiple
&& b
->ignore_count
)
3622 ui_out_text (uiout
, "\tignore next ");
3623 ui_out_field_int (uiout
, "ignore", b
->ignore_count
);
3624 ui_out_text (uiout
, " hits\n");
3627 if (!part_of_multiple
&& (l
= b
->commands
))
3629 struct cleanup
*script_chain
;
3632 script_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "script");
3633 print_command_lines (uiout
, l
, 4);
3634 do_cleanups (script_chain
);
3636 do_cleanups (bkpt_chain
);
3637 do_cleanups (old_chain
);
3641 print_one_breakpoint (struct breakpoint
*b
,
3642 CORE_ADDR
*last_addr
)
3644 print_one_breakpoint_location (b
, NULL
, 0, last_addr
);
3646 /* If this breakpoint has custom print function,
3647 it's already printed. Otherwise, print individual
3648 locations, if any. */
3649 if (b
->ops
== NULL
|| b
->ops
->print_one
== NULL
)
3651 /* If breakpoint has a single location that is
3652 disabled, we print it as if it had
3653 several locations, since otherwise it's hard to
3654 represent "breakpoint enabled, location disabled"
3656 Note that while hardware watchpoints have
3657 several locations internally, that's no a property
3660 && !is_hardware_watchpoint (b
)
3661 && (b
->loc
->next
|| !b
->loc
->enabled
)
3662 && !ui_out_is_mi_like_p (uiout
))
3664 struct bp_location
*loc
;
3666 for (loc
= b
->loc
; loc
; loc
= loc
->next
, ++n
)
3667 print_one_breakpoint_location (b
, loc
, n
, last_addr
);
3673 struct captured_breakpoint_query_args
3679 do_captured_breakpoint_query (struct ui_out
*uiout
, void *data
)
3681 struct captured_breakpoint_query_args
*args
= data
;
3682 struct breakpoint
*b
;
3683 CORE_ADDR dummy_addr
= 0;
3686 if (args
->bnum
== b
->number
)
3688 print_one_breakpoint (b
, &dummy_addr
);
3696 gdb_breakpoint_query (struct ui_out
*uiout
, int bnum
, char **error_message
)
3698 struct captured_breakpoint_query_args args
;
3700 /* For the moment we don't trust print_one_breakpoint() to not throw
3702 if (catch_exceptions_with_msg (uiout
, do_captured_breakpoint_query
, &args
,
3703 error_message
, RETURN_MASK_ALL
) < 0)
3709 /* Return non-zero if B is user settable (breakpoints, watchpoints,
3710 catchpoints, et.al.). */
3713 user_settable_breakpoint (const struct breakpoint
*b
)
3715 return (b
->type
== bp_breakpoint
3716 || b
->type
== bp_catch_load
3717 || b
->type
== bp_catch_unload
3718 || b
->type
== bp_catch_fork
3719 || b
->type
== bp_catch_vfork
3720 || b
->type
== bp_catch_exec
3721 || b
->type
== bp_hardware_breakpoint
3722 || b
->type
== bp_watchpoint
3723 || b
->type
== bp_read_watchpoint
3724 || b
->type
== bp_access_watchpoint
3725 || b
->type
== bp_hardware_watchpoint
);
3728 /* Print information on user settable breakpoint (watchpoint, etc)
3729 number BNUM. If BNUM is -1 print all user settable breakpoints.
3730 If ALLFLAG is non-zero, include non- user settable breakpoints. */
3733 breakpoint_1 (int bnum
, int allflag
)
3735 struct breakpoint
*b
;
3736 CORE_ADDR last_addr
= (CORE_ADDR
) -1;
3737 int nr_printable_breakpoints
;
3738 struct cleanup
*bkpttbl_chain
;
3740 /* Compute the number of rows in the table. */
3741 nr_printable_breakpoints
= 0;
3744 || bnum
== b
->number
)
3746 if (allflag
|| user_settable_breakpoint (b
))
3747 nr_printable_breakpoints
++;
3752 = make_cleanup_ui_out_table_begin_end (uiout
, 6, nr_printable_breakpoints
,
3756 = make_cleanup_ui_out_table_begin_end (uiout
, 5, nr_printable_breakpoints
,
3759 if (nr_printable_breakpoints
> 0)
3760 annotate_breakpoints_headers ();
3761 if (nr_printable_breakpoints
> 0)
3763 ui_out_table_header (uiout
, 7, ui_left
, "number", "Num"); /* 1 */
3764 if (nr_printable_breakpoints
> 0)
3766 ui_out_table_header (uiout
, 14, ui_left
, "type", "Type"); /* 2 */
3767 if (nr_printable_breakpoints
> 0)
3769 ui_out_table_header (uiout
, 4, ui_left
, "disp", "Disp"); /* 3 */
3770 if (nr_printable_breakpoints
> 0)
3772 ui_out_table_header (uiout
, 3, ui_left
, "enabled", "Enb"); /* 4 */
3775 if (nr_printable_breakpoints
> 0)
3777 if (gdbarch_addr_bit (current_gdbarch
) <= 32)
3778 ui_out_table_header (uiout
, 10, ui_left
, "addr", "Address");/* 5 */
3780 ui_out_table_header (uiout
, 18, ui_left
, "addr", "Address");/* 5 */
3782 if (nr_printable_breakpoints
> 0)
3784 ui_out_table_header (uiout
, 40, ui_noalign
, "what", "What"); /* 6 */
3785 ui_out_table_body (uiout
);
3786 if (nr_printable_breakpoints
> 0)
3787 annotate_breakpoints_table ();
3791 || bnum
== b
->number
)
3793 /* We only print out user settable breakpoints unless the
3795 if (allflag
|| user_settable_breakpoint (b
))
3796 print_one_breakpoint (b
, &last_addr
);
3799 do_cleanups (bkpttbl_chain
);
3801 if (nr_printable_breakpoints
== 0)
3804 ui_out_message (uiout
, 0, "No breakpoints or watchpoints.\n");
3806 ui_out_message (uiout
, 0, "No breakpoint or watchpoint number %d.\n",
3811 /* Compare against (CORE_ADDR)-1 in case some compiler decides
3812 that a comparison of an unsigned with -1 is always false. */
3813 if (last_addr
!= (CORE_ADDR
) -1 && !server_command
)
3814 set_next_address (last_addr
);
3817 /* FIXME? Should this be moved up so that it is only called when
3818 there have been breakpoints? */
3819 annotate_breakpoints_table_end ();
3823 breakpoints_info (char *bnum_exp
, int from_tty
)
3828 bnum
= parse_and_eval_long (bnum_exp
);
3830 breakpoint_1 (bnum
, 0);
3834 maintenance_info_breakpoints (char *bnum_exp
, int from_tty
)
3839 bnum
= parse_and_eval_long (bnum_exp
);
3841 breakpoint_1 (bnum
, 1);
3845 breakpoint_has_pc (struct breakpoint
*b
, CORE_ADDR pc
, asection
*section
)
3847 struct bp_location
*bl
= b
->loc
;
3848 for (; bl
; bl
= bl
->next
)
3850 if (bl
->address
== pc
3851 && (!overlay_debugging
|| bl
->section
== section
))
3857 /* Print a message describing any breakpoints set at PC. */
3860 describe_other_breakpoints (CORE_ADDR pc
, asection
*section
, int thread
)
3863 struct breakpoint
*b
;
3866 others
+= breakpoint_has_pc (b
, pc
, section
);
3870 printf_filtered (_("Note: breakpoint "));
3871 else /* if (others == ???) */
3872 printf_filtered (_("Note: breakpoints "));
3874 if (breakpoint_has_pc (b
, pc
, section
))
3877 printf_filtered ("%d", b
->number
);
3878 if (b
->thread
== -1 && thread
!= -1)
3879 printf_filtered (" (all threads)");
3880 else if (b
->thread
!= -1)
3881 printf_filtered (" (thread %d)", b
->thread
);
3882 printf_filtered ("%s%s ",
3883 ((b
->enable_state
== bp_disabled
||
3884 b
->enable_state
== bp_call_disabled
)
3886 : b
->enable_state
== bp_permanent
3890 : ((others
== 1) ? " and" : ""));
3892 printf_filtered (_("also set at pc "));
3893 fputs_filtered (paddress (pc
), gdb_stdout
);
3894 printf_filtered (".\n");
3898 /* Set the default place to put a breakpoint
3899 for the `break' command with no arguments. */
3902 set_default_breakpoint (int valid
, CORE_ADDR addr
, struct symtab
*symtab
,
3905 default_breakpoint_valid
= valid
;
3906 default_breakpoint_address
= addr
;
3907 default_breakpoint_symtab
= symtab
;
3908 default_breakpoint_line
= line
;
3911 /* Return true iff it is meaningful to use the address member of
3912 BPT. For some breakpoint types, the address member is irrelevant
3913 and it makes no sense to attempt to compare it to other addresses
3914 (or use it for any other purpose either).
3916 More specifically, each of the following breakpoint types will always
3917 have a zero valued address and we don't want check_duplicates() to mark
3918 breakpoints of any of these types to be a duplicate of an actual
3919 breakpoint at address zero:
3922 bp_hardware_watchpoint
3924 bp_access_watchpoint
3931 breakpoint_address_is_meaningful (struct breakpoint
*bpt
)
3933 enum bptype type
= bpt
->type
;
3935 return (type
!= bp_watchpoint
3936 && type
!= bp_hardware_watchpoint
3937 && type
!= bp_read_watchpoint
3938 && type
!= bp_access_watchpoint
3939 && type
!= bp_catch_exec
3940 && type
!= bp_longjmp_resume
3941 && type
!= bp_catch_fork
3942 && type
!= bp_catch_vfork
);
3945 /* Rescan breakpoints at the same address and section as BPT,
3946 marking the first one as "first" and any others as "duplicates".
3947 This is so that the bpt instruction is only inserted once.
3948 If we have a permanent breakpoint at the same place as BPT, make
3949 that one the official one, and the rest as duplicates. */
3952 check_duplicates_for (CORE_ADDR address
, asection
*section
)
3954 struct bp_location
*b
;
3956 struct bp_location
*perm_bp
= 0;
3958 ALL_BP_LOCATIONS (b
)
3959 if (b
->owner
->enable_state
!= bp_disabled
3960 && b
->owner
->enable_state
!= bp_call_disabled
3962 && !b
->shlib_disabled
3963 && b
->address
== address
/* address / overlay match */
3964 && (!overlay_debugging
|| b
->section
== section
)
3965 && breakpoint_address_is_meaningful (b
->owner
))
3967 /* Have we found a permanent breakpoint? */
3968 if (b
->owner
->enable_state
== bp_permanent
)
3975 b
->duplicate
= count
> 1;
3978 /* If we found a permanent breakpoint at this address, go over the
3979 list again and declare all the other breakpoints there to be the
3983 perm_bp
->duplicate
= 0;
3985 /* Permanent breakpoint should always be inserted. */
3986 if (! perm_bp
->inserted
)
3987 internal_error (__FILE__
, __LINE__
,
3988 _("allegedly permanent breakpoint is not "
3989 "actually inserted"));
3991 ALL_BP_LOCATIONS (b
)
3994 if (b
->owner
->enable_state
!= bp_disabled
3995 && b
->owner
->enable_state
!= bp_call_disabled
3996 && b
->enabled
&& !b
->shlib_disabled
3997 && b
->address
== address
/* address / overlay match */
3998 && (!overlay_debugging
|| b
->section
== section
)
3999 && breakpoint_address_is_meaningful (b
->owner
))
4002 internal_error (__FILE__
, __LINE__
,
4003 _("another breakpoint was inserted on top of "
4004 "a permanent breakpoint"));
4013 check_duplicates (struct breakpoint
*bpt
)
4015 struct bp_location
*bl
= bpt
->loc
;
4017 if (! breakpoint_address_is_meaningful (bpt
))
4020 for (; bl
; bl
= bl
->next
)
4021 check_duplicates_for (bl
->address
, bl
->section
);
4025 breakpoint_adjustment_warning (CORE_ADDR from_addr
, CORE_ADDR to_addr
,
4026 int bnum
, int have_bnum
)
4031 strcpy (astr1
, hex_string_custom ((unsigned long) from_addr
, 8));
4032 strcpy (astr2
, hex_string_custom ((unsigned long) to_addr
, 8));
4034 warning (_("Breakpoint %d address previously adjusted from %s to %s."),
4035 bnum
, astr1
, astr2
);
4037 warning (_("Breakpoint address adjusted from %s to %s."), astr1
, astr2
);
4040 /* Adjust a breakpoint's address to account for architectural constraints
4041 on breakpoint placement. Return the adjusted address. Note: Very
4042 few targets require this kind of adjustment. For most targets,
4043 this function is simply the identity function. */
4046 adjust_breakpoint_address (CORE_ADDR bpaddr
, enum bptype bptype
)
4048 if (!gdbarch_adjust_breakpoint_address_p (current_gdbarch
))
4050 /* Very few targets need any kind of breakpoint adjustment. */
4053 else if (bptype
== bp_watchpoint
4054 || bptype
== bp_hardware_watchpoint
4055 || bptype
== bp_read_watchpoint
4056 || bptype
== bp_access_watchpoint
4057 || bptype
== bp_catch_fork
4058 || bptype
== bp_catch_vfork
4059 || bptype
== bp_catch_exec
)
4061 /* Watchpoints and the various bp_catch_* eventpoints should not
4062 have their addresses modified. */
4067 CORE_ADDR adjusted_bpaddr
;
4069 /* Some targets have architectural constraints on the placement
4070 of breakpoint instructions. Obtain the adjusted address. */
4071 adjusted_bpaddr
= gdbarch_adjust_breakpoint_address (current_gdbarch
,
4074 /* An adjusted breakpoint address can significantly alter
4075 a user's expectations. Print a warning if an adjustment
4077 if (adjusted_bpaddr
!= bpaddr
)
4078 breakpoint_adjustment_warning (bpaddr
, adjusted_bpaddr
, 0, 0);
4080 return adjusted_bpaddr
;
4084 /* Allocate a struct bp_location. */
4086 static struct bp_location
*
4087 allocate_bp_location (struct breakpoint
*bpt
, enum bptype bp_type
)
4089 struct bp_location
*loc
, *loc_p
;
4091 loc
= xmalloc (sizeof (struct bp_location
));
4092 memset (loc
, 0, sizeof (*loc
));
4096 loc
->shlib_disabled
= 0;
4105 case bp_longjmp_resume
:
4106 case bp_step_resume
:
4107 case bp_watchpoint_scope
:
4109 case bp_shlib_event
:
4110 case bp_thread_event
:
4111 case bp_overlay_event
:
4113 case bp_catch_unload
:
4114 loc
->loc_type
= bp_loc_software_breakpoint
;
4116 case bp_hardware_breakpoint
:
4117 loc
->loc_type
= bp_loc_hardware_breakpoint
;
4119 case bp_hardware_watchpoint
:
4120 case bp_read_watchpoint
:
4121 case bp_access_watchpoint
:
4122 loc
->loc_type
= bp_loc_hardware_watchpoint
;
4126 case bp_catch_vfork
:
4128 loc
->loc_type
= bp_loc_other
;
4131 internal_error (__FILE__
, __LINE__
, _("unknown breakpoint type"));
4134 /* Add this breakpoint to the end of the chain. */
4136 loc_p
= bp_location_chain
;
4138 bp_location_chain
= loc
;
4141 while (loc_p
->global_next
)
4142 loc_p
= loc_p
->global_next
;
4143 loc_p
->global_next
= loc
;
4149 static void free_bp_location (struct bp_location
*loc
)
4156 /* Helper to set_raw_breakpoint below. Creates a breakpoint
4157 that has type BPTYPE and has no locations as yet. */
4159 static struct breakpoint
*
4160 set_raw_breakpoint_without_location (enum bptype bptype
)
4162 struct breakpoint
*b
, *b1
;
4164 b
= (struct breakpoint
*) xmalloc (sizeof (struct breakpoint
));
4165 memset (b
, 0, sizeof (*b
));
4168 b
->language
= current_language
->la_language
;
4169 b
->input_radix
= input_radix
;
4171 b
->enable_state
= bp_enabled
;
4174 b
->ignore_count
= 0;
4176 b
->frame_id
= null_frame_id
;
4177 b
->dll_pathname
= NULL
;
4178 b
->triggered_dll_pathname
= NULL
;
4179 b
->forked_inferior_pid
= 0;
4180 b
->exec_pathname
= NULL
;
4182 b
->condition_not_parsed
= 0;
4184 /* Add this breakpoint to the end of the chain
4185 so that a list of breakpoints will come out in order
4186 of increasing numbers. */
4188 b1
= breakpoint_chain
;
4190 breakpoint_chain
= b
;
4200 /* Initialize loc->function_name. */
4202 set_breakpoint_location_function (struct bp_location
*loc
)
4204 if (loc
->owner
->type
== bp_breakpoint
4205 || loc
->owner
->type
== bp_hardware_breakpoint
)
4207 find_pc_partial_function (loc
->address
, &(loc
->function_name
),
4209 if (loc
->function_name
)
4210 loc
->function_name
= xstrdup (loc
->function_name
);
4214 /* set_raw_breakpoint is a low level routine for allocating and
4215 partially initializing a breakpoint of type BPTYPE. The newly
4216 created breakpoint's address, section, source file name, and line
4217 number are provided by SAL. The newly created and partially
4218 initialized breakpoint is added to the breakpoint chain and
4219 is also returned as the value of this function.
4221 It is expected that the caller will complete the initialization of
4222 the newly created breakpoint struct as well as output any status
4223 information regarding the creation of a new breakpoint. In
4224 particular, set_raw_breakpoint does NOT set the breakpoint
4225 number! Care should be taken to not allow an error to occur
4226 prior to completing the initialization of the breakpoint. If this
4227 should happen, a bogus breakpoint will be left on the chain. */
4230 set_raw_breakpoint (struct symtab_and_line sal
, enum bptype bptype
)
4232 struct breakpoint
*b
= set_raw_breakpoint_without_location (bptype
);
4233 CORE_ADDR adjusted_address
;
4235 /* Adjust the breakpoint's address prior to allocating a location.
4236 Once we call allocate_bp_location(), that mostly uninitialized
4237 location will be placed on the location chain. Adjustment of the
4238 breakpoint may cause read_memory_nobpt() to be called and we do
4239 not want its scan of the location chain to find a breakpoint and
4240 location that's only been partially initialized. */
4241 adjusted_address
= adjust_breakpoint_address (sal
.pc
, bptype
);
4243 b
->loc
= allocate_bp_location (b
, bptype
);
4244 b
->loc
->requested_address
= sal
.pc
;
4245 b
->loc
->address
= adjusted_address
;
4247 if (sal
.symtab
== NULL
)
4248 b
->source_file
= NULL
;
4250 b
->source_file
= savestring (sal
.symtab
->filename
,
4251 strlen (sal
.symtab
->filename
));
4252 b
->loc
->section
= sal
.section
;
4253 b
->line_number
= sal
.line
;
4255 set_breakpoint_location_function (b
->loc
);
4257 check_duplicates (b
);
4258 breakpoints_changed ();
4264 /* Note that the breakpoint object B describes a permanent breakpoint
4265 instruction, hard-wired into the inferior's code. */
4267 make_breakpoint_permanent (struct breakpoint
*b
)
4269 struct bp_location
*bl
;
4270 b
->enable_state
= bp_permanent
;
4272 /* By definition, permanent breakpoints are already present in the code.
4273 Mark all locations as inserted. For now, make_breakpoint_permanent
4274 is called in just one place, so it's hard to say if it's reasonable
4275 to have permanent breakpoint with multiple locations or not,
4276 but it's easy to implmement. */
4277 for (bl
= b
->loc
; bl
; bl
= bl
->next
)
4281 static struct breakpoint
*
4282 create_internal_breakpoint (CORE_ADDR address
, enum bptype type
)
4284 static int internal_breakpoint_number
= -1;
4285 struct symtab_and_line sal
;
4286 struct breakpoint
*b
;
4288 init_sal (&sal
); /* initialize to zeroes */
4291 sal
.section
= find_pc_overlay (sal
.pc
);
4293 b
= set_raw_breakpoint (sal
, type
);
4294 b
->number
= internal_breakpoint_number
--;
4295 b
->disposition
= disp_donttouch
;
4302 create_longjmp_breakpoint (char *func_name
)
4304 struct breakpoint
*b
;
4305 struct minimal_symbol
*m
;
4307 if (func_name
== NULL
)
4308 b
= create_internal_breakpoint (0, bp_longjmp_resume
);
4311 if ((m
= lookup_minimal_symbol_text (func_name
, NULL
)) == NULL
)
4314 b
= create_internal_breakpoint (SYMBOL_VALUE_ADDRESS (m
), bp_longjmp
);
4317 b
->enable_state
= bp_disabled
;
4320 b
->addr_string
= xstrdup (func_name
);
4323 /* Call this routine when stepping and nexting to enable a breakpoint
4324 if we do a longjmp(). When we hit that breakpoint, call
4325 set_longjmp_resume_breakpoint() to figure out where we are going. */
4328 enable_longjmp_breakpoint (void)
4330 struct breakpoint
*b
;
4333 if (b
->type
== bp_longjmp
)
4335 b
->enable_state
= bp_enabled
;
4336 check_duplicates (b
);
4341 disable_longjmp_breakpoint (void)
4343 struct breakpoint
*b
;
4346 if (b
->type
== bp_longjmp
4347 || b
->type
== bp_longjmp_resume
)
4349 b
->enable_state
= bp_disabled
;
4350 check_duplicates (b
);
4355 create_overlay_event_breakpoint (char *func_name
)
4357 struct breakpoint
*b
;
4358 struct minimal_symbol
*m
;
4360 if ((m
= lookup_minimal_symbol_text (func_name
, NULL
)) == NULL
)
4363 b
= create_internal_breakpoint (SYMBOL_VALUE_ADDRESS (m
),
4365 b
->addr_string
= xstrdup (func_name
);
4367 if (overlay_debugging
== ovly_auto
)
4369 b
->enable_state
= bp_enabled
;
4370 overlay_events_enabled
= 1;
4374 b
->enable_state
= bp_disabled
;
4375 overlay_events_enabled
= 0;
4380 enable_overlay_breakpoints (void)
4382 struct breakpoint
*b
;
4385 if (b
->type
== bp_overlay_event
)
4387 b
->enable_state
= bp_enabled
;
4388 check_duplicates (b
);
4389 overlay_events_enabled
= 1;
4394 disable_overlay_breakpoints (void)
4396 struct breakpoint
*b
;
4399 if (b
->type
== bp_overlay_event
)
4401 b
->enable_state
= bp_disabled
;
4402 check_duplicates (b
);
4403 overlay_events_enabled
= 0;
4408 create_thread_event_breakpoint (CORE_ADDR address
)
4410 struct breakpoint
*b
;
4412 b
= create_internal_breakpoint (address
, bp_thread_event
);
4414 b
->enable_state
= bp_enabled
;
4415 /* addr_string has to be used or breakpoint_re_set will delete me. */
4416 b
->addr_string
= xstrprintf ("*0x%s", paddr (b
->loc
->address
));
4422 remove_thread_event_breakpoints (void)
4424 struct breakpoint
*b
, *temp
;
4426 ALL_BREAKPOINTS_SAFE (b
, temp
)
4427 if (b
->type
== bp_thread_event
)
4428 delete_breakpoint (b
);
4431 struct captured_parse_breakpoint_args
4434 struct symtabs_and_lines
*sals_p
;
4435 char ***addr_string_p
;
4439 struct lang_and_radix
4447 remove_solib_event_breakpoints (void)
4449 struct breakpoint
*b
, *temp
;
4451 ALL_BREAKPOINTS_SAFE (b
, temp
)
4452 if (b
->type
== bp_shlib_event
)
4453 delete_breakpoint (b
);
4457 create_solib_event_breakpoint (CORE_ADDR address
)
4459 struct breakpoint
*b
;
4461 b
= create_internal_breakpoint (address
, bp_shlib_event
);
4465 /* Disable any breakpoints that are on code in shared libraries. Only
4466 apply to enabled breakpoints, disabled ones can just stay disabled. */
4469 disable_breakpoints_in_shlibs (void)
4471 struct bp_location
*loc
;
4472 int disabled_shlib_breaks
= 0;
4474 ALL_BP_LOCATIONS (loc
)
4476 struct breakpoint
*b
= loc
->owner
;
4477 /* We apply the check to all breakpoints, including disabled
4478 for those with loc->duplicate set. This is so that when breakpoint
4479 becomes enabled, or the duplicate is removed, gdb will try to insert
4480 all breakpoints. If we don't set shlib_disabled here, we'll try
4481 to insert those breakpoints and fail. */
4482 if (((b
->type
== bp_breakpoint
) || (b
->type
== bp_hardware_breakpoint
))
4483 && !loc
->shlib_disabled
4485 && PC_SOLIB (loc
->address
)
4487 && solib_address (loc
->address
)
4491 loc
->shlib_disabled
= 1;
4496 /* Disable any breakpoints that are in in an unloaded shared library. Only
4497 apply to enabled breakpoints, disabled ones can just stay disabled. */
4500 disable_breakpoints_in_unloaded_shlib (struct so_list
*solib
)
4502 struct bp_location
*loc
;
4503 int disabled_shlib_breaks
= 0;
4505 ALL_BP_LOCATIONS (loc
)
4507 struct breakpoint
*b
= loc
->owner
;
4508 if ((loc
->loc_type
== bp_loc_hardware_breakpoint
4509 || loc
->loc_type
== bp_loc_software_breakpoint
)
4510 && !loc
->shlib_disabled
)
4513 char *so_name
= PC_SOLIB (loc
->address
);
4515 char *so_name
= solib_address (loc
->address
);
4517 if (so_name
&& !strcmp (so_name
, solib
->so_name
))
4519 loc
->shlib_disabled
= 1;
4520 /* At this point, we cannot rely on remove_breakpoint
4521 succeeding so we must mark the breakpoint as not inserted
4522 to prevent future errors occurring in remove_breakpoints. */
4524 if (!disabled_shlib_breaks
)
4526 target_terminal_ours_for_output ();
4527 warning (_("Temporarily disabling breakpoints for unloaded shared library \"%s\""),
4530 disabled_shlib_breaks
= 1;
4537 create_fork_vfork_event_catchpoint (int tempflag
, char *cond_string
,
4538 enum bptype bp_kind
)
4540 struct symtab_and_line sal
;
4541 struct breakpoint
*b
;
4542 int thread
= -1; /* All threads. */
4549 b
= set_raw_breakpoint (sal
, bp_kind
);
4550 set_breakpoint_count (breakpoint_count
+ 1);
4551 b
->number
= breakpoint_count
;
4552 b
->cond_string
= (cond_string
== NULL
) ?
4553 NULL
: savestring (cond_string
, strlen (cond_string
));
4555 b
->addr_string
= NULL
;
4556 b
->enable_state
= bp_enabled
;
4557 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
4558 b
->forked_inferior_pid
= 0;
4564 create_fork_event_catchpoint (int tempflag
, char *cond_string
)
4566 create_fork_vfork_event_catchpoint (tempflag
, cond_string
, bp_catch_fork
);
4570 create_vfork_event_catchpoint (int tempflag
, char *cond_string
)
4572 create_fork_vfork_event_catchpoint (tempflag
, cond_string
, bp_catch_vfork
);
4576 create_exec_event_catchpoint (int tempflag
, char *cond_string
)
4578 struct symtab_and_line sal
;
4579 struct breakpoint
*b
;
4580 int thread
= -1; /* All threads. */
4587 b
= set_raw_breakpoint (sal
, bp_catch_exec
);
4588 set_breakpoint_count (breakpoint_count
+ 1);
4589 b
->number
= breakpoint_count
;
4590 b
->cond_string
= (cond_string
== NULL
) ?
4591 NULL
: savestring (cond_string
, strlen (cond_string
));
4593 b
->addr_string
= NULL
;
4594 b
->enable_state
= bp_enabled
;
4595 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
4601 hw_breakpoint_used_count (void)
4603 struct breakpoint
*b
;
4608 if (b
->type
== bp_hardware_breakpoint
&& b
->enable_state
== bp_enabled
)
4616 hw_watchpoint_used_count (enum bptype type
, int *other_type_used
)
4618 struct breakpoint
*b
;
4621 *other_type_used
= 0;
4624 if (breakpoint_enabled (b
))
4626 if (b
->type
== type
)
4628 else if ((b
->type
== bp_hardware_watchpoint
||
4629 b
->type
== bp_read_watchpoint
||
4630 b
->type
== bp_access_watchpoint
))
4631 *other_type_used
= 1;
4637 /* Call this after hitting the longjmp() breakpoint. Use this to set
4638 a new breakpoint at the target of the jmp_buf.
4640 FIXME - This ought to be done by setting a temporary breakpoint
4641 that gets deleted automatically... */
4644 set_longjmp_resume_breakpoint (CORE_ADDR pc
, struct frame_id frame_id
)
4646 struct breakpoint
*b
;
4649 if (b
->type
== bp_longjmp_resume
)
4651 b
->loc
->requested_address
= pc
;
4652 b
->loc
->address
= adjust_breakpoint_address (b
->loc
->requested_address
,
4654 b
->enable_state
= bp_enabled
;
4655 b
->frame_id
= frame_id
;
4656 check_duplicates (b
);
4662 disable_watchpoints_before_interactive_call_start (void)
4664 struct breakpoint
*b
;
4668 if (((b
->type
== bp_watchpoint
)
4669 || (b
->type
== bp_hardware_watchpoint
)
4670 || (b
->type
== bp_read_watchpoint
)
4671 || (b
->type
== bp_access_watchpoint
))
4672 && breakpoint_enabled (b
))
4674 b
->enable_state
= bp_call_disabled
;
4675 check_duplicates (b
);
4681 enable_watchpoints_after_interactive_call_stop (void)
4683 struct breakpoint
*b
;
4687 if (((b
->type
== bp_watchpoint
)
4688 || (b
->type
== bp_hardware_watchpoint
)
4689 || (b
->type
== bp_read_watchpoint
)
4690 || (b
->type
== bp_access_watchpoint
))
4691 && (b
->enable_state
== bp_call_disabled
))
4693 b
->enable_state
= bp_enabled
;
4694 check_duplicates (b
);
4700 /* Set a breakpoint that will evaporate an end of command
4701 at address specified by SAL.
4702 Restrict it to frame FRAME if FRAME is nonzero. */
4705 set_momentary_breakpoint (struct symtab_and_line sal
, struct frame_id frame_id
,
4708 struct breakpoint
*b
;
4709 b
= set_raw_breakpoint (sal
, type
);
4710 b
->enable_state
= bp_enabled
;
4711 b
->disposition
= disp_donttouch
;
4712 b
->frame_id
= frame_id
;
4714 /* If we're debugging a multi-threaded program, then we
4715 want momentary breakpoints to be active in only a
4716 single thread of control. */
4717 if (in_thread_list (inferior_ptid
))
4718 b
->thread
= pid_to_thread_id (inferior_ptid
);
4724 /* Tell the user we have just set a breakpoint B. */
4727 mention (struct breakpoint
*b
)
4730 struct cleanup
*old_chain
, *ui_out_chain
;
4731 struct ui_stream
*stb
;
4733 stb
= ui_out_stream_new (uiout
);
4734 old_chain
= make_cleanup_ui_out_stream_delete (stb
);
4736 /* FIXME: This is misplaced; mention() is called by things (like
4737 hitting a watchpoint) other than breakpoint creation. It should
4738 be possible to clean this up and at the same time replace the
4739 random calls to breakpoint_changed with this hook, as has already
4740 been done for deprecated_delete_breakpoint_hook and so on. */
4741 if (deprecated_create_breakpoint_hook
)
4742 deprecated_create_breakpoint_hook (b
);
4743 breakpoint_create_event (b
->number
);
4745 if (b
->ops
!= NULL
&& b
->ops
->print_mention
!= NULL
)
4746 b
->ops
->print_mention (b
);
4751 printf_filtered (_("(apparently deleted?) Eventpoint %d: "), b
->number
);
4754 ui_out_text (uiout
, "Watchpoint ");
4755 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "wpt");
4756 ui_out_field_int (uiout
, "number", b
->number
);
4757 ui_out_text (uiout
, ": ");
4758 print_expression (b
->exp
, stb
->stream
);
4759 ui_out_field_stream (uiout
, "exp", stb
);
4760 do_cleanups (ui_out_chain
);
4762 case bp_hardware_watchpoint
:
4763 ui_out_text (uiout
, "Hardware watchpoint ");
4764 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "wpt");
4765 ui_out_field_int (uiout
, "number", b
->number
);
4766 ui_out_text (uiout
, ": ");
4767 print_expression (b
->exp
, stb
->stream
);
4768 ui_out_field_stream (uiout
, "exp", stb
);
4769 do_cleanups (ui_out_chain
);
4771 case bp_read_watchpoint
:
4772 ui_out_text (uiout
, "Hardware read watchpoint ");
4773 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "hw-rwpt");
4774 ui_out_field_int (uiout
, "number", b
->number
);
4775 ui_out_text (uiout
, ": ");
4776 print_expression (b
->exp
, stb
->stream
);
4777 ui_out_field_stream (uiout
, "exp", stb
);
4778 do_cleanups (ui_out_chain
);
4780 case bp_access_watchpoint
:
4781 ui_out_text (uiout
, "Hardware access (read/write) watchpoint ");
4782 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "hw-awpt");
4783 ui_out_field_int (uiout
, "number", b
->number
);
4784 ui_out_text (uiout
, ": ");
4785 print_expression (b
->exp
, stb
->stream
);
4786 ui_out_field_stream (uiout
, "exp", stb
);
4787 do_cleanups (ui_out_chain
);
4790 if (ui_out_is_mi_like_p (uiout
))
4795 printf_filtered (_("Breakpoint %d"), b
->number
);
4798 case bp_hardware_breakpoint
:
4799 if (ui_out_is_mi_like_p (uiout
))
4804 printf_filtered (_("Hardware assisted breakpoint %d"), b
->number
);
4808 case bp_catch_unload
:
4809 printf_filtered (_("Catchpoint %d (%s %s)"),
4811 (b
->type
== bp_catch_load
) ? "load" : "unload",
4812 (b
->dll_pathname
!= NULL
) ?
4813 b
->dll_pathname
: "<any library>");
4816 case bp_catch_vfork
:
4817 printf_filtered (_("Catchpoint %d (%s)"),
4819 (b
->type
== bp_catch_fork
) ? "fork" : "vfork");
4822 printf_filtered (_("Catchpoint %d (exec)"),
4829 case bp_longjmp_resume
:
4830 case bp_step_resume
:
4832 case bp_watchpoint_scope
:
4833 case bp_shlib_event
:
4834 case bp_thread_event
:
4835 case bp_overlay_event
:
4841 /* i18n: cagney/2005-02-11: Below needs to be merged into a
4845 printf_filtered (_(" (%s) pending."), b
->addr_string
);
4849 if (addressprint
|| b
->source_file
== NULL
)
4851 printf_filtered (" at ");
4852 fputs_filtered (paddress (b
->loc
->address
), gdb_stdout
);
4855 printf_filtered (": file %s, line %d.",
4856 b
->source_file
, b
->line_number
);
4860 struct bp_location
*loc
= b
->loc
;
4862 for (; loc
; loc
= loc
->next
)
4864 printf_filtered (" (%d locations)", n
);
4869 do_cleanups (old_chain
);
4870 if (ui_out_is_mi_like_p (uiout
))
4872 printf_filtered ("\n");
4876 static struct bp_location
*
4877 add_location_to_breakpoint (struct breakpoint
*b
, enum bptype bptype
,
4878 const struct symtab_and_line
*sal
)
4880 struct bp_location
*loc
, **tmp
;
4882 loc
= allocate_bp_location (b
, bptype
);
4883 for (tmp
= &(b
->loc
); *tmp
!= NULL
; tmp
= &((*tmp
)->next
))
4886 loc
->requested_address
= sal
->pc
;
4887 loc
->address
= adjust_breakpoint_address (loc
->requested_address
,
4889 loc
->section
= sal
->section
;
4891 set_breakpoint_location_function (loc
);
4895 /* Create a breakpoint with SAL as location. Use ADDR_STRING
4896 as textual description of the location, and COND_STRING
4897 as condition expression. */
4900 create_breakpoint (struct symtabs_and_lines sals
, char *addr_string
,
4902 enum bptype type
, enum bpdisp disposition
,
4903 int thread
, int ignore_count
, int from_tty
)
4905 struct breakpoint
*b
= NULL
;
4908 if (type
== bp_hardware_breakpoint
)
4910 int i
= hw_breakpoint_used_count ();
4911 int target_resources_ok
=
4912 TARGET_CAN_USE_HARDWARE_WATCHPOINT (bp_hardware_breakpoint
,
4914 if (target_resources_ok
== 0)
4915 error (_("No hardware breakpoint support in the target."));
4916 else if (target_resources_ok
< 0)
4917 error (_("Hardware breakpoints used exceeds limit."));
4920 for (i
= 0; i
< sals
.nelts
; ++i
)
4922 struct symtab_and_line sal
= sals
.sals
[i
];
4923 struct bp_location
*loc
;
4926 describe_other_breakpoints (sal
.pc
, sal
.section
, thread
);
4930 b
= set_raw_breakpoint (sal
, type
);
4931 set_breakpoint_count (breakpoint_count
+ 1);
4932 b
->number
= breakpoint_count
;
4935 b
->cond_string
= cond_string
;
4936 b
->ignore_count
= ignore_count
;
4937 b
->enable_state
= bp_enabled
;
4938 b
->disposition
= disposition
;
4944 loc
= add_location_to_breakpoint (b
, type
, &sal
);
4949 char *arg
= b
->cond_string
;
4950 loc
->cond
= parse_exp_1 (&arg
, block_for_pc (loc
->address
), 0);
4952 error (_("Garbage %s follows condition"), arg
);
4957 b
->addr_string
= addr_string
;
4959 /* addr_string has to be used or breakpoint_re_set will delete
4961 b
->addr_string
= xstrprintf ("*0x%s", paddr (b
->loc
->address
));
4966 /* Remove element at INDEX_TO_REMOVE from SAL, shifting other
4967 elements to fill the void space. */
4968 static void remove_sal (struct symtabs_and_lines
*sal
, int index_to_remove
)
4970 int i
= index_to_remove
+1;
4971 int last_index
= sal
->nelts
-1;
4973 for (;i
<= last_index
; ++i
)
4974 sal
->sals
[i
-1] = sal
->sals
[i
];
4979 /* If appropriate, obtains all sals that correspond
4980 to the same file and line as SAL. This is done
4981 only if SAL does not have explicit PC and has
4982 line and file information. If we got just a single
4983 expanded sal, return the original.
4985 Otherwise, if SAL.explicit_line is not set, filter out
4986 all sals for which the name of enclosing function
4987 is different from SAL. This makes sure that if we have
4988 breakpoint originally set in template instantiation, say
4989 foo<int>(), we won't expand SAL to locations at the same
4990 line in all existing instantiations of 'foo'.
4993 struct symtabs_and_lines
4994 expand_line_sal_maybe (struct symtab_and_line sal
)
4996 struct symtabs_and_lines expanded
;
4997 CORE_ADDR original_pc
= sal
.pc
;
4998 char *original_function
= NULL
;
5002 /* If we have explicit pc, don't expand.
5003 If we have no line number, we can't expand. */
5004 if (sal
.explicit_pc
|| sal
.line
== 0 || sal
.symtab
== NULL
)
5007 expanded
.sals
= xmalloc (sizeof (struct symtab_and_line
));
5008 expanded
.sals
[0] = sal
;
5013 find_pc_partial_function (original_pc
, &original_function
, NULL
, NULL
);
5015 expanded
= expand_line_sal (sal
);
5016 if (expanded
.nelts
== 1)
5018 /* We had one sal, we got one sal. Without futher
5019 processing, just return the original sal. */
5020 xfree (expanded
.sals
);
5022 expanded
.sals
= xmalloc (sizeof (struct symtab_and_line
));
5023 sal
.pc
= original_pc
;
5024 expanded
.sals
[0] = sal
;
5028 if (!sal
.explicit_line
)
5030 CORE_ADDR func_addr
, func_end
;
5031 for (i
= 0; i
< expanded
.nelts
; ++i
)
5033 CORE_ADDR pc
= expanded
.sals
[i
].pc
;
5034 char *this_function
;
5035 if (find_pc_partial_function (pc
, &this_function
,
5036 &func_addr
, &func_end
))
5038 if (this_function
&&
5039 strcmp (this_function
, original_function
) != 0)
5041 remove_sal (&expanded
, i
);
5044 else if (func_addr
== pc
)
5046 /* We're at beginning of a function, and should
5048 struct symbol
*sym
= find_pc_function (pc
);
5050 expanded
.sals
[i
] = find_function_start_sal (sym
, 1);
5053 = gdbarch_skip_prologue (current_gdbarch
, pc
);
5060 if (expanded
.nelts
<= 1)
5062 /* This is un ugly workaround. If we get zero
5063 expanded sals then something is really wrong.
5064 Fix that by returnign the original sal. */
5065 xfree (expanded
.sals
);
5067 expanded
.sals
= xmalloc (sizeof (struct symtab_and_line
));
5068 sal
.pc
= original_pc
;
5069 expanded
.sals
[0] = sal
;
5076 for (i
= 0; i
< expanded
.nelts
; ++i
)
5077 if (expanded
.sals
[i
].pc
== original_pc
)
5088 /* Add SALS.nelts breakpoints to the breakpoint table. For each
5089 SALS.sal[i] breakpoint, include the corresponding ADDR_STRING[i]
5090 value. COND_STRING, if not NULL, specified the condition to be
5091 used for all breakpoints. Essentially the only case where
5092 SALS.nelts is not 1 is when we set a breakpoint on an overloaded
5093 function. In that case, it's still not possible to specify
5094 separate conditions for different overloaded functions, so
5095 we take just a single condition string.
5097 NOTE: If the function succeeds, the caller is expected to cleanup
5098 the arrays ADDR_STRING, COND_STRING, and SALS (but not the
5099 array contents). If the function fails (error() is called), the
5100 caller is expected to cleanups both the ADDR_STRING, COND_STRING,
5101 COND and SALS arrays and each of those arrays contents. */
5104 create_breakpoints (struct symtabs_and_lines sals
, char **addr_string
,
5106 enum bptype type
, enum bpdisp disposition
,
5107 int thread
, int ignore_count
, int from_tty
)
5110 for (i
= 0; i
< sals
.nelts
; ++i
)
5112 struct symtabs_and_lines expanded
=
5113 expand_line_sal_maybe (sals
.sals
[i
]);
5115 create_breakpoint (expanded
, addr_string
[i
],
5116 cond_string
, type
, disposition
,
5117 thread
, ignore_count
, from_tty
);
5121 /* Parse ARG which is assumed to be a SAL specification possibly
5122 followed by conditionals. On return, SALS contains an array of SAL
5123 addresses found. ADDR_STRING contains a vector of (canonical)
5124 address strings. ARG points to the end of the SAL. */
5127 parse_breakpoint_sals (char **address
,
5128 struct symtabs_and_lines
*sals
,
5129 char ***addr_string
,
5132 char *addr_start
= *address
;
5133 *addr_string
= NULL
;
5134 /* If no arg given, or if first arg is 'if ', use the default
5136 if ((*address
) == NULL
5137 || (strncmp ((*address
), "if", 2) == 0 && isspace ((*address
)[2])))
5139 if (default_breakpoint_valid
)
5141 struct symtab_and_line sal
;
5142 init_sal (&sal
); /* initialize to zeroes */
5143 sals
->sals
= (struct symtab_and_line
*)
5144 xmalloc (sizeof (struct symtab_and_line
));
5145 sal
.pc
= default_breakpoint_address
;
5146 sal
.line
= default_breakpoint_line
;
5147 sal
.symtab
= default_breakpoint_symtab
;
5148 sal
.section
= find_pc_overlay (sal
.pc
);
5149 sals
->sals
[0] = sal
;
5153 error (_("No default breakpoint address now."));
5157 /* Force almost all breakpoints to be in terms of the
5158 current_source_symtab (which is decode_line_1's default). This
5159 should produce the results we want almost all of the time while
5160 leaving default_breakpoint_* alone.
5161 ObjC: However, don't match an Objective-C method name which
5162 may have a '+' or '-' succeeded by a '[' */
5164 struct symtab_and_line cursal
= get_current_source_symtab_and_line ();
5166 if (default_breakpoint_valid
5168 || ((strchr ("+-", (*address
)[0]) != NULL
)
5169 && ((*address
)[1] != '['))))
5170 *sals
= decode_line_1 (address
, 1, default_breakpoint_symtab
,
5171 default_breakpoint_line
, addr_string
,
5174 *sals
= decode_line_1 (address
, 1, (struct symtab
*) NULL
, 0,
5175 addr_string
, not_found_ptr
);
5177 /* For any SAL that didn't have a canonical string, fill one in. */
5178 if (sals
->nelts
> 0 && *addr_string
== NULL
)
5179 *addr_string
= xcalloc (sals
->nelts
, sizeof (char **));
5180 if (addr_start
!= (*address
))
5183 for (i
= 0; i
< sals
->nelts
; i
++)
5185 /* Add the string if not present. */
5186 if ((*addr_string
)[i
] == NULL
)
5187 (*addr_string
)[i
] = savestring (addr_start
, (*address
) - addr_start
);
5193 /* Convert each SAL into a real PC. Verify that the PC can be
5194 inserted as a breakpoint. If it can't throw an error. */
5197 breakpoint_sals_to_pc (struct symtabs_and_lines
*sals
,
5201 for (i
= 0; i
< sals
->nelts
; i
++)
5202 resolve_sal_pc (&sals
->sals
[i
]);
5206 do_captured_parse_breakpoint (struct ui_out
*ui
, void *data
)
5208 struct captured_parse_breakpoint_args
*args
= data
;
5210 parse_breakpoint_sals (args
->arg_p
, args
->sals_p
, args
->addr_string_p
,
5211 args
->not_found_ptr
);
5214 /* Given TOK, a string specification of condition and thread, as
5215 accepted by the 'break' command, extract the condition
5216 string and thread number and set *COND_STRING and *THREAD.
5217 PC identifies the context at which the condition should be parsed.
5218 If no condition is found, *COND_STRING is set to NULL.
5219 If no thread is found, *THREAD is set to -1. */
5221 find_condition_and_thread (char *tok
, CORE_ADDR pc
,
5222 char **cond_string
, int *thread
)
5224 *cond_string
= NULL
;
5230 char *cond_start
= NULL
;
5231 char *cond_end
= NULL
;
5232 while (*tok
== ' ' || *tok
== '\t')
5237 while (*end_tok
!= ' ' && *end_tok
!= '\t' && *end_tok
!= '\000')
5240 toklen
= end_tok
- tok
;
5242 if (toklen
>= 1 && strncmp (tok
, "if", toklen
) == 0)
5244 tok
= cond_start
= end_tok
+ 1;
5245 parse_exp_1 (&tok
, block_for_pc (pc
), 0);
5247 *cond_string
= savestring (cond_start
,
5248 cond_end
- cond_start
);
5250 else if (toklen
>= 1 && strncmp (tok
, "thread", toklen
) == 0)
5256 *thread
= strtol (tok
, &tok
, 0);
5258 error (_("Junk after thread keyword."));
5259 if (!valid_thread_id (*thread
))
5260 error (_("Unknown thread %d."), *thread
);
5263 error (_("Junk at end of arguments."));
5267 /* Set a breakpoint. This function is shared between
5268 CLI and MI functions for setting a breakpoint.
5269 This function has two major modes of operations,
5270 selected by the PARSE_CONDITION_AND_THREAD parameter.
5271 If non-zero, the function will parse arg, extracting
5272 breakpoint location, address and thread. Otherwise,
5273 ARG is just the location of breakpoint, with condition
5274 and thread specified by the COND_STRING and THREAD
5278 break_command_really (char *arg
, char *cond_string
, int thread
,
5279 int parse_condition_and_thread
,
5280 int tempflag
, int hardwareflag
,
5282 enum auto_boolean pending_break_support
,
5285 struct gdb_exception e
;
5286 struct symtabs_and_lines sals
;
5287 struct symtab_and_line pending_sal
;
5290 char *addr_start
= arg
;
5292 struct cleanup
*old_chain
;
5293 struct cleanup
*breakpoint_chain
= NULL
;
5294 struct captured_parse_breakpoint_args parse_args
;
5303 parse_args
.arg_p
= &arg
;
5304 parse_args
.sals_p
= &sals
;
5305 parse_args
.addr_string_p
= &addr_string
;
5306 parse_args
.not_found_ptr
= ¬_found
;
5308 e
= catch_exception (uiout
, do_captured_parse_breakpoint
,
5309 &parse_args
, RETURN_MASK_ALL
);
5311 /* If caller is interested in rc value from parse, set value. */
5315 throw_exception (e
);
5319 case NOT_FOUND_ERROR
:
5321 /* If pending breakpoint support is turned off, throw
5324 if (pending_break_support
== AUTO_BOOLEAN_FALSE
)
5325 throw_exception (e
);
5327 exception_print (gdb_stderr
, e
);
5329 /* If pending breakpoint support is auto query and the user
5330 selects no, then simply return the error code. */
5331 if (pending_break_support
== AUTO_BOOLEAN_AUTO
&&
5332 !nquery ("Make breakpoint pending on future shared library load? "))
5335 /* At this point, either the user was queried about setting
5336 a pending breakpoint and selected yes, or pending
5337 breakpoint behavior is on and thus a pending breakpoint
5338 is defaulted on behalf of the user. */
5339 copy_arg
= xstrdup (addr_start
);
5340 addr_string
= ©_arg
;
5342 sals
.sals
= &pending_sal
;
5347 throw_exception (e
);
5354 /* Create a chain of things that always need to be cleaned up. */
5355 old_chain
= make_cleanup (null_cleanup
, 0);
5359 /* Make sure that all storage allocated to SALS gets freed. */
5360 make_cleanup (xfree
, sals
.sals
);
5362 /* Cleanup the addr_string array but not its contents. */
5363 make_cleanup (xfree
, addr_string
);
5366 /* ----------------------------- SNIP -----------------------------
5367 Anything added to the cleanup chain beyond this point is assumed
5368 to be part of a breakpoint. If the breakpoint create succeeds
5369 then the memory is not reclaimed. */
5370 breakpoint_chain
= make_cleanup (null_cleanup
, 0);
5372 /* Mark the contents of the addr_string for cleanup. These go on
5373 the breakpoint_chain and only occure if the breakpoint create
5375 for (i
= 0; i
< sals
.nelts
; i
++)
5377 if (addr_string
[i
] != NULL
)
5378 make_cleanup (xfree
, addr_string
[i
]);
5381 /* Resolve all line numbers to PC's and verify that the addresses
5382 are ok for the target. */
5384 breakpoint_sals_to_pc (&sals
, addr_start
);
5386 /* Verify that condition can be parsed, before setting any
5387 breakpoints. Allocate a separate condition expression for each
5391 if (parse_condition_and_thread
)
5393 /* Here we only parse 'arg' to separate condition
5394 from thread number, so parsing in context of first
5395 sal is OK. When setting the breakpoint we'll
5396 re-parse it in context of each sal. */
5399 find_condition_and_thread (arg
, sals
.sals
[0].pc
, &cond_string
, &thread
);
5401 make_cleanup (xfree
, cond_string
);
5405 /* Create a private copy of condition string. */
5408 cond_string
= xstrdup (cond_string
);
5409 make_cleanup (xfree
, cond_string
);
5412 create_breakpoints (sals
, addr_string
, cond_string
,
5413 hardwareflag
? bp_hardware_breakpoint
5415 tempflag
? disp_del
: disp_donttouch
,
5416 thread
, ignore_count
, from_tty
);
5420 struct symtab_and_line sal
= {0};
5421 struct breakpoint
*b
;
5423 make_cleanup (xfree
, copy_arg
);
5425 b
= set_raw_breakpoint_without_location (hardwareflag
5426 ? bp_hardware_breakpoint
5428 set_breakpoint_count (breakpoint_count
+ 1);
5429 b
->number
= breakpoint_count
;
5431 b
->addr_string
= addr_string
[0];
5432 b
->cond_string
= NULL
;
5433 b
->ignore_count
= ignore_count
;
5434 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
5435 b
->condition_not_parsed
= 1;
5440 warning (_("Multiple breakpoints were set.\n"
5441 "Use the \"delete\" command to delete unwanted breakpoints."));
5442 /* That's it. Discard the cleanups for data inserted into the
5444 discard_cleanups (breakpoint_chain
);
5445 /* But cleanup everything else. */
5446 do_cleanups (old_chain
);
5449 /* Set a breakpoint.
5450 ARG is a string describing breakpoint address,
5451 condition, and thread.
5452 FLAG specifies if a breakpoint is hardware on,
5453 and if breakpoint is temporary, using BP_HARDWARE_FLAG
5457 break_command_1 (char *arg
, int flag
, int from_tty
)
5459 int hardwareflag
= flag
& BP_HARDWAREFLAG
;
5460 int tempflag
= flag
& BP_TEMPFLAG
;
5462 break_command_really (arg
,
5463 NULL
, 0, 1 /* parse arg */,
5464 tempflag
, hardwareflag
,
5465 0 /* Ignore count */,
5466 pending_break_support
, from_tty
);
5471 set_breakpoint (char *address
, char *condition
,
5472 int hardwareflag
, int tempflag
,
5473 int thread
, int ignore_count
,
5476 break_command_really (address
, condition
, thread
,
5477 0 /* condition and thread are valid. */,
5478 tempflag
, hardwareflag
,
5481 ? AUTO_BOOLEAN_TRUE
: AUTO_BOOLEAN_FALSE
,
5485 /* Adjust SAL to the first instruction past the function prologue.
5486 The end of the prologue is determined using the line table from
5487 the debugging information.
5489 If SAL is already past the prologue, then do nothing. */
5492 skip_prologue_sal (struct symtab_and_line
*sal
)
5494 struct symbol
*sym
= find_pc_function (sal
->pc
);
5495 struct symtab_and_line start_sal
;
5500 start_sal
= find_function_start_sal (sym
, 1);
5501 if (sal
->pc
< start_sal
.pc
)
5505 /* Helper function for break_command_1 and disassemble_command. */
5508 resolve_sal_pc (struct symtab_and_line
*sal
)
5512 if (sal
->pc
== 0 && sal
->symtab
!= NULL
)
5514 if (!find_line_pc (sal
->symtab
, sal
->line
, &pc
))
5515 error (_("No line %d in file \"%s\"."),
5516 sal
->line
, sal
->symtab
->filename
);
5519 /* If this SAL corresponds to a breakpoint inserted using
5520 a line number, then skip the function prologue if necessary. */
5521 if (sal
->explicit_line
)
5522 skip_prologue_sal (sal
);
5525 if (sal
->section
== 0 && sal
->symtab
!= NULL
)
5527 struct blockvector
*bv
;
5531 bv
= blockvector_for_pc_sect (sal
->pc
, 0, &b
, sal
->symtab
);
5534 sym
= block_function (b
);
5537 fixup_symbol_section (sym
, sal
->symtab
->objfile
);
5538 sal
->section
= SYMBOL_BFD_SECTION (sym
);
5542 /* It really is worthwhile to have the section, so we'll just
5543 have to look harder. This case can be executed if we have
5544 line numbers but no functions (as can happen in assembly
5547 struct minimal_symbol
*msym
;
5549 msym
= lookup_minimal_symbol_by_pc (sal
->pc
);
5551 sal
->section
= SYMBOL_BFD_SECTION (msym
);
5558 break_command (char *arg
, int from_tty
)
5560 break_command_1 (arg
, 0, from_tty
);
5564 tbreak_command (char *arg
, int from_tty
)
5566 break_command_1 (arg
, BP_TEMPFLAG
, from_tty
);
5570 hbreak_command (char *arg
, int from_tty
)
5572 break_command_1 (arg
, BP_HARDWAREFLAG
, from_tty
);
5576 thbreak_command (char *arg
, int from_tty
)
5578 break_command_1 (arg
, (BP_TEMPFLAG
| BP_HARDWAREFLAG
), from_tty
);
5582 stop_command (char *arg
, int from_tty
)
5584 printf_filtered (_("Specify the type of breakpoint to set.\n\
5585 Usage: stop in <function | address>\n\
5586 stop at <line>\n"));
5590 stopin_command (char *arg
, int from_tty
)
5594 if (arg
== (char *) NULL
)
5596 else if (*arg
!= '*')
5601 /* look for a ':'. If this is a line number specification, then
5602 say it is bad, otherwise, it should be an address or
5603 function/method name */
5604 while (*argptr
&& !hasColon
)
5606 hasColon
= (*argptr
== ':');
5611 badInput
= (*argptr
!= ':'); /* Not a class::method */
5613 badInput
= isdigit (*arg
); /* a simple line number */
5617 printf_filtered (_("Usage: stop in <function | address>\n"));
5619 break_command_1 (arg
, 0, from_tty
);
5623 stopat_command (char *arg
, int from_tty
)
5627 if (arg
== (char *) NULL
|| *arg
== '*') /* no line number */
5634 /* look for a ':'. If there is a '::' then get out, otherwise
5635 it is probably a line number. */
5636 while (*argptr
&& !hasColon
)
5638 hasColon
= (*argptr
== ':');
5643 badInput
= (*argptr
== ':'); /* we have class::method */
5645 badInput
= !isdigit (*arg
); /* not a line number */
5649 printf_filtered (_("Usage: stop at <line>\n"));
5651 break_command_1 (arg
, 0, from_tty
);
5654 /* accessflag: hw_write: watch write,
5655 hw_read: watch read,
5656 hw_access: watch access (read or write) */
5658 watch_command_1 (char *arg
, int accessflag
, int from_tty
)
5660 struct breakpoint
*b
, *scope_breakpoint
= NULL
;
5661 struct symtab_and_line sal
;
5662 struct expression
*exp
;
5663 struct block
*exp_valid_block
;
5664 struct value
*val
, *mark
;
5665 struct frame_info
*frame
;
5666 struct frame_info
*prev_frame
= NULL
;
5667 char *exp_start
= NULL
;
5668 char *exp_end
= NULL
;
5669 char *tok
, *id_tok_start
, *end_tok
;
5671 char *cond_start
= NULL
;
5672 char *cond_end
= NULL
;
5673 struct expression
*cond
= NULL
;
5674 int i
, other_type_used
, target_resources_ok
= 0;
5675 enum bptype bp_type
;
5679 init_sal (&sal
); /* initialize to zeroes */
5681 /* Make sure that we actually have parameters to parse. */
5682 if (arg
!= NULL
&& arg
[0] != '\0')
5684 toklen
= strlen (arg
); /* Size of argument list. */
5686 /* Points tok to the end of the argument list. */
5687 tok
= arg
+ toklen
- 1;
5689 /* Go backwards in the parameters list. Skip the last parameter.
5690 If we're expecting a 'thread <thread_num>' parameter, this should
5691 be the thread identifier. */
5692 while (tok
> arg
&& (*tok
== ' ' || *tok
== '\t'))
5694 while (tok
> arg
&& (*tok
!= ' ' && *tok
!= '\t'))
5697 /* Points end_tok to the beginning of the last token. */
5698 id_tok_start
= tok
+ 1;
5700 /* Go backwards in the parameters list. Skip one more parameter.
5701 If we're expecting a 'thread <thread_num>' parameter, we should
5702 reach a "thread" token. */
5703 while (tok
> arg
&& (*tok
== ' ' || *tok
== '\t'))
5708 while (tok
> arg
&& (*tok
!= ' ' && *tok
!= '\t'))
5711 /* Move the pointer forward to skip the whitespace and
5712 calculate the length of the token. */
5714 toklen
= end_tok
- tok
;
5716 if (toklen
>= 1 && strncmp (tok
, "thread", toklen
) == 0)
5718 /* At this point we've found a "thread" token, which means
5719 the user is trying to set a watchpoint that triggers
5720 only in a specific thread. */
5723 /* Extract the thread ID from the next token. */
5724 thread
= strtol (id_tok_start
, &endp
, 0);
5726 /* Check if the user provided a valid numeric value for the
5728 if (*endp
!= ' ' && *endp
!= '\t' && *endp
!= '\0')
5729 error (_("Invalid thread ID specification %s."), id_tok_start
);
5731 /* Check if the thread actually exists. */
5732 if (!valid_thread_id (thread
))
5733 error (_("Unknown thread %d."), thread
);
5735 /* Truncate the string and get rid of the thread <thread_num>
5736 parameter before the parameter list is parsed by the
5737 evaluate_expression() function. */
5742 /* Parse the rest of the arguments. */
5743 innermost_block
= NULL
;
5745 exp
= parse_exp_1 (&arg
, 0, 0);
5747 exp_valid_block
= innermost_block
;
5748 mark
= value_mark ();
5749 val
= evaluate_expression (exp
);
5750 release_value (val
);
5751 if (value_lazy (val
))
5752 value_fetch_lazy (val
);
5755 while (*tok
== ' ' || *tok
== '\t')
5759 while (*end_tok
!= ' ' && *end_tok
!= '\t' && *end_tok
!= '\000')
5762 toklen
= end_tok
- tok
;
5763 if (toklen
>= 1 && strncmp (tok
, "if", toklen
) == 0)
5765 tok
= cond_start
= end_tok
+ 1;
5766 cond
= parse_exp_1 (&tok
, 0, 0);
5770 error (_("Junk at end of command."));
5772 if (accessflag
== hw_read
)
5773 bp_type
= bp_read_watchpoint
;
5774 else if (accessflag
== hw_access
)
5775 bp_type
= bp_access_watchpoint
;
5777 bp_type
= bp_hardware_watchpoint
;
5779 mem_cnt
= can_use_hardware_watchpoint (val
);
5780 if (mem_cnt
== 0 && bp_type
!= bp_hardware_watchpoint
)
5781 error (_("Expression cannot be implemented with read/access watchpoint."));
5784 i
= hw_watchpoint_used_count (bp_type
, &other_type_used
);
5785 target_resources_ok
=
5786 TARGET_CAN_USE_HARDWARE_WATCHPOINT (bp_type
, i
+ mem_cnt
,
5788 if (target_resources_ok
== 0 && bp_type
!= bp_hardware_watchpoint
)
5789 error (_("Target does not support this type of hardware watchpoint."));
5791 if (target_resources_ok
< 0 && bp_type
!= bp_hardware_watchpoint
)
5792 error (_("Target can only support one kind of HW watchpoint at a time."));
5795 /* Change the type of breakpoint to an ordinary watchpoint if a hardware
5796 watchpoint could not be set. */
5797 if (!mem_cnt
|| target_resources_ok
<= 0)
5798 bp_type
= bp_watchpoint
;
5800 frame
= block_innermost_frame (exp_valid_block
);
5802 prev_frame
= get_prev_frame (frame
);
5806 /* If the expression is "local", then set up a "watchpoint scope"
5807 breakpoint at the point where we've left the scope of the watchpoint
5808 expression. Create the scope breakpoint before the watchpoint, so
5809 that we will encounter it first in bpstat_stop_status. */
5810 if (innermost_block
&& prev_frame
)
5812 scope_breakpoint
= create_internal_breakpoint (get_frame_pc (prev_frame
),
5813 bp_watchpoint_scope
);
5815 scope_breakpoint
->enable_state
= bp_enabled
;
5817 /* Automatically delete the breakpoint when it hits. */
5818 scope_breakpoint
->disposition
= disp_del
;
5820 /* Only break in the proper frame (help with recursion). */
5821 scope_breakpoint
->frame_id
= get_frame_id (prev_frame
);
5823 /* Set the address at which we will stop. */
5824 scope_breakpoint
->loc
->requested_address
5825 = get_frame_pc (prev_frame
);
5826 scope_breakpoint
->loc
->address
5827 = adjust_breakpoint_address (scope_breakpoint
->loc
->requested_address
,
5828 scope_breakpoint
->type
);
5831 /* Now set up the breakpoint. */
5832 b
= set_raw_breakpoint (sal
, bp_type
);
5833 set_breakpoint_count (breakpoint_count
+ 1);
5834 b
->number
= breakpoint_count
;
5836 b
->disposition
= disp_donttouch
;
5838 b
->exp_valid_block
= exp_valid_block
;
5839 b
->exp_string
= savestring (exp_start
, exp_end
- exp_start
);
5841 b
->loc
->cond
= cond
;
5843 b
->cond_string
= savestring (cond_start
, cond_end
- cond_start
);
5848 b
->watchpoint_frame
= get_frame_id (frame
);
5850 b
->watchpoint_frame
= null_frame_id
;
5852 if (scope_breakpoint
!= NULL
)
5854 /* The scope breakpoint is related to the watchpoint. We will
5855 need to act on them together. */
5856 b
->related_breakpoint
= scope_breakpoint
;
5857 scope_breakpoint
->related_breakpoint
= b
;
5860 value_free_to_mark (mark
);
5864 /* Return count of locations need to be watched and can be handled
5865 in hardware. If the watchpoint can not be handled
5866 in hardware return zero. */
5869 can_use_hardware_watchpoint (struct value
*v
)
5871 int found_memory_cnt
= 0;
5872 struct value
*head
= v
;
5874 /* Did the user specifically forbid us to use hardware watchpoints? */
5875 if (!can_use_hw_watchpoints
)
5878 /* Make sure that the value of the expression depends only upon
5879 memory contents, and values computed from them within GDB. If we
5880 find any register references or function calls, we can't use a
5881 hardware watchpoint.
5883 The idea here is that evaluating an expression generates a series
5884 of values, one holding the value of every subexpression. (The
5885 expression a*b+c has five subexpressions: a, b, a*b, c, and
5886 a*b+c.) GDB's values hold almost enough information to establish
5887 the criteria given above --- they identify memory lvalues,
5888 register lvalues, computed values, etcetera. So we can evaluate
5889 the expression, and then scan the chain of values that leaves
5890 behind to decide whether we can detect any possible change to the
5891 expression's final value using only hardware watchpoints.
5893 However, I don't think that the values returned by inferior
5894 function calls are special in any way. So this function may not
5895 notice that an expression involving an inferior function call
5896 can't be watched with hardware watchpoints. FIXME. */
5897 for (; v
; v
= value_next (v
))
5899 if (VALUE_LVAL (v
) == lval_memory
)
5902 /* A lazy memory lvalue is one that GDB never needed to fetch;
5903 we either just used its address (e.g., `a' in `a.b') or
5904 we never needed it at all (e.g., `a' in `a,b'). */
5908 /* Ahh, memory we actually used! Check if we can cover
5909 it with hardware watchpoints. */
5910 struct type
*vtype
= check_typedef (value_type (v
));
5912 /* We only watch structs and arrays if user asked for it
5913 explicitly, never if they just happen to appear in a
5914 middle of some value chain. */
5916 || (TYPE_CODE (vtype
) != TYPE_CODE_STRUCT
5917 && TYPE_CODE (vtype
) != TYPE_CODE_ARRAY
))
5919 CORE_ADDR vaddr
= VALUE_ADDRESS (v
) + value_offset (v
);
5920 int len
= TYPE_LENGTH (value_type (v
));
5922 if (!TARGET_REGION_OK_FOR_HW_WATCHPOINT (vaddr
, len
))
5929 else if (VALUE_LVAL (v
) != not_lval
5930 && deprecated_value_modifiable (v
) == 0)
5931 return 0; /* ??? What does this represent? */
5932 else if (VALUE_LVAL (v
) == lval_register
)
5933 return 0; /* cannot watch a register with a HW watchpoint */
5936 /* The expression itself looks suitable for using a hardware
5937 watchpoint, but give the target machine a chance to reject it. */
5938 return found_memory_cnt
;
5942 watch_command_wrapper (char *arg
, int from_tty
)
5944 watch_command (arg
, from_tty
);
5948 watch_command (char *arg
, int from_tty
)
5950 watch_command_1 (arg
, hw_write
, from_tty
);
5954 rwatch_command_wrapper (char *arg
, int from_tty
)
5956 rwatch_command (arg
, from_tty
);
5960 rwatch_command (char *arg
, int from_tty
)
5962 watch_command_1 (arg
, hw_read
, from_tty
);
5966 awatch_command_wrapper (char *arg
, int from_tty
)
5968 awatch_command (arg
, from_tty
);
5972 awatch_command (char *arg
, int from_tty
)
5974 watch_command_1 (arg
, hw_access
, from_tty
);
5978 /* Helper routines for the until_command routine in infcmd.c. Here
5979 because it uses the mechanisms of breakpoints. */
5981 /* This function is called by fetch_inferior_event via the
5982 cmd_continuation pointer, to complete the until command. It takes
5983 care of cleaning up the temporary breakpoints set up by the until
5986 until_break_command_continuation (struct continuation_arg
*arg
)
5988 struct cleanup
*cleanups
;
5990 cleanups
= (struct cleanup
*) arg
->data
.pointer
;
5991 do_exec_cleanups (cleanups
);
5995 until_break_command (char *arg
, int from_tty
, int anywhere
)
5997 struct symtabs_and_lines sals
;
5998 struct symtab_and_line sal
;
5999 struct frame_info
*frame
= get_selected_frame (NULL
);
6000 struct frame_info
*prev_frame
= get_prev_frame (frame
);
6001 struct breakpoint
*breakpoint
;
6002 struct cleanup
*old_chain
;
6003 struct continuation_arg
*arg1
;
6006 clear_proceed_status ();
6008 /* Set a breakpoint where the user wants it and at return from
6011 if (default_breakpoint_valid
)
6012 sals
= decode_line_1 (&arg
, 1, default_breakpoint_symtab
,
6013 default_breakpoint_line
, (char ***) NULL
, NULL
);
6015 sals
= decode_line_1 (&arg
, 1, (struct symtab
*) NULL
,
6016 0, (char ***) NULL
, NULL
);
6018 if (sals
.nelts
!= 1)
6019 error (_("Couldn't get information on specified line."));
6022 xfree (sals
.sals
); /* malloc'd, so freed */
6025 error (_("Junk at end of arguments."));
6027 resolve_sal_pc (&sal
);
6030 /* If the user told us to continue until a specified location,
6031 we don't specify a frame at which we need to stop. */
6032 breakpoint
= set_momentary_breakpoint (sal
, null_frame_id
, bp_until
);
6034 /* Otherwise, specify the current frame, because we want to stop only
6035 at the very same frame. */
6036 breakpoint
= set_momentary_breakpoint (sal
, get_frame_id (frame
),
6039 if (!target_can_async_p ())
6040 old_chain
= make_cleanup_delete_breakpoint (breakpoint
);
6042 old_chain
= make_exec_cleanup_delete_breakpoint (breakpoint
);
6044 /* If we are running asynchronously, and the target supports async
6045 execution, we are not waiting for the target to stop, in the call
6046 tp proceed, below. This means that we cannot delete the
6047 brekpoints until the target has actually stopped. The only place
6048 where we get a chance to do that is in fetch_inferior_event, so
6049 we must set things up for that. */
6051 if (target_can_async_p ())
6053 /* In this case the arg for the continuation is just the point
6054 in the exec_cleanups chain from where to start doing
6055 cleanups, because all the continuation does is the cleanups in
6056 the exec_cleanup_chain. */
6058 (struct continuation_arg
*) xmalloc (sizeof (struct continuation_arg
));
6060 arg1
->data
.pointer
= old_chain
;
6062 add_continuation (until_break_command_continuation
, arg1
);
6065 /* Keep within the current frame, or in frames called by the current
6069 sal
= find_pc_line (get_frame_pc (prev_frame
), 0);
6070 sal
.pc
= get_frame_pc (prev_frame
);
6071 breakpoint
= set_momentary_breakpoint (sal
, get_frame_id (prev_frame
),
6073 if (!target_can_async_p ())
6074 make_cleanup_delete_breakpoint (breakpoint
);
6076 make_exec_cleanup_delete_breakpoint (breakpoint
);
6079 proceed (-1, TARGET_SIGNAL_DEFAULT
, 0);
6080 /* Do the cleanups now, anly if we are not running asynchronously,
6081 of if we are, but the target is still synchronous. */
6082 if (!target_can_async_p ())
6083 do_cleanups (old_chain
);
6087 ep_skip_leading_whitespace (char **s
)
6089 if ((s
== NULL
) || (*s
== NULL
))
6091 while (isspace (**s
))
6095 /* This function examines a string, and attempts to find a token
6096 that might be an event name in the leading characters. If a
6097 possible match is found, a pointer to the last character of
6098 the token is returned. Else, NULL is returned. */
6101 ep_find_event_name_end (char *arg
)
6104 char *event_name_end
= NULL
;
6106 /* If we could depend upon the presense of strrpbrk, we'd use that... */
6110 /* We break out of the loop when we find a token delimiter.
6111 Basically, we're looking for alphanumerics and underscores;
6112 anything else delimites the token. */
6115 if (!isalnum (*s
) && (*s
!= '_'))
6121 return event_name_end
;
6125 /* This function attempts to parse an optional "if <cond>" clause
6126 from the arg string. If one is not found, it returns NULL.
6128 Else, it returns a pointer to the condition string. (It does not
6129 attempt to evaluate the string against a particular block.) And,
6130 it updates arg to point to the first character following the parsed
6131 if clause in the arg string. */
6134 ep_parse_optional_if_clause (char **arg
)
6138 if (((*arg
)[0] != 'i') || ((*arg
)[1] != 'f') || !isspace ((*arg
)[2]))
6141 /* Skip the "if" keyword. */
6144 /* Skip any extra leading whitespace, and record the start of the
6145 condition string. */
6146 ep_skip_leading_whitespace (arg
);
6149 /* Assume that the condition occupies the remainder of the arg string. */
6150 (*arg
) += strlen (cond_string
);
6155 /* This function attempts to parse an optional filename from the arg
6156 string. If one is not found, it returns NULL.
6158 Else, it returns a pointer to the parsed filename. (This function
6159 makes no attempt to verify that a file of that name exists, or is
6160 accessible.) And, it updates arg to point to the first character
6161 following the parsed filename in the arg string.
6163 Note that clients needing to preserve the returned filename for
6164 future access should copy it to their own buffers. */
6166 ep_parse_optional_filename (char **arg
)
6168 static char filename
[1024];
6173 if ((*arg_p
== '\0') || isspace (*arg_p
))
6191 /* Commands to deal with catching events, such as signals, exceptions,
6192 process start/exit, etc. */
6196 catch_fork
, catch_vfork
6201 catch_fork_command_1 (catch_fork_kind fork_kind
, char *arg
, int tempflag
,
6204 char *cond_string
= NULL
;
6206 ep_skip_leading_whitespace (&arg
);
6208 /* The allowed syntax is:
6210 catch [v]fork if <cond>
6212 First, check if there's an if clause. */
6213 cond_string
= ep_parse_optional_if_clause (&arg
);
6215 if ((*arg
!= '\0') && !isspace (*arg
))
6216 error (_("Junk at end of arguments."));
6218 /* If this target supports it, create a fork or vfork catchpoint
6219 and enable reporting of such events. */
6223 create_fork_event_catchpoint (tempflag
, cond_string
);
6226 create_vfork_event_catchpoint (tempflag
, cond_string
);
6229 error (_("unsupported or unknown fork kind; cannot catch it"));
6235 catch_exec_command_1 (char *arg
, int tempflag
, int from_tty
)
6237 char *cond_string
= NULL
;
6239 ep_skip_leading_whitespace (&arg
);
6241 /* The allowed syntax is:
6243 catch exec if <cond>
6245 First, check if there's an if clause. */
6246 cond_string
= ep_parse_optional_if_clause (&arg
);
6248 if ((*arg
!= '\0') && !isspace (*arg
))
6249 error (_("Junk at end of arguments."));
6251 /* If this target supports it, create an exec catchpoint
6252 and enable reporting of such events. */
6253 create_exec_event_catchpoint (tempflag
, cond_string
);
6257 catch_load_command_1 (char *arg
, int tempflag
, int from_tty
)
6259 char *dll_pathname
= NULL
;
6260 char *cond_string
= NULL
;
6262 ep_skip_leading_whitespace (&arg
);
6264 /* The allowed syntax is:
6266 catch load if <cond>
6267 catch load <filename>
6268 catch load <filename> if <cond>
6270 The user is not allowed to specify the <filename> after an
6273 We'll ignore the pathological case of a file named "if".
6275 First, check if there's an if clause. If so, then there
6276 cannot be a filename. */
6277 cond_string
= ep_parse_optional_if_clause (&arg
);
6279 /* If there was an if clause, then there cannot be a filename.
6280 Else, there might be a filename and an if clause. */
6281 if (cond_string
== NULL
)
6283 dll_pathname
= ep_parse_optional_filename (&arg
);
6284 ep_skip_leading_whitespace (&arg
);
6285 cond_string
= ep_parse_optional_if_clause (&arg
);
6288 if ((*arg
!= '\0') && !isspace (*arg
))
6289 error (_("Junk at end of arguments."));
6291 /* Create a load breakpoint that only triggers when a load of
6292 the specified dll (or any dll, if no pathname was specified)
6294 SOLIB_CREATE_CATCH_LOAD_HOOK (PIDGET (inferior_ptid
), tempflag
,
6295 dll_pathname
, cond_string
);
6299 catch_unload_command_1 (char *arg
, int tempflag
, int from_tty
)
6301 char *dll_pathname
= NULL
;
6302 char *cond_string
= NULL
;
6304 ep_skip_leading_whitespace (&arg
);
6306 /* The allowed syntax is:
6308 catch unload if <cond>
6309 catch unload <filename>
6310 catch unload <filename> if <cond>
6312 The user is not allowed to specify the <filename> after an
6315 We'll ignore the pathological case of a file named "if".
6317 First, check if there's an if clause. If so, then there
6318 cannot be a filename. */
6319 cond_string
= ep_parse_optional_if_clause (&arg
);
6321 /* If there was an if clause, then there cannot be a filename.
6322 Else, there might be a filename and an if clause. */
6323 if (cond_string
== NULL
)
6325 dll_pathname
= ep_parse_optional_filename (&arg
);
6326 ep_skip_leading_whitespace (&arg
);
6327 cond_string
= ep_parse_optional_if_clause (&arg
);
6330 if ((*arg
!= '\0') && !isspace (*arg
))
6331 error (_("Junk at end of arguments."));
6333 /* Create an unload breakpoint that only triggers when an unload of
6334 the specified dll (or any dll, if no pathname was specified)
6336 SOLIB_CREATE_CATCH_UNLOAD_HOOK (PIDGET (inferior_ptid
), tempflag
,
6337 dll_pathname
, cond_string
);
6340 static enum print_stop_action
6341 print_exception_catchpoint (struct breakpoint
*b
)
6343 annotate_catchpoint (b
->number
);
6345 if (strstr (b
->addr_string
, "throw") != NULL
)
6346 printf_filtered (_("\nCatchpoint %d (exception thrown)\n"),
6349 printf_filtered (_("\nCatchpoint %d (exception caught)\n"),
6352 return PRINT_SRC_AND_LOC
;
6356 print_one_exception_catchpoint (struct breakpoint
*b
, CORE_ADDR
*last_addr
)
6361 ui_out_field_core_addr (uiout
, "addr", b
->loc
->address
);
6364 *last_addr
= b
->loc
->address
;
6365 if (strstr (b
->addr_string
, "throw") != NULL
)
6366 ui_out_field_string (uiout
, "what", "exception throw");
6368 ui_out_field_string (uiout
, "what", "exception catch");
6372 print_mention_exception_catchpoint (struct breakpoint
*b
)
6374 if (strstr (b
->addr_string
, "throw") != NULL
)
6375 printf_filtered (_("Catchpoint %d (throw)"), b
->number
);
6377 printf_filtered (_("Catchpoint %d (catch)"), b
->number
);
6380 static struct breakpoint_ops gnu_v3_exception_catchpoint_ops
= {
6381 print_exception_catchpoint
,
6382 print_one_exception_catchpoint
,
6383 print_mention_exception_catchpoint
6387 handle_gnu_v3_exceptions (int tempflag
, char *cond_string
,
6388 enum exception_event_kind ex_event
, int from_tty
)
6390 char *trigger_func_name
, *nameptr
;
6391 struct symtabs_and_lines sals
;
6392 struct breakpoint
*b
;
6394 if (ex_event
== EX_EVENT_CATCH
)
6395 trigger_func_name
= xstrdup ("__cxa_begin_catch");
6397 trigger_func_name
= xstrdup ("__cxa_throw");
6399 nameptr
= trigger_func_name
;
6400 sals
= decode_line_1 (&nameptr
, 1, NULL
, 0, NULL
, NULL
);
6401 if (sals
.nelts
== 0)
6403 xfree (trigger_func_name
);
6407 b
= set_raw_breakpoint (sals
.sals
[0], bp_breakpoint
);
6408 set_breakpoint_count (breakpoint_count
+ 1);
6409 b
->number
= breakpoint_count
;
6410 b
->cond_string
= (cond_string
== NULL
) ?
6411 NULL
: savestring (cond_string
, strlen (cond_string
));
6413 b
->addr_string
= trigger_func_name
;
6414 b
->enable_state
= bp_enabled
;
6415 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
6416 b
->ops
= &gnu_v3_exception_catchpoint_ops
;
6423 /* Deal with "catch catch" and "catch throw" commands */
6426 catch_exception_command_1 (enum exception_event_kind ex_event
, char *arg
,
6427 int tempflag
, int from_tty
)
6429 char *cond_string
= NULL
;
6430 struct symtab_and_line
*sal
= NULL
;
6432 ep_skip_leading_whitespace (&arg
);
6434 cond_string
= ep_parse_optional_if_clause (&arg
);
6436 if ((*arg
!= '\0') && !isspace (*arg
))
6437 error (_("Junk at end of arguments."));
6439 if ((ex_event
!= EX_EVENT_THROW
) &&
6440 (ex_event
!= EX_EVENT_CATCH
))
6441 error (_("Unsupported or unknown exception event; cannot catch it"));
6443 if (handle_gnu_v3_exceptions (tempflag
, cond_string
, ex_event
, from_tty
))
6446 warning (_("Unsupported with this platform/compiler combination."));
6449 /* Create a breakpoint struct for Ada exception catchpoints. */
6452 create_ada_exception_breakpoint (struct symtab_and_line sal
,
6456 struct expression
*cond
,
6457 struct breakpoint_ops
*ops
,
6461 struct breakpoint
*b
;
6465 describe_other_breakpoints (sal
.pc
, sal
.section
, -1);
6466 /* FIXME: brobecker/2006-12-28: Actually, re-implement a special
6467 version for exception catchpoints, because two catchpoints
6468 used for different exception names will use the same address.
6469 In this case, a "breakpoint ... also set at..." warning is
6470 unproductive. Besides. the warning phrasing is also a bit
6471 inapropriate, we should use the word catchpoint, and tell
6472 the user what type of catchpoint it is. The above is good
6473 enough for now, though. */
6476 b
= set_raw_breakpoint (sal
, bp_breakpoint
);
6477 set_breakpoint_count (breakpoint_count
+ 1);
6479 b
->enable_state
= bp_enabled
;
6480 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
6481 b
->number
= breakpoint_count
;
6482 b
->ignore_count
= 0;
6483 b
->loc
->cond
= cond
;
6484 b
->addr_string
= addr_string
;
6485 b
->language
= language_ada
;
6486 b
->cond_string
= cond_string
;
6487 b
->exp_string
= exp_string
;
6494 /* Implement the "catch exception" command. */
6497 catch_ada_exception_command (char *arg
, int tempflag
, int from_tty
)
6499 struct symtab_and_line sal
;
6501 char *addr_string
= NULL
;
6502 char *exp_string
= NULL
;
6503 char *cond_string
= NULL
;
6504 struct expression
*cond
= NULL
;
6505 struct breakpoint_ops
*ops
= NULL
;
6507 sal
= ada_decode_exception_location (arg
, &addr_string
, &exp_string
,
6508 &cond_string
, &cond
, &ops
);
6509 create_ada_exception_breakpoint (sal
, addr_string
, exp_string
,
6510 cond_string
, cond
, ops
, tempflag
,
6514 /* Implement the "catch assert" command. */
6517 catch_assert_command (char *arg
, int tempflag
, int from_tty
)
6519 struct symtab_and_line sal
;
6520 char *addr_string
= NULL
;
6521 struct breakpoint_ops
*ops
= NULL
;
6523 sal
= ada_decode_assert_location (arg
, &addr_string
, &ops
);
6524 create_ada_exception_breakpoint (sal
, addr_string
, NULL
, NULL
, NULL
, ops
,
6525 tempflag
, from_tty
);
6529 catch_command_1 (char *arg
, int tempflag
, int from_tty
)
6532 /* The first argument may be an event name, such as "start" or "load".
6533 If so, then handle it as such. If it doesn't match an event name,
6534 then attempt to interpret it as an exception name. (This latter is
6535 the v4.16-and-earlier GDB meaning of the "catch" command.)
6537 First, try to find the bounds of what might be an event name. */
6538 char *arg1_start
= arg
;
6542 if (arg1_start
== NULL
)
6544 /* Old behaviour was to use pre-v-4.16 syntax */
6545 /* catch_throw_command_1 (arg1_start, tempflag, from_tty); */
6547 /* Now, this is not allowed */
6548 error (_("Catch requires an event name."));
6551 arg1_end
= ep_find_event_name_end (arg1_start
);
6552 if (arg1_end
== NULL
)
6553 error (_("catch requires an event"));
6554 arg1_length
= arg1_end
+ 1 - arg1_start
;
6556 /* Try to match what we found against known event names. */
6557 if (strncmp (arg1_start
, "signal", arg1_length
) == 0)
6559 error (_("Catch of signal not yet implemented"));
6561 else if (strncmp (arg1_start
, "catch", arg1_length
) == 0)
6563 catch_exception_command_1 (EX_EVENT_CATCH
, arg1_end
+ 1,
6564 tempflag
, from_tty
);
6566 else if (strncmp (arg1_start
, "throw", arg1_length
) == 0)
6568 catch_exception_command_1 (EX_EVENT_THROW
, arg1_end
+ 1,
6569 tempflag
, from_tty
);
6571 else if (strncmp (arg1_start
, "thread_start", arg1_length
) == 0)
6573 error (_("Catch of thread_start not yet implemented"));
6575 else if (strncmp (arg1_start
, "thread_exit", arg1_length
) == 0)
6577 error (_("Catch of thread_exit not yet implemented"));
6579 else if (strncmp (arg1_start
, "thread_join", arg1_length
) == 0)
6581 error (_("Catch of thread_join not yet implemented"));
6583 else if (strncmp (arg1_start
, "start", arg1_length
) == 0)
6585 error (_("Catch of start not yet implemented"));
6587 else if (strncmp (arg1_start
, "exit", arg1_length
) == 0)
6589 error (_("Catch of exit not yet implemented"));
6591 else if (strncmp (arg1_start
, "fork", arg1_length
) == 0)
6593 catch_fork_command_1 (catch_fork
, arg1_end
+ 1, tempflag
, from_tty
);
6595 else if (strncmp (arg1_start
, "vfork", arg1_length
) == 0)
6597 catch_fork_command_1 (catch_vfork
, arg1_end
+ 1, tempflag
, from_tty
);
6599 else if (strncmp (arg1_start
, "exec", arg1_length
) == 0)
6601 catch_exec_command_1 (arg1_end
+ 1, tempflag
, from_tty
);
6603 else if (strncmp (arg1_start
, "load", arg1_length
) == 0)
6605 catch_load_command_1 (arg1_end
+ 1, tempflag
, from_tty
);
6607 else if (strncmp (arg1_start
, "unload", arg1_length
) == 0)
6609 catch_unload_command_1 (arg1_end
+ 1, tempflag
, from_tty
);
6611 else if (strncmp (arg1_start
, "stop", arg1_length
) == 0)
6613 error (_("Catch of stop not yet implemented"));
6615 else if (strncmp (arg1_start
, "exception", arg1_length
) == 0)
6617 catch_ada_exception_command (arg1_end
+ 1, tempflag
, from_tty
);
6620 else if (strncmp (arg1_start
, "assert", arg1_length
) == 0)
6622 catch_assert_command (arg1_end
+ 1, tempflag
, from_tty
);
6625 /* This doesn't appear to be an event name */
6629 /* Pre-v.4.16 behaviour was to treat the argument
6630 as the name of an exception */
6631 /* catch_throw_command_1 (arg1_start, tempflag, from_tty); */
6632 /* Now this is not allowed */
6633 error (_("Unknown event kind specified for catch"));
6639 catch_command (char *arg
, int from_tty
)
6641 catch_command_1 (arg
, 0, from_tty
);
6646 tcatch_command (char *arg
, int from_tty
)
6648 catch_command_1 (arg
, 1, from_tty
);
6651 /* Delete breakpoints by address or line. */
6654 clear_command (char *arg
, int from_tty
)
6656 struct breakpoint
*b
;
6657 VEC(breakpoint_p
) *found
= 0;
6660 struct symtabs_and_lines sals
;
6661 struct symtab_and_line sal
;
6666 sals
= decode_line_spec (arg
, 1);
6671 sals
.sals
= (struct symtab_and_line
*)
6672 xmalloc (sizeof (struct symtab_and_line
));
6673 make_cleanup (xfree
, sals
.sals
);
6674 init_sal (&sal
); /* initialize to zeroes */
6675 sal
.line
= default_breakpoint_line
;
6676 sal
.symtab
= default_breakpoint_symtab
;
6677 sal
.pc
= default_breakpoint_address
;
6678 if (sal
.symtab
== 0)
6679 error (_("No source file specified."));
6687 /* We don't call resolve_sal_pc here. That's not
6688 as bad as it seems, because all existing breakpoints
6689 typically have both file/line and pc set. So, if
6690 clear is given file/line, we can match this to existing
6691 breakpoint without obtaining pc at all.
6693 We only support clearing given the address explicitly
6694 present in breakpoint table. Say, we've set breakpoint
6695 at file:line. There were several PC values for that file:line,
6696 due to optimization, all in one block.
6697 We've picked one PC value. If "clear" is issued with another
6698 PC corresponding to the same file:line, the breakpoint won't
6699 be cleared. We probably can still clear the breakpoint, but
6700 since the other PC value is never presented to user, user
6701 can only find it by guessing, and it does not seem important
6704 /* For each line spec given, delete bps which correspond
6705 to it. Do it in two passes, solely to preserve the current
6706 behavior that from_tty is forced true if we delete more than
6710 for (i
= 0; i
< sals
.nelts
; i
++)
6712 /* If exact pc given, clear bpts at that pc.
6713 If line given (pc == 0), clear all bpts on specified line.
6714 If defaulting, clear all bpts on default line
6717 defaulting sal.pc != 0 tests to do
6722 1 0 <can't happen> */
6726 /* Find all matching breakpoints and add them to
6731 /* Are we going to delete b? */
6732 if (b
->type
!= bp_none
6733 && b
->type
!= bp_watchpoint
6734 && b
->type
!= bp_hardware_watchpoint
6735 && b
->type
!= bp_read_watchpoint
6736 && b
->type
!= bp_access_watchpoint
)
6738 struct bp_location
*loc
= b
->loc
;
6739 for (; loc
; loc
= loc
->next
)
6741 int pc_match
= sal
.pc
6742 && (loc
->address
== sal
.pc
)
6743 && (!section_is_overlay (loc
->section
)
6744 || loc
->section
== sal
.section
);
6745 int line_match
= ((default_match
|| (0 == sal
.pc
))
6746 && b
->source_file
!= NULL
6747 && sal
.symtab
!= NULL
6748 && strcmp (b
->source_file
, sal
.symtab
->filename
) == 0
6749 && b
->line_number
== sal
.line
);
6750 if (pc_match
|| line_match
)
6759 VEC_safe_push(breakpoint_p
, found
, b
);
6762 /* Now go thru the 'found' chain and delete them. */
6763 if (VEC_empty(breakpoint_p
, found
))
6766 error (_("No breakpoint at %s."), arg
);
6768 error (_("No breakpoint at this line."));
6771 if (VEC_length(breakpoint_p
, found
) > 1)
6772 from_tty
= 1; /* Always report if deleted more than one */
6775 if (VEC_length(breakpoint_p
, found
) == 1)
6776 printf_unfiltered (_("Deleted breakpoint "));
6778 printf_unfiltered (_("Deleted breakpoints "));
6780 breakpoints_changed ();
6782 for (ix
= 0; VEC_iterate(breakpoint_p
, found
, ix
, b
); ix
++)
6785 printf_unfiltered ("%d ", b
->number
);
6786 delete_breakpoint (b
);
6789 putchar_unfiltered ('\n');
6792 /* Delete breakpoint in BS if they are `delete' breakpoints and
6793 all breakpoints that are marked for deletion, whether hit or not.
6794 This is called after any breakpoint is hit, or after errors. */
6797 breakpoint_auto_delete (bpstat bs
)
6799 struct breakpoint
*b
, *temp
;
6801 for (; bs
; bs
= bs
->next
)
6802 if (bs
->breakpoint_at
&& bs
->breakpoint_at
->owner
->disposition
== disp_del
6804 delete_breakpoint (bs
->breakpoint_at
->owner
);
6806 ALL_BREAKPOINTS_SAFE (b
, temp
)
6808 if (b
->disposition
== disp_del_at_next_stop
)
6809 delete_breakpoint (b
);
6813 /* Remove locations of breakpoint BPT from
6814 the global list of breakpoint locations. */
6817 unlink_locations_from_global_list (struct breakpoint
*bpt
)
6819 /* This code assumes that the locations
6820 of a breakpoint are found in the global list
6821 in the same order, but not necessary adjacent. */
6822 struct bp_location
**tmp
= &bp_location_chain
;
6823 struct bp_location
*here
= bpt
->loc
;
6828 for (; *tmp
&& here
;)
6832 *tmp
= here
->global_next
;
6837 tmp
= &((*tmp
)->global_next
);
6842 /* Delete a breakpoint and clean up all traces of it in the data
6846 delete_breakpoint (struct breakpoint
*bpt
)
6848 struct breakpoint
*b
;
6850 struct bp_location
*loc
;
6852 gdb_assert (bpt
!= NULL
);
6854 /* Has this bp already been deleted? This can happen because multiple
6855 lists can hold pointers to bp's. bpstat lists are especial culprits.
6857 One example of this happening is a watchpoint's scope bp. When the
6858 scope bp triggers, we notice that the watchpoint is out of scope, and
6859 delete it. We also delete its scope bp. But the scope bp is marked
6860 "auto-deleting", and is already on a bpstat. That bpstat is then
6861 checked for auto-deleting bp's, which are deleted.
6863 A real solution to this problem might involve reference counts in bp's,
6864 and/or giving them pointers back to their referencing bpstat's, and
6865 teaching delete_breakpoint to only free a bp's storage when no more
6866 references were extent. A cheaper bandaid was chosen. */
6867 if (bpt
->type
== bp_none
)
6870 if (deprecated_delete_breakpoint_hook
)
6871 deprecated_delete_breakpoint_hook (bpt
);
6872 breakpoint_delete_event (bpt
->number
);
6874 for (loc
= bpt
->loc
; loc
; loc
= loc
->next
)
6877 remove_breakpoint (loc
, mark_inserted
);
6882 if (loc
->function_name
)
6883 xfree (loc
->function_name
);
6886 if (breakpoint_chain
== bpt
)
6887 breakpoint_chain
= bpt
->next
;
6892 b
->next
= bpt
->next
;
6896 unlink_locations_from_global_list (bpt
);
6898 check_duplicates (bpt
);
6900 if (bpt
->type
!= bp_hardware_watchpoint
6901 && bpt
->type
!= bp_read_watchpoint
6902 && bpt
->type
!= bp_access_watchpoint
6903 && bpt
->type
!= bp_catch_fork
6904 && bpt
->type
!= bp_catch_vfork
6905 && bpt
->type
!= bp_catch_exec
)
6906 for (loc
= bpt
->loc
; loc
; loc
= loc
->next
)
6908 /* If this breakpoint location was inserted, and there is
6909 another breakpoint at the same address, we need to
6910 insert the other breakpoint. */
6913 struct bp_location
*loc2
;
6914 ALL_BP_LOCATIONS (loc2
)
6915 if (loc2
->address
== loc
->address
6916 && loc2
->section
== loc
->section
6918 && loc2
->owner
->enable_state
!= bp_disabled
6920 && !loc2
->shlib_disabled
6921 && loc2
->owner
->enable_state
!= bp_call_disabled
)
6925 /* We should never reach this point if there is a permanent
6926 breakpoint at the same address as the one being deleted.
6927 If there is a permanent breakpoint somewhere, it should
6928 always be the only one inserted. */
6929 if (loc2
->owner
->enable_state
== bp_permanent
)
6930 internal_error (__FILE__
, __LINE__
,
6931 _("another breakpoint was inserted on top of "
6932 "a permanent breakpoint"));
6934 memset (&loc2
->target_info
, 0, sizeof (loc2
->target_info
));
6935 loc2
->target_info
.placed_address
= loc2
->address
;
6936 if (b
->type
== bp_hardware_breakpoint
)
6937 val
= target_insert_hw_breakpoint (&loc2
->target_info
);
6939 val
= target_insert_breakpoint (&loc2
->target_info
);
6941 /* If there was an error in the insert, print a message, then stop execution. */
6944 struct ui_file
*tmp_error_stream
= mem_fileopen ();
6945 make_cleanup_ui_file_delete (tmp_error_stream
);
6948 if (b
->type
== bp_hardware_breakpoint
)
6950 fprintf_unfiltered (tmp_error_stream
,
6951 "Cannot insert hardware breakpoint %d.\n"
6952 "You may have requested too many hardware breakpoints.\n",
6957 fprintf_unfiltered (tmp_error_stream
, "Cannot insert breakpoint %d.\n", b
->number
);
6958 fprintf_filtered (tmp_error_stream
, "Error accessing memory address ");
6959 fputs_filtered (paddress (loc2
->address
),
6961 fprintf_filtered (tmp_error_stream
, ": %s.\n",
6962 safe_strerror (val
));
6965 fprintf_unfiltered (tmp_error_stream
,"The same program may be running in another process.");
6966 target_terminal_ours_for_output ();
6967 error_stream(tmp_error_stream
);
6975 free_command_lines (&bpt
->commands
);
6976 if (bpt
->cond_string
!= NULL
)
6977 xfree (bpt
->cond_string
);
6978 if (bpt
->addr_string
!= NULL
)
6979 xfree (bpt
->addr_string
);
6980 if (bpt
->exp
!= NULL
)
6982 if (bpt
->exp_string
!= NULL
)
6983 xfree (bpt
->exp_string
);
6984 if (bpt
->val
!= NULL
)
6985 value_free (bpt
->val
);
6986 if (bpt
->source_file
!= NULL
)
6987 xfree (bpt
->source_file
);
6988 if (bpt
->dll_pathname
!= NULL
)
6989 xfree (bpt
->dll_pathname
);
6990 if (bpt
->triggered_dll_pathname
!= NULL
)
6991 xfree (bpt
->triggered_dll_pathname
);
6992 if (bpt
->exec_pathname
!= NULL
)
6993 xfree (bpt
->exec_pathname
);
6995 /* Be sure no bpstat's are pointing at it after it's been freed. */
6996 /* FIXME, how can we find all bpstat's?
6997 We just check stop_bpstat for now. Note that we cannot just
6998 remove bpstats pointing at bpt from the stop_bpstat list
6999 entirely, as breakpoint commands are associated with the bpstat;
7000 if we remove it here, then the later call to
7001 bpstat_do_actions (&stop_bpstat);
7002 in event-top.c won't do anything, and temporary breakpoints
7003 with commands won't work. */
7004 for (bs
= stop_bpstat
; bs
; bs
= bs
->next
)
7005 if (bs
->breakpoint_at
&& bs
->breakpoint_at
->owner
== bpt
)
7007 bs
->breakpoint_at
= NULL
;
7009 /* bs->commands will be freed later. */
7011 /* On the chance that someone will soon try again to delete this same
7012 bp, we mark it as deleted before freeing its storage. */
7013 bpt
->type
= bp_none
;
7015 for (loc
= bpt
->loc
; loc
;)
7017 struct bp_location
*loc_next
= loc
->next
;
7025 do_delete_breakpoint_cleanup (void *b
)
7027 delete_breakpoint (b
);
7031 make_cleanup_delete_breakpoint (struct breakpoint
*b
)
7033 return make_cleanup (do_delete_breakpoint_cleanup
, b
);
7037 make_exec_cleanup_delete_breakpoint (struct breakpoint
*b
)
7039 return make_exec_cleanup (do_delete_breakpoint_cleanup
, b
);
7043 delete_command (char *arg
, int from_tty
)
7045 struct breakpoint
*b
, *temp
;
7051 int breaks_to_delete
= 0;
7053 /* Delete all breakpoints if no argument.
7054 Do not delete internal or call-dummy breakpoints, these
7055 have to be deleted with an explicit breakpoint number argument. */
7058 if (b
->type
!= bp_call_dummy
&&
7059 b
->type
!= bp_shlib_event
&&
7060 b
->type
!= bp_thread_event
&&
7061 b
->type
!= bp_overlay_event
&&
7064 breaks_to_delete
= 1;
7069 /* Ask user only if there are some breakpoints to delete. */
7071 || (breaks_to_delete
&& query (_("Delete all breakpoints? "))))
7073 ALL_BREAKPOINTS_SAFE (b
, temp
)
7075 if (b
->type
!= bp_call_dummy
&&
7076 b
->type
!= bp_shlib_event
&&
7077 b
->type
!= bp_thread_event
&&
7078 b
->type
!= bp_overlay_event
&&
7080 delete_breakpoint (b
);
7085 map_breakpoint_numbers (arg
, delete_breakpoint
);
7089 all_locations_are_pending (struct bp_location
*loc
)
7091 for (; loc
; loc
= loc
->next
)
7092 if (!loc
->shlib_disabled
)
7097 /* Subroutine of update_breakpoint_locations to simplify it.
7098 Return non-zero if multiple fns in list LOC have the same name.
7099 Null names are ignored. */
7102 ambiguous_names_p (struct bp_location
*loc
)
7104 struct bp_location
*l
;
7105 htab_t htab
= htab_create_alloc (13, htab_hash_string
,
7106 (int (*) (const void *, const void *)) streq
,
7107 NULL
, xcalloc
, xfree
);
7109 for (l
= loc
; l
!= NULL
; l
= l
->next
)
7112 const char *name
= l
->function_name
;
7114 /* Allow for some names to be NULL, ignore them. */
7118 slot
= (const char **) htab_find_slot (htab
, (const void *) name
,
7120 /* NOTE: We can assume slot != NULL here because xcalloc never returns
7135 update_breakpoint_locations (struct breakpoint
*b
,
7136 struct symtabs_and_lines sals
)
7140 struct bp_location
*existing_locations
= b
->loc
;
7142 /* If there's no new locations, and all existing locations
7143 are pending, don't do anything. This optimizes
7144 the common case where all locations are in the same
7145 shared library, that was unloaded. We'd like to
7146 retain the location, so that when the library
7147 is loaded again, we don't loose the enabled/disabled
7148 status of the individual locations. */
7149 if (all_locations_are_pending (existing_locations
) && sals
.nelts
== 0)
7152 unlink_locations_from_global_list (b
);
7155 for (i
= 0; i
< sals
.nelts
; ++i
)
7157 struct bp_location
*new_loc
=
7158 add_location_to_breakpoint (b
, b
->type
, &(sals
.sals
[i
]));
7160 /* Reparse conditions, they might contain references to the
7162 if (b
->cond_string
!= NULL
)
7164 struct gdb_exception e
;
7167 TRY_CATCH (e
, RETURN_MASK_ERROR
)
7169 new_loc
->cond
= parse_exp_1 (&s
, block_for_pc (sals
.sals
[i
].pc
),
7174 warning (_("failed to reevaluate condition for breakpoint %d: %s"),
7175 b
->number
, e
.message
);
7176 new_loc
->enabled
= 0;
7180 if (b
->source_file
!= NULL
)
7181 xfree (b
->source_file
);
7182 if (sals
.sals
[i
].symtab
== NULL
)
7183 b
->source_file
= NULL
;
7186 savestring (sals
.sals
[i
].symtab
->filename
,
7187 strlen (sals
.sals
[i
].symtab
->filename
));
7189 if (b
->line_number
== 0)
7190 b
->line_number
= sals
.sals
[i
].line
;
7193 /* If possible, carry over 'disable' status from existing breakpoints. */
7195 struct bp_location
*e
= existing_locations
;
7196 /* If there are multiple breakpoints with the same function name,
7197 e.g. for inline functions, comparing function names won't work.
7198 Instead compare pc addresses; this is just a heuristic as things
7199 may have moved, but in practice it gives the correct answer
7200 often enough until a better solution is found. */
7201 int have_ambiguous_names
= ambiguous_names_p (b
->loc
);
7203 for (; e
; e
= e
->next
)
7205 if (!e
->enabled
&& e
->function_name
)
7207 struct bp_location
*l
= b
->loc
;
7208 if (have_ambiguous_names
)
7210 for (; l
; l
= l
->next
)
7211 if (e
->address
== l
->address
)
7219 for (; l
; l
= l
->next
)
7220 if (l
->function_name
7221 && strcmp (e
->function_name
, l
->function_name
) == 0)
7231 while (existing_locations
)
7233 struct bp_location
*next
= existing_locations
->next
;
7234 free_bp_location (existing_locations
);
7235 existing_locations
= next
;
7240 /* Reset a breakpoint given it's struct breakpoint * BINT.
7241 The value we return ends up being the return value from catch_errors.
7242 Unused in this case. */
7245 breakpoint_re_set_one (void *bint
)
7247 /* get past catch_errs */
7248 struct breakpoint
*b
= (struct breakpoint
*) bint
;
7252 int *not_found_ptr
= ¬_found
;
7253 struct symtabs_and_lines sals
= {};
7254 struct symtabs_and_lines expanded
;
7256 enum enable_state save_enable
;
7257 struct gdb_exception e
;
7263 warning (_("attempted to reset apparently deleted breakpoint #%d?"),
7267 case bp_hardware_breakpoint
:
7269 case bp_catch_unload
:
7270 if (b
->addr_string
== NULL
)
7272 /* Anything without a string can't be re-set. */
7273 delete_breakpoint (b
);
7277 set_language (b
->language
);
7278 input_radix
= b
->input_radix
;
7280 TRY_CATCH (e
, RETURN_MASK_ERROR
)
7282 sals
= decode_line_1 (&s
, 1, (struct symtab
*) NULL
, 0, (char ***) NULL
,
7287 int not_found_and_ok
= 0;
7288 /* For pending breakpoints, it's expected that parsing
7289 will fail until the right shared library is loaded.
7290 User has already told to create pending breakpoints and
7291 don't need extra messages. If breakpoint is in bp_shlib_disabled
7292 state, then user already saw the message about that breakpoint
7293 being disabled, and don't want to see more errors. */
7295 && (b
->condition_not_parsed
7296 || (b
->loc
&& b
->loc
->shlib_disabled
)
7297 || b
->enable_state
== bp_disabled
))
7298 not_found_and_ok
= 1;
7300 if (!not_found_and_ok
)
7302 /* We surely don't want to warn about the same breakpoint
7303 10 times. One solution, implemented here, is disable
7304 the breakpoint on error. Another solution would be to
7305 have separate 'warning emitted' flag. Since this
7306 happens only when a binary has changed, I don't know
7307 which approach is better. */
7308 b
->enable_state
= bp_disabled
;
7309 throw_exception (e
);
7316 gdb_assert (sals
.nelts
== 1);
7317 resolve_sal_pc (&sals
.sals
[0]);
7318 if (b
->condition_not_parsed
&& s
&& s
[0])
7320 char *cond_string
= 0;
7322 find_condition_and_thread (s
, sals
.sals
[0].pc
,
7323 &cond_string
, &thread
);
7325 b
->cond_string
= cond_string
;
7327 b
->condition_not_parsed
= 0;
7329 expanded
= expand_line_sal_maybe (sals
.sals
[0]);
7330 update_breakpoint_locations (b
, expanded
);
7332 /* Now that this is re-enabled, check_duplicates
7334 check_duplicates (b
);
7340 case bp_hardware_watchpoint
:
7341 case bp_read_watchpoint
:
7342 case bp_access_watchpoint
:
7343 /* Watchpoint can be either on expression using entirely global variables,
7344 or it can be on local variables.
7346 Watchpoints of the first kind are never auto-deleted, and even persist
7347 across program restarts. Since they can use variables from shared
7348 libraries, we need to reparse expression as libraries are loaded
7351 Watchpoints on local variables can also change meaning as result
7352 of solib event. For example, if a watchpoint uses both a local and
7353 a global variables in expression, it's a local watchpoint, but
7354 unloading of a shared library will make the expression invalid.
7355 This is not a very common use case, but we still re-evaluate
7356 expression, to avoid surprises to the user.
7358 Note that for local watchpoints, we re-evaluate it only if
7359 watchpoints frame id is still valid. If it's not, it means
7360 the watchpoint is out of scope and will be deleted soon. In fact,
7361 I'm not sure we'll ever be called in this case.
7363 If a local watchpoint's frame id is still valid, then
7364 b->exp_valid_block is likewise valid, and we can safely use it.
7366 Don't do anything about disabled watchpoints, since they will
7367 be reevaluated again when enabled. */
7368 update_watchpoint (b
, 1 /* reparse */);
7370 /* We needn't really do anything to reset these, since the mask
7371 that requests them is unaffected by e.g., new libraries being
7374 case bp_catch_vfork
:
7379 printf_filtered (_("Deleting unknown breakpoint type %d\n"), b
->type
);
7381 /* Delete longjmp and overlay event breakpoints; they will be
7382 reset later by breakpoint_re_set. */
7384 case bp_longjmp_resume
:
7385 case bp_overlay_event
:
7386 delete_breakpoint (b
);
7389 /* This breakpoint is special, it's set up when the inferior
7390 starts and we really don't want to touch it. */
7391 case bp_shlib_event
:
7393 /* Like bp_shlib_event, this breakpoint type is special.
7394 Once it is set up, we do not want to touch it. */
7395 case bp_thread_event
:
7397 /* Keep temporary breakpoints, which can be encountered when we step
7398 over a dlopen call and SOLIB_ADD is resetting the breakpoints.
7399 Otherwise these should have been blown away via the cleanup chain
7400 or by breakpoint_init_inferior when we rerun the executable. */
7403 case bp_watchpoint_scope
:
7405 case bp_step_resume
:
7412 /* Re-set all breakpoints after symbols have been re-loaded. */
7414 breakpoint_re_set (void)
7416 struct breakpoint
*b
, *temp
;
7417 enum language save_language
;
7418 int save_input_radix
;
7420 save_language
= current_language
->la_language
;
7421 save_input_radix
= input_radix
;
7422 ALL_BREAKPOINTS_SAFE (b
, temp
)
7424 /* Format possible error msg */
7425 char *message
= xstrprintf ("Error in re-setting breakpoint %d: ",
7427 struct cleanup
*cleanups
= make_cleanup (xfree
, message
);
7428 catch_errors (breakpoint_re_set_one
, b
, message
, RETURN_MASK_ALL
);
7429 do_cleanups (cleanups
);
7431 set_language (save_language
);
7432 input_radix
= save_input_radix
;
7434 if (gdbarch_get_longjmp_target_p (current_gdbarch
))
7436 create_longjmp_breakpoint ("longjmp");
7437 create_longjmp_breakpoint ("_longjmp");
7438 create_longjmp_breakpoint ("siglongjmp");
7439 create_longjmp_breakpoint ("_siglongjmp");
7440 create_longjmp_breakpoint (NULL
);
7443 create_overlay_event_breakpoint ("_ovly_debug_event");
7446 /* Reset the thread number of this breakpoint:
7448 - If the breakpoint is for all threads, leave it as-is.
7449 - Else, reset it to the current thread for inferior_ptid. */
7451 breakpoint_re_set_thread (struct breakpoint
*b
)
7453 if (b
->thread
!= -1)
7455 if (in_thread_list (inferior_ptid
))
7456 b
->thread
= pid_to_thread_id (inferior_ptid
);
7460 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
7461 If from_tty is nonzero, it prints a message to that effect,
7462 which ends with a period (no newline). */
7465 set_ignore_count (int bptnum
, int count
, int from_tty
)
7467 struct breakpoint
*b
;
7473 if (b
->number
== bptnum
)
7475 b
->ignore_count
= count
;
7479 printf_filtered (_("Will stop next time breakpoint %d is reached."),
7481 else if (count
== 1)
7482 printf_filtered (_("Will ignore next crossing of breakpoint %d."),
7485 printf_filtered (_("Will ignore next %d crossings of breakpoint %d."),
7488 breakpoints_changed ();
7489 breakpoint_modify_event (b
->number
);
7493 error (_("No breakpoint number %d."), bptnum
);
7496 /* Clear the ignore counts of all breakpoints. */
7498 breakpoint_clear_ignore_counts (void)
7500 struct breakpoint
*b
;
7503 b
->ignore_count
= 0;
7506 /* Command to set ignore-count of breakpoint N to COUNT. */
7509 ignore_command (char *args
, int from_tty
)
7515 error_no_arg (_("a breakpoint number"));
7517 num
= get_number (&p
);
7519 error (_("bad breakpoint number: '%s'"), args
);
7521 error (_("Second argument (specified ignore-count) is missing."));
7523 set_ignore_count (num
,
7524 longest_to_int (value_as_long (parse_and_eval (p
))),
7527 printf_filtered ("\n");
7530 /* Call FUNCTION on each of the breakpoints
7531 whose numbers are given in ARGS. */
7534 map_breakpoint_numbers (char *args
, void (*function
) (struct breakpoint
*))
7539 struct breakpoint
*b
, *tmp
;
7543 error_no_arg (_("one or more breakpoint numbers"));
7550 num
= get_number_or_range (&p1
);
7553 warning (_("bad breakpoint number at or near '%s'"), p
);
7557 ALL_BREAKPOINTS_SAFE (b
, tmp
)
7558 if (b
->number
== num
)
7560 struct breakpoint
*related_breakpoint
= b
->related_breakpoint
;
7563 if (related_breakpoint
)
7564 function (related_breakpoint
);
7568 printf_unfiltered (_("No breakpoint number %d.\n"), num
);
7574 static struct bp_location
*
7575 find_location_by_number (char *number
)
7577 char *dot
= strchr (number
, '.');
7581 struct breakpoint
*b
;
7582 struct bp_location
*loc
;
7587 bp_num
= get_number_or_range (&p1
);
7589 error (_("Bad breakpoint number '%s'"), number
);
7592 if (b
->number
== bp_num
)
7597 if (!b
|| b
->number
!= bp_num
)
7598 error (_("Bad breakpoint number '%s'"), number
);
7601 loc_num
= get_number_or_range (&p1
);
7603 error (_("Bad breakpoint location number '%s'"), number
);
7607 for (;loc_num
&& loc
; --loc_num
, loc
= loc
->next
)
7610 error (_("Bad breakpoint location number '%s'"), dot
+1);
7616 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
7617 If from_tty is nonzero, it prints a message to that effect,
7618 which ends with a period (no newline). */
7621 disable_breakpoint (struct breakpoint
*bpt
)
7623 /* Never disable a watchpoint scope breakpoint; we want to
7624 hit them when we leave scope so we can delete both the
7625 watchpoint and its scope breakpoint at that time. */
7626 if (bpt
->type
== bp_watchpoint_scope
)
7629 /* You can't disable permanent breakpoints. */
7630 if (bpt
->enable_state
== bp_permanent
)
7633 bpt
->enable_state
= bp_disabled
;
7635 check_duplicates (bpt
);
7637 if (deprecated_modify_breakpoint_hook
)
7638 deprecated_modify_breakpoint_hook (bpt
);
7639 breakpoint_modify_event (bpt
->number
);
7643 disable_command (char *args
, int from_tty
)
7645 struct breakpoint
*bpt
;
7647 ALL_BREAKPOINTS (bpt
)
7651 warning (_("attempted to disable apparently deleted breakpoint #%d?"),
7656 case bp_catch_unload
:
7658 case bp_catch_vfork
:
7660 case bp_hardware_breakpoint
:
7662 case bp_hardware_watchpoint
:
7663 case bp_read_watchpoint
:
7664 case bp_access_watchpoint
:
7665 disable_breakpoint (bpt
);
7669 else if (strchr (args
, '.'))
7671 struct bp_location
*loc
= find_location_by_number (args
);
7674 check_duplicates (loc
->owner
);
7677 map_breakpoint_numbers (args
, disable_breakpoint
);
7681 do_enable_breakpoint (struct breakpoint
*bpt
, enum bpdisp disposition
)
7683 int target_resources_ok
, other_type_used
;
7686 if (bpt
->type
== bp_hardware_breakpoint
)
7689 i
= hw_breakpoint_used_count ();
7690 target_resources_ok
=
7691 TARGET_CAN_USE_HARDWARE_WATCHPOINT (bp_hardware_breakpoint
,
7693 if (target_resources_ok
== 0)
7694 error (_("No hardware breakpoint support in the target."));
7695 else if (target_resources_ok
< 0)
7696 error (_("Hardware breakpoints used exceeds limit."));
7699 if (bpt
->type
== bp_watchpoint
||
7700 bpt
->type
== bp_hardware_watchpoint
||
7701 bpt
->type
== bp_read_watchpoint
||
7702 bpt
->type
== bp_access_watchpoint
)
7704 struct frame_id saved_frame_id
;
7706 saved_frame_id
= get_frame_id (get_selected_frame (NULL
));
7707 if (bpt
->exp_valid_block
!= NULL
)
7709 struct frame_info
*fr
=
7710 fr
= frame_find_by_id (bpt
->watchpoint_frame
);
7713 printf_filtered (_("\
7714 Cannot enable watchpoint %d because the block in which its expression\n\
7715 is valid is not currently in scope.\n"), bpt
->number
);
7722 value_free (bpt
->val
);
7723 mark
= value_mark ();
7724 bpt
->val
= evaluate_expression (bpt
->exp
);
7725 release_value (bpt
->val
);
7726 if (value_lazy (bpt
->val
))
7727 value_fetch_lazy (bpt
->val
);
7729 if (bpt
->type
== bp_hardware_watchpoint
||
7730 bpt
->type
== bp_read_watchpoint
||
7731 bpt
->type
== bp_access_watchpoint
)
7733 int i
= hw_watchpoint_used_count (bpt
->type
, &other_type_used
);
7734 int mem_cnt
= can_use_hardware_watchpoint (bpt
->val
);
7736 /* Hack around 'unused var' error for some targets here */
7737 (void) mem_cnt
, (void) i
;
7738 target_resources_ok
= TARGET_CAN_USE_HARDWARE_WATCHPOINT (
7739 bpt
->type
, i
+ mem_cnt
, other_type_used
);
7740 /* we can consider of type is bp_hardware_watchpoint, convert to
7741 bp_watchpoint in the following condition */
7742 if (target_resources_ok
< 0)
7744 printf_filtered (_("\
7745 Cannot enable watchpoint %d because target watch resources\n\
7746 have been allocated for other watchpoints.\n"), bpt
->number
);
7747 value_free_to_mark (mark
);
7752 select_frame (frame_find_by_id (saved_frame_id
));
7753 value_free_to_mark (mark
);
7756 if (bpt
->enable_state
!= bp_permanent
)
7757 bpt
->enable_state
= bp_enabled
;
7758 bpt
->disposition
= disposition
;
7759 check_duplicates (bpt
);
7760 breakpoints_changed ();
7762 if (deprecated_modify_breakpoint_hook
)
7763 deprecated_modify_breakpoint_hook (bpt
);
7764 breakpoint_modify_event (bpt
->number
);
7769 enable_breakpoint (struct breakpoint
*bpt
)
7771 do_enable_breakpoint (bpt
, bpt
->disposition
);
7774 /* The enable command enables the specified breakpoints (or all defined
7775 breakpoints) so they once again become (or continue to be) effective
7776 in stopping the inferior. */
7779 enable_command (char *args
, int from_tty
)
7781 struct breakpoint
*bpt
;
7783 ALL_BREAKPOINTS (bpt
)
7787 warning (_("attempted to enable apparently deleted breakpoint #%d?"),
7792 case bp_catch_unload
:
7794 case bp_catch_vfork
:
7796 case bp_hardware_breakpoint
:
7798 case bp_hardware_watchpoint
:
7799 case bp_read_watchpoint
:
7800 case bp_access_watchpoint
:
7801 enable_breakpoint (bpt
);
7805 else if (strchr (args
, '.'))
7807 struct bp_location
*loc
= find_location_by_number (args
);
7810 check_duplicates (loc
->owner
);
7813 map_breakpoint_numbers (args
, enable_breakpoint
);
7817 enable_once_breakpoint (struct breakpoint
*bpt
)
7819 do_enable_breakpoint (bpt
, disp_disable
);
7823 enable_once_command (char *args
, int from_tty
)
7825 map_breakpoint_numbers (args
, enable_once_breakpoint
);
7829 enable_delete_breakpoint (struct breakpoint
*bpt
)
7831 do_enable_breakpoint (bpt
, disp_del
);
7835 enable_delete_command (char *args
, int from_tty
)
7837 map_breakpoint_numbers (args
, enable_delete_breakpoint
);
7841 set_breakpoint_cmd (char *args
, int from_tty
)
7846 show_breakpoint_cmd (char *args
, int from_tty
)
7850 /* Use default_breakpoint_'s, or nothing if they aren't valid. */
7852 struct symtabs_and_lines
7853 decode_line_spec_1 (char *string
, int funfirstline
)
7855 struct symtabs_and_lines sals
;
7857 error (_("Empty line specification."));
7858 if (default_breakpoint_valid
)
7859 sals
= decode_line_1 (&string
, funfirstline
,
7860 default_breakpoint_symtab
,
7861 default_breakpoint_line
,
7862 (char ***) NULL
, NULL
);
7864 sals
= decode_line_1 (&string
, funfirstline
,
7865 (struct symtab
*) NULL
, 0, (char ***) NULL
, NULL
);
7867 error (_("Junk at end of line specification: %s"), string
);
7871 /* Create and insert a raw software breakpoint at PC. Return an
7872 identifier, which should be used to remove the breakpoint later.
7873 In general, places which call this should be using something on the
7874 breakpoint chain instead; this function should be eliminated
7878 deprecated_insert_raw_breakpoint (CORE_ADDR pc
)
7880 struct bp_target_info
*bp_tgt
;
7882 bp_tgt
= xmalloc (sizeof (struct bp_target_info
));
7883 memset (bp_tgt
, 0, sizeof (struct bp_target_info
));
7885 bp_tgt
->placed_address
= pc
;
7886 if (target_insert_breakpoint (bp_tgt
) != 0)
7888 /* Could not insert the breakpoint. */
7896 /* Remove a breakpoint BP inserted by deprecated_insert_raw_breakpoint. */
7899 deprecated_remove_raw_breakpoint (void *bp
)
7901 struct bp_target_info
*bp_tgt
= bp
;
7904 ret
= target_remove_breakpoint (bp_tgt
);
7910 /* One (or perhaps two) breakpoints used for software single stepping. */
7912 static void *single_step_breakpoints
[2];
7914 /* Create and insert a breakpoint for software single step. */
7917 insert_single_step_breakpoint (CORE_ADDR next_pc
)
7921 if (single_step_breakpoints
[0] == NULL
)
7922 bpt_p
= &single_step_breakpoints
[0];
7925 gdb_assert (single_step_breakpoints
[1] == NULL
);
7926 bpt_p
= &single_step_breakpoints
[1];
7929 /* NOTE drow/2006-04-11: A future improvement to this function would be
7930 to only create the breakpoints once, and actually put them on the
7931 breakpoint chain. That would let us use set_raw_breakpoint. We could
7932 adjust the addresses each time they were needed. Doing this requires
7933 corresponding changes elsewhere where single step breakpoints are
7934 handled, however. So, for now, we use this. */
7936 *bpt_p
= deprecated_insert_raw_breakpoint (next_pc
);
7938 error (_("Could not insert single-step breakpoint at 0x%s"),
7939 paddr_nz (next_pc
));
7942 /* Remove and delete any breakpoints used for software single step. */
7945 remove_single_step_breakpoints (void)
7947 gdb_assert (single_step_breakpoints
[0] != NULL
);
7949 /* See insert_single_step_breakpoint for more about this deprecated
7951 deprecated_remove_raw_breakpoint (single_step_breakpoints
[0]);
7952 single_step_breakpoints
[0] = NULL
;
7954 if (single_step_breakpoints
[1] != NULL
)
7956 deprecated_remove_raw_breakpoint (single_step_breakpoints
[1]);
7957 single_step_breakpoints
[1] = NULL
;
7961 /* Check whether a software single-step breakpoint is inserted at PC. */
7964 single_step_breakpoint_inserted_here_p (CORE_ADDR pc
)
7968 for (i
= 0; i
< 2; i
++)
7970 struct bp_target_info
*bp_tgt
= single_step_breakpoints
[i
];
7971 if (bp_tgt
&& bp_tgt
->placed_address
== pc
)
7979 /* This help string is used for the break, hbreak, tbreak and thbreak commands.
7980 It is defined as a macro to prevent duplication.
7981 COMMAND should be a string constant containing the name of the command. */
7982 #define BREAK_ARGS_HELP(command) \
7983 command" [LOCATION] [thread THREADNUM] [if CONDITION]\n\
7984 LOCATION may be a line number, function name, or \"*\" and an address.\n\
7985 If a line number is specified, break at start of code for that line.\n\
7986 If a function is specified, break at start of code for that function.\n\
7987 If an address is specified, break at that exact address.\n\
7988 With no LOCATION, uses current execution address of selected stack frame.\n\
7989 This is useful for breaking on return to a stack frame.\n\
7991 THREADNUM is the number from \"info threads\".\n\
7992 CONDITION is a boolean expression.\n\
7994 Multiple breakpoints at one place are permitted, and useful if conditional.\n\
7996 Do \"help breakpoints\" for info on other commands dealing with breakpoints."
7999 _initialize_breakpoint (void)
8001 static struct cmd_list_element
*breakpoint_set_cmdlist
;
8002 static struct cmd_list_element
*breakpoint_show_cmdlist
;
8003 struct cmd_list_element
*c
;
8005 observer_attach_solib_unloaded (disable_breakpoints_in_unloaded_shlib
);
8007 breakpoint_chain
= 0;
8008 /* Don't bother to call set_breakpoint_count. $bpnum isn't useful
8009 before a breakpoint is set. */
8010 breakpoint_count
= 0;
8012 add_com ("ignore", class_breakpoint
, ignore_command
, _("\
8013 Set ignore-count of breakpoint number N to COUNT.\n\
8014 Usage is `ignore N COUNT'."));
8016 add_com_alias ("bc", "ignore", class_breakpoint
, 1);
8018 add_com ("commands", class_breakpoint
, commands_command
, _("\
8019 Set commands to be executed when a breakpoint is hit.\n\
8020 Give breakpoint number as argument after \"commands\".\n\
8021 With no argument, the targeted breakpoint is the last one set.\n\
8022 The commands themselves follow starting on the next line.\n\
8023 Type a line containing \"end\" to indicate the end of them.\n\
8024 Give \"silent\" as the first line to make the breakpoint silent;\n\
8025 then no output is printed when it is hit, except what the commands print."));
8027 add_com ("condition", class_breakpoint
, condition_command
, _("\
8028 Specify breakpoint number N to break only if COND is true.\n\
8029 Usage is `condition N COND', where N is an integer and COND is an\n\
8030 expression to be evaluated whenever breakpoint N is reached."));
8032 c
= add_com ("tbreak", class_breakpoint
, tbreak_command
, _("\
8033 Set a temporary breakpoint.\n\
8034 Like \"break\" except the breakpoint is only temporary,\n\
8035 so it will be deleted when hit. Equivalent to \"break\" followed\n\
8036 by using \"enable delete\" on the breakpoint number.\n\
8038 BREAK_ARGS_HELP ("tbreak")));
8039 set_cmd_completer (c
, location_completer
);
8041 c
= add_com ("hbreak", class_breakpoint
, hbreak_command
, _("\
8042 Set a hardware assisted breakpoint.\n\
8043 Like \"break\" except the breakpoint requires hardware support,\n\
8044 some target hardware may not have this support.\n\
8046 BREAK_ARGS_HELP ("hbreak")));
8047 set_cmd_completer (c
, location_completer
);
8049 c
= add_com ("thbreak", class_breakpoint
, thbreak_command
, _("\
8050 Set a temporary hardware assisted breakpoint.\n\
8051 Like \"hbreak\" except the breakpoint is only temporary,\n\
8052 so it will be deleted when hit.\n\
8054 BREAK_ARGS_HELP ("thbreak")));
8055 set_cmd_completer (c
, location_completer
);
8057 add_prefix_cmd ("enable", class_breakpoint
, enable_command
, _("\
8058 Enable some breakpoints.\n\
8059 Give breakpoint numbers (separated by spaces) as arguments.\n\
8060 With no subcommand, breakpoints are enabled until you command otherwise.\n\
8061 This is used to cancel the effect of the \"disable\" command.\n\
8062 With a subcommand you can enable temporarily."),
8063 &enablelist
, "enable ", 1, &cmdlist
);
8065 add_com ("ab", class_breakpoint
, enable_command
, _("\
8066 Enable some breakpoints.\n\
8067 Give breakpoint numbers (separated by spaces) as arguments.\n\
8068 With no subcommand, breakpoints are enabled until you command otherwise.\n\
8069 This is used to cancel the effect of the \"disable\" command.\n\
8070 With a subcommand you can enable temporarily."));
8072 add_com_alias ("en", "enable", class_breakpoint
, 1);
8074 add_abbrev_prefix_cmd ("breakpoints", class_breakpoint
, enable_command
, _("\
8075 Enable some breakpoints.\n\
8076 Give breakpoint numbers (separated by spaces) as arguments.\n\
8077 This is used to cancel the effect of the \"disable\" command.\n\
8078 May be abbreviated to simply \"enable\".\n"),
8079 &enablebreaklist
, "enable breakpoints ", 1, &enablelist
);
8081 add_cmd ("once", no_class
, enable_once_command
, _("\
8082 Enable breakpoints for one hit. Give breakpoint numbers.\n\
8083 If a breakpoint is hit while enabled in this fashion, it becomes disabled."),
8086 add_cmd ("delete", no_class
, enable_delete_command
, _("\
8087 Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
8088 If a breakpoint is hit while enabled in this fashion, it is deleted."),
8091 add_cmd ("delete", no_class
, enable_delete_command
, _("\
8092 Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
8093 If a breakpoint is hit while enabled in this fashion, it is deleted."),
8096 add_cmd ("once", no_class
, enable_once_command
, _("\
8097 Enable breakpoints for one hit. Give breakpoint numbers.\n\
8098 If a breakpoint is hit while enabled in this fashion, it becomes disabled."),
8101 add_prefix_cmd ("disable", class_breakpoint
, disable_command
, _("\
8102 Disable some breakpoints.\n\
8103 Arguments are breakpoint numbers with spaces in between.\n\
8104 To disable all breakpoints, give no argument.\n\
8105 A disabled breakpoint is not forgotten, but has no effect until reenabled."),
8106 &disablelist
, "disable ", 1, &cmdlist
);
8107 add_com_alias ("dis", "disable", class_breakpoint
, 1);
8108 add_com_alias ("disa", "disable", class_breakpoint
, 1);
8110 add_com ("sb", class_breakpoint
, disable_command
, _("\
8111 Disable some breakpoints.\n\
8112 Arguments are breakpoint numbers with spaces in between.\n\
8113 To disable all breakpoints, give no argument.\n\
8114 A disabled breakpoint is not forgotten, but has no effect until reenabled."));
8116 add_cmd ("breakpoints", class_alias
, disable_command
, _("\
8117 Disable some breakpoints.\n\
8118 Arguments are breakpoint numbers with spaces in between.\n\
8119 To disable all breakpoints, give no argument.\n\
8120 A disabled breakpoint is not forgotten, but has no effect until reenabled.\n\
8121 This command may be abbreviated \"disable\"."),
8124 add_prefix_cmd ("delete", class_breakpoint
, delete_command
, _("\
8125 Delete some breakpoints or auto-display expressions.\n\
8126 Arguments are breakpoint numbers with spaces in between.\n\
8127 To delete all breakpoints, give no argument.\n\
8129 Also a prefix command for deletion of other GDB objects.\n\
8130 The \"unset\" command is also an alias for \"delete\"."),
8131 &deletelist
, "delete ", 1, &cmdlist
);
8132 add_com_alias ("d", "delete", class_breakpoint
, 1);
8133 add_com_alias ("del", "delete", class_breakpoint
, 1);
8135 add_com ("db", class_breakpoint
, delete_command
, _("\
8136 Delete some breakpoints.\n\
8137 Arguments are breakpoint numbers with spaces in between.\n\
8138 To delete all breakpoints, give no argument.\n"));
8140 add_cmd ("breakpoints", class_alias
, delete_command
, _("\
8141 Delete some breakpoints or auto-display expressions.\n\
8142 Arguments are breakpoint numbers with spaces in between.\n\
8143 To delete all breakpoints, give no argument.\n\
8144 This command may be abbreviated \"delete\"."),
8147 add_com ("clear", class_breakpoint
, clear_command
, _("\
8148 Clear breakpoint at specified line or function.\n\
8149 Argument may be line number, function name, or \"*\" and an address.\n\
8150 If line number is specified, all breakpoints in that line are cleared.\n\
8151 If function is specified, breakpoints at beginning of function are cleared.\n\
8152 If an address is specified, breakpoints at that address are cleared.\n\
8154 With no argument, clears all breakpoints in the line that the selected frame\n\
8157 See also the \"delete\" command which clears breakpoints by number."));
8159 c
= add_com ("break", class_breakpoint
, break_command
, _("\
8160 Set breakpoint at specified line or function.\n"
8161 BREAK_ARGS_HELP ("break")));
8162 set_cmd_completer (c
, location_completer
);
8164 add_com_alias ("b", "break", class_run
, 1);
8165 add_com_alias ("br", "break", class_run
, 1);
8166 add_com_alias ("bre", "break", class_run
, 1);
8167 add_com_alias ("brea", "break", class_run
, 1);
8171 add_com_alias ("ba", "break", class_breakpoint
, 1);
8172 add_com_alias ("bu", "ubreak", class_breakpoint
, 1);
8177 add_abbrev_prefix_cmd ("stop", class_breakpoint
, stop_command
, _("\
8178 Break in function/address or break at a line in the current file."),
8179 &stoplist
, "stop ", 1, &cmdlist
);
8180 add_cmd ("in", class_breakpoint
, stopin_command
,
8181 _("Break in function or address."), &stoplist
);
8182 add_cmd ("at", class_breakpoint
, stopat_command
,
8183 _("Break at a line in the current file."), &stoplist
);
8184 add_com ("status", class_info
, breakpoints_info
, _("\
8185 Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
8186 The \"Type\" column indicates one of:\n\
8187 \tbreakpoint - normal breakpoint\n\
8188 \twatchpoint - watchpoint\n\
8189 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
8190 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
8191 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
8192 address and file/line number respectively.\n\
8194 Convenience variable \"$_\" and default examine address for \"x\"\n\
8195 are set to the address of the last breakpoint listed unless the command\n\
8196 is prefixed with \"server \".\n\n\
8197 Convenience variable \"$bpnum\" contains the number of the last\n\
8201 add_info ("breakpoints", breakpoints_info
, _("\
8202 Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
8203 The \"Type\" column indicates one of:\n\
8204 \tbreakpoint - normal breakpoint\n\
8205 \twatchpoint - watchpoint\n\
8206 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
8207 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
8208 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
8209 address and file/line number respectively.\n\
8211 Convenience variable \"$_\" and default examine address for \"x\"\n\
8212 are set to the address of the last breakpoint listed unless the command\n\
8213 is prefixed with \"server \".\n\n\
8214 Convenience variable \"$bpnum\" contains the number of the last\n\
8218 add_com ("lb", class_breakpoint
, breakpoints_info
, _("\
8219 Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
8220 The \"Type\" column indicates one of:\n\
8221 \tbreakpoint - normal breakpoint\n\
8222 \twatchpoint - watchpoint\n\
8223 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
8224 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
8225 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
8226 address and file/line number respectively.\n\
8228 Convenience variable \"$_\" and default examine address for \"x\"\n\
8229 are set to the address of the last breakpoint listed unless the command\n\
8230 is prefixed with \"server \".\n\n\
8231 Convenience variable \"$bpnum\" contains the number of the last\n\
8234 add_cmd ("breakpoints", class_maintenance
, maintenance_info_breakpoints
, _("\
8235 Status of all breakpoints, or breakpoint number NUMBER.\n\
8236 The \"Type\" column indicates one of:\n\
8237 \tbreakpoint - normal breakpoint\n\
8238 \twatchpoint - watchpoint\n\
8239 \tlongjmp - internal breakpoint used to step through longjmp()\n\
8240 \tlongjmp resume - internal breakpoint at the target of longjmp()\n\
8241 \tuntil - internal breakpoint used by the \"until\" command\n\
8242 \tfinish - internal breakpoint used by the \"finish\" command\n\
8243 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
8244 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
8245 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
8246 address and file/line number respectively.\n\
8248 Convenience variable \"$_\" and default examine address for \"x\"\n\
8249 are set to the address of the last breakpoint listed unless the command\n\
8250 is prefixed with \"server \".\n\n\
8251 Convenience variable \"$bpnum\" contains the number of the last\n\
8253 &maintenanceinfolist
);
8255 add_com ("catch", class_breakpoint
, catch_command
, _("\
8256 Set catchpoints to catch events.\n\
8257 Raised signals may be caught:\n\
8258 \tcatch signal - all signals\n\
8259 \tcatch signal <signame> - a particular signal\n\
8260 Raised exceptions may be caught:\n\
8261 \tcatch throw - all exceptions, when thrown\n\
8262 \tcatch throw <exceptname> - a particular exception, when thrown\n\
8263 \tcatch catch - all exceptions, when caught\n\
8264 \tcatch catch <exceptname> - a particular exception, when caught\n\
8265 Thread or process events may be caught:\n\
8266 \tcatch thread_start - any threads, just after creation\n\
8267 \tcatch thread_exit - any threads, just before expiration\n\
8268 \tcatch thread_join - any threads, just after joins\n\
8269 Process events may be caught:\n\
8270 \tcatch start - any processes, just after creation\n\
8271 \tcatch exit - any processes, just before expiration\n\
8272 \tcatch fork - calls to fork()\n\
8273 \tcatch vfork - calls to vfork()\n\
8274 \tcatch exec - calls to exec()\n\
8275 Dynamically-linked library events may be caught:\n\
8276 \tcatch load - loads of any library\n\
8277 \tcatch load <libname> - loads of a particular library\n\
8278 \tcatch unload - unloads of any library\n\
8279 \tcatch unload <libname> - unloads of a particular library\n\
8280 The act of your program's execution stopping may also be caught:\n\
8282 C++ exceptions may be caught:\n\
8283 \tcatch throw - all exceptions, when thrown\n\
8284 \tcatch catch - all exceptions, when caught\n\
8285 Ada exceptions may be caught:\n\
8286 \tcatch exception - all exceptions, when raised\n\
8287 \tcatch exception <name> - a particular exception, when raised\n\
8288 \tcatch exception unhandled - all unhandled exceptions, when raised\n\
8289 \tcatch assert - all failed assertions, when raised\n\
8291 Do \"help set follow-fork-mode\" for info on debugging your program\n\
8292 after a fork or vfork is caught.\n\n\
8293 Do \"help breakpoints\" for info on other commands dealing with breakpoints."));
8295 add_com ("tcatch", class_breakpoint
, tcatch_command
, _("\
8296 Set temporary catchpoints to catch events.\n\
8297 Args like \"catch\" command.\n\
8298 Like \"catch\" except the catchpoint is only temporary,\n\
8299 so it will be deleted when hit. Equivalent to \"catch\" followed\n\
8300 by using \"enable delete\" on the catchpoint number."));
8302 c
= add_com ("watch", class_breakpoint
, watch_command
, _("\
8303 Set a watchpoint for an expression.\n\
8304 A watchpoint stops execution of your program whenever the value of\n\
8305 an expression changes."));
8306 set_cmd_completer (c
, location_completer
);
8308 c
= add_com ("rwatch", class_breakpoint
, rwatch_command
, _("\
8309 Set a read watchpoint for an expression.\n\
8310 A watchpoint stops execution of your program whenever the value of\n\
8311 an expression is read."));
8312 set_cmd_completer (c
, location_completer
);
8314 c
= add_com ("awatch", class_breakpoint
, awatch_command
, _("\
8315 Set a watchpoint for an expression.\n\
8316 A watchpoint stops execution of your program whenever the value of\n\
8317 an expression is either read or written."));
8318 set_cmd_completer (c
, location_completer
);
8320 add_info ("watchpoints", breakpoints_info
,
8321 _("Synonym for ``info breakpoints''."));
8324 /* XXX: cagney/2005-02-23: This should be a boolean, and should
8325 respond to changes - contrary to the description. */
8326 add_setshow_zinteger_cmd ("can-use-hw-watchpoints", class_support
,
8327 &can_use_hw_watchpoints
, _("\
8328 Set debugger's willingness to use watchpoint hardware."), _("\
8329 Show debugger's willingness to use watchpoint hardware."), _("\
8330 If zero, gdb will not use hardware for new watchpoints, even if\n\
8331 such is available. (However, any hardware watchpoints that were\n\
8332 created before setting this to nonzero, will continue to use watchpoint\n\
8335 show_can_use_hw_watchpoints
,
8336 &setlist
, &showlist
);
8338 can_use_hw_watchpoints
= 1;
8340 add_prefix_cmd ("breakpoint", class_maintenance
, set_breakpoint_cmd
, _("\
8341 Breakpoint specific settings\n\
8342 Configure various breakpoint-specific variables such as\n\
8343 pending breakpoint behavior"),
8344 &breakpoint_set_cmdlist
, "set breakpoint ",
8345 0/*allow-unknown*/, &setlist
);
8346 add_prefix_cmd ("breakpoint", class_maintenance
, show_breakpoint_cmd
, _("\
8347 Breakpoint specific settings\n\
8348 Configure various breakpoint-specific variables such as\n\
8349 pending breakpoint behavior"),
8350 &breakpoint_show_cmdlist
, "show breakpoint ",
8351 0/*allow-unknown*/, &showlist
);
8353 add_setshow_auto_boolean_cmd ("pending", no_class
,
8354 &pending_break_support
, _("\
8355 Set debugger's behavior regarding pending breakpoints."), _("\
8356 Show debugger's behavior regarding pending breakpoints."), _("\
8357 If on, an unrecognized breakpoint location will cause gdb to create a\n\
8358 pending breakpoint. If off, an unrecognized breakpoint location results in\n\
8359 an error. If auto, an unrecognized breakpoint location results in a\n\
8360 user-query to see if a pending breakpoint should be created."),
8362 show_pending_break_support
,
8363 &breakpoint_set_cmdlist
,
8364 &breakpoint_show_cmdlist
);
8366 pending_break_support
= AUTO_BOOLEAN_AUTO
;
8368 add_setshow_boolean_cmd ("auto-hw", no_class
,
8369 &automatic_hardware_breakpoints
, _("\
8370 Set automatic usage of hardware breakpoints."), _("\
8371 Show automatic usage of hardware breakpoints."), _("\
8372 If set, the debugger will automatically use hardware breakpoints for\n\
8373 breakpoints set with \"break\" but falling in read-only memory. If not set,\n\
8374 a warning will be emitted for such breakpoints."),
8376 show_automatic_hardware_breakpoints
,
8377 &breakpoint_set_cmdlist
,
8378 &breakpoint_show_cmdlist
);
8380 automatic_hardware_breakpoints
= 1;