1 /* Everything about breakpoints, for GDB.
3 Copyright (C) 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
4 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
5 2008 Free Software Foundation, Inc.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
27 #include "breakpoint.h"
29 #include "expression.h"
35 #include "gdbthread.h"
38 #include "gdb_string.h"
45 #include "completer.h"
48 #include "cli/cli-script.h"
49 #include "gdb_assert.h"
54 #include "exceptions.h"
60 #include "gdb-events.h"
61 #include "mi/mi-common.h"
63 /* Prototypes for local functions. */
65 static void catch_command_1 (char *, int, int);
67 static void enable_delete_command (char *, int);
69 static void enable_delete_breakpoint (struct breakpoint
*);
71 static void enable_once_command (char *, int);
73 static void enable_once_breakpoint (struct breakpoint
*);
75 static void disable_command (char *, int);
77 static void enable_command (char *, int);
79 static void map_breakpoint_numbers (char *, void (*)(struct breakpoint
*));
81 static void ignore_command (char *, int);
83 static int breakpoint_re_set_one (void *);
85 static void clear_command (char *, int);
87 static void catch_command (char *, int);
89 static void watch_command (char *, int);
91 static int can_use_hardware_watchpoint (struct value
*);
93 static void break_command_1 (char *, int, int);
95 static void mention (struct breakpoint
*);
97 struct breakpoint
*set_raw_breakpoint (struct symtab_and_line
, enum bptype
);
99 static void check_duplicates (struct breakpoint
*);
101 static void breakpoint_adjustment_warning (CORE_ADDR
, CORE_ADDR
, int, int);
103 static CORE_ADDR
adjust_breakpoint_address (CORE_ADDR bpaddr
,
106 static void describe_other_breakpoints (CORE_ADDR
, asection
*, int);
108 static void breakpoints_info (char *, int);
110 static void breakpoint_1 (int, int);
112 static bpstat
bpstat_alloc (const struct bp_location
*, bpstat
);
114 static int breakpoint_cond_eval (void *);
116 static void cleanup_executing_breakpoints (void *);
118 static void commands_command (char *, int);
120 static void condition_command (char *, int);
122 static int get_number_trailer (char **, int);
124 void set_breakpoint_count (int);
133 static int remove_breakpoint (struct bp_location
*, insertion_state_t
);
135 static enum print_stop_action
print_it_typical (bpstat
);
137 static enum print_stop_action
print_bp_stop_message (bpstat bs
);
139 static int watchpoint_check (void *);
141 static void maintenance_info_breakpoints (char *, int);
143 static void create_overlay_event_breakpoint (char *);
145 static int hw_breakpoint_used_count (void);
147 static int hw_watchpoint_used_count (enum bptype
, int *);
149 static void hbreak_command (char *, int);
151 static void thbreak_command (char *, int);
153 static void watch_command_1 (char *, int, int);
155 static void rwatch_command (char *, int);
157 static void awatch_command (char *, int);
159 static void do_enable_breakpoint (struct breakpoint
*, enum bpdisp
);
161 static void create_fork_vfork_event_catchpoint (int tempflag
,
163 enum bptype bp_kind
);
165 static void stop_command (char *arg
, int from_tty
);
167 static void stopin_command (char *arg
, int from_tty
);
169 static void stopat_command (char *arg
, int from_tty
);
171 static char *ep_find_event_name_end (char *arg
);
173 static char *ep_parse_optional_if_clause (char **arg
);
175 static char *ep_parse_optional_filename (char **arg
);
177 static void catch_exception_command_1 (enum exception_event_kind ex_event
,
178 char *arg
, int tempflag
, int from_tty
);
180 static void tcatch_command (char *arg
, int from_tty
);
182 static void ep_skip_leading_whitespace (char **s
);
184 static int single_step_breakpoint_inserted_here_p (CORE_ADDR pc
);
186 static void free_bp_location (struct bp_location
*loc
);
188 static struct bp_location
*
189 allocate_bp_location (struct breakpoint
*bpt
, enum bptype bp_type
);
191 static void update_global_location_list (int);
193 static void update_global_location_list_nothrow (int);
195 static int is_hardware_watchpoint (struct breakpoint
*bpt
);
197 static void insert_breakpoint_locations (void);
200 bpdisp_text (enum bpdisp disp
)
202 /* NOTE: the following values are a part of MI protocol and represent
203 values of 'disp' field returned when inferior stops at a breakpoint. */
204 static char *bpdisps
[] = {"del", "dstp", "dis", "keep"};
205 return bpdisps
[(int) disp
];
208 /* Prototypes for exported functions. */
209 /* If FALSE, gdb will not use hardware support for watchpoints, even
210 if such is available. */
211 static int can_use_hw_watchpoints
;
214 show_can_use_hw_watchpoints (struct ui_file
*file
, int from_tty
,
215 struct cmd_list_element
*c
,
218 fprintf_filtered (file
, _("\
219 Debugger's willingness to use watchpoint hardware is %s.\n"),
223 /* If AUTO_BOOLEAN_FALSE, gdb will not attempt to create pending breakpoints.
224 If AUTO_BOOLEAN_TRUE, gdb will automatically create pending breakpoints
225 for unrecognized breakpoint locations.
226 If AUTO_BOOLEAN_AUTO, gdb will query when breakpoints are unrecognized. */
227 static enum auto_boolean pending_break_support
;
229 show_pending_break_support (struct ui_file
*file
, int from_tty
,
230 struct cmd_list_element
*c
,
233 fprintf_filtered (file
, _("\
234 Debugger's behavior regarding pending breakpoints is %s.\n"),
238 /* If 1, gdb will automatically use hardware breakpoints for breakpoints
239 set with "break" but falling in read-only memory.
240 If 0, gdb will warn about such breakpoints, but won't automatically
241 use hardware breakpoints. */
242 static int automatic_hardware_breakpoints
;
244 show_automatic_hardware_breakpoints (struct ui_file
*file
, int from_tty
,
245 struct cmd_list_element
*c
,
248 fprintf_filtered (file
, _("\
249 Automatic usage of hardware breakpoints is %s.\n"),
253 /* If 1, gdb will keep breakpoints inserted even as inferior is stopped,
254 and immediately insert any new breakpoints. If 0, gdb will insert
255 breakpoints into inferior only when resuming it, and will remove
256 breakpoints upon stop. */
257 static int always_inserted_mode
= 0;
259 show_always_inserted_mode (struct ui_file
*file
, int from_tty
,
260 struct cmd_list_element
*c
, const char *value
)
262 fprintf_filtered (file
, _("Always inserted breakpoint mode is %s.\n"), value
);
266 void _initialize_breakpoint (void);
268 extern int addressprint
; /* Print machine addresses? */
270 /* Are we executing breakpoint commands? */
271 static int executing_breakpoint_commands
;
273 /* Are overlay event breakpoints enabled? */
274 static int overlay_events_enabled
;
276 /* Walk the following statement or block through all breakpoints.
277 ALL_BREAKPOINTS_SAFE does so even if the statment deletes the current
280 #define ALL_BREAKPOINTS(B) for (B = breakpoint_chain; B; B = B->next)
282 #define ALL_BREAKPOINTS_SAFE(B,TMP) \
283 for (B = breakpoint_chain; \
284 B ? (TMP=B->next, 1): 0; \
287 /* Similar iterators for the low-level breakpoints. */
289 #define ALL_BP_LOCATIONS(B) for (B = bp_location_chain; B; B = B->global_next)
291 #define ALL_BP_LOCATIONS_SAFE(B,TMP) \
292 for (B = bp_location_chain; \
293 B ? (TMP=B->global_next, 1): 0; \
296 /* True if breakpoint hit counts should be displayed in breakpoint info. */
298 int show_breakpoint_hit_counts
= 1;
300 /* Chains of all breakpoints defined. */
302 struct breakpoint
*breakpoint_chain
;
304 struct bp_location
*bp_location_chain
;
306 /* The locations that no longer correspond to any breakpoint,
307 unlinked from bp_location_chain, but for which a hit
308 may still be reported by a target. */
309 VEC(bp_location_p
) *moribund_locations
= NULL
;
311 /* Number of last breakpoint made. */
313 int breakpoint_count
;
315 /* This function returns a pointer to the string representation of the
316 pathname of the dynamically-linked library that has just been
319 This function must be used only when SOLIB_HAVE_LOAD_EVENT is TRUE,
320 or undefined results are guaranteed.
322 This string's contents are only valid immediately after the
323 inferior has stopped in the dynamic linker hook, and becomes
324 invalid as soon as the inferior is continued. Clients should make
325 a copy of this string if they wish to continue the inferior and
326 then access the string. */
328 #ifndef SOLIB_LOADED_LIBRARY_PATHNAME
329 #define SOLIB_LOADED_LIBRARY_PATHNAME(pid) ""
332 /* This function returns a pointer to the string representation of the
333 pathname of the dynamically-linked library that has just been
336 This function must be used only when SOLIB_HAVE_UNLOAD_EVENT is
337 TRUE, or undefined results are guaranteed.
339 This string's contents are only valid immediately after the
340 inferior has stopped in the dynamic linker hook, and becomes
341 invalid as soon as the inferior is continued. Clients should make
342 a copy of this string if they wish to continue the inferior and
343 then access the string. */
345 #ifndef SOLIB_UNLOADED_LIBRARY_PATHNAME
346 #define SOLIB_UNLOADED_LIBRARY_PATHNAME(pid) ""
349 /* This function is called by the "catch load" command. It allows the
350 debugger to be notified by the dynamic linker when a specified
351 library file (or any library file, if filename is NULL) is loaded. */
353 #ifndef SOLIB_CREATE_CATCH_LOAD_HOOK
354 #define SOLIB_CREATE_CATCH_LOAD_HOOK(pid,tempflag,filename,cond_string) \
355 error (_("catch of library loads not yet implemented on this platform"))
358 /* This function is called by the "catch unload" command. It allows
359 the debugger to be notified by the dynamic linker when a specified
360 library file (or any library file, if filename is NULL) is
363 #ifndef SOLIB_CREATE_CATCH_UNLOAD_HOOK
364 #define SOLIB_CREATE_CATCH_UNLOAD_HOOK(pid, tempflag, filename, cond_string) \
365 error (_("catch of library unloads not yet implemented on this platform"))
368 /* Return whether a breakpoint is an active enabled breakpoint. */
370 breakpoint_enabled (struct breakpoint
*b
)
372 return (b
->enable_state
== bp_enabled
);
375 /* Set breakpoint count to NUM. */
378 set_breakpoint_count (int num
)
380 breakpoint_count
= num
;
381 set_internalvar (lookup_internalvar ("bpnum"),
382 value_from_longest (builtin_type_int
, (LONGEST
) num
));
385 /* Used in run_command to zero the hit count when a new run starts. */
388 clear_breakpoint_hit_counts (void)
390 struct breakpoint
*b
;
396 /* Default address, symtab and line to put a breakpoint at
397 for "break" command with no arg.
398 if default_breakpoint_valid is zero, the other three are
399 not valid, and "break" with no arg is an error.
401 This set by print_stack_frame, which calls set_default_breakpoint. */
403 int default_breakpoint_valid
;
404 CORE_ADDR default_breakpoint_address
;
405 struct symtab
*default_breakpoint_symtab
;
406 int default_breakpoint_line
;
408 /* *PP is a string denoting a breakpoint. Get the number of the breakpoint.
409 Advance *PP after the string and any trailing whitespace.
411 Currently the string can either be a number or "$" followed by the name
412 of a convenience variable. Making it an expression wouldn't work well
413 for map_breakpoint_numbers (e.g. "4 + 5 + 6").
415 If the string is a NULL pointer, that denotes the last breakpoint.
417 TRAILER is a character which can be found after the number; most
418 commonly this is `-'. If you don't want a trailer, use \0. */
420 get_number_trailer (char **pp
, int trailer
)
422 int retval
= 0; /* default */
426 /* Empty line means refer to the last breakpoint. */
427 return breakpoint_count
;
430 /* Make a copy of the name, so we can null-terminate it
431 to pass to lookup_internalvar(). */
436 while (isalnum (*p
) || *p
== '_')
438 varname
= (char *) alloca (p
- start
+ 1);
439 strncpy (varname
, start
, p
- start
);
440 varname
[p
- start
] = '\0';
441 val
= value_of_internalvar (lookup_internalvar (varname
));
442 if (TYPE_CODE (value_type (val
)) == TYPE_CODE_INT
)
443 retval
= (int) value_as_long (val
);
446 printf_filtered (_("Convenience variable must have integer value.\n"));
454 while (*p
>= '0' && *p
<= '9')
457 /* There is no number here. (e.g. "cond a == b"). */
459 /* Skip non-numeric token */
460 while (*p
&& !isspace((int) *p
))
462 /* Return zero, which caller must interpret as error. */
468 if (!(isspace (*p
) || *p
== '\0' || *p
== trailer
))
470 /* Trailing junk: return 0 and let caller print error msg. */
471 while (!(isspace (*p
) || *p
== '\0' || *p
== trailer
))
482 /* Like get_number_trailer, but don't allow a trailer. */
484 get_number (char **pp
)
486 return get_number_trailer (pp
, '\0');
489 /* Parse a number or a range.
490 * A number will be of the form handled by get_number.
491 * A range will be of the form <number1> - <number2>, and
492 * will represent all the integers between number1 and number2,
495 * While processing a range, this fuction is called iteratively;
496 * At each call it will return the next value in the range.
498 * At the beginning of parsing a range, the char pointer PP will
499 * be advanced past <number1> and left pointing at the '-' token.
500 * Subsequent calls will not advance the pointer until the range
501 * is completed. The call that completes the range will advance
502 * pointer PP past <number2>.
506 get_number_or_range (char **pp
)
508 static int last_retval
, end_value
;
509 static char *end_ptr
;
510 static int in_range
= 0;
514 /* Default case: pp is pointing either to a solo number,
515 or to the first number of a range. */
516 last_retval
= get_number_trailer (pp
, '-');
521 /* This is the start of a range (<number1> - <number2>).
522 Skip the '-', parse and remember the second number,
523 and also remember the end of the final token. */
527 while (isspace ((int) *end_ptr
))
528 end_ptr
++; /* skip white space */
529 end_value
= get_number (temp
);
530 if (end_value
< last_retval
)
532 error (_("inverted range"));
534 else if (end_value
== last_retval
)
536 /* degenerate range (number1 == number2). Advance the
537 token pointer so that the range will be treated as a
546 error (_("negative value"));
549 /* pp points to the '-' that betokens a range. All
550 number-parsing has already been done. Return the next
551 integer value (one greater than the saved previous value).
552 Do not advance the token pointer 'pp' until the end of range
555 if (++last_retval
== end_value
)
557 /* End of range reached; advance token pointer. */
567 /* condition N EXP -- set break condition of breakpoint N to EXP. */
570 condition_command (char *arg
, int from_tty
)
572 struct breakpoint
*b
;
577 error_no_arg (_("breakpoint number"));
580 bnum
= get_number (&p
);
582 error (_("Bad breakpoint argument: '%s'"), arg
);
585 if (b
->number
== bnum
)
587 struct bp_location
*loc
= b
->loc
;
588 for (; loc
; loc
= loc
->next
)
596 if (b
->cond_string
!= NULL
)
597 xfree (b
->cond_string
);
601 b
->cond_string
= NULL
;
603 printf_filtered (_("Breakpoint %d now unconditional.\n"), bnum
);
608 /* I don't know if it matters whether this is the string the user
609 typed in or the decompiled expression. */
610 b
->cond_string
= savestring (arg
, strlen (arg
));
611 b
->condition_not_parsed
= 0;
612 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
616 parse_exp_1 (&arg
, block_for_pc (loc
->address
), 0);
618 error (_("Junk at end of expression"));
621 breakpoints_changed ();
622 breakpoint_modify_event (b
->number
);
626 error (_("No breakpoint number %d."), bnum
);
630 commands_command (char *arg
, int from_tty
)
632 struct breakpoint
*b
;
635 struct command_line
*l
;
637 /* If we allowed this, we would have problems with when to
638 free the storage, if we change the commands currently
641 if (executing_breakpoint_commands
)
642 error (_("Can't use the \"commands\" command among a breakpoint's commands."));
645 bnum
= get_number (&p
);
648 error (_("Unexpected extra arguments following breakpoint number."));
651 if (b
->number
== bnum
)
653 char *tmpbuf
= xstrprintf ("Type commands for when breakpoint %d is hit, one per line.",
655 struct cleanup
*cleanups
= make_cleanup (xfree
, tmpbuf
);
656 l
= read_command_lines (tmpbuf
, from_tty
);
657 do_cleanups (cleanups
);
658 free_command_lines (&b
->commands
);
660 breakpoints_changed ();
661 breakpoint_modify_event (b
->number
);
664 error (_("No breakpoint number %d."), bnum
);
667 /* Like commands_command, but instead of reading the commands from
668 input stream, takes them from an already parsed command structure.
670 This is used by cli-script.c to DTRT with breakpoint commands
671 that are part of if and while bodies. */
672 enum command_control_type
673 commands_from_control_command (char *arg
, struct command_line
*cmd
)
675 struct breakpoint
*b
;
679 /* If we allowed this, we would have problems with when to
680 free the storage, if we change the commands currently
683 if (executing_breakpoint_commands
)
684 error (_("Can't use the \"commands\" command among a breakpoint's commands."));
686 /* An empty string for the breakpoint number means the last
687 breakpoint, but get_number expects a NULL pointer. */
692 bnum
= get_number (&p
);
695 error (_("Unexpected extra arguments following breakpoint number."));
698 if (b
->number
== bnum
)
700 free_command_lines (&b
->commands
);
701 if (cmd
->body_count
!= 1)
702 error (_("Invalid \"commands\" block structure."));
703 /* We need to copy the commands because if/while will free the
704 list after it finishes execution. */
705 b
->commands
= copy_command_lines (cmd
->body_list
[0]);
706 breakpoints_changed ();
707 breakpoint_modify_event (b
->number
);
708 return simple_control
;
710 error (_("No breakpoint number %d."), bnum
);
713 /* Update BUF, which is LEN bytes read from the target address MEMADDR,
714 by replacing any memory breakpoints with their shadowed contents. */
717 breakpoint_restore_shadows (gdb_byte
*buf
, ULONGEST memaddr
, LONGEST len
)
719 struct bp_location
*b
;
720 CORE_ADDR bp_addr
= 0;
726 if (b
->owner
->type
== bp_none
)
727 warning (_("reading through apparently deleted breakpoint #%d?"),
730 if (b
->loc_type
!= bp_loc_software_breakpoint
)
734 /* Addresses and length of the part of the breakpoint that
736 bp_addr
= b
->target_info
.placed_address
;
737 bp_size
= b
->target_info
.shadow_len
;
739 /* bp isn't valid, or doesn't shadow memory. */
742 if (bp_addr
+ bp_size
<= memaddr
)
743 /* The breakpoint is entirely before the chunk of memory we
747 if (bp_addr
>= memaddr
+ len
)
748 /* The breakpoint is entirely after the chunk of memory we are
752 /* Offset within shadow_contents. */
753 if (bp_addr
< memaddr
)
755 /* Only copy the second part of the breakpoint. */
756 bp_size
-= memaddr
- bp_addr
;
757 bptoffset
= memaddr
- bp_addr
;
761 if (bp_addr
+ bp_size
> memaddr
+ len
)
763 /* Only copy the first part of the breakpoint. */
764 bp_size
-= (bp_addr
+ bp_size
) - (memaddr
+ len
);
767 memcpy (buf
+ bp_addr
- memaddr
,
768 b
->target_info
.shadow_contents
+ bptoffset
, bp_size
);
773 /* A wrapper function for inserting catchpoints. */
775 insert_catchpoint (struct ui_out
*uo
, void *args
)
777 struct breakpoint
*b
= (struct breakpoint
*) args
;
783 target_insert_fork_catchpoint (PIDGET (inferior_ptid
));
786 target_insert_vfork_catchpoint (PIDGET (inferior_ptid
));
789 target_insert_exec_catchpoint (PIDGET (inferior_ptid
));
792 internal_error (__FILE__
, __LINE__
, _("unknown breakpoint type"));
798 is_hardware_watchpoint (struct breakpoint
*bpt
)
800 return (bpt
->type
== bp_hardware_watchpoint
801 || bpt
->type
== bp_read_watchpoint
802 || bpt
->type
== bp_access_watchpoint
);
805 /* Find the current value of a watchpoint on EXP. Return the value in
806 *VALP and *RESULTP and the chain of intermediate and final values
807 in *VAL_CHAIN. RESULTP and VAL_CHAIN may be NULL if the caller does
810 If an error occurs while evaluating the expression, *RESULTP will
811 be set to NULL. *RESULTP may be a lazy value, if the result could
812 not be read from memory. It is used to determine whether a value
813 is user-specified (we should watch the whole value) or intermediate
814 (we should watch only the bit used to locate the final value).
816 If the final value, or any intermediate value, could not be read
817 from memory, *VALP will be set to NULL. *VAL_CHAIN will still be
818 set to any referenced values. *VALP will never be a lazy value.
819 This is the value which we store in struct breakpoint.
821 If VAL_CHAIN is non-NULL, *VAL_CHAIN will be released from the
822 value chain. The caller must free the values individually. If
823 VAL_CHAIN is NULL, all generated values will be left on the value
827 fetch_watchpoint_value (struct expression
*exp
, struct value
**valp
,
828 struct value
**resultp
, struct value
**val_chain
)
830 struct value
*mark
, *new_mark
, *result
;
838 /* Evaluate the expression. */
839 mark
= value_mark ();
841 gdb_evaluate_expression (exp
, &result
);
842 new_mark
= value_mark ();
843 if (mark
== new_mark
)
848 /* Make sure it's not lazy, so that after the target stops again we
849 have a non-lazy previous value to compare with. */
851 && (!value_lazy (result
) || gdb_value_fetch_lazy (result
)))
856 /* Return the chain of intermediate values. We use this to
857 decide which addresses to watch. */
858 *val_chain
= new_mark
;
859 value_release_to_mark (mark
);
863 /* Assuming that B is a hardware watchpoint:
864 - Reparse watchpoint expression, is REPARSE is non-zero
865 - Evaluate expression and store the result in B->val
866 - Update the list of values that must be watched in B->loc.
868 If the watchpoint is disabled, do nothing. If this is
869 local watchpoint that is out of scope, delete it. */
871 update_watchpoint (struct breakpoint
*b
, int reparse
)
873 int within_current_scope
;
874 struct frame_id saved_frame_id
;
875 struct bp_location
*loc
;
878 /* We don't free locations. They are stored in
879 bp_location_chain and update_global_locations will
880 eventually delete them and remove breakpoints if
884 if (b
->disposition
== disp_del_at_next_stop
)
887 /* Save the current frame's ID so we can restore it after
888 evaluating the watchpoint expression on its own frame. */
889 /* FIXME drow/2003-09-09: It would be nice if evaluate_expression
890 took a frame parameter, so that we didn't have to change the
892 saved_frame_id
= get_frame_id (get_selected_frame (NULL
));
894 /* Determine if the watchpoint is within scope. */
895 if (b
->exp_valid_block
== NULL
)
896 within_current_scope
= 1;
899 struct frame_info
*fi
;
900 fi
= frame_find_by_id (b
->watchpoint_frame
);
901 within_current_scope
= (fi
!= NULL
);
902 if (within_current_scope
)
906 if (within_current_scope
&& reparse
)
915 b
->exp
= parse_exp_1 (&s
, b
->exp_valid_block
, 0);
916 /* If the meaning of expression itself changed, the old value is
917 no longer relevant. We don't want to report a watchpoint hit
918 to the user when the old value and the new value may actually
919 be completely different objects. */
925 /* If we failed to parse the expression, for example because
926 it refers to a global variable in a not-yet-loaded shared library,
927 don't try to insert watchpoint. We don't automatically delete
928 such watchpoint, though, since failure to parse expression
929 is different from out-of-scope watchpoint. */
930 if (within_current_scope
&& b
->exp
)
932 struct value
*val_chain
, *v
, *result
, *next
;
934 fetch_watchpoint_value (b
->exp
, &v
, &result
, &val_chain
);
936 /* Avoid setting b->val if it's already set. The meaning of
937 b->val is 'the last value' user saw, and we should update
938 it only if we reported that last value to user. As it
939 happens, the code that reports it updates b->val directly. */
946 /* Look at each value on the value chain. */
947 for (v
= val_chain
; v
; v
= next
)
949 /* If it's a memory location, and GDB actually needed
950 its contents to evaluate the expression, then we
951 must watch it. If the first value returned is
952 still lazy, that means an error occurred reading it;
953 watch it anyway in case it becomes readable. */
954 if (VALUE_LVAL (v
) == lval_memory
955 && (v
== val_chain
|| ! value_lazy (v
)))
957 struct type
*vtype
= check_typedef (value_type (v
));
959 /* We only watch structs and arrays if user asked
960 for it explicitly, never if they just happen to
961 appear in the middle of some value chain. */
963 || (TYPE_CODE (vtype
) != TYPE_CODE_STRUCT
964 && TYPE_CODE (vtype
) != TYPE_CODE_ARRAY
))
968 struct bp_location
*loc
, **tmp
;
970 addr
= VALUE_ADDRESS (v
) + value_offset (v
);
971 len
= TYPE_LENGTH (value_type (v
));
973 if (b
->type
== bp_read_watchpoint
)
975 else if (b
->type
== bp_access_watchpoint
)
978 loc
= allocate_bp_location (b
, bp_hardware_watchpoint
);
979 for (tmp
= &(b
->loc
); *tmp
!= NULL
; tmp
= &((*tmp
)->next
))
984 loc
->watchpoint_type
= type
;
988 next
= value_next (v
);
993 /* We just regenerated the list of breakpoint locations.
994 The new location does not have its condition field set to anything
995 and therefore, we must always reparse the cond_string, independently
996 of the value of the reparse flag. */
997 if (b
->cond_string
!= NULL
)
999 char *s
= b
->cond_string
;
1000 b
->loc
->cond
= parse_exp_1 (&s
, b
->exp_valid_block
, 0);
1003 else if (!within_current_scope
)
1005 printf_filtered (_("\
1006 Hardware watchpoint %d deleted because the program has left the block \n\
1007 in which its expression is valid.\n"),
1009 if (b
->related_breakpoint
)
1010 b
->related_breakpoint
->disposition
= disp_del_at_next_stop
;
1011 b
->disposition
= disp_del_at_next_stop
;
1014 /* Restore the selected frame. */
1015 select_frame (frame_find_by_id (saved_frame_id
));
1019 /* Returns 1 iff breakpoint location should be
1020 inserted in the inferior. */
1022 should_be_inserted (struct bp_location
*bpt
)
1024 if (!breakpoint_enabled (bpt
->owner
))
1027 if (bpt
->owner
->disposition
== disp_del_at_next_stop
)
1030 if (!bpt
->enabled
|| bpt
->shlib_disabled
|| bpt
->duplicate
)
1036 /* Insert a low-level "breakpoint" of some type. BPT is the breakpoint.
1037 Any error messages are printed to TMP_ERROR_STREAM; and DISABLED_BREAKS,
1038 PROCESS_WARNING, and HW_BREAKPOINT_ERROR are used to report problems.
1040 NOTE drow/2003-09-09: This routine could be broken down to an object-style
1041 method for each breakpoint or catchpoint type. */
1043 insert_bp_location (struct bp_location
*bpt
,
1044 struct ui_file
*tmp_error_stream
,
1045 int *disabled_breaks
, int *process_warning
,
1046 int *hw_breakpoint_error
)
1050 if (!should_be_inserted (bpt
) || bpt
->inserted
)
1053 /* Initialize the target-specific information. */
1054 memset (&bpt
->target_info
, 0, sizeof (bpt
->target_info
));
1055 bpt
->target_info
.placed_address
= bpt
->address
;
1057 if (bpt
->loc_type
== bp_loc_software_breakpoint
1058 || bpt
->loc_type
== bp_loc_hardware_breakpoint
)
1060 if (bpt
->owner
->type
!= bp_hardware_breakpoint
)
1062 /* If the explicitly specified breakpoint type
1063 is not hardware breakpoint, check the memory map to see
1064 if the breakpoint address is in read only memory or not.
1065 Two important cases are:
1066 - location type is not hardware breakpoint, memory
1067 is readonly. We change the type of the location to
1068 hardware breakpoint.
1069 - location type is hardware breakpoint, memory is read-write.
1070 This means we've previously made the location hardware one, but
1071 then the memory map changed, so we undo.
1073 When breakpoints are removed, remove_breakpoints will
1074 use location types we've just set here, the only possible
1075 problem is that memory map has changed during running program,
1076 but it's not going to work anyway with current gdb. */
1077 struct mem_region
*mr
1078 = lookup_mem_region (bpt
->target_info
.placed_address
);
1082 if (automatic_hardware_breakpoints
)
1085 enum bp_loc_type new_type
;
1087 if (mr
->attrib
.mode
!= MEM_RW
)
1088 new_type
= bp_loc_hardware_breakpoint
;
1090 new_type
= bp_loc_software_breakpoint
;
1092 if (new_type
!= bpt
->loc_type
)
1094 static int said
= 0;
1095 bpt
->loc_type
= new_type
;
1098 fprintf_filtered (gdb_stdout
, _("\
1099 Note: automatically using hardware breakpoints for read-only addresses.\n"));
1104 else if (bpt
->loc_type
== bp_loc_software_breakpoint
1105 && mr
->attrib
.mode
!= MEM_RW
)
1106 warning (_("cannot set software breakpoint at readonly address %s"),
1107 paddr (bpt
->address
));
1111 /* First check to see if we have to handle an overlay. */
1112 if (overlay_debugging
== ovly_off
1113 || bpt
->section
== NULL
1114 || !(section_is_overlay (bpt
->section
)))
1116 /* No overlay handling: just set the breakpoint. */
1118 if (bpt
->loc_type
== bp_loc_hardware_breakpoint
)
1119 val
= target_insert_hw_breakpoint (&bpt
->target_info
);
1121 val
= target_insert_breakpoint (&bpt
->target_info
);
1125 /* This breakpoint is in an overlay section.
1126 Shall we set a breakpoint at the LMA? */
1127 if (!overlay_events_enabled
)
1129 /* Yes -- overlay event support is not active,
1130 so we must try to set a breakpoint at the LMA.
1131 This will not work for a hardware breakpoint. */
1132 if (bpt
->loc_type
== bp_loc_hardware_breakpoint
)
1133 warning (_("hardware breakpoint %d not supported in overlay!"),
1134 bpt
->owner
->number
);
1137 CORE_ADDR addr
= overlay_unmapped_address (bpt
->address
,
1139 /* Set a software (trap) breakpoint at the LMA. */
1140 bpt
->overlay_target_info
= bpt
->target_info
;
1141 bpt
->overlay_target_info
.placed_address
= addr
;
1142 val
= target_insert_breakpoint (&bpt
->overlay_target_info
);
1144 fprintf_unfiltered (tmp_error_stream
,
1145 "Overlay breakpoint %d failed: in ROM?",
1146 bpt
->owner
->number
);
1149 /* Shall we set a breakpoint at the VMA? */
1150 if (section_is_mapped (bpt
->section
))
1152 /* Yes. This overlay section is mapped into memory. */
1153 if (bpt
->loc_type
== bp_loc_hardware_breakpoint
)
1154 val
= target_insert_hw_breakpoint (&bpt
->target_info
);
1156 val
= target_insert_breakpoint (&bpt
->target_info
);
1160 /* No. This breakpoint will not be inserted.
1161 No error, but do not mark the bp as 'inserted'. */
1168 /* Can't set the breakpoint. */
1169 if (solib_address (bpt
->address
))
1171 /* See also: disable_breakpoints_in_shlibs. */
1173 bpt
->shlib_disabled
= 1;
1174 if (!*disabled_breaks
)
1176 fprintf_unfiltered (tmp_error_stream
,
1177 "Cannot insert breakpoint %d.\n",
1178 bpt
->owner
->number
);
1179 fprintf_unfiltered (tmp_error_stream
,
1180 "Temporarily disabling shared library breakpoints:\n");
1182 *disabled_breaks
= 1;
1183 fprintf_unfiltered (tmp_error_stream
,
1184 "breakpoint #%d\n", bpt
->owner
->number
);
1188 #ifdef ONE_PROCESS_WRITETEXT
1189 *process_warning
= 1;
1191 if (bpt
->loc_type
== bp_loc_hardware_breakpoint
)
1193 *hw_breakpoint_error
= 1;
1194 fprintf_unfiltered (tmp_error_stream
,
1195 "Cannot insert hardware breakpoint %d.\n",
1196 bpt
->owner
->number
);
1200 fprintf_unfiltered (tmp_error_stream
,
1201 "Cannot insert breakpoint %d.\n",
1202 bpt
->owner
->number
);
1203 fprintf_filtered (tmp_error_stream
,
1204 "Error accessing memory address ");
1205 fputs_filtered (paddress (bpt
->address
), tmp_error_stream
);
1206 fprintf_filtered (tmp_error_stream
, ": %s.\n",
1207 safe_strerror (val
));
1218 else if (bpt
->loc_type
== bp_loc_hardware_watchpoint
1219 /* NOTE drow/2003-09-08: This state only exists for removing
1220 watchpoints. It's not clear that it's necessary... */
1221 && bpt
->owner
->disposition
!= disp_del_at_next_stop
)
1223 val
= target_insert_watchpoint (bpt
->address
,
1225 bpt
->watchpoint_type
);
1226 bpt
->inserted
= (val
!= -1);
1229 else if (bpt
->owner
->type
== bp_catch_fork
1230 || bpt
->owner
->type
== bp_catch_vfork
1231 || bpt
->owner
->type
== bp_catch_exec
)
1233 struct gdb_exception e
= catch_exception (uiout
, insert_catchpoint
,
1234 bpt
->owner
, RETURN_MASK_ERROR
);
1235 exception_fprintf (gdb_stderr
, e
, "warning: inserting catchpoint %d: ",
1236 bpt
->owner
->number
);
1238 bpt
->owner
->enable_state
= bp_disabled
;
1242 /* We've already printed an error message if there was a problem
1243 inserting this catchpoint, and we've disabled the catchpoint,
1244 so just return success. */
1251 /* Make sure all breakpoints are inserted in inferior.
1252 Throws exception on any error.
1253 A breakpoint that is already inserted won't be inserted
1254 again, so calling this function twice is safe. */
1256 insert_breakpoints (void)
1258 struct breakpoint
*bpt
;
1260 ALL_BREAKPOINTS (bpt
)
1261 if (is_hardware_watchpoint (bpt
))
1262 update_watchpoint (bpt
, 0 /* don't reparse. */);
1264 update_global_location_list (1);
1266 if (!always_inserted_mode
&& target_has_execution
)
1267 /* update_global_location_list does not insert breakpoints
1268 when always_inserted_mode is not enabled. Explicitly
1270 insert_breakpoint_locations ();
1273 /* insert_breakpoints is used when starting or continuing the program.
1274 remove_breakpoints is used when the program stops.
1275 Both return zero if successful,
1276 or an `errno' value if could not write the inferior. */
1279 insert_breakpoint_locations (void)
1281 struct breakpoint
*bpt
;
1282 struct bp_location
*b
, *temp
;
1285 int disabled_breaks
= 0;
1286 int hw_breakpoint_error
= 0;
1287 int process_warning
= 0;
1289 struct ui_file
*tmp_error_stream
= mem_fileopen ();
1290 make_cleanup_ui_file_delete (tmp_error_stream
);
1292 /* Explicitly mark the warning -- this will only be printed if
1293 there was an error. */
1294 fprintf_unfiltered (tmp_error_stream
, "Warning:\n");
1296 ALL_BP_LOCATIONS_SAFE (b
, temp
)
1298 if (!should_be_inserted (b
) || b
->inserted
)
1301 /* There is no point inserting thread-specific breakpoints if the
1302 thread no longer exists. */
1303 if (b
->owner
->thread
!= -1
1304 && !valid_thread_id (b
->owner
->thread
))
1307 val
= insert_bp_location (b
, tmp_error_stream
,
1308 &disabled_breaks
, &process_warning
,
1309 &hw_breakpoint_error
);
1314 /* If we failed to insert all locations of a watchpoint,
1315 remove them, as half-inserted watchpoint is of limited use. */
1316 ALL_BREAKPOINTS (bpt
)
1318 int some_failed
= 0;
1319 struct bp_location
*loc
;
1321 if (!is_hardware_watchpoint (bpt
))
1324 if (bpt
->enable_state
!= bp_enabled
)
1327 if (bpt
->disposition
== disp_del_at_next_stop
)
1330 for (loc
= bpt
->loc
; loc
; loc
= loc
->next
)
1338 for (loc
= bpt
->loc
; loc
; loc
= loc
->next
)
1340 remove_breakpoint (loc
, mark_uninserted
);
1342 hw_breakpoint_error
= 1;
1343 fprintf_unfiltered (tmp_error_stream
,
1344 "Could not insert hardware watchpoint %d.\n",
1352 /* If a hardware breakpoint or watchpoint was inserted, add a
1353 message about possibly exhausted resources. */
1354 if (hw_breakpoint_error
)
1356 fprintf_unfiltered (tmp_error_stream
,
1357 "Could not insert hardware breakpoints:\n\
1358 You may have requested too many hardware breakpoints/watchpoints.\n");
1360 #ifdef ONE_PROCESS_WRITETEXT
1361 if (process_warning
)
1362 fprintf_unfiltered (tmp_error_stream
,
1363 "The same program may be running in another process.");
1365 target_terminal_ours_for_output ();
1366 error_stream (tmp_error_stream
);
1371 remove_breakpoints (void)
1373 struct bp_location
*b
;
1376 ALL_BP_LOCATIONS (b
)
1380 val
= remove_breakpoint (b
, mark_uninserted
);
1389 remove_hw_watchpoints (void)
1391 struct bp_location
*b
;
1394 ALL_BP_LOCATIONS (b
)
1396 if (b
->inserted
&& b
->loc_type
== bp_loc_hardware_watchpoint
)
1398 val
= remove_breakpoint (b
, mark_uninserted
);
1407 reattach_breakpoints (int pid
)
1409 struct bp_location
*b
;
1411 struct cleanup
*old_chain
= save_inferior_ptid ();
1412 struct ui_file
*tmp_error_stream
= mem_fileopen ();
1413 int dummy1
= 0, dummy2
= 0, dummy3
= 0;
1415 make_cleanup_ui_file_delete (tmp_error_stream
);
1417 inferior_ptid
= pid_to_ptid (pid
);
1418 ALL_BP_LOCATIONS (b
)
1423 val
= insert_bp_location (b
, tmp_error_stream
,
1424 &dummy1
, &dummy2
, &dummy3
);
1427 do_cleanups (old_chain
);
1432 do_cleanups (old_chain
);
1437 update_breakpoints_after_exec (void)
1439 struct breakpoint
*b
;
1440 struct breakpoint
*temp
;
1441 struct bp_location
*bploc
;
1443 /* We're about to delete breakpoints from GDB's lists. If the
1444 INSERTED flag is true, GDB will try to lift the breakpoints by
1445 writing the breakpoints' "shadow contents" back into memory. The
1446 "shadow contents" are NOT valid after an exec, so GDB should not
1447 do that. Instead, the target is responsible from marking
1448 breakpoints out as soon as it detects an exec. We don't do that
1449 here instead, because there may be other attempts to delete
1450 breakpoints after detecting an exec and before reaching here. */
1451 ALL_BP_LOCATIONS (bploc
)
1452 gdb_assert (!bploc
->inserted
);
1454 ALL_BREAKPOINTS_SAFE (b
, temp
)
1456 /* Solib breakpoints must be explicitly reset after an exec(). */
1457 if (b
->type
== bp_shlib_event
)
1459 delete_breakpoint (b
);
1463 /* Thread event breakpoints must be set anew after an exec(),
1464 as must overlay event breakpoints. */
1465 if (b
->type
== bp_thread_event
|| b
->type
== bp_overlay_event
)
1467 delete_breakpoint (b
);
1471 /* Step-resume breakpoints are meaningless after an exec(). */
1472 if (b
->type
== bp_step_resume
)
1474 delete_breakpoint (b
);
1478 /* Longjmp and longjmp-resume breakpoints are also meaningless
1480 if (b
->type
== bp_longjmp
|| b
->type
== bp_longjmp_resume
)
1482 delete_breakpoint (b
);
1486 /* Don't delete an exec catchpoint, because else the inferior
1487 won't stop when it ought!
1489 Similarly, we probably ought to keep vfork catchpoints, 'cause
1490 on this target, we may not be able to stop when the vfork is
1491 seen, but only when the subsequent exec is seen. (And because
1492 deleting fork catchpoints here but not vfork catchpoints will
1493 seem mysterious to users, keep those too.) */
1494 if ((b
->type
== bp_catch_exec
) ||
1495 (b
->type
== bp_catch_vfork
) ||
1496 (b
->type
== bp_catch_fork
))
1501 /* bp_finish is a special case. The only way we ought to be able
1502 to see one of these when an exec() has happened, is if the user
1503 caught a vfork, and then said "finish". Ordinarily a finish just
1504 carries them to the call-site of the current callee, by setting
1505 a temporary bp there and resuming. But in this case, the finish
1506 will carry them entirely through the vfork & exec.
1508 We don't want to allow a bp_finish to remain inserted now. But
1509 we can't safely delete it, 'cause finish_command has a handle to
1510 the bp on a bpstat, and will later want to delete it. There's a
1511 chance (and I've seen it happen) that if we delete the bp_finish
1512 here, that its storage will get reused by the time finish_command
1513 gets 'round to deleting the "use to be a bp_finish" breakpoint.
1514 We really must allow finish_command to delete a bp_finish.
1516 In the absense of a general solution for the "how do we know
1517 it's safe to delete something others may have handles to?"
1518 problem, what we'll do here is just uninsert the bp_finish, and
1519 let finish_command delete it.
1521 (We know the bp_finish is "doomed" in the sense that it's
1522 momentary, and will be deleted as soon as finish_command sees
1523 the inferior stopped. So it doesn't matter that the bp's
1524 address is probably bogus in the new a.out, unlike e.g., the
1525 solib breakpoints.) */
1527 if (b
->type
== bp_finish
)
1532 /* Without a symbolic address, we have little hope of the
1533 pre-exec() address meaning the same thing in the post-exec()
1535 if (b
->addr_string
== NULL
)
1537 delete_breakpoint (b
);
1541 /* FIXME what about longjmp breakpoints? Re-create them here? */
1542 create_overlay_event_breakpoint ("_ovly_debug_event");
1546 detach_breakpoints (int pid
)
1548 struct bp_location
*b
;
1550 struct cleanup
*old_chain
= save_inferior_ptid ();
1552 if (pid
== PIDGET (inferior_ptid
))
1553 error (_("Cannot detach breakpoints of inferior_ptid"));
1555 /* Set inferior_ptid; remove_breakpoint uses this global. */
1556 inferior_ptid
= pid_to_ptid (pid
);
1557 ALL_BP_LOCATIONS (b
)
1561 val
= remove_breakpoint (b
, mark_inserted
);
1564 do_cleanups (old_chain
);
1569 do_cleanups (old_chain
);
1574 remove_breakpoint (struct bp_location
*b
, insertion_state_t is
)
1578 if (b
->owner
->enable_state
== bp_permanent
)
1579 /* Permanent breakpoints cannot be inserted or removed. */
1582 /* The type of none suggests that owner is actually deleted.
1583 This should not ever happen. */
1584 gdb_assert (b
->owner
->type
!= bp_none
);
1586 if (b
->loc_type
== bp_loc_software_breakpoint
1587 || b
->loc_type
== bp_loc_hardware_breakpoint
)
1589 /* "Normal" instruction breakpoint: either the standard
1590 trap-instruction bp (bp_breakpoint), or a
1591 bp_hardware_breakpoint. */
1593 /* First check to see if we have to handle an overlay. */
1594 if (overlay_debugging
== ovly_off
1595 || b
->section
== NULL
1596 || !(section_is_overlay (b
->section
)))
1598 /* No overlay handling: just remove the breakpoint. */
1600 if (b
->loc_type
== bp_loc_hardware_breakpoint
)
1601 val
= target_remove_hw_breakpoint (&b
->target_info
);
1603 val
= target_remove_breakpoint (&b
->target_info
);
1607 /* This breakpoint is in an overlay section.
1608 Did we set a breakpoint at the LMA? */
1609 if (!overlay_events_enabled
)
1611 /* Yes -- overlay event support is not active, so we
1612 should have set a breakpoint at the LMA. Remove it.
1614 /* Ignore any failures: if the LMA is in ROM, we will
1615 have already warned when we failed to insert it. */
1616 if (b
->loc_type
== bp_loc_hardware_breakpoint
)
1617 target_remove_hw_breakpoint (&b
->overlay_target_info
);
1619 target_remove_breakpoint (&b
->overlay_target_info
);
1621 /* Did we set a breakpoint at the VMA?
1622 If so, we will have marked the breakpoint 'inserted'. */
1625 /* Yes -- remove it. Previously we did not bother to
1626 remove the breakpoint if the section had been
1627 unmapped, but let's not rely on that being safe. We
1628 don't know what the overlay manager might do. */
1629 if (b
->loc_type
== bp_loc_hardware_breakpoint
)
1630 val
= target_remove_hw_breakpoint (&b
->target_info
);
1632 /* However, we should remove *software* breakpoints only
1633 if the section is still mapped, or else we overwrite
1634 wrong code with the saved shadow contents. */
1635 else if (section_is_mapped (b
->section
))
1636 val
= target_remove_breakpoint (&b
->target_info
);
1642 /* No -- not inserted, so no need to remove. No error. */
1648 b
->inserted
= (is
== mark_inserted
);
1650 else if (b
->loc_type
== bp_loc_hardware_watchpoint
)
1655 b
->inserted
= (is
== mark_inserted
);
1656 val
= target_remove_watchpoint (b
->address
, b
->length
,
1657 b
->watchpoint_type
);
1659 /* Failure to remove any of the hardware watchpoints comes here. */
1660 if ((is
== mark_uninserted
) && (b
->inserted
))
1661 warning (_("Could not remove hardware watchpoint %d."),
1664 else if ((b
->owner
->type
== bp_catch_fork
||
1665 b
->owner
->type
== bp_catch_vfork
||
1666 b
->owner
->type
== bp_catch_exec
)
1667 && breakpoint_enabled (b
->owner
)
1671 switch (b
->owner
->type
)
1674 val
= target_remove_fork_catchpoint (PIDGET (inferior_ptid
));
1676 case bp_catch_vfork
:
1677 val
= target_remove_vfork_catchpoint (PIDGET (inferior_ptid
));
1680 val
= target_remove_exec_catchpoint (PIDGET (inferior_ptid
));
1683 warning (_("Internal error, %s line %d."), __FILE__
, __LINE__
);
1688 b
->inserted
= (is
== mark_inserted
);
1694 /* Clear the "inserted" flag in all breakpoints. */
1697 mark_breakpoints_out (void)
1699 struct bp_location
*bpt
;
1701 ALL_BP_LOCATIONS (bpt
)
1705 /* Clear the "inserted" flag in all breakpoints and delete any
1706 breakpoints which should go away between runs of the program.
1708 Plus other such housekeeping that has to be done for breakpoints
1711 Note: this function gets called at the end of a run (by
1712 generic_mourn_inferior) and when a run begins (by
1713 init_wait_for_inferior). */
1718 breakpoint_init_inferior (enum inf_context context
)
1720 struct breakpoint
*b
, *temp
;
1721 struct bp_location
*bpt
;
1723 ALL_BP_LOCATIONS (bpt
)
1726 ALL_BREAKPOINTS_SAFE (b
, temp
)
1731 case bp_watchpoint_scope
:
1733 /* If the call dummy breakpoint is at the entry point it will
1734 cause problems when the inferior is rerun, so we better
1737 Also get rid of scope breakpoints. */
1738 delete_breakpoint (b
);
1742 case bp_hardware_watchpoint
:
1743 case bp_read_watchpoint
:
1744 case bp_access_watchpoint
:
1746 /* Likewise for watchpoints on local expressions. */
1747 if (b
->exp_valid_block
!= NULL
)
1748 delete_breakpoint (b
);
1749 else if (context
== inf_starting
)
1751 /* Reset val field to force reread of starting value
1752 in insert_breakpoints. */
1754 value_free (b
->val
);
1765 /* breakpoint_here_p (PC) returns non-zero if an enabled breakpoint
1766 exists at PC. It returns ordinary_breakpoint_here if it's an
1767 ordinary breakpoint, or permanent_breakpoint_here if it's a
1768 permanent breakpoint.
1769 - When continuing from a location with an ordinary breakpoint, we
1770 actually single step once before calling insert_breakpoints.
1771 - When continuing from a localion with a permanent breakpoint, we
1772 need to use the `SKIP_PERMANENT_BREAKPOINT' macro, provided by
1773 the target, to advance the PC past the breakpoint. */
1775 enum breakpoint_here
1776 breakpoint_here_p (CORE_ADDR pc
)
1778 const struct bp_location
*bpt
;
1779 int any_breakpoint_here
= 0;
1781 ALL_BP_LOCATIONS (bpt
)
1783 if (bpt
->loc_type
!= bp_loc_software_breakpoint
1784 && bpt
->loc_type
!= bp_loc_hardware_breakpoint
)
1787 if ((breakpoint_enabled (bpt
->owner
)
1788 || bpt
->owner
->enable_state
== bp_permanent
)
1789 && bpt
->address
== pc
) /* bp is enabled and matches pc */
1791 if (overlay_debugging
1792 && section_is_overlay (bpt
->section
)
1793 && !section_is_mapped (bpt
->section
))
1794 continue; /* unmapped overlay -- can't be a match */
1795 else if (bpt
->owner
->enable_state
== bp_permanent
)
1796 return permanent_breakpoint_here
;
1798 any_breakpoint_here
= 1;
1802 return any_breakpoint_here
? ordinary_breakpoint_here
: 0;
1806 /* Returns non-zero if there's a breakpoint inserted at PC, which is
1807 inserted using regular breakpoint_chain/bp_location_chain mechanism.
1808 This does not check for single-step breakpoints, which are
1809 inserted and removed using direct target manipulation. */
1812 regular_breakpoint_inserted_here_p (CORE_ADDR pc
)
1814 const struct bp_location
*bpt
;
1816 ALL_BP_LOCATIONS (bpt
)
1818 if (bpt
->loc_type
!= bp_loc_software_breakpoint
1819 && bpt
->loc_type
!= bp_loc_hardware_breakpoint
)
1823 && bpt
->address
== pc
) /* bp is inserted and matches pc */
1825 if (overlay_debugging
1826 && section_is_overlay (bpt
->section
)
1827 && !section_is_mapped (bpt
->section
))
1828 continue; /* unmapped overlay -- can't be a match */
1836 /* Returns non-zero iff there's either regular breakpoint
1837 or a single step breakpoint inserted at PC. */
1840 breakpoint_inserted_here_p (CORE_ADDR pc
)
1842 if (regular_breakpoint_inserted_here_p (pc
))
1845 if (single_step_breakpoint_inserted_here_p (pc
))
1851 /* This function returns non-zero iff there is a software breakpoint
1855 software_breakpoint_inserted_here_p (CORE_ADDR pc
)
1857 const struct bp_location
*bpt
;
1858 int any_breakpoint_here
= 0;
1860 ALL_BP_LOCATIONS (bpt
)
1862 if (bpt
->loc_type
!= bp_loc_software_breakpoint
)
1866 && bpt
->address
== pc
) /* bp is enabled and matches pc */
1868 if (overlay_debugging
1869 && section_is_overlay (bpt
->section
)
1870 && !section_is_mapped (bpt
->section
))
1871 continue; /* unmapped overlay -- can't be a match */
1877 /* Also check for software single-step breakpoints. */
1878 if (single_step_breakpoint_inserted_here_p (pc
))
1884 /* breakpoint_thread_match (PC, PTID) returns true if the breakpoint at
1885 PC is valid for process/thread PTID. */
1888 breakpoint_thread_match (CORE_ADDR pc
, ptid_t ptid
)
1890 const struct bp_location
*bpt
;
1893 thread
= pid_to_thread_id (ptid
);
1895 ALL_BP_LOCATIONS (bpt
)
1897 if (bpt
->loc_type
!= bp_loc_software_breakpoint
1898 && bpt
->loc_type
!= bp_loc_hardware_breakpoint
)
1901 if ((breakpoint_enabled (bpt
->owner
)
1902 || bpt
->owner
->enable_state
== bp_permanent
)
1903 && bpt
->address
== pc
1904 && (bpt
->owner
->thread
== -1 || bpt
->owner
->thread
== thread
))
1906 if (overlay_debugging
1907 && section_is_overlay (bpt
->section
)
1908 && !section_is_mapped (bpt
->section
))
1909 continue; /* unmapped overlay -- can't be a match */
1919 /* bpstat stuff. External routines' interfaces are documented
1923 ep_is_catchpoint (struct breakpoint
*ep
)
1926 (ep
->type
== bp_catch_load
)
1927 || (ep
->type
== bp_catch_unload
)
1928 || (ep
->type
== bp_catch_fork
)
1929 || (ep
->type
== bp_catch_vfork
)
1930 || (ep
->type
== bp_catch_exec
);
1932 /* ??rehrauer: Add more kinds here, as are implemented... */
1936 ep_is_shlib_catchpoint (struct breakpoint
*ep
)
1939 (ep
->type
== bp_catch_load
)
1940 || (ep
->type
== bp_catch_unload
);
1944 bpstat_free (bpstat bs
)
1946 if (bs
->old_val
!= NULL
)
1947 value_free (bs
->old_val
);
1948 free_command_lines (&bs
->commands
);
1952 /* Clear a bpstat so that it says we are not at any breakpoint.
1953 Also free any storage that is part of a bpstat. */
1956 bpstat_clear (bpstat
*bsp
)
1973 /* Return a copy of a bpstat. Like "bs1 = bs2" but all storage that
1974 is part of the bpstat is copied as well. */
1977 bpstat_copy (bpstat bs
)
1981 bpstat retval
= NULL
;
1986 for (; bs
!= NULL
; bs
= bs
->next
)
1988 tmp
= (bpstat
) xmalloc (sizeof (*tmp
));
1989 memcpy (tmp
, bs
, sizeof (*tmp
));
1990 if (bs
->commands
!= NULL
)
1991 tmp
->commands
= copy_command_lines (bs
->commands
);
1992 if (bs
->old_val
!= NULL
)
1994 tmp
->old_val
= value_copy (bs
->old_val
);
1995 release_value (tmp
->old_val
);
1999 /* This is the first thing in the chain. */
2009 /* Find the bpstat associated with this breakpoint */
2012 bpstat_find_breakpoint (bpstat bsp
, struct breakpoint
*breakpoint
)
2017 for (; bsp
!= NULL
; bsp
= bsp
->next
)
2019 if (bsp
->breakpoint_at
&& bsp
->breakpoint_at
->owner
== breakpoint
)
2025 /* Find a step_resume breakpoint associated with this bpstat.
2026 (If there are multiple step_resume bp's on the list, this function
2027 will arbitrarily pick one.)
2029 It is an error to use this function if BPSTAT doesn't contain a
2030 step_resume breakpoint.
2032 See wait_for_inferior's use of this function. */
2034 bpstat_find_step_resume_breakpoint (bpstat bsp
)
2038 gdb_assert (bsp
!= NULL
);
2040 current_thread
= pid_to_thread_id (inferior_ptid
);
2042 for (; bsp
!= NULL
; bsp
= bsp
->next
)
2044 if ((bsp
->breakpoint_at
!= NULL
) &&
2045 (bsp
->breakpoint_at
->owner
->type
== bp_step_resume
) &&
2046 (bsp
->breakpoint_at
->owner
->thread
== current_thread
||
2047 bsp
->breakpoint_at
->owner
->thread
== -1))
2048 return bsp
->breakpoint_at
->owner
;
2051 internal_error (__FILE__
, __LINE__
, _("No step_resume breakpoint found."));
2055 /* Put in *NUM the breakpoint number of the first breakpoint we are stopped
2056 at. *BSP upon return is a bpstat which points to the remaining
2057 breakpoints stopped at (but which is not guaranteed to be good for
2058 anything but further calls to bpstat_num).
2059 Return 0 if passed a bpstat which does not indicate any breakpoints.
2060 Return -1 if stopped at a breakpoint that has been deleted since
2062 Return 1 otherwise. */
2065 bpstat_num (bpstat
*bsp
, int *num
)
2067 struct breakpoint
*b
;
2070 return 0; /* No more breakpoint values */
2072 /* We assume we'll never have several bpstats that
2073 correspond to a single breakpoint -- otherwise,
2074 this function might return the same number more
2075 than once and this will look ugly. */
2076 b
= (*bsp
)->breakpoint_at
? (*bsp
)->breakpoint_at
->owner
: NULL
;
2077 *bsp
= (*bsp
)->next
;
2079 return -1; /* breakpoint that's been deleted since */
2081 *num
= b
->number
; /* We have its number */
2085 /* Modify BS so that the actions will not be performed. */
2088 bpstat_clear_actions (bpstat bs
)
2090 for (; bs
!= NULL
; bs
= bs
->next
)
2092 free_command_lines (&bs
->commands
);
2093 if (bs
->old_val
!= NULL
)
2095 value_free (bs
->old_val
);
2101 /* Stub for cleaning up our state if we error-out of a breakpoint command */
2103 cleanup_executing_breakpoints (void *ignore
)
2105 executing_breakpoint_commands
= 0;
2108 /* Execute all the commands associated with all the breakpoints at this
2109 location. Any of these commands could cause the process to proceed
2110 beyond this point, etc. We look out for such changes by checking
2111 the global "breakpoint_proceeded" after each command. */
2114 bpstat_do_actions (bpstat
*bsp
)
2117 struct cleanup
*old_chain
;
2119 /* Avoid endless recursion if a `source' command is contained
2121 if (executing_breakpoint_commands
)
2124 executing_breakpoint_commands
= 1;
2125 old_chain
= make_cleanup (cleanup_executing_breakpoints
, 0);
2128 /* Note that (as of this writing), our callers all appear to
2129 be passing us the address of global stop_bpstat. And, if
2130 our calls to execute_control_command cause the inferior to
2131 proceed, that global (and hence, *bsp) will change.
2133 We must be careful to not touch *bsp unless the inferior
2134 has not proceeded. */
2136 /* This pointer will iterate over the list of bpstat's. */
2139 breakpoint_proceeded
= 0;
2140 for (; bs
!= NULL
; bs
= bs
->next
)
2142 struct command_line
*cmd
;
2143 struct cleanup
*this_cmd_tree_chain
;
2145 /* Take ownership of the BSP's command tree, if it has one.
2147 The command tree could legitimately contain commands like
2148 'step' and 'next', which call clear_proceed_status, which
2149 frees stop_bpstat's command tree. To make sure this doesn't
2150 free the tree we're executing out from under us, we need to
2151 take ownership of the tree ourselves. Since a given bpstat's
2152 commands are only executed once, we don't need to copy it; we
2153 can clear the pointer in the bpstat, and make sure we free
2154 the tree when we're done. */
2157 this_cmd_tree_chain
= make_cleanup_free_command_lines (&cmd
);
2161 execute_control_command (cmd
);
2163 if (breakpoint_proceeded
)
2169 /* We can free this command tree now. */
2170 do_cleanups (this_cmd_tree_chain
);
2172 if (breakpoint_proceeded
)
2174 if (target_can_async_p ())
2175 /* If we are in async mode, then the target might
2176 be still running, not stopped at any breakpoint,
2177 so nothing for us to do here -- just return to
2181 /* In sync mode, when execute_control_command returns
2182 we're already standing on the next breakpoint.
2183 Breakpoint commands for that stop were not run,
2184 since execute_command does not run breakpoint
2185 commands -- only command_line_handler does, but
2186 that one is not involved in execution of breakpoint
2187 commands. So, we can now execute breakpoint commands.
2188 There's an implicit assumption that we're called with
2189 stop_bpstat, so our parameter is the new bpstat to
2191 It should be noted that making execute_command do
2192 bpstat actions is not an option -- in this case we'll
2193 have recursive invocation of bpstat for each breakpoint
2194 with a command, and can easily blow up GDB stack. */
2198 do_cleanups (old_chain
);
2201 /* Print out the (old or new) value associated with a watchpoint. */
2204 watchpoint_value_print (struct value
*val
, struct ui_file
*stream
)
2207 fprintf_unfiltered (stream
, _("<unreadable>"));
2209 value_print (val
, stream
, 0, Val_pretty_default
);
2212 /* This is the normal print function for a bpstat. In the future,
2213 much of this logic could (should?) be moved to bpstat_stop_status,
2214 by having it set different print_it values.
2216 Current scheme: When we stop, bpstat_print() is called. It loops
2217 through the bpstat list of things causing this stop, calling the
2218 print_bp_stop_message function on each one. The behavior of the
2219 print_bp_stop_message function depends on the print_it field of
2220 bpstat. If such field so indicates, call this function here.
2222 Return values from this routine (ultimately used by bpstat_print()
2223 and normal_stop() to decide what to do):
2224 PRINT_NOTHING: Means we already printed all we needed to print,
2225 don't print anything else.
2226 PRINT_SRC_ONLY: Means we printed something, and we do *not* desire
2227 that something to be followed by a location.
2228 PRINT_SCR_AND_LOC: Means we printed something, and we *do* desire
2229 that something to be followed by a location.
2230 PRINT_UNKNOWN: Means we printed nothing or we need to do some more
2233 static enum print_stop_action
2234 print_it_typical (bpstat bs
)
2236 struct cleanup
*old_chain
, *ui_out_chain
;
2237 struct breakpoint
*b
;
2238 const struct bp_location
*bl
;
2239 struct ui_stream
*stb
;
2241 stb
= ui_out_stream_new (uiout
);
2242 old_chain
= make_cleanup_ui_out_stream_delete (stb
);
2243 /* bs->breakpoint_at can be NULL if it was a momentary breakpoint
2244 which has since been deleted. */
2245 if (bs
->breakpoint_at
== NULL
)
2246 return PRINT_UNKNOWN
;
2247 bl
= bs
->breakpoint_at
;
2253 case bp_hardware_breakpoint
:
2254 bp_temp
= bs
->breakpoint_at
->owner
->disposition
== disp_del
;
2255 if (bl
->address
!= bl
->requested_address
)
2256 breakpoint_adjustment_warning (bl
->requested_address
,
2259 annotate_breakpoint (b
->number
);
2261 ui_out_text (uiout
, "\nTemporary breakpoint ");
2263 ui_out_text (uiout
, "\nBreakpoint ");
2264 if (ui_out_is_mi_like_p (uiout
))
2266 ui_out_field_string (uiout
, "reason",
2267 async_reason_lookup (EXEC_ASYNC_BREAKPOINT_HIT
));
2268 ui_out_field_string (uiout
, "disp", bpdisp_text (b
->disposition
));
2270 ui_out_field_int (uiout
, "bkptno", b
->number
);
2271 ui_out_text (uiout
, ", ");
2272 return PRINT_SRC_AND_LOC
;
2275 case bp_shlib_event
:
2276 /* Did we stop because the user set the stop_on_solib_events
2277 variable? (If so, we report this as a generic, "Stopped due
2278 to shlib event" message.) */
2279 printf_filtered (_("Stopped due to shared library event\n"));
2280 return PRINT_NOTHING
;
2283 case bp_thread_event
:
2284 /* Not sure how we will get here.
2285 GDB should not stop for these breakpoints. */
2286 printf_filtered (_("Thread Event Breakpoint: gdb should not stop!\n"));
2287 return PRINT_NOTHING
;
2290 case bp_overlay_event
:
2291 /* By analogy with the thread event, GDB should not stop for these. */
2292 printf_filtered (_("Overlay Event Breakpoint: gdb should not stop!\n"));
2293 return PRINT_NOTHING
;
2297 annotate_catchpoint (b
->number
);
2298 printf_filtered (_("\nCatchpoint %d (loaded %s), "),
2300 b
->triggered_dll_pathname
);
2301 return PRINT_SRC_AND_LOC
;
2304 case bp_catch_unload
:
2305 annotate_catchpoint (b
->number
);
2306 printf_filtered (_("\nCatchpoint %d (unloaded %s), "),
2308 b
->triggered_dll_pathname
);
2309 return PRINT_SRC_AND_LOC
;
2313 annotate_catchpoint (b
->number
);
2314 printf_filtered (_("\nCatchpoint %d (forked process %d), "),
2316 ptid_get_pid (b
->forked_inferior_pid
));
2317 return PRINT_SRC_AND_LOC
;
2320 case bp_catch_vfork
:
2321 annotate_catchpoint (b
->number
);
2322 printf_filtered (_("\nCatchpoint %d (vforked process %d), "),
2324 ptid_get_pid (b
->forked_inferior_pid
));
2325 return PRINT_SRC_AND_LOC
;
2329 annotate_catchpoint (b
->number
);
2330 printf_filtered (_("\nCatchpoint %d (exec'd %s), "),
2333 return PRINT_SRC_AND_LOC
;
2337 case bp_hardware_watchpoint
:
2338 annotate_watchpoint (b
->number
);
2339 if (ui_out_is_mi_like_p (uiout
))
2342 async_reason_lookup (EXEC_ASYNC_WATCHPOINT_TRIGGER
));
2344 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "value");
2345 ui_out_text (uiout
, "\nOld value = ");
2346 watchpoint_value_print (bs
->old_val
, stb
->stream
);
2347 ui_out_field_stream (uiout
, "old", stb
);
2348 ui_out_text (uiout
, "\nNew value = ");
2349 watchpoint_value_print (b
->val
, stb
->stream
);
2350 ui_out_field_stream (uiout
, "new", stb
);
2351 do_cleanups (ui_out_chain
);
2352 ui_out_text (uiout
, "\n");
2353 /* More than one watchpoint may have been triggered. */
2354 return PRINT_UNKNOWN
;
2357 case bp_read_watchpoint
:
2358 if (ui_out_is_mi_like_p (uiout
))
2361 async_reason_lookup (EXEC_ASYNC_READ_WATCHPOINT_TRIGGER
));
2363 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "value");
2364 ui_out_text (uiout
, "\nValue = ");
2365 watchpoint_value_print (b
->val
, stb
->stream
);
2366 ui_out_field_stream (uiout
, "value", stb
);
2367 do_cleanups (ui_out_chain
);
2368 ui_out_text (uiout
, "\n");
2369 return PRINT_UNKNOWN
;
2372 case bp_access_watchpoint
:
2373 if (bs
->old_val
!= NULL
)
2375 annotate_watchpoint (b
->number
);
2376 if (ui_out_is_mi_like_p (uiout
))
2379 async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER
));
2381 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "value");
2382 ui_out_text (uiout
, "\nOld value = ");
2383 watchpoint_value_print (bs
->old_val
, stb
->stream
);
2384 ui_out_field_stream (uiout
, "old", stb
);
2385 ui_out_text (uiout
, "\nNew value = ");
2390 if (ui_out_is_mi_like_p (uiout
))
2393 async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER
));
2394 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "value");
2395 ui_out_text (uiout
, "\nValue = ");
2397 watchpoint_value_print (b
->val
, stb
->stream
);
2398 ui_out_field_stream (uiout
, "new", stb
);
2399 do_cleanups (ui_out_chain
);
2400 ui_out_text (uiout
, "\n");
2401 return PRINT_UNKNOWN
;
2404 /* Fall through, we don't deal with these types of breakpoints
2408 if (ui_out_is_mi_like_p (uiout
))
2411 async_reason_lookup (EXEC_ASYNC_FUNCTION_FINISHED
));
2412 return PRINT_UNKNOWN
;
2416 if (ui_out_is_mi_like_p (uiout
))
2419 async_reason_lookup (EXEC_ASYNC_LOCATION_REACHED
));
2420 return PRINT_UNKNOWN
;
2425 case bp_longjmp_resume
:
2426 case bp_step_resume
:
2427 case bp_watchpoint_scope
:
2430 return PRINT_UNKNOWN
;
2434 /* Generic routine for printing messages indicating why we
2435 stopped. The behavior of this function depends on the value
2436 'print_it' in the bpstat structure. Under some circumstances we
2437 may decide not to print anything here and delegate the task to
2440 static enum print_stop_action
2441 print_bp_stop_message (bpstat bs
)
2443 switch (bs
->print_it
)
2446 /* Nothing should be printed for this bpstat entry. */
2447 return PRINT_UNKNOWN
;
2451 /* We still want to print the frame, but we already printed the
2452 relevant messages. */
2453 return PRINT_SRC_AND_LOC
;
2456 case print_it_normal
:
2458 const struct bp_location
*bl
= bs
->breakpoint_at
;
2459 struct breakpoint
*b
= bl
? bl
->owner
: NULL
;
2461 /* Normal case. Call the breakpoint's print_it method, or
2462 print_it_typical. */
2463 /* FIXME: how breakpoint can ever be NULL here? */
2464 if (b
!= NULL
&& b
->ops
!= NULL
&& b
->ops
->print_it
!= NULL
)
2465 return b
->ops
->print_it (b
);
2467 return print_it_typical (bs
);
2472 internal_error (__FILE__
, __LINE__
,
2473 _("print_bp_stop_message: unrecognized enum value"));
2478 /* Print a message indicating what happened. This is called from
2479 normal_stop(). The input to this routine is the head of the bpstat
2480 list - a list of the eventpoints that caused this stop. This
2481 routine calls the generic print routine for printing a message
2482 about reasons for stopping. This will print (for example) the
2483 "Breakpoint n," part of the output. The return value of this
2486 PRINT_UNKNOWN: Means we printed nothing
2487 PRINT_SRC_AND_LOC: Means we printed something, and expect subsequent
2488 code to print the location. An example is
2489 "Breakpoint 1, " which should be followed by
2491 PRINT_SRC_ONLY: Means we printed something, but there is no need
2492 to also print the location part of the message.
2493 An example is the catch/throw messages, which
2494 don't require a location appended to the end.
2495 PRINT_NOTHING: We have done some printing and we don't need any
2496 further info to be printed.*/
2498 enum print_stop_action
2499 bpstat_print (bpstat bs
)
2503 /* Maybe another breakpoint in the chain caused us to stop.
2504 (Currently all watchpoints go on the bpstat whether hit or not.
2505 That probably could (should) be changed, provided care is taken
2506 with respect to bpstat_explains_signal). */
2507 for (; bs
; bs
= bs
->next
)
2509 val
= print_bp_stop_message (bs
);
2510 if (val
== PRINT_SRC_ONLY
2511 || val
== PRINT_SRC_AND_LOC
2512 || val
== PRINT_NOTHING
)
2516 /* We reached the end of the chain, or we got a null BS to start
2517 with and nothing was printed. */
2518 return PRINT_UNKNOWN
;
2521 /* Evaluate the expression EXP and return 1 if value is zero.
2522 This is used inside a catch_errors to evaluate the breakpoint condition.
2523 The argument is a "struct expression *" that has been cast to char * to
2524 make it pass through catch_errors. */
2527 breakpoint_cond_eval (void *exp
)
2529 struct value
*mark
= value_mark ();
2530 int i
= !value_true (evaluate_expression ((struct expression
*) exp
));
2531 value_free_to_mark (mark
);
2535 /* Allocate a new bpstat and chain it to the current one. */
2538 bpstat_alloc (const struct bp_location
*bl
, bpstat cbs
/* Current "bs" value */ )
2542 bs
= (bpstat
) xmalloc (sizeof (*bs
));
2544 bs
->breakpoint_at
= bl
;
2545 /* If the condition is false, etc., don't do the commands. */
2546 bs
->commands
= NULL
;
2548 bs
->print_it
= print_it_normal
;
2552 /* The target has stopped with waitstatus WS. Check if any hardware
2553 watchpoints have triggered, according to the target. */
2556 watchpoints_triggered (struct target_waitstatus
*ws
)
2558 int stopped_by_watchpoint
= STOPPED_BY_WATCHPOINT (*ws
);
2560 struct breakpoint
*b
;
2562 if (!stopped_by_watchpoint
)
2564 /* We were not stopped by a watchpoint. Mark all watchpoints
2565 as not triggered. */
2567 if (b
->type
== bp_hardware_watchpoint
2568 || b
->type
== bp_read_watchpoint
2569 || b
->type
== bp_access_watchpoint
)
2570 b
->watchpoint_triggered
= watch_triggered_no
;
2575 if (!target_stopped_data_address (¤t_target
, &addr
))
2577 /* We were stopped by a watchpoint, but we don't know where.
2578 Mark all watchpoints as unknown. */
2580 if (b
->type
== bp_hardware_watchpoint
2581 || b
->type
== bp_read_watchpoint
2582 || b
->type
== bp_access_watchpoint
)
2583 b
->watchpoint_triggered
= watch_triggered_unknown
;
2585 return stopped_by_watchpoint
;
2588 /* The target could report the data address. Mark watchpoints
2589 affected by this data address as triggered, and all others as not
2593 if (b
->type
== bp_hardware_watchpoint
2594 || b
->type
== bp_read_watchpoint
2595 || b
->type
== bp_access_watchpoint
)
2597 struct bp_location
*loc
;
2600 b
->watchpoint_triggered
= watch_triggered_no
;
2601 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
2602 /* Exact match not required. Within range is
2604 if (target_watchpoint_addr_within_range (¤t_target
,
2608 b
->watchpoint_triggered
= watch_triggered_yes
;
2616 /* Possible return values for watchpoint_check (this can't be an enum
2617 because of check_errors). */
2618 /* The watchpoint has been deleted. */
2619 #define WP_DELETED 1
2620 /* The value has changed. */
2621 #define WP_VALUE_CHANGED 2
2622 /* The value has not changed. */
2623 #define WP_VALUE_NOT_CHANGED 3
2625 #define BP_TEMPFLAG 1
2626 #define BP_HARDWAREFLAG 2
2628 /* Check watchpoint condition. */
2631 watchpoint_check (void *p
)
2633 bpstat bs
= (bpstat
) p
;
2634 struct breakpoint
*b
;
2635 struct frame_info
*fr
;
2636 int within_current_scope
;
2638 b
= bs
->breakpoint_at
->owner
;
2640 if (b
->exp_valid_block
== NULL
)
2641 within_current_scope
= 1;
2644 /* There is no current frame at this moment. If we're going to have
2645 any chance of handling watchpoints on local variables, we'll need
2646 the frame chain (so we can determine if we're in scope). */
2647 reinit_frame_cache ();
2648 fr
= frame_find_by_id (b
->watchpoint_frame
);
2649 within_current_scope
= (fr
!= NULL
);
2651 /* If we've gotten confused in the unwinder, we might have
2652 returned a frame that can't describe this variable. */
2653 if (within_current_scope
2654 && (block_linkage_function (b
->exp_valid_block
)
2655 != get_frame_function (fr
)))
2656 within_current_scope
= 0;
2658 /* in_function_epilogue_p() returns a non-zero value if we're still
2659 in the function but the stack frame has already been invalidated.
2660 Since we can't rely on the values of local variables after the
2661 stack has been destroyed, we are treating the watchpoint in that
2662 state as `not changed' without further checking.
2664 vinschen/2003-09-04: The former implementation left out the case
2665 that the watchpoint frame couldn't be found by frame_find_by_id()
2666 because the current PC is currently in an epilogue. Calling
2667 gdbarch_in_function_epilogue_p() also when fr == NULL fixes that. */
2668 if ((!within_current_scope
|| fr
== get_current_frame ())
2669 && gdbarch_in_function_epilogue_p (current_gdbarch
, read_pc ()))
2670 return WP_VALUE_NOT_CHANGED
;
2671 if (fr
&& within_current_scope
)
2672 /* If we end up stopping, the current frame will get selected
2673 in normal_stop. So this call to select_frame won't affect
2678 if (within_current_scope
)
2680 /* We use value_{,free_to_}mark because it could be a
2681 *long* time before we return to the command level and
2682 call free_all_values. We can't call free_all_values because
2683 we might be in the middle of evaluating a function call. */
2685 struct value
*mark
= value_mark ();
2686 struct value
*new_val
;
2688 fetch_watchpoint_value (b
->exp
, &new_val
, NULL
, NULL
);
2689 if ((b
->val
!= NULL
) != (new_val
!= NULL
)
2690 || (b
->val
!= NULL
&& !value_equal (b
->val
, new_val
)))
2692 if (new_val
!= NULL
)
2694 release_value (new_val
);
2695 value_free_to_mark (mark
);
2697 bs
->old_val
= b
->val
;
2700 /* We will stop here */
2701 return WP_VALUE_CHANGED
;
2705 /* Nothing changed, don't do anything. */
2706 value_free_to_mark (mark
);
2707 /* We won't stop here */
2708 return WP_VALUE_NOT_CHANGED
;
2713 /* This seems like the only logical thing to do because
2714 if we temporarily ignored the watchpoint, then when
2715 we reenter the block in which it is valid it contains
2716 garbage (in the case of a function, it may have two
2717 garbage values, one before and one after the prologue).
2718 So we can't even detect the first assignment to it and
2719 watch after that (since the garbage may or may not equal
2720 the first value assigned). */
2721 /* We print all the stop information in print_it_typical(), but
2722 in this case, by the time we call print_it_typical() this bp
2723 will be deleted already. So we have no choice but print the
2724 information here. */
2725 if (ui_out_is_mi_like_p (uiout
))
2727 (uiout
, "reason", async_reason_lookup (EXEC_ASYNC_WATCHPOINT_SCOPE
));
2728 ui_out_text (uiout
, "\nWatchpoint ");
2729 ui_out_field_int (uiout
, "wpnum", b
->number
);
2730 ui_out_text (uiout
, " deleted because the program has left the block in\n\
2731 which its expression is valid.\n");
2733 if (b
->related_breakpoint
)
2734 b
->related_breakpoint
->disposition
= disp_del_at_next_stop
;
2735 b
->disposition
= disp_del_at_next_stop
;
2741 /* Return true if it looks like target has stopped due to hitting
2742 breakpoint location BL. This function does not check if we
2743 should stop, only if BL explains the stop. */
2745 bpstat_check_location (const struct bp_location
*bl
, CORE_ADDR bp_addr
)
2747 struct breakpoint
*b
= bl
->owner
;
2749 if (b
->type
!= bp_watchpoint
2750 && b
->type
!= bp_hardware_watchpoint
2751 && b
->type
!= bp_read_watchpoint
2752 && b
->type
!= bp_access_watchpoint
2753 && b
->type
!= bp_hardware_breakpoint
2754 && b
->type
!= bp_catch_fork
2755 && b
->type
!= bp_catch_vfork
2756 && b
->type
!= bp_catch_exec
) /* a non-watchpoint bp */
2758 if (bl
->address
!= bp_addr
) /* address doesn't match */
2760 if (overlay_debugging
/* unmapped overlay section */
2761 && section_is_overlay (bl
->section
)
2762 && !section_is_mapped (bl
->section
))
2766 /* Continuable hardware watchpoints are treated as non-existent if the
2767 reason we stopped wasn't a hardware watchpoint (we didn't stop on
2768 some data address). Otherwise gdb won't stop on a break instruction
2769 in the code (not from a breakpoint) when a hardware watchpoint has
2770 been defined. Also skip watchpoints which we know did not trigger
2771 (did not match the data address). */
2773 if ((b
->type
== bp_hardware_watchpoint
2774 || b
->type
== bp_read_watchpoint
2775 || b
->type
== bp_access_watchpoint
)
2776 && b
->watchpoint_triggered
== watch_triggered_no
)
2779 if (b
->type
== bp_hardware_breakpoint
)
2781 if (bl
->address
!= bp_addr
)
2783 if (overlay_debugging
/* unmapped overlay section */
2784 && section_is_overlay (bl
->section
)
2785 && !section_is_mapped (bl
->section
))
2789 /* Is this a catchpoint of a load or unload? If so, did we
2790 get a load or unload of the specified library? If not,
2792 if ((b
->type
== bp_catch_load
)
2793 #if defined(SOLIB_HAVE_LOAD_EVENT)
2794 && (!SOLIB_HAVE_LOAD_EVENT (PIDGET (inferior_ptid
))
2795 || ((b
->dll_pathname
!= NULL
)
2796 && (strcmp (b
->dll_pathname
,
2797 SOLIB_LOADED_LIBRARY_PATHNAME (
2798 PIDGET (inferior_ptid
)))
2804 if ((b
->type
== bp_catch_unload
)
2805 #if defined(SOLIB_HAVE_UNLOAD_EVENT)
2806 && (!SOLIB_HAVE_UNLOAD_EVENT (PIDGET (inferior_ptid
))
2807 || ((b
->dll_pathname
!= NULL
)
2808 && (strcmp (b
->dll_pathname
,
2809 SOLIB_UNLOADED_LIBRARY_PATHNAME (
2810 PIDGET (inferior_ptid
)))
2816 if ((b
->type
== bp_catch_fork
)
2817 && !inferior_has_forked (inferior_ptid
,
2818 &b
->forked_inferior_pid
))
2821 if ((b
->type
== bp_catch_vfork
)
2822 && !inferior_has_vforked (inferior_ptid
,
2823 &b
->forked_inferior_pid
))
2826 if ((b
->type
== bp_catch_exec
)
2827 && !inferior_has_execd (inferior_ptid
, &b
->exec_pathname
))
2833 /* If BS refers to a watchpoint, determine if the watched values
2834 has actually changed, and we should stop. If not, set BS->stop
2837 bpstat_check_watchpoint (bpstat bs
)
2839 const struct bp_location
*bl
= bs
->breakpoint_at
;
2840 struct breakpoint
*b
= bl
->owner
;
2842 if (b
->type
== bp_watchpoint
2843 || b
->type
== bp_read_watchpoint
2844 || b
->type
== bp_access_watchpoint
2845 || b
->type
== bp_hardware_watchpoint
)
2849 int must_check_value
= 0;
2851 if (b
->type
== bp_watchpoint
)
2852 /* For a software watchpoint, we must always check the
2854 must_check_value
= 1;
2855 else if (b
->watchpoint_triggered
== watch_triggered_yes
)
2856 /* We have a hardware watchpoint (read, write, or access)
2857 and the target earlier reported an address watched by
2859 must_check_value
= 1;
2860 else if (b
->watchpoint_triggered
== watch_triggered_unknown
2861 && b
->type
== bp_hardware_watchpoint
)
2862 /* We were stopped by a hardware watchpoint, but the target could
2863 not report the data address. We must check the watchpoint's
2864 value. Access and read watchpoints are out of luck; without
2865 a data address, we can't figure it out. */
2866 must_check_value
= 1;
2868 if (must_check_value
)
2870 char *message
= xstrprintf ("Error evaluating expression for watchpoint %d\n",
2872 struct cleanup
*cleanups
= make_cleanup (xfree
, message
);
2873 int e
= catch_errors (watchpoint_check
, bs
, message
,
2875 do_cleanups (cleanups
);
2879 /* We've already printed what needs to be printed. */
2880 bs
->print_it
= print_it_done
;
2883 case WP_VALUE_CHANGED
:
2884 if (b
->type
== bp_read_watchpoint
)
2886 /* Don't stop: read watchpoints shouldn't fire if
2887 the value has changed. This is for targets
2888 which cannot set read-only watchpoints. */
2889 bs
->print_it
= print_it_noop
;
2893 case WP_VALUE_NOT_CHANGED
:
2894 if (b
->type
== bp_hardware_watchpoint
2895 || b
->type
== bp_watchpoint
)
2897 /* Don't stop: write watchpoints shouldn't fire if
2898 the value hasn't changed. */
2899 bs
->print_it
= print_it_noop
;
2907 /* Error from catch_errors. */
2908 printf_filtered (_("Watchpoint %d deleted.\n"), b
->number
);
2909 if (b
->related_breakpoint
)
2910 b
->related_breakpoint
->disposition
= disp_del_at_next_stop
;
2911 b
->disposition
= disp_del_at_next_stop
;
2912 /* We've already printed what needs to be printed. */
2913 bs
->print_it
= print_it_done
;
2917 else /* must_check_value == 0 */
2919 /* This is a case where some watchpoint(s) triggered, but
2920 not at the address of this watchpoint, or else no
2921 watchpoint triggered after all. So don't print
2922 anything for this watchpoint. */
2923 bs
->print_it
= print_it_noop
;
2930 /* Check conditions (condition proper, frame, thread and ignore count)
2931 of breakpoint referred to by BS. If we should not stop for this
2932 breakpoint, set BS->stop to 0. */
2934 bpstat_check_breakpoint_conditions (bpstat bs
, ptid_t ptid
)
2936 int thread_id
= pid_to_thread_id (ptid
);
2937 const struct bp_location
*bl
= bs
->breakpoint_at
;
2938 struct breakpoint
*b
= bl
->owner
;
2940 if (frame_id_p (b
->frame_id
)
2941 && !frame_id_eq (b
->frame_id
, get_frame_id (get_current_frame ())))
2945 int value_is_zero
= 0;
2947 /* If this is a scope breakpoint, mark the associated
2948 watchpoint as triggered so that we will handle the
2949 out-of-scope event. We'll get to the watchpoint next
2951 if (b
->type
== bp_watchpoint_scope
)
2952 b
->related_breakpoint
->watchpoint_triggered
= watch_triggered_yes
;
2954 if (bl
->cond
&& bl
->owner
->disposition
!= disp_del_at_next_stop
)
2956 /* Need to select the frame, with all that implies
2957 so that the conditions will have the right context. */
2958 select_frame (get_current_frame ());
2960 = catch_errors (breakpoint_cond_eval
, (bl
->cond
),
2961 "Error in testing breakpoint condition:\n",
2963 /* FIXME-someday, should give breakpoint # */
2966 if (bl
->cond
&& value_is_zero
)
2970 else if (b
->thread
!= -1 && b
->thread
!= thread_id
)
2974 else if (b
->ignore_count
> 0)
2977 annotate_ignore_count_change ();
2979 /* Increase the hit count even though we don't
2987 /* Get a bpstat associated with having just stopped at address
2988 BP_ADDR in thread PTID.
2990 Determine whether we stopped at a breakpoint, etc, or whether we
2991 don't understand this stop. Result is a chain of bpstat's such that:
2993 if we don't understand the stop, the result is a null pointer.
2995 if we understand why we stopped, the result is not null.
2997 Each element of the chain refers to a particular breakpoint or
2998 watchpoint at which we have stopped. (We may have stopped for
2999 several reasons concurrently.)
3001 Each element of the chain has valid next, breakpoint_at,
3002 commands, FIXME??? fields. */
3005 bpstat_stop_status (CORE_ADDR bp_addr
, ptid_t ptid
)
3007 struct breakpoint
*b
= NULL
;
3008 const struct bp_location
*bl
;
3009 struct bp_location
*loc
;
3010 /* Root of the chain of bpstat's */
3011 struct bpstats root_bs
[1];
3012 /* Pointer to the last thing in the chain currently. */
3013 bpstat bs
= root_bs
;
3016 ALL_BP_LOCATIONS (bl
)
3020 if (!breakpoint_enabled (b
) && b
->enable_state
!= bp_permanent
)
3023 /* For hardware watchpoints, we look only at the first location.
3024 The watchpoint_check function will work on entire expression,
3025 not the individual locations. For read watchopints, the
3026 watchpoints_triggered function have checked all locations
3029 if (b
->type
== bp_hardware_watchpoint
&& bl
!= b
->loc
)
3032 if (!bpstat_check_location (bl
, bp_addr
))
3035 /* Come here if it's a watchpoint, or if the break address matches */
3037 bs
= bpstat_alloc (bl
, bs
); /* Alloc a bpstat to explain stop */
3039 /* Assume we stop. Should we find watchpoint that is not actually
3040 triggered, or if condition of breakpoint is false, we'll reset
3045 bpstat_check_watchpoint (bs
);
3049 if (b
->type
== bp_thread_event
|| b
->type
== bp_overlay_event
)
3050 /* We do not stop for these. */
3053 bpstat_check_breakpoint_conditions (bs
, ptid
);
3059 /* We will stop here */
3060 if (b
->disposition
== disp_disable
)
3062 b
->enable_state
= bp_disabled
;
3063 update_global_location_list (0);
3067 bs
->commands
= b
->commands
;
3069 (strcmp ("silent", bs
->commands
->line
) == 0
3070 || (xdb_commands
&& strcmp ("Q", bs
->commands
->line
) == 0)))
3072 bs
->commands
= bs
->commands
->next
;
3075 bs
->commands
= copy_command_lines (bs
->commands
);
3078 /* Print nothing for this entry if we dont stop or if we dont print. */
3079 if (bs
->stop
== 0 || bs
->print
== 0)
3080 bs
->print_it
= print_it_noop
;
3083 for (ix
= 0; VEC_iterate (bp_location_p
, moribund_locations
, ix
, loc
); ++ix
)
3085 if (loc
->address
== bp_addr
)
3087 bs
= bpstat_alloc (loc
, bs
);
3088 /* For hits of moribund locations, we should just proceed. */
3091 bs
->print_it
= print_it_noop
;
3095 bs
->next
= NULL
; /* Terminate the chain */
3096 bs
= root_bs
->next
; /* Re-grab the head of the chain */
3098 /* If we aren't stopping, the value of some hardware watchpoint may
3099 not have changed, but the intermediate memory locations we are
3100 watching may have. Don't bother if we're stopping; this will get
3102 for (bs
= root_bs
->next
; bs
!= NULL
; bs
= bs
->next
)
3107 for (bs
= root_bs
->next
; bs
!= NULL
; bs
= bs
->next
)
3109 && bs
->breakpoint_at
->owner
3110 && (bs
->breakpoint_at
->owner
->type
== bp_hardware_watchpoint
3111 || bs
->breakpoint_at
->owner
->type
== bp_read_watchpoint
3112 || bs
->breakpoint_at
->owner
->type
== bp_access_watchpoint
))
3114 /* remove/insert can invalidate bs->breakpoint_at, if this
3115 location is no longer used by the watchpoint. Prevent
3116 further code from trying to use it. */
3117 bs
->breakpoint_at
= NULL
;
3118 remove_breakpoints ();
3119 insert_breakpoints ();
3123 return root_bs
->next
;
3126 /* Tell what to do about this bpstat. */
3128 bpstat_what (bpstat bs
)
3130 /* Classify each bpstat as one of the following. */
3133 /* This bpstat element has no effect on the main_action. */
3136 /* There was a watchpoint, stop but don't print. */
3139 /* There was a watchpoint, stop and print. */
3142 /* There was a breakpoint but we're not stopping. */
3145 /* There was a breakpoint, stop but don't print. */
3148 /* There was a breakpoint, stop and print. */
3151 /* We hit the longjmp breakpoint. */
3154 /* We hit the longjmp_resume breakpoint. */
3157 /* We hit the step_resume breakpoint. */
3160 /* We hit the shared library event breakpoint. */
3163 /* We caught a shared library event. */
3166 /* This is just used to count how many enums there are. */
3170 /* Here is the table which drives this routine. So that we can
3171 format it pretty, we define some abbreviations for the
3172 enum bpstat_what codes. */
3173 #define kc BPSTAT_WHAT_KEEP_CHECKING
3174 #define ss BPSTAT_WHAT_STOP_SILENT
3175 #define sn BPSTAT_WHAT_STOP_NOISY
3176 #define sgl BPSTAT_WHAT_SINGLE
3177 #define slr BPSTAT_WHAT_SET_LONGJMP_RESUME
3178 #define clr BPSTAT_WHAT_CLEAR_LONGJMP_RESUME
3179 #define sr BPSTAT_WHAT_STEP_RESUME
3180 #define shl BPSTAT_WHAT_CHECK_SHLIBS
3181 #define shlr BPSTAT_WHAT_CHECK_SHLIBS_RESUME_FROM_HOOK
3183 /* "Can't happen." Might want to print an error message.
3184 abort() is not out of the question, but chances are GDB is just
3185 a bit confused, not unusable. */
3186 #define err BPSTAT_WHAT_STOP_NOISY
3188 /* Given an old action and a class, come up with a new action. */
3189 /* One interesting property of this table is that wp_silent is the same
3190 as bp_silent and wp_noisy is the same as bp_noisy. That is because
3191 after stopping, the check for whether to step over a breakpoint
3192 (BPSTAT_WHAT_SINGLE type stuff) is handled in proceed() without
3193 reference to how we stopped. We retain separate wp_silent and
3194 bp_silent codes in case we want to change that someday.
3196 Another possibly interesting property of this table is that
3197 there's a partial ordering, priority-like, of the actions. Once
3198 you've decided that some action is appropriate, you'll never go
3199 back and decide something of a lower priority is better. The
3202 kc < clr sgl shl shlr slr sn sr ss
3203 sgl < shl shlr slr sn sr ss
3204 slr < err shl shlr sn sr ss
3205 clr < err shl shlr sn sr ss
3212 What I think this means is that we don't need a damned table
3213 here. If you just put the rows and columns in the right order,
3214 it'd look awfully regular. We could simply walk the bpstat list
3215 and choose the highest priority action we find, with a little
3216 logic to handle the 'err' cases. */
3218 /* step_resume entries: a step resume breakpoint overrides another
3219 breakpoint of signal handling (see comment in wait_for_inferior
3220 at where we set the step_resume breakpoint). */
3222 static const enum bpstat_what_main_action
3223 table
[(int) class_last
][(int) BPSTAT_WHAT_LAST
] =
3226 /* kc ss sn sgl slr clr sr shl shlr
3229 {kc
, ss
, sn
, sgl
, slr
, clr
, sr
, shl
, shlr
},
3231 {ss
, ss
, sn
, ss
, ss
, ss
, sr
, shl
, shlr
},
3233 {sn
, sn
, sn
, sn
, sn
, sn
, sr
, shl
, shlr
},
3235 {sgl
, ss
, sn
, sgl
, slr
, slr
, sr
, shl
, shlr
},
3237 {ss
, ss
, sn
, ss
, ss
, ss
, sr
, shl
, shlr
},
3239 {sn
, sn
, sn
, sn
, sn
, sn
, sr
, shl
, shlr
},
3241 {slr
, ss
, sn
, slr
, slr
, err
, sr
, shl
, shlr
},
3243 {clr
, ss
, sn
, err
, err
, err
, sr
, shl
, shlr
},
3245 {sr
, sr
, sr
, sr
, sr
, sr
, sr
, sr
, sr
},
3247 {shl
, shl
, shl
, shl
, shl
, shl
, sr
, shl
, shlr
},
3249 {shlr
, shlr
, shlr
, shlr
, shlr
, shlr
, sr
, shlr
, shlr
}
3263 enum bpstat_what_main_action current_action
= BPSTAT_WHAT_KEEP_CHECKING
;
3264 struct bpstat_what retval
;
3266 retval
.call_dummy
= 0;
3267 for (; bs
!= NULL
; bs
= bs
->next
)
3269 enum class bs_class
= no_effect
;
3270 if (bs
->breakpoint_at
== NULL
)
3271 /* I suspect this can happen if it was a momentary breakpoint
3272 which has since been deleted. */
3274 if (bs
->breakpoint_at
->owner
== NULL
)
3275 bs_class
= bp_nostop
;
3277 switch (bs
->breakpoint_at
->owner
->type
)
3283 case bp_hardware_breakpoint
:
3289 bs_class
= bp_noisy
;
3291 bs_class
= bp_silent
;
3294 bs_class
= bp_nostop
;
3297 case bp_hardware_watchpoint
:
3298 case bp_read_watchpoint
:
3299 case bp_access_watchpoint
:
3303 bs_class
= wp_noisy
;
3305 bs_class
= wp_silent
;
3308 /* There was a watchpoint, but we're not stopping.
3309 This requires no further action. */
3310 bs_class
= no_effect
;
3313 bs_class
= long_jump
;
3315 case bp_longjmp_resume
:
3316 bs_class
= long_resume
;
3318 case bp_step_resume
:
3321 bs_class
= step_resume
;
3324 /* It is for the wrong frame. */
3325 bs_class
= bp_nostop
;
3327 case bp_watchpoint_scope
:
3328 bs_class
= bp_nostop
;
3330 case bp_shlib_event
:
3331 bs_class
= shlib_event
;
3333 case bp_thread_event
:
3334 case bp_overlay_event
:
3335 bs_class
= bp_nostop
;
3338 case bp_catch_unload
:
3339 /* Only if this catchpoint triggered should we cause the
3340 step-out-of-dld behaviour. Otherwise, we ignore this
3343 bs_class
= catch_shlib_event
;
3345 bs_class
= no_effect
;
3348 case bp_catch_vfork
:
3353 bs_class
= bp_noisy
;
3355 bs_class
= bp_silent
;
3358 /* There was a catchpoint, but we're not stopping.
3359 This requires no further action. */
3360 bs_class
= no_effect
;
3363 /* Make sure the action is stop (silent or noisy),
3364 so infrun.c pops the dummy frame. */
3365 bs_class
= bp_silent
;
3366 retval
.call_dummy
= 1;
3369 current_action
= table
[(int) bs_class
][(int) current_action
];
3371 retval
.main_action
= current_action
;
3375 /* Nonzero if we should step constantly (e.g. watchpoints on machines
3376 without hardware support). This isn't related to a specific bpstat,
3377 just to things like whether watchpoints are set. */
3380 bpstat_should_step (void)
3382 struct breakpoint
*b
;
3384 if (breakpoint_enabled (b
) && b
->type
== bp_watchpoint
)
3391 /* Given a bpstat that records zero or more triggered eventpoints, this
3392 function returns another bpstat which contains only the catchpoints
3393 on that first list, if any. */
3395 bpstat_get_triggered_catchpoints (bpstat ep_list
, bpstat
*cp_list
)
3397 struct bpstats root_bs
[1];
3398 bpstat bs
= root_bs
;
3399 struct breakpoint
*ep
;
3402 bpstat_clear (cp_list
);
3403 root_bs
->next
= NULL
;
3405 for (; ep_list
!= NULL
; ep_list
= ep_list
->next
)
3407 /* Is this eventpoint a catchpoint? If not, ignore it. */
3408 ep
= ep_list
->breakpoint_at
->owner
;
3411 if ((ep
->type
!= bp_catch_load
) &&
3412 (ep
->type
!= bp_catch_unload
))
3413 /* pai: (temp) ADD fork/vfork here!! */
3416 /* Yes; add it to the list. */
3417 bs
= bpstat_alloc (ep_list
->breakpoint_at
, bs
);
3422 #if defined(SOLIB_ADD)
3423 /* Also, for each triggered catchpoint, tag it with the name of
3424 the library that caused this trigger. (We copy the name now,
3425 because it's only guaranteed to be available NOW, when the
3426 catchpoint triggers. Clients who may wish to know the name
3427 later must get it from the catchpoint itself.) */
3428 if (ep
->triggered_dll_pathname
!= NULL
)
3429 xfree (ep
->triggered_dll_pathname
);
3430 if (ep
->type
== bp_catch_load
)
3431 dll_pathname
= SOLIB_LOADED_LIBRARY_PATHNAME (
3432 PIDGET (inferior_ptid
));
3434 dll_pathname
= SOLIB_UNLOADED_LIBRARY_PATHNAME (
3435 PIDGET (inferior_ptid
));
3437 dll_pathname
= NULL
;
3441 ep
->triggered_dll_pathname
= (char *)
3442 xmalloc (strlen (dll_pathname
) + 1);
3443 strcpy (ep
->triggered_dll_pathname
, dll_pathname
);
3446 ep
->triggered_dll_pathname
= NULL
;
3452 static void print_breakpoint_location (struct breakpoint
*b
,
3453 struct bp_location
*loc
,
3455 struct ui_stream
*stb
)
3460 = find_pc_sect_function (loc
->address
, loc
->section
);
3463 ui_out_text (uiout
, "in ");
3464 ui_out_field_string (uiout
, "func",
3465 SYMBOL_PRINT_NAME (sym
));
3466 ui_out_wrap_hint (uiout
, wrap_indent
);
3467 ui_out_text (uiout
, " at ");
3469 ui_out_field_string (uiout
, "file", b
->source_file
);
3470 ui_out_text (uiout
, ":");
3472 if (ui_out_is_mi_like_p (uiout
))
3474 struct symtab_and_line sal
= find_pc_line (loc
->address
, 0);
3475 char *fullname
= symtab_to_fullname (sal
.symtab
);
3478 ui_out_field_string (uiout
, "fullname", fullname
);
3481 ui_out_field_int (uiout
, "line", b
->line_number
);
3485 ui_out_field_string (uiout
, "pending", b
->addr_string
);
3489 print_address_symbolic (loc
->address
, stb
->stream
, demangle
, "");
3490 ui_out_field_stream (uiout
, "at", stb
);
3494 /* Print B to gdb_stdout. */
3496 print_one_breakpoint_location (struct breakpoint
*b
,
3497 struct bp_location
*loc
,
3499 CORE_ADDR
*last_addr
)
3501 struct command_line
*l
;
3503 struct ep_type_description
3508 static struct ep_type_description bptypes
[] =
3510 {bp_none
, "?deleted?"},
3511 {bp_breakpoint
, "breakpoint"},
3512 {bp_hardware_breakpoint
, "hw breakpoint"},
3513 {bp_until
, "until"},
3514 {bp_finish
, "finish"},
3515 {bp_watchpoint
, "watchpoint"},
3516 {bp_hardware_watchpoint
, "hw watchpoint"},
3517 {bp_read_watchpoint
, "read watchpoint"},
3518 {bp_access_watchpoint
, "acc watchpoint"},
3519 {bp_longjmp
, "longjmp"},
3520 {bp_longjmp_resume
, "longjmp resume"},
3521 {bp_step_resume
, "step resume"},
3522 {bp_watchpoint_scope
, "watchpoint scope"},
3523 {bp_call_dummy
, "call dummy"},
3524 {bp_shlib_event
, "shlib events"},
3525 {bp_thread_event
, "thread events"},
3526 {bp_overlay_event
, "overlay events"},
3527 {bp_catch_load
, "catch load"},
3528 {bp_catch_unload
, "catch unload"},
3529 {bp_catch_fork
, "catch fork"},
3530 {bp_catch_vfork
, "catch vfork"},
3531 {bp_catch_exec
, "catch exec"}
3534 static char bpenables
[] = "nynny";
3535 char wrap_indent
[80];
3536 struct ui_stream
*stb
= ui_out_stream_new (uiout
);
3537 struct cleanup
*old_chain
= make_cleanup_ui_out_stream_delete (stb
);
3538 struct cleanup
*bkpt_chain
;
3540 int header_of_multiple
= 0;
3541 int part_of_multiple
= (loc
!= NULL
);
3543 gdb_assert (!loc
|| loc_number
!= 0);
3544 /* See comment in print_one_breakpoint concerning
3545 treatment of breakpoints with single disabled
3549 && (b
->loc
->next
!= NULL
|| !b
->loc
->enabled
)))
3550 header_of_multiple
= 1;
3555 bkpt_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "bkpt");
3559 if (part_of_multiple
)
3562 formatted
= xstrprintf ("%d.%d", b
->number
, loc_number
);
3563 ui_out_field_string (uiout
, "number", formatted
);
3568 ui_out_field_int (uiout
, "number", b
->number
);
3573 if (part_of_multiple
)
3574 ui_out_field_skip (uiout
, "type");
3577 if (((int) b
->type
>= (sizeof (bptypes
) / sizeof (bptypes
[0])))
3578 || ((int) b
->type
!= bptypes
[(int) b
->type
].type
))
3579 internal_error (__FILE__
, __LINE__
,
3580 _("bptypes table does not describe type #%d."),
3582 ui_out_field_string (uiout
, "type", bptypes
[(int) b
->type
].description
);
3587 if (part_of_multiple
)
3588 ui_out_field_skip (uiout
, "disp");
3590 ui_out_field_string (uiout
, "disp", bpdisp_text (b
->disposition
));
3595 if (part_of_multiple
)
3596 ui_out_field_string (uiout
, "enabled", loc
->enabled
? "y" : "n");
3598 ui_out_field_fmt (uiout
, "enabled", "%c",
3599 bpenables
[(int) b
->enable_state
]);
3600 ui_out_spaces (uiout
, 2);
3604 strcpy (wrap_indent
, " ");
3607 if (gdbarch_addr_bit (current_gdbarch
) <= 32)
3608 strcat (wrap_indent
, " ");
3610 strcat (wrap_indent
, " ");
3613 if (b
->ops
!= NULL
&& b
->ops
->print_one
!= NULL
)
3615 /* Although the print_one can possibly print
3616 all locations, calling it here is not likely
3617 to get any nice result. So, make sure there's
3618 just one location. */
3619 gdb_assert (b
->loc
== NULL
|| b
->loc
->next
== NULL
);
3620 b
->ops
->print_one (b
, last_addr
);
3626 internal_error (__FILE__
, __LINE__
,
3627 _("print_one_breakpoint: bp_none encountered\n"));
3631 case bp_hardware_watchpoint
:
3632 case bp_read_watchpoint
:
3633 case bp_access_watchpoint
:
3634 /* Field 4, the address, is omitted (which makes the columns
3635 not line up too nicely with the headers, but the effect
3636 is relatively readable). */
3638 ui_out_field_skip (uiout
, "addr");
3640 print_expression (b
->exp
, stb
->stream
);
3641 ui_out_field_stream (uiout
, "what", stb
);
3645 case bp_catch_unload
:
3646 /* Field 4, the address, is omitted (which makes the columns
3647 not line up too nicely with the headers, but the effect
3648 is relatively readable). */
3650 ui_out_field_skip (uiout
, "addr");
3652 if (b
->dll_pathname
== NULL
)
3654 ui_out_field_string (uiout
, "what", "<any library>");
3655 ui_out_spaces (uiout
, 1);
3659 ui_out_text (uiout
, "library \"");
3660 ui_out_field_string (uiout
, "what", b
->dll_pathname
);
3661 ui_out_text (uiout
, "\" ");
3666 case bp_catch_vfork
:
3667 /* Field 4, the address, is omitted (which makes the columns
3668 not line up too nicely with the headers, but the effect
3669 is relatively readable). */
3671 ui_out_field_skip (uiout
, "addr");
3673 if (!ptid_equal (b
->forked_inferior_pid
, null_ptid
))
3675 ui_out_text (uiout
, "process ");
3676 ui_out_field_int (uiout
, "what",
3677 ptid_get_pid (b
->forked_inferior_pid
));
3678 ui_out_spaces (uiout
, 1);
3683 /* Field 4, the address, is omitted (which makes the columns
3684 not line up too nicely with the headers, but the effect
3685 is relatively readable). */
3687 ui_out_field_skip (uiout
, "addr");
3689 if (b
->exec_pathname
!= NULL
)
3691 ui_out_text (uiout
, "program \"");
3692 ui_out_field_string (uiout
, "what", b
->exec_pathname
);
3693 ui_out_text (uiout
, "\" ");
3698 case bp_hardware_breakpoint
:
3702 case bp_longjmp_resume
:
3703 case bp_step_resume
:
3704 case bp_watchpoint_scope
:
3706 case bp_shlib_event
:
3707 case bp_thread_event
:
3708 case bp_overlay_event
:
3712 if (header_of_multiple
)
3713 ui_out_field_string (uiout
, "addr", "<MULTIPLE>");
3714 else if (b
->loc
== NULL
|| loc
->shlib_disabled
)
3715 ui_out_field_string (uiout
, "addr", "<PENDING>");
3717 ui_out_field_core_addr (uiout
, "addr", loc
->address
);
3720 if (!header_of_multiple
)
3721 print_breakpoint_location (b
, loc
, wrap_indent
, stb
);
3723 *last_addr
= b
->loc
->address
;
3727 if (!part_of_multiple
&& b
->thread
!= -1)
3729 /* FIXME: This seems to be redundant and lost here; see the
3730 "stop only in" line a little further down. */
3731 ui_out_text (uiout
, " thread ");
3732 ui_out_field_int (uiout
, "thread", b
->thread
);
3735 ui_out_text (uiout
, "\n");
3737 if (part_of_multiple
&& frame_id_p (b
->frame_id
))
3740 ui_out_text (uiout
, "\tstop only in stack frame at ");
3741 /* FIXME: cagney/2002-12-01: Shouldn't be poeking around inside
3743 ui_out_field_core_addr (uiout
, "frame", b
->frame_id
.stack_addr
);
3744 ui_out_text (uiout
, "\n");
3747 if (!part_of_multiple
&& b
->cond_string
&& !ada_exception_catchpoint_p (b
))
3749 /* We do not print the condition for Ada exception catchpoints
3750 because the condition is an internal implementation detail
3751 that we do not want to expose to the user. */
3753 ui_out_text (uiout
, "\tstop only if ");
3754 ui_out_field_string (uiout
, "cond", b
->cond_string
);
3755 ui_out_text (uiout
, "\n");
3758 if (!part_of_multiple
&& b
->thread
!= -1)
3760 /* FIXME should make an annotation for this */
3761 ui_out_text (uiout
, "\tstop only in thread ");
3762 ui_out_field_int (uiout
, "thread", b
->thread
);
3763 ui_out_text (uiout
, "\n");
3766 if (!part_of_multiple
&& show_breakpoint_hit_counts
&& b
->hit_count
)
3768 /* FIXME should make an annotation for this */
3769 if (ep_is_catchpoint (b
))
3770 ui_out_text (uiout
, "\tcatchpoint");
3772 ui_out_text (uiout
, "\tbreakpoint");
3773 ui_out_text (uiout
, " already hit ");
3774 ui_out_field_int (uiout
, "times", b
->hit_count
);
3775 if (b
->hit_count
== 1)
3776 ui_out_text (uiout
, " time\n");
3778 ui_out_text (uiout
, " times\n");
3781 /* Output the count also if it is zero, but only if this is
3782 mi. FIXME: Should have a better test for this. */
3783 if (ui_out_is_mi_like_p (uiout
))
3784 if (!part_of_multiple
&& show_breakpoint_hit_counts
&& b
->hit_count
== 0)
3785 ui_out_field_int (uiout
, "times", b
->hit_count
);
3787 if (!part_of_multiple
&& b
->ignore_count
)
3790 ui_out_text (uiout
, "\tignore next ");
3791 ui_out_field_int (uiout
, "ignore", b
->ignore_count
);
3792 ui_out_text (uiout
, " hits\n");
3795 if (!part_of_multiple
&& (l
= b
->commands
))
3797 struct cleanup
*script_chain
;
3800 script_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "script");
3801 print_command_lines (uiout
, l
, 4);
3802 do_cleanups (script_chain
);
3805 if (ui_out_is_mi_like_p (uiout
) && !part_of_multiple
)
3808 ui_out_field_string (uiout
, "original-location", b
->addr_string
);
3809 else if (b
->exp_string
)
3810 ui_out_field_string (uiout
, "original-location", b
->exp_string
);
3813 do_cleanups (bkpt_chain
);
3814 do_cleanups (old_chain
);
3818 print_one_breakpoint (struct breakpoint
*b
,
3819 CORE_ADDR
*last_addr
)
3821 print_one_breakpoint_location (b
, NULL
, 0, last_addr
);
3823 /* If this breakpoint has custom print function,
3824 it's already printed. Otherwise, print individual
3825 locations, if any. */
3826 if (b
->ops
== NULL
|| b
->ops
->print_one
== NULL
)
3828 /* If breakpoint has a single location that is
3829 disabled, we print it as if it had
3830 several locations, since otherwise it's hard to
3831 represent "breakpoint enabled, location disabled"
3833 Note that while hardware watchpoints have
3834 several locations internally, that's no a property
3837 && !is_hardware_watchpoint (b
)
3838 && (b
->loc
->next
|| !b
->loc
->enabled
)
3839 && !ui_out_is_mi_like_p (uiout
))
3841 struct bp_location
*loc
;
3843 for (loc
= b
->loc
; loc
; loc
= loc
->next
, ++n
)
3844 print_one_breakpoint_location (b
, loc
, n
, last_addr
);
3850 struct captured_breakpoint_query_args
3856 do_captured_breakpoint_query (struct ui_out
*uiout
, void *data
)
3858 struct captured_breakpoint_query_args
*args
= data
;
3859 struct breakpoint
*b
;
3860 CORE_ADDR dummy_addr
= 0;
3863 if (args
->bnum
== b
->number
)
3865 print_one_breakpoint (b
, &dummy_addr
);
3873 gdb_breakpoint_query (struct ui_out
*uiout
, int bnum
, char **error_message
)
3875 struct captured_breakpoint_query_args args
;
3877 /* For the moment we don't trust print_one_breakpoint() to not throw
3879 if (catch_exceptions_with_msg (uiout
, do_captured_breakpoint_query
, &args
,
3880 error_message
, RETURN_MASK_ALL
) < 0)
3886 /* Return non-zero if B is user settable (breakpoints, watchpoints,
3887 catchpoints, et.al.). */
3890 user_settable_breakpoint (const struct breakpoint
*b
)
3892 return (b
->type
== bp_breakpoint
3893 || b
->type
== bp_catch_load
3894 || b
->type
== bp_catch_unload
3895 || b
->type
== bp_catch_fork
3896 || b
->type
== bp_catch_vfork
3897 || b
->type
== bp_catch_exec
3898 || b
->type
== bp_hardware_breakpoint
3899 || b
->type
== bp_watchpoint
3900 || b
->type
== bp_read_watchpoint
3901 || b
->type
== bp_access_watchpoint
3902 || b
->type
== bp_hardware_watchpoint
);
3905 /* Print information on user settable breakpoint (watchpoint, etc)
3906 number BNUM. If BNUM is -1 print all user settable breakpoints.
3907 If ALLFLAG is non-zero, include non- user settable breakpoints. */
3910 breakpoint_1 (int bnum
, int allflag
)
3912 struct breakpoint
*b
;
3913 CORE_ADDR last_addr
= (CORE_ADDR
) -1;
3914 int nr_printable_breakpoints
;
3915 struct cleanup
*bkpttbl_chain
;
3917 /* Compute the number of rows in the table. */
3918 nr_printable_breakpoints
= 0;
3921 || bnum
== b
->number
)
3923 if (allflag
|| user_settable_breakpoint (b
))
3924 nr_printable_breakpoints
++;
3929 = make_cleanup_ui_out_table_begin_end (uiout
, 6, nr_printable_breakpoints
,
3933 = make_cleanup_ui_out_table_begin_end (uiout
, 5, nr_printable_breakpoints
,
3936 if (nr_printable_breakpoints
> 0)
3937 annotate_breakpoints_headers ();
3938 if (nr_printable_breakpoints
> 0)
3940 ui_out_table_header (uiout
, 7, ui_left
, "number", "Num"); /* 1 */
3941 if (nr_printable_breakpoints
> 0)
3943 ui_out_table_header (uiout
, 14, ui_left
, "type", "Type"); /* 2 */
3944 if (nr_printable_breakpoints
> 0)
3946 ui_out_table_header (uiout
, 4, ui_left
, "disp", "Disp"); /* 3 */
3947 if (nr_printable_breakpoints
> 0)
3949 ui_out_table_header (uiout
, 3, ui_left
, "enabled", "Enb"); /* 4 */
3952 if (nr_printable_breakpoints
> 0)
3954 if (gdbarch_addr_bit (current_gdbarch
) <= 32)
3955 ui_out_table_header (uiout
, 10, ui_left
, "addr", "Address");/* 5 */
3957 ui_out_table_header (uiout
, 18, ui_left
, "addr", "Address");/* 5 */
3959 if (nr_printable_breakpoints
> 0)
3961 ui_out_table_header (uiout
, 40, ui_noalign
, "what", "What"); /* 6 */
3962 ui_out_table_body (uiout
);
3963 if (nr_printable_breakpoints
> 0)
3964 annotate_breakpoints_table ();
3968 || bnum
== b
->number
)
3970 /* We only print out user settable breakpoints unless the
3972 if (allflag
|| user_settable_breakpoint (b
))
3973 print_one_breakpoint (b
, &last_addr
);
3976 do_cleanups (bkpttbl_chain
);
3978 if (nr_printable_breakpoints
== 0)
3981 ui_out_message (uiout
, 0, "No breakpoints or watchpoints.\n");
3983 ui_out_message (uiout
, 0, "No breakpoint or watchpoint number %d.\n",
3988 /* Compare against (CORE_ADDR)-1 in case some compiler decides
3989 that a comparison of an unsigned with -1 is always false. */
3990 if (last_addr
!= (CORE_ADDR
) -1 && !server_command
)
3991 set_next_address (last_addr
);
3994 /* FIXME? Should this be moved up so that it is only called when
3995 there have been breakpoints? */
3996 annotate_breakpoints_table_end ();
4000 breakpoints_info (char *bnum_exp
, int from_tty
)
4005 bnum
= parse_and_eval_long (bnum_exp
);
4007 breakpoint_1 (bnum
, 0);
4011 maintenance_info_breakpoints (char *bnum_exp
, int from_tty
)
4016 bnum
= parse_and_eval_long (bnum_exp
);
4018 breakpoint_1 (bnum
, 1);
4022 breakpoint_has_pc (struct breakpoint
*b
, CORE_ADDR pc
, asection
*section
)
4024 struct bp_location
*bl
= b
->loc
;
4025 for (; bl
; bl
= bl
->next
)
4027 if (bl
->address
== pc
4028 && (!overlay_debugging
|| bl
->section
== section
))
4034 /* Print a message describing any breakpoints set at PC. */
4037 describe_other_breakpoints (CORE_ADDR pc
, asection
*section
, int thread
)
4040 struct breakpoint
*b
;
4043 others
+= breakpoint_has_pc (b
, pc
, section
);
4047 printf_filtered (_("Note: breakpoint "));
4048 else /* if (others == ???) */
4049 printf_filtered (_("Note: breakpoints "));
4051 if (breakpoint_has_pc (b
, pc
, section
))
4054 printf_filtered ("%d", b
->number
);
4055 if (b
->thread
== -1 && thread
!= -1)
4056 printf_filtered (" (all threads)");
4057 else if (b
->thread
!= -1)
4058 printf_filtered (" (thread %d)", b
->thread
);
4059 printf_filtered ("%s%s ",
4060 ((b
->enable_state
== bp_disabled
||
4061 b
->enable_state
== bp_call_disabled
)
4063 : b
->enable_state
== bp_permanent
4067 : ((others
== 1) ? " and" : ""));
4069 printf_filtered (_("also set at pc "));
4070 fputs_filtered (paddress (pc
), gdb_stdout
);
4071 printf_filtered (".\n");
4075 /* Set the default place to put a breakpoint
4076 for the `break' command with no arguments. */
4079 set_default_breakpoint (int valid
, CORE_ADDR addr
, struct symtab
*symtab
,
4082 default_breakpoint_valid
= valid
;
4083 default_breakpoint_address
= addr
;
4084 default_breakpoint_symtab
= symtab
;
4085 default_breakpoint_line
= line
;
4088 /* Return true iff it is meaningful to use the address member of
4089 BPT. For some breakpoint types, the address member is irrelevant
4090 and it makes no sense to attempt to compare it to other addresses
4091 (or use it for any other purpose either).
4093 More specifically, each of the following breakpoint types will always
4094 have a zero valued address and we don't want check_duplicates() to mark
4095 breakpoints of any of these types to be a duplicate of an actual
4096 breakpoint at address zero:
4099 bp_hardware_watchpoint
4101 bp_access_watchpoint
4107 breakpoint_address_is_meaningful (struct breakpoint
*bpt
)
4109 enum bptype type
= bpt
->type
;
4111 return (type
!= bp_watchpoint
4112 && type
!= bp_hardware_watchpoint
4113 && type
!= bp_read_watchpoint
4114 && type
!= bp_access_watchpoint
4115 && type
!= bp_catch_exec
4116 && type
!= bp_catch_fork
4117 && type
!= bp_catch_vfork
);
4120 /* Rescan breakpoints at the same address and section as BPT,
4121 marking the first one as "first" and any others as "duplicates".
4122 This is so that the bpt instruction is only inserted once.
4123 If we have a permanent breakpoint at the same place as BPT, make
4124 that one the official one, and the rest as duplicates. */
4127 check_duplicates_for (CORE_ADDR address
, asection
*section
)
4129 struct bp_location
*b
;
4131 struct bp_location
*perm_bp
= 0;
4133 ALL_BP_LOCATIONS (b
)
4134 if (b
->owner
->enable_state
!= bp_disabled
4135 && b
->owner
->enable_state
!= bp_call_disabled
4137 && !b
->shlib_disabled
4138 && b
->address
== address
/* address / overlay match */
4139 && (!overlay_debugging
|| b
->section
== section
)
4140 && breakpoint_address_is_meaningful (b
->owner
))
4142 /* Have we found a permanent breakpoint? */
4143 if (b
->owner
->enable_state
== bp_permanent
)
4150 b
->duplicate
= count
> 1;
4153 /* If we found a permanent breakpoint at this address, go over the
4154 list again and declare all the other breakpoints there to be the
4158 perm_bp
->duplicate
= 0;
4160 /* Permanent breakpoint should always be inserted. */
4161 if (! perm_bp
->inserted
)
4162 internal_error (__FILE__
, __LINE__
,
4163 _("allegedly permanent breakpoint is not "
4164 "actually inserted"));
4166 ALL_BP_LOCATIONS (b
)
4169 if (b
->owner
->enable_state
!= bp_disabled
4170 && b
->owner
->enable_state
!= bp_call_disabled
4171 && b
->enabled
&& !b
->shlib_disabled
4172 && b
->address
== address
/* address / overlay match */
4173 && (!overlay_debugging
|| b
->section
== section
)
4174 && breakpoint_address_is_meaningful (b
->owner
))
4177 internal_error (__FILE__
, __LINE__
,
4178 _("another breakpoint was inserted on top of "
4179 "a permanent breakpoint"));
4188 check_duplicates (struct breakpoint
*bpt
)
4190 struct bp_location
*bl
= bpt
->loc
;
4192 if (! breakpoint_address_is_meaningful (bpt
))
4195 for (; bl
; bl
= bl
->next
)
4196 check_duplicates_for (bl
->address
, bl
->section
);
4200 breakpoint_adjustment_warning (CORE_ADDR from_addr
, CORE_ADDR to_addr
,
4201 int bnum
, int have_bnum
)
4206 strcpy (astr1
, hex_string_custom ((unsigned long) from_addr
, 8));
4207 strcpy (astr2
, hex_string_custom ((unsigned long) to_addr
, 8));
4209 warning (_("Breakpoint %d address previously adjusted from %s to %s."),
4210 bnum
, astr1
, astr2
);
4212 warning (_("Breakpoint address adjusted from %s to %s."), astr1
, astr2
);
4215 /* Adjust a breakpoint's address to account for architectural constraints
4216 on breakpoint placement. Return the adjusted address. Note: Very
4217 few targets require this kind of adjustment. For most targets,
4218 this function is simply the identity function. */
4221 adjust_breakpoint_address (CORE_ADDR bpaddr
, enum bptype bptype
)
4223 if (!gdbarch_adjust_breakpoint_address_p (current_gdbarch
))
4225 /* Very few targets need any kind of breakpoint adjustment. */
4228 else if (bptype
== bp_watchpoint
4229 || bptype
== bp_hardware_watchpoint
4230 || bptype
== bp_read_watchpoint
4231 || bptype
== bp_access_watchpoint
4232 || bptype
== bp_catch_fork
4233 || bptype
== bp_catch_vfork
4234 || bptype
== bp_catch_exec
)
4236 /* Watchpoints and the various bp_catch_* eventpoints should not
4237 have their addresses modified. */
4242 CORE_ADDR adjusted_bpaddr
;
4244 /* Some targets have architectural constraints on the placement
4245 of breakpoint instructions. Obtain the adjusted address. */
4246 adjusted_bpaddr
= gdbarch_adjust_breakpoint_address (current_gdbarch
,
4249 /* An adjusted breakpoint address can significantly alter
4250 a user's expectations. Print a warning if an adjustment
4252 if (adjusted_bpaddr
!= bpaddr
)
4253 breakpoint_adjustment_warning (bpaddr
, adjusted_bpaddr
, 0, 0);
4255 return adjusted_bpaddr
;
4259 /* Allocate a struct bp_location. */
4261 static struct bp_location
*
4262 allocate_bp_location (struct breakpoint
*bpt
, enum bptype bp_type
)
4264 struct bp_location
*loc
, *loc_p
;
4266 loc
= xmalloc (sizeof (struct bp_location
));
4267 memset (loc
, 0, sizeof (*loc
));
4271 loc
->shlib_disabled
= 0;
4280 case bp_longjmp_resume
:
4281 case bp_step_resume
:
4282 case bp_watchpoint_scope
:
4284 case bp_shlib_event
:
4285 case bp_thread_event
:
4286 case bp_overlay_event
:
4288 case bp_catch_unload
:
4289 loc
->loc_type
= bp_loc_software_breakpoint
;
4291 case bp_hardware_breakpoint
:
4292 loc
->loc_type
= bp_loc_hardware_breakpoint
;
4294 case bp_hardware_watchpoint
:
4295 case bp_read_watchpoint
:
4296 case bp_access_watchpoint
:
4297 loc
->loc_type
= bp_loc_hardware_watchpoint
;
4301 case bp_catch_vfork
:
4303 loc
->loc_type
= bp_loc_other
;
4306 internal_error (__FILE__
, __LINE__
, _("unknown breakpoint type"));
4312 static void free_bp_location (struct bp_location
*loc
)
4317 if (loc
->function_name
)
4318 xfree (loc
->function_name
);
4323 /* Helper to set_raw_breakpoint below. Creates a breakpoint
4324 that has type BPTYPE and has no locations as yet. */
4326 static struct breakpoint
*
4327 set_raw_breakpoint_without_location (enum bptype bptype
)
4329 struct breakpoint
*b
, *b1
;
4331 b
= (struct breakpoint
*) xmalloc (sizeof (struct breakpoint
));
4332 memset (b
, 0, sizeof (*b
));
4335 b
->language
= current_language
->la_language
;
4336 b
->input_radix
= input_radix
;
4338 b
->enable_state
= bp_enabled
;
4341 b
->ignore_count
= 0;
4343 b
->frame_id
= null_frame_id
;
4344 b
->dll_pathname
= NULL
;
4345 b
->triggered_dll_pathname
= NULL
;
4346 b
->forked_inferior_pid
= null_ptid
;
4347 b
->exec_pathname
= NULL
;
4349 b
->condition_not_parsed
= 0;
4351 /* Add this breakpoint to the end of the chain
4352 so that a list of breakpoints will come out in order
4353 of increasing numbers. */
4355 b1
= breakpoint_chain
;
4357 breakpoint_chain
= b
;
4367 /* Initialize loc->function_name. */
4369 set_breakpoint_location_function (struct bp_location
*loc
)
4371 if (loc
->owner
->type
== bp_breakpoint
4372 || loc
->owner
->type
== bp_hardware_breakpoint
)
4374 find_pc_partial_function (loc
->address
, &(loc
->function_name
),
4376 if (loc
->function_name
)
4377 loc
->function_name
= xstrdup (loc
->function_name
);
4381 /* set_raw_breakpoint is a low level routine for allocating and
4382 partially initializing a breakpoint of type BPTYPE. The newly
4383 created breakpoint's address, section, source file name, and line
4384 number are provided by SAL. The newly created and partially
4385 initialized breakpoint is added to the breakpoint chain and
4386 is also returned as the value of this function.
4388 It is expected that the caller will complete the initialization of
4389 the newly created breakpoint struct as well as output any status
4390 information regarding the creation of a new breakpoint. In
4391 particular, set_raw_breakpoint does NOT set the breakpoint
4392 number! Care should be taken to not allow an error to occur
4393 prior to completing the initialization of the breakpoint. If this
4394 should happen, a bogus breakpoint will be left on the chain. */
4397 set_raw_breakpoint (struct symtab_and_line sal
, enum bptype bptype
)
4399 struct breakpoint
*b
= set_raw_breakpoint_without_location (bptype
);
4400 CORE_ADDR adjusted_address
;
4402 /* Adjust the breakpoint's address prior to allocating a location.
4403 Once we call allocate_bp_location(), that mostly uninitialized
4404 location will be placed on the location chain. Adjustment of the
4405 breakpoint may cause target_read_memory() to be called and we do
4406 not want its scan of the location chain to find a breakpoint and
4407 location that's only been partially initialized. */
4408 adjusted_address
= adjust_breakpoint_address (sal
.pc
, bptype
);
4410 b
->loc
= allocate_bp_location (b
, bptype
);
4411 b
->loc
->requested_address
= sal
.pc
;
4412 b
->loc
->address
= adjusted_address
;
4414 if (sal
.symtab
== NULL
)
4415 b
->source_file
= NULL
;
4417 b
->source_file
= savestring (sal
.symtab
->filename
,
4418 strlen (sal
.symtab
->filename
));
4419 b
->loc
->section
= sal
.section
;
4420 b
->line_number
= sal
.line
;
4422 set_breakpoint_location_function (b
->loc
);
4424 breakpoints_changed ();
4430 /* Note that the breakpoint object B describes a permanent breakpoint
4431 instruction, hard-wired into the inferior's code. */
4433 make_breakpoint_permanent (struct breakpoint
*b
)
4435 struct bp_location
*bl
;
4436 b
->enable_state
= bp_permanent
;
4438 /* By definition, permanent breakpoints are already present in the code.
4439 Mark all locations as inserted. For now, make_breakpoint_permanent
4440 is called in just one place, so it's hard to say if it's reasonable
4441 to have permanent breakpoint with multiple locations or not,
4442 but it's easy to implmement. */
4443 for (bl
= b
->loc
; bl
; bl
= bl
->next
)
4447 static struct breakpoint
*
4448 create_internal_breakpoint (CORE_ADDR address
, enum bptype type
)
4450 static int internal_breakpoint_number
= -1;
4451 struct symtab_and_line sal
;
4452 struct breakpoint
*b
;
4454 init_sal (&sal
); /* initialize to zeroes */
4457 sal
.section
= find_pc_overlay (sal
.pc
);
4459 b
= set_raw_breakpoint (sal
, type
);
4460 b
->number
= internal_breakpoint_number
--;
4461 b
->disposition
= disp_donttouch
;
4468 create_longjmp_breakpoint (char *func_name
)
4470 struct breakpoint
*b
;
4471 struct minimal_symbol
*m
;
4473 if ((m
= lookup_minimal_symbol_text (func_name
, NULL
)) == NULL
)
4475 set_momentary_breakpoint_at_pc (SYMBOL_VALUE_ADDRESS (m
), bp_longjmp
);
4476 update_global_location_list (1);
4479 /* Call this routine when stepping and nexting to enable a breakpoint
4480 if we do a longjmp(). When we hit that breakpoint, call
4481 set_longjmp_resume_breakpoint() to figure out where we are going. */
4484 set_longjmp_breakpoint (void)
4486 struct breakpoint
*b
;
4488 if (gdbarch_get_longjmp_target_p (current_gdbarch
))
4490 create_longjmp_breakpoint ("longjmp");
4491 create_longjmp_breakpoint ("_longjmp");
4492 create_longjmp_breakpoint ("siglongjmp");
4493 create_longjmp_breakpoint ("_siglongjmp");
4497 /* Delete all longjmp breakpoints from THREAD. */
4499 delete_longjmp_breakpoint (int thread
)
4501 struct breakpoint
*b
, *temp
;
4503 ALL_BREAKPOINTS_SAFE (b
, temp
)
4504 if (b
->type
== bp_longjmp
)
4506 if (b
->thread
== thread
)
4507 delete_breakpoint (b
);
4512 create_overlay_event_breakpoint (char *func_name
)
4514 struct breakpoint
*b
;
4515 struct minimal_symbol
*m
;
4517 if ((m
= lookup_minimal_symbol_text (func_name
, NULL
)) == NULL
)
4520 b
= create_internal_breakpoint (SYMBOL_VALUE_ADDRESS (m
),
4522 b
->addr_string
= xstrdup (func_name
);
4524 if (overlay_debugging
== ovly_auto
)
4526 b
->enable_state
= bp_enabled
;
4527 overlay_events_enabled
= 1;
4531 b
->enable_state
= bp_disabled
;
4532 overlay_events_enabled
= 0;
4534 update_global_location_list (1);
4538 enable_overlay_breakpoints (void)
4540 struct breakpoint
*b
;
4543 if (b
->type
== bp_overlay_event
)
4545 b
->enable_state
= bp_enabled
;
4546 update_global_location_list (1);
4547 overlay_events_enabled
= 1;
4552 disable_overlay_breakpoints (void)
4554 struct breakpoint
*b
;
4557 if (b
->type
== bp_overlay_event
)
4559 b
->enable_state
= bp_disabled
;
4560 update_global_location_list (0);
4561 overlay_events_enabled
= 0;
4566 create_thread_event_breakpoint (CORE_ADDR address
)
4568 struct breakpoint
*b
;
4570 b
= create_internal_breakpoint (address
, bp_thread_event
);
4572 b
->enable_state
= bp_enabled
;
4573 /* addr_string has to be used or breakpoint_re_set will delete me. */
4574 b
->addr_string
= xstrprintf ("*0x%s", paddr (b
->loc
->address
));
4576 update_global_location_list_nothrow (1);
4582 remove_thread_event_breakpoints (void)
4584 struct breakpoint
*b
, *temp
;
4586 ALL_BREAKPOINTS_SAFE (b
, temp
)
4587 if (b
->type
== bp_thread_event
)
4588 delete_breakpoint (b
);
4591 struct captured_parse_breakpoint_args
4594 struct symtabs_and_lines
*sals_p
;
4595 char ***addr_string_p
;
4599 struct lang_and_radix
4607 remove_solib_event_breakpoints (void)
4609 struct breakpoint
*b
, *temp
;
4611 ALL_BREAKPOINTS_SAFE (b
, temp
)
4612 if (b
->type
== bp_shlib_event
)
4613 delete_breakpoint (b
);
4617 create_solib_event_breakpoint (CORE_ADDR address
)
4619 struct breakpoint
*b
;
4621 b
= create_internal_breakpoint (address
, bp_shlib_event
);
4622 update_global_location_list_nothrow (1);
4626 /* Disable any breakpoints that are on code in shared libraries. Only
4627 apply to enabled breakpoints, disabled ones can just stay disabled. */
4630 disable_breakpoints_in_shlibs (void)
4632 struct bp_location
*loc
;
4633 int disabled_shlib_breaks
= 0;
4635 ALL_BP_LOCATIONS (loc
)
4637 struct breakpoint
*b
= loc
->owner
;
4638 /* We apply the check to all breakpoints, including disabled
4639 for those with loc->duplicate set. This is so that when breakpoint
4640 becomes enabled, or the duplicate is removed, gdb will try to insert
4641 all breakpoints. If we don't set shlib_disabled here, we'll try
4642 to insert those breakpoints and fail. */
4643 if (((b
->type
== bp_breakpoint
) || (b
->type
== bp_hardware_breakpoint
))
4644 && !loc
->shlib_disabled
4646 && PC_SOLIB (loc
->address
)
4648 && solib_address (loc
->address
)
4652 loc
->shlib_disabled
= 1;
4657 /* Disable any breakpoints that are in in an unloaded shared library. Only
4658 apply to enabled breakpoints, disabled ones can just stay disabled. */
4661 disable_breakpoints_in_unloaded_shlib (struct so_list
*solib
)
4663 struct bp_location
*loc
;
4664 int disabled_shlib_breaks
= 0;
4666 ALL_BP_LOCATIONS (loc
)
4668 struct breakpoint
*b
= loc
->owner
;
4669 if ((loc
->loc_type
== bp_loc_hardware_breakpoint
4670 || loc
->loc_type
== bp_loc_software_breakpoint
)
4671 && !loc
->shlib_disabled
)
4674 char *so_name
= PC_SOLIB (loc
->address
);
4676 char *so_name
= solib_address (loc
->address
);
4678 if (so_name
&& !strcmp (so_name
, solib
->so_name
))
4680 loc
->shlib_disabled
= 1;
4681 /* At this point, we cannot rely on remove_breakpoint
4682 succeeding so we must mark the breakpoint as not inserted
4683 to prevent future errors occurring in remove_breakpoints. */
4685 if (!disabled_shlib_breaks
)
4687 target_terminal_ours_for_output ();
4688 warning (_("Temporarily disabling breakpoints for unloaded shared library \"%s\""),
4691 disabled_shlib_breaks
= 1;
4698 create_fork_vfork_event_catchpoint (int tempflag
, char *cond_string
,
4699 enum bptype bp_kind
)
4701 struct symtab_and_line sal
;
4702 struct breakpoint
*b
;
4703 int thread
= -1; /* All threads. */
4710 b
= set_raw_breakpoint (sal
, bp_kind
);
4711 set_breakpoint_count (breakpoint_count
+ 1);
4712 b
->number
= breakpoint_count
;
4713 b
->cond_string
= (cond_string
== NULL
) ?
4714 NULL
: savestring (cond_string
, strlen (cond_string
));
4716 b
->addr_string
= NULL
;
4717 b
->enable_state
= bp_enabled
;
4718 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
4719 b
->forked_inferior_pid
= null_ptid
;
4720 update_global_location_list (1);
4727 create_fork_event_catchpoint (int tempflag
, char *cond_string
)
4729 create_fork_vfork_event_catchpoint (tempflag
, cond_string
, bp_catch_fork
);
4733 create_vfork_event_catchpoint (int tempflag
, char *cond_string
)
4735 create_fork_vfork_event_catchpoint (tempflag
, cond_string
, bp_catch_vfork
);
4739 create_exec_event_catchpoint (int tempflag
, char *cond_string
)
4741 struct symtab_and_line sal
;
4742 struct breakpoint
*b
;
4743 int thread
= -1; /* All threads. */
4750 b
= set_raw_breakpoint (sal
, bp_catch_exec
);
4751 set_breakpoint_count (breakpoint_count
+ 1);
4752 b
->number
= breakpoint_count
;
4753 b
->cond_string
= (cond_string
== NULL
) ?
4754 NULL
: savestring (cond_string
, strlen (cond_string
));
4756 b
->addr_string
= NULL
;
4757 b
->enable_state
= bp_enabled
;
4758 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
4759 update_global_location_list (1);
4765 hw_breakpoint_used_count (void)
4767 struct breakpoint
*b
;
4772 if (b
->type
== bp_hardware_breakpoint
&& b
->enable_state
== bp_enabled
)
4780 hw_watchpoint_used_count (enum bptype type
, int *other_type_used
)
4782 struct breakpoint
*b
;
4785 *other_type_used
= 0;
4788 if (breakpoint_enabled (b
))
4790 if (b
->type
== type
)
4792 else if ((b
->type
== bp_hardware_watchpoint
||
4793 b
->type
== bp_read_watchpoint
||
4794 b
->type
== bp_access_watchpoint
))
4795 *other_type_used
= 1;
4802 disable_watchpoints_before_interactive_call_start (void)
4804 struct breakpoint
*b
;
4808 if (((b
->type
== bp_watchpoint
)
4809 || (b
->type
== bp_hardware_watchpoint
)
4810 || (b
->type
== bp_read_watchpoint
)
4811 || (b
->type
== bp_access_watchpoint
))
4812 && breakpoint_enabled (b
))
4814 b
->enable_state
= bp_call_disabled
;
4815 update_global_location_list (0);
4821 enable_watchpoints_after_interactive_call_stop (void)
4823 struct breakpoint
*b
;
4827 if (((b
->type
== bp_watchpoint
)
4828 || (b
->type
== bp_hardware_watchpoint
)
4829 || (b
->type
== bp_read_watchpoint
)
4830 || (b
->type
== bp_access_watchpoint
))
4831 && (b
->enable_state
== bp_call_disabled
))
4833 b
->enable_state
= bp_enabled
;
4834 update_global_location_list (1);
4840 /* Set a breakpoint that will evaporate an end of command
4841 at address specified by SAL.
4842 Restrict it to frame FRAME if FRAME is nonzero. */
4845 set_momentary_breakpoint (struct symtab_and_line sal
, struct frame_id frame_id
,
4848 struct breakpoint
*b
;
4849 b
= set_raw_breakpoint (sal
, type
);
4850 b
->enable_state
= bp_enabled
;
4851 b
->disposition
= disp_donttouch
;
4852 b
->frame_id
= frame_id
;
4854 /* If we're debugging a multi-threaded program, then we
4855 want momentary breakpoints to be active in only a
4856 single thread of control. */
4857 if (in_thread_list (inferior_ptid
))
4858 b
->thread
= pid_to_thread_id (inferior_ptid
);
4860 update_global_location_list_nothrow (1);
4866 set_momentary_breakpoint_at_pc (CORE_ADDR pc
, enum bptype type
)
4868 struct symtab_and_line sal
;
4870 sal
= find_pc_line (pc
, 0);
4872 sal
.section
= find_pc_overlay (pc
);
4873 sal
.explicit_pc
= 1;
4875 return set_momentary_breakpoint (sal
, null_frame_id
, type
);
4879 /* Tell the user we have just set a breakpoint B. */
4882 mention (struct breakpoint
*b
)
4885 struct cleanup
*old_chain
, *ui_out_chain
;
4886 struct ui_stream
*stb
;
4888 stb
= ui_out_stream_new (uiout
);
4889 old_chain
= make_cleanup_ui_out_stream_delete (stb
);
4891 /* FIXME: This is misplaced; mention() is called by things (like
4892 hitting a watchpoint) other than breakpoint creation. It should
4893 be possible to clean this up and at the same time replace the
4894 random calls to breakpoint_changed with this hook, as has already
4895 been done for deprecated_delete_breakpoint_hook and so on. */
4896 if (deprecated_create_breakpoint_hook
)
4897 deprecated_create_breakpoint_hook (b
);
4898 breakpoint_create_event (b
->number
);
4900 if (b
->ops
!= NULL
&& b
->ops
->print_mention
!= NULL
)
4901 b
->ops
->print_mention (b
);
4906 printf_filtered (_("(apparently deleted?) Eventpoint %d: "), b
->number
);
4909 ui_out_text (uiout
, "Watchpoint ");
4910 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "wpt");
4911 ui_out_field_int (uiout
, "number", b
->number
);
4912 ui_out_text (uiout
, ": ");
4913 print_expression (b
->exp
, stb
->stream
);
4914 ui_out_field_stream (uiout
, "exp", stb
);
4915 do_cleanups (ui_out_chain
);
4917 case bp_hardware_watchpoint
:
4918 ui_out_text (uiout
, "Hardware watchpoint ");
4919 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "wpt");
4920 ui_out_field_int (uiout
, "number", b
->number
);
4921 ui_out_text (uiout
, ": ");
4922 print_expression (b
->exp
, stb
->stream
);
4923 ui_out_field_stream (uiout
, "exp", stb
);
4924 do_cleanups (ui_out_chain
);
4926 case bp_read_watchpoint
:
4927 ui_out_text (uiout
, "Hardware read watchpoint ");
4928 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "hw-rwpt");
4929 ui_out_field_int (uiout
, "number", b
->number
);
4930 ui_out_text (uiout
, ": ");
4931 print_expression (b
->exp
, stb
->stream
);
4932 ui_out_field_stream (uiout
, "exp", stb
);
4933 do_cleanups (ui_out_chain
);
4935 case bp_access_watchpoint
:
4936 ui_out_text (uiout
, "Hardware access (read/write) watchpoint ");
4937 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "hw-awpt");
4938 ui_out_field_int (uiout
, "number", b
->number
);
4939 ui_out_text (uiout
, ": ");
4940 print_expression (b
->exp
, stb
->stream
);
4941 ui_out_field_stream (uiout
, "exp", stb
);
4942 do_cleanups (ui_out_chain
);
4945 if (ui_out_is_mi_like_p (uiout
))
4950 if (b
->disposition
== disp_del
)
4951 printf_filtered (_("Temporary breakpoint"));
4953 printf_filtered (_("Breakpoint"));
4954 printf_filtered (_(" %d"), b
->number
);
4957 case bp_hardware_breakpoint
:
4958 if (ui_out_is_mi_like_p (uiout
))
4963 printf_filtered (_("Hardware assisted breakpoint %d"), b
->number
);
4967 case bp_catch_unload
:
4968 printf_filtered (_("Catchpoint %d (%s %s)"),
4970 (b
->type
== bp_catch_load
) ? "load" : "unload",
4971 (b
->dll_pathname
!= NULL
) ?
4972 b
->dll_pathname
: "<any library>");
4975 case bp_catch_vfork
:
4976 printf_filtered (_("Catchpoint %d (%s)"),
4978 (b
->type
== bp_catch_fork
) ? "fork" : "vfork");
4981 printf_filtered (_("Catchpoint %d (exec)"),
4988 case bp_longjmp_resume
:
4989 case bp_step_resume
:
4991 case bp_watchpoint_scope
:
4992 case bp_shlib_event
:
4993 case bp_thread_event
:
4994 case bp_overlay_event
:
5000 /* i18n: cagney/2005-02-11: Below needs to be merged into a
5004 printf_filtered (_(" (%s) pending."), b
->addr_string
);
5008 if (addressprint
|| b
->source_file
== NULL
)
5010 printf_filtered (" at ");
5011 fputs_filtered (paddress (b
->loc
->address
), gdb_stdout
);
5014 printf_filtered (": file %s, line %d.",
5015 b
->source_file
, b
->line_number
);
5019 struct bp_location
*loc
= b
->loc
;
5021 for (; loc
; loc
= loc
->next
)
5023 printf_filtered (" (%d locations)", n
);
5028 do_cleanups (old_chain
);
5029 if (ui_out_is_mi_like_p (uiout
))
5031 printf_filtered ("\n");
5035 static struct bp_location
*
5036 add_location_to_breakpoint (struct breakpoint
*b
, enum bptype bptype
,
5037 const struct symtab_and_line
*sal
)
5039 struct bp_location
*loc
, **tmp
;
5041 loc
= allocate_bp_location (b
, bptype
);
5042 for (tmp
= &(b
->loc
); *tmp
!= NULL
; tmp
= &((*tmp
)->next
))
5045 loc
->requested_address
= sal
->pc
;
5046 loc
->address
= adjust_breakpoint_address (loc
->requested_address
,
5048 loc
->section
= sal
->section
;
5050 set_breakpoint_location_function (loc
);
5054 /* Create a breakpoint with SAL as location. Use ADDR_STRING
5055 as textual description of the location, and COND_STRING
5056 as condition expression. */
5059 create_breakpoint (struct symtabs_and_lines sals
, char *addr_string
,
5061 enum bptype type
, enum bpdisp disposition
,
5062 int thread
, int ignore_count
,
5063 struct breakpoint_ops
*ops
, int from_tty
)
5065 struct breakpoint
*b
= NULL
;
5068 if (type
== bp_hardware_breakpoint
)
5070 int i
= hw_breakpoint_used_count ();
5071 int target_resources_ok
=
5072 TARGET_CAN_USE_HARDWARE_WATCHPOINT (bp_hardware_breakpoint
,
5074 if (target_resources_ok
== 0)
5075 error (_("No hardware breakpoint support in the target."));
5076 else if (target_resources_ok
< 0)
5077 error (_("Hardware breakpoints used exceeds limit."));
5080 for (i
= 0; i
< sals
.nelts
; ++i
)
5082 struct symtab_and_line sal
= sals
.sals
[i
];
5083 struct bp_location
*loc
;
5086 describe_other_breakpoints (sal
.pc
, sal
.section
, thread
);
5090 b
= set_raw_breakpoint (sal
, type
);
5091 set_breakpoint_count (breakpoint_count
+ 1);
5092 b
->number
= breakpoint_count
;
5095 b
->cond_string
= cond_string
;
5096 b
->ignore_count
= ignore_count
;
5097 b
->enable_state
= bp_enabled
;
5098 b
->disposition
= disposition
;
5104 loc
= add_location_to_breakpoint (b
, type
, &sal
);
5109 char *arg
= b
->cond_string
;
5110 loc
->cond
= parse_exp_1 (&arg
, block_for_pc (loc
->address
), 0);
5112 error (_("Garbage %s follows condition"), arg
);
5117 b
->addr_string
= addr_string
;
5119 /* addr_string has to be used or breakpoint_re_set will delete
5121 b
->addr_string
= xstrprintf ("*0x%s", paddr (b
->loc
->address
));
5127 /* Remove element at INDEX_TO_REMOVE from SAL, shifting other
5128 elements to fill the void space. */
5129 static void remove_sal (struct symtabs_and_lines
*sal
, int index_to_remove
)
5131 int i
= index_to_remove
+1;
5132 int last_index
= sal
->nelts
-1;
5134 for (;i
<= last_index
; ++i
)
5135 sal
->sals
[i
-1] = sal
->sals
[i
];
5140 /* If appropriate, obtains all sals that correspond
5141 to the same file and line as SAL. This is done
5142 only if SAL does not have explicit PC and has
5143 line and file information. If we got just a single
5144 expanded sal, return the original.
5146 Otherwise, if SAL.explicit_line is not set, filter out
5147 all sals for which the name of enclosing function
5148 is different from SAL. This makes sure that if we have
5149 breakpoint originally set in template instantiation, say
5150 foo<int>(), we won't expand SAL to locations at the same
5151 line in all existing instantiations of 'foo'.
5154 struct symtabs_and_lines
5155 expand_line_sal_maybe (struct symtab_and_line sal
)
5157 struct symtabs_and_lines expanded
;
5158 CORE_ADDR original_pc
= sal
.pc
;
5159 char *original_function
= NULL
;
5163 /* If we have explicit pc, don't expand.
5164 If we have no line number, we can't expand. */
5165 if (sal
.explicit_pc
|| sal
.line
== 0 || sal
.symtab
== NULL
)
5168 expanded
.sals
= xmalloc (sizeof (struct symtab_and_line
));
5169 expanded
.sals
[0] = sal
;
5174 find_pc_partial_function (original_pc
, &original_function
, NULL
, NULL
);
5176 expanded
= expand_line_sal (sal
);
5177 if (expanded
.nelts
== 1)
5179 /* We had one sal, we got one sal. Without futher
5180 processing, just return the original sal. */
5181 xfree (expanded
.sals
);
5183 expanded
.sals
= xmalloc (sizeof (struct symtab_and_line
));
5184 sal
.pc
= original_pc
;
5185 expanded
.sals
[0] = sal
;
5189 if (!sal
.explicit_line
)
5191 CORE_ADDR func_addr
, func_end
;
5192 for (i
= 0; i
< expanded
.nelts
; ++i
)
5194 CORE_ADDR pc
= expanded
.sals
[i
].pc
;
5195 char *this_function
;
5196 if (find_pc_partial_function (pc
, &this_function
,
5197 &func_addr
, &func_end
))
5199 if (this_function
&&
5200 strcmp (this_function
, original_function
) != 0)
5202 remove_sal (&expanded
, i
);
5205 else if (func_addr
== pc
)
5207 /* We're at beginning of a function, and should
5209 struct symbol
*sym
= find_pc_function (pc
);
5211 expanded
.sals
[i
] = find_function_start_sal (sym
, 1);
5214 = gdbarch_skip_prologue (current_gdbarch
, pc
);
5221 if (expanded
.nelts
<= 1)
5223 /* This is un ugly workaround. If we get zero
5224 expanded sals then something is really wrong.
5225 Fix that by returnign the original sal. */
5226 xfree (expanded
.sals
);
5228 expanded
.sals
= xmalloc (sizeof (struct symtab_and_line
));
5229 sal
.pc
= original_pc
;
5230 expanded
.sals
[0] = sal
;
5237 for (i
= 0; i
< expanded
.nelts
; ++i
)
5238 if (expanded
.sals
[i
].pc
== original_pc
)
5249 /* Add SALS.nelts breakpoints to the breakpoint table. For each
5250 SALS.sal[i] breakpoint, include the corresponding ADDR_STRING[i]
5251 value. COND_STRING, if not NULL, specified the condition to be
5252 used for all breakpoints. Essentially the only case where
5253 SALS.nelts is not 1 is when we set a breakpoint on an overloaded
5254 function. In that case, it's still not possible to specify
5255 separate conditions for different overloaded functions, so
5256 we take just a single condition string.
5258 NOTE: If the function succeeds, the caller is expected to cleanup
5259 the arrays ADDR_STRING, COND_STRING, and SALS (but not the
5260 array contents). If the function fails (error() is called), the
5261 caller is expected to cleanups both the ADDR_STRING, COND_STRING,
5262 COND and SALS arrays and each of those arrays contents. */
5265 create_breakpoints (struct symtabs_and_lines sals
, char **addr_string
,
5267 enum bptype type
, enum bpdisp disposition
,
5268 int thread
, int ignore_count
,
5269 struct breakpoint_ops
*ops
, int from_tty
)
5272 for (i
= 0; i
< sals
.nelts
; ++i
)
5274 struct symtabs_and_lines expanded
=
5275 expand_line_sal_maybe (sals
.sals
[i
]);
5277 create_breakpoint (expanded
, addr_string
[i
],
5278 cond_string
, type
, disposition
,
5279 thread
, ignore_count
, ops
, from_tty
);
5282 update_global_location_list (1);
5285 /* Parse ARG which is assumed to be a SAL specification possibly
5286 followed by conditionals. On return, SALS contains an array of SAL
5287 addresses found. ADDR_STRING contains a vector of (canonical)
5288 address strings. ARG points to the end of the SAL. */
5291 parse_breakpoint_sals (char **address
,
5292 struct symtabs_and_lines
*sals
,
5293 char ***addr_string
,
5296 char *addr_start
= *address
;
5297 *addr_string
= NULL
;
5298 /* If no arg given, or if first arg is 'if ', use the default
5300 if ((*address
) == NULL
5301 || (strncmp ((*address
), "if", 2) == 0 && isspace ((*address
)[2])))
5303 if (default_breakpoint_valid
)
5305 struct symtab_and_line sal
;
5306 init_sal (&sal
); /* initialize to zeroes */
5307 sals
->sals
= (struct symtab_and_line
*)
5308 xmalloc (sizeof (struct symtab_and_line
));
5309 sal
.pc
= default_breakpoint_address
;
5310 sal
.line
= default_breakpoint_line
;
5311 sal
.symtab
= default_breakpoint_symtab
;
5312 sal
.section
= find_pc_overlay (sal
.pc
);
5313 sals
->sals
[0] = sal
;
5317 error (_("No default breakpoint address now."));
5321 /* Force almost all breakpoints to be in terms of the
5322 current_source_symtab (which is decode_line_1's default). This
5323 should produce the results we want almost all of the time while
5324 leaving default_breakpoint_* alone.
5325 ObjC: However, don't match an Objective-C method name which
5326 may have a '+' or '-' succeeded by a '[' */
5328 struct symtab_and_line cursal
= get_current_source_symtab_and_line ();
5330 if (default_breakpoint_valid
5332 || ((strchr ("+-", (*address
)[0]) != NULL
)
5333 && ((*address
)[1] != '['))))
5334 *sals
= decode_line_1 (address
, 1, default_breakpoint_symtab
,
5335 default_breakpoint_line
, addr_string
,
5338 *sals
= decode_line_1 (address
, 1, (struct symtab
*) NULL
, 0,
5339 addr_string
, not_found_ptr
);
5341 /* For any SAL that didn't have a canonical string, fill one in. */
5342 if (sals
->nelts
> 0 && *addr_string
== NULL
)
5343 *addr_string
= xcalloc (sals
->nelts
, sizeof (char **));
5344 if (addr_start
!= (*address
))
5347 for (i
= 0; i
< sals
->nelts
; i
++)
5349 /* Add the string if not present. */
5350 if ((*addr_string
)[i
] == NULL
)
5351 (*addr_string
)[i
] = savestring (addr_start
, (*address
) - addr_start
);
5357 /* Convert each SAL into a real PC. Verify that the PC can be
5358 inserted as a breakpoint. If it can't throw an error. */
5361 breakpoint_sals_to_pc (struct symtabs_and_lines
*sals
,
5365 for (i
= 0; i
< sals
->nelts
; i
++)
5366 resolve_sal_pc (&sals
->sals
[i
]);
5370 do_captured_parse_breakpoint (struct ui_out
*ui
, void *data
)
5372 struct captured_parse_breakpoint_args
*args
= data
;
5374 parse_breakpoint_sals (args
->arg_p
, args
->sals_p
, args
->addr_string_p
,
5375 args
->not_found_ptr
);
5378 /* Given TOK, a string specification of condition and thread, as
5379 accepted by the 'break' command, extract the condition
5380 string and thread number and set *COND_STRING and *THREAD.
5381 PC identifies the context at which the condition should be parsed.
5382 If no condition is found, *COND_STRING is set to NULL.
5383 If no thread is found, *THREAD is set to -1. */
5385 find_condition_and_thread (char *tok
, CORE_ADDR pc
,
5386 char **cond_string
, int *thread
)
5388 *cond_string
= NULL
;
5394 char *cond_start
= NULL
;
5395 char *cond_end
= NULL
;
5396 while (*tok
== ' ' || *tok
== '\t')
5401 while (*end_tok
!= ' ' && *end_tok
!= '\t' && *end_tok
!= '\000')
5404 toklen
= end_tok
- tok
;
5406 if (toklen
>= 1 && strncmp (tok
, "if", toklen
) == 0)
5408 tok
= cond_start
= end_tok
+ 1;
5409 parse_exp_1 (&tok
, block_for_pc (pc
), 0);
5411 *cond_string
= savestring (cond_start
,
5412 cond_end
- cond_start
);
5414 else if (toklen
>= 1 && strncmp (tok
, "thread", toklen
) == 0)
5420 *thread
= strtol (tok
, &tok
, 0);
5422 error (_("Junk after thread keyword."));
5423 if (!valid_thread_id (*thread
))
5424 error (_("Unknown thread %d."), *thread
);
5427 error (_("Junk at end of arguments."));
5431 /* Set a breakpoint. This function is shared between
5432 CLI and MI functions for setting a breakpoint.
5433 This function has two major modes of operations,
5434 selected by the PARSE_CONDITION_AND_THREAD parameter.
5435 If non-zero, the function will parse arg, extracting
5436 breakpoint location, address and thread. Otherwise,
5437 ARG is just the location of breakpoint, with condition
5438 and thread specified by the COND_STRING and THREAD
5442 break_command_really (char *arg
, char *cond_string
, int thread
,
5443 int parse_condition_and_thread
,
5444 int tempflag
, int hardwareflag
,
5446 enum auto_boolean pending_break_support
,
5447 struct breakpoint_ops
*ops
,
5450 struct gdb_exception e
;
5451 struct symtabs_and_lines sals
;
5452 struct symtab_and_line pending_sal
;
5455 char *addr_start
= arg
;
5457 struct cleanup
*old_chain
;
5458 struct cleanup
*breakpoint_chain
= NULL
;
5459 struct captured_parse_breakpoint_args parse_args
;
5468 parse_args
.arg_p
= &arg
;
5469 parse_args
.sals_p
= &sals
;
5470 parse_args
.addr_string_p
= &addr_string
;
5471 parse_args
.not_found_ptr
= ¬_found
;
5473 e
= catch_exception (uiout
, do_captured_parse_breakpoint
,
5474 &parse_args
, RETURN_MASK_ALL
);
5476 /* If caller is interested in rc value from parse, set value. */
5480 throw_exception (e
);
5484 case NOT_FOUND_ERROR
:
5486 /* If pending breakpoint support is turned off, throw
5489 if (pending_break_support
== AUTO_BOOLEAN_FALSE
)
5490 throw_exception (e
);
5492 exception_print (gdb_stderr
, e
);
5494 /* If pending breakpoint support is auto query and the user
5495 selects no, then simply return the error code. */
5496 if (pending_break_support
== AUTO_BOOLEAN_AUTO
&&
5497 !nquery ("Make breakpoint pending on future shared library load? "))
5500 /* At this point, either the user was queried about setting
5501 a pending breakpoint and selected yes, or pending
5502 breakpoint behavior is on and thus a pending breakpoint
5503 is defaulted on behalf of the user. */
5504 copy_arg
= xstrdup (addr_start
);
5505 addr_string
= ©_arg
;
5507 sals
.sals
= &pending_sal
;
5512 throw_exception (e
);
5519 /* Create a chain of things that always need to be cleaned up. */
5520 old_chain
= make_cleanup (null_cleanup
, 0);
5524 /* Make sure that all storage allocated to SALS gets freed. */
5525 make_cleanup (xfree
, sals
.sals
);
5527 /* Cleanup the addr_string array but not its contents. */
5528 make_cleanup (xfree
, addr_string
);
5531 /* ----------------------------- SNIP -----------------------------
5532 Anything added to the cleanup chain beyond this point is assumed
5533 to be part of a breakpoint. If the breakpoint create succeeds
5534 then the memory is not reclaimed. */
5535 breakpoint_chain
= make_cleanup (null_cleanup
, 0);
5537 /* Mark the contents of the addr_string for cleanup. These go on
5538 the breakpoint_chain and only occure if the breakpoint create
5540 for (i
= 0; i
< sals
.nelts
; i
++)
5542 if (addr_string
[i
] != NULL
)
5543 make_cleanup (xfree
, addr_string
[i
]);
5546 /* Resolve all line numbers to PC's and verify that the addresses
5547 are ok for the target. */
5549 breakpoint_sals_to_pc (&sals
, addr_start
);
5551 /* Verify that condition can be parsed, before setting any
5552 breakpoints. Allocate a separate condition expression for each
5556 if (parse_condition_and_thread
)
5558 /* Here we only parse 'arg' to separate condition
5559 from thread number, so parsing in context of first
5560 sal is OK. When setting the breakpoint we'll
5561 re-parse it in context of each sal. */
5564 find_condition_and_thread (arg
, sals
.sals
[0].pc
, &cond_string
, &thread
);
5566 make_cleanup (xfree
, cond_string
);
5570 /* Create a private copy of condition string. */
5573 cond_string
= xstrdup (cond_string
);
5574 make_cleanup (xfree
, cond_string
);
5577 create_breakpoints (sals
, addr_string
, cond_string
,
5578 hardwareflag
? bp_hardware_breakpoint
5580 tempflag
? disp_del
: disp_donttouch
,
5581 thread
, ignore_count
, ops
, from_tty
);
5585 struct symtab_and_line sal
= {0};
5586 struct breakpoint
*b
;
5588 make_cleanup (xfree
, copy_arg
);
5590 b
= set_raw_breakpoint_without_location (hardwareflag
5591 ? bp_hardware_breakpoint
5593 set_breakpoint_count (breakpoint_count
+ 1);
5594 b
->number
= breakpoint_count
;
5596 b
->addr_string
= addr_string
[0];
5597 b
->cond_string
= NULL
;
5598 b
->ignore_count
= ignore_count
;
5599 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
5600 b
->condition_not_parsed
= 1;
5603 update_global_location_list (1);
5608 warning (_("Multiple breakpoints were set.\n"
5609 "Use the \"delete\" command to delete unwanted breakpoints."));
5610 /* That's it. Discard the cleanups for data inserted into the
5612 discard_cleanups (breakpoint_chain
);
5613 /* But cleanup everything else. */
5614 do_cleanups (old_chain
);
5617 /* Set a breakpoint.
5618 ARG is a string describing breakpoint address,
5619 condition, and thread.
5620 FLAG specifies if a breakpoint is hardware on,
5621 and if breakpoint is temporary, using BP_HARDWARE_FLAG
5625 break_command_1 (char *arg
, int flag
, int from_tty
)
5627 int hardwareflag
= flag
& BP_HARDWAREFLAG
;
5628 int tempflag
= flag
& BP_TEMPFLAG
;
5630 break_command_really (arg
,
5631 NULL
, 0, 1 /* parse arg */,
5632 tempflag
, hardwareflag
,
5633 0 /* Ignore count */,
5634 pending_break_support
,
5635 NULL
/* breakpoint_ops */,
5641 set_breakpoint (char *address
, char *condition
,
5642 int hardwareflag
, int tempflag
,
5643 int thread
, int ignore_count
,
5646 break_command_really (address
, condition
, thread
,
5647 0 /* condition and thread are valid. */,
5648 tempflag
, hardwareflag
,
5651 ? AUTO_BOOLEAN_TRUE
: AUTO_BOOLEAN_FALSE
,
5655 /* Adjust SAL to the first instruction past the function prologue.
5656 The end of the prologue is determined using the line table from
5657 the debugging information.
5659 If SAL is already past the prologue, then do nothing. */
5662 skip_prologue_sal (struct symtab_and_line
*sal
)
5664 struct symbol
*sym
= find_pc_function (sal
->pc
);
5665 struct symtab_and_line start_sal
;
5670 start_sal
= find_function_start_sal (sym
, 1);
5671 if (sal
->pc
< start_sal
.pc
)
5675 /* Helper function for break_command_1 and disassemble_command. */
5678 resolve_sal_pc (struct symtab_and_line
*sal
)
5682 if (sal
->pc
== 0 && sal
->symtab
!= NULL
)
5684 if (!find_line_pc (sal
->symtab
, sal
->line
, &pc
))
5685 error (_("No line %d in file \"%s\"."),
5686 sal
->line
, sal
->symtab
->filename
);
5689 /* If this SAL corresponds to a breakpoint inserted using
5690 a line number, then skip the function prologue if necessary. */
5691 if (sal
->explicit_line
)
5692 skip_prologue_sal (sal
);
5695 if (sal
->section
== 0 && sal
->symtab
!= NULL
)
5697 struct blockvector
*bv
;
5701 bv
= blockvector_for_pc_sect (sal
->pc
, 0, &b
, sal
->symtab
);
5704 sym
= block_linkage_function (b
);
5707 fixup_symbol_section (sym
, sal
->symtab
->objfile
);
5708 sal
->section
= SYMBOL_BFD_SECTION (sym
);
5712 /* It really is worthwhile to have the section, so we'll just
5713 have to look harder. This case can be executed if we have
5714 line numbers but no functions (as can happen in assembly
5717 struct minimal_symbol
*msym
;
5719 msym
= lookup_minimal_symbol_by_pc (sal
->pc
);
5721 sal
->section
= SYMBOL_BFD_SECTION (msym
);
5728 break_command (char *arg
, int from_tty
)
5730 break_command_1 (arg
, 0, from_tty
);
5734 tbreak_command (char *arg
, int from_tty
)
5736 break_command_1 (arg
, BP_TEMPFLAG
, from_tty
);
5740 hbreak_command (char *arg
, int from_tty
)
5742 break_command_1 (arg
, BP_HARDWAREFLAG
, from_tty
);
5746 thbreak_command (char *arg
, int from_tty
)
5748 break_command_1 (arg
, (BP_TEMPFLAG
| BP_HARDWAREFLAG
), from_tty
);
5752 stop_command (char *arg
, int from_tty
)
5754 printf_filtered (_("Specify the type of breakpoint to set.\n\
5755 Usage: stop in <function | address>\n\
5756 stop at <line>\n"));
5760 stopin_command (char *arg
, int from_tty
)
5764 if (arg
== (char *) NULL
)
5766 else if (*arg
!= '*')
5771 /* look for a ':'. If this is a line number specification, then
5772 say it is bad, otherwise, it should be an address or
5773 function/method name */
5774 while (*argptr
&& !hasColon
)
5776 hasColon
= (*argptr
== ':');
5781 badInput
= (*argptr
!= ':'); /* Not a class::method */
5783 badInput
= isdigit (*arg
); /* a simple line number */
5787 printf_filtered (_("Usage: stop in <function | address>\n"));
5789 break_command_1 (arg
, 0, from_tty
);
5793 stopat_command (char *arg
, int from_tty
)
5797 if (arg
== (char *) NULL
|| *arg
== '*') /* no line number */
5804 /* look for a ':'. If there is a '::' then get out, otherwise
5805 it is probably a line number. */
5806 while (*argptr
&& !hasColon
)
5808 hasColon
= (*argptr
== ':');
5813 badInput
= (*argptr
== ':'); /* we have class::method */
5815 badInput
= !isdigit (*arg
); /* not a line number */
5819 printf_filtered (_("Usage: stop at <line>\n"));
5821 break_command_1 (arg
, 0, from_tty
);
5824 /* accessflag: hw_write: watch write,
5825 hw_read: watch read,
5826 hw_access: watch access (read or write) */
5828 watch_command_1 (char *arg
, int accessflag
, int from_tty
)
5830 struct breakpoint
*b
, *scope_breakpoint
= NULL
;
5831 struct symtab_and_line sal
;
5832 struct expression
*exp
;
5833 struct block
*exp_valid_block
;
5834 struct value
*val
, *mark
;
5835 struct frame_info
*frame
;
5836 struct frame_info
*prev_frame
= NULL
;
5837 char *exp_start
= NULL
;
5838 char *exp_end
= NULL
;
5839 char *tok
, *id_tok_start
, *end_tok
;
5841 char *cond_start
= NULL
;
5842 char *cond_end
= NULL
;
5843 struct expression
*cond
= NULL
;
5844 int i
, other_type_used
, target_resources_ok
= 0;
5845 enum bptype bp_type
;
5849 init_sal (&sal
); /* initialize to zeroes */
5851 /* Make sure that we actually have parameters to parse. */
5852 if (arg
!= NULL
&& arg
[0] != '\0')
5854 toklen
= strlen (arg
); /* Size of argument list. */
5856 /* Points tok to the end of the argument list. */
5857 tok
= arg
+ toklen
- 1;
5859 /* Go backwards in the parameters list. Skip the last parameter.
5860 If we're expecting a 'thread <thread_num>' parameter, this should
5861 be the thread identifier. */
5862 while (tok
> arg
&& (*tok
== ' ' || *tok
== '\t'))
5864 while (tok
> arg
&& (*tok
!= ' ' && *tok
!= '\t'))
5867 /* Points end_tok to the beginning of the last token. */
5868 id_tok_start
= tok
+ 1;
5870 /* Go backwards in the parameters list. Skip one more parameter.
5871 If we're expecting a 'thread <thread_num>' parameter, we should
5872 reach a "thread" token. */
5873 while (tok
> arg
&& (*tok
== ' ' || *tok
== '\t'))
5878 while (tok
> arg
&& (*tok
!= ' ' && *tok
!= '\t'))
5881 /* Move the pointer forward to skip the whitespace and
5882 calculate the length of the token. */
5884 toklen
= end_tok
- tok
;
5886 if (toklen
>= 1 && strncmp (tok
, "thread", toklen
) == 0)
5888 /* At this point we've found a "thread" token, which means
5889 the user is trying to set a watchpoint that triggers
5890 only in a specific thread. */
5893 /* Extract the thread ID from the next token. */
5894 thread
= strtol (id_tok_start
, &endp
, 0);
5896 /* Check if the user provided a valid numeric value for the
5898 if (*endp
!= ' ' && *endp
!= '\t' && *endp
!= '\0')
5899 error (_("Invalid thread ID specification %s."), id_tok_start
);
5901 /* Check if the thread actually exists. */
5902 if (!valid_thread_id (thread
))
5903 error (_("Unknown thread %d."), thread
);
5905 /* Truncate the string and get rid of the thread <thread_num>
5906 parameter before the parameter list is parsed by the
5907 evaluate_expression() function. */
5912 /* Parse the rest of the arguments. */
5913 innermost_block
= NULL
;
5915 exp
= parse_exp_1 (&arg
, 0, 0);
5917 exp_valid_block
= innermost_block
;
5918 mark
= value_mark ();
5919 fetch_watchpoint_value (exp
, &val
, NULL
, NULL
);
5921 release_value (val
);
5924 while (*tok
== ' ' || *tok
== '\t')
5928 while (*end_tok
!= ' ' && *end_tok
!= '\t' && *end_tok
!= '\000')
5931 toklen
= end_tok
- tok
;
5932 if (toklen
>= 1 && strncmp (tok
, "if", toklen
) == 0)
5934 tok
= cond_start
= end_tok
+ 1;
5935 cond
= parse_exp_1 (&tok
, 0, 0);
5939 error (_("Junk at end of command."));
5941 if (accessflag
== hw_read
)
5942 bp_type
= bp_read_watchpoint
;
5943 else if (accessflag
== hw_access
)
5944 bp_type
= bp_access_watchpoint
;
5946 bp_type
= bp_hardware_watchpoint
;
5948 mem_cnt
= can_use_hardware_watchpoint (val
);
5949 if (mem_cnt
== 0 && bp_type
!= bp_hardware_watchpoint
)
5950 error (_("Expression cannot be implemented with read/access watchpoint."));
5953 i
= hw_watchpoint_used_count (bp_type
, &other_type_used
);
5954 target_resources_ok
=
5955 TARGET_CAN_USE_HARDWARE_WATCHPOINT (bp_type
, i
+ mem_cnt
,
5957 if (target_resources_ok
== 0 && bp_type
!= bp_hardware_watchpoint
)
5958 error (_("Target does not support this type of hardware watchpoint."));
5960 if (target_resources_ok
< 0 && bp_type
!= bp_hardware_watchpoint
)
5961 error (_("Target can only support one kind of HW watchpoint at a time."));
5964 /* Change the type of breakpoint to an ordinary watchpoint if a hardware
5965 watchpoint could not be set. */
5966 if (!mem_cnt
|| target_resources_ok
<= 0)
5967 bp_type
= bp_watchpoint
;
5969 frame
= block_innermost_frame (exp_valid_block
);
5971 prev_frame
= get_prev_frame (frame
);
5975 /* If the expression is "local", then set up a "watchpoint scope"
5976 breakpoint at the point where we've left the scope of the watchpoint
5977 expression. Create the scope breakpoint before the watchpoint, so
5978 that we will encounter it first in bpstat_stop_status. */
5979 if (innermost_block
&& prev_frame
)
5981 scope_breakpoint
= create_internal_breakpoint (get_frame_pc (prev_frame
),
5982 bp_watchpoint_scope
);
5984 scope_breakpoint
->enable_state
= bp_enabled
;
5986 /* Automatically delete the breakpoint when it hits. */
5987 scope_breakpoint
->disposition
= disp_del
;
5989 /* Only break in the proper frame (help with recursion). */
5990 scope_breakpoint
->frame_id
= get_frame_id (prev_frame
);
5992 /* Set the address at which we will stop. */
5993 scope_breakpoint
->loc
->requested_address
5994 = get_frame_pc (prev_frame
);
5995 scope_breakpoint
->loc
->address
5996 = adjust_breakpoint_address (scope_breakpoint
->loc
->requested_address
,
5997 scope_breakpoint
->type
);
6000 /* Now set up the breakpoint. */
6001 b
= set_raw_breakpoint (sal
, bp_type
);
6002 set_breakpoint_count (breakpoint_count
+ 1);
6003 b
->number
= breakpoint_count
;
6005 b
->disposition
= disp_donttouch
;
6007 b
->exp_valid_block
= exp_valid_block
;
6008 b
->exp_string
= savestring (exp_start
, exp_end
- exp_start
);
6011 b
->loc
->cond
= cond
;
6013 b
->cond_string
= savestring (cond_start
, cond_end
- cond_start
);
6018 b
->watchpoint_frame
= get_frame_id (frame
);
6020 b
->watchpoint_frame
= null_frame_id
;
6022 if (scope_breakpoint
!= NULL
)
6024 /* The scope breakpoint is related to the watchpoint. We will
6025 need to act on them together. */
6026 b
->related_breakpoint
= scope_breakpoint
;
6027 scope_breakpoint
->related_breakpoint
= b
;
6030 value_free_to_mark (mark
);
6032 update_global_location_list (1);
6035 /* Return count of locations need to be watched and can be handled
6036 in hardware. If the watchpoint can not be handled
6037 in hardware return zero. */
6040 can_use_hardware_watchpoint (struct value
*v
)
6042 int found_memory_cnt
= 0;
6043 struct value
*head
= v
;
6045 /* Did the user specifically forbid us to use hardware watchpoints? */
6046 if (!can_use_hw_watchpoints
)
6049 /* Make sure that the value of the expression depends only upon
6050 memory contents, and values computed from them within GDB. If we
6051 find any register references or function calls, we can't use a
6052 hardware watchpoint.
6054 The idea here is that evaluating an expression generates a series
6055 of values, one holding the value of every subexpression. (The
6056 expression a*b+c has five subexpressions: a, b, a*b, c, and
6057 a*b+c.) GDB's values hold almost enough information to establish
6058 the criteria given above --- they identify memory lvalues,
6059 register lvalues, computed values, etcetera. So we can evaluate
6060 the expression, and then scan the chain of values that leaves
6061 behind to decide whether we can detect any possible change to the
6062 expression's final value using only hardware watchpoints.
6064 However, I don't think that the values returned by inferior
6065 function calls are special in any way. So this function may not
6066 notice that an expression involving an inferior function call
6067 can't be watched with hardware watchpoints. FIXME. */
6068 for (; v
; v
= value_next (v
))
6070 if (VALUE_LVAL (v
) == lval_memory
)
6073 /* A lazy memory lvalue is one that GDB never needed to fetch;
6074 we either just used its address (e.g., `a' in `a.b') or
6075 we never needed it at all (e.g., `a' in `a,b'). */
6079 /* Ahh, memory we actually used! Check if we can cover
6080 it with hardware watchpoints. */
6081 struct type
*vtype
= check_typedef (value_type (v
));
6083 /* We only watch structs and arrays if user asked for it
6084 explicitly, never if they just happen to appear in a
6085 middle of some value chain. */
6087 || (TYPE_CODE (vtype
) != TYPE_CODE_STRUCT
6088 && TYPE_CODE (vtype
) != TYPE_CODE_ARRAY
))
6090 CORE_ADDR vaddr
= VALUE_ADDRESS (v
) + value_offset (v
);
6091 int len
= TYPE_LENGTH (value_type (v
));
6093 if (!TARGET_REGION_OK_FOR_HW_WATCHPOINT (vaddr
, len
))
6100 else if (VALUE_LVAL (v
) != not_lval
6101 && deprecated_value_modifiable (v
) == 0)
6102 return 0; /* ??? What does this represent? */
6103 else if (VALUE_LVAL (v
) == lval_register
)
6104 return 0; /* cannot watch a register with a HW watchpoint */
6107 /* The expression itself looks suitable for using a hardware
6108 watchpoint, but give the target machine a chance to reject it. */
6109 return found_memory_cnt
;
6113 watch_command_wrapper (char *arg
, int from_tty
)
6115 watch_command (arg
, from_tty
);
6119 watch_command (char *arg
, int from_tty
)
6121 watch_command_1 (arg
, hw_write
, from_tty
);
6125 rwatch_command_wrapper (char *arg
, int from_tty
)
6127 rwatch_command (arg
, from_tty
);
6131 rwatch_command (char *arg
, int from_tty
)
6133 watch_command_1 (arg
, hw_read
, from_tty
);
6137 awatch_command_wrapper (char *arg
, int from_tty
)
6139 awatch_command (arg
, from_tty
);
6143 awatch_command (char *arg
, int from_tty
)
6145 watch_command_1 (arg
, hw_access
, from_tty
);
6149 /* Helper routines for the until_command routine in infcmd.c. Here
6150 because it uses the mechanisms of breakpoints. */
6152 struct until_break_command_continuation_args
6154 struct breakpoint
*breakpoint
;
6155 struct breakpoint
*breakpoint2
;
6158 /* This function is called by fetch_inferior_event via the
6159 cmd_continuation pointer, to complete the until command. It takes
6160 care of cleaning up the temporary breakpoints set up by the until
6163 until_break_command_continuation (void *arg
)
6165 struct until_break_command_continuation_args
*a
= arg
;
6167 delete_breakpoint (a
->breakpoint
);
6169 delete_breakpoint (a
->breakpoint2
);
6173 until_break_command (char *arg
, int from_tty
, int anywhere
)
6175 struct symtabs_and_lines sals
;
6176 struct symtab_and_line sal
;
6177 struct frame_info
*frame
= get_selected_frame (NULL
);
6178 struct frame_info
*prev_frame
= get_prev_frame (frame
);
6179 struct breakpoint
*breakpoint
;
6180 struct breakpoint
*breakpoint2
= NULL
;
6181 struct cleanup
*old_chain
;
6183 clear_proceed_status ();
6185 /* Set a breakpoint where the user wants it and at return from
6188 if (default_breakpoint_valid
)
6189 sals
= decode_line_1 (&arg
, 1, default_breakpoint_symtab
,
6190 default_breakpoint_line
, (char ***) NULL
, NULL
);
6192 sals
= decode_line_1 (&arg
, 1, (struct symtab
*) NULL
,
6193 0, (char ***) NULL
, NULL
);
6195 if (sals
.nelts
!= 1)
6196 error (_("Couldn't get information on specified line."));
6199 xfree (sals
.sals
); /* malloc'd, so freed */
6202 error (_("Junk at end of arguments."));
6204 resolve_sal_pc (&sal
);
6207 /* If the user told us to continue until a specified location,
6208 we don't specify a frame at which we need to stop. */
6209 breakpoint
= set_momentary_breakpoint (sal
, null_frame_id
, bp_until
);
6211 /* Otherwise, specify the current frame, because we want to stop only
6212 at the very same frame. */
6213 breakpoint
= set_momentary_breakpoint (sal
, get_frame_id (frame
),
6216 old_chain
= make_cleanup_delete_breakpoint (breakpoint
);
6218 /* Keep within the current frame, or in frames called by the current
6222 sal
= find_pc_line (get_frame_pc (prev_frame
), 0);
6223 sal
.pc
= get_frame_pc (prev_frame
);
6224 breakpoint2
= set_momentary_breakpoint (sal
, get_frame_id (prev_frame
),
6226 make_cleanup_delete_breakpoint (breakpoint2
);
6229 proceed (-1, TARGET_SIGNAL_DEFAULT
, 0);
6231 /* If we are running asynchronously, and proceed call above has actually
6232 managed to start the target, arrange for breakpoints to be
6233 deleted when the target stops. Otherwise, we're already stopped and
6234 delete breakpoints via cleanup chain. */
6236 if (target_can_async_p () && is_running (inferior_ptid
))
6238 struct until_break_command_continuation_args
*args
;
6239 args
= xmalloc (sizeof (*args
));
6241 args
->breakpoint
= breakpoint
;
6242 args
->breakpoint2
= breakpoint2
;
6244 discard_cleanups (old_chain
);
6245 add_continuation (until_break_command_continuation
, args
,
6249 do_cleanups (old_chain
);
6253 ep_skip_leading_whitespace (char **s
)
6255 if ((s
== NULL
) || (*s
== NULL
))
6257 while (isspace (**s
))
6261 /* This function examines a string, and attempts to find a token
6262 that might be an event name in the leading characters. If a
6263 possible match is found, a pointer to the last character of
6264 the token is returned. Else, NULL is returned. */
6267 ep_find_event_name_end (char *arg
)
6270 char *event_name_end
= NULL
;
6272 /* If we could depend upon the presense of strrpbrk, we'd use that... */
6276 /* We break out of the loop when we find a token delimiter.
6277 Basically, we're looking for alphanumerics and underscores;
6278 anything else delimites the token. */
6281 if (!isalnum (*s
) && (*s
!= '_'))
6287 return event_name_end
;
6291 /* This function attempts to parse an optional "if <cond>" clause
6292 from the arg string. If one is not found, it returns NULL.
6294 Else, it returns a pointer to the condition string. (It does not
6295 attempt to evaluate the string against a particular block.) And,
6296 it updates arg to point to the first character following the parsed
6297 if clause in the arg string. */
6300 ep_parse_optional_if_clause (char **arg
)
6304 if (((*arg
)[0] != 'i') || ((*arg
)[1] != 'f') || !isspace ((*arg
)[2]))
6307 /* Skip the "if" keyword. */
6310 /* Skip any extra leading whitespace, and record the start of the
6311 condition string. */
6312 ep_skip_leading_whitespace (arg
);
6315 /* Assume that the condition occupies the remainder of the arg string. */
6316 (*arg
) += strlen (cond_string
);
6321 /* This function attempts to parse an optional filename from the arg
6322 string. If one is not found, it returns NULL.
6324 Else, it returns a pointer to the parsed filename. (This function
6325 makes no attempt to verify that a file of that name exists, or is
6326 accessible.) And, it updates arg to point to the first character
6327 following the parsed filename in the arg string.
6329 Note that clients needing to preserve the returned filename for
6330 future access should copy it to their own buffers. */
6332 ep_parse_optional_filename (char **arg
)
6334 static char filename
[1024];
6339 if ((*arg_p
== '\0') || isspace (*arg_p
))
6357 /* Commands to deal with catching events, such as signals, exceptions,
6358 process start/exit, etc. */
6362 catch_fork
, catch_vfork
6367 catch_fork_command_1 (catch_fork_kind fork_kind
, char *arg
, int tempflag
,
6370 char *cond_string
= NULL
;
6372 ep_skip_leading_whitespace (&arg
);
6374 /* The allowed syntax is:
6376 catch [v]fork if <cond>
6378 First, check if there's an if clause. */
6379 cond_string
= ep_parse_optional_if_clause (&arg
);
6381 if ((*arg
!= '\0') && !isspace (*arg
))
6382 error (_("Junk at end of arguments."));
6384 /* If this target supports it, create a fork or vfork catchpoint
6385 and enable reporting of such events. */
6389 create_fork_event_catchpoint (tempflag
, cond_string
);
6392 create_vfork_event_catchpoint (tempflag
, cond_string
);
6395 error (_("unsupported or unknown fork kind; cannot catch it"));
6401 catch_exec_command_1 (char *arg
, int tempflag
, int from_tty
)
6403 char *cond_string
= NULL
;
6405 ep_skip_leading_whitespace (&arg
);
6407 /* The allowed syntax is:
6409 catch exec if <cond>
6411 First, check if there's an if clause. */
6412 cond_string
= ep_parse_optional_if_clause (&arg
);
6414 if ((*arg
!= '\0') && !isspace (*arg
))
6415 error (_("Junk at end of arguments."));
6417 /* If this target supports it, create an exec catchpoint
6418 and enable reporting of such events. */
6419 create_exec_event_catchpoint (tempflag
, cond_string
);
6423 catch_load_command_1 (char *arg
, int tempflag
, int from_tty
)
6425 char *dll_pathname
= NULL
;
6426 char *cond_string
= NULL
;
6428 ep_skip_leading_whitespace (&arg
);
6430 /* The allowed syntax is:
6432 catch load if <cond>
6433 catch load <filename>
6434 catch load <filename> if <cond>
6436 The user is not allowed to specify the <filename> after an
6439 We'll ignore the pathological case of a file named "if".
6441 First, check if there's an if clause. If so, then there
6442 cannot be a filename. */
6443 cond_string
= ep_parse_optional_if_clause (&arg
);
6445 /* If there was an if clause, then there cannot be a filename.
6446 Else, there might be a filename and an if clause. */
6447 if (cond_string
== NULL
)
6449 dll_pathname
= ep_parse_optional_filename (&arg
);
6450 ep_skip_leading_whitespace (&arg
);
6451 cond_string
= ep_parse_optional_if_clause (&arg
);
6454 if ((*arg
!= '\0') && !isspace (*arg
))
6455 error (_("Junk at end of arguments."));
6457 /* Create a load breakpoint that only triggers when a load of
6458 the specified dll (or any dll, if no pathname was specified)
6460 SOLIB_CREATE_CATCH_LOAD_HOOK (PIDGET (inferior_ptid
), tempflag
,
6461 dll_pathname
, cond_string
);
6465 catch_unload_command_1 (char *arg
, int tempflag
, int from_tty
)
6467 char *dll_pathname
= NULL
;
6468 char *cond_string
= NULL
;
6470 ep_skip_leading_whitespace (&arg
);
6472 /* The allowed syntax is:
6474 catch unload if <cond>
6475 catch unload <filename>
6476 catch unload <filename> if <cond>
6478 The user is not allowed to specify the <filename> after an
6481 We'll ignore the pathological case of a file named "if".
6483 First, check if there's an if clause. If so, then there
6484 cannot be a filename. */
6485 cond_string
= ep_parse_optional_if_clause (&arg
);
6487 /* If there was an if clause, then there cannot be a filename.
6488 Else, there might be a filename and an if clause. */
6489 if (cond_string
== NULL
)
6491 dll_pathname
= ep_parse_optional_filename (&arg
);
6492 ep_skip_leading_whitespace (&arg
);
6493 cond_string
= ep_parse_optional_if_clause (&arg
);
6496 if ((*arg
!= '\0') && !isspace (*arg
))
6497 error (_("Junk at end of arguments."));
6499 /* Create an unload breakpoint that only triggers when an unload of
6500 the specified dll (or any dll, if no pathname was specified)
6502 SOLIB_CREATE_CATCH_UNLOAD_HOOK (PIDGET (inferior_ptid
), tempflag
,
6503 dll_pathname
, cond_string
);
6506 static enum print_stop_action
6507 print_exception_catchpoint (struct breakpoint
*b
)
6509 int bp_temp
, bp_throw
;
6511 annotate_catchpoint (b
->number
);
6513 bp_throw
= strstr (b
->addr_string
, "throw") != NULL
;
6514 if (b
->loc
->address
!= b
->loc
->requested_address
)
6515 breakpoint_adjustment_warning (b
->loc
->requested_address
,
6518 bp_temp
= b
->loc
->owner
->disposition
== disp_del
;
6520 bp_temp
? "Temporary catchpoint "
6522 if (!ui_out_is_mi_like_p (uiout
))
6523 ui_out_field_int (uiout
, "bkptno", b
->number
);
6525 bp_throw
? " (exception thrown), "
6526 : " (exception caught), ");
6527 if (ui_out_is_mi_like_p (uiout
))
6529 ui_out_field_string (uiout
, "reason",
6530 async_reason_lookup (EXEC_ASYNC_BREAKPOINT_HIT
));
6531 ui_out_field_string (uiout
, "disp", bpdisp_text (b
->disposition
));
6532 ui_out_field_int (uiout
, "bkptno", b
->number
);
6534 return PRINT_SRC_AND_LOC
;
6538 print_one_exception_catchpoint (struct breakpoint
*b
, CORE_ADDR
*last_addr
)
6543 if (b
->loc
== NULL
|| b
->loc
->shlib_disabled
)
6544 ui_out_field_string (uiout
, "addr", "<PENDING>");
6546 ui_out_field_core_addr (uiout
, "addr", b
->loc
->address
);
6550 *last_addr
= b
->loc
->address
;
6551 if (strstr (b
->addr_string
, "throw") != NULL
)
6552 ui_out_field_string (uiout
, "what", "exception throw");
6554 ui_out_field_string (uiout
, "what", "exception catch");
6558 print_mention_exception_catchpoint (struct breakpoint
*b
)
6563 bp_temp
= b
->loc
->owner
->disposition
== disp_del
;
6564 bp_throw
= strstr (b
->addr_string
, "throw") != NULL
;
6565 ui_out_text (uiout
, bp_temp
? _("Temporary catchpoint ")
6566 : _("Catchpoint "));
6567 ui_out_field_int (uiout
, "bkptno", b
->number
);
6568 ui_out_text (uiout
, bp_throw
? _(" (throw)")
6572 static struct breakpoint_ops gnu_v3_exception_catchpoint_ops
= {
6573 print_exception_catchpoint
,
6574 print_one_exception_catchpoint
,
6575 print_mention_exception_catchpoint
6579 handle_gnu_v3_exceptions (int tempflag
, char *cond_string
,
6580 enum exception_event_kind ex_event
, int from_tty
)
6582 char *trigger_func_name
;
6584 if (ex_event
== EX_EVENT_CATCH
)
6585 trigger_func_name
= "__cxa_begin_catch";
6587 trigger_func_name
= "__cxa_throw";
6589 break_command_really (trigger_func_name
, cond_string
, -1,
6590 0 /* condition and thread are valid. */,
6593 AUTO_BOOLEAN_TRUE
/* pending */,
6594 &gnu_v3_exception_catchpoint_ops
, from_tty
);
6599 /* Deal with "catch catch" and "catch throw" commands */
6602 catch_exception_command_1 (enum exception_event_kind ex_event
, char *arg
,
6603 int tempflag
, int from_tty
)
6605 char *cond_string
= NULL
;
6606 struct symtab_and_line
*sal
= NULL
;
6608 ep_skip_leading_whitespace (&arg
);
6610 cond_string
= ep_parse_optional_if_clause (&arg
);
6612 if ((*arg
!= '\0') && !isspace (*arg
))
6613 error (_("Junk at end of arguments."));
6615 if ((ex_event
!= EX_EVENT_THROW
) &&
6616 (ex_event
!= EX_EVENT_CATCH
))
6617 error (_("Unsupported or unknown exception event; cannot catch it"));
6619 if (handle_gnu_v3_exceptions (tempflag
, cond_string
, ex_event
, from_tty
))
6622 warning (_("Unsupported with this platform/compiler combination."));
6625 /* Create a breakpoint struct for Ada exception catchpoints. */
6628 create_ada_exception_breakpoint (struct symtab_and_line sal
,
6632 struct expression
*cond
,
6633 struct breakpoint_ops
*ops
,
6637 struct breakpoint
*b
;
6641 describe_other_breakpoints (sal
.pc
, sal
.section
, -1);
6642 /* FIXME: brobecker/2006-12-28: Actually, re-implement a special
6643 version for exception catchpoints, because two catchpoints
6644 used for different exception names will use the same address.
6645 In this case, a "breakpoint ... also set at..." warning is
6646 unproductive. Besides. the warning phrasing is also a bit
6647 inapropriate, we should use the word catchpoint, and tell
6648 the user what type of catchpoint it is. The above is good
6649 enough for now, though. */
6652 b
= set_raw_breakpoint (sal
, bp_breakpoint
);
6653 set_breakpoint_count (breakpoint_count
+ 1);
6655 b
->enable_state
= bp_enabled
;
6656 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
6657 b
->number
= breakpoint_count
;
6658 b
->ignore_count
= 0;
6659 b
->loc
->cond
= cond
;
6660 b
->addr_string
= addr_string
;
6661 b
->language
= language_ada
;
6662 b
->cond_string
= cond_string
;
6663 b
->exp_string
= exp_string
;
6668 update_global_location_list (1);
6671 /* Implement the "catch exception" command. */
6674 catch_ada_exception_command (char *arg
, int tempflag
, int from_tty
)
6676 struct symtab_and_line sal
;
6678 char *addr_string
= NULL
;
6679 char *exp_string
= NULL
;
6680 char *cond_string
= NULL
;
6681 struct expression
*cond
= NULL
;
6682 struct breakpoint_ops
*ops
= NULL
;
6684 sal
= ada_decode_exception_location (arg
, &addr_string
, &exp_string
,
6685 &cond_string
, &cond
, &ops
);
6686 create_ada_exception_breakpoint (sal
, addr_string
, exp_string
,
6687 cond_string
, cond
, ops
, tempflag
,
6691 /* Implement the "catch assert" command. */
6694 catch_assert_command (char *arg
, int tempflag
, int from_tty
)
6696 struct symtab_and_line sal
;
6697 char *addr_string
= NULL
;
6698 struct breakpoint_ops
*ops
= NULL
;
6700 sal
= ada_decode_assert_location (arg
, &addr_string
, &ops
);
6701 create_ada_exception_breakpoint (sal
, addr_string
, NULL
, NULL
, NULL
, ops
,
6702 tempflag
, from_tty
);
6706 catch_command_1 (char *arg
, int tempflag
, int from_tty
)
6709 /* The first argument may be an event name, such as "start" or "load".
6710 If so, then handle it as such. If it doesn't match an event name,
6711 then attempt to interpret it as an exception name. (This latter is
6712 the v4.16-and-earlier GDB meaning of the "catch" command.)
6714 First, try to find the bounds of what might be an event name. */
6715 char *arg1_start
= arg
;
6719 if (arg1_start
== NULL
)
6721 /* Old behaviour was to use pre-v-4.16 syntax */
6722 /* catch_throw_command_1 (arg1_start, tempflag, from_tty); */
6724 /* Now, this is not allowed */
6725 error (_("Catch requires an event name."));
6728 arg1_end
= ep_find_event_name_end (arg1_start
);
6729 if (arg1_end
== NULL
)
6730 error (_("catch requires an event"));
6731 arg1_length
= arg1_end
+ 1 - arg1_start
;
6733 /* Try to match what we found against known event names. */
6734 if (strncmp (arg1_start
, "signal", arg1_length
) == 0)
6736 error (_("Catch of signal not yet implemented"));
6738 else if (strncmp (arg1_start
, "catch", arg1_length
) == 0)
6740 catch_exception_command_1 (EX_EVENT_CATCH
, arg1_end
+ 1,
6741 tempflag
, from_tty
);
6743 else if (strncmp (arg1_start
, "throw", arg1_length
) == 0)
6745 catch_exception_command_1 (EX_EVENT_THROW
, arg1_end
+ 1,
6746 tempflag
, from_tty
);
6748 else if (strncmp (arg1_start
, "thread_start", arg1_length
) == 0)
6750 error (_("Catch of thread_start not yet implemented"));
6752 else if (strncmp (arg1_start
, "thread_exit", arg1_length
) == 0)
6754 error (_("Catch of thread_exit not yet implemented"));
6756 else if (strncmp (arg1_start
, "thread_join", arg1_length
) == 0)
6758 error (_("Catch of thread_join not yet implemented"));
6760 else if (strncmp (arg1_start
, "start", arg1_length
) == 0)
6762 error (_("Catch of start not yet implemented"));
6764 else if (strncmp (arg1_start
, "exit", arg1_length
) == 0)
6766 error (_("Catch of exit not yet implemented"));
6768 else if (strncmp (arg1_start
, "fork", arg1_length
) == 0)
6770 catch_fork_command_1 (catch_fork
, arg1_end
+ 1, tempflag
, from_tty
);
6772 else if (strncmp (arg1_start
, "vfork", arg1_length
) == 0)
6774 catch_fork_command_1 (catch_vfork
, arg1_end
+ 1, tempflag
, from_tty
);
6776 else if (strncmp (arg1_start
, "exec", arg1_length
) == 0)
6778 catch_exec_command_1 (arg1_end
+ 1, tempflag
, from_tty
);
6780 else if (strncmp (arg1_start
, "load", arg1_length
) == 0)
6782 catch_load_command_1 (arg1_end
+ 1, tempflag
, from_tty
);
6784 else if (strncmp (arg1_start
, "unload", arg1_length
) == 0)
6786 catch_unload_command_1 (arg1_end
+ 1, tempflag
, from_tty
);
6788 else if (strncmp (arg1_start
, "stop", arg1_length
) == 0)
6790 error (_("Catch of stop not yet implemented"));
6792 else if (strncmp (arg1_start
, "exception", arg1_length
) == 0)
6794 catch_ada_exception_command (arg1_end
+ 1, tempflag
, from_tty
);
6797 else if (strncmp (arg1_start
, "assert", arg1_length
) == 0)
6799 catch_assert_command (arg1_end
+ 1, tempflag
, from_tty
);
6802 /* This doesn't appear to be an event name */
6806 /* Pre-v.4.16 behaviour was to treat the argument
6807 as the name of an exception */
6808 /* catch_throw_command_1 (arg1_start, tempflag, from_tty); */
6809 /* Now this is not allowed */
6810 error (_("Unknown event kind specified for catch"));
6816 catch_command (char *arg
, int from_tty
)
6818 catch_command_1 (arg
, 0, from_tty
);
6823 tcatch_command (char *arg
, int from_tty
)
6825 catch_command_1 (arg
, 1, from_tty
);
6828 /* Delete breakpoints by address or line. */
6831 clear_command (char *arg
, int from_tty
)
6833 struct breakpoint
*b
;
6834 VEC(breakpoint_p
) *found
= 0;
6837 struct symtabs_and_lines sals
;
6838 struct symtab_and_line sal
;
6843 sals
= decode_line_spec (arg
, 1);
6848 sals
.sals
= (struct symtab_and_line
*)
6849 xmalloc (sizeof (struct symtab_and_line
));
6850 make_cleanup (xfree
, sals
.sals
);
6851 init_sal (&sal
); /* initialize to zeroes */
6852 sal
.line
= default_breakpoint_line
;
6853 sal
.symtab
= default_breakpoint_symtab
;
6854 sal
.pc
= default_breakpoint_address
;
6855 if (sal
.symtab
== 0)
6856 error (_("No source file specified."));
6864 /* We don't call resolve_sal_pc here. That's not
6865 as bad as it seems, because all existing breakpoints
6866 typically have both file/line and pc set. So, if
6867 clear is given file/line, we can match this to existing
6868 breakpoint without obtaining pc at all.
6870 We only support clearing given the address explicitly
6871 present in breakpoint table. Say, we've set breakpoint
6872 at file:line. There were several PC values for that file:line,
6873 due to optimization, all in one block.
6874 We've picked one PC value. If "clear" is issued with another
6875 PC corresponding to the same file:line, the breakpoint won't
6876 be cleared. We probably can still clear the breakpoint, but
6877 since the other PC value is never presented to user, user
6878 can only find it by guessing, and it does not seem important
6881 /* For each line spec given, delete bps which correspond
6882 to it. Do it in two passes, solely to preserve the current
6883 behavior that from_tty is forced true if we delete more than
6887 for (i
= 0; i
< sals
.nelts
; i
++)
6889 /* If exact pc given, clear bpts at that pc.
6890 If line given (pc == 0), clear all bpts on specified line.
6891 If defaulting, clear all bpts on default line
6894 defaulting sal.pc != 0 tests to do
6899 1 0 <can't happen> */
6903 /* Find all matching breakpoints and add them to
6908 /* Are we going to delete b? */
6909 if (b
->type
!= bp_none
6910 && b
->type
!= bp_watchpoint
6911 && b
->type
!= bp_hardware_watchpoint
6912 && b
->type
!= bp_read_watchpoint
6913 && b
->type
!= bp_access_watchpoint
)
6915 struct bp_location
*loc
= b
->loc
;
6916 for (; loc
; loc
= loc
->next
)
6918 int pc_match
= sal
.pc
6919 && (loc
->address
== sal
.pc
)
6920 && (!section_is_overlay (loc
->section
)
6921 || loc
->section
== sal
.section
);
6922 int line_match
= ((default_match
|| (0 == sal
.pc
))
6923 && b
->source_file
!= NULL
6924 && sal
.symtab
!= NULL
6925 && strcmp (b
->source_file
, sal
.symtab
->filename
) == 0
6926 && b
->line_number
== sal
.line
);
6927 if (pc_match
|| line_match
)
6936 VEC_safe_push(breakpoint_p
, found
, b
);
6939 /* Now go thru the 'found' chain and delete them. */
6940 if (VEC_empty(breakpoint_p
, found
))
6943 error (_("No breakpoint at %s."), arg
);
6945 error (_("No breakpoint at this line."));
6948 if (VEC_length(breakpoint_p
, found
) > 1)
6949 from_tty
= 1; /* Always report if deleted more than one */
6952 if (VEC_length(breakpoint_p
, found
) == 1)
6953 printf_unfiltered (_("Deleted breakpoint "));
6955 printf_unfiltered (_("Deleted breakpoints "));
6957 breakpoints_changed ();
6959 for (ix
= 0; VEC_iterate(breakpoint_p
, found
, ix
, b
); ix
++)
6962 printf_unfiltered ("%d ", b
->number
);
6963 delete_breakpoint (b
);
6966 putchar_unfiltered ('\n');
6969 /* Delete breakpoint in BS if they are `delete' breakpoints and
6970 all breakpoints that are marked for deletion, whether hit or not.
6971 This is called after any breakpoint is hit, or after errors. */
6974 breakpoint_auto_delete (bpstat bs
)
6976 struct breakpoint
*b
, *temp
;
6978 for (; bs
; bs
= bs
->next
)
6979 if (bs
->breakpoint_at
6980 && bs
->breakpoint_at
->owner
6981 && bs
->breakpoint_at
->owner
->disposition
== disp_del
6983 delete_breakpoint (bs
->breakpoint_at
->owner
);
6985 ALL_BREAKPOINTS_SAFE (b
, temp
)
6987 if (b
->disposition
== disp_del_at_next_stop
)
6988 delete_breakpoint (b
);
6992 /* If SHOULD_INSERT is true, do not insert any breakpoint locations
6993 into the inferior, only remove already-inserted locations that no
6994 longer should be inserted. Functions that delete a breakpoint or
6995 breakpoints should pass false, so that deleting a breakpoint
6996 doesn't have the side effect of inserting the locations of other
6997 breakpoints that are marked not-inserted, but should_be_inserted
6998 returns true on them.
7000 This behaviour is useful is situations close to tear-down -- e.g.,
7001 after an exec, while the target still has execution, but breakpoint
7002 shadows of the previous executable image should *NOT* be restored
7003 to the new image; or before detaching, where the target still has
7004 execution and wants to delete breakpoints from GDB's lists, and all
7005 breakpoints had already been removed from the inferior. */
7008 update_global_location_list (int should_insert
)
7010 struct breakpoint
*b
;
7011 struct bp_location
**next
= &bp_location_chain
;
7012 struct bp_location
*loc
;
7013 struct bp_location
*loc2
;
7014 struct gdb_exception e
;
7015 VEC(bp_location_p
) *old_locations
= NULL
;
7019 /* Store old locations for future reference. */
7020 for (loc
= bp_location_chain
; loc
; loc
= loc
->global_next
)
7021 VEC_safe_push (bp_location_p
, old_locations
, loc
);
7023 bp_location_chain
= NULL
;
7026 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
7029 next
= &(loc
->global_next
);
7034 /* Identify bp_location instances that are no longer present in the new
7035 list, and therefore should be freed. Note that it's not necessary that
7036 those locations should be removed from inferior -- if there's another
7037 location at the same address (previously marked as duplicate),
7038 we don't need to remove/insert the location. */
7039 for (ix
= 0; VEC_iterate(bp_location_p
, old_locations
, ix
, loc
); ++ix
)
7041 /* Tells if 'loc' is found amoung the new locations. If not, we
7043 int found_object
= 0;
7044 /* Tells if the location should remain inserted in the target. */
7045 int keep_in_target
= 0;
7047 for (loc2
= bp_location_chain
; loc2
; loc2
= loc2
->global_next
)
7054 /* If this location is no longer present, and inserted, look if there's
7055 maybe a new location at the same address. If so, mark that one
7056 inserted, and don't remove this one. This is needed so that we
7057 don't have a time window where a breakpoint at certain location is not
7062 /* If the location is inserted now, we might have to remove it. */
7064 if (found_object
&& should_be_inserted (loc
))
7066 /* The location is still present in the location list, and still
7067 should be inserted. Don't do anything. */
7072 /* The location is either no longer present, or got disabled.
7073 See if there's another location at the same address, in which
7074 case we don't need to remove this one from the target. */
7075 if (breakpoint_address_is_meaningful (loc
->owner
))
7076 for (loc2
= bp_location_chain
; loc2
; loc2
= loc2
->global_next
)
7078 /* For the sake of should_insert_location. The
7079 call to check_duplicates will fix up this later. */
7080 loc2
->duplicate
= 0;
7081 if (should_be_inserted (loc2
)
7082 && loc2
!= loc
&& loc2
->address
== loc
->address
)
7085 loc2
->target_info
= loc
->target_info
;
7092 if (!keep_in_target
)
7094 if (remove_breakpoint (loc
, mark_uninserted
))
7096 /* This is just about all we can do. We could keep this
7097 location on the global list, and try to remove it next
7098 time, but there's no particular reason why we will
7101 Note that at this point, loc->owner is still valid,
7102 as delete_breakpoint frees the breakpoint only
7103 after calling us. */
7104 printf_filtered (_("warning: Error removing breakpoint %d\n"),
7105 loc
->owner
->number
);
7115 /* This location was removed from the targets. In non-stop mode,
7116 a race condition is possible where we've removed a breakpoint,
7117 but stop events for that breakpoint are already queued and will
7118 arrive later. To suppress spurious SIGTRAPs reported to user,
7119 we keep this breakpoint location for a bit, and will retire it
7120 after we see 3 * thread_count events.
7121 The theory here is that reporting of events should,
7122 "on the average", be fair, so after that many event we'll see
7123 events from all threads that have anything of interest, and no
7124 longer need to keep this breakpoint. This is just a
7125 heuristic, but if it's wrong, we'll report unexpected SIGTRAP,
7126 which is usability issue, but not a correctness problem. */
7127 loc
->events_till_retirement
= 3 * (thread_count () + 1);
7131 free_bp_location (loc
);
7137 check_duplicates (b
);
7140 if (always_inserted_mode
&& should_insert
&& target_has_execution
)
7141 insert_breakpoint_locations ();
7145 breakpoint_retire_moribund (void)
7147 struct bp_location
*loc
;
7150 for (ix
= 0; VEC_iterate (bp_location_p
, moribund_locations
, ix
, loc
); ++ix
)
7151 if (--(loc
->events_till_retirement
) == 0)
7153 free_bp_location (loc
);
7154 VEC_unordered_remove (bp_location_p
, moribund_locations
, ix
);
7160 update_global_location_list_nothrow (int inserting
)
7162 struct gdb_exception e
;
7163 TRY_CATCH (e
, RETURN_MASK_ERROR
)
7164 update_global_location_list (inserting
);
7167 /* Clear BPT from a BPS. */
7169 bpstat_remove_breakpoint (bpstat bps
, struct breakpoint
*bpt
)
7172 for (bs
= bps
; bs
; bs
= bs
->next
)
7173 if (bs
->breakpoint_at
&& bs
->breakpoint_at
->owner
== bpt
)
7175 bs
->breakpoint_at
= NULL
;
7177 /* bs->commands will be freed later. */
7181 /* Callback for iterate_over_threads. */
7183 bpstat_remove_breakpoint_callback (struct thread_info
*th
, void *data
)
7185 struct breakpoint
*bpt
= data
;
7186 bpstat_remove_breakpoint (th
->stop_bpstat
, bpt
);
7190 /* Delete a breakpoint and clean up all traces of it in the data
7194 delete_breakpoint (struct breakpoint
*bpt
)
7196 struct breakpoint
*b
;
7197 struct bp_location
*loc
, *next
;
7199 gdb_assert (bpt
!= NULL
);
7201 /* Has this bp already been deleted? This can happen because multiple
7202 lists can hold pointers to bp's. bpstat lists are especial culprits.
7204 One example of this happening is a watchpoint's scope bp. When the
7205 scope bp triggers, we notice that the watchpoint is out of scope, and
7206 delete it. We also delete its scope bp. But the scope bp is marked
7207 "auto-deleting", and is already on a bpstat. That bpstat is then
7208 checked for auto-deleting bp's, which are deleted.
7210 A real solution to this problem might involve reference counts in bp's,
7211 and/or giving them pointers back to their referencing bpstat's, and
7212 teaching delete_breakpoint to only free a bp's storage when no more
7213 references were extent. A cheaper bandaid was chosen. */
7214 if (bpt
->type
== bp_none
)
7217 if (deprecated_delete_breakpoint_hook
)
7218 deprecated_delete_breakpoint_hook (bpt
);
7219 breakpoint_delete_event (bpt
->number
);
7221 if (breakpoint_chain
== bpt
)
7222 breakpoint_chain
= bpt
->next
;
7227 b
->next
= bpt
->next
;
7231 free_command_lines (&bpt
->commands
);
7232 if (bpt
->cond_string
!= NULL
)
7233 xfree (bpt
->cond_string
);
7234 if (bpt
->addr_string
!= NULL
)
7235 xfree (bpt
->addr_string
);
7236 if (bpt
->exp
!= NULL
)
7238 if (bpt
->exp_string
!= NULL
)
7239 xfree (bpt
->exp_string
);
7240 if (bpt
->val
!= NULL
)
7241 value_free (bpt
->val
);
7242 if (bpt
->source_file
!= NULL
)
7243 xfree (bpt
->source_file
);
7244 if (bpt
->dll_pathname
!= NULL
)
7245 xfree (bpt
->dll_pathname
);
7246 if (bpt
->triggered_dll_pathname
!= NULL
)
7247 xfree (bpt
->triggered_dll_pathname
);
7248 if (bpt
->exec_pathname
!= NULL
)
7249 xfree (bpt
->exec_pathname
);
7251 /* Be sure no bpstat's are pointing at it after it's been freed. */
7252 /* FIXME, how can we find all bpstat's?
7253 We just check stop_bpstat for now. Note that we cannot just
7254 remove bpstats pointing at bpt from the stop_bpstat list
7255 entirely, as breakpoint commands are associated with the bpstat;
7256 if we remove it here, then the later call to
7257 bpstat_do_actions (&stop_bpstat);
7258 in event-top.c won't do anything, and temporary breakpoints
7259 with commands won't work. */
7261 /* Clear the current context. */
7262 bpstat_remove_breakpoint (stop_bpstat
, bpt
);
7263 /* And from all threads. */
7264 iterate_over_threads (bpstat_remove_breakpoint_callback
, bpt
);
7266 /* Now that breakpoint is removed from breakpoint
7267 list, update the global location list. This
7268 will remove locations that used to belong to
7269 this breakpoint. Do this before freeing
7270 the breakpoint itself, since remove_breakpoint
7271 looks at location's owner. It might be better
7272 design to have location completely self-contained,
7273 but it's not the case now. */
7274 update_global_location_list (0);
7277 /* On the chance that someone will soon try again to delete this same
7278 bp, we mark it as deleted before freeing its storage. */
7279 bpt
->type
= bp_none
;
7285 do_delete_breakpoint_cleanup (void *b
)
7287 delete_breakpoint (b
);
7291 make_cleanup_delete_breakpoint (struct breakpoint
*b
)
7293 return make_cleanup (do_delete_breakpoint_cleanup
, b
);
7297 delete_command (char *arg
, int from_tty
)
7299 struct breakpoint
*b
, *temp
;
7305 int breaks_to_delete
= 0;
7307 /* Delete all breakpoints if no argument.
7308 Do not delete internal or call-dummy breakpoints, these
7309 have to be deleted with an explicit breakpoint number argument. */
7312 if (b
->type
!= bp_call_dummy
&&
7313 b
->type
!= bp_shlib_event
&&
7314 b
->type
!= bp_thread_event
&&
7315 b
->type
!= bp_overlay_event
&&
7318 breaks_to_delete
= 1;
7323 /* Ask user only if there are some breakpoints to delete. */
7325 || (breaks_to_delete
&& query (_("Delete all breakpoints? "))))
7327 ALL_BREAKPOINTS_SAFE (b
, temp
)
7329 if (b
->type
!= bp_call_dummy
&&
7330 b
->type
!= bp_shlib_event
&&
7331 b
->type
!= bp_thread_event
&&
7332 b
->type
!= bp_overlay_event
&&
7334 delete_breakpoint (b
);
7339 map_breakpoint_numbers (arg
, delete_breakpoint
);
7343 all_locations_are_pending (struct bp_location
*loc
)
7345 for (; loc
; loc
= loc
->next
)
7346 if (!loc
->shlib_disabled
)
7351 /* Subroutine of update_breakpoint_locations to simplify it.
7352 Return non-zero if multiple fns in list LOC have the same name.
7353 Null names are ignored. */
7356 ambiguous_names_p (struct bp_location
*loc
)
7358 struct bp_location
*l
;
7359 htab_t htab
= htab_create_alloc (13, htab_hash_string
,
7360 (int (*) (const void *, const void *)) streq
,
7361 NULL
, xcalloc
, xfree
);
7363 for (l
= loc
; l
!= NULL
; l
= l
->next
)
7366 const char *name
= l
->function_name
;
7368 /* Allow for some names to be NULL, ignore them. */
7372 slot
= (const char **) htab_find_slot (htab
, (const void *) name
,
7374 /* NOTE: We can assume slot != NULL here because xcalloc never returns
7389 update_breakpoint_locations (struct breakpoint
*b
,
7390 struct symtabs_and_lines sals
)
7394 struct bp_location
*existing_locations
= b
->loc
;
7396 /* If there's no new locations, and all existing locations
7397 are pending, don't do anything. This optimizes
7398 the common case where all locations are in the same
7399 shared library, that was unloaded. We'd like to
7400 retain the location, so that when the library
7401 is loaded again, we don't loose the enabled/disabled
7402 status of the individual locations. */
7403 if (all_locations_are_pending (existing_locations
) && sals
.nelts
== 0)
7408 for (i
= 0; i
< sals
.nelts
; ++i
)
7410 struct bp_location
*new_loc
=
7411 add_location_to_breakpoint (b
, b
->type
, &(sals
.sals
[i
]));
7413 /* Reparse conditions, they might contain references to the
7415 if (b
->cond_string
!= NULL
)
7417 struct gdb_exception e
;
7420 TRY_CATCH (e
, RETURN_MASK_ERROR
)
7422 new_loc
->cond
= parse_exp_1 (&s
, block_for_pc (sals
.sals
[i
].pc
),
7427 warning (_("failed to reevaluate condition for breakpoint %d: %s"),
7428 b
->number
, e
.message
);
7429 new_loc
->enabled
= 0;
7433 if (b
->source_file
!= NULL
)
7434 xfree (b
->source_file
);
7435 if (sals
.sals
[i
].symtab
== NULL
)
7436 b
->source_file
= NULL
;
7439 savestring (sals
.sals
[i
].symtab
->filename
,
7440 strlen (sals
.sals
[i
].symtab
->filename
));
7442 if (b
->line_number
== 0)
7443 b
->line_number
= sals
.sals
[i
].line
;
7446 /* If possible, carry over 'disable' status from existing breakpoints. */
7448 struct bp_location
*e
= existing_locations
;
7449 /* If there are multiple breakpoints with the same function name,
7450 e.g. for inline functions, comparing function names won't work.
7451 Instead compare pc addresses; this is just a heuristic as things
7452 may have moved, but in practice it gives the correct answer
7453 often enough until a better solution is found. */
7454 int have_ambiguous_names
= ambiguous_names_p (b
->loc
);
7456 for (; e
; e
= e
->next
)
7458 if (!e
->enabled
&& e
->function_name
)
7460 struct bp_location
*l
= b
->loc
;
7461 if (have_ambiguous_names
)
7463 for (; l
; l
= l
->next
)
7464 if (e
->address
== l
->address
)
7472 for (; l
; l
= l
->next
)
7473 if (l
->function_name
7474 && strcmp (e
->function_name
, l
->function_name
) == 0)
7484 update_global_location_list (1);
7488 /* Reset a breakpoint given it's struct breakpoint * BINT.
7489 The value we return ends up being the return value from catch_errors.
7490 Unused in this case. */
7493 breakpoint_re_set_one (void *bint
)
7495 /* get past catch_errs */
7496 struct breakpoint
*b
= (struct breakpoint
*) bint
;
7500 int *not_found_ptr
= ¬_found
;
7501 struct symtabs_and_lines sals
= {};
7502 struct symtabs_and_lines expanded
;
7504 enum enable_state save_enable
;
7505 struct gdb_exception e
;
7511 warning (_("attempted to reset apparently deleted breakpoint #%d?"),
7515 case bp_hardware_breakpoint
:
7517 case bp_catch_unload
:
7518 if (b
->addr_string
== NULL
)
7520 /* Anything without a string can't be re-set. */
7521 delete_breakpoint (b
);
7525 set_language (b
->language
);
7526 input_radix
= b
->input_radix
;
7528 TRY_CATCH (e
, RETURN_MASK_ERROR
)
7530 sals
= decode_line_1 (&s
, 1, (struct symtab
*) NULL
, 0, (char ***) NULL
,
7535 int not_found_and_ok
= 0;
7536 /* For pending breakpoints, it's expected that parsing
7537 will fail until the right shared library is loaded.
7538 User has already told to create pending breakpoints and
7539 don't need extra messages. If breakpoint is in bp_shlib_disabled
7540 state, then user already saw the message about that breakpoint
7541 being disabled, and don't want to see more errors. */
7543 && (b
->condition_not_parsed
7544 || (b
->loc
&& b
->loc
->shlib_disabled
)
7545 || b
->enable_state
== bp_disabled
))
7546 not_found_and_ok
= 1;
7548 if (!not_found_and_ok
)
7550 /* We surely don't want to warn about the same breakpoint
7551 10 times. One solution, implemented here, is disable
7552 the breakpoint on error. Another solution would be to
7553 have separate 'warning emitted' flag. Since this
7554 happens only when a binary has changed, I don't know
7555 which approach is better. */
7556 b
->enable_state
= bp_disabled
;
7557 throw_exception (e
);
7564 gdb_assert (sals
.nelts
== 1);
7565 resolve_sal_pc (&sals
.sals
[0]);
7566 if (b
->condition_not_parsed
&& s
&& s
[0])
7568 char *cond_string
= 0;
7570 find_condition_and_thread (s
, sals
.sals
[0].pc
,
7571 &cond_string
, &thread
);
7573 b
->cond_string
= cond_string
;
7575 b
->condition_not_parsed
= 0;
7577 expanded
= expand_line_sal_maybe (sals
.sals
[0]);
7578 update_breakpoint_locations (b
, expanded
);
7584 case bp_hardware_watchpoint
:
7585 case bp_read_watchpoint
:
7586 case bp_access_watchpoint
:
7587 /* Watchpoint can be either on expression using entirely global variables,
7588 or it can be on local variables.
7590 Watchpoints of the first kind are never auto-deleted, and even persist
7591 across program restarts. Since they can use variables from shared
7592 libraries, we need to reparse expression as libraries are loaded
7595 Watchpoints on local variables can also change meaning as result
7596 of solib event. For example, if a watchpoint uses both a local and
7597 a global variables in expression, it's a local watchpoint, but
7598 unloading of a shared library will make the expression invalid.
7599 This is not a very common use case, but we still re-evaluate
7600 expression, to avoid surprises to the user.
7602 Note that for local watchpoints, we re-evaluate it only if
7603 watchpoints frame id is still valid. If it's not, it means
7604 the watchpoint is out of scope and will be deleted soon. In fact,
7605 I'm not sure we'll ever be called in this case.
7607 If a local watchpoint's frame id is still valid, then
7608 b->exp_valid_block is likewise valid, and we can safely use it.
7610 Don't do anything about disabled watchpoints, since they will
7611 be reevaluated again when enabled. */
7612 update_watchpoint (b
, 1 /* reparse */);
7614 /* We needn't really do anything to reset these, since the mask
7615 that requests them is unaffected by e.g., new libraries being
7618 case bp_catch_vfork
:
7623 printf_filtered (_("Deleting unknown breakpoint type %d\n"), b
->type
);
7625 /* Delete overlay event breakpoints; they will be reset later by
7626 breakpoint_re_set. */
7627 case bp_overlay_event
:
7628 delete_breakpoint (b
);
7631 /* This breakpoint is special, it's set up when the inferior
7632 starts and we really don't want to touch it. */
7633 case bp_shlib_event
:
7635 /* Like bp_shlib_event, this breakpoint type is special.
7636 Once it is set up, we do not want to touch it. */
7637 case bp_thread_event
:
7639 /* Keep temporary breakpoints, which can be encountered when we step
7640 over a dlopen call and SOLIB_ADD is resetting the breakpoints.
7641 Otherwise these should have been blown away via the cleanup chain
7642 or by breakpoint_init_inferior when we rerun the executable. */
7645 case bp_watchpoint_scope
:
7647 case bp_step_resume
:
7649 case bp_longjmp_resume
:
7656 /* Re-set all breakpoints after symbols have been re-loaded. */
7658 breakpoint_re_set (void)
7660 struct breakpoint
*b
, *temp
;
7661 enum language save_language
;
7662 int save_input_radix
;
7664 save_language
= current_language
->la_language
;
7665 save_input_radix
= input_radix
;
7666 ALL_BREAKPOINTS_SAFE (b
, temp
)
7668 /* Format possible error msg */
7669 char *message
= xstrprintf ("Error in re-setting breakpoint %d: ",
7671 struct cleanup
*cleanups
= make_cleanup (xfree
, message
);
7672 catch_errors (breakpoint_re_set_one
, b
, message
, RETURN_MASK_ALL
);
7673 do_cleanups (cleanups
);
7675 set_language (save_language
);
7676 input_radix
= save_input_radix
;
7678 create_overlay_event_breakpoint ("_ovly_debug_event");
7681 /* Reset the thread number of this breakpoint:
7683 - If the breakpoint is for all threads, leave it as-is.
7684 - Else, reset it to the current thread for inferior_ptid. */
7686 breakpoint_re_set_thread (struct breakpoint
*b
)
7688 if (b
->thread
!= -1)
7690 if (in_thread_list (inferior_ptid
))
7691 b
->thread
= pid_to_thread_id (inferior_ptid
);
7695 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
7696 If from_tty is nonzero, it prints a message to that effect,
7697 which ends with a period (no newline). */
7700 set_ignore_count (int bptnum
, int count
, int from_tty
)
7702 struct breakpoint
*b
;
7708 if (b
->number
== bptnum
)
7710 b
->ignore_count
= count
;
7714 printf_filtered (_("Will stop next time breakpoint %d is reached."),
7716 else if (count
== 1)
7717 printf_filtered (_("Will ignore next crossing of breakpoint %d."),
7720 printf_filtered (_("Will ignore next %d crossings of breakpoint %d."),
7723 breakpoints_changed ();
7724 breakpoint_modify_event (b
->number
);
7728 error (_("No breakpoint number %d."), bptnum
);
7731 /* Clear the ignore counts of all breakpoints. */
7733 breakpoint_clear_ignore_counts (void)
7735 struct breakpoint
*b
;
7738 b
->ignore_count
= 0;
7741 /* Command to set ignore-count of breakpoint N to COUNT. */
7744 ignore_command (char *args
, int from_tty
)
7750 error_no_arg (_("a breakpoint number"));
7752 num
= get_number (&p
);
7754 error (_("bad breakpoint number: '%s'"), args
);
7756 error (_("Second argument (specified ignore-count) is missing."));
7758 set_ignore_count (num
,
7759 longest_to_int (value_as_long (parse_and_eval (p
))),
7762 printf_filtered ("\n");
7765 /* Call FUNCTION on each of the breakpoints
7766 whose numbers are given in ARGS. */
7769 map_breakpoint_numbers (char *args
, void (*function
) (struct breakpoint
*))
7774 struct breakpoint
*b
, *tmp
;
7778 error_no_arg (_("one or more breakpoint numbers"));
7785 num
= get_number_or_range (&p1
);
7788 warning (_("bad breakpoint number at or near '%s'"), p
);
7792 ALL_BREAKPOINTS_SAFE (b
, tmp
)
7793 if (b
->number
== num
)
7795 struct breakpoint
*related_breakpoint
= b
->related_breakpoint
;
7798 if (related_breakpoint
)
7799 function (related_breakpoint
);
7803 printf_unfiltered (_("No breakpoint number %d.\n"), num
);
7809 static struct bp_location
*
7810 find_location_by_number (char *number
)
7812 char *dot
= strchr (number
, '.');
7816 struct breakpoint
*b
;
7817 struct bp_location
*loc
;
7822 bp_num
= get_number_or_range (&p1
);
7824 error (_("Bad breakpoint number '%s'"), number
);
7827 if (b
->number
== bp_num
)
7832 if (!b
|| b
->number
!= bp_num
)
7833 error (_("Bad breakpoint number '%s'"), number
);
7836 loc_num
= get_number_or_range (&p1
);
7838 error (_("Bad breakpoint location number '%s'"), number
);
7842 for (;loc_num
&& loc
; --loc_num
, loc
= loc
->next
)
7845 error (_("Bad breakpoint location number '%s'"), dot
+1);
7851 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
7852 If from_tty is nonzero, it prints a message to that effect,
7853 which ends with a period (no newline). */
7856 disable_breakpoint (struct breakpoint
*bpt
)
7858 /* Never disable a watchpoint scope breakpoint; we want to
7859 hit them when we leave scope so we can delete both the
7860 watchpoint and its scope breakpoint at that time. */
7861 if (bpt
->type
== bp_watchpoint_scope
)
7864 /* You can't disable permanent breakpoints. */
7865 if (bpt
->enable_state
== bp_permanent
)
7868 bpt
->enable_state
= bp_disabled
;
7870 update_global_location_list (0);
7872 if (deprecated_modify_breakpoint_hook
)
7873 deprecated_modify_breakpoint_hook (bpt
);
7874 breakpoint_modify_event (bpt
->number
);
7878 disable_command (char *args
, int from_tty
)
7880 struct breakpoint
*bpt
;
7882 ALL_BREAKPOINTS (bpt
)
7886 warning (_("attempted to disable apparently deleted breakpoint #%d?"),
7891 case bp_catch_unload
:
7893 case bp_catch_vfork
:
7895 case bp_hardware_breakpoint
:
7897 case bp_hardware_watchpoint
:
7898 case bp_read_watchpoint
:
7899 case bp_access_watchpoint
:
7900 disable_breakpoint (bpt
);
7904 else if (strchr (args
, '.'))
7906 struct bp_location
*loc
= find_location_by_number (args
);
7909 update_global_location_list (0);
7912 map_breakpoint_numbers (args
, disable_breakpoint
);
7916 do_enable_breakpoint (struct breakpoint
*bpt
, enum bpdisp disposition
)
7918 int target_resources_ok
, other_type_used
;
7921 if (bpt
->type
== bp_hardware_breakpoint
)
7924 i
= hw_breakpoint_used_count ();
7925 target_resources_ok
=
7926 TARGET_CAN_USE_HARDWARE_WATCHPOINT (bp_hardware_breakpoint
,
7928 if (target_resources_ok
== 0)
7929 error (_("No hardware breakpoint support in the target."));
7930 else if (target_resources_ok
< 0)
7931 error (_("Hardware breakpoints used exceeds limit."));
7934 if (bpt
->type
== bp_watchpoint
||
7935 bpt
->type
== bp_hardware_watchpoint
||
7936 bpt
->type
== bp_read_watchpoint
||
7937 bpt
->type
== bp_access_watchpoint
)
7939 struct frame_id saved_frame_id
;
7941 saved_frame_id
= get_frame_id (get_selected_frame (NULL
));
7942 if (bpt
->exp_valid_block
!= NULL
)
7944 struct frame_info
*fr
=
7945 fr
= frame_find_by_id (bpt
->watchpoint_frame
);
7948 printf_filtered (_("\
7949 Cannot enable watchpoint %d because the block in which its expression\n\
7950 is valid is not currently in scope.\n"), bpt
->number
);
7957 value_free (bpt
->val
);
7958 mark
= value_mark ();
7959 fetch_watchpoint_value (bpt
->exp
, &bpt
->val
, NULL
, NULL
);
7961 release_value (bpt
->val
);
7964 if (bpt
->type
== bp_hardware_watchpoint
||
7965 bpt
->type
== bp_read_watchpoint
||
7966 bpt
->type
== bp_access_watchpoint
)
7968 int i
= hw_watchpoint_used_count (bpt
->type
, &other_type_used
);
7969 int mem_cnt
= can_use_hardware_watchpoint (bpt
->val
);
7971 /* Hack around 'unused var' error for some targets here */
7972 (void) mem_cnt
, (void) i
;
7973 target_resources_ok
= TARGET_CAN_USE_HARDWARE_WATCHPOINT (
7974 bpt
->type
, i
+ mem_cnt
, other_type_used
);
7975 /* we can consider of type is bp_hardware_watchpoint, convert to
7976 bp_watchpoint in the following condition */
7977 if (target_resources_ok
< 0)
7979 printf_filtered (_("\
7980 Cannot enable watchpoint %d because target watch resources\n\
7981 have been allocated for other watchpoints.\n"), bpt
->number
);
7982 value_free_to_mark (mark
);
7987 select_frame (frame_find_by_id (saved_frame_id
));
7988 value_free_to_mark (mark
);
7991 if (bpt
->enable_state
!= bp_permanent
)
7992 bpt
->enable_state
= bp_enabled
;
7993 bpt
->disposition
= disposition
;
7994 update_global_location_list (1);
7995 breakpoints_changed ();
7997 if (deprecated_modify_breakpoint_hook
)
7998 deprecated_modify_breakpoint_hook (bpt
);
7999 breakpoint_modify_event (bpt
->number
);
8004 enable_breakpoint (struct breakpoint
*bpt
)
8006 do_enable_breakpoint (bpt
, bpt
->disposition
);
8009 /* The enable command enables the specified breakpoints (or all defined
8010 breakpoints) so they once again become (or continue to be) effective
8011 in stopping the inferior. */
8014 enable_command (char *args
, int from_tty
)
8016 struct breakpoint
*bpt
;
8018 ALL_BREAKPOINTS (bpt
)
8022 warning (_("attempted to enable apparently deleted breakpoint #%d?"),
8027 case bp_catch_unload
:
8029 case bp_catch_vfork
:
8031 case bp_hardware_breakpoint
:
8033 case bp_hardware_watchpoint
:
8034 case bp_read_watchpoint
:
8035 case bp_access_watchpoint
:
8036 enable_breakpoint (bpt
);
8040 else if (strchr (args
, '.'))
8042 struct bp_location
*loc
= find_location_by_number (args
);
8045 update_global_location_list (1);
8048 map_breakpoint_numbers (args
, enable_breakpoint
);
8052 enable_once_breakpoint (struct breakpoint
*bpt
)
8054 do_enable_breakpoint (bpt
, disp_disable
);
8058 enable_once_command (char *args
, int from_tty
)
8060 map_breakpoint_numbers (args
, enable_once_breakpoint
);
8064 enable_delete_breakpoint (struct breakpoint
*bpt
)
8066 do_enable_breakpoint (bpt
, disp_del
);
8070 enable_delete_command (char *args
, int from_tty
)
8072 map_breakpoint_numbers (args
, enable_delete_breakpoint
);
8076 set_breakpoint_cmd (char *args
, int from_tty
)
8081 show_breakpoint_cmd (char *args
, int from_tty
)
8085 /* Use default_breakpoint_'s, or nothing if they aren't valid. */
8087 struct symtabs_and_lines
8088 decode_line_spec_1 (char *string
, int funfirstline
)
8090 struct symtabs_and_lines sals
;
8092 error (_("Empty line specification."));
8093 if (default_breakpoint_valid
)
8094 sals
= decode_line_1 (&string
, funfirstline
,
8095 default_breakpoint_symtab
,
8096 default_breakpoint_line
,
8097 (char ***) NULL
, NULL
);
8099 sals
= decode_line_1 (&string
, funfirstline
,
8100 (struct symtab
*) NULL
, 0, (char ***) NULL
, NULL
);
8102 error (_("Junk at end of line specification: %s"), string
);
8106 /* Create and insert a raw software breakpoint at PC. Return an
8107 identifier, which should be used to remove the breakpoint later.
8108 In general, places which call this should be using something on the
8109 breakpoint chain instead; this function should be eliminated
8113 deprecated_insert_raw_breakpoint (CORE_ADDR pc
)
8115 struct bp_target_info
*bp_tgt
;
8117 bp_tgt
= xmalloc (sizeof (struct bp_target_info
));
8118 memset (bp_tgt
, 0, sizeof (struct bp_target_info
));
8120 bp_tgt
->placed_address
= pc
;
8121 if (target_insert_breakpoint (bp_tgt
) != 0)
8123 /* Could not insert the breakpoint. */
8131 /* Remove a breakpoint BP inserted by deprecated_insert_raw_breakpoint. */
8134 deprecated_remove_raw_breakpoint (void *bp
)
8136 struct bp_target_info
*bp_tgt
= bp
;
8139 ret
= target_remove_breakpoint (bp_tgt
);
8145 /* One (or perhaps two) breakpoints used for software single stepping. */
8147 static void *single_step_breakpoints
[2];
8149 /* Create and insert a breakpoint for software single step. */
8152 insert_single_step_breakpoint (CORE_ADDR next_pc
)
8156 if (single_step_breakpoints
[0] == NULL
)
8157 bpt_p
= &single_step_breakpoints
[0];
8160 gdb_assert (single_step_breakpoints
[1] == NULL
);
8161 bpt_p
= &single_step_breakpoints
[1];
8164 /* NOTE drow/2006-04-11: A future improvement to this function would be
8165 to only create the breakpoints once, and actually put them on the
8166 breakpoint chain. That would let us use set_raw_breakpoint. We could
8167 adjust the addresses each time they were needed. Doing this requires
8168 corresponding changes elsewhere where single step breakpoints are
8169 handled, however. So, for now, we use this. */
8171 *bpt_p
= deprecated_insert_raw_breakpoint (next_pc
);
8173 error (_("Could not insert single-step breakpoint at 0x%s"),
8174 paddr_nz (next_pc
));
8177 /* Remove and delete any breakpoints used for software single step. */
8180 remove_single_step_breakpoints (void)
8182 gdb_assert (single_step_breakpoints
[0] != NULL
);
8184 /* See insert_single_step_breakpoint for more about this deprecated
8186 deprecated_remove_raw_breakpoint (single_step_breakpoints
[0]);
8187 single_step_breakpoints
[0] = NULL
;
8189 if (single_step_breakpoints
[1] != NULL
)
8191 deprecated_remove_raw_breakpoint (single_step_breakpoints
[1]);
8192 single_step_breakpoints
[1] = NULL
;
8196 /* Check whether a software single-step breakpoint is inserted at PC. */
8199 single_step_breakpoint_inserted_here_p (CORE_ADDR pc
)
8203 for (i
= 0; i
< 2; i
++)
8205 struct bp_target_info
*bp_tgt
= single_step_breakpoints
[i
];
8206 if (bp_tgt
&& bp_tgt
->placed_address
== pc
)
8213 int breakpoints_always_inserted_mode (void)
8215 return always_inserted_mode
;
8219 /* This help string is used for the break, hbreak, tbreak and thbreak commands.
8220 It is defined as a macro to prevent duplication.
8221 COMMAND should be a string constant containing the name of the command. */
8222 #define BREAK_ARGS_HELP(command) \
8223 command" [LOCATION] [thread THREADNUM] [if CONDITION]\n\
8224 LOCATION may be a line number, function name, or \"*\" and an address.\n\
8225 If a line number is specified, break at start of code for that line.\n\
8226 If a function is specified, break at start of code for that function.\n\
8227 If an address is specified, break at that exact address.\n\
8228 With no LOCATION, uses current execution address of selected stack frame.\n\
8229 This is useful for breaking on return to a stack frame.\n\
8231 THREADNUM is the number from \"info threads\".\n\
8232 CONDITION is a boolean expression.\n\
8234 Multiple breakpoints at one place are permitted, and useful if conditional.\n\
8236 Do \"help breakpoints\" for info on other commands dealing with breakpoints."
8239 _initialize_breakpoint (void)
8241 static struct cmd_list_element
*breakpoint_set_cmdlist
;
8242 static struct cmd_list_element
*breakpoint_show_cmdlist
;
8243 struct cmd_list_element
*c
;
8245 observer_attach_solib_unloaded (disable_breakpoints_in_unloaded_shlib
);
8247 breakpoint_chain
= 0;
8248 /* Don't bother to call set_breakpoint_count. $bpnum isn't useful
8249 before a breakpoint is set. */
8250 breakpoint_count
= 0;
8252 add_com ("ignore", class_breakpoint
, ignore_command
, _("\
8253 Set ignore-count of breakpoint number N to COUNT.\n\
8254 Usage is `ignore N COUNT'."));
8256 add_com_alias ("bc", "ignore", class_breakpoint
, 1);
8258 add_com ("commands", class_breakpoint
, commands_command
, _("\
8259 Set commands to be executed when a breakpoint is hit.\n\
8260 Give breakpoint number as argument after \"commands\".\n\
8261 With no argument, the targeted breakpoint is the last one set.\n\
8262 The commands themselves follow starting on the next line.\n\
8263 Type a line containing \"end\" to indicate the end of them.\n\
8264 Give \"silent\" as the first line to make the breakpoint silent;\n\
8265 then no output is printed when it is hit, except what the commands print."));
8267 add_com ("condition", class_breakpoint
, condition_command
, _("\
8268 Specify breakpoint number N to break only if COND is true.\n\
8269 Usage is `condition N COND', where N is an integer and COND is an\n\
8270 expression to be evaluated whenever breakpoint N is reached."));
8272 c
= add_com ("tbreak", class_breakpoint
, tbreak_command
, _("\
8273 Set a temporary breakpoint.\n\
8274 Like \"break\" except the breakpoint is only temporary,\n\
8275 so it will be deleted when hit. Equivalent to \"break\" followed\n\
8276 by using \"enable delete\" on the breakpoint number.\n\
8278 BREAK_ARGS_HELP ("tbreak")));
8279 set_cmd_completer (c
, location_completer
);
8281 c
= add_com ("hbreak", class_breakpoint
, hbreak_command
, _("\
8282 Set a hardware assisted breakpoint.\n\
8283 Like \"break\" except the breakpoint requires hardware support,\n\
8284 some target hardware may not have this support.\n\
8286 BREAK_ARGS_HELP ("hbreak")));
8287 set_cmd_completer (c
, location_completer
);
8289 c
= add_com ("thbreak", class_breakpoint
, thbreak_command
, _("\
8290 Set a temporary hardware assisted breakpoint.\n\
8291 Like \"hbreak\" except the breakpoint is only temporary,\n\
8292 so it will be deleted when hit.\n\
8294 BREAK_ARGS_HELP ("thbreak")));
8295 set_cmd_completer (c
, location_completer
);
8297 add_prefix_cmd ("enable", class_breakpoint
, enable_command
, _("\
8298 Enable some breakpoints.\n\
8299 Give breakpoint numbers (separated by spaces) as arguments.\n\
8300 With no subcommand, breakpoints are enabled until you command otherwise.\n\
8301 This is used to cancel the effect of the \"disable\" command.\n\
8302 With a subcommand you can enable temporarily."),
8303 &enablelist
, "enable ", 1, &cmdlist
);
8305 add_com ("ab", class_breakpoint
, enable_command
, _("\
8306 Enable some breakpoints.\n\
8307 Give breakpoint numbers (separated by spaces) as arguments.\n\
8308 With no subcommand, breakpoints are enabled until you command otherwise.\n\
8309 This is used to cancel the effect of the \"disable\" command.\n\
8310 With a subcommand you can enable temporarily."));
8312 add_com_alias ("en", "enable", class_breakpoint
, 1);
8314 add_abbrev_prefix_cmd ("breakpoints", class_breakpoint
, enable_command
, _("\
8315 Enable some breakpoints.\n\
8316 Give breakpoint numbers (separated by spaces) as arguments.\n\
8317 This is used to cancel the effect of the \"disable\" command.\n\
8318 May be abbreviated to simply \"enable\".\n"),
8319 &enablebreaklist
, "enable breakpoints ", 1, &enablelist
);
8321 add_cmd ("once", no_class
, enable_once_command
, _("\
8322 Enable breakpoints for one hit. Give breakpoint numbers.\n\
8323 If a breakpoint is hit while enabled in this fashion, it becomes disabled."),
8326 add_cmd ("delete", no_class
, enable_delete_command
, _("\
8327 Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
8328 If a breakpoint is hit while enabled in this fashion, it is deleted."),
8331 add_cmd ("delete", no_class
, enable_delete_command
, _("\
8332 Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
8333 If a breakpoint is hit while enabled in this fashion, it is deleted."),
8336 add_cmd ("once", no_class
, enable_once_command
, _("\
8337 Enable breakpoints for one hit. Give breakpoint numbers.\n\
8338 If a breakpoint is hit while enabled in this fashion, it becomes disabled."),
8341 add_prefix_cmd ("disable", class_breakpoint
, disable_command
, _("\
8342 Disable some breakpoints.\n\
8343 Arguments are breakpoint numbers with spaces in between.\n\
8344 To disable all breakpoints, give no argument.\n\
8345 A disabled breakpoint is not forgotten, but has no effect until reenabled."),
8346 &disablelist
, "disable ", 1, &cmdlist
);
8347 add_com_alias ("dis", "disable", class_breakpoint
, 1);
8348 add_com_alias ("disa", "disable", class_breakpoint
, 1);
8350 add_com ("sb", class_breakpoint
, disable_command
, _("\
8351 Disable some breakpoints.\n\
8352 Arguments are breakpoint numbers with spaces in between.\n\
8353 To disable all breakpoints, give no argument.\n\
8354 A disabled breakpoint is not forgotten, but has no effect until reenabled."));
8356 add_cmd ("breakpoints", class_alias
, disable_command
, _("\
8357 Disable some breakpoints.\n\
8358 Arguments are breakpoint numbers with spaces in between.\n\
8359 To disable all breakpoints, give no argument.\n\
8360 A disabled breakpoint is not forgotten, but has no effect until reenabled.\n\
8361 This command may be abbreviated \"disable\"."),
8364 add_prefix_cmd ("delete", class_breakpoint
, delete_command
, _("\
8365 Delete some breakpoints or auto-display expressions.\n\
8366 Arguments are breakpoint numbers with spaces in between.\n\
8367 To delete all breakpoints, give no argument.\n\
8369 Also a prefix command for deletion of other GDB objects.\n\
8370 The \"unset\" command is also an alias for \"delete\"."),
8371 &deletelist
, "delete ", 1, &cmdlist
);
8372 add_com_alias ("d", "delete", class_breakpoint
, 1);
8373 add_com_alias ("del", "delete", class_breakpoint
, 1);
8375 add_com ("db", class_breakpoint
, delete_command
, _("\
8376 Delete some breakpoints.\n\
8377 Arguments are breakpoint numbers with spaces in between.\n\
8378 To delete all breakpoints, give no argument.\n"));
8380 add_cmd ("breakpoints", class_alias
, delete_command
, _("\
8381 Delete some breakpoints or auto-display expressions.\n\
8382 Arguments are breakpoint numbers with spaces in between.\n\
8383 To delete all breakpoints, give no argument.\n\
8384 This command may be abbreviated \"delete\"."),
8387 add_com ("clear", class_breakpoint
, clear_command
, _("\
8388 Clear breakpoint at specified line or function.\n\
8389 Argument may be line number, function name, or \"*\" and an address.\n\
8390 If line number is specified, all breakpoints in that line are cleared.\n\
8391 If function is specified, breakpoints at beginning of function are cleared.\n\
8392 If an address is specified, breakpoints at that address are cleared.\n\
8394 With no argument, clears all breakpoints in the line that the selected frame\n\
8397 See also the \"delete\" command which clears breakpoints by number."));
8399 c
= add_com ("break", class_breakpoint
, break_command
, _("\
8400 Set breakpoint at specified line or function.\n"
8401 BREAK_ARGS_HELP ("break")));
8402 set_cmd_completer (c
, location_completer
);
8404 add_com_alias ("b", "break", class_run
, 1);
8405 add_com_alias ("br", "break", class_run
, 1);
8406 add_com_alias ("bre", "break", class_run
, 1);
8407 add_com_alias ("brea", "break", class_run
, 1);
8411 add_com_alias ("ba", "break", class_breakpoint
, 1);
8412 add_com_alias ("bu", "ubreak", class_breakpoint
, 1);
8417 add_abbrev_prefix_cmd ("stop", class_breakpoint
, stop_command
, _("\
8418 Break in function/address or break at a line in the current file."),
8419 &stoplist
, "stop ", 1, &cmdlist
);
8420 add_cmd ("in", class_breakpoint
, stopin_command
,
8421 _("Break in function or address."), &stoplist
);
8422 add_cmd ("at", class_breakpoint
, stopat_command
,
8423 _("Break at a line in the current file."), &stoplist
);
8424 add_com ("status", class_info
, breakpoints_info
, _("\
8425 Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
8426 The \"Type\" column indicates one of:\n\
8427 \tbreakpoint - normal breakpoint\n\
8428 \twatchpoint - watchpoint\n\
8429 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
8430 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
8431 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
8432 address and file/line number respectively.\n\
8434 Convenience variable \"$_\" and default examine address for \"x\"\n\
8435 are set to the address of the last breakpoint listed unless the command\n\
8436 is prefixed with \"server \".\n\n\
8437 Convenience variable \"$bpnum\" contains the number of the last\n\
8441 add_info ("breakpoints", breakpoints_info
, _("\
8442 Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
8443 The \"Type\" column indicates one of:\n\
8444 \tbreakpoint - normal breakpoint\n\
8445 \twatchpoint - watchpoint\n\
8446 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
8447 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
8448 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
8449 address and file/line number respectively.\n\
8451 Convenience variable \"$_\" and default examine address for \"x\"\n\
8452 are set to the address of the last breakpoint listed unless the command\n\
8453 is prefixed with \"server \".\n\n\
8454 Convenience variable \"$bpnum\" contains the number of the last\n\
8458 add_com ("lb", class_breakpoint
, breakpoints_info
, _("\
8459 Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
8460 The \"Type\" column indicates one of:\n\
8461 \tbreakpoint - normal breakpoint\n\
8462 \twatchpoint - watchpoint\n\
8463 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
8464 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
8465 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
8466 address and file/line number respectively.\n\
8468 Convenience variable \"$_\" and default examine address for \"x\"\n\
8469 are set to the address of the last breakpoint listed unless the command\n\
8470 is prefixed with \"server \".\n\n\
8471 Convenience variable \"$bpnum\" contains the number of the last\n\
8474 add_cmd ("breakpoints", class_maintenance
, maintenance_info_breakpoints
, _("\
8475 Status of all breakpoints, or breakpoint number NUMBER.\n\
8476 The \"Type\" column indicates one of:\n\
8477 \tbreakpoint - normal breakpoint\n\
8478 \twatchpoint - watchpoint\n\
8479 \tlongjmp - internal breakpoint used to step through longjmp()\n\
8480 \tlongjmp resume - internal breakpoint at the target of longjmp()\n\
8481 \tuntil - internal breakpoint used by the \"until\" command\n\
8482 \tfinish - internal breakpoint used by the \"finish\" command\n\
8483 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
8484 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
8485 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
8486 address and file/line number respectively.\n\
8488 Convenience variable \"$_\" and default examine address for \"x\"\n\
8489 are set to the address of the last breakpoint listed unless the command\n\
8490 is prefixed with \"server \".\n\n\
8491 Convenience variable \"$bpnum\" contains the number of the last\n\
8493 &maintenanceinfolist
);
8495 add_com ("catch", class_breakpoint
, catch_command
, _("\
8496 Set catchpoints to catch events.\n\
8497 Raised signals may be caught:\n\
8498 \tcatch signal - all signals\n\
8499 \tcatch signal <signame> - a particular signal\n\
8500 Raised exceptions may be caught:\n\
8501 \tcatch throw - all exceptions, when thrown\n\
8502 \tcatch throw <exceptname> - a particular exception, when thrown\n\
8503 \tcatch catch - all exceptions, when caught\n\
8504 \tcatch catch <exceptname> - a particular exception, when caught\n\
8505 Thread or process events may be caught:\n\
8506 \tcatch thread_start - any threads, just after creation\n\
8507 \tcatch thread_exit - any threads, just before expiration\n\
8508 \tcatch thread_join - any threads, just after joins\n\
8509 Process events may be caught:\n\
8510 \tcatch start - any processes, just after creation\n\
8511 \tcatch exit - any processes, just before expiration\n\
8512 \tcatch fork - calls to fork()\n\
8513 \tcatch vfork - calls to vfork()\n\
8514 \tcatch exec - calls to exec()\n\
8515 Dynamically-linked library events may be caught:\n\
8516 \tcatch load - loads of any library\n\
8517 \tcatch load <libname> - loads of a particular library\n\
8518 \tcatch unload - unloads of any library\n\
8519 \tcatch unload <libname> - unloads of a particular library\n\
8520 The act of your program's execution stopping may also be caught:\n\
8522 C++ exceptions may be caught:\n\
8523 \tcatch throw - all exceptions, when thrown\n\
8524 \tcatch catch - all exceptions, when caught\n\
8525 Ada exceptions may be caught:\n\
8526 \tcatch exception - all exceptions, when raised\n\
8527 \tcatch exception <name> - a particular exception, when raised\n\
8528 \tcatch exception unhandled - all unhandled exceptions, when raised\n\
8529 \tcatch assert - all failed assertions, when raised\n\
8531 Do \"help set follow-fork-mode\" for info on debugging your program\n\
8532 after a fork or vfork is caught.\n\n\
8533 Do \"help breakpoints\" for info on other commands dealing with breakpoints."));
8535 add_com ("tcatch", class_breakpoint
, tcatch_command
, _("\
8536 Set temporary catchpoints to catch events.\n\
8537 Args like \"catch\" command.\n\
8538 Like \"catch\" except the catchpoint is only temporary,\n\
8539 so it will be deleted when hit. Equivalent to \"catch\" followed\n\
8540 by using \"enable delete\" on the catchpoint number."));
8542 c
= add_com ("watch", class_breakpoint
, watch_command
, _("\
8543 Set a watchpoint for an expression.\n\
8544 A watchpoint stops execution of your program whenever the value of\n\
8545 an expression changes."));
8546 set_cmd_completer (c
, expression_completer
);
8548 c
= add_com ("rwatch", class_breakpoint
, rwatch_command
, _("\
8549 Set a read watchpoint for an expression.\n\
8550 A watchpoint stops execution of your program whenever the value of\n\
8551 an expression is read."));
8552 set_cmd_completer (c
, expression_completer
);
8554 c
= add_com ("awatch", class_breakpoint
, awatch_command
, _("\
8555 Set a watchpoint for an expression.\n\
8556 A watchpoint stops execution of your program whenever the value of\n\
8557 an expression is either read or written."));
8558 set_cmd_completer (c
, expression_completer
);
8560 add_info ("watchpoints", breakpoints_info
,
8561 _("Synonym for ``info breakpoints''."));
8564 /* XXX: cagney/2005-02-23: This should be a boolean, and should
8565 respond to changes - contrary to the description. */
8566 add_setshow_zinteger_cmd ("can-use-hw-watchpoints", class_support
,
8567 &can_use_hw_watchpoints
, _("\
8568 Set debugger's willingness to use watchpoint hardware."), _("\
8569 Show debugger's willingness to use watchpoint hardware."), _("\
8570 If zero, gdb will not use hardware for new watchpoints, even if\n\
8571 such is available. (However, any hardware watchpoints that were\n\
8572 created before setting this to nonzero, will continue to use watchpoint\n\
8575 show_can_use_hw_watchpoints
,
8576 &setlist
, &showlist
);
8578 can_use_hw_watchpoints
= 1;
8580 add_prefix_cmd ("breakpoint", class_maintenance
, set_breakpoint_cmd
, _("\
8581 Breakpoint specific settings\n\
8582 Configure various breakpoint-specific variables such as\n\
8583 pending breakpoint behavior"),
8584 &breakpoint_set_cmdlist
, "set breakpoint ",
8585 0/*allow-unknown*/, &setlist
);
8586 add_prefix_cmd ("breakpoint", class_maintenance
, show_breakpoint_cmd
, _("\
8587 Breakpoint specific settings\n\
8588 Configure various breakpoint-specific variables such as\n\
8589 pending breakpoint behavior"),
8590 &breakpoint_show_cmdlist
, "show breakpoint ",
8591 0/*allow-unknown*/, &showlist
);
8593 add_setshow_auto_boolean_cmd ("pending", no_class
,
8594 &pending_break_support
, _("\
8595 Set debugger's behavior regarding pending breakpoints."), _("\
8596 Show debugger's behavior regarding pending breakpoints."), _("\
8597 If on, an unrecognized breakpoint location will cause gdb to create a\n\
8598 pending breakpoint. If off, an unrecognized breakpoint location results in\n\
8599 an error. If auto, an unrecognized breakpoint location results in a\n\
8600 user-query to see if a pending breakpoint should be created."),
8602 show_pending_break_support
,
8603 &breakpoint_set_cmdlist
,
8604 &breakpoint_show_cmdlist
);
8606 pending_break_support
= AUTO_BOOLEAN_AUTO
;
8608 add_setshow_boolean_cmd ("auto-hw", no_class
,
8609 &automatic_hardware_breakpoints
, _("\
8610 Set automatic usage of hardware breakpoints."), _("\
8611 Show automatic usage of hardware breakpoints."), _("\
8612 If set, the debugger will automatically use hardware breakpoints for\n\
8613 breakpoints set with \"break\" but falling in read-only memory. If not set,\n\
8614 a warning will be emitted for such breakpoints."),
8616 show_automatic_hardware_breakpoints
,
8617 &breakpoint_set_cmdlist
,
8618 &breakpoint_show_cmdlist
);
8620 add_setshow_boolean_cmd ("always-inserted", class_support
,
8621 &always_inserted_mode
, _("\
8622 Set mode for inserting breakpoints."), _("\
8623 Show mode for inserting breakpoints."), _("\
8624 When this mode is off (which is the default), breakpoints are inserted in\n\
8625 inferior when it is resumed, and removed when execution stops. When this\n\
8626 mode is on, breakpoints are inserted immediately and removed only when\n\
8627 the user deletes the breakpoint."),
8629 &show_always_inserted_mode
,
8630 &breakpoint_set_cmdlist
,
8631 &breakpoint_show_cmdlist
);
8633 automatic_hardware_breakpoints
= 1;