1 /* Everything about breakpoints, for GDB.
3 Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994,
4 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005
5 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 2 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, write to the Free Software
21 Foundation, Inc., 59 Temple Place - Suite 330,
22 Boston, MA 02111-1307, USA. */
28 #include "breakpoint.h"
30 #include "expression.h"
36 #include "gdbthread.h"
39 #include "gdb_string.h"
46 #include "completer.h"
49 #include "cli/cli-script.h"
50 #include "gdb_assert.h"
55 #include "exceptions.h"
57 #include "gdb-events.h"
59 /* Prototypes for local functions. */
61 static void until_break_command_continuation (struct continuation_arg
*arg
);
63 static void catch_command_1 (char *, int, int);
65 static void enable_delete_command (char *, int);
67 static void enable_delete_breakpoint (struct breakpoint
*);
69 static void enable_once_command (char *, int);
71 static void enable_once_breakpoint (struct breakpoint
*);
73 static void disable_command (char *, int);
75 static void enable_command (char *, int);
77 static void map_breakpoint_numbers (char *, void (*)(struct breakpoint
*));
79 static void ignore_command (char *, int);
81 static int breakpoint_re_set_one (void *);
83 static void clear_command (char *, int);
85 static void catch_command (char *, int);
87 static void watch_command (char *, int);
89 static int can_use_hardware_watchpoint (struct value
*);
91 static int break_command_1 (char *, int, int, struct breakpoint
*);
93 static void mention (struct breakpoint
*);
95 struct breakpoint
*set_raw_breakpoint (struct symtab_and_line
, enum bptype
);
97 static void check_duplicates (struct breakpoint
*);
99 static void breakpoint_adjustment_warning (CORE_ADDR
, CORE_ADDR
, int, int);
101 static CORE_ADDR
adjust_breakpoint_address (CORE_ADDR bpaddr
,
104 static void describe_other_breakpoints (CORE_ADDR
, asection
*);
106 static void breakpoints_info (char *, int);
108 static void breakpoint_1 (int, int);
110 static bpstat
bpstat_alloc (struct breakpoint
*, bpstat
);
112 static int breakpoint_cond_eval (void *);
114 static void cleanup_executing_breakpoints (void *);
116 static void commands_command (char *, int);
118 static void condition_command (char *, int);
120 static int get_number_trailer (char **, int);
122 void set_breakpoint_count (int);
131 static int remove_breakpoint (struct bp_location
*, insertion_state_t
);
133 static enum print_stop_action
print_it_typical (bpstat
);
135 static enum print_stop_action
print_bp_stop_message (bpstat bs
);
139 enum exception_event_kind kind
;
142 args_for_catchpoint_enable
;
144 static int watchpoint_check (void *);
146 static int cover_target_enable_exception_callback (void *);
148 static void maintenance_info_breakpoints (char *, int);
150 static void create_longjmp_breakpoint (char *);
152 static void create_overlay_event_breakpoint (char *);
154 static int hw_breakpoint_used_count (void);
156 static int hw_watchpoint_used_count (enum bptype
, int *);
158 static void hbreak_command (char *, int);
160 static void thbreak_command (char *, int);
162 static void watch_command_1 (char *, int, int);
164 static void rwatch_command (char *, int);
166 static void awatch_command (char *, int);
168 static void do_enable_breakpoint (struct breakpoint
*, enum bpdisp
);
170 static void solib_load_unload_1 (char *hookname
,
173 char *cond_string
, enum bptype bp_kind
);
175 static void create_fork_vfork_event_catchpoint (int tempflag
,
177 enum bptype bp_kind
);
179 static void stop_command (char *arg
, int from_tty
);
181 static void stopin_command (char *arg
, int from_tty
);
183 static void stopat_command (char *arg
, int from_tty
);
185 static char *ep_find_event_name_end (char *arg
);
187 static char *ep_parse_optional_if_clause (char **arg
);
189 static char *ep_parse_optional_filename (char **arg
);
191 static void create_exception_catchpoint (int tempflag
, char *cond_string
,
192 enum exception_event_kind ex_event
,
193 struct symtab_and_line
*sal
);
195 static void catch_exception_command_1 (enum exception_event_kind ex_event
,
196 char *arg
, int tempflag
, int from_tty
);
198 static void tcatch_command (char *arg
, int from_tty
);
200 static void ep_skip_leading_whitespace (char **s
);
202 /* Prototypes for exported functions. */
204 /* If FALSE, gdb will not use hardware support for watchpoints, even
205 if such is available. */
206 static int can_use_hw_watchpoints
;
209 show_can_use_hw_watchpoints (struct ui_file
*file
, int from_tty
,
210 struct cmd_list_element
*c
,
213 fprintf_filtered (file
, _("\
214 Debugger's willingness to use watchpoint hardware is %s.\n"),
218 /* If AUTO_BOOLEAN_FALSE, gdb will not attempt to create pending breakpoints.
219 If AUTO_BOOLEAN_TRUE, gdb will automatically create pending breakpoints
220 for unrecognized breakpoint locations.
221 If AUTO_BOOLEAN_AUTO, gdb will query when breakpoints are unrecognized. */
222 static enum auto_boolean pending_break_support
;
224 show_pending_break_support (struct ui_file
*file
, int from_tty
,
225 struct cmd_list_element
*c
,
228 fprintf_filtered (file
, _("\
229 Debugger's behavior regarding pending breakpoints is %s.\n"),
233 void _initialize_breakpoint (void);
235 extern int addressprint
; /* Print machine addresses? */
237 /* Are we executing breakpoint commands? */
238 static int executing_breakpoint_commands
;
240 /* Are overlay event breakpoints enabled? */
241 static int overlay_events_enabled
;
243 /* Walk the following statement or block through all breakpoints.
244 ALL_BREAKPOINTS_SAFE does so even if the statment deletes the current
247 #define ALL_BREAKPOINTS(B) for (B = breakpoint_chain; B; B = B->next)
249 #define ALL_BREAKPOINTS_SAFE(B,TMP) \
250 for (B = breakpoint_chain; \
251 B ? (TMP=B->next, 1): 0; \
254 /* Similar iterators for the low-level breakpoints. */
256 #define ALL_BP_LOCATIONS(B) for (B = bp_location_chain; B; B = B->next)
258 #define ALL_BP_LOCATIONS_SAFE(B,TMP) \
259 for (B = bp_location_chain; \
260 B ? (TMP=B->next, 1): 0; \
263 /* True if breakpoint hit counts should be displayed in breakpoint info. */
265 int show_breakpoint_hit_counts
= 1;
267 /* Chains of all breakpoints defined. */
269 struct breakpoint
*breakpoint_chain
;
271 struct bp_location
*bp_location_chain
;
273 /* Number of last breakpoint made. */
275 int breakpoint_count
;
277 /* Pointer to current exception event record */
278 static struct exception_event_record
*current_exception_event
;
280 /* Indicator of whether exception catchpoints should be nuked between
281 runs of a program. */
282 int deprecated_exception_catchpoints_are_fragile
= 0;
284 /* Indicator of when exception catchpoints set-up should be
285 reinitialized -- e.g. when program is re-run. */
286 int deprecated_exception_support_initialized
= 0;
288 /* This function returns a pointer to the string representation of the
289 pathname of the dynamically-linked library that has just been
292 This function must be used only when SOLIB_HAVE_LOAD_EVENT is TRUE,
293 or undefined results are guaranteed.
295 This string's contents are only valid immediately after the
296 inferior has stopped in the dynamic linker hook, and becomes
297 invalid as soon as the inferior is continued. Clients should make
298 a copy of this string if they wish to continue the inferior and
299 then access the string. */
301 #ifndef SOLIB_LOADED_LIBRARY_PATHNAME
302 #define SOLIB_LOADED_LIBRARY_PATHNAME(pid) ""
305 /* This function returns a pointer to the string representation of the
306 pathname of the dynamically-linked library that has just been
309 This function must be used only when SOLIB_HAVE_UNLOAD_EVENT is
310 TRUE, or undefined results are guaranteed.
312 This string's contents are only valid immediately after the
313 inferior has stopped in the dynamic linker hook, and becomes
314 invalid as soon as the inferior is continued. Clients should make
315 a copy of this string if they wish to continue the inferior and
316 then access the string. */
318 #ifndef SOLIB_UNLOADED_LIBRARY_PATHNAME
319 #define SOLIB_UNLOADED_LIBRARY_PATHNAME(pid) ""
322 /* This function is called by the "catch load" command. It allows the
323 debugger to be notified by the dynamic linker when a specified
324 library file (or any library file, if filename is NULL) is loaded. */
326 #ifndef SOLIB_CREATE_CATCH_LOAD_HOOK
327 #define SOLIB_CREATE_CATCH_LOAD_HOOK(pid,tempflag,filename,cond_string) \
328 error (_("catch of library loads not yet implemented on this platform"))
331 /* This function is called by the "catch unload" command. It allows
332 the debugger to be notified by the dynamic linker when a specified
333 library file (or any library file, if filename is NULL) is
336 #ifndef SOLIB_CREATE_CATCH_UNLOAD_HOOK
337 #define SOLIB_CREATE_CATCH_UNLOAD_HOOK(pid, tempflag, filename, cond_string) \
338 error (_("catch of library unloads not yet implemented on this platform"))
341 /* Return whether a breakpoint is an active enabled breakpoint. */
343 breakpoint_enabled (struct breakpoint
*b
)
345 return (b
->enable_state
== bp_enabled
&& !b
->pending
);
348 /* Set breakpoint count to NUM. */
351 set_breakpoint_count (int num
)
353 breakpoint_count
= num
;
354 set_internalvar (lookup_internalvar ("bpnum"),
355 value_from_longest (builtin_type_int
, (LONGEST
) num
));
358 /* Used in run_command to zero the hit count when a new run starts. */
361 clear_breakpoint_hit_counts (void)
363 struct breakpoint
*b
;
369 /* Default address, symtab and line to put a breakpoint at
370 for "break" command with no arg.
371 if default_breakpoint_valid is zero, the other three are
372 not valid, and "break" with no arg is an error.
374 This set by print_stack_frame, which calls set_default_breakpoint. */
376 int default_breakpoint_valid
;
377 CORE_ADDR default_breakpoint_address
;
378 struct symtab
*default_breakpoint_symtab
;
379 int default_breakpoint_line
;
381 /* *PP is a string denoting a breakpoint. Get the number of the breakpoint.
382 Advance *PP after the string and any trailing whitespace.
384 Currently the string can either be a number or "$" followed by the name
385 of a convenience variable. Making it an expression wouldn't work well
386 for map_breakpoint_numbers (e.g. "4 + 5 + 6").
388 TRAILER is a character which can be found after the number; most
389 commonly this is `-'. If you don't want a trailer, use \0. */
391 get_number_trailer (char **pp
, int trailer
)
393 int retval
= 0; /* default */
397 /* Empty line means refer to the last breakpoint. */
398 return breakpoint_count
;
401 /* Make a copy of the name, so we can null-terminate it
402 to pass to lookup_internalvar(). */
407 while (isalnum (*p
) || *p
== '_')
409 varname
= (char *) alloca (p
- start
+ 1);
410 strncpy (varname
, start
, p
- start
);
411 varname
[p
- start
] = '\0';
412 val
= value_of_internalvar (lookup_internalvar (varname
));
413 if (TYPE_CODE (value_type (val
)) == TYPE_CODE_INT
)
414 retval
= (int) value_as_long (val
);
417 printf_filtered (_("Convenience variable must have integer value.\n"));
425 while (*p
>= '0' && *p
<= '9')
428 /* There is no number here. (e.g. "cond a == b"). */
430 /* Skip non-numeric token */
431 while (*p
&& !isspace((int) *p
))
433 /* Return zero, which caller must interpret as error. */
439 if (!(isspace (*p
) || *p
== '\0' || *p
== trailer
))
441 /* Trailing junk: return 0 and let caller print error msg. */
442 while (!(isspace (*p
) || *p
== '\0' || *p
== trailer
))
453 /* Like get_number_trailer, but don't allow a trailer. */
455 get_number (char **pp
)
457 return get_number_trailer (pp
, '\0');
460 /* Parse a number or a range.
461 * A number will be of the form handled by get_number.
462 * A range will be of the form <number1> - <number2>, and
463 * will represent all the integers between number1 and number2,
466 * While processing a range, this fuction is called iteratively;
467 * At each call it will return the next value in the range.
469 * At the beginning of parsing a range, the char pointer PP will
470 * be advanced past <number1> and left pointing at the '-' token.
471 * Subsequent calls will not advance the pointer until the range
472 * is completed. The call that completes the range will advance
473 * pointer PP past <number2>.
477 get_number_or_range (char **pp
)
479 static int last_retval
, end_value
;
480 static char *end_ptr
;
481 static int in_range
= 0;
485 /* Default case: pp is pointing either to a solo number,
486 or to the first number of a range. */
487 last_retval
= get_number_trailer (pp
, '-');
492 /* This is the start of a range (<number1> - <number2>).
493 Skip the '-', parse and remember the second number,
494 and also remember the end of the final token. */
498 while (isspace ((int) *end_ptr
))
499 end_ptr
++; /* skip white space */
500 end_value
= get_number (temp
);
501 if (end_value
< last_retval
)
503 error (_("inverted range"));
505 else if (end_value
== last_retval
)
507 /* degenerate range (number1 == number2). Advance the
508 token pointer so that the range will be treated as a
517 error (_("negative value"));
520 /* pp points to the '-' that betokens a range. All
521 number-parsing has already been done. Return the next
522 integer value (one greater than the saved previous value).
523 Do not advance the token pointer 'pp' until the end of range
526 if (++last_retval
== end_value
)
528 /* End of range reached; advance token pointer. */
538 /* condition N EXP -- set break condition of breakpoint N to EXP. */
541 condition_command (char *arg
, int from_tty
)
543 struct breakpoint
*b
;
548 error_no_arg (_("breakpoint number"));
551 bnum
= get_number (&p
);
553 error (_("Bad breakpoint argument: '%s'"), arg
);
556 if (b
->number
== bnum
)
563 if (b
->cond_string
!= NULL
)
564 xfree (b
->cond_string
);
569 b
->cond_string
= NULL
;
571 printf_filtered (_("Breakpoint %d now unconditional.\n"), bnum
);
576 /* I don't know if it matters whether this is the string the user
577 typed in or the decompiled expression. */
578 b
->cond_string
= savestring (arg
, strlen (arg
));
581 b
->cond
= parse_exp_1 (&arg
, block_for_pc (b
->loc
->address
), 0);
583 error (_("Junk at end of expression"));
586 breakpoints_changed ();
587 breakpoint_modify_event (b
->number
);
591 error (_("No breakpoint number %d."), bnum
);
595 commands_command (char *arg
, int from_tty
)
597 struct breakpoint
*b
;
600 struct command_line
*l
;
602 /* If we allowed this, we would have problems with when to
603 free the storage, if we change the commands currently
606 if (executing_breakpoint_commands
)
607 error (_("Can't use the \"commands\" command among a breakpoint's commands."));
610 bnum
= get_number (&p
);
613 error (_("Unexpected extra arguments following breakpoint number."));
616 if (b
->number
== bnum
)
618 char *tmpbuf
= xstrprintf ("Type commands for when breakpoint %d is hit, one per line.",
620 struct cleanup
*cleanups
= make_cleanup (xfree
, tmpbuf
);
621 l
= read_command_lines (tmpbuf
, from_tty
);
622 do_cleanups (cleanups
);
623 free_command_lines (&b
->commands
);
625 breakpoints_changed ();
626 breakpoint_modify_event (b
->number
);
629 error (_("No breakpoint number %d."), bnum
);
632 /* Like target_read_memory() but if breakpoints are inserted, return
633 the shadow contents instead of the breakpoints themselves.
635 Read "memory data" from whatever target or inferior we have.
636 Returns zero if successful, errno value if not. EIO is used
637 for address out of bounds. If breakpoints are inserted, returns
638 shadow contents, not the breakpoints themselves. From breakpoint.c. */
641 deprecated_read_memory_nobpt (CORE_ADDR memaddr
, gdb_byte
*myaddr
,
645 struct bp_location
*b
;
646 CORE_ADDR bp_addr
= 0;
649 if (BREAKPOINT_FROM_PC (&bp_addr
, &bp_size
) == NULL
)
650 /* No breakpoints on this machine. */
651 return target_read_memory (memaddr
, myaddr
, len
);
655 if (b
->owner
->type
== bp_none
)
656 warning (_("reading through apparently deleted breakpoint #%d?"),
659 if (b
->loc_type
!= bp_loc_software_breakpoint
)
663 /* Addresses and length of the part of the breakpoint that
665 /* XXXX The m68k, sh and h8300 have different local and remote
666 breakpoint values. BREAKPOINT_FROM_PC still manages to
667 correctly determine the breakpoints memory address and size
668 for these targets. */
669 bp_addr
= b
->address
;
671 if (BREAKPOINT_FROM_PC (&bp_addr
, &bp_size
) == NULL
)
676 if (bp_addr
+ bp_size
<= memaddr
)
677 /* The breakpoint is entirely before the chunk of memory we
680 if (bp_addr
>= memaddr
+ len
)
681 /* The breakpoint is entirely after the chunk of memory we are
684 /* Copy the breakpoint from the shadow contents, and recurse for
685 the things before and after. */
687 /* Offset within shadow_contents. */
690 if (bp_addr
< memaddr
)
692 /* Only copy the second part of the breakpoint. */
693 bp_size
-= memaddr
- bp_addr
;
694 bptoffset
= memaddr
- bp_addr
;
698 if (bp_addr
+ bp_size
> memaddr
+ len
)
700 /* Only copy the first part of the breakpoint. */
701 bp_size
-= (bp_addr
+ bp_size
) - (memaddr
+ len
);
704 memcpy (myaddr
+ bp_addr
- memaddr
,
705 b
->shadow_contents
+ bptoffset
, bp_size
);
707 if (bp_addr
> memaddr
)
709 /* Copy the section of memory before the breakpoint. */
710 status
= deprecated_read_memory_nobpt (memaddr
, myaddr
, bp_addr
- memaddr
);
715 if (bp_addr
+ bp_size
< memaddr
+ len
)
717 /* Copy the section of memory after the breakpoint. */
718 status
= deprecated_read_memory_nobpt (bp_addr
+ bp_size
,
719 myaddr
+ bp_addr
+ bp_size
- memaddr
,
720 memaddr
+ len
- (bp_addr
+ bp_size
));
727 /* Nothing overlaps. Just call read_memory_noerr. */
728 return target_read_memory (memaddr
, myaddr
, len
);
732 /* A wrapper function for inserting catchpoints. */
734 insert_catchpoint (struct ui_out
*uo
, void *args
)
736 struct breakpoint
*b
= (struct breakpoint
*) args
;
742 target_insert_fork_catchpoint (PIDGET (inferior_ptid
));
745 target_insert_vfork_catchpoint (PIDGET (inferior_ptid
));
748 target_insert_exec_catchpoint (PIDGET (inferior_ptid
));
751 internal_error (__FILE__
, __LINE__
, _("unknown breakpoint type"));
756 /* Helper routine: free the value chain for a breakpoint (watchpoint). */
758 static void free_valchain (struct bp_location
*b
)
763 /* Free the saved value chain. We will construct a new one
764 the next time the watchpoint is inserted. */
765 for (v
= b
->owner
->val_chain
; v
; v
= n
)
770 b
->owner
->val_chain
= NULL
;
773 /* Insert a low-level "breakpoint" of some type. BPT is the breakpoint.
774 Any error messages are printed to TMP_ERROR_STREAM; and DISABLED_BREAKS,
775 PROCESS_WARNING, and HW_BREAKPOINT_ERROR are used to report problems.
777 NOTE drow/2003-09-09: This routine could be broken down to an object-style
778 method for each breakpoint or catchpoint type. */
780 insert_bp_location (struct bp_location
*bpt
,
781 struct ui_file
*tmp_error_stream
,
782 int *disabled_breaks
, int *process_warning
,
783 int *hw_breakpoint_error
)
787 /* Permanent breakpoints cannot be inserted or removed. Disabled
788 breakpoints should not be inserted. */
789 if (!breakpoint_enabled (bpt
->owner
))
792 if (bpt
->inserted
|| bpt
->duplicate
)
795 if (bpt
->loc_type
== bp_loc_software_breakpoint
796 || bpt
->loc_type
== bp_loc_hardware_breakpoint
)
798 /* First check to see if we have to handle an overlay. */
799 if (overlay_debugging
== ovly_off
800 || bpt
->section
== NULL
801 || !(section_is_overlay (bpt
->section
)))
803 /* No overlay handling: just set the breakpoint. */
805 if (bpt
->loc_type
== bp_loc_hardware_breakpoint
)
806 val
= target_insert_hw_breakpoint (bpt
->address
,
807 bpt
->shadow_contents
);
809 val
= target_insert_breakpoint (bpt
->address
,
810 bpt
->shadow_contents
);
814 /* This breakpoint is in an overlay section.
815 Shall we set a breakpoint at the LMA? */
816 if (!overlay_events_enabled
)
818 /* Yes -- overlay event support is not active,
819 so we must try to set a breakpoint at the LMA.
820 This will not work for a hardware breakpoint. */
821 if (bpt
->loc_type
== bp_loc_hardware_breakpoint
)
822 warning (_("hardware breakpoint %d not supported in overlay!"),
826 CORE_ADDR addr
= overlay_unmapped_address (bpt
->address
,
828 /* Set a software (trap) breakpoint at the LMA. */
829 val
= target_insert_breakpoint (addr
, bpt
->shadow_contents
);
831 fprintf_unfiltered (tmp_error_stream
,
832 "Overlay breakpoint %d failed: in ROM?",
836 /* Shall we set a breakpoint at the VMA? */
837 if (section_is_mapped (bpt
->section
))
839 /* Yes. This overlay section is mapped into memory. */
840 if (bpt
->loc_type
== bp_loc_hardware_breakpoint
)
841 val
= target_insert_hw_breakpoint (bpt
->address
,
842 bpt
->shadow_contents
);
844 val
= target_insert_breakpoint (bpt
->address
,
845 bpt
->shadow_contents
);
849 /* No. This breakpoint will not be inserted.
850 No error, but do not mark the bp as 'inserted'. */
857 /* Can't set the breakpoint. */
859 #if defined (DISABLE_UNSETTABLE_BREAK)
860 DISABLE_UNSETTABLE_BREAK (bpt
->address
)
862 solib_address (bpt
->address
)
866 /* See also: disable_breakpoints_in_shlibs. */
868 bpt
->owner
->enable_state
= bp_shlib_disabled
;
869 if (!*disabled_breaks
)
871 fprintf_unfiltered (tmp_error_stream
,
872 "Cannot insert breakpoint %d.\n",
874 fprintf_unfiltered (tmp_error_stream
,
875 "Temporarily disabling shared library breakpoints:\n");
877 *disabled_breaks
= 1;
878 fprintf_unfiltered (tmp_error_stream
,
879 "breakpoint #%d\n", bpt
->owner
->number
);
883 #ifdef ONE_PROCESS_WRITETEXT
884 *process_warning
= 1;
886 if (bpt
->loc_type
== bp_loc_hardware_breakpoint
)
888 *hw_breakpoint_error
= 1;
889 fprintf_unfiltered (tmp_error_stream
,
890 "Cannot insert hardware breakpoint %d.\n",
895 fprintf_unfiltered (tmp_error_stream
,
896 "Cannot insert breakpoint %d.\n",
898 fprintf_filtered (tmp_error_stream
,
899 "Error accessing memory address ");
900 deprecated_print_address_numeric (bpt
->address
, 1, tmp_error_stream
);
901 fprintf_filtered (tmp_error_stream
, ": %s.\n",
902 safe_strerror (val
));
913 else if (bpt
->loc_type
== bp_loc_hardware_watchpoint
914 /* NOTE drow/2003-09-08: This state only exists for removing
915 watchpoints. It's not clear that it's necessary... */
916 && bpt
->owner
->disposition
!= disp_del_at_next_stop
)
918 /* FIXME drow/2003-09-08: This code sets multiple hardware watchpoints
919 based on the expression. Ideally this should happen at a higher level,
920 and there should be one bp_location for each computed address we
921 must watch. As soon as a many-to-one mapping is available I'll
924 int within_current_scope
;
925 struct value
*mark
= value_mark ();
927 struct frame_id saved_frame_id
;
929 /* Save the current frame's ID so we can restore it after
930 evaluating the watchpoint expression on its own frame. */
931 /* FIXME drow/2003-09-09: It would be nice if evaluate_expression
932 took a frame parameter, so that we didn't have to change the
934 saved_frame_id
= get_frame_id (deprecated_selected_frame
);
936 /* Determine if the watchpoint is within scope. */
937 if (bpt
->owner
->exp_valid_block
== NULL
)
938 within_current_scope
= 1;
941 struct frame_info
*fi
;
942 fi
= frame_find_by_id (bpt
->owner
->watchpoint_frame
);
943 within_current_scope
= (fi
!= NULL
);
944 if (within_current_scope
)
948 if (within_current_scope
)
952 /* Evaluate the expression and cut the chain of values
953 produced off from the value chain.
955 Make sure the value returned isn't lazy; we use
956 laziness to determine what memory GDB actually needed
957 in order to compute the value of the expression. */
958 v
= evaluate_expression (bpt
->owner
->exp
);
960 value_release_to_mark (mark
);
962 bpt
->owner
->val_chain
= v
;
965 /* Look at each value on the value chain. */
966 for (; v
; v
= value_next (v
))
968 /* If it's a memory location, and GDB actually needed
969 its contents to evaluate the expression, then we
971 if (VALUE_LVAL (v
) == lval_memory
974 struct type
*vtype
= check_typedef (value_type (v
));
976 /* We only watch structs and arrays if user asked
977 for it explicitly, never if they just happen to
978 appear in the middle of some value chain. */
979 if (v
== bpt
->owner
->val_chain
980 || (TYPE_CODE (vtype
) != TYPE_CODE_STRUCT
981 && TYPE_CODE (vtype
) != TYPE_CODE_ARRAY
))
986 addr
= VALUE_ADDRESS (v
) + value_offset (v
);
987 len
= TYPE_LENGTH (value_type (v
));
989 if (bpt
->owner
->type
== bp_read_watchpoint
)
991 else if (bpt
->owner
->type
== bp_access_watchpoint
)
994 val
= target_insert_watchpoint (addr
, len
, type
);
997 /* Don't exit the loop, try to insert
998 every value on the value chain. That's
999 because we will be removing all the
1000 watches below, and removing a
1001 watchpoint we didn't insert could have
1009 /* Failure to insert a watchpoint on any memory value in the
1010 value chain brings us here. */
1013 remove_breakpoint (bpt
, mark_uninserted
);
1014 *hw_breakpoint_error
= 1;
1015 fprintf_unfiltered (tmp_error_stream
,
1016 "Could not insert hardware watchpoint %d.\n",
1017 bpt
->owner
->number
);
1023 printf_filtered (_("\
1024 Hardware watchpoint %d deleted because the program has left the block \n\
1025 in which its expression is valid.\n"),
1026 bpt
->owner
->number
);
1027 if (bpt
->owner
->related_breakpoint
)
1028 bpt
->owner
->related_breakpoint
->disposition
= disp_del_at_next_stop
;
1029 bpt
->owner
->disposition
= disp_del_at_next_stop
;
1032 /* Restore the selected frame. */
1033 select_frame (frame_find_by_id (saved_frame_id
));
1038 else if (ep_is_exception_catchpoint (bpt
->owner
))
1040 /* FIXME drow/2003-09-09: This code sets both a catchpoint and a
1041 breakpoint. Once again, it would be better if this was represented
1042 as two bp_locations. */
1044 /* If we get here, we must have a callback mechanism for exception
1045 events -- with g++ style embedded label support, we insert
1046 ordinary breakpoints and not catchpoints. */
1047 val
= target_insert_breakpoint (bpt
->address
, bpt
->shadow_contents
);
1050 /* Couldn't set breakpoint for some reason */
1051 fprintf_unfiltered (tmp_error_stream
,
1052 "Cannot insert catchpoint %d; disabling it.\n",
1053 bpt
->owner
->number
);
1054 fprintf_filtered (tmp_error_stream
,
1055 "Error accessing memory address ");
1056 deprecated_print_address_numeric (bpt
->address
, 1, tmp_error_stream
);
1057 fprintf_filtered (tmp_error_stream
, ": %s.\n",
1058 safe_strerror (val
));
1059 bpt
->owner
->enable_state
= bp_disabled
;
1063 /* Bp set, now make sure callbacks are enabled */
1064 /* Format possible error msg */
1065 char *message
= xstrprintf ("Error inserting catchpoint %d:\n",
1066 bpt
->owner
->number
);
1067 struct cleanup
*cleanups
= make_cleanup (xfree
, message
);
1069 args_for_catchpoint_enable args
;
1070 args
.kind
= bpt
->owner
->type
== bp_catch_catch
?
1071 EX_EVENT_CATCH
: EX_EVENT_THROW
;
1073 val
= catch_errors (cover_target_enable_exception_callback
,
1074 &args
, message
, RETURN_MASK_ALL
);
1075 do_cleanups (cleanups
);
1076 if (val
!= 0 && val
!= -1)
1079 /* Check if something went wrong; val == 0 can be ignored */
1082 /* something went wrong */
1083 fprintf_unfiltered (tmp_error_stream
,
1084 "Cannot insert catchpoint %d; disabling it.\n",
1085 bpt
->owner
->number
);
1086 bpt
->owner
->enable_state
= bp_disabled
;
1093 else if (bpt
->owner
->type
== bp_catch_fork
1094 || bpt
->owner
->type
== bp_catch_vfork
1095 || bpt
->owner
->type
== bp_catch_exec
)
1097 struct gdb_exception e
= catch_exception (uiout
, insert_catchpoint
,
1098 bpt
->owner
, RETURN_MASK_ERROR
);
1099 exception_fprintf (gdb_stderr
, e
, "warning: inserting catchpoint %d: ",
1100 bpt
->owner
->number
);
1102 bpt
->owner
->enable_state
= bp_disabled
;
1106 /* We've already printed an error message if there was a problem
1107 inserting this catchpoint, and we've disabled the catchpoint,
1108 so just return success. */
1115 /* insert_breakpoints is used when starting or continuing the program.
1116 remove_breakpoints is used when the program stops.
1117 Both return zero if successful,
1118 or an `errno' value if could not write the inferior. */
1121 insert_breakpoints (void)
1123 struct bp_location
*b
, *temp
;
1124 int return_val
= 0; /* return success code. */
1126 int disabled_breaks
= 0;
1127 int hw_breakpoint_error
= 0;
1128 int process_warning
= 0;
1130 struct ui_file
*tmp_error_stream
= mem_fileopen ();
1131 make_cleanup_ui_file_delete (tmp_error_stream
);
1133 /* Explicitly mark the warning -- this will only be printed if
1134 there was an error. */
1135 fprintf_unfiltered (tmp_error_stream
, "Warning:\n");
1137 ALL_BP_LOCATIONS_SAFE (b
, temp
)
1139 /* Permanent breakpoints cannot be inserted or removed. Disabled
1140 breakpoints should not be inserted. */
1141 if (!breakpoint_enabled (b
->owner
))
1144 /* FIXME drow/2003-10-07: This code should be pushed elsewhere when
1145 hardware watchpoints are split into multiple loc breakpoints. */
1146 if ((b
->loc_type
== bp_loc_hardware_watchpoint
1147 || b
->owner
->type
== bp_watchpoint
) && !b
->owner
->val
)
1150 val
= evaluate_expression (b
->owner
->exp
);
1151 release_value (val
);
1152 if (value_lazy (val
))
1153 value_fetch_lazy (val
);
1154 b
->owner
->val
= val
;
1157 val
= insert_bp_location (b
, tmp_error_stream
,
1158 &disabled_breaks
, &process_warning
,
1159 &hw_breakpoint_error
);
1166 /* If a hardware breakpoint or watchpoint was inserted, add a
1167 message about possibly exhausted resources. */
1168 if (hw_breakpoint_error
)
1170 fprintf_unfiltered (tmp_error_stream
,
1171 "Could not insert hardware breakpoints:\n\
1172 You may have requested too many hardware breakpoints/watchpoints.\n");
1174 #ifdef ONE_PROCESS_WRITETEXT
1175 if (process_warning
)
1176 fprintf_unfiltered (tmp_error_stream
,
1177 "The same program may be running in another process.");
1179 target_terminal_ours_for_output ();
1180 error_stream (tmp_error_stream
);
1186 remove_breakpoints (void)
1188 struct bp_location
*b
;
1191 ALL_BP_LOCATIONS (b
)
1195 val
= remove_breakpoint (b
, mark_uninserted
);
1204 remove_hw_watchpoints (void)
1206 struct bp_location
*b
;
1209 ALL_BP_LOCATIONS (b
)
1211 if (b
->inserted
&& b
->loc_type
== bp_loc_hardware_watchpoint
)
1213 val
= remove_breakpoint (b
, mark_uninserted
);
1222 reattach_breakpoints (int pid
)
1224 struct bp_location
*b
;
1226 struct cleanup
*old_chain
= save_inferior_ptid ();
1228 /* Set inferior_ptid; remove_breakpoint uses this global. */
1229 inferior_ptid
= pid_to_ptid (pid
);
1230 ALL_BP_LOCATIONS (b
)
1234 remove_breakpoint (b
, mark_inserted
);
1235 if (b
->loc_type
== bp_loc_hardware_breakpoint
)
1236 val
= target_insert_hw_breakpoint (b
->address
, b
->shadow_contents
);
1238 val
= target_insert_breakpoint (b
->address
, b
->shadow_contents
);
1239 /* FIXME drow/2003-10-07: This doesn't handle any other kinds of
1240 breakpoints. It's wrong for watchpoints, for example. */
1243 do_cleanups (old_chain
);
1248 do_cleanups (old_chain
);
1253 update_breakpoints_after_exec (void)
1255 struct breakpoint
*b
;
1256 struct breakpoint
*temp
;
1258 /* Doing this first prevents the badness of having delete_breakpoint()
1259 write a breakpoint's current "shadow contents" to lift the bp. That
1260 shadow is NOT valid after an exec()! */
1261 mark_breakpoints_out ();
1263 ALL_BREAKPOINTS_SAFE (b
, temp
)
1265 /* Solib breakpoints must be explicitly reset after an exec(). */
1266 if (b
->type
== bp_shlib_event
)
1268 delete_breakpoint (b
);
1272 /* Thread event breakpoints must be set anew after an exec(),
1273 as must overlay event breakpoints. */
1274 if (b
->type
== bp_thread_event
|| b
->type
== bp_overlay_event
)
1276 delete_breakpoint (b
);
1280 /* Step-resume breakpoints are meaningless after an exec(). */
1281 if (b
->type
== bp_step_resume
)
1283 delete_breakpoint (b
);
1287 /* Ditto the sigtramp handler breakpoints. */
1288 if (b
->type
== bp_through_sigtramp
)
1290 delete_breakpoint (b
);
1294 /* Ditto the exception-handling catchpoints. */
1295 if ((b
->type
== bp_catch_catch
) || (b
->type
== bp_catch_throw
))
1297 delete_breakpoint (b
);
1301 /* Don't delete an exec catchpoint, because else the inferior
1302 won't stop when it ought!
1304 Similarly, we probably ought to keep vfork catchpoints, 'cause
1305 on this target, we may not be able to stop when the vfork is
1306 seen, but only when the subsequent exec is seen. (And because
1307 deleting fork catchpoints here but not vfork catchpoints will
1308 seem mysterious to users, keep those too.)
1310 ??rehrauer: Let's hope that merely clearing out this catchpoint's
1311 target address field, if any, is sufficient to have it be reset
1312 automagically. Certainly on HP-UX that's true.
1314 Jim Blandy <jimb@redhat.com>: Actually, zero is a perfectly
1315 valid code address on some platforms (like the mn10300
1316 simulators). We shouldn't assign any special interpretation to
1317 a breakpoint with a zero address. And in fact, GDB doesn't ---
1318 I can't see what that comment above is talking about. As far
1319 as I can tell, setting the address of a
1320 bp_catch_exec/bp_catch_vfork/bp_catch_fork breakpoint to zero
1321 is meaningless, since those are implemented with HP-UX kernel
1322 hackery, not by storing breakpoint instructions somewhere. */
1323 if ((b
->type
== bp_catch_exec
) ||
1324 (b
->type
== bp_catch_vfork
) ||
1325 (b
->type
== bp_catch_fork
))
1327 b
->loc
->address
= (CORE_ADDR
) NULL
;
1331 /* bp_finish is a special case. The only way we ought to be able
1332 to see one of these when an exec() has happened, is if the user
1333 caught a vfork, and then said "finish". Ordinarily a finish just
1334 carries them to the call-site of the current callee, by setting
1335 a temporary bp there and resuming. But in this case, the finish
1336 will carry them entirely through the vfork & exec.
1338 We don't want to allow a bp_finish to remain inserted now. But
1339 we can't safely delete it, 'cause finish_command has a handle to
1340 the bp on a bpstat, and will later want to delete it. There's a
1341 chance (and I've seen it happen) that if we delete the bp_finish
1342 here, that its storage will get reused by the time finish_command
1343 gets 'round to deleting the "use to be a bp_finish" breakpoint.
1344 We really must allow finish_command to delete a bp_finish.
1346 In the absense of a general solution for the "how do we know
1347 it's safe to delete something others may have handles to?"
1348 problem, what we'll do here is just uninsert the bp_finish, and
1349 let finish_command delete it.
1351 (We know the bp_finish is "doomed" in the sense that it's
1352 momentary, and will be deleted as soon as finish_command sees
1353 the inferior stopped. So it doesn't matter that the bp's
1354 address is probably bogus in the new a.out, unlike e.g., the
1355 solib breakpoints.) */
1357 if (b
->type
== bp_finish
)
1362 /* Without a symbolic address, we have little hope of the
1363 pre-exec() address meaning the same thing in the post-exec()
1365 if (b
->addr_string
== NULL
)
1367 delete_breakpoint (b
);
1371 /* If this breakpoint has survived the above battery of checks, then
1372 it must have a symbolic address. Be sure that it gets reevaluated
1373 to a target address, rather than reusing the old evaluation.
1375 Jim Blandy <jimb@redhat.com>: As explained above in the comment
1376 for bp_catch_exec and friends, I'm pretty sure this is entirely
1377 unnecessary. A call to breakpoint_re_set_one always recomputes
1378 the breakpoint's address from scratch, or deletes it if it can't.
1379 So I think this assignment could be deleted without effect. */
1380 b
->loc
->address
= (CORE_ADDR
) NULL
;
1382 /* FIXME what about longjmp breakpoints? Re-create them here? */
1383 create_overlay_event_breakpoint ("_ovly_debug_event");
1387 detach_breakpoints (int pid
)
1389 struct bp_location
*b
;
1391 struct cleanup
*old_chain
= save_inferior_ptid ();
1393 if (pid
== PIDGET (inferior_ptid
))
1394 error (_("Cannot detach breakpoints of inferior_ptid"));
1396 /* Set inferior_ptid; remove_breakpoint uses this global. */
1397 inferior_ptid
= pid_to_ptid (pid
);
1398 ALL_BP_LOCATIONS (b
)
1402 val
= remove_breakpoint (b
, mark_inserted
);
1405 do_cleanups (old_chain
);
1410 do_cleanups (old_chain
);
1415 remove_breakpoint (struct bp_location
*b
, insertion_state_t is
)
1419 if (b
->owner
->enable_state
== bp_permanent
)
1420 /* Permanent breakpoints cannot be inserted or removed. */
1423 if (b
->owner
->type
== bp_none
)
1424 warning (_("attempted to remove apparently deleted breakpoint #%d?"),
1427 if (b
->loc_type
== bp_loc_software_breakpoint
1428 || b
->loc_type
== bp_loc_hardware_breakpoint
)
1430 /* "Normal" instruction breakpoint: either the standard
1431 trap-instruction bp (bp_breakpoint), or a
1432 bp_hardware_breakpoint. */
1434 /* First check to see if we have to handle an overlay. */
1435 if (overlay_debugging
== ovly_off
1436 || b
->section
== NULL
1437 || !(section_is_overlay (b
->section
)))
1439 /* No overlay handling: just remove the breakpoint. */
1441 if (b
->loc_type
== bp_loc_hardware_breakpoint
)
1442 val
= target_remove_hw_breakpoint (b
->address
,
1443 b
->shadow_contents
);
1445 val
= target_remove_breakpoint (b
->address
, b
->shadow_contents
);
1449 /* This breakpoint is in an overlay section.
1450 Did we set a breakpoint at the LMA? */
1451 if (!overlay_events_enabled
)
1453 /* Yes -- overlay event support is not active, so we
1454 should have set a breakpoint at the LMA. Remove it.
1456 CORE_ADDR addr
= overlay_unmapped_address (b
->address
,
1458 /* Ignore any failures: if the LMA is in ROM, we will
1459 have already warned when we failed to insert it. */
1460 if (b
->loc_type
== bp_loc_hardware_breakpoint
)
1461 target_remove_hw_breakpoint (addr
, b
->shadow_contents
);
1463 target_remove_breakpoint (addr
, b
->shadow_contents
);
1465 /* Did we set a breakpoint at the VMA?
1466 If so, we will have marked the breakpoint 'inserted'. */
1469 /* Yes -- remove it. Previously we did not bother to
1470 remove the breakpoint if the section had been
1471 unmapped, but let's not rely on that being safe. We
1472 don't know what the overlay manager might do. */
1473 if (b
->loc_type
== bp_loc_hardware_breakpoint
)
1474 val
= target_remove_hw_breakpoint (b
->address
,
1475 b
->shadow_contents
);
1477 val
= target_remove_breakpoint (b
->address
,
1478 b
->shadow_contents
);
1482 /* No -- not inserted, so no need to remove. No error. */
1488 b
->inserted
= (is
== mark_inserted
);
1490 else if (b
->loc_type
== bp_loc_hardware_watchpoint
1491 && breakpoint_enabled (b
->owner
)
1497 b
->inserted
= (is
== mark_inserted
);
1498 /* Walk down the saved value chain. */
1499 for (v
= b
->owner
->val_chain
; v
; v
= value_next (v
))
1501 /* For each memory reference remove the watchpoint
1503 if (VALUE_LVAL (v
) == lval_memory
1504 && ! value_lazy (v
))
1506 struct type
*vtype
= check_typedef (value_type (v
));
1508 if (v
== b
->owner
->val_chain
1509 || (TYPE_CODE (vtype
) != TYPE_CODE_STRUCT
1510 && TYPE_CODE (vtype
) != TYPE_CODE_ARRAY
))
1515 addr
= VALUE_ADDRESS (v
) + value_offset (v
);
1516 len
= TYPE_LENGTH (value_type (v
));
1518 if (b
->owner
->type
== bp_read_watchpoint
)
1520 else if (b
->owner
->type
== bp_access_watchpoint
)
1523 val
= target_remove_watchpoint (addr
, len
, type
);
1530 /* Failure to remove any of the hardware watchpoints comes here. */
1531 if ((is
== mark_uninserted
) && (b
->inserted
))
1532 warning (_("Could not remove hardware watchpoint %d."),
1535 else if ((b
->owner
->type
== bp_catch_fork
||
1536 b
->owner
->type
== bp_catch_vfork
||
1537 b
->owner
->type
== bp_catch_exec
)
1538 && breakpoint_enabled (b
->owner
)
1542 switch (b
->owner
->type
)
1545 val
= target_remove_fork_catchpoint (PIDGET (inferior_ptid
));
1547 case bp_catch_vfork
:
1548 val
= target_remove_vfork_catchpoint (PIDGET (inferior_ptid
));
1551 val
= target_remove_exec_catchpoint (PIDGET (inferior_ptid
));
1554 warning (_("Internal error, %s line %d."), __FILE__
, __LINE__
);
1559 b
->inserted
= (is
== mark_inserted
);
1561 else if ((b
->owner
->type
== bp_catch_catch
||
1562 b
->owner
->type
== bp_catch_throw
)
1563 && breakpoint_enabled (b
->owner
)
1567 val
= target_remove_breakpoint (b
->address
, b
->shadow_contents
);
1570 b
->inserted
= (is
== mark_inserted
);
1572 else if (ep_is_exception_catchpoint (b
->owner
)
1573 && b
->inserted
/* sometimes previous insert doesn't happen */
1574 && breakpoint_enabled (b
->owner
)
1578 val
= target_remove_breakpoint (b
->address
, b
->shadow_contents
);
1582 b
->inserted
= (is
== mark_inserted
);
1588 /* Clear the "inserted" flag in all breakpoints. */
1591 mark_breakpoints_out (void)
1593 struct bp_location
*bpt
;
1595 ALL_BP_LOCATIONS (bpt
)
1599 /* Clear the "inserted" flag in all breakpoints and delete any
1600 breakpoints which should go away between runs of the program.
1602 Plus other such housekeeping that has to be done for breakpoints
1605 Note: this function gets called at the end of a run (by
1606 generic_mourn_inferior) and when a run begins (by
1607 init_wait_for_inferior). */
1612 breakpoint_init_inferior (enum inf_context context
)
1614 struct breakpoint
*b
, *temp
;
1615 struct bp_location
*bpt
;
1616 static int warning_needed
= 0;
1618 ALL_BP_LOCATIONS (bpt
)
1621 ALL_BREAKPOINTS_SAFE (b
, temp
)
1626 case bp_watchpoint_scope
:
1628 /* If the call dummy breakpoint is at the entry point it will
1629 cause problems when the inferior is rerun, so we better
1632 Also get rid of scope breakpoints. */
1633 delete_breakpoint (b
);
1637 case bp_hardware_watchpoint
:
1638 case bp_read_watchpoint
:
1639 case bp_access_watchpoint
:
1641 /* Likewise for watchpoints on local expressions. */
1642 if (b
->exp_valid_block
!= NULL
)
1643 delete_breakpoint (b
);
1644 if (context
== inf_starting
)
1646 /* Reset val field to force reread of starting value
1647 in insert_breakpoints. */
1649 value_free (b
->val
);
1654 /* Likewise for exception catchpoints in dynamic-linked
1655 executables where required */
1656 if (ep_is_exception_catchpoint (b
)
1657 && deprecated_exception_catchpoints_are_fragile
)
1660 delete_breakpoint (b
);
1666 if (deprecated_exception_catchpoints_are_fragile
)
1667 deprecated_exception_support_initialized
= 0;
1669 /* Don't issue the warning unless it's really needed... */
1670 if (warning_needed
&& (context
!= inf_exited
))
1672 warning (_("Exception catchpoints from last run were deleted.\n"
1673 "You must reinsert them explicitly."));
1678 /* breakpoint_here_p (PC) returns non-zero if an enabled breakpoint
1679 exists at PC. It returns ordinary_breakpoint_here if it's an
1680 ordinary breakpoint, or permanent_breakpoint_here if it's a
1681 permanent breakpoint.
1682 - When continuing from a location with an ordinary breakpoint, we
1683 actually single step once before calling insert_breakpoints.
1684 - When continuing from a localion with a permanent breakpoint, we
1685 need to use the `SKIP_PERMANENT_BREAKPOINT' macro, provided by
1686 the target, to advance the PC past the breakpoint. */
1688 enum breakpoint_here
1689 breakpoint_here_p (CORE_ADDR pc
)
1691 struct bp_location
*bpt
;
1692 int any_breakpoint_here
= 0;
1694 ALL_BP_LOCATIONS (bpt
)
1696 if (bpt
->loc_type
!= bp_loc_software_breakpoint
1697 && bpt
->loc_type
!= bp_loc_hardware_breakpoint
)
1700 if ((breakpoint_enabled (bpt
->owner
)
1701 || bpt
->owner
->enable_state
== bp_permanent
)
1702 && bpt
->address
== pc
) /* bp is enabled and matches pc */
1704 if (overlay_debugging
1705 && section_is_overlay (bpt
->section
)
1706 && !section_is_mapped (bpt
->section
))
1707 continue; /* unmapped overlay -- can't be a match */
1708 else if (bpt
->owner
->enable_state
== bp_permanent
)
1709 return permanent_breakpoint_here
;
1711 any_breakpoint_here
= 1;
1715 return any_breakpoint_here
? ordinary_breakpoint_here
: 0;
1719 /* breakpoint_inserted_here_p (PC) is just like breakpoint_here_p(),
1720 but it only returns true if there is actually a breakpoint inserted
1724 breakpoint_inserted_here_p (CORE_ADDR pc
)
1726 struct bp_location
*bpt
;
1728 ALL_BP_LOCATIONS (bpt
)
1730 if (bpt
->loc_type
!= bp_loc_software_breakpoint
1731 && bpt
->loc_type
!= bp_loc_hardware_breakpoint
)
1735 && bpt
->address
== pc
) /* bp is inserted and matches pc */
1737 if (overlay_debugging
1738 && section_is_overlay (bpt
->section
)
1739 && !section_is_mapped (bpt
->section
))
1740 continue; /* unmapped overlay -- can't be a match */
1749 /* This function returns non-zero iff there is a software breakpoint
1753 software_breakpoint_inserted_here_p (CORE_ADDR pc
)
1755 struct bp_location
*bpt
;
1756 int any_breakpoint_here
= 0;
1758 ALL_BP_LOCATIONS (bpt
)
1760 if (bpt
->loc_type
!= bp_loc_software_breakpoint
)
1763 if ((breakpoint_enabled (bpt
->owner
)
1764 || bpt
->owner
->enable_state
== bp_permanent
)
1766 && bpt
->address
== pc
) /* bp is enabled and matches pc */
1768 if (overlay_debugging
1769 && section_is_overlay (bpt
->section
)
1770 && !section_is_mapped (bpt
->section
))
1771 continue; /* unmapped overlay -- can't be a match */
1780 /* breakpoint_thread_match (PC, PTID) returns true if the breakpoint at
1781 PC is valid for process/thread PTID. */
1784 breakpoint_thread_match (CORE_ADDR pc
, ptid_t ptid
)
1786 struct bp_location
*bpt
;
1789 thread
= pid_to_thread_id (ptid
);
1791 ALL_BP_LOCATIONS (bpt
)
1793 if (bpt
->loc_type
!= bp_loc_software_breakpoint
1794 && bpt
->loc_type
!= bp_loc_hardware_breakpoint
)
1797 if ((breakpoint_enabled (bpt
->owner
)
1798 || bpt
->owner
->enable_state
== bp_permanent
)
1799 && bpt
->address
== pc
1800 && (bpt
->owner
->thread
== -1 || bpt
->owner
->thread
== thread
))
1802 if (overlay_debugging
1803 && section_is_overlay (bpt
->section
)
1804 && !section_is_mapped (bpt
->section
))
1805 continue; /* unmapped overlay -- can't be a match */
1815 /* bpstat stuff. External routines' interfaces are documented
1819 ep_is_catchpoint (struct breakpoint
*ep
)
1822 (ep
->type
== bp_catch_load
)
1823 || (ep
->type
== bp_catch_unload
)
1824 || (ep
->type
== bp_catch_fork
)
1825 || (ep
->type
== bp_catch_vfork
)
1826 || (ep
->type
== bp_catch_exec
)
1827 || (ep
->type
== bp_catch_catch
)
1828 || (ep
->type
== bp_catch_throw
);
1830 /* ??rehrauer: Add more kinds here, as are implemented... */
1834 ep_is_shlib_catchpoint (struct breakpoint
*ep
)
1837 (ep
->type
== bp_catch_load
)
1838 || (ep
->type
== bp_catch_unload
);
1842 ep_is_exception_catchpoint (struct breakpoint
*ep
)
1845 (ep
->type
== bp_catch_catch
)
1846 || (ep
->type
== bp_catch_throw
);
1849 /* Clear a bpstat so that it says we are not at any breakpoint.
1850 Also free any storage that is part of a bpstat. */
1853 bpstat_clear (bpstat
*bsp
)
1864 if (p
->old_val
!= NULL
)
1865 value_free (p
->old_val
);
1866 free_command_lines (&p
->commands
);
1873 /* Return a copy of a bpstat. Like "bs1 = bs2" but all storage that
1874 is part of the bpstat is copied as well. */
1877 bpstat_copy (bpstat bs
)
1881 bpstat retval
= NULL
;
1886 for (; bs
!= NULL
; bs
= bs
->next
)
1888 tmp
= (bpstat
) xmalloc (sizeof (*tmp
));
1889 memcpy (tmp
, bs
, sizeof (*tmp
));
1890 if (bs
->commands
!= NULL
)
1891 tmp
->commands
= copy_command_lines (bs
->commands
);
1892 if (bs
->old_val
!= NULL
)
1893 tmp
->old_val
= value_copy (bs
->old_val
);
1896 /* This is the first thing in the chain. */
1906 /* Find the bpstat associated with this breakpoint */
1909 bpstat_find_breakpoint (bpstat bsp
, struct breakpoint
*breakpoint
)
1914 for (; bsp
!= NULL
; bsp
= bsp
->next
)
1916 if (bsp
->breakpoint_at
== breakpoint
)
1922 /* Find a step_resume breakpoint associated with this bpstat.
1923 (If there are multiple step_resume bp's on the list, this function
1924 will arbitrarily pick one.)
1926 It is an error to use this function if BPSTAT doesn't contain a
1927 step_resume breakpoint.
1929 See wait_for_inferior's use of this function. */
1931 bpstat_find_step_resume_breakpoint (bpstat bsp
)
1935 gdb_assert (bsp
!= NULL
);
1937 current_thread
= pid_to_thread_id (inferior_ptid
);
1939 for (; bsp
!= NULL
; bsp
= bsp
->next
)
1941 if ((bsp
->breakpoint_at
!= NULL
) &&
1942 (bsp
->breakpoint_at
->type
== bp_step_resume
) &&
1943 (bsp
->breakpoint_at
->thread
== current_thread
||
1944 bsp
->breakpoint_at
->thread
== -1))
1945 return bsp
->breakpoint_at
;
1948 internal_error (__FILE__
, __LINE__
, _("No step_resume breakpoint found."));
1952 /* Return the breakpoint number of the first breakpoint we are stopped
1953 at. *BSP upon return is a bpstat which points to the remaining
1954 breakpoints stopped at (but which is not guaranteed to be good for
1955 anything but further calls to bpstat_num).
1956 Return 0 if passed a bpstat which does not indicate any breakpoints. */
1959 bpstat_num (bpstat
*bsp
)
1961 struct breakpoint
*b
;
1964 return 0; /* No more breakpoint values */
1967 b
= (*bsp
)->breakpoint_at
;
1968 *bsp
= (*bsp
)->next
;
1970 return -1; /* breakpoint that's been deleted since */
1972 return b
->number
; /* We have its number */
1976 /* Modify BS so that the actions will not be performed. */
1979 bpstat_clear_actions (bpstat bs
)
1981 for (; bs
!= NULL
; bs
= bs
->next
)
1983 free_command_lines (&bs
->commands
);
1984 if (bs
->old_val
!= NULL
)
1986 value_free (bs
->old_val
);
1992 /* Stub for cleaning up our state if we error-out of a breakpoint command */
1994 cleanup_executing_breakpoints (void *ignore
)
1996 executing_breakpoint_commands
= 0;
1999 /* Execute all the commands associated with all the breakpoints at this
2000 location. Any of these commands could cause the process to proceed
2001 beyond this point, etc. We look out for such changes by checking
2002 the global "breakpoint_proceeded" after each command. */
2005 bpstat_do_actions (bpstat
*bsp
)
2008 struct cleanup
*old_chain
;
2010 /* Avoid endless recursion if a `source' command is contained
2012 if (executing_breakpoint_commands
)
2015 executing_breakpoint_commands
= 1;
2016 old_chain
= make_cleanup (cleanup_executing_breakpoints
, 0);
2019 /* Note that (as of this writing), our callers all appear to
2020 be passing us the address of global stop_bpstat. And, if
2021 our calls to execute_control_command cause the inferior to
2022 proceed, that global (and hence, *bsp) will change.
2024 We must be careful to not touch *bsp unless the inferior
2025 has not proceeded. */
2027 /* This pointer will iterate over the list of bpstat's. */
2030 breakpoint_proceeded
= 0;
2031 for (; bs
!= NULL
; bs
= bs
->next
)
2033 struct command_line
*cmd
;
2034 struct cleanup
*this_cmd_tree_chain
;
2036 /* Take ownership of the BSP's command tree, if it has one.
2038 The command tree could legitimately contain commands like
2039 'step' and 'next', which call clear_proceed_status, which
2040 frees stop_bpstat's command tree. To make sure this doesn't
2041 free the tree we're executing out from under us, we need to
2042 take ownership of the tree ourselves. Since a given bpstat's
2043 commands are only executed once, we don't need to copy it; we
2044 can clear the pointer in the bpstat, and make sure we free
2045 the tree when we're done. */
2048 this_cmd_tree_chain
= make_cleanup_free_command_lines (&cmd
);
2052 execute_control_command (cmd
);
2054 if (breakpoint_proceeded
)
2060 /* We can free this command tree now. */
2061 do_cleanups (this_cmd_tree_chain
);
2063 if (breakpoint_proceeded
)
2064 /* The inferior is proceeded by the command; bomb out now.
2065 The bpstat chain has been blown away by wait_for_inferior.
2066 But since execution has stopped again, there is a new bpstat
2067 to look at, so start over. */
2070 do_cleanups (old_chain
);
2073 /* This is the normal print function for a bpstat. In the future,
2074 much of this logic could (should?) be moved to bpstat_stop_status,
2075 by having it set different print_it values.
2077 Current scheme: When we stop, bpstat_print() is called. It loops
2078 through the bpstat list of things causing this stop, calling the
2079 print_bp_stop_message function on each one. The behavior of the
2080 print_bp_stop_message function depends on the print_it field of
2081 bpstat. If such field so indicates, call this function here.
2083 Return values from this routine (ultimately used by bpstat_print()
2084 and normal_stop() to decide what to do):
2085 PRINT_NOTHING: Means we already printed all we needed to print,
2086 don't print anything else.
2087 PRINT_SRC_ONLY: Means we printed something, and we do *not* desire
2088 that something to be followed by a location.
2089 PRINT_SCR_AND_LOC: Means we printed something, and we *do* desire
2090 that something to be followed by a location.
2091 PRINT_UNKNOWN: Means we printed nothing or we need to do some more
2094 static enum print_stop_action
2095 print_it_typical (bpstat bs
)
2097 struct cleanup
*old_chain
, *ui_out_chain
;
2098 struct ui_stream
*stb
;
2099 stb
= ui_out_stream_new (uiout
);
2100 old_chain
= make_cleanup_ui_out_stream_delete (stb
);
2101 /* bs->breakpoint_at can be NULL if it was a momentary breakpoint
2102 which has since been deleted. */
2103 if (bs
->breakpoint_at
== NULL
)
2104 return PRINT_UNKNOWN
;
2106 switch (bs
->breakpoint_at
->type
)
2109 case bp_hardware_breakpoint
:
2110 if (bs
->breakpoint_at
->loc
->address
!= bs
->breakpoint_at
->loc
->requested_address
)
2111 breakpoint_adjustment_warning (bs
->breakpoint_at
->loc
->requested_address
,
2112 bs
->breakpoint_at
->loc
->address
,
2113 bs
->breakpoint_at
->number
, 1);
2114 annotate_breakpoint (bs
->breakpoint_at
->number
);
2115 ui_out_text (uiout
, "\nBreakpoint ");
2116 if (ui_out_is_mi_like_p (uiout
))
2117 ui_out_field_string (uiout
, "reason", "breakpoint-hit");
2118 ui_out_field_int (uiout
, "bkptno", bs
->breakpoint_at
->number
);
2119 ui_out_text (uiout
, ", ");
2120 return PRINT_SRC_AND_LOC
;
2123 case bp_shlib_event
:
2124 /* Did we stop because the user set the stop_on_solib_events
2125 variable? (If so, we report this as a generic, "Stopped due
2126 to shlib event" message.) */
2127 printf_filtered (_("Stopped due to shared library event\n"));
2128 return PRINT_NOTHING
;
2131 case bp_thread_event
:
2132 /* Not sure how we will get here.
2133 GDB should not stop for these breakpoints. */
2134 printf_filtered (_("Thread Event Breakpoint: gdb should not stop!\n"));
2135 return PRINT_NOTHING
;
2138 case bp_overlay_event
:
2139 /* By analogy with the thread event, GDB should not stop for these. */
2140 printf_filtered (_("Overlay Event Breakpoint: gdb should not stop!\n"));
2141 return PRINT_NOTHING
;
2145 annotate_catchpoint (bs
->breakpoint_at
->number
);
2146 printf_filtered (_("\nCatchpoint %d (loaded %s), "),
2147 bs
->breakpoint_at
->number
,
2148 bs
->breakpoint_at
->triggered_dll_pathname
);
2149 return PRINT_SRC_AND_LOC
;
2152 case bp_catch_unload
:
2153 annotate_catchpoint (bs
->breakpoint_at
->number
);
2154 printf_filtered (_("\nCatchpoint %d (unloaded %s), "),
2155 bs
->breakpoint_at
->number
,
2156 bs
->breakpoint_at
->triggered_dll_pathname
);
2157 return PRINT_SRC_AND_LOC
;
2161 annotate_catchpoint (bs
->breakpoint_at
->number
);
2162 printf_filtered (_("\nCatchpoint %d (forked process %d), "),
2163 bs
->breakpoint_at
->number
,
2164 bs
->breakpoint_at
->forked_inferior_pid
);
2165 return PRINT_SRC_AND_LOC
;
2168 case bp_catch_vfork
:
2169 annotate_catchpoint (bs
->breakpoint_at
->number
);
2170 printf_filtered (_("\nCatchpoint %d (vforked process %d), "),
2171 bs
->breakpoint_at
->number
,
2172 bs
->breakpoint_at
->forked_inferior_pid
);
2173 return PRINT_SRC_AND_LOC
;
2177 annotate_catchpoint (bs
->breakpoint_at
->number
);
2178 printf_filtered (_("\nCatchpoint %d (exec'd %s), "),
2179 bs
->breakpoint_at
->number
,
2180 bs
->breakpoint_at
->exec_pathname
);
2181 return PRINT_SRC_AND_LOC
;
2184 case bp_catch_catch
:
2185 if (current_exception_event
&&
2186 (CURRENT_EXCEPTION_KIND
== EX_EVENT_CATCH
))
2188 annotate_catchpoint (bs
->breakpoint_at
->number
);
2189 printf_filtered (_("\nCatchpoint %d (exception caught), "),
2190 bs
->breakpoint_at
->number
);
2191 if (CURRENT_EXCEPTION_THROW_PC
&& CURRENT_EXCEPTION_THROW_LINE
)
2192 printf_filtered (_("throw location %s:%d, "),
2193 CURRENT_EXCEPTION_THROW_FILE
,
2194 CURRENT_EXCEPTION_THROW_LINE
);
2196 printf_filtered (_("throw location unknown, "));
2198 if (CURRENT_EXCEPTION_CATCH_PC
&& CURRENT_EXCEPTION_CATCH_LINE
)
2199 printf_filtered (_("catch location %s:%d\n"),
2200 CURRENT_EXCEPTION_CATCH_FILE
,
2201 CURRENT_EXCEPTION_CATCH_LINE
);
2203 printf_filtered (_("catch location unknown\n"));
2205 /* don't bother to print location frame info */
2206 return PRINT_SRC_ONLY
;
2210 /* really throw, some other bpstat will handle it */
2211 return PRINT_UNKNOWN
;
2215 case bp_catch_throw
:
2216 if (current_exception_event
&&
2217 (CURRENT_EXCEPTION_KIND
== EX_EVENT_THROW
))
2219 annotate_catchpoint (bs
->breakpoint_at
->number
);
2220 printf_filtered (_("\nCatchpoint %d (exception thrown), "),
2221 bs
->breakpoint_at
->number
);
2222 if (CURRENT_EXCEPTION_THROW_PC
&& CURRENT_EXCEPTION_THROW_LINE
)
2223 printf_filtered (_("throw location %s:%d, "),
2224 CURRENT_EXCEPTION_THROW_FILE
,
2225 CURRENT_EXCEPTION_THROW_LINE
);
2227 printf_filtered (_("throw location unknown, "));
2229 if (CURRENT_EXCEPTION_CATCH_PC
&& CURRENT_EXCEPTION_CATCH_LINE
)
2230 printf_filtered (_("catch location %s:%d\n"),
2231 CURRENT_EXCEPTION_CATCH_FILE
,
2232 CURRENT_EXCEPTION_CATCH_LINE
);
2234 printf_filtered (_("catch location unknown\n"));
2236 /* don't bother to print location frame info */
2237 return PRINT_SRC_ONLY
;
2241 /* really catch, some other bpstat will handle it */
2242 return PRINT_UNKNOWN
;
2247 case bp_hardware_watchpoint
:
2248 if (bs
->old_val
!= NULL
)
2250 annotate_watchpoint (bs
->breakpoint_at
->number
);
2251 if (ui_out_is_mi_like_p (uiout
))
2252 ui_out_field_string (uiout
, "reason", "watchpoint-trigger");
2253 mention (bs
->breakpoint_at
);
2254 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "value");
2255 ui_out_text (uiout
, "\nOld value = ");
2256 value_print (bs
->old_val
, stb
->stream
, 0, Val_pretty_default
);
2257 ui_out_field_stream (uiout
, "old", stb
);
2258 ui_out_text (uiout
, "\nNew value = ");
2259 value_print (bs
->breakpoint_at
->val
, stb
->stream
, 0, Val_pretty_default
);
2260 ui_out_field_stream (uiout
, "new", stb
);
2261 do_cleanups (ui_out_chain
);
2262 ui_out_text (uiout
, "\n");
2263 value_free (bs
->old_val
);
2266 /* More than one watchpoint may have been triggered. */
2267 return PRINT_UNKNOWN
;
2270 case bp_read_watchpoint
:
2271 if (ui_out_is_mi_like_p (uiout
))
2272 ui_out_field_string (uiout
, "reason", "read-watchpoint-trigger");
2273 mention (bs
->breakpoint_at
);
2274 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "value");
2275 ui_out_text (uiout
, "\nValue = ");
2276 value_print (bs
->breakpoint_at
->val
, stb
->stream
, 0, Val_pretty_default
);
2277 ui_out_field_stream (uiout
, "value", stb
);
2278 do_cleanups (ui_out_chain
);
2279 ui_out_text (uiout
, "\n");
2280 return PRINT_UNKNOWN
;
2283 case bp_access_watchpoint
:
2284 if (bs
->old_val
!= NULL
)
2286 annotate_watchpoint (bs
->breakpoint_at
->number
);
2287 if (ui_out_is_mi_like_p (uiout
))
2288 ui_out_field_string (uiout
, "reason", "access-watchpoint-trigger");
2289 mention (bs
->breakpoint_at
);
2290 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "value");
2291 ui_out_text (uiout
, "\nOld value = ");
2292 value_print (bs
->old_val
, stb
->stream
, 0, Val_pretty_default
);
2293 ui_out_field_stream (uiout
, "old", stb
);
2294 value_free (bs
->old_val
);
2296 ui_out_text (uiout
, "\nNew value = ");
2300 mention (bs
->breakpoint_at
);
2301 if (ui_out_is_mi_like_p (uiout
))
2302 ui_out_field_string (uiout
, "reason", "access-watchpoint-trigger");
2303 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "value");
2304 ui_out_text (uiout
, "\nValue = ");
2306 value_print (bs
->breakpoint_at
->val
, stb
->stream
, 0,Val_pretty_default
);
2307 ui_out_field_stream (uiout
, "new", stb
);
2308 do_cleanups (ui_out_chain
);
2309 ui_out_text (uiout
, "\n");
2310 return PRINT_UNKNOWN
;
2313 /* Fall through, we don't deal with these types of breakpoints
2317 if (ui_out_is_mi_like_p (uiout
))
2318 ui_out_field_string (uiout
, "reason", "function-finished");
2319 return PRINT_UNKNOWN
;
2323 if (ui_out_is_mi_like_p (uiout
))
2324 ui_out_field_string (uiout
, "reason", "location-reached");
2325 return PRINT_UNKNOWN
;
2330 case bp_longjmp_resume
:
2331 case bp_step_resume
:
2332 case bp_through_sigtramp
:
2333 case bp_watchpoint_scope
:
2336 return PRINT_UNKNOWN
;
2340 /* Generic routine for printing messages indicating why we
2341 stopped. The behavior of this function depends on the value
2342 'print_it' in the bpstat structure. Under some circumstances we
2343 may decide not to print anything here and delegate the task to
2346 static enum print_stop_action
2347 print_bp_stop_message (bpstat bs
)
2349 switch (bs
->print_it
)
2352 /* Nothing should be printed for this bpstat entry. */
2353 return PRINT_UNKNOWN
;
2357 /* We still want to print the frame, but we already printed the
2358 relevant messages. */
2359 return PRINT_SRC_AND_LOC
;
2362 case print_it_normal
:
2363 /* Normal case. Call the breakpoint's print_it method, or
2364 print_it_typical. */
2365 if (bs
->breakpoint_at
!= NULL
&& bs
->breakpoint_at
->ops
!= NULL
2366 && bs
->breakpoint_at
->ops
->print_it
!= NULL
)
2367 return bs
->breakpoint_at
->ops
->print_it (bs
->breakpoint_at
);
2369 return print_it_typical (bs
);
2373 internal_error (__FILE__
, __LINE__
,
2374 _("print_bp_stop_message: unrecognized enum value"));
2379 /* Print a message indicating what happened. This is called from
2380 normal_stop(). The input to this routine is the head of the bpstat
2381 list - a list of the eventpoints that caused this stop. This
2382 routine calls the generic print routine for printing a message
2383 about reasons for stopping. This will print (for example) the
2384 "Breakpoint n," part of the output. The return value of this
2387 PRINT_UNKNOWN: Means we printed nothing
2388 PRINT_SRC_AND_LOC: Means we printed something, and expect subsequent
2389 code to print the location. An example is
2390 "Breakpoint 1, " which should be followed by
2392 PRINT_SRC_ONLY: Means we printed something, but there is no need
2393 to also print the location part of the message.
2394 An example is the catch/throw messages, which
2395 don't require a location appended to the end.
2396 PRINT_NOTHING: We have done some printing and we don't need any
2397 further info to be printed.*/
2399 enum print_stop_action
2400 bpstat_print (bpstat bs
)
2404 /* Maybe another breakpoint in the chain caused us to stop.
2405 (Currently all watchpoints go on the bpstat whether hit or not.
2406 That probably could (should) be changed, provided care is taken
2407 with respect to bpstat_explains_signal). */
2408 for (; bs
; bs
= bs
->next
)
2410 val
= print_bp_stop_message (bs
);
2411 if (val
== PRINT_SRC_ONLY
2412 || val
== PRINT_SRC_AND_LOC
2413 || val
== PRINT_NOTHING
)
2417 /* We reached the end of the chain, or we got a null BS to start
2418 with and nothing was printed. */
2419 return PRINT_UNKNOWN
;
2422 /* Evaluate the expression EXP and return 1 if value is zero.
2423 This is used inside a catch_errors to evaluate the breakpoint condition.
2424 The argument is a "struct expression *" that has been cast to char * to
2425 make it pass through catch_errors. */
2428 breakpoint_cond_eval (void *exp
)
2430 struct value
*mark
= value_mark ();
2431 int i
= !value_true (evaluate_expression ((struct expression
*) exp
));
2432 value_free_to_mark (mark
);
2436 /* Allocate a new bpstat and chain it to the current one. */
2439 bpstat_alloc (struct breakpoint
*b
, bpstat cbs
/* Current "bs" value */ )
2443 bs
= (bpstat
) xmalloc (sizeof (*bs
));
2445 bs
->breakpoint_at
= b
;
2446 /* If the condition is false, etc., don't do the commands. */
2447 bs
->commands
= NULL
;
2449 bs
->print_it
= print_it_normal
;
2453 /* Possible return values for watchpoint_check (this can't be an enum
2454 because of check_errors). */
2455 /* The watchpoint has been deleted. */
2456 #define WP_DELETED 1
2457 /* The value has changed. */
2458 #define WP_VALUE_CHANGED 2
2459 /* The value has not changed. */
2460 #define WP_VALUE_NOT_CHANGED 3
2462 #define BP_TEMPFLAG 1
2463 #define BP_HARDWAREFLAG 2
2465 /* Check watchpoint condition. */
2468 watchpoint_check (void *p
)
2470 bpstat bs
= (bpstat
) p
;
2471 struct breakpoint
*b
;
2472 struct frame_info
*fr
;
2473 int within_current_scope
;
2475 b
= bs
->breakpoint_at
;
2477 if (b
->exp_valid_block
== NULL
)
2478 within_current_scope
= 1;
2481 /* There is no current frame at this moment. If we're going to have
2482 any chance of handling watchpoints on local variables, we'll need
2483 the frame chain (so we can determine if we're in scope). */
2484 reinit_frame_cache ();
2485 fr
= frame_find_by_id (b
->watchpoint_frame
);
2486 within_current_scope
= (fr
!= NULL
);
2487 /* in_function_epilogue_p() returns a non-zero value if we're still
2488 in the function but the stack frame has already been invalidated.
2489 Since we can't rely on the values of local variables after the
2490 stack has been destroyed, we are treating the watchpoint in that
2491 state as `not changed' without further checking.
2493 vinschen/2003-09-04: The former implementation left out the case
2494 that the watchpoint frame couldn't be found by frame_find_by_id()
2495 because the current PC is currently in an epilogue. Calling
2496 gdbarch_in_function_epilogue_p() also when fr == NULL fixes that. */
2497 if ((!within_current_scope
|| fr
== get_current_frame ())
2498 && gdbarch_in_function_epilogue_p (current_gdbarch
, read_pc ()))
2499 return WP_VALUE_NOT_CHANGED
;
2500 if (fr
&& within_current_scope
)
2501 /* If we end up stopping, the current frame will get selected
2502 in normal_stop. So this call to select_frame won't affect
2507 if (within_current_scope
)
2509 /* We use value_{,free_to_}mark because it could be a
2510 *long* time before we return to the command level and
2511 call free_all_values. We can't call free_all_values because
2512 we might be in the middle of evaluating a function call. */
2514 struct value
*mark
= value_mark ();
2515 struct value
*new_val
= evaluate_expression (bs
->breakpoint_at
->exp
);
2516 if (!value_equal (b
->val
, new_val
))
2518 release_value (new_val
);
2519 value_free_to_mark (mark
);
2520 bs
->old_val
= b
->val
;
2522 /* We will stop here */
2523 return WP_VALUE_CHANGED
;
2527 /* Nothing changed, don't do anything. */
2528 value_free_to_mark (mark
);
2529 /* We won't stop here */
2530 return WP_VALUE_NOT_CHANGED
;
2535 /* This seems like the only logical thing to do because
2536 if we temporarily ignored the watchpoint, then when
2537 we reenter the block in which it is valid it contains
2538 garbage (in the case of a function, it may have two
2539 garbage values, one before and one after the prologue).
2540 So we can't even detect the first assignment to it and
2541 watch after that (since the garbage may or may not equal
2542 the first value assigned). */
2543 /* We print all the stop information in print_it_typical(), but
2544 in this case, by the time we call print_it_typical() this bp
2545 will be deleted already. So we have no choice but print the
2546 information here. */
2547 if (ui_out_is_mi_like_p (uiout
))
2548 ui_out_field_string (uiout
, "reason", "watchpoint-scope");
2549 ui_out_text (uiout
, "\nWatchpoint ");
2550 ui_out_field_int (uiout
, "wpnum", bs
->breakpoint_at
->number
);
2551 ui_out_text (uiout
, " deleted because the program has left the block in\n\
2552 which its expression is valid.\n");
2554 if (b
->related_breakpoint
)
2555 b
->related_breakpoint
->disposition
= disp_del_at_next_stop
;
2556 b
->disposition
= disp_del_at_next_stop
;
2562 /* Get a bpstat associated with having just stopped at address
2563 BP_ADDR in thread PTID. STOPPED_BY_WATCHPOINT is 1 if the
2564 target thinks we stopped due to a hardware watchpoint, 0 if we
2565 know we did not trigger a hardware watchpoint, and -1 if we do not know. */
2567 /* Determine whether we stopped at a breakpoint, etc, or whether we
2568 don't understand this stop. Result is a chain of bpstat's such that:
2570 if we don't understand the stop, the result is a null pointer.
2572 if we understand why we stopped, the result is not null.
2574 Each element of the chain refers to a particular breakpoint or
2575 watchpoint at which we have stopped. (We may have stopped for
2576 several reasons concurrently.)
2578 Each element of the chain has valid next, breakpoint_at,
2579 commands, FIXME??? fields. */
2582 bpstat_stop_status (CORE_ADDR bp_addr
, ptid_t ptid
, int stopped_by_watchpoint
)
2584 struct breakpoint
*b
, *temp
;
2585 /* True if we've hit a breakpoint (as opposed to a watchpoint). */
2586 int real_breakpoint
= 0;
2587 /* Root of the chain of bpstat's */
2588 struct bpstats root_bs
[1];
2589 /* Pointer to the last thing in the chain currently. */
2590 bpstat bs
= root_bs
;
2591 int thread_id
= pid_to_thread_id (ptid
);
2593 ALL_BREAKPOINTS_SAFE (b
, temp
)
2595 if (!breakpoint_enabled (b
) && b
->enable_state
!= bp_permanent
)
2598 if (b
->type
!= bp_watchpoint
2599 && b
->type
!= bp_hardware_watchpoint
2600 && b
->type
!= bp_read_watchpoint
2601 && b
->type
!= bp_access_watchpoint
2602 && b
->type
!= bp_hardware_breakpoint
2603 && b
->type
!= bp_catch_fork
2604 && b
->type
!= bp_catch_vfork
2605 && b
->type
!= bp_catch_exec
2606 && b
->type
!= bp_catch_catch
2607 && b
->type
!= bp_catch_throw
) /* a non-watchpoint bp */
2609 if (b
->loc
->address
!= bp_addr
) /* address doesn't match */
2611 if (overlay_debugging
/* unmapped overlay section */
2612 && section_is_overlay (b
->loc
->section
)
2613 && !section_is_mapped (b
->loc
->section
))
2617 /* Continuable hardware watchpoints are treated as non-existent if the
2618 reason we stopped wasn't a hardware watchpoint (we didn't stop on
2619 some data address). Otherwise gdb won't stop on a break instruction
2620 in the code (not from a breakpoint) when a hardware watchpoint has
2623 if ((b
->type
== bp_hardware_watchpoint
2624 || b
->type
== bp_read_watchpoint
2625 || b
->type
== bp_access_watchpoint
)
2626 && !stopped_by_watchpoint
)
2629 if (b
->type
== bp_hardware_breakpoint
)
2631 if (b
->loc
->address
!= bp_addr
)
2633 if (overlay_debugging
/* unmapped overlay section */
2634 && section_is_overlay (b
->loc
->section
)
2635 && !section_is_mapped (b
->loc
->section
))
2639 /* Is this a catchpoint of a load or unload? If so, did we
2640 get a load or unload of the specified library? If not,
2642 if ((b
->type
== bp_catch_load
)
2643 #if defined(SOLIB_HAVE_LOAD_EVENT)
2644 && (!SOLIB_HAVE_LOAD_EVENT (PIDGET (inferior_ptid
))
2645 || ((b
->dll_pathname
!= NULL
)
2646 && (strcmp (b
->dll_pathname
,
2647 SOLIB_LOADED_LIBRARY_PATHNAME (
2648 PIDGET (inferior_ptid
)))
2654 if ((b
->type
== bp_catch_unload
)
2655 #if defined(SOLIB_HAVE_UNLOAD_EVENT)
2656 && (!SOLIB_HAVE_UNLOAD_EVENT (PIDGET (inferior_ptid
))
2657 || ((b
->dll_pathname
!= NULL
)
2658 && (strcmp (b
->dll_pathname
,
2659 SOLIB_UNLOADED_LIBRARY_PATHNAME (
2660 PIDGET (inferior_ptid
)))
2666 if ((b
->type
== bp_catch_fork
)
2667 && !inferior_has_forked (PIDGET (inferior_ptid
),
2668 &b
->forked_inferior_pid
))
2671 if ((b
->type
== bp_catch_vfork
)
2672 && !inferior_has_vforked (PIDGET (inferior_ptid
),
2673 &b
->forked_inferior_pid
))
2676 if ((b
->type
== bp_catch_exec
)
2677 && !inferior_has_execd (PIDGET (inferior_ptid
), &b
->exec_pathname
))
2680 if (ep_is_exception_catchpoint (b
) &&
2681 !(current_exception_event
= target_get_current_exception_event ()))
2684 /* Come here if it's a watchpoint, or if the break address matches */
2686 bs
= bpstat_alloc (b
, bs
); /* Alloc a bpstat to explain stop */
2688 /* Watchpoints may change this, if not found to have triggered. */
2692 if (b
->type
== bp_watchpoint
||
2693 b
->type
== bp_hardware_watchpoint
)
2695 char *message
= xstrprintf ("Error evaluating expression for watchpoint %d\n",
2697 struct cleanup
*cleanups
= make_cleanup (xfree
, message
);
2698 int e
= catch_errors (watchpoint_check
, bs
, message
,
2700 do_cleanups (cleanups
);
2704 /* We've already printed what needs to be printed. */
2705 /* Actually this is superfluous, because by the time we
2706 call print_it_typical() the wp will be already deleted,
2707 and the function will return immediately. */
2708 bs
->print_it
= print_it_done
;
2711 case WP_VALUE_CHANGED
:
2715 case WP_VALUE_NOT_CHANGED
:
2717 bs
->print_it
= print_it_noop
;
2724 /* Error from catch_errors. */
2725 printf_filtered (_("Watchpoint %d deleted.\n"), b
->number
);
2726 if (b
->related_breakpoint
)
2727 b
->related_breakpoint
->disposition
= disp_del_at_next_stop
;
2728 b
->disposition
= disp_del_at_next_stop
;
2729 /* We've already printed what needs to be printed. */
2730 bs
->print_it
= print_it_done
;
2736 else if (b
->type
== bp_read_watchpoint
||
2737 b
->type
== bp_access_watchpoint
)
2743 if (!target_stopped_data_address (¤t_target
, &addr
))
2745 for (v
= b
->val_chain
; v
; v
= value_next (v
))
2747 if (VALUE_LVAL (v
) == lval_memory
2748 && ! value_lazy (v
))
2750 struct type
*vtype
= check_typedef (value_type (v
));
2752 if (v
== b
->val_chain
2753 || (TYPE_CODE (vtype
) != TYPE_CODE_STRUCT
2754 && TYPE_CODE (vtype
) != TYPE_CODE_ARRAY
))
2758 vaddr
= VALUE_ADDRESS (v
) + value_offset (v
);
2759 /* Exact match not required. Within range is
2761 if (addr
>= vaddr
&&
2762 addr
< vaddr
+ TYPE_LENGTH (value_type (v
)))
2769 char *message
= xstrprintf ("Error evaluating expression for watchpoint %d\n",
2771 struct cleanup
*cleanups
= make_cleanup (xfree
, message
);
2772 int e
= catch_errors (watchpoint_check
, bs
, message
,
2774 do_cleanups (cleanups
);
2778 /* We've already printed what needs to be printed. */
2779 bs
->print_it
= print_it_done
;
2782 case WP_VALUE_CHANGED
:
2783 if (b
->type
== bp_read_watchpoint
)
2785 /* Don't stop: read watchpoints shouldn't fire if
2786 the value has changed. This is for targets
2787 which cannot set read-only watchpoints. */
2788 bs
->print_it
= print_it_noop
;
2794 case WP_VALUE_NOT_CHANGED
:
2801 /* Error from catch_errors. */
2802 printf_filtered (_("Watchpoint %d deleted.\n"), b
->number
);
2803 if (b
->related_breakpoint
)
2804 b
->related_breakpoint
->disposition
= disp_del_at_next_stop
;
2805 b
->disposition
= disp_del_at_next_stop
;
2806 /* We've already printed what needs to be printed. */
2807 bs
->print_it
= print_it_done
;
2811 else /* found == 0 */
2813 /* This is a case where some watchpoint(s) triggered,
2814 but not at the address of this watchpoint (FOUND
2815 was left zero). So don't print anything for this
2817 bs
->print_it
= print_it_noop
;
2824 /* By definition, an encountered breakpoint is a triggered
2828 real_breakpoint
= 1;
2831 if (frame_id_p (b
->frame_id
)
2832 && !frame_id_eq (b
->frame_id
, get_frame_id (get_current_frame ())))
2836 int value_is_zero
= 0;
2840 /* Need to select the frame, with all that implies
2841 so that the conditions will have the right context. */
2842 select_frame (get_current_frame ());
2844 = catch_errors (breakpoint_cond_eval
, (b
->cond
),
2845 "Error in testing breakpoint condition:\n",
2847 /* FIXME-someday, should give breakpoint # */
2850 if (b
->cond
&& value_is_zero
)
2853 /* Don't consider this a hit. */
2856 else if (b
->thread
!= -1 && b
->thread
!= thread_id
)
2859 /* Don't consider this a hit. */
2862 else if (b
->ignore_count
> 0)
2865 annotate_ignore_count_change ();
2870 /* We will stop here */
2871 if (b
->disposition
== disp_disable
)
2872 b
->enable_state
= bp_disabled
;
2875 bs
->commands
= b
->commands
;
2877 (strcmp ("silent", bs
->commands
->line
) == 0
2878 || (xdb_commands
&& strcmp ("Q", bs
->commands
->line
) == 0)))
2880 bs
->commands
= bs
->commands
->next
;
2883 bs
->commands
= copy_command_lines (bs
->commands
);
2886 /* Print nothing for this entry if we dont stop or if we dont print. */
2887 if (bs
->stop
== 0 || bs
->print
== 0)
2888 bs
->print_it
= print_it_noop
;
2891 bs
->next
= NULL
; /* Terminate the chain */
2892 bs
= root_bs
->next
; /* Re-grab the head of the chain */
2894 /* The value of a hardware watchpoint hasn't changed, but the
2895 intermediate memory locations we are watching may have. */
2896 if (bs
&& !bs
->stop
&&
2897 (bs
->breakpoint_at
->type
== bp_hardware_watchpoint
||
2898 bs
->breakpoint_at
->type
== bp_read_watchpoint
||
2899 bs
->breakpoint_at
->type
== bp_access_watchpoint
))
2901 remove_breakpoints ();
2902 insert_breakpoints ();
2907 /* Tell what to do about this bpstat. */
2909 bpstat_what (bpstat bs
)
2911 /* Classify each bpstat as one of the following. */
2914 /* This bpstat element has no effect on the main_action. */
2917 /* There was a watchpoint, stop but don't print. */
2920 /* There was a watchpoint, stop and print. */
2923 /* There was a breakpoint but we're not stopping. */
2926 /* There was a breakpoint, stop but don't print. */
2929 /* There was a breakpoint, stop and print. */
2932 /* We hit the longjmp breakpoint. */
2935 /* We hit the longjmp_resume breakpoint. */
2938 /* We hit the step_resume breakpoint. */
2941 /* We hit the through_sigtramp breakpoint. */
2944 /* We hit the shared library event breakpoint. */
2947 /* We caught a shared library event. */
2950 /* This is just used to count how many enums there are. */
2954 /* Here is the table which drives this routine. So that we can
2955 format it pretty, we define some abbreviations for the
2956 enum bpstat_what codes. */
2957 #define kc BPSTAT_WHAT_KEEP_CHECKING
2958 #define ss BPSTAT_WHAT_STOP_SILENT
2959 #define sn BPSTAT_WHAT_STOP_NOISY
2960 #define sgl BPSTAT_WHAT_SINGLE
2961 #define slr BPSTAT_WHAT_SET_LONGJMP_RESUME
2962 #define clr BPSTAT_WHAT_CLEAR_LONGJMP_RESUME
2963 #define clrs BPSTAT_WHAT_CLEAR_LONGJMP_RESUME_SINGLE
2964 #define sr BPSTAT_WHAT_STEP_RESUME
2965 #define ts BPSTAT_WHAT_THROUGH_SIGTRAMP
2966 #define shl BPSTAT_WHAT_CHECK_SHLIBS
2967 #define shlr BPSTAT_WHAT_CHECK_SHLIBS_RESUME_FROM_HOOK
2969 /* "Can't happen." Might want to print an error message.
2970 abort() is not out of the question, but chances are GDB is just
2971 a bit confused, not unusable. */
2972 #define err BPSTAT_WHAT_STOP_NOISY
2974 /* Given an old action and a class, come up with a new action. */
2975 /* One interesting property of this table is that wp_silent is the same
2976 as bp_silent and wp_noisy is the same as bp_noisy. That is because
2977 after stopping, the check for whether to step over a breakpoint
2978 (BPSTAT_WHAT_SINGLE type stuff) is handled in proceed() without
2979 reference to how we stopped. We retain separate wp_silent and
2980 bp_silent codes in case we want to change that someday.
2982 Another possibly interesting property of this table is that
2983 there's a partial ordering, priority-like, of the actions. Once
2984 you've decided that some action is appropriate, you'll never go
2985 back and decide something of a lower priority is better. The
2988 kc < clr sgl shl shlr slr sn sr ss ts
2989 sgl < clrs shl shlr slr sn sr ss ts
2990 slr < err shl shlr sn sr ss ts
2991 clr < clrs err shl shlr sn sr ss ts
2992 clrs < err shl shlr sn sr ss ts
2993 ss < shl shlr sn sr ts
3000 What I think this means is that we don't need a damned table
3001 here. If you just put the rows and columns in the right order,
3002 it'd look awfully regular. We could simply walk the bpstat list
3003 and choose the highest priority action we find, with a little
3004 logic to handle the 'err' cases, and the CLEAR_LONGJMP_RESUME/
3005 CLEAR_LONGJMP_RESUME_SINGLE distinction (which breakpoint.h says
3006 is messy anyway). */
3008 /* step_resume entries: a step resume breakpoint overrides another
3009 breakpoint of signal handling (see comment in wait_for_inferior
3010 at where we set the step_resume breakpoint). */
3011 /* We handle the through_sigtramp_breakpoint the same way; having both
3012 one of those and a step_resume_breakpoint is probably very rare (?). */
3014 static const enum bpstat_what_main_action
3015 table
[(int) class_last
][(int) BPSTAT_WHAT_LAST
] =
3018 /* kc ss sn sgl slr clr clrs sr ts shl shlr
3021 {kc
, ss
, sn
, sgl
, slr
, clr
, clrs
, sr
, ts
, shl
, shlr
},
3023 {ss
, ss
, sn
, ss
, ss
, ss
, ss
, sr
, ts
, shl
, shlr
},
3025 {sn
, sn
, sn
, sn
, sn
, sn
, sn
, sr
, ts
, shl
, shlr
},
3027 {sgl
, ss
, sn
, sgl
, slr
, clrs
, clrs
, sr
, ts
, shl
, shlr
},
3029 {ss
, ss
, sn
, ss
, ss
, ss
, ss
, sr
, ts
, shl
, shlr
},
3031 {sn
, sn
, sn
, sn
, sn
, sn
, sn
, sr
, ts
, shl
, shlr
},
3033 {slr
, ss
, sn
, slr
, slr
, err
, err
, sr
, ts
, shl
, shlr
},
3035 {clr
, ss
, sn
, clrs
, err
, err
, err
, sr
, ts
, shl
, shlr
},
3037 {sr
, sr
, sr
, sr
, sr
, sr
, sr
, sr
, ts
, shl
, shlr
},
3039 {ts
, ts
, ts
, ts
, ts
, ts
, ts
, ts
, ts
, shl
, shlr
},
3041 {shl
, shl
, shl
, shl
, shl
, shl
, shl
, shl
, ts
, shl
, shlr
},
3043 {shlr
, shlr
, shlr
, shlr
, shlr
, shlr
, shlr
, shlr
, ts
, shlr
, shlr
}
3058 enum bpstat_what_main_action current_action
= BPSTAT_WHAT_KEEP_CHECKING
;
3059 struct bpstat_what retval
;
3061 retval
.call_dummy
= 0;
3062 for (; bs
!= NULL
; bs
= bs
->next
)
3064 enum class bs_class
= no_effect
;
3065 if (bs
->breakpoint_at
== NULL
)
3066 /* I suspect this can happen if it was a momentary breakpoint
3067 which has since been deleted. */
3069 switch (bs
->breakpoint_at
->type
)
3075 case bp_hardware_breakpoint
:
3081 bs_class
= bp_noisy
;
3083 bs_class
= bp_silent
;
3086 bs_class
= bp_nostop
;
3089 case bp_hardware_watchpoint
:
3090 case bp_read_watchpoint
:
3091 case bp_access_watchpoint
:
3095 bs_class
= wp_noisy
;
3097 bs_class
= wp_silent
;
3100 /* There was a watchpoint, but we're not stopping.
3101 This requires no further action. */
3102 bs_class
= no_effect
;
3105 bs_class
= long_jump
;
3107 case bp_longjmp_resume
:
3108 bs_class
= long_resume
;
3110 case bp_step_resume
:
3113 bs_class
= step_resume
;
3116 /* It is for the wrong frame. */
3117 bs_class
= bp_nostop
;
3119 case bp_through_sigtramp
:
3120 bs_class
= through_sig
;
3122 case bp_watchpoint_scope
:
3123 bs_class
= bp_nostop
;
3125 case bp_shlib_event
:
3126 bs_class
= shlib_event
;
3128 case bp_thread_event
:
3129 case bp_overlay_event
:
3130 bs_class
= bp_nostop
;
3133 case bp_catch_unload
:
3134 /* Only if this catchpoint triggered should we cause the
3135 step-out-of-dld behaviour. Otherwise, we ignore this
3138 bs_class
= catch_shlib_event
;
3140 bs_class
= no_effect
;
3143 case bp_catch_vfork
:
3148 bs_class
= bp_noisy
;
3150 bs_class
= bp_silent
;
3153 /* There was a catchpoint, but we're not stopping.
3154 This requires no further action. */
3155 bs_class
= no_effect
;
3157 case bp_catch_catch
:
3158 if (!bs
->stop
|| CURRENT_EXCEPTION_KIND
!= EX_EVENT_CATCH
)
3159 bs_class
= bp_nostop
;
3161 bs_class
= bs
->print
? bp_noisy
: bp_silent
;
3163 case bp_catch_throw
:
3164 if (!bs
->stop
|| CURRENT_EXCEPTION_KIND
!= EX_EVENT_THROW
)
3165 bs_class
= bp_nostop
;
3167 bs_class
= bs
->print
? bp_noisy
: bp_silent
;
3170 /* Make sure the action is stop (silent or noisy),
3171 so infrun.c pops the dummy frame. */
3172 bs_class
= bp_silent
;
3173 retval
.call_dummy
= 1;
3176 current_action
= table
[(int) bs_class
][(int) current_action
];
3178 retval
.main_action
= current_action
;
3182 /* Nonzero if we should step constantly (e.g. watchpoints on machines
3183 without hardware support). This isn't related to a specific bpstat,
3184 just to things like whether watchpoints are set. */
3187 bpstat_should_step (void)
3189 struct breakpoint
*b
;
3191 if (breakpoint_enabled (b
) && b
->type
== bp_watchpoint
)
3196 /* Nonzero if there are enabled hardware watchpoints. */
3198 bpstat_have_active_hw_watchpoints (void)
3200 struct bp_location
*bpt
;
3201 ALL_BP_LOCATIONS (bpt
)
3202 if (breakpoint_enabled (bpt
->owner
)
3204 && bpt
->loc_type
== bp_loc_hardware_watchpoint
)
3210 /* Given a bpstat that records zero or more triggered eventpoints, this
3211 function returns another bpstat which contains only the catchpoints
3212 on that first list, if any. */
3214 bpstat_get_triggered_catchpoints (bpstat ep_list
, bpstat
*cp_list
)
3216 struct bpstats root_bs
[1];
3217 bpstat bs
= root_bs
;
3218 struct breakpoint
*ep
;
3221 bpstat_clear (cp_list
);
3222 root_bs
->next
= NULL
;
3224 for (; ep_list
!= NULL
; ep_list
= ep_list
->next
)
3226 /* Is this eventpoint a catchpoint? If not, ignore it. */
3227 ep
= ep_list
->breakpoint_at
;
3230 if ((ep
->type
!= bp_catch_load
) &&
3231 (ep
->type
!= bp_catch_unload
) &&
3232 (ep
->type
!= bp_catch_catch
) &&
3233 (ep
->type
!= bp_catch_throw
))
3234 /* pai: (temp) ADD fork/vfork here!! */
3237 /* Yes; add it to the list. */
3238 bs
= bpstat_alloc (ep
, bs
);
3243 #if defined(SOLIB_ADD)
3244 /* Also, for each triggered catchpoint, tag it with the name of
3245 the library that caused this trigger. (We copy the name now,
3246 because it's only guaranteed to be available NOW, when the
3247 catchpoint triggers. Clients who may wish to know the name
3248 later must get it from the catchpoint itself.) */
3249 if (ep
->triggered_dll_pathname
!= NULL
)
3250 xfree (ep
->triggered_dll_pathname
);
3251 if (ep
->type
== bp_catch_load
)
3252 dll_pathname
= SOLIB_LOADED_LIBRARY_PATHNAME (
3253 PIDGET (inferior_ptid
));
3255 dll_pathname
= SOLIB_UNLOADED_LIBRARY_PATHNAME (
3256 PIDGET (inferior_ptid
));
3258 dll_pathname
= NULL
;
3262 ep
->triggered_dll_pathname
= (char *)
3263 xmalloc (strlen (dll_pathname
) + 1);
3264 strcpy (ep
->triggered_dll_pathname
, dll_pathname
);
3267 ep
->triggered_dll_pathname
= NULL
;
3273 /* Print B to gdb_stdout. */
3275 print_one_breakpoint (struct breakpoint
*b
,
3276 CORE_ADDR
*last_addr
)
3278 struct command_line
*l
;
3280 struct ep_type_description
3285 static struct ep_type_description bptypes
[] =
3287 {bp_none
, "?deleted?"},
3288 {bp_breakpoint
, "breakpoint"},
3289 {bp_hardware_breakpoint
, "hw breakpoint"},
3290 {bp_until
, "until"},
3291 {bp_finish
, "finish"},
3292 {bp_watchpoint
, "watchpoint"},
3293 {bp_hardware_watchpoint
, "hw watchpoint"},
3294 {bp_read_watchpoint
, "read watchpoint"},
3295 {bp_access_watchpoint
, "acc watchpoint"},
3296 {bp_longjmp
, "longjmp"},
3297 {bp_longjmp_resume
, "longjmp resume"},
3298 {bp_step_resume
, "step resume"},
3299 {bp_through_sigtramp
, "sigtramp"},
3300 {bp_watchpoint_scope
, "watchpoint scope"},
3301 {bp_call_dummy
, "call dummy"},
3302 {bp_shlib_event
, "shlib events"},
3303 {bp_thread_event
, "thread events"},
3304 {bp_overlay_event
, "overlay events"},
3305 {bp_catch_load
, "catch load"},
3306 {bp_catch_unload
, "catch unload"},
3307 {bp_catch_fork
, "catch fork"},
3308 {bp_catch_vfork
, "catch vfork"},
3309 {bp_catch_exec
, "catch exec"},
3310 {bp_catch_catch
, "catch catch"},
3311 {bp_catch_throw
, "catch throw"}
3314 static char *bpdisps
[] =
3315 {"del", "dstp", "dis", "keep"};
3316 static char bpenables
[] = "nynny";
3317 char wrap_indent
[80];
3318 struct ui_stream
*stb
= ui_out_stream_new (uiout
);
3319 struct cleanup
*old_chain
= make_cleanup_ui_out_stream_delete (stb
);
3320 struct cleanup
*bkpt_chain
;
3323 bkpt_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "bkpt");
3327 ui_out_field_int (uiout
, "number", b
->number
);
3331 if (((int) b
->type
> (sizeof (bptypes
) / sizeof (bptypes
[0])))
3332 || ((int) b
->type
!= bptypes
[(int) b
->type
].type
))
3333 internal_error (__FILE__
, __LINE__
,
3334 _("bptypes table does not describe type #%d."),
3336 ui_out_field_string (uiout
, "type", bptypes
[(int) b
->type
].description
);
3340 ui_out_field_string (uiout
, "disp", bpdisps
[(int) b
->disposition
]);
3344 ui_out_field_fmt (uiout
, "enabled", "%c", bpenables
[(int) b
->enable_state
]);
3345 ui_out_spaces (uiout
, 2);
3348 strcpy (wrap_indent
, " ");
3351 if (TARGET_ADDR_BIT
<= 32)
3352 strcat (wrap_indent
, " ");
3354 strcat (wrap_indent
, " ");
3357 if (b
->ops
!= NULL
&& b
->ops
->print_one
!= NULL
)
3358 b
->ops
->print_one (b
, last_addr
);
3363 internal_error (__FILE__
, __LINE__
,
3364 _("print_one_breakpoint: bp_none encountered\n"));
3368 case bp_hardware_watchpoint
:
3369 case bp_read_watchpoint
:
3370 case bp_access_watchpoint
:
3371 /* Field 4, the address, is omitted (which makes the columns
3372 not line up too nicely with the headers, but the effect
3373 is relatively readable). */
3375 ui_out_field_skip (uiout
, "addr");
3377 print_expression (b
->exp
, stb
->stream
);
3378 ui_out_field_stream (uiout
, "what", stb
);
3382 case bp_catch_unload
:
3383 /* Field 4, the address, is omitted (which makes the columns
3384 not line up too nicely with the headers, but the effect
3385 is relatively readable). */
3387 ui_out_field_skip (uiout
, "addr");
3389 if (b
->dll_pathname
== NULL
)
3391 ui_out_field_string (uiout
, "what", "<any library>");
3392 ui_out_spaces (uiout
, 1);
3396 ui_out_text (uiout
, "library \"");
3397 ui_out_field_string (uiout
, "what", b
->dll_pathname
);
3398 ui_out_text (uiout
, "\" ");
3403 case bp_catch_vfork
:
3404 /* Field 4, the address, is omitted (which makes the columns
3405 not line up too nicely with the headers, but the effect
3406 is relatively readable). */
3408 ui_out_field_skip (uiout
, "addr");
3410 if (b
->forked_inferior_pid
!= 0)
3412 ui_out_text (uiout
, "process ");
3413 ui_out_field_int (uiout
, "what", b
->forked_inferior_pid
);
3414 ui_out_spaces (uiout
, 1);
3418 /* Field 4, the address, is omitted (which makes the columns
3419 not line up too nicely with the headers, but the effect
3420 is relatively readable). */
3422 ui_out_field_skip (uiout
, "addr");
3424 if (b
->exec_pathname
!= NULL
)
3426 ui_out_text (uiout
, "program \"");
3427 ui_out_field_string (uiout
, "what", b
->exec_pathname
);
3428 ui_out_text (uiout
, "\" ");
3432 case bp_catch_catch
:
3433 /* Field 4, the address, is omitted (which makes the columns
3434 not line up too nicely with the headers, but the effect
3435 is relatively readable). */
3437 ui_out_field_skip (uiout
, "addr");
3439 ui_out_field_string (uiout
, "what", "exception catch");
3440 ui_out_spaces (uiout
, 1);
3443 case bp_catch_throw
:
3444 /* Field 4, the address, is omitted (which makes the columns
3445 not line up too nicely with the headers, but the effect
3446 is relatively readable). */
3448 ui_out_field_skip (uiout
, "addr");
3450 ui_out_field_string (uiout
, "what", "exception throw");
3451 ui_out_spaces (uiout
, 1);
3455 case bp_hardware_breakpoint
:
3459 case bp_longjmp_resume
:
3460 case bp_step_resume
:
3461 case bp_through_sigtramp
:
3462 case bp_watchpoint_scope
:
3464 case bp_shlib_event
:
3465 case bp_thread_event
:
3466 case bp_overlay_event
:
3471 ui_out_field_string (uiout
, "addr", "<PENDING>");
3473 ui_out_field_core_addr (uiout
, "addr", b
->loc
->address
);
3476 *last_addr
= b
->loc
->address
;
3479 sym
= find_pc_sect_function (b
->loc
->address
, b
->loc
->section
);
3482 ui_out_text (uiout
, "in ");
3483 ui_out_field_string (uiout
, "func",
3484 SYMBOL_PRINT_NAME (sym
));
3485 ui_out_wrap_hint (uiout
, wrap_indent
);
3486 ui_out_text (uiout
, " at ");
3488 ui_out_field_string (uiout
, "file", b
->source_file
);
3489 ui_out_text (uiout
, ":");
3490 ui_out_field_int (uiout
, "line", b
->line_number
);
3492 else if (b
->pending
)
3494 ui_out_field_string (uiout
, "pending", b
->addr_string
);
3498 print_address_symbolic (b
->loc
->address
, stb
->stream
, demangle
, "");
3499 ui_out_field_stream (uiout
, "at", stb
);
3504 if (b
->thread
!= -1)
3506 /* FIXME: This seems to be redundant and lost here; see the
3507 "stop only in" line a little further down. */
3508 ui_out_text (uiout
, " thread ");
3509 ui_out_field_int (uiout
, "thread", b
->thread
);
3512 ui_out_text (uiout
, "\n");
3514 if (frame_id_p (b
->frame_id
))
3517 ui_out_text (uiout
, "\tstop only in stack frame at ");
3518 /* FIXME: cagney/2002-12-01: Shouldn't be poeking around inside
3520 ui_out_field_core_addr (uiout
, "frame", b
->frame_id
.stack_addr
);
3521 ui_out_text (uiout
, "\n");
3527 ui_out_text (uiout
, "\tstop only if ");
3528 print_expression (b
->cond
, stb
->stream
);
3529 ui_out_field_stream (uiout
, "cond", stb
);
3530 ui_out_text (uiout
, "\n");
3533 if (b
->pending
&& b
->cond_string
)
3536 ui_out_text (uiout
, "\tstop only if ");
3537 ui_out_field_string (uiout
, "cond", b
->cond_string
);
3538 ui_out_text (uiout
, "\n");
3541 if (b
->thread
!= -1)
3543 /* FIXME should make an annotation for this */
3544 ui_out_text (uiout
, "\tstop only in thread ");
3545 ui_out_field_int (uiout
, "thread", b
->thread
);
3546 ui_out_text (uiout
, "\n");
3549 if (show_breakpoint_hit_counts
&& b
->hit_count
)
3551 /* FIXME should make an annotation for this */
3552 if (ep_is_catchpoint (b
))
3553 ui_out_text (uiout
, "\tcatchpoint");
3555 ui_out_text (uiout
, "\tbreakpoint");
3556 ui_out_text (uiout
, " already hit ");
3557 ui_out_field_int (uiout
, "times", b
->hit_count
);
3558 if (b
->hit_count
== 1)
3559 ui_out_text (uiout
, " time\n");
3561 ui_out_text (uiout
, " times\n");
3564 /* Output the count also if it is zero, but only if this is
3565 mi. FIXME: Should have a better test for this. */
3566 if (ui_out_is_mi_like_p (uiout
))
3567 if (show_breakpoint_hit_counts
&& b
->hit_count
== 0)
3568 ui_out_field_int (uiout
, "times", b
->hit_count
);
3570 if (b
->ignore_count
)
3573 ui_out_text (uiout
, "\tignore next ");
3574 ui_out_field_int (uiout
, "ignore", b
->ignore_count
);
3575 ui_out_text (uiout
, " hits\n");
3578 if ((l
= b
->commands
))
3580 struct cleanup
*script_chain
;
3583 script_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "script");
3584 print_command_lines (uiout
, l
, 4);
3585 do_cleanups (script_chain
);
3587 do_cleanups (bkpt_chain
);
3588 do_cleanups (old_chain
);
3591 struct captured_breakpoint_query_args
3597 do_captured_breakpoint_query (struct ui_out
*uiout
, void *data
)
3599 struct captured_breakpoint_query_args
*args
= data
;
3600 struct breakpoint
*b
;
3601 CORE_ADDR dummy_addr
= 0;
3604 if (args
->bnum
== b
->number
)
3606 print_one_breakpoint (b
, &dummy_addr
);
3614 gdb_breakpoint_query (struct ui_out
*uiout
, int bnum
, char **error_message
)
3616 struct captured_breakpoint_query_args args
;
3618 /* For the moment we don't trust print_one_breakpoint() to not throw
3620 return catch_exceptions_with_msg (uiout
, do_captured_breakpoint_query
, &args
,
3621 error_message
, RETURN_MASK_ALL
);
3624 /* Return non-zero if B is user settable (breakpoints, watchpoints,
3625 catchpoints, et.al.). */
3628 user_settable_breakpoint (const struct breakpoint
*b
)
3630 return (b
->type
== bp_breakpoint
3631 || b
->type
== bp_catch_load
3632 || b
->type
== bp_catch_unload
3633 || b
->type
== bp_catch_fork
3634 || b
->type
== bp_catch_vfork
3635 || b
->type
== bp_catch_exec
3636 || b
->type
== bp_catch_catch
3637 || b
->type
== bp_catch_throw
3638 || b
->type
== bp_hardware_breakpoint
3639 || b
->type
== bp_watchpoint
3640 || b
->type
== bp_read_watchpoint
3641 || b
->type
== bp_access_watchpoint
3642 || b
->type
== bp_hardware_watchpoint
);
3645 /* Print information on user settable breakpoint (watchpoint, etc)
3646 number BNUM. If BNUM is -1 print all user settable breakpoints.
3647 If ALLFLAG is non-zero, include non- user settable breakpoints. */
3650 breakpoint_1 (int bnum
, int allflag
)
3652 struct breakpoint
*b
;
3653 CORE_ADDR last_addr
= (CORE_ADDR
) -1;
3654 int nr_printable_breakpoints
;
3655 struct cleanup
*bkpttbl_chain
;
3657 /* Compute the number of rows in the table. */
3658 nr_printable_breakpoints
= 0;
3661 || bnum
== b
->number
)
3663 if (allflag
|| user_settable_breakpoint (b
))
3664 nr_printable_breakpoints
++;
3669 = make_cleanup_ui_out_table_begin_end (uiout
, 6, nr_printable_breakpoints
,
3673 = make_cleanup_ui_out_table_begin_end (uiout
, 5, nr_printable_breakpoints
,
3676 if (nr_printable_breakpoints
> 0)
3677 annotate_breakpoints_headers ();
3678 if (nr_printable_breakpoints
> 0)
3680 ui_out_table_header (uiout
, 3, ui_left
, "number", "Num"); /* 1 */
3681 if (nr_printable_breakpoints
> 0)
3683 ui_out_table_header (uiout
, 14, ui_left
, "type", "Type"); /* 2 */
3684 if (nr_printable_breakpoints
> 0)
3686 ui_out_table_header (uiout
, 4, ui_left
, "disp", "Disp"); /* 3 */
3687 if (nr_printable_breakpoints
> 0)
3689 ui_out_table_header (uiout
, 3, ui_left
, "enabled", "Enb"); /* 4 */
3692 if (nr_printable_breakpoints
> 0)
3694 if (TARGET_ADDR_BIT
<= 32)
3695 ui_out_table_header (uiout
, 10, ui_left
, "addr", "Address");/* 5 */
3697 ui_out_table_header (uiout
, 18, ui_left
, "addr", "Address");/* 5 */
3699 if (nr_printable_breakpoints
> 0)
3701 ui_out_table_header (uiout
, 40, ui_noalign
, "what", "What"); /* 6 */
3702 ui_out_table_body (uiout
);
3703 if (nr_printable_breakpoints
> 0)
3704 annotate_breakpoints_table ();
3708 || bnum
== b
->number
)
3710 /* We only print out user settable breakpoints unless the
3712 if (allflag
|| user_settable_breakpoint (b
))
3713 print_one_breakpoint (b
, &last_addr
);
3716 do_cleanups (bkpttbl_chain
);
3718 if (nr_printable_breakpoints
== 0)
3721 ui_out_message (uiout
, 0, "No breakpoints or watchpoints.\n");
3723 ui_out_message (uiout
, 0, "No breakpoint or watchpoint number %d.\n",
3728 /* Compare against (CORE_ADDR)-1 in case some compiler decides
3729 that a comparison of an unsigned with -1 is always false. */
3730 if (last_addr
!= (CORE_ADDR
) -1)
3731 set_next_address (last_addr
);
3734 /* FIXME? Should this be moved up so that it is only called when
3735 there have been breakpoints? */
3736 annotate_breakpoints_table_end ();
3740 breakpoints_info (char *bnum_exp
, int from_tty
)
3745 bnum
= parse_and_eval_long (bnum_exp
);
3747 breakpoint_1 (bnum
, 0);
3751 maintenance_info_breakpoints (char *bnum_exp
, int from_tty
)
3756 bnum
= parse_and_eval_long (bnum_exp
);
3758 breakpoint_1 (bnum
, 1);
3761 /* Print a message describing any breakpoints set at PC. */
3764 describe_other_breakpoints (CORE_ADDR pc
, asection
*section
)
3767 struct breakpoint
*b
;
3770 if (b
->loc
->address
== pc
) /* address match / overlay match */
3771 if (!b
->pending
&& (!overlay_debugging
|| b
->loc
->section
== section
))
3776 printf_filtered (_("Note: breakpoint "));
3777 else /* if (others == ???) */
3778 printf_filtered (_("Note: breakpoints "));
3780 if (b
->loc
->address
== pc
) /* address match / overlay match */
3781 if (!b
->pending
&& (!overlay_debugging
|| b
->loc
->section
== section
))
3784 printf_filtered ("%d%s%s ",
3786 ((b
->enable_state
== bp_disabled
||
3787 b
->enable_state
== bp_shlib_disabled
||
3788 b
->enable_state
== bp_call_disabled
)
3790 : b
->enable_state
== bp_permanent
3794 : ((others
== 1) ? " and" : ""));
3796 printf_filtered (_("also set at pc "));
3797 deprecated_print_address_numeric (pc
, 1, gdb_stdout
);
3798 printf_filtered (".\n");
3802 /* Set the default place to put a breakpoint
3803 for the `break' command with no arguments. */
3806 set_default_breakpoint (int valid
, CORE_ADDR addr
, struct symtab
*symtab
,
3809 default_breakpoint_valid
= valid
;
3810 default_breakpoint_address
= addr
;
3811 default_breakpoint_symtab
= symtab
;
3812 default_breakpoint_line
= line
;
3815 /* Return true iff it is meaningful to use the address member of
3816 BPT. For some breakpoint types, the address member is irrelevant
3817 and it makes no sense to attempt to compare it to other addresses
3818 (or use it for any other purpose either).
3820 More specifically, each of the following breakpoint types will always
3821 have a zero valued address and we don't want check_duplicates() to mark
3822 breakpoints of any of these types to be a duplicate of an actual
3823 breakpoint at address zero:
3826 bp_hardware_watchpoint
3828 bp_access_watchpoint
3835 breakpoint_address_is_meaningful (struct breakpoint
*bpt
)
3837 enum bptype type
= bpt
->type
;
3839 return (type
!= bp_watchpoint
3840 && type
!= bp_hardware_watchpoint
3841 && type
!= bp_read_watchpoint
3842 && type
!= bp_access_watchpoint
3843 && type
!= bp_catch_exec
3844 && type
!= bp_longjmp_resume
3845 && type
!= bp_catch_fork
3846 && type
!= bp_catch_vfork
);
3849 /* Rescan breakpoints at the same address and section as BPT,
3850 marking the first one as "first" and any others as "duplicates".
3851 This is so that the bpt instruction is only inserted once.
3852 If we have a permanent breakpoint at the same place as BPT, make
3853 that one the official one, and the rest as duplicates. */
3856 check_duplicates (struct breakpoint
*bpt
)
3858 struct bp_location
*b
;
3860 struct bp_location
*perm_bp
= 0;
3861 CORE_ADDR address
= bpt
->loc
->address
;
3862 asection
*section
= bpt
->loc
->section
;
3864 if (! breakpoint_address_is_meaningful (bpt
))
3867 ALL_BP_LOCATIONS (b
)
3868 if (b
->owner
->enable_state
!= bp_disabled
3869 && b
->owner
->enable_state
!= bp_shlib_disabled
3870 && !b
->owner
->pending
3871 && b
->owner
->enable_state
!= bp_call_disabled
3872 && b
->address
== address
/* address / overlay match */
3873 && (!overlay_debugging
|| b
->section
== section
)
3874 && breakpoint_address_is_meaningful (b
->owner
))
3876 /* Have we found a permanent breakpoint? */
3877 if (b
->owner
->enable_state
== bp_permanent
)
3884 b
->duplicate
= count
> 1;
3887 /* If we found a permanent breakpoint at this address, go over the
3888 list again and declare all the other breakpoints there to be the
3892 perm_bp
->duplicate
= 0;
3894 /* Permanent breakpoint should always be inserted. */
3895 if (! perm_bp
->inserted
)
3896 internal_error (__FILE__
, __LINE__
,
3897 _("allegedly permanent breakpoint is not "
3898 "actually inserted"));
3900 ALL_BP_LOCATIONS (b
)
3903 if (b
->owner
->enable_state
!= bp_disabled
3904 && b
->owner
->enable_state
!= bp_shlib_disabled
3905 && !b
->owner
->pending
3906 && b
->owner
->enable_state
!= bp_call_disabled
3907 && b
->address
== address
/* address / overlay match */
3908 && (!overlay_debugging
|| b
->section
== section
)
3909 && breakpoint_address_is_meaningful (b
->owner
))
3912 internal_error (__FILE__
, __LINE__
,
3913 _("another breakpoint was inserted on top of "
3914 "a permanent breakpoint"));
3923 breakpoint_adjustment_warning (CORE_ADDR from_addr
, CORE_ADDR to_addr
,
3924 int bnum
, int have_bnum
)
3929 strcpy (astr1
, hex_string_custom ((unsigned long) from_addr
, 8));
3930 strcpy (astr2
, hex_string_custom ((unsigned long) to_addr
, 8));
3932 warning (_("Breakpoint %d address previously adjusted from %s to %s."),
3933 bnum
, astr1
, astr2
);
3935 warning (_("Breakpoint address adjusted from %s to %s."), astr1
, astr2
);
3938 /* Adjust a breakpoint's address to account for architectural constraints
3939 on breakpoint placement. Return the adjusted address. Note: Very
3940 few targets require this kind of adjustment. For most targets,
3941 this function is simply the identity function. */
3944 adjust_breakpoint_address (CORE_ADDR bpaddr
, enum bptype bptype
)
3946 if (!gdbarch_adjust_breakpoint_address_p (current_gdbarch
))
3948 /* Very few targets need any kind of breakpoint adjustment. */
3951 else if (bptype
== bp_watchpoint
3952 || bptype
== bp_hardware_watchpoint
3953 || bptype
== bp_read_watchpoint
3954 || bptype
== bp_access_watchpoint
3955 || bptype
== bp_catch_fork
3956 || bptype
== bp_catch_vfork
3957 || bptype
== bp_catch_exec
)
3959 /* Watchpoints and the various bp_catch_* eventpoints should not
3960 have their addresses modified. */
3965 CORE_ADDR adjusted_bpaddr
;
3967 /* Some targets have architectural constraints on the placement
3968 of breakpoint instructions. Obtain the adjusted address. */
3969 adjusted_bpaddr
= gdbarch_adjust_breakpoint_address (current_gdbarch
,
3972 /* An adjusted breakpoint address can significantly alter
3973 a user's expectations. Print a warning if an adjustment
3975 if (adjusted_bpaddr
!= bpaddr
)
3976 breakpoint_adjustment_warning (bpaddr
, adjusted_bpaddr
, 0, 0);
3978 return adjusted_bpaddr
;
3982 /* Allocate a struct bp_location. */
3984 static struct bp_location
*
3985 allocate_bp_location (struct breakpoint
*bpt
, enum bptype bp_type
)
3987 struct bp_location
*loc
, *loc_p
;
3989 loc
= xmalloc (sizeof (struct bp_location
));
3990 memset (loc
, 0, sizeof (*loc
));
4000 case bp_longjmp_resume
:
4001 case bp_step_resume
:
4002 case bp_through_sigtramp
:
4003 case bp_watchpoint_scope
:
4005 case bp_shlib_event
:
4006 case bp_thread_event
:
4007 case bp_overlay_event
:
4009 case bp_catch_unload
:
4010 loc
->loc_type
= bp_loc_software_breakpoint
;
4012 case bp_hardware_breakpoint
:
4013 loc
->loc_type
= bp_loc_hardware_breakpoint
;
4015 case bp_hardware_watchpoint
:
4016 case bp_read_watchpoint
:
4017 case bp_access_watchpoint
:
4018 loc
->loc_type
= bp_loc_hardware_watchpoint
;
4022 case bp_catch_vfork
:
4024 case bp_catch_catch
:
4025 case bp_catch_throw
:
4026 loc
->loc_type
= bp_loc_other
;
4029 internal_error (__FILE__
, __LINE__
, _("unknown breakpoint type"));
4032 /* Add this breakpoint to the end of the chain. */
4034 loc_p
= bp_location_chain
;
4036 bp_location_chain
= loc
;
4040 loc_p
= loc_p
->next
;
4047 /* set_raw_breakpoint() is a low level routine for allocating and
4048 partially initializing a breakpoint of type BPTYPE. The newly
4049 created breakpoint's address, section, source file name, and line
4050 number are provided by SAL. The newly created and partially
4051 initialized breakpoint is added to the breakpoint chain and
4052 is also returned as the value of this function.
4054 It is expected that the caller will complete the initialization of
4055 the newly created breakpoint struct as well as output any status
4056 information regarding the creation of a new breakpoint. In
4057 particular, set_raw_breakpoint() does NOT set the breakpoint
4058 number! Care should be taken to not allow an error() to occur
4059 prior to completing the initialization of the breakpoint. If this
4060 should happen, a bogus breakpoint will be left on the chain. */
4063 set_raw_breakpoint (struct symtab_and_line sal
, enum bptype bptype
)
4065 struct breakpoint
*b
, *b1
;
4067 b
= (struct breakpoint
*) xmalloc (sizeof (struct breakpoint
));
4068 memset (b
, 0, sizeof (*b
));
4069 b
->loc
= allocate_bp_location (b
, bptype
);
4070 b
->loc
->requested_address
= sal
.pc
;
4071 b
->loc
->address
= adjust_breakpoint_address (b
->loc
->requested_address
,
4073 if (sal
.symtab
== NULL
)
4074 b
->source_file
= NULL
;
4076 b
->source_file
= savestring (sal
.symtab
->filename
,
4077 strlen (sal
.symtab
->filename
));
4078 b
->loc
->section
= sal
.section
;
4080 b
->language
= current_language
->la_language
;
4081 b
->input_radix
= input_radix
;
4083 b
->line_number
= sal
.line
;
4084 b
->enable_state
= bp_enabled
;
4087 b
->ignore_count
= 0;
4089 b
->frame_id
= null_frame_id
;
4090 b
->dll_pathname
= NULL
;
4091 b
->triggered_dll_pathname
= NULL
;
4092 b
->forked_inferior_pid
= 0;
4093 b
->exec_pathname
= NULL
;
4097 /* Add this breakpoint to the end of the chain
4098 so that a list of breakpoints will come out in order
4099 of increasing numbers. */
4101 b1
= breakpoint_chain
;
4103 breakpoint_chain
= b
;
4111 check_duplicates (b
);
4112 breakpoints_changed ();
4118 /* Note that the breakpoint object B describes a permanent breakpoint
4119 instruction, hard-wired into the inferior's code. */
4121 make_breakpoint_permanent (struct breakpoint
*b
)
4123 b
->enable_state
= bp_permanent
;
4125 /* By definition, permanent breakpoints are already present in the code. */
4126 b
->loc
->inserted
= 1;
4129 static struct breakpoint
*
4130 create_internal_breakpoint (CORE_ADDR address
, enum bptype type
)
4132 static int internal_breakpoint_number
= -1;
4133 struct symtab_and_line sal
;
4134 struct breakpoint
*b
;
4136 init_sal (&sal
); /* initialize to zeroes */
4139 sal
.section
= find_pc_overlay (sal
.pc
);
4141 b
= set_raw_breakpoint (sal
, type
);
4142 b
->number
= internal_breakpoint_number
--;
4143 b
->disposition
= disp_donttouch
;
4150 create_longjmp_breakpoint (char *func_name
)
4152 struct breakpoint
*b
;
4153 struct minimal_symbol
*m
;
4155 if (func_name
== NULL
)
4156 b
= create_internal_breakpoint (0, bp_longjmp_resume
);
4159 if ((m
= lookup_minimal_symbol_text (func_name
, NULL
)) == NULL
)
4162 b
= create_internal_breakpoint (SYMBOL_VALUE_ADDRESS (m
), bp_longjmp
);
4165 b
->enable_state
= bp_disabled
;
4168 b
->addr_string
= xstrdup (func_name
);
4171 /* Call this routine when stepping and nexting to enable a breakpoint
4172 if we do a longjmp(). When we hit that breakpoint, call
4173 set_longjmp_resume_breakpoint() to figure out where we are going. */
4176 enable_longjmp_breakpoint (void)
4178 struct breakpoint
*b
;
4181 if (b
->type
== bp_longjmp
)
4183 b
->enable_state
= bp_enabled
;
4184 check_duplicates (b
);
4189 disable_longjmp_breakpoint (void)
4191 struct breakpoint
*b
;
4194 if (b
->type
== bp_longjmp
4195 || b
->type
== bp_longjmp_resume
)
4197 b
->enable_state
= bp_disabled
;
4198 check_duplicates (b
);
4203 create_overlay_event_breakpoint (char *func_name
)
4205 struct breakpoint
*b
;
4206 struct minimal_symbol
*m
;
4208 if ((m
= lookup_minimal_symbol_text (func_name
, NULL
)) == NULL
)
4211 b
= create_internal_breakpoint (SYMBOL_VALUE_ADDRESS (m
),
4213 b
->addr_string
= xstrdup (func_name
);
4215 if (overlay_debugging
== ovly_auto
)
4217 b
->enable_state
= bp_enabled
;
4218 overlay_events_enabled
= 1;
4222 b
->enable_state
= bp_disabled
;
4223 overlay_events_enabled
= 0;
4228 enable_overlay_breakpoints (void)
4230 struct breakpoint
*b
;
4233 if (b
->type
== bp_overlay_event
)
4235 b
->enable_state
= bp_enabled
;
4236 check_duplicates (b
);
4237 overlay_events_enabled
= 1;
4242 disable_overlay_breakpoints (void)
4244 struct breakpoint
*b
;
4247 if (b
->type
== bp_overlay_event
)
4249 b
->enable_state
= bp_disabled
;
4250 check_duplicates (b
);
4251 overlay_events_enabled
= 0;
4256 create_thread_event_breakpoint (CORE_ADDR address
)
4258 struct breakpoint
*b
;
4260 b
= create_internal_breakpoint (address
, bp_thread_event
);
4262 b
->enable_state
= bp_enabled
;
4263 /* addr_string has to be used or breakpoint_re_set will delete me. */
4264 b
->addr_string
= xstrprintf ("*0x%s", paddr (b
->loc
->address
));
4270 remove_thread_event_breakpoints (void)
4272 struct breakpoint
*b
, *temp
;
4274 ALL_BREAKPOINTS_SAFE (b
, temp
)
4275 if (b
->type
== bp_thread_event
)
4276 delete_breakpoint (b
);
4279 struct captured_parse_breakpoint_args
4282 struct symtabs_and_lines
*sals_p
;
4283 char ***addr_string_p
;
4287 struct lang_and_radix
4293 /* Cleanup helper routine to restore the current language and
4296 do_restore_lang_radix_cleanup (void *old
)
4298 struct lang_and_radix
*p
= old
;
4299 set_language (p
->lang
);
4300 input_radix
= p
->radix
;
4303 /* Try and resolve a pending breakpoint. */
4305 resolve_pending_breakpoint (struct breakpoint
*b
)
4307 /* Try and reparse the breakpoint in case the shared library
4309 struct symtabs_and_lines sals
;
4310 struct symtab_and_line pending_sal
;
4311 char **cond_string
= (char **) NULL
;
4312 char *copy_arg
= b
->addr_string
;
4317 struct ui_file
*old_gdb_stderr
;
4318 struct lang_and_radix old_lr
;
4319 struct cleanup
*old_chain
;
4321 /* Set language, input-radix, then reissue breakpoint command.
4322 Ensure the language and input-radix are restored afterwards. */
4323 old_lr
.lang
= current_language
->la_language
;
4324 old_lr
.radix
= input_radix
;
4325 old_chain
= make_cleanup (do_restore_lang_radix_cleanup
, &old_lr
);
4327 set_language (b
->language
);
4328 input_radix
= b
->input_radix
;
4329 rc
= break_command_1 (b
->addr_string
, b
->flag
, b
->from_tty
, b
);
4331 if (rc
== GDB_RC_OK
)
4332 /* Pending breakpoint has been resolved. */
4333 printf_filtered (_("Pending breakpoint \"%s\" resolved\n"), b
->addr_string
);
4335 do_cleanups (old_chain
);
4340 remove_solib_event_breakpoints (void)
4342 struct breakpoint
*b
, *temp
;
4344 ALL_BREAKPOINTS_SAFE (b
, temp
)
4345 if (b
->type
== bp_shlib_event
)
4346 delete_breakpoint (b
);
4350 create_solib_event_breakpoint (CORE_ADDR address
)
4352 struct breakpoint
*b
;
4354 b
= create_internal_breakpoint (address
, bp_shlib_event
);
4358 /* Disable any breakpoints that are on code in shared libraries. Only
4359 apply to enabled breakpoints, disabled ones can just stay disabled. */
4362 disable_breakpoints_in_shlibs (int silent
)
4364 struct breakpoint
*b
;
4365 int disabled_shlib_breaks
= 0;
4367 /* See also: insert_breakpoints, under DISABLE_UNSETTABLE_BREAK. */
4370 if (((b
->type
== bp_breakpoint
) || (b
->type
== bp_hardware_breakpoint
))
4371 && breakpoint_enabled (b
) && !b
->loc
->duplicate
4373 && PC_SOLIB (b
->loc
->address
)
4375 && solib_address (b
->loc
->address
)
4379 b
->enable_state
= bp_shlib_disabled
;
4382 if (!disabled_shlib_breaks
)
4384 target_terminal_ours_for_output ();
4385 warning (_("Temporarily disabling shared library breakpoints:"));
4387 disabled_shlib_breaks
= 1;
4388 warning (_("breakpoint #%d "), b
->number
);
4394 /* Disable any breakpoints that are in in an unloaded shared library. Only
4395 apply to enabled breakpoints, disabled ones can just stay disabled. */
4398 disable_breakpoints_in_unloaded_shlib (struct so_list
*solib
)
4400 struct breakpoint
*b
;
4401 int disabled_shlib_breaks
= 0;
4403 /* See also: insert_breakpoints, under DISABLE_UNSETTABLE_BREAK. */
4406 if ((b
->loc
->loc_type
== bp_loc_hardware_breakpoint
4407 || b
->loc
->loc_type
== bp_loc_software_breakpoint
)
4408 && breakpoint_enabled (b
) && !b
->loc
->duplicate
)
4411 char *so_name
= PC_SOLIB (b
->loc
->address
);
4413 char *so_name
= solib_address (b
->loc
->address
);
4415 if (so_name
&& !strcmp (so_name
, solib
->so_name
))
4417 b
->enable_state
= bp_shlib_disabled
;
4418 /* At this point, we cannot rely on remove_breakpoint
4419 succeeding so we must mark the breakpoint as not inserted
4420 to prevent future errors occurring in remove_breakpoints. */
4421 b
->loc
->inserted
= 0;
4422 if (!disabled_shlib_breaks
)
4424 target_terminal_ours_for_output ();
4425 warning (_("Temporarily disabling breakpoints for unloaded shared library \"%s\""),
4428 disabled_shlib_breaks
= 1;
4434 /* Try to reenable any breakpoints in shared libraries. */
4436 re_enable_breakpoints_in_shlibs (void)
4438 struct breakpoint
*b
, *tmp
;
4440 ALL_BREAKPOINTS_SAFE (b
, tmp
)
4442 if (b
->enable_state
== bp_shlib_disabled
)
4446 /* Do not reenable the breakpoint if the shared library is
4447 still not mapped in. */
4449 lib
= PC_SOLIB (b
->loc
->address
);
4451 lib
= solib_address (b
->loc
->address
);
4453 if (lib
!= NULL
&& target_read_memory (b
->loc
->address
, buf
, 1) == 0)
4454 b
->enable_state
= bp_enabled
;
4456 else if (b
->pending
&& (b
->enable_state
== bp_enabled
))
4458 if (resolve_pending_breakpoint (b
) == GDB_RC_OK
)
4459 delete_breakpoint (b
);
4465 solib_load_unload_1 (char *hookname
, int tempflag
, char *dll_pathname
,
4466 char *cond_string
, enum bptype bp_kind
)
4468 struct breakpoint
*b
;
4469 struct symtabs_and_lines sals
;
4470 struct cleanup
*old_chain
;
4471 struct cleanup
*canonical_strings_chain
= NULL
;
4472 char *addr_start
= hookname
;
4473 char *addr_end
= NULL
;
4474 char **canonical
= (char **) NULL
;
4475 int thread
= -1; /* All threads. */
4477 /* Set a breakpoint on the specified hook. */
4478 sals
= decode_line_1 (&hookname
, 1, (struct symtab
*) NULL
,
4479 0, &canonical
, NULL
);
4480 addr_end
= hookname
;
4482 if (sals
.nelts
== 0)
4484 warning (_("Unable to set a breakpoint on dynamic linker callback.\n"
4485 "Suggest linking with /opt/langtools/lib/end.o.\n"
4486 "GDB will be unable to track shl_load/shl_unload calls."));
4489 if (sals
.nelts
!= 1)
4491 warning (_("Unable to set unique breakpoint on dynamic linker callback.\n"
4492 "GDB will be unable to track shl_load/shl_unload calls."));
4496 /* Make sure that all storage allocated in decode_line_1 gets freed
4497 in case the following errors out. */
4498 old_chain
= make_cleanup (xfree
, sals
.sals
);
4499 if (canonical
!= (char **) NULL
)
4501 make_cleanup (xfree
, canonical
);
4502 canonical_strings_chain
= make_cleanup (null_cleanup
, 0);
4503 if (canonical
[0] != NULL
)
4504 make_cleanup (xfree
, canonical
[0]);
4507 resolve_sal_pc (&sals
.sals
[0]);
4509 /* Remove the canonical strings from the cleanup, they are needed below. */
4510 if (canonical
!= (char **) NULL
)
4511 discard_cleanups (canonical_strings_chain
);
4513 b
= set_raw_breakpoint (sals
.sals
[0], bp_kind
);
4514 set_breakpoint_count (breakpoint_count
+ 1);
4515 b
->number
= breakpoint_count
;
4517 b
->cond_string
= (cond_string
== NULL
) ?
4518 NULL
: savestring (cond_string
, strlen (cond_string
));
4521 if (canonical
!= (char **) NULL
&& canonical
[0] != NULL
)
4522 b
->addr_string
= canonical
[0];
4523 else if (addr_start
)
4524 b
->addr_string
= savestring (addr_start
, addr_end
- addr_start
);
4526 b
->enable_state
= bp_enabled
;
4527 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
4529 if (dll_pathname
== NULL
)
4530 b
->dll_pathname
= NULL
;
4533 b
->dll_pathname
= (char *) xmalloc (strlen (dll_pathname
) + 1);
4534 strcpy (b
->dll_pathname
, dll_pathname
);
4538 do_cleanups (old_chain
);
4542 create_solib_load_event_breakpoint (char *hookname
, int tempflag
,
4543 char *dll_pathname
, char *cond_string
)
4545 solib_load_unload_1 (hookname
, tempflag
, dll_pathname
,
4546 cond_string
, bp_catch_load
);
4550 create_solib_unload_event_breakpoint (char *hookname
, int tempflag
,
4551 char *dll_pathname
, char *cond_string
)
4553 solib_load_unload_1 (hookname
, tempflag
, dll_pathname
,
4554 cond_string
, bp_catch_unload
);
4558 create_fork_vfork_event_catchpoint (int tempflag
, char *cond_string
,
4559 enum bptype bp_kind
)
4561 struct symtab_and_line sal
;
4562 struct breakpoint
*b
;
4563 int thread
= -1; /* All threads. */
4570 b
= set_raw_breakpoint (sal
, bp_kind
);
4571 set_breakpoint_count (breakpoint_count
+ 1);
4572 b
->number
= breakpoint_count
;
4574 b
->cond_string
= (cond_string
== NULL
) ?
4575 NULL
: savestring (cond_string
, strlen (cond_string
));
4577 b
->addr_string
= NULL
;
4578 b
->enable_state
= bp_enabled
;
4579 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
4580 b
->forked_inferior_pid
= 0;
4586 create_fork_event_catchpoint (int tempflag
, char *cond_string
)
4588 create_fork_vfork_event_catchpoint (tempflag
, cond_string
, bp_catch_fork
);
4592 create_vfork_event_catchpoint (int tempflag
, char *cond_string
)
4594 create_fork_vfork_event_catchpoint (tempflag
, cond_string
, bp_catch_vfork
);
4598 create_exec_event_catchpoint (int tempflag
, char *cond_string
)
4600 struct symtab_and_line sal
;
4601 struct breakpoint
*b
;
4602 int thread
= -1; /* All threads. */
4609 b
= set_raw_breakpoint (sal
, bp_catch_exec
);
4610 set_breakpoint_count (breakpoint_count
+ 1);
4611 b
->number
= breakpoint_count
;
4613 b
->cond_string
= (cond_string
== NULL
) ?
4614 NULL
: savestring (cond_string
, strlen (cond_string
));
4616 b
->addr_string
= NULL
;
4617 b
->enable_state
= bp_enabled
;
4618 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
4624 hw_breakpoint_used_count (void)
4626 struct breakpoint
*b
;
4631 if (b
->type
== bp_hardware_breakpoint
&& b
->enable_state
== bp_enabled
)
4639 hw_watchpoint_used_count (enum bptype type
, int *other_type_used
)
4641 struct breakpoint
*b
;
4644 *other_type_used
= 0;
4647 if (breakpoint_enabled (b
))
4649 if (b
->type
== type
)
4651 else if ((b
->type
== bp_hardware_watchpoint
||
4652 b
->type
== bp_read_watchpoint
||
4653 b
->type
== bp_access_watchpoint
))
4654 *other_type_used
= 1;
4660 /* Call this after hitting the longjmp() breakpoint. Use this to set
4661 a new breakpoint at the target of the jmp_buf.
4663 FIXME - This ought to be done by setting a temporary breakpoint
4664 that gets deleted automatically... */
4667 set_longjmp_resume_breakpoint (CORE_ADDR pc
, struct frame_id frame_id
)
4669 struct breakpoint
*b
;
4672 if (b
->type
== bp_longjmp_resume
)
4674 b
->loc
->requested_address
= pc
;
4675 b
->loc
->address
= adjust_breakpoint_address (b
->loc
->requested_address
,
4677 b
->enable_state
= bp_enabled
;
4678 b
->frame_id
= frame_id
;
4679 check_duplicates (b
);
4685 disable_watchpoints_before_interactive_call_start (void)
4687 struct breakpoint
*b
;
4691 if (((b
->type
== bp_watchpoint
)
4692 || (b
->type
== bp_hardware_watchpoint
)
4693 || (b
->type
== bp_read_watchpoint
)
4694 || (b
->type
== bp_access_watchpoint
)
4695 || ep_is_exception_catchpoint (b
))
4696 && breakpoint_enabled (b
))
4698 b
->enable_state
= bp_call_disabled
;
4699 check_duplicates (b
);
4705 enable_watchpoints_after_interactive_call_stop (void)
4707 struct breakpoint
*b
;
4711 if (((b
->type
== bp_watchpoint
)
4712 || (b
->type
== bp_hardware_watchpoint
)
4713 || (b
->type
== bp_read_watchpoint
)
4714 || (b
->type
== bp_access_watchpoint
)
4715 || ep_is_exception_catchpoint (b
))
4716 && (b
->enable_state
== bp_call_disabled
))
4718 b
->enable_state
= bp_enabled
;
4719 check_duplicates (b
);
4725 /* Set a breakpoint that will evaporate an end of command
4726 at address specified by SAL.
4727 Restrict it to frame FRAME if FRAME is nonzero. */
4730 set_momentary_breakpoint (struct symtab_and_line sal
, struct frame_id frame_id
,
4733 struct breakpoint
*b
;
4734 b
= set_raw_breakpoint (sal
, type
);
4735 b
->enable_state
= bp_enabled
;
4736 b
->disposition
= disp_donttouch
;
4737 b
->frame_id
= frame_id
;
4739 /* If we're debugging a multi-threaded program, then we
4740 want momentary breakpoints to be active in only a
4741 single thread of control. */
4742 if (in_thread_list (inferior_ptid
))
4743 b
->thread
= pid_to_thread_id (inferior_ptid
);
4749 /* Tell the user we have just set a breakpoint B. */
4752 mention (struct breakpoint
*b
)
4755 struct cleanup
*old_chain
, *ui_out_chain
;
4756 struct ui_stream
*stb
;
4758 stb
= ui_out_stream_new (uiout
);
4759 old_chain
= make_cleanup_ui_out_stream_delete (stb
);
4761 /* FIXME: This is misplaced; mention() is called by things (like
4762 hitting a watchpoint) other than breakpoint creation. It should
4763 be possible to clean this up and at the same time replace the
4764 random calls to breakpoint_changed with this hook, as has already
4765 been done for deprecated_delete_breakpoint_hook and so on. */
4766 if (deprecated_create_breakpoint_hook
)
4767 deprecated_create_breakpoint_hook (b
);
4768 breakpoint_create_event (b
->number
);
4770 if (b
->ops
!= NULL
&& b
->ops
->print_mention
!= NULL
)
4771 b
->ops
->print_mention (b
);
4776 printf_filtered (_("(apparently deleted?) Eventpoint %d: "), b
->number
);
4779 ui_out_text (uiout
, "Watchpoint ");
4780 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "wpt");
4781 ui_out_field_int (uiout
, "number", b
->number
);
4782 ui_out_text (uiout
, ": ");
4783 print_expression (b
->exp
, stb
->stream
);
4784 ui_out_field_stream (uiout
, "exp", stb
);
4785 do_cleanups (ui_out_chain
);
4787 case bp_hardware_watchpoint
:
4788 ui_out_text (uiout
, "Hardware watchpoint ");
4789 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "wpt");
4790 ui_out_field_int (uiout
, "number", b
->number
);
4791 ui_out_text (uiout
, ": ");
4792 print_expression (b
->exp
, stb
->stream
);
4793 ui_out_field_stream (uiout
, "exp", stb
);
4794 do_cleanups (ui_out_chain
);
4796 case bp_read_watchpoint
:
4797 ui_out_text (uiout
, "Hardware read watchpoint ");
4798 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "hw-rwpt");
4799 ui_out_field_int (uiout
, "number", b
->number
);
4800 ui_out_text (uiout
, ": ");
4801 print_expression (b
->exp
, stb
->stream
);
4802 ui_out_field_stream (uiout
, "exp", stb
);
4803 do_cleanups (ui_out_chain
);
4805 case bp_access_watchpoint
:
4806 ui_out_text (uiout
, "Hardware access (read/write) watchpoint ");
4807 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "hw-awpt");
4808 ui_out_field_int (uiout
, "number", b
->number
);
4809 ui_out_text (uiout
, ": ");
4810 print_expression (b
->exp
, stb
->stream
);
4811 ui_out_field_stream (uiout
, "exp", stb
);
4812 do_cleanups (ui_out_chain
);
4815 if (ui_out_is_mi_like_p (uiout
))
4820 printf_filtered (_("Breakpoint %d"), b
->number
);
4823 case bp_hardware_breakpoint
:
4824 if (ui_out_is_mi_like_p (uiout
))
4829 printf_filtered (_("Hardware assisted breakpoint %d"), b
->number
);
4833 case bp_catch_unload
:
4834 printf_filtered (_("Catchpoint %d (%s %s)"),
4836 (b
->type
== bp_catch_load
) ? "load" : "unload",
4837 (b
->dll_pathname
!= NULL
) ?
4838 b
->dll_pathname
: "<any library>");
4841 case bp_catch_vfork
:
4842 printf_filtered (_("Catchpoint %d (%s)"),
4844 (b
->type
== bp_catch_fork
) ? "fork" : "vfork");
4847 printf_filtered (_("Catchpoint %d (exec)"),
4850 case bp_catch_catch
:
4851 case bp_catch_throw
:
4852 printf_filtered (_("Catchpoint %d (%s)"),
4854 (b
->type
== bp_catch_catch
) ? "catch" : "throw");
4860 case bp_longjmp_resume
:
4861 case bp_step_resume
:
4862 case bp_through_sigtramp
:
4864 case bp_watchpoint_scope
:
4865 case bp_shlib_event
:
4866 case bp_thread_event
:
4867 case bp_overlay_event
:
4873 /* i18n: cagney/2005-02-11: Below needs to be merged into a
4877 printf_filtered (_(" (%s) pending."), b
->addr_string
);
4881 if (addressprint
|| b
->source_file
== NULL
)
4883 printf_filtered (" at ");
4884 deprecated_print_address_numeric (b
->loc
->address
, 1, gdb_stdout
);
4887 printf_filtered (": file %s, line %d.",
4888 b
->source_file
, b
->line_number
);
4891 do_cleanups (old_chain
);
4892 if (ui_out_is_mi_like_p (uiout
))
4894 printf_filtered ("\n");
4898 /* Add SALS.nelts breakpoints to the breakpoint table. For each
4899 SALS.sal[i] breakpoint, include the corresponding ADDR_STRING[i],
4900 COND[i] and COND_STRING[i] values.
4902 The parameter PENDING_BP points to a pending breakpoint that is
4903 the basis of the breakpoints currently being created. The pending
4904 breakpoint may contain a separate condition string or commands
4905 that were added after the initial pending breakpoint was created.
4907 NOTE: If the function succeeds, the caller is expected to cleanup
4908 the arrays ADDR_STRING, COND_STRING, COND and SALS (but not the
4909 array contents). If the function fails (error() is called), the
4910 caller is expected to cleanups both the ADDR_STRING, COND_STRING,
4911 COND and SALS arrays and each of those arrays contents. */
4914 create_breakpoints (struct symtabs_and_lines sals
, char **addr_string
,
4915 struct expression
**cond
, char **cond_string
,
4916 enum bptype type
, enum bpdisp disposition
,
4917 int thread
, int ignore_count
, int from_tty
,
4918 struct breakpoint
*pending_bp
)
4920 if (type
== bp_hardware_breakpoint
)
4922 int i
= hw_breakpoint_used_count ();
4923 int target_resources_ok
=
4924 TARGET_CAN_USE_HARDWARE_WATCHPOINT (bp_hardware_breakpoint
,
4926 if (target_resources_ok
== 0)
4927 error (_("No hardware breakpoint support in the target."));
4928 else if (target_resources_ok
< 0)
4929 error (_("Hardware breakpoints used exceeds limit."));
4932 /* Now set all the breakpoints. */
4935 for (i
= 0; i
< sals
.nelts
; i
++)
4937 struct breakpoint
*b
;
4938 struct symtab_and_line sal
= sals
.sals
[i
];
4941 describe_other_breakpoints (sal
.pc
, sal
.section
);
4943 b
= set_raw_breakpoint (sal
, type
);
4944 set_breakpoint_count (breakpoint_count
+ 1);
4945 b
->number
= breakpoint_count
;
4949 b
->addr_string
= addr_string
[i
];
4951 /* addr_string has to be used or breakpoint_re_set will delete
4953 b
->addr_string
= xstrprintf ("*0x%s", paddr (b
->loc
->address
));
4954 b
->cond_string
= cond_string
[i
];
4955 b
->ignore_count
= ignore_count
;
4956 b
->enable_state
= bp_enabled
;
4957 b
->disposition
= disposition
;
4958 /* If resolving a pending breakpoint, a check must be made to see if
4959 the user has specified a new condition or commands for the
4960 breakpoint. A new condition will override any condition that was
4961 initially specified with the initial breakpoint command. */
4965 if (pending_bp
->cond_string
)
4967 arg
= pending_bp
->cond_string
;
4968 b
->cond_string
= savestring (arg
, strlen (arg
));
4969 b
->cond
= parse_exp_1 (&arg
, block_for_pc (b
->loc
->address
), 0);
4971 error (_("Junk at end of pending breakpoint condition expression"));
4973 /* If there are commands associated with the breakpoint, they should
4975 if (pending_bp
->commands
)
4976 b
->commands
= copy_command_lines (pending_bp
->commands
);
4978 /* We have to copy over the ignore_count and thread as well. */
4979 b
->ignore_count
= pending_bp
->ignore_count
;
4980 b
->thread
= pending_bp
->thread
;
4987 /* Parse ARG which is assumed to be a SAL specification possibly
4988 followed by conditionals. On return, SALS contains an array of SAL
4989 addresses found. ADDR_STRING contains a vector of (canonical)
4990 address strings. ARG points to the end of the SAL. */
4993 parse_breakpoint_sals (char **address
,
4994 struct symtabs_and_lines
*sals
,
4995 char ***addr_string
,
4998 char *addr_start
= *address
;
4999 *addr_string
= NULL
;
5000 /* If no arg given, or if first arg is 'if ', use the default
5002 if ((*address
) == NULL
5003 || (strncmp ((*address
), "if", 2) == 0 && isspace ((*address
)[2])))
5005 if (default_breakpoint_valid
)
5007 struct symtab_and_line sal
;
5008 init_sal (&sal
); /* initialize to zeroes */
5009 sals
->sals
= (struct symtab_and_line
*)
5010 xmalloc (sizeof (struct symtab_and_line
));
5011 sal
.pc
= default_breakpoint_address
;
5012 sal
.line
= default_breakpoint_line
;
5013 sal
.symtab
= default_breakpoint_symtab
;
5014 sal
.section
= find_pc_overlay (sal
.pc
);
5015 sals
->sals
[0] = sal
;
5019 error (_("No default breakpoint address now."));
5023 /* Force almost all breakpoints to be in terms of the
5024 current_source_symtab (which is decode_line_1's default). This
5025 should produce the results we want almost all of the time while
5026 leaving default_breakpoint_* alone.
5027 ObjC: However, don't match an Objective-C method name which
5028 may have a '+' or '-' succeeded by a '[' */
5030 struct symtab_and_line cursal
= get_current_source_symtab_and_line ();
5032 if (default_breakpoint_valid
5034 || ((strchr ("+-", (*address
)[0]) != NULL
)
5035 && ((*address
)[1] != '['))))
5036 *sals
= decode_line_1 (address
, 1, default_breakpoint_symtab
,
5037 default_breakpoint_line
, addr_string
,
5040 *sals
= decode_line_1 (address
, 1, (struct symtab
*) NULL
, 0,
5041 addr_string
, not_found_ptr
);
5043 /* For any SAL that didn't have a canonical string, fill one in. */
5044 if (sals
->nelts
> 0 && *addr_string
== NULL
)
5045 *addr_string
= xcalloc (sals
->nelts
, sizeof (char **));
5046 if (addr_start
!= (*address
))
5049 for (i
= 0; i
< sals
->nelts
; i
++)
5051 /* Add the string if not present. */
5052 if ((*addr_string
)[i
] == NULL
)
5053 (*addr_string
)[i
] = savestring (addr_start
, (*address
) - addr_start
);
5059 /* Convert each SAL into a real PC. Verify that the PC can be
5060 inserted as a breakpoint. If it can't throw an error. */
5063 breakpoint_sals_to_pc (struct symtabs_and_lines
*sals
,
5067 for (i
= 0; i
< sals
->nelts
; i
++)
5069 resolve_sal_pc (&sals
->sals
[i
]);
5071 /* It's possible for the PC to be nonzero, but still an illegal
5072 value on some targets.
5074 For example, on HP-UX if you start gdb, and before running the
5075 inferior you try to set a breakpoint on a shared library function
5076 "foo" where the inferior doesn't call "foo" directly but does
5077 pass its address to another function call, then we do find a
5078 minimal symbol for the "foo", but it's address is invalid.
5079 (Appears to be an index into a table that the loader sets up
5080 when the inferior is run.)
5082 Give the target a chance to bless sals.sals[i].pc before we
5083 try to make a breakpoint for it. */
5084 #ifdef DEPRECATED_PC_REQUIRES_RUN_BEFORE_USE
5085 if (DEPRECATED_PC_REQUIRES_RUN_BEFORE_USE (sals
->sals
[i
].pc
))
5087 if (address
== NULL
)
5088 error (_("Cannot break without a running program."));
5090 error (_("Cannot break on %s without a running program."),
5098 do_captured_parse_breakpoint (struct ui_out
*ui
, void *data
)
5100 struct captured_parse_breakpoint_args
*args
= data
;
5102 parse_breakpoint_sals (args
->arg_p
, args
->sals_p
, args
->addr_string_p
,
5103 args
->not_found_ptr
);
5106 /* Set a breakpoint according to ARG (function, linenum or *address)
5107 flag: first bit : 0 non-temporary, 1 temporary.
5108 second bit : 0 normal breakpoint, 1 hardware breakpoint.
5110 PENDING_BP is non-NULL when this function is being called to resolve
5111 a pending breakpoint. */
5114 break_command_1 (char *arg
, int flag
, int from_tty
, struct breakpoint
*pending_bp
)
5116 struct gdb_exception e
;
5117 int tempflag
, hardwareflag
;
5118 struct symtabs_and_lines sals
;
5119 struct expression
**cond
= 0;
5120 struct symtab_and_line pending_sal
;
5121 char **cond_string
= (char **) NULL
;
5124 char *addr_start
= arg
;
5126 struct cleanup
*old_chain
;
5127 struct cleanup
*breakpoint_chain
= NULL
;
5128 struct captured_parse_breakpoint_args parse_args
;
5132 int ignore_count
= 0;
5135 hardwareflag
= flag
& BP_HARDWAREFLAG
;
5136 tempflag
= flag
& BP_TEMPFLAG
;
5142 parse_args
.arg_p
= &arg
;
5143 parse_args
.sals_p
= &sals
;
5144 parse_args
.addr_string_p
= &addr_string
;
5145 parse_args
.not_found_ptr
= ¬_found
;
5147 e
= catch_exception (uiout
, do_captured_parse_breakpoint
,
5148 &parse_args
, RETURN_MASK_ALL
);
5150 /* If caller is interested in rc value from parse, set value. */
5154 exception_print (gdb_stderr
, e
);
5159 case NOT_FOUND_ERROR
:
5160 /* If called to resolve pending breakpoint, just return
5165 exception_print (gdb_stderr
, e
);
5167 /* If pending breakpoint support is turned off, throw
5170 if (pending_break_support
== AUTO_BOOLEAN_FALSE
)
5171 deprecated_throw_reason (RETURN_ERROR
);
5173 /* If pending breakpoint support is auto query and the user
5174 selects no, then simply return the error code. */
5175 if (pending_break_support
== AUTO_BOOLEAN_AUTO
&&
5176 !nquery ("Make breakpoint pending on future shared library load? "))
5179 /* At this point, either the user was queried about setting
5180 a pending breakpoint and selected yes, or pending
5181 breakpoint behavior is on and thus a pending breakpoint
5182 is defaulted on behalf of the user. */
5183 copy_arg
= xstrdup (addr_start
);
5184 addr_string
= ©_arg
;
5186 sals
.sals
= &pending_sal
;
5191 exception_print (gdb_stderr
, e
);
5199 /* Create a chain of things that always need to be cleaned up. */
5200 old_chain
= make_cleanup (null_cleanup
, 0);
5204 /* Make sure that all storage allocated to SALS gets freed. */
5205 make_cleanup (xfree
, sals
.sals
);
5207 /* Cleanup the addr_string array but not its contents. */
5208 make_cleanup (xfree
, addr_string
);
5211 /* Allocate space for all the cond expressions. */
5212 cond
= xcalloc (sals
.nelts
, sizeof (struct expression
*));
5213 make_cleanup (xfree
, cond
);
5215 /* Allocate space for all the cond strings. */
5216 cond_string
= xcalloc (sals
.nelts
, sizeof (char **));
5217 make_cleanup (xfree
, cond_string
);
5219 /* ----------------------------- SNIP -----------------------------
5220 Anything added to the cleanup chain beyond this point is assumed
5221 to be part of a breakpoint. If the breakpoint create succeeds
5222 then the memory is not reclaimed. */
5223 breakpoint_chain
= make_cleanup (null_cleanup
, 0);
5225 /* Mark the contents of the addr_string for cleanup. These go on
5226 the breakpoint_chain and only occure if the breakpoint create
5228 for (i
= 0; i
< sals
.nelts
; i
++)
5230 if (addr_string
[i
] != NULL
)
5231 make_cleanup (xfree
, addr_string
[i
]);
5234 /* Resolve all line numbers to PC's and verify that the addresses
5235 are ok for the target. */
5237 breakpoint_sals_to_pc (&sals
, addr_start
);
5239 /* Verify that condition can be parsed, before setting any
5240 breakpoints. Allocate a separate condition expression for each
5242 thread
= -1; /* No specific thread yet */
5245 for (i
= 0; i
< sals
.nelts
; i
++)
5252 char *cond_start
= NULL
;
5253 char *cond_end
= NULL
;
5254 while (*tok
== ' ' || *tok
== '\t')
5259 while (*end_tok
!= ' ' && *end_tok
!= '\t' && *end_tok
!= '\000')
5262 toklen
= end_tok
- tok
;
5264 if (toklen
>= 1 && strncmp (tok
, "if", toklen
) == 0)
5266 tok
= cond_start
= end_tok
+ 1;
5267 cond
[i
] = parse_exp_1 (&tok
, block_for_pc (sals
.sals
[i
].pc
),
5269 make_cleanup (xfree
, cond
[i
]);
5271 cond_string
[i
] = savestring (cond_start
,
5272 cond_end
- cond_start
);
5273 make_cleanup (xfree
, cond_string
[i
]);
5275 else if (toklen
>= 1 && strncmp (tok
, "thread", toklen
) == 0)
5281 thread
= strtol (tok
, &tok
, 0);
5283 error (_("Junk after thread keyword."));
5284 if (!valid_thread_id (thread
))
5285 error (_("Unknown thread %d."), thread
);
5288 error (_("Junk at end of arguments."));
5291 create_breakpoints (sals
, addr_string
, cond
, cond_string
,
5292 hardwareflag
? bp_hardware_breakpoint
5294 tempflag
? disp_del
: disp_donttouch
,
5295 thread
, ignore_count
, from_tty
,
5300 struct symtab_and_line sal
;
5301 struct breakpoint
*b
;
5306 make_cleanup (xfree
, copy_arg
);
5308 b
= set_raw_breakpoint (sal
, hardwareflag
? bp_hardware_breakpoint
5310 set_breakpoint_count (breakpoint_count
+ 1);
5311 b
->number
= breakpoint_count
;
5314 b
->addr_string
= *addr_string
;
5315 b
->cond_string
= *cond_string
;
5316 b
->ignore_count
= ignore_count
;
5318 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
5319 b
->from_tty
= from_tty
;
5325 warning (_("Multiple breakpoints were set.\n"
5326 "Use the \"delete\" command to delete unwanted breakpoints."));
5327 /* That's it. Discard the cleanups for data inserted into the
5329 discard_cleanups (breakpoint_chain
);
5330 /* But cleanup everything else. */
5331 do_cleanups (old_chain
);
5336 /* Set a breakpoint of TYPE/DISPOSITION according to ARG (function,
5337 linenum or *address) with COND and IGNORE_COUNT. */
5339 struct captured_breakpoint_args
5350 do_captured_breakpoint (struct ui_out
*uiout
, void *data
)
5352 struct captured_breakpoint_args
*args
= data
;
5353 struct symtabs_and_lines sals
;
5354 struct expression
**cond
;
5355 struct cleanup
*old_chain
;
5356 struct cleanup
*breakpoint_chain
= NULL
;
5363 /* Parse the source and lines spec. Delay check that the expression
5364 didn't contain trailing garbage until after cleanups are in
5368 address_end
= args
->address
;
5370 parse_breakpoint_sals (&address_end
, &sals
, &addr_string
, 0);
5375 /* Create a chain of things at always need to be cleaned up. */
5376 old_chain
= make_cleanup (null_cleanup
, 0);
5378 /* Always have a addr_string array, even if it is empty. */
5379 make_cleanup (xfree
, addr_string
);
5381 /* Make sure that all storage allocated to SALS gets freed. */
5382 make_cleanup (xfree
, sals
.sals
);
5384 /* Allocate space for all the cond expressions. */
5385 cond
= xcalloc (sals
.nelts
, sizeof (struct expression
*));
5386 make_cleanup (xfree
, cond
);
5388 /* Allocate space for all the cond strings. */
5389 cond_string
= xcalloc (sals
.nelts
, sizeof (char **));
5390 make_cleanup (xfree
, cond_string
);
5392 /* ----------------------------- SNIP -----------------------------
5393 Anything added to the cleanup chain beyond this point is assumed
5394 to be part of a breakpoint. If the breakpoint create goes
5395 through then that memory is not cleaned up. */
5396 breakpoint_chain
= make_cleanup (null_cleanup
, 0);
5398 /* Mark the contents of the addr_string for cleanup. These go on
5399 the breakpoint_chain and only occure if the breakpoint create
5401 for (i
= 0; i
< sals
.nelts
; i
++)
5403 if (addr_string
[i
] != NULL
)
5404 make_cleanup (xfree
, addr_string
[i
]);
5407 /* Wait until now before checking for garbage at the end of the
5408 address. That way cleanups can take care of freeing any
5410 if (*address_end
!= '\0')
5411 error (_("Garbage %s following breakpoint address"), address_end
);
5413 /* Resolve all line numbers to PC's. */
5414 breakpoint_sals_to_pc (&sals
, args
->address
);
5416 /* Verify that conditions can be parsed, before setting any
5418 for (i
= 0; i
< sals
.nelts
; i
++)
5420 if (args
->condition
!= NULL
)
5422 char *tok
= args
->condition
;
5423 cond
[i
] = parse_exp_1 (&tok
, block_for_pc (sals
.sals
[i
].pc
), 0);
5425 error (_("Garbage %s follows condition"), tok
);
5426 make_cleanup (xfree
, cond
[i
]);
5427 cond_string
[i
] = xstrdup (args
->condition
);
5431 create_breakpoints (sals
, addr_string
, cond
, cond_string
,
5432 args
->hardwareflag
? bp_hardware_breakpoint
: bp_breakpoint
,
5433 args
->tempflag
? disp_del
: disp_donttouch
,
5434 args
->thread
, args
->ignore_count
, 0/*from-tty*/,
5435 NULL
/*pending_bp*/);
5437 /* That's it. Discard the cleanups for data inserted into the
5439 discard_cleanups (breakpoint_chain
);
5440 /* But cleanup everything else. */
5441 do_cleanups (old_chain
);
5446 gdb_breakpoint (char *address
, char *condition
,
5447 int hardwareflag
, int tempflag
,
5448 int thread
, int ignore_count
,
5449 char **error_message
)
5451 struct captured_breakpoint_args args
;
5452 args
.address
= address
;
5453 args
.condition
= condition
;
5454 args
.hardwareflag
= hardwareflag
;
5455 args
.tempflag
= tempflag
;
5456 args
.thread
= thread
;
5457 args
.ignore_count
= ignore_count
;
5458 return catch_exceptions_with_msg (uiout
, do_captured_breakpoint
, &args
,
5459 error_message
, RETURN_MASK_ALL
);
5463 /* Helper function for break_command_1 and disassemble_command. */
5466 resolve_sal_pc (struct symtab_and_line
*sal
)
5470 if (sal
->pc
== 0 && sal
->symtab
!= NULL
)
5472 if (!find_line_pc (sal
->symtab
, sal
->line
, &pc
))
5473 error (_("No line %d in file \"%s\"."),
5474 sal
->line
, sal
->symtab
->filename
);
5478 if (sal
->section
== 0 && sal
->symtab
!= NULL
)
5480 struct blockvector
*bv
;
5485 bv
= blockvector_for_pc_sect (sal
->pc
, 0, &index
, sal
->symtab
);
5488 b
= BLOCKVECTOR_BLOCK (bv
, index
);
5489 sym
= block_function (b
);
5492 fixup_symbol_section (sym
, sal
->symtab
->objfile
);
5493 sal
->section
= SYMBOL_BFD_SECTION (sym
);
5497 /* It really is worthwhile to have the section, so we'll just
5498 have to look harder. This case can be executed if we have
5499 line numbers but no functions (as can happen in assembly
5502 struct minimal_symbol
*msym
;
5504 msym
= lookup_minimal_symbol_by_pc (sal
->pc
);
5506 sal
->section
= SYMBOL_BFD_SECTION (msym
);
5513 break_command (char *arg
, int from_tty
)
5515 break_command_1 (arg
, 0, from_tty
, NULL
);
5519 tbreak_command (char *arg
, int from_tty
)
5521 break_command_1 (arg
, BP_TEMPFLAG
, from_tty
, NULL
);
5525 hbreak_command (char *arg
, int from_tty
)
5527 break_command_1 (arg
, BP_HARDWAREFLAG
, from_tty
, NULL
);
5531 thbreak_command (char *arg
, int from_tty
)
5533 break_command_1 (arg
, (BP_TEMPFLAG
| BP_HARDWAREFLAG
), from_tty
, NULL
);
5537 stop_command (char *arg
, int from_tty
)
5539 printf_filtered (_("Specify the type of breakpoint to set.\n\
5540 Usage: stop in <function | address>\n\
5541 stop at <line>\n"));
5545 stopin_command (char *arg
, int from_tty
)
5549 if (arg
== (char *) NULL
)
5551 else if (*arg
!= '*')
5556 /* look for a ':'. If this is a line number specification, then
5557 say it is bad, otherwise, it should be an address or
5558 function/method name */
5559 while (*argptr
&& !hasColon
)
5561 hasColon
= (*argptr
== ':');
5566 badInput
= (*argptr
!= ':'); /* Not a class::method */
5568 badInput
= isdigit (*arg
); /* a simple line number */
5572 printf_filtered (_("Usage: stop in <function | address>\n"));
5574 break_command_1 (arg
, 0, from_tty
, NULL
);
5578 stopat_command (char *arg
, int from_tty
)
5582 if (arg
== (char *) NULL
|| *arg
== '*') /* no line number */
5589 /* look for a ':'. If there is a '::' then get out, otherwise
5590 it is probably a line number. */
5591 while (*argptr
&& !hasColon
)
5593 hasColon
= (*argptr
== ':');
5598 badInput
= (*argptr
== ':'); /* we have class::method */
5600 badInput
= !isdigit (*arg
); /* not a line number */
5604 printf_filtered (_("Usage: stop at <line>\n"));
5606 break_command_1 (arg
, 0, from_tty
, NULL
);
5609 /* accessflag: hw_write: watch write,
5610 hw_read: watch read,
5611 hw_access: watch access (read or write) */
5613 watch_command_1 (char *arg
, int accessflag
, int from_tty
)
5615 struct breakpoint
*b
;
5616 struct symtab_and_line sal
;
5617 struct expression
*exp
;
5618 struct block
*exp_valid_block
;
5619 struct value
*val
, *mark
;
5620 struct frame_info
*frame
;
5621 struct frame_info
*prev_frame
= NULL
;
5622 char *exp_start
= NULL
;
5623 char *exp_end
= NULL
;
5624 char *tok
, *end_tok
;
5626 char *cond_start
= NULL
;
5627 char *cond_end
= NULL
;
5628 struct expression
*cond
= NULL
;
5629 int i
, other_type_used
, target_resources_ok
= 0;
5630 enum bptype bp_type
;
5633 init_sal (&sal
); /* initialize to zeroes */
5635 /* Parse arguments. */
5636 innermost_block
= NULL
;
5638 exp
= parse_exp_1 (&arg
, 0, 0);
5640 exp_valid_block
= innermost_block
;
5641 mark
= value_mark ();
5642 val
= evaluate_expression (exp
);
5643 release_value (val
);
5644 if (value_lazy (val
))
5645 value_fetch_lazy (val
);
5648 while (*tok
== ' ' || *tok
== '\t')
5652 while (*end_tok
!= ' ' && *end_tok
!= '\t' && *end_tok
!= '\000')
5655 toklen
= end_tok
- tok
;
5656 if (toklen
>= 1 && strncmp (tok
, "if", toklen
) == 0)
5658 tok
= cond_start
= end_tok
+ 1;
5659 cond
= parse_exp_1 (&tok
, 0, 0);
5663 error (_("Junk at end of command."));
5665 if (accessflag
== hw_read
)
5666 bp_type
= bp_read_watchpoint
;
5667 else if (accessflag
== hw_access
)
5668 bp_type
= bp_access_watchpoint
;
5670 bp_type
= bp_hardware_watchpoint
;
5672 mem_cnt
= can_use_hardware_watchpoint (val
);
5673 if (mem_cnt
== 0 && bp_type
!= bp_hardware_watchpoint
)
5674 error (_("Expression cannot be implemented with read/access watchpoint."));
5677 i
= hw_watchpoint_used_count (bp_type
, &other_type_used
);
5678 target_resources_ok
=
5679 TARGET_CAN_USE_HARDWARE_WATCHPOINT (bp_type
, i
+ mem_cnt
,
5681 if (target_resources_ok
== 0 && bp_type
!= bp_hardware_watchpoint
)
5682 error (_("Target does not support this type of hardware watchpoint."));
5684 if (target_resources_ok
< 0 && bp_type
!= bp_hardware_watchpoint
)
5685 error (_("Target can only support one kind of HW watchpoint at a time."));
5688 #if defined(HPUXHPPA)
5689 /* On HP-UX if you set a h/w
5690 watchpoint before the "run" command, the inferior dies with a e.g.,
5691 SIGILL once you start it. I initially believed this was due to a
5692 bad interaction between page protection traps and the initial
5693 startup sequence by the dynamic linker.
5695 However, I tried avoiding that by having HP-UX's implementation of
5696 TARGET_CAN_USE_HW_WATCHPOINT return FALSE if there was no inferior_ptid
5697 yet, which forced slow watches before a "run" or "attach", and it
5698 still fails somewhere in the startup code.
5700 Until I figure out what's happening, I'm disallowing watches altogether
5701 before the "run" or "attach" command. We'll tell the user they must
5702 set watches after getting the program started. */
5703 if (!target_has_execution
)
5705 warning (_("can't do that without a running program; try \"break main\"), \"run\" first");
5708 #endif /* HPUXHPPA */
5710 /* Change the type of breakpoint to an ordinary watchpoint if a hardware
5711 watchpoint could not be set. */
5712 if (!mem_cnt
|| target_resources_ok
<= 0)
5713 bp_type
= bp_watchpoint
;
5715 /* Now set up the breakpoint. */
5716 b
= set_raw_breakpoint (sal
, bp_type
);
5717 set_breakpoint_count (breakpoint_count
+ 1);
5718 b
->number
= breakpoint_count
;
5719 b
->disposition
= disp_donttouch
;
5721 b
->exp_valid_block
= exp_valid_block
;
5722 b
->exp_string
= savestring (exp_start
, exp_end
- exp_start
);
5726 b
->cond_string
= savestring (cond_start
, cond_end
- cond_start
);
5730 frame
= block_innermost_frame (exp_valid_block
);
5733 prev_frame
= get_prev_frame (frame
);
5734 b
->watchpoint_frame
= get_frame_id (frame
);
5738 memset (&b
->watchpoint_frame
, 0, sizeof (b
->watchpoint_frame
));
5741 /* If the expression is "local", then set up a "watchpoint scope"
5742 breakpoint at the point where we've left the scope of the watchpoint
5744 if (innermost_block
)
5748 struct breakpoint
*scope_breakpoint
;
5749 scope_breakpoint
= create_internal_breakpoint (get_frame_pc (prev_frame
),
5750 bp_watchpoint_scope
);
5752 scope_breakpoint
->enable_state
= bp_enabled
;
5754 /* Automatically delete the breakpoint when it hits. */
5755 scope_breakpoint
->disposition
= disp_del
;
5757 /* Only break in the proper frame (help with recursion). */
5758 scope_breakpoint
->frame_id
= get_frame_id (prev_frame
);
5760 /* Set the address at which we will stop. */
5761 scope_breakpoint
->loc
->requested_address
5762 = get_frame_pc (prev_frame
);
5763 scope_breakpoint
->loc
->address
5764 = adjust_breakpoint_address (scope_breakpoint
->loc
->requested_address
,
5765 scope_breakpoint
->type
);
5767 /* The scope breakpoint is related to the watchpoint. We
5768 will need to act on them together. */
5769 b
->related_breakpoint
= scope_breakpoint
;
5772 value_free_to_mark (mark
);
5776 /* Return count of locations need to be watched and can be handled
5777 in hardware. If the watchpoint can not be handled
5778 in hardware return zero. */
5780 #if !defined(TARGET_REGION_OK_FOR_HW_WATCHPOINT)
5781 #define TARGET_REGION_OK_FOR_HW_WATCHPOINT(ADDR,LEN) \
5782 (TARGET_REGION_SIZE_OK_FOR_HW_WATCHPOINT(LEN))
5786 can_use_hardware_watchpoint (struct value
*v
)
5788 int found_memory_cnt
= 0;
5789 struct value
*head
= v
;
5791 /* Did the user specifically forbid us to use hardware watchpoints? */
5792 if (!can_use_hw_watchpoints
)
5795 /* Make sure that the value of the expression depends only upon
5796 memory contents, and values computed from them within GDB. If we
5797 find any register references or function calls, we can't use a
5798 hardware watchpoint.
5800 The idea here is that evaluating an expression generates a series
5801 of values, one holding the value of every subexpression. (The
5802 expression a*b+c has five subexpressions: a, b, a*b, c, and
5803 a*b+c.) GDB's values hold almost enough information to establish
5804 the criteria given above --- they identify memory lvalues,
5805 register lvalues, computed values, etcetera. So we can evaluate
5806 the expression, and then scan the chain of values that leaves
5807 behind to decide whether we can detect any possible change to the
5808 expression's final value using only hardware watchpoints.
5810 However, I don't think that the values returned by inferior
5811 function calls are special in any way. So this function may not
5812 notice that an expression involving an inferior function call
5813 can't be watched with hardware watchpoints. FIXME. */
5814 for (; v
; v
= value_next (v
))
5816 if (VALUE_LVAL (v
) == lval_memory
)
5819 /* A lazy memory lvalue is one that GDB never needed to fetch;
5820 we either just used its address (e.g., `a' in `a.b') or
5821 we never needed it at all (e.g., `a' in `a,b'). */
5825 /* Ahh, memory we actually used! Check if we can cover
5826 it with hardware watchpoints. */
5827 struct type
*vtype
= check_typedef (value_type (v
));
5829 /* We only watch structs and arrays if user asked for it
5830 explicitly, never if they just happen to appear in a
5831 middle of some value chain. */
5833 || (TYPE_CODE (vtype
) != TYPE_CODE_STRUCT
5834 && TYPE_CODE (vtype
) != TYPE_CODE_ARRAY
))
5836 CORE_ADDR vaddr
= VALUE_ADDRESS (v
) + value_offset (v
);
5837 int len
= TYPE_LENGTH (value_type (v
));
5839 if (!TARGET_REGION_OK_FOR_HW_WATCHPOINT (vaddr
, len
))
5846 else if (VALUE_LVAL (v
) != not_lval
5847 && deprecated_value_modifiable (v
) == 0)
5848 return 0; /* ??? What does this represent? */
5849 else if (VALUE_LVAL (v
) == lval_register
)
5850 return 0; /* cannot watch a register with a HW watchpoint */
5853 /* The expression itself looks suitable for using a hardware
5854 watchpoint, but give the target machine a chance to reject it. */
5855 return found_memory_cnt
;
5859 watch_command_wrapper (char *arg
, int from_tty
)
5861 watch_command (arg
, from_tty
);
5865 watch_command (char *arg
, int from_tty
)
5867 watch_command_1 (arg
, hw_write
, from_tty
);
5871 rwatch_command_wrapper (char *arg
, int from_tty
)
5873 rwatch_command (arg
, from_tty
);
5877 rwatch_command (char *arg
, int from_tty
)
5879 watch_command_1 (arg
, hw_read
, from_tty
);
5883 awatch_command_wrapper (char *arg
, int from_tty
)
5885 awatch_command (arg
, from_tty
);
5889 awatch_command (char *arg
, int from_tty
)
5891 watch_command_1 (arg
, hw_access
, from_tty
);
5895 /* Helper routines for the until_command routine in infcmd.c. Here
5896 because it uses the mechanisms of breakpoints. */
5898 /* This function is called by fetch_inferior_event via the
5899 cmd_continuation pointer, to complete the until command. It takes
5900 care of cleaning up the temporary breakpoints set up by the until
5903 until_break_command_continuation (struct continuation_arg
*arg
)
5905 struct cleanup
*cleanups
;
5907 cleanups
= (struct cleanup
*) arg
->data
.pointer
;
5908 do_exec_cleanups (cleanups
);
5912 until_break_command (char *arg
, int from_tty
, int anywhere
)
5914 struct symtabs_and_lines sals
;
5915 struct symtab_and_line sal
;
5916 struct frame_info
*prev_frame
= get_prev_frame (deprecated_selected_frame
);
5917 struct breakpoint
*breakpoint
;
5918 struct cleanup
*old_chain
;
5919 struct continuation_arg
*arg1
;
5922 clear_proceed_status ();
5924 /* Set a breakpoint where the user wants it and at return from
5927 if (default_breakpoint_valid
)
5928 sals
= decode_line_1 (&arg
, 1, default_breakpoint_symtab
,
5929 default_breakpoint_line
, (char ***) NULL
, NULL
);
5931 sals
= decode_line_1 (&arg
, 1, (struct symtab
*) NULL
,
5932 0, (char ***) NULL
, NULL
);
5934 if (sals
.nelts
!= 1)
5935 error (_("Couldn't get information on specified line."));
5938 xfree (sals
.sals
); /* malloc'd, so freed */
5941 error (_("Junk at end of arguments."));
5943 resolve_sal_pc (&sal
);
5946 /* If the user told us to continue until a specified location,
5947 we don't specify a frame at which we need to stop. */
5948 breakpoint
= set_momentary_breakpoint (sal
, null_frame_id
, bp_until
);
5950 /* Otherwise, specify the current frame, because we want to stop only
5951 at the very same frame. */
5952 breakpoint
= set_momentary_breakpoint (sal
,
5953 get_frame_id (deprecated_selected_frame
),
5956 if (!target_can_async_p ())
5957 old_chain
= make_cleanup_delete_breakpoint (breakpoint
);
5959 old_chain
= make_exec_cleanup_delete_breakpoint (breakpoint
);
5961 /* If we are running asynchronously, and the target supports async
5962 execution, we are not waiting for the target to stop, in the call
5963 tp proceed, below. This means that we cannot delete the
5964 brekpoints until the target has actually stopped. The only place
5965 where we get a chance to do that is in fetch_inferior_event, so
5966 we must set things up for that. */
5968 if (target_can_async_p ())
5970 /* In this case the arg for the continuation is just the point
5971 in the exec_cleanups chain from where to start doing
5972 cleanups, because all the continuation does is the cleanups in
5973 the exec_cleanup_chain. */
5975 (struct continuation_arg
*) xmalloc (sizeof (struct continuation_arg
));
5977 arg1
->data
.pointer
= old_chain
;
5979 add_continuation (until_break_command_continuation
, arg1
);
5982 /* Keep within the current frame, or in frames called by the current
5986 sal
= find_pc_line (get_frame_pc (prev_frame
), 0);
5987 sal
.pc
= get_frame_pc (prev_frame
);
5988 breakpoint
= set_momentary_breakpoint (sal
, get_frame_id (prev_frame
),
5990 if (!target_can_async_p ())
5991 make_cleanup_delete_breakpoint (breakpoint
);
5993 make_exec_cleanup_delete_breakpoint (breakpoint
);
5996 proceed (-1, TARGET_SIGNAL_DEFAULT
, 0);
5997 /* Do the cleanups now, anly if we are not running asynchronously,
5998 of if we are, but the target is still synchronous. */
5999 if (!target_can_async_p ())
6000 do_cleanups (old_chain
);
6004 ep_skip_leading_whitespace (char **s
)
6006 if ((s
== NULL
) || (*s
== NULL
))
6008 while (isspace (**s
))
6012 /* This function examines a string, and attempts to find a token
6013 that might be an event name in the leading characters. If a
6014 possible match is found, a pointer to the last character of
6015 the token is returned. Else, NULL is returned. */
6018 ep_find_event_name_end (char *arg
)
6021 char *event_name_end
= NULL
;
6023 /* If we could depend upon the presense of strrpbrk, we'd use that... */
6027 /* We break out of the loop when we find a token delimiter.
6028 Basically, we're looking for alphanumerics and underscores;
6029 anything else delimites the token. */
6032 if (!isalnum (*s
) && (*s
!= '_'))
6038 return event_name_end
;
6042 /* This function attempts to parse an optional "if <cond>" clause
6043 from the arg string. If one is not found, it returns NULL.
6045 Else, it returns a pointer to the condition string. (It does not
6046 attempt to evaluate the string against a particular block.) And,
6047 it updates arg to point to the first character following the parsed
6048 if clause in the arg string. */
6051 ep_parse_optional_if_clause (char **arg
)
6055 if (((*arg
)[0] != 'i') || ((*arg
)[1] != 'f') || !isspace ((*arg
)[2]))
6058 /* Skip the "if" keyword. */
6061 /* Skip any extra leading whitespace, and record the start of the
6062 condition string. */
6063 ep_skip_leading_whitespace (arg
);
6066 /* Assume that the condition occupies the remainder of the arg string. */
6067 (*arg
) += strlen (cond_string
);
6072 /* This function attempts to parse an optional filename from the arg
6073 string. If one is not found, it returns NULL.
6075 Else, it returns a pointer to the parsed filename. (This function
6076 makes no attempt to verify that a file of that name exists, or is
6077 accessible.) And, it updates arg to point to the first character
6078 following the parsed filename in the arg string.
6080 Note that clients needing to preserve the returned filename for
6081 future access should copy it to their own buffers. */
6083 ep_parse_optional_filename (char **arg
)
6085 static char filename
[1024];
6090 if ((*arg_p
== '\0') || isspace (*arg_p
))
6108 /* Commands to deal with catching events, such as signals, exceptions,
6109 process start/exit, etc. */
6113 catch_fork
, catch_vfork
6118 catch_fork_command_1 (catch_fork_kind fork_kind
, char *arg
, int tempflag
,
6121 char *cond_string
= NULL
;
6123 ep_skip_leading_whitespace (&arg
);
6125 /* The allowed syntax is:
6127 catch [v]fork if <cond>
6129 First, check if there's an if clause. */
6130 cond_string
= ep_parse_optional_if_clause (&arg
);
6132 if ((*arg
!= '\0') && !isspace (*arg
))
6133 error (_("Junk at end of arguments."));
6135 /* If this target supports it, create a fork or vfork catchpoint
6136 and enable reporting of such events. */
6140 create_fork_event_catchpoint (tempflag
, cond_string
);
6143 create_vfork_event_catchpoint (tempflag
, cond_string
);
6146 error (_("unsupported or unknown fork kind; cannot catch it"));
6152 catch_exec_command_1 (char *arg
, int tempflag
, int from_tty
)
6154 char *cond_string
= NULL
;
6156 ep_skip_leading_whitespace (&arg
);
6158 /* The allowed syntax is:
6160 catch exec if <cond>
6162 First, check if there's an if clause. */
6163 cond_string
= ep_parse_optional_if_clause (&arg
);
6165 if ((*arg
!= '\0') && !isspace (*arg
))
6166 error (_("Junk at end of arguments."));
6168 /* If this target supports it, create an exec catchpoint
6169 and enable reporting of such events. */
6170 create_exec_event_catchpoint (tempflag
, cond_string
);
6174 catch_load_command_1 (char *arg
, int tempflag
, int from_tty
)
6176 char *dll_pathname
= NULL
;
6177 char *cond_string
= NULL
;
6179 ep_skip_leading_whitespace (&arg
);
6181 /* The allowed syntax is:
6183 catch load if <cond>
6184 catch load <filename>
6185 catch load <filename> if <cond>
6187 The user is not allowed to specify the <filename> after an
6190 We'll ignore the pathological case of a file named "if".
6192 First, check if there's an if clause. If so, then there
6193 cannot be a filename. */
6194 cond_string
= ep_parse_optional_if_clause (&arg
);
6196 /* If there was an if clause, then there cannot be a filename.
6197 Else, there might be a filename and an if clause. */
6198 if (cond_string
== NULL
)
6200 dll_pathname
= ep_parse_optional_filename (&arg
);
6201 ep_skip_leading_whitespace (&arg
);
6202 cond_string
= ep_parse_optional_if_clause (&arg
);
6205 if ((*arg
!= '\0') && !isspace (*arg
))
6206 error (_("Junk at end of arguments."));
6208 /* Create a load breakpoint that only triggers when a load of
6209 the specified dll (or any dll, if no pathname was specified)
6211 SOLIB_CREATE_CATCH_LOAD_HOOK (PIDGET (inferior_ptid
), tempflag
,
6212 dll_pathname
, cond_string
);
6216 catch_unload_command_1 (char *arg
, int tempflag
, int from_tty
)
6218 char *dll_pathname
= NULL
;
6219 char *cond_string
= NULL
;
6221 ep_skip_leading_whitespace (&arg
);
6223 /* The allowed syntax is:
6225 catch unload if <cond>
6226 catch unload <filename>
6227 catch unload <filename> if <cond>
6229 The user is not allowed to specify the <filename> after an
6232 We'll ignore the pathological case of a file named "if".
6234 First, check if there's an if clause. If so, then there
6235 cannot be a filename. */
6236 cond_string
= ep_parse_optional_if_clause (&arg
);
6238 /* If there was an if clause, then there cannot be a filename.
6239 Else, there might be a filename and an if clause. */
6240 if (cond_string
== NULL
)
6242 dll_pathname
= ep_parse_optional_filename (&arg
);
6243 ep_skip_leading_whitespace (&arg
);
6244 cond_string
= ep_parse_optional_if_clause (&arg
);
6247 if ((*arg
!= '\0') && !isspace (*arg
))
6248 error (_("Junk at end of arguments."));
6250 /* Create an unload breakpoint that only triggers when an unload of
6251 the specified dll (or any dll, if no pathname was specified)
6253 SOLIB_CREATE_CATCH_UNLOAD_HOOK (PIDGET (inferior_ptid
), tempflag
,
6254 dll_pathname
, cond_string
);
6257 /* Commands to deal with catching exceptions. */
6259 /* Set a breakpoint at the specified callback routine for an
6260 exception event callback */
6263 create_exception_catchpoint (int tempflag
, char *cond_string
,
6264 enum exception_event_kind ex_event
,
6265 struct symtab_and_line
*sal
)
6267 struct breakpoint
*b
;
6268 int thread
= -1; /* All threads. */
6271 if (!sal
) /* no exception support? */
6276 case EX_EVENT_THROW
:
6277 bptype
= bp_catch_throw
;
6279 case EX_EVENT_CATCH
:
6280 bptype
= bp_catch_catch
;
6282 default: /* error condition */
6283 error (_("Internal error -- invalid catchpoint kind"));
6286 b
= set_raw_breakpoint (*sal
, bptype
);
6287 set_breakpoint_count (breakpoint_count
+ 1);
6288 b
->number
= breakpoint_count
;
6290 b
->cond_string
= (cond_string
== NULL
) ?
6291 NULL
: savestring (cond_string
, strlen (cond_string
));
6293 b
->addr_string
= NULL
;
6294 b
->enable_state
= bp_enabled
;
6295 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
6299 static enum print_stop_action
6300 print_exception_catchpoint (struct breakpoint
*b
)
6302 annotate_catchpoint (b
->number
);
6304 if (strstr (b
->addr_string
, "throw") != NULL
)
6305 printf_filtered (_("\nCatchpoint %d (exception thrown)\n"),
6308 printf_filtered (_("\nCatchpoint %d (exception caught)\n"),
6311 return PRINT_SRC_AND_LOC
;
6315 print_one_exception_catchpoint (struct breakpoint
*b
, CORE_ADDR
*last_addr
)
6320 ui_out_field_core_addr (uiout
, "addr", b
->loc
->address
);
6323 *last_addr
= b
->loc
->address
;
6324 if (strstr (b
->addr_string
, "throw") != NULL
)
6325 ui_out_field_string (uiout
, "what", "exception throw");
6327 ui_out_field_string (uiout
, "what", "exception catch");
6331 print_mention_exception_catchpoint (struct breakpoint
*b
)
6333 if (strstr (b
->addr_string
, "throw") != NULL
)
6334 printf_filtered (_("Catchpoint %d (throw)"), b
->number
);
6336 printf_filtered (_("Catchpoint %d (catch)"), b
->number
);
6339 static struct breakpoint_ops gnu_v3_exception_catchpoint_ops
= {
6340 print_exception_catchpoint
,
6341 print_one_exception_catchpoint
,
6342 print_mention_exception_catchpoint
6346 handle_gnu_v3_exceptions (int tempflag
, char *cond_string
,
6347 enum exception_event_kind ex_event
, int from_tty
)
6349 char *trigger_func_name
, *nameptr
;
6350 struct symtabs_and_lines sals
;
6351 struct breakpoint
*b
;
6353 if (ex_event
== EX_EVENT_CATCH
)
6354 trigger_func_name
= xstrdup ("__cxa_begin_catch");
6356 trigger_func_name
= xstrdup ("__cxa_throw");
6358 nameptr
= trigger_func_name
;
6359 sals
= decode_line_1 (&nameptr
, 1, NULL
, 0, NULL
, NULL
);
6360 if (sals
.nelts
== 0)
6362 xfree (trigger_func_name
);
6366 b
= set_raw_breakpoint (sals
.sals
[0], bp_breakpoint
);
6367 set_breakpoint_count (breakpoint_count
+ 1);
6368 b
->number
= breakpoint_count
;
6370 b
->cond_string
= (cond_string
== NULL
) ?
6371 NULL
: savestring (cond_string
, strlen (cond_string
));
6373 b
->addr_string
= trigger_func_name
;
6374 b
->enable_state
= bp_enabled
;
6375 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
6376 b
->ops
= &gnu_v3_exception_catchpoint_ops
;
6383 /* Deal with "catch catch" and "catch throw" commands */
6386 catch_exception_command_1 (enum exception_event_kind ex_event
, char *arg
,
6387 int tempflag
, int from_tty
)
6389 char *cond_string
= NULL
;
6390 struct symtab_and_line
*sal
= NULL
;
6392 ep_skip_leading_whitespace (&arg
);
6394 cond_string
= ep_parse_optional_if_clause (&arg
);
6396 if ((*arg
!= '\0') && !isspace (*arg
))
6397 error (_("Junk at end of arguments."));
6399 if ((ex_event
!= EX_EVENT_THROW
) &&
6400 (ex_event
!= EX_EVENT_CATCH
))
6401 error (_("Unsupported or unknown exception event; cannot catch it"));
6403 if (handle_gnu_v3_exceptions (tempflag
, cond_string
, ex_event
, from_tty
))
6406 /* See if we can find a callback routine */
6407 sal
= target_enable_exception_callback (ex_event
, 1);
6411 /* We have callbacks from the runtime system for exceptions.
6412 Set a breakpoint on the sal found, if no errors */
6413 if (sal
!= (struct symtab_and_line
*) -1)
6414 create_exception_catchpoint (tempflag
, cond_string
, ex_event
, sal
);
6416 return; /* something went wrong with setting up callbacks */
6419 warning (_("Unsupported with this platform/compiler combination."));
6422 /* Cover routine to allow wrapping target_enable_exception_catchpoints
6423 inside a catch_errors */
6426 cover_target_enable_exception_callback (void *arg
)
6428 args_for_catchpoint_enable
*args
= arg
;
6429 struct symtab_and_line
*sal
;
6430 sal
= target_enable_exception_callback (args
->kind
, args
->enable_p
);
6433 else if (sal
== (struct symtab_and_line
*) -1)
6436 return 1; /*is valid */
6440 catch_command_1 (char *arg
, int tempflag
, int from_tty
)
6443 /* The first argument may be an event name, such as "start" or "load".
6444 If so, then handle it as such. If it doesn't match an event name,
6445 then attempt to interpret it as an exception name. (This latter is
6446 the v4.16-and-earlier GDB meaning of the "catch" command.)
6448 First, try to find the bounds of what might be an event name. */
6449 char *arg1_start
= arg
;
6453 if (arg1_start
== NULL
)
6455 /* Old behaviour was to use pre-v-4.16 syntax */
6456 /* catch_throw_command_1 (arg1_start, tempflag, from_tty); */
6458 /* Now, this is not allowed */
6459 error (_("Catch requires an event name."));
6462 arg1_end
= ep_find_event_name_end (arg1_start
);
6463 if (arg1_end
== NULL
)
6464 error (_("catch requires an event"));
6465 arg1_length
= arg1_end
+ 1 - arg1_start
;
6467 /* Try to match what we found against known event names. */
6468 if (strncmp (arg1_start
, "signal", arg1_length
) == 0)
6470 error (_("Catch of signal not yet implemented"));
6472 else if (strncmp (arg1_start
, "catch", arg1_length
) == 0)
6474 catch_exception_command_1 (EX_EVENT_CATCH
, arg1_end
+ 1,
6475 tempflag
, from_tty
);
6477 else if (strncmp (arg1_start
, "throw", arg1_length
) == 0)
6479 catch_exception_command_1 (EX_EVENT_THROW
, arg1_end
+ 1,
6480 tempflag
, from_tty
);
6482 else if (strncmp (arg1_start
, "thread_start", arg1_length
) == 0)
6484 error (_("Catch of thread_start not yet implemented"));
6486 else if (strncmp (arg1_start
, "thread_exit", arg1_length
) == 0)
6488 error (_("Catch of thread_exit not yet implemented"));
6490 else if (strncmp (arg1_start
, "thread_join", arg1_length
) == 0)
6492 error (_("Catch of thread_join not yet implemented"));
6494 else if (strncmp (arg1_start
, "start", arg1_length
) == 0)
6496 error (_("Catch of start not yet implemented"));
6498 else if (strncmp (arg1_start
, "exit", arg1_length
) == 0)
6500 error (_("Catch of exit not yet implemented"));
6502 else if (strncmp (arg1_start
, "fork", arg1_length
) == 0)
6504 catch_fork_command_1 (catch_fork
, arg1_end
+ 1, tempflag
, from_tty
);
6506 else if (strncmp (arg1_start
, "vfork", arg1_length
) == 0)
6508 catch_fork_command_1 (catch_vfork
, arg1_end
+ 1, tempflag
, from_tty
);
6510 else if (strncmp (arg1_start
, "exec", arg1_length
) == 0)
6512 catch_exec_command_1 (arg1_end
+ 1, tempflag
, from_tty
);
6514 else if (strncmp (arg1_start
, "load", arg1_length
) == 0)
6516 catch_load_command_1 (arg1_end
+ 1, tempflag
, from_tty
);
6518 else if (strncmp (arg1_start
, "unload", arg1_length
) == 0)
6520 catch_unload_command_1 (arg1_end
+ 1, tempflag
, from_tty
);
6522 else if (strncmp (arg1_start
, "stop", arg1_length
) == 0)
6524 error (_("Catch of stop not yet implemented"));
6527 /* This doesn't appear to be an event name */
6531 /* Pre-v.4.16 behaviour was to treat the argument
6532 as the name of an exception */
6533 /* catch_throw_command_1 (arg1_start, tempflag, from_tty); */
6534 /* Now this is not allowed */
6535 error (_("Unknown event kind specified for catch"));
6540 /* Used by the gui, could be made a worker for other things. */
6543 set_breakpoint_sal (struct symtab_and_line sal
)
6545 struct breakpoint
*b
;
6546 b
= set_raw_breakpoint (sal
, bp_breakpoint
);
6547 set_breakpoint_count (breakpoint_count
+ 1);
6548 b
->number
= breakpoint_count
;
6555 catch_command (char *arg
, int from_tty
)
6557 catch_command_1 (arg
, 0, from_tty
);
6562 tcatch_command (char *arg
, int from_tty
)
6564 catch_command_1 (arg
, 1, from_tty
);
6567 /* Delete breakpoints by address or line. */
6570 clear_command (char *arg
, int from_tty
)
6572 struct breakpoint
*b
, *tmp
, *prev
, *found
;
6574 struct symtabs_and_lines sals
;
6575 struct symtab_and_line sal
;
6580 sals
= decode_line_spec (arg
, 1);
6585 sals
.sals
= (struct symtab_and_line
*)
6586 xmalloc (sizeof (struct symtab_and_line
));
6587 make_cleanup (xfree
, sals
.sals
);
6588 init_sal (&sal
); /* initialize to zeroes */
6589 sal
.line
= default_breakpoint_line
;
6590 sal
.symtab
= default_breakpoint_symtab
;
6591 sal
.pc
= default_breakpoint_address
;
6592 if (sal
.symtab
== 0)
6593 error (_("No source file specified."));
6601 /* For each line spec given, delete bps which correspond
6602 to it. Do it in two passes, solely to preserve the current
6603 behavior that from_tty is forced true if we delete more than
6607 for (i
= 0; i
< sals
.nelts
; i
++)
6609 /* If exact pc given, clear bpts at that pc.
6610 If line given (pc == 0), clear all bpts on specified line.
6611 If defaulting, clear all bpts on default line
6614 defaulting sal.pc != 0 tests to do
6619 1 0 <can't happen> */
6624 /* Find all matching breakpoints, remove them from the
6625 breakpoint chain, and add them to the 'found' chain. */
6626 ALL_BREAKPOINTS_SAFE (b
, tmp
)
6628 /* Are we going to delete b? */
6629 if (b
->type
!= bp_none
6630 && b
->type
!= bp_watchpoint
6631 && b
->type
!= bp_hardware_watchpoint
6632 && b
->type
!= bp_read_watchpoint
6633 && b
->type
!= bp_access_watchpoint
6634 /* Not if b is a watchpoint of any sort... */
6635 && (((sal
.pc
&& (b
->loc
->address
== sal
.pc
))
6636 && (!section_is_overlay (b
->loc
->section
)
6637 || b
->loc
->section
== sal
.section
))
6638 /* Yes, if sal.pc matches b (modulo overlays). */
6639 || ((default_match
|| (0 == sal
.pc
))
6640 && b
->source_file
!= NULL
6641 && sal
.symtab
!= NULL
6642 && strcmp (b
->source_file
, sal
.symtab
->filename
) == 0
6643 && b
->line_number
== sal
.line
)))
6644 /* Yes, if sal source file and line matches b. */
6646 /* Remove it from breakpoint_chain... */
6647 if (b
== breakpoint_chain
)
6649 /* b is at the head of the list */
6650 breakpoint_chain
= b
->next
;
6654 prev
->next
= b
->next
;
6656 /* And add it to 'found' chain. */
6662 /* Keep b, and keep a pointer to it. */
6667 /* Now go thru the 'found' chain and delete them. */
6671 error (_("No breakpoint at %s."), arg
);
6673 error (_("No breakpoint at this line."));
6677 from_tty
= 1; /* Always report if deleted more than one */
6681 printf_unfiltered (_("Deleted breakpoint "));
6683 printf_unfiltered (_("Deleted breakpoints "));
6685 breakpoints_changed ();
6689 printf_unfiltered ("%d ", found
->number
);
6691 delete_breakpoint (found
);
6695 putchar_unfiltered ('\n');
6698 /* Delete breakpoint in BS if they are `delete' breakpoints and
6699 all breakpoints that are marked for deletion, whether hit or not.
6700 This is called after any breakpoint is hit, or after errors. */
6703 breakpoint_auto_delete (bpstat bs
)
6705 struct breakpoint
*b
, *temp
;
6707 for (; bs
; bs
= bs
->next
)
6708 if (bs
->breakpoint_at
&& bs
->breakpoint_at
->disposition
== disp_del
6710 delete_breakpoint (bs
->breakpoint_at
);
6712 ALL_BREAKPOINTS_SAFE (b
, temp
)
6714 if (b
->disposition
== disp_del_at_next_stop
)
6715 delete_breakpoint (b
);
6719 /* Delete a breakpoint and clean up all traces of it in the data
6723 delete_breakpoint (struct breakpoint
*bpt
)
6725 struct breakpoint
*b
;
6727 struct bp_location
*loc
;
6729 gdb_assert (bpt
!= NULL
);
6731 /* Has this bp already been deleted? This can happen because multiple
6732 lists can hold pointers to bp's. bpstat lists are especial culprits.
6734 One example of this happening is a watchpoint's scope bp. When the
6735 scope bp triggers, we notice that the watchpoint is out of scope, and
6736 delete it. We also delete its scope bp. But the scope bp is marked
6737 "auto-deleting", and is already on a bpstat. That bpstat is then
6738 checked for auto-deleting bp's, which are deleted.
6740 A real solution to this problem might involve reference counts in bp's,
6741 and/or giving them pointers back to their referencing bpstat's, and
6742 teaching delete_breakpoint to only free a bp's storage when no more
6743 references were extent. A cheaper bandaid was chosen. */
6744 if (bpt
->type
== bp_none
)
6747 if (deprecated_delete_breakpoint_hook
)
6748 deprecated_delete_breakpoint_hook (bpt
);
6749 breakpoint_delete_event (bpt
->number
);
6751 if (bpt
->loc
->inserted
)
6752 remove_breakpoint (bpt
->loc
, mark_inserted
);
6754 free_valchain (bpt
->loc
);
6756 if (breakpoint_chain
== bpt
)
6757 breakpoint_chain
= bpt
->next
;
6759 if (bp_location_chain
== bpt
->loc
)
6760 bp_location_chain
= bpt
->loc
->next
;
6762 /* If we have callback-style exception catchpoints, don't go through
6763 the adjustments to the C++ runtime library etc. if the inferior
6764 isn't actually running. target_enable_exception_callback for a
6765 null target ops vector gives an undesirable error message, so we
6766 check here and avoid it. Since currently (1997-09-17) only HP-UX aCC's
6767 exceptions are supported in this way, it's OK for now. FIXME */
6768 if (ep_is_exception_catchpoint (bpt
) && target_has_execution
)
6770 /* Format possible error msg */
6771 char *message
= xstrprintf ("Error in deleting catchpoint %d:\n",
6773 struct cleanup
*cleanups
= make_cleanup (xfree
, message
);
6774 args_for_catchpoint_enable args
;
6775 args
.kind
= bpt
->type
== bp_catch_catch
?
6776 EX_EVENT_CATCH
: EX_EVENT_THROW
;
6778 catch_errors (cover_target_enable_exception_callback
, &args
,
6779 message
, RETURN_MASK_ALL
);
6780 do_cleanups (cleanups
);
6787 b
->next
= bpt
->next
;
6791 ALL_BP_LOCATIONS (loc
)
6792 if (loc
->next
== bpt
->loc
)
6794 loc
->next
= bpt
->loc
->next
;
6798 check_duplicates (bpt
);
6799 /* If this breakpoint was inserted, and there is another breakpoint
6800 at the same address, we need to insert the other breakpoint. */
6801 if (bpt
->loc
->inserted
6802 && bpt
->type
!= bp_hardware_watchpoint
6803 && bpt
->type
!= bp_read_watchpoint
6804 && bpt
->type
!= bp_access_watchpoint
6805 && bpt
->type
!= bp_catch_fork
6806 && bpt
->type
!= bp_catch_vfork
6807 && bpt
->type
!= bp_catch_exec
)
6810 if (b
->loc
->address
== bpt
->loc
->address
6811 && b
->loc
->section
== bpt
->loc
->section
6812 && !b
->loc
->duplicate
6813 && b
->enable_state
!= bp_disabled
6814 && b
->enable_state
!= bp_shlib_disabled
6816 && b
->enable_state
!= bp_call_disabled
)
6820 /* We should never reach this point if there is a permanent
6821 breakpoint at the same address as the one being deleted.
6822 If there is a permanent breakpoint somewhere, it should
6823 always be the only one inserted. */
6824 if (b
->enable_state
== bp_permanent
)
6825 internal_error (__FILE__
, __LINE__
,
6826 _("another breakpoint was inserted on top of "
6827 "a permanent breakpoint"));
6829 if (b
->type
== bp_hardware_breakpoint
)
6830 val
= target_insert_hw_breakpoint (b
->loc
->address
, b
->loc
->shadow_contents
);
6832 val
= target_insert_breakpoint (b
->loc
->address
, b
->loc
->shadow_contents
);
6834 /* If there was an error in the insert, print a message, then stop execution. */
6837 struct ui_file
*tmp_error_stream
= mem_fileopen ();
6838 make_cleanup_ui_file_delete (tmp_error_stream
);
6841 if (b
->type
== bp_hardware_breakpoint
)
6843 fprintf_unfiltered (tmp_error_stream
,
6844 "Cannot insert hardware breakpoint %d.\n"
6845 "You may have requested too many hardware breakpoints.\n",
6850 fprintf_unfiltered (tmp_error_stream
, "Cannot insert breakpoint %d.\n", b
->number
);
6851 fprintf_filtered (tmp_error_stream
, "Error accessing memory address ");
6852 deprecated_print_address_numeric (b
->loc
->address
, 1, tmp_error_stream
);
6853 fprintf_filtered (tmp_error_stream
, ": %s.\n",
6854 safe_strerror (val
));
6857 fprintf_unfiltered (tmp_error_stream
,"The same program may be running in another process.");
6858 target_terminal_ours_for_output ();
6859 error_stream(tmp_error_stream
);
6862 b
->loc
->inserted
= 1;
6866 free_command_lines (&bpt
->commands
);
6869 if (bpt
->cond_string
!= NULL
)
6870 xfree (bpt
->cond_string
);
6871 if (bpt
->addr_string
!= NULL
)
6872 xfree (bpt
->addr_string
);
6873 if (bpt
->exp
!= NULL
)
6875 if (bpt
->exp_string
!= NULL
)
6876 xfree (bpt
->exp_string
);
6877 if (bpt
->val
!= NULL
)
6878 value_free (bpt
->val
);
6879 if (bpt
->source_file
!= NULL
)
6880 xfree (bpt
->source_file
);
6881 if (bpt
->dll_pathname
!= NULL
)
6882 xfree (bpt
->dll_pathname
);
6883 if (bpt
->triggered_dll_pathname
!= NULL
)
6884 xfree (bpt
->triggered_dll_pathname
);
6885 if (bpt
->exec_pathname
!= NULL
)
6886 xfree (bpt
->exec_pathname
);
6888 /* Be sure no bpstat's are pointing at it after it's been freed. */
6889 /* FIXME, how can we find all bpstat's?
6890 We just check stop_bpstat for now. */
6891 for (bs
= stop_bpstat
; bs
; bs
= bs
->next
)
6892 if (bs
->breakpoint_at
== bpt
)
6894 bs
->breakpoint_at
= NULL
;
6896 /* bs->commands will be freed later. */
6898 /* On the chance that someone will soon try again to delete this same
6899 bp, we mark it as deleted before freeing its storage. */
6900 bpt
->type
= bp_none
;
6907 do_delete_breakpoint_cleanup (void *b
)
6909 delete_breakpoint (b
);
6913 make_cleanup_delete_breakpoint (struct breakpoint
*b
)
6915 return make_cleanup (do_delete_breakpoint_cleanup
, b
);
6919 make_exec_cleanup_delete_breakpoint (struct breakpoint
*b
)
6921 return make_exec_cleanup (do_delete_breakpoint_cleanup
, b
);
6925 delete_command (char *arg
, int from_tty
)
6927 struct breakpoint
*b
, *temp
;
6933 int breaks_to_delete
= 0;
6935 /* Delete all breakpoints if no argument.
6936 Do not delete internal or call-dummy breakpoints, these
6937 have to be deleted with an explicit breakpoint number argument. */
6940 if (b
->type
!= bp_call_dummy
&&
6941 b
->type
!= bp_shlib_event
&&
6942 b
->type
!= bp_thread_event
&&
6943 b
->type
!= bp_overlay_event
&&
6945 breaks_to_delete
= 1;
6948 /* Ask user only if there are some breakpoints to delete. */
6950 || (breaks_to_delete
&& query (_("Delete all breakpoints? "))))
6952 ALL_BREAKPOINTS_SAFE (b
, temp
)
6954 if (b
->type
!= bp_call_dummy
&&
6955 b
->type
!= bp_shlib_event
&&
6956 b
->type
!= bp_thread_event
&&
6957 b
->type
!= bp_overlay_event
&&
6959 delete_breakpoint (b
);
6964 map_breakpoint_numbers (arg
, delete_breakpoint
);
6967 /* Reset a breakpoint given it's struct breakpoint * BINT.
6968 The value we return ends up being the return value from catch_errors.
6969 Unused in this case. */
6972 breakpoint_re_set_one (void *bint
)
6974 /* get past catch_errs */
6975 struct breakpoint
*b
= (struct breakpoint
*) bint
;
6979 int *not_found_ptr
= NULL
;
6980 struct symtabs_and_lines sals
;
6982 enum enable_state save_enable
;
6987 warning (_("attempted to reset apparently deleted breakpoint #%d?"),
6991 case bp_hardware_breakpoint
:
6993 case bp_catch_unload
:
6994 if (b
->addr_string
== NULL
)
6996 /* Anything without a string can't be re-set. */
6997 delete_breakpoint (b
);
7000 /* HACK: cagney/2001-11-11: kettenis/2001-11-11: MarkK wrote:
7002 ``And a hack it is, although Apple's Darwin version of GDB
7003 contains an almost identical hack to implement a "future
7004 break" command. It seems to work in many real world cases,
7005 but it is easy to come up with a test case where the patch
7006 doesn't help at all.''
7008 ``It seems that the way GDB implements breakpoints - in -
7009 shared - libraries was designed for a.out shared library
7010 systems (SunOS 4) where shared libraries were loaded at a
7011 fixed address in memory. Since ELF shared libraries can (and
7012 will) be loaded at any address in memory, things break.
7013 Fixing this is not trivial. Therefore, I'm not sure whether
7014 we should add this hack to the branch only. I cannot
7015 guarantee that things will be fixed on the trunk in the near
7018 In case we have a problem, disable this breakpoint. We'll
7019 restore its status if we succeed. Don't disable a
7020 shlib_disabled breakpoint though. There's a fair chance we
7021 can't re-set it if the shared library it's in hasn't been
7027 save_enable
= b
->enable_state
;
7028 if (b
->enable_state
!= bp_shlib_disabled
)
7029 b
->enable_state
= bp_disabled
;
7031 /* If resetting a shlib-disabled breakpoint, we don't want to
7032 see an error message if it is not found since we will expect
7033 this to occur until the shared library is finally reloaded.
7034 We accomplish this by giving decode_line_1 a pointer to use
7035 for silent notification that the symbol is not found. */
7036 not_found_ptr
= ¬_found
;
7038 set_language (b
->language
);
7039 input_radix
= b
->input_radix
;
7041 sals
= decode_line_1 (&s
, 1, (struct symtab
*) NULL
, 0, (char ***) NULL
,
7043 for (i
= 0; i
< sals
.nelts
; i
++)
7045 resolve_sal_pc (&sals
.sals
[i
]);
7047 /* Reparse conditions, they might contain references to the
7049 if (b
->cond_string
!= NULL
)
7055 /* Avoid re-freeing b->exp if an error during the call
7059 b
->cond
= parse_exp_1 (&s
, block_for_pc (sals
.sals
[i
].pc
), 0);
7062 /* We need to re-set the breakpoint if the address changes... */
7063 if (b
->loc
->address
!= sals
.sals
[i
].pc
7064 /* ...or new and old breakpoints both have source files, and
7065 the source file name or the line number changes... */
7066 || (b
->source_file
!= NULL
7067 && sals
.sals
[i
].symtab
!= NULL
7068 && (strcmp (b
->source_file
, sals
.sals
[i
].symtab
->filename
) != 0
7069 || b
->line_number
!= sals
.sals
[i
].line
)
7071 /* ...or we switch between having a source file and not having
7073 || ((b
->source_file
== NULL
) != (sals
.sals
[i
].symtab
== NULL
))
7076 if (b
->source_file
!= NULL
)
7077 xfree (b
->source_file
);
7078 if (sals
.sals
[i
].symtab
== NULL
)
7079 b
->source_file
= NULL
;
7082 savestring (sals
.sals
[i
].symtab
->filename
,
7083 strlen (sals
.sals
[i
].symtab
->filename
));
7084 b
->line_number
= sals
.sals
[i
].line
;
7085 b
->loc
->requested_address
= sals
.sals
[i
].pc
;
7087 = adjust_breakpoint_address (b
->loc
->requested_address
,
7090 /* Used to check for duplicates here, but that can
7091 cause trouble, as it doesn't check for disabled
7096 /* Might be better to do this just once per breakpoint_re_set,
7097 rather than once for every breakpoint. */
7098 breakpoints_changed ();
7100 b
->loc
->section
= sals
.sals
[i
].section
;
7101 b
->enable_state
= save_enable
; /* Restore it, this worked. */
7104 /* Now that this is re-enabled, check_duplicates
7106 check_duplicates (b
);
7113 case bp_hardware_watchpoint
:
7114 case bp_read_watchpoint
:
7115 case bp_access_watchpoint
:
7116 innermost_block
= NULL
;
7117 /* The issue arises of what context to evaluate this in. The
7118 same one as when it was set, but what does that mean when
7119 symbols have been re-read? We could save the filename and
7120 functionname, but if the context is more local than that, the
7121 best we could do would be something like how many levels deep
7122 and which index at that particular level, but that's going to
7123 be less stable than filenames or function names. */
7125 /* So for now, just use a global context. */
7129 /* Avoid re-freeing b->exp if an error during the call to
7130 parse_expression. */
7133 b
->exp
= parse_expression (b
->exp_string
);
7134 b
->exp_valid_block
= innermost_block
;
7135 mark
= value_mark ();
7138 value_free (b
->val
);
7139 /* Avoid re-freeing b->val if an error during the call to
7140 evaluate_expression. */
7143 b
->val
= evaluate_expression (b
->exp
);
7144 release_value (b
->val
);
7145 if (value_lazy (b
->val
) && breakpoint_enabled (b
))
7146 value_fetch_lazy (b
->val
);
7148 if (b
->cond_string
!= NULL
)
7154 /* Avoid re-freeing b->exp if an error during the call
7158 b
->cond
= parse_exp_1 (&s
, (struct block
*) 0, 0);
7160 if (breakpoint_enabled (b
))
7162 value_free_to_mark (mark
);
7164 case bp_catch_catch
:
7165 case bp_catch_throw
:
7167 /* We needn't really do anything to reset these, since the mask
7168 that requests them is unaffected by e.g., new libraries being
7171 case bp_catch_vfork
:
7176 printf_filtered (_("Deleting unknown breakpoint type %d\n"), b
->type
);
7178 /* Delete longjmp and overlay event breakpoints; they will be
7179 reset later by breakpoint_re_set. */
7181 case bp_longjmp_resume
:
7182 case bp_overlay_event
:
7183 delete_breakpoint (b
);
7186 /* This breakpoint is special, it's set up when the inferior
7187 starts and we really don't want to touch it. */
7188 case bp_shlib_event
:
7190 /* Like bp_shlib_event, this breakpoint type is special.
7191 Once it is set up, we do not want to touch it. */
7192 case bp_thread_event
:
7194 /* Keep temporary breakpoints, which can be encountered when we step
7195 over a dlopen call and SOLIB_ADD is resetting the breakpoints.
7196 Otherwise these should have been blown away via the cleanup chain
7197 or by breakpoint_init_inferior when we rerun the executable. */
7200 case bp_watchpoint_scope
:
7202 case bp_step_resume
:
7209 /* Re-set all breakpoints after symbols have been re-loaded. */
7211 breakpoint_re_set (void)
7213 struct breakpoint
*b
, *temp
;
7214 enum language save_language
;
7215 int save_input_radix
;
7217 save_language
= current_language
->la_language
;
7218 save_input_radix
= input_radix
;
7219 ALL_BREAKPOINTS_SAFE (b
, temp
)
7221 /* Format possible error msg */
7222 char *message
= xstrprintf ("Error in re-setting breakpoint %d:\n",
7224 struct cleanup
*cleanups
= make_cleanup (xfree
, message
);
7225 catch_errors (breakpoint_re_set_one
, b
, message
, RETURN_MASK_ALL
);
7226 do_cleanups (cleanups
);
7228 set_language (save_language
);
7229 input_radix
= save_input_radix
;
7231 if (GET_LONGJMP_TARGET_P ())
7233 create_longjmp_breakpoint ("longjmp");
7234 create_longjmp_breakpoint ("_longjmp");
7235 create_longjmp_breakpoint ("siglongjmp");
7236 create_longjmp_breakpoint ("_siglongjmp");
7237 create_longjmp_breakpoint (NULL
);
7240 create_overlay_event_breakpoint ("_ovly_debug_event");
7243 /* Reset the thread number of this breakpoint:
7245 - If the breakpoint is for all threads, leave it as-is.
7246 - Else, reset it to the current thread for inferior_ptid. */
7248 breakpoint_re_set_thread (struct breakpoint
*b
)
7250 if (b
->thread
!= -1)
7252 if (in_thread_list (inferior_ptid
))
7253 b
->thread
= pid_to_thread_id (inferior_ptid
);
7257 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
7258 If from_tty is nonzero, it prints a message to that effect,
7259 which ends with a period (no newline). */
7262 set_ignore_count (int bptnum
, int count
, int from_tty
)
7264 struct breakpoint
*b
;
7270 if (b
->number
== bptnum
)
7272 b
->ignore_count
= count
;
7276 printf_filtered (_("Will stop next time breakpoint %d is reached."),
7278 else if (count
== 1)
7279 printf_filtered (_("Will ignore next crossing of breakpoint %d."),
7282 printf_filtered (_("Will ignore next %d crossings of breakpoint %d."),
7285 breakpoints_changed ();
7286 breakpoint_modify_event (b
->number
);
7290 error (_("No breakpoint number %d."), bptnum
);
7293 /* Clear the ignore counts of all breakpoints. */
7295 breakpoint_clear_ignore_counts (void)
7297 struct breakpoint
*b
;
7300 b
->ignore_count
= 0;
7303 /* Command to set ignore-count of breakpoint N to COUNT. */
7306 ignore_command (char *args
, int from_tty
)
7312 error_no_arg (_("a breakpoint number"));
7314 num
= get_number (&p
);
7316 error (_("bad breakpoint number: '%s'"), args
);
7318 error (_("Second argument (specified ignore-count) is missing."));
7320 set_ignore_count (num
,
7321 longest_to_int (value_as_long (parse_and_eval (p
))),
7324 printf_filtered ("\n");
7327 /* Call FUNCTION on each of the breakpoints
7328 whose numbers are given in ARGS. */
7331 map_breakpoint_numbers (char *args
, void (*function
) (struct breakpoint
*))
7336 struct breakpoint
*b
, *tmp
;
7340 error_no_arg (_("one or more breakpoint numbers"));
7347 num
= get_number_or_range (&p1
);
7350 warning (_("bad breakpoint number at or near '%s'"), p
);
7354 ALL_BREAKPOINTS_SAFE (b
, tmp
)
7355 if (b
->number
== num
)
7357 struct breakpoint
*related_breakpoint
= b
->related_breakpoint
;
7360 if (related_breakpoint
)
7361 function (related_breakpoint
);
7365 printf_unfiltered (_("No breakpoint number %d.\n"), num
);
7371 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
7372 If from_tty is nonzero, it prints a message to that effect,
7373 which ends with a period (no newline). */
7376 disable_breakpoint (struct breakpoint
*bpt
)
7378 /* Never disable a watchpoint scope breakpoint; we want to
7379 hit them when we leave scope so we can delete both the
7380 watchpoint and its scope breakpoint at that time. */
7381 if (bpt
->type
== bp_watchpoint_scope
)
7384 /* You can't disable permanent breakpoints. */
7385 if (bpt
->enable_state
== bp_permanent
)
7388 bpt
->enable_state
= bp_disabled
;
7390 check_duplicates (bpt
);
7392 if (deprecated_modify_breakpoint_hook
)
7393 deprecated_modify_breakpoint_hook (bpt
);
7394 breakpoint_modify_event (bpt
->number
);
7398 disable_command (char *args
, int from_tty
)
7400 struct breakpoint
*bpt
;
7402 ALL_BREAKPOINTS (bpt
)
7406 warning (_("attempted to disable apparently deleted breakpoint #%d?"),
7411 case bp_catch_unload
:
7413 case bp_catch_vfork
:
7415 case bp_catch_catch
:
7416 case bp_catch_throw
:
7417 case bp_hardware_breakpoint
:
7419 case bp_hardware_watchpoint
:
7420 case bp_read_watchpoint
:
7421 case bp_access_watchpoint
:
7422 disable_breakpoint (bpt
);
7427 map_breakpoint_numbers (args
, disable_breakpoint
);
7431 do_enable_breakpoint (struct breakpoint
*bpt
, enum bpdisp disposition
)
7433 int target_resources_ok
, other_type_used
;
7436 if (bpt
->type
== bp_hardware_breakpoint
)
7439 i
= hw_breakpoint_used_count ();
7440 target_resources_ok
=
7441 TARGET_CAN_USE_HARDWARE_WATCHPOINT (bp_hardware_breakpoint
,
7443 if (target_resources_ok
== 0)
7444 error (_("No hardware breakpoint support in the target."));
7445 else if (target_resources_ok
< 0)
7446 error (_("Hardware breakpoints used exceeds limit."));
7451 if (bpt
->enable_state
!= bp_enabled
)
7453 /* When enabling a pending breakpoint, we need to check if the breakpoint
7454 is resolvable since shared libraries could have been loaded
7455 after the breakpoint was disabled. */
7456 breakpoints_changed ();
7457 if (resolve_pending_breakpoint (bpt
) == GDB_RC_OK
)
7459 delete_breakpoint (bpt
);
7462 bpt
->enable_state
= bp_enabled
;
7463 bpt
->disposition
= disposition
;
7466 else /* Not a pending breakpoint. */
7468 if (bpt
->enable_state
!= bp_permanent
)
7469 bpt
->enable_state
= bp_enabled
;
7470 bpt
->disposition
= disposition
;
7471 check_duplicates (bpt
);
7472 breakpoints_changed ();
7474 if (bpt
->type
== bp_watchpoint
||
7475 bpt
->type
== bp_hardware_watchpoint
||
7476 bpt
->type
== bp_read_watchpoint
||
7477 bpt
->type
== bp_access_watchpoint
)
7479 struct frame_id saved_frame_id
;
7481 saved_frame_id
= get_frame_id (get_selected_frame (NULL
));
7482 if (bpt
->exp_valid_block
!= NULL
)
7484 struct frame_info
*fr
=
7485 fr
= frame_find_by_id (bpt
->watchpoint_frame
);
7488 printf_filtered (_("\
7489 Cannot enable watchpoint %d because the block in which its expression\n\
7490 is valid is not currently in scope.\n"), bpt
->number
);
7491 bpt
->enable_state
= bp_disabled
;
7497 value_free (bpt
->val
);
7498 mark
= value_mark ();
7499 bpt
->val
= evaluate_expression (bpt
->exp
);
7500 release_value (bpt
->val
);
7501 if (value_lazy (bpt
->val
))
7502 value_fetch_lazy (bpt
->val
);
7504 if (bpt
->type
== bp_hardware_watchpoint
||
7505 bpt
->type
== bp_read_watchpoint
||
7506 bpt
->type
== bp_access_watchpoint
)
7508 int i
= hw_watchpoint_used_count (bpt
->type
, &other_type_used
);
7509 int mem_cnt
= can_use_hardware_watchpoint (bpt
->val
);
7511 /* Hack around 'unused var' error for some targets here */
7513 target_resources_ok
= TARGET_CAN_USE_HARDWARE_WATCHPOINT (
7514 bpt
->type
, i
+ mem_cnt
, other_type_used
);
7515 /* we can consider of type is bp_hardware_watchpoint, convert to
7516 bp_watchpoint in the following condition */
7517 if (target_resources_ok
< 0)
7519 printf_filtered (_("\
7520 Cannot enable watchpoint %d because target watch resources\n\
7521 have been allocated for other watchpoints.\n"), bpt
->number
);
7522 bpt
->enable_state
= bp_disabled
;
7523 value_free_to_mark (mark
);
7528 select_frame (frame_find_by_id (saved_frame_id
));
7529 value_free_to_mark (mark
);
7533 if (deprecated_modify_breakpoint_hook
)
7534 deprecated_modify_breakpoint_hook (bpt
);
7535 breakpoint_modify_event (bpt
->number
);
7539 enable_breakpoint (struct breakpoint
*bpt
)
7541 do_enable_breakpoint (bpt
, bpt
->disposition
);
7544 /* The enable command enables the specified breakpoints (or all defined
7545 breakpoints) so they once again become (or continue to be) effective
7546 in stopping the inferior. */
7549 enable_command (char *args
, int from_tty
)
7551 struct breakpoint
*bpt
;
7553 ALL_BREAKPOINTS (bpt
)
7557 warning (_("attempted to enable apparently deleted breakpoint #%d?"),
7562 case bp_catch_unload
:
7564 case bp_catch_vfork
:
7566 case bp_catch_catch
:
7567 case bp_catch_throw
:
7568 case bp_hardware_breakpoint
:
7570 case bp_hardware_watchpoint
:
7571 case bp_read_watchpoint
:
7572 case bp_access_watchpoint
:
7573 enable_breakpoint (bpt
);
7578 map_breakpoint_numbers (args
, enable_breakpoint
);
7582 enable_once_breakpoint (struct breakpoint
*bpt
)
7584 do_enable_breakpoint (bpt
, disp_disable
);
7588 enable_once_command (char *args
, int from_tty
)
7590 map_breakpoint_numbers (args
, enable_once_breakpoint
);
7594 enable_delete_breakpoint (struct breakpoint
*bpt
)
7596 do_enable_breakpoint (bpt
, disp_del
);
7600 enable_delete_command (char *args
, int from_tty
)
7602 map_breakpoint_numbers (args
, enable_delete_breakpoint
);
7606 set_breakpoint_cmd (char *args
, int from_tty
)
7611 show_breakpoint_cmd (char *args
, int from_tty
)
7615 /* Use default_breakpoint_'s, or nothing if they aren't valid. */
7617 struct symtabs_and_lines
7618 decode_line_spec_1 (char *string
, int funfirstline
)
7620 struct symtabs_and_lines sals
;
7622 error (_("Empty line specification."));
7623 if (default_breakpoint_valid
)
7624 sals
= decode_line_1 (&string
, funfirstline
,
7625 default_breakpoint_symtab
,
7626 default_breakpoint_line
,
7627 (char ***) NULL
, NULL
);
7629 sals
= decode_line_1 (&string
, funfirstline
,
7630 (struct symtab
*) NULL
, 0, (char ***) NULL
, NULL
);
7632 error (_("Junk at end of line specification: %s"), string
);
7637 _initialize_breakpoint (void)
7639 static struct cmd_list_element
*breakpoint_set_cmdlist
;
7640 static struct cmd_list_element
*breakpoint_show_cmdlist
;
7641 struct cmd_list_element
*c
;
7643 observer_attach_solib_unloaded (disable_breakpoints_in_unloaded_shlib
);
7645 breakpoint_chain
= 0;
7646 /* Don't bother to call set_breakpoint_count. $bpnum isn't useful
7647 before a breakpoint is set. */
7648 breakpoint_count
= 0;
7650 add_com ("ignore", class_breakpoint
, ignore_command
, _("\
7651 Set ignore-count of breakpoint number N to COUNT.\n\
7652 Usage is `ignore N COUNT'."));
7654 add_com_alias ("bc", "ignore", class_breakpoint
, 1);
7656 add_com ("commands", class_breakpoint
, commands_command
, _("\
7657 Set commands to be executed when a breakpoint is hit.\n\
7658 Give breakpoint number as argument after \"commands\".\n\
7659 With no argument, the targeted breakpoint is the last one set.\n\
7660 The commands themselves follow starting on the next line.\n\
7661 Type a line containing \"end\" to indicate the end of them.\n\
7662 Give \"silent\" as the first line to make the breakpoint silent;\n\
7663 then no output is printed when it is hit, except what the commands print."));
7665 add_com ("condition", class_breakpoint
, condition_command
, _("\
7666 Specify breakpoint number N to break only if COND is true.\n\
7667 Usage is `condition N COND', where N is an integer and COND is an\n\
7668 expression to be evaluated whenever breakpoint N is reached."));
7670 c
= add_com ("tbreak", class_breakpoint
, tbreak_command
, _("\
7671 Set a temporary breakpoint. Args like \"break\" command.\n\
7672 Like \"break\" except the breakpoint is only temporary,\n\
7673 so it will be deleted when hit. Equivalent to \"break\" followed\n\
7674 by using \"enable delete\" on the breakpoint number."));
7675 set_cmd_completer (c
, location_completer
);
7677 c
= add_com ("hbreak", class_breakpoint
, hbreak_command
, _("\
7678 Set a hardware assisted breakpoint. Args like \"break\" command.\n\
7679 Like \"break\" except the breakpoint requires hardware support,\n\
7680 some target hardware may not have this support."));
7681 set_cmd_completer (c
, location_completer
);
7683 c
= add_com ("thbreak", class_breakpoint
, thbreak_command
, _("\
7684 Set a temporary hardware assisted breakpoint. Args like \"break\" command.\n\
7685 Like \"hbreak\" except the breakpoint is only temporary,\n\
7686 so it will be deleted when hit."));
7687 set_cmd_completer (c
, location_completer
);
7689 add_prefix_cmd ("enable", class_breakpoint
, enable_command
, _("\
7690 Enable some breakpoints.\n\
7691 Give breakpoint numbers (separated by spaces) as arguments.\n\
7692 With no subcommand, breakpoints are enabled until you command otherwise.\n\
7693 This is used to cancel the effect of the \"disable\" command.\n\
7694 With a subcommand you can enable temporarily."),
7695 &enablelist
, "enable ", 1, &cmdlist
);
7697 add_com ("ab", class_breakpoint
, enable_command
, _("\
7698 Enable some breakpoints.\n\
7699 Give breakpoint numbers (separated by spaces) as arguments.\n\
7700 With no subcommand, breakpoints are enabled until you command otherwise.\n\
7701 This is used to cancel the effect of the \"disable\" command.\n\
7702 With a subcommand you can enable temporarily."));
7704 add_com_alias ("en", "enable", class_breakpoint
, 1);
7706 add_abbrev_prefix_cmd ("breakpoints", class_breakpoint
, enable_command
, _("\
7707 Enable some breakpoints.\n\
7708 Give breakpoint numbers (separated by spaces) as arguments.\n\
7709 This is used to cancel the effect of the \"disable\" command.\n\
7710 May be abbreviated to simply \"enable\".\n"),
7711 &enablebreaklist
, "enable breakpoints ", 1, &enablelist
);
7713 add_cmd ("once", no_class
, enable_once_command
, _("\
7714 Enable breakpoints for one hit. Give breakpoint numbers.\n\
7715 If a breakpoint is hit while enabled in this fashion, it becomes disabled."),
7718 add_cmd ("delete", no_class
, enable_delete_command
, _("\
7719 Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
7720 If a breakpoint is hit while enabled in this fashion, it is deleted."),
7723 add_cmd ("delete", no_class
, enable_delete_command
, _("\
7724 Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
7725 If a breakpoint is hit while enabled in this fashion, it is deleted."),
7728 add_cmd ("once", no_class
, enable_once_command
, _("\
7729 Enable breakpoints for one hit. Give breakpoint numbers.\n\
7730 If a breakpoint is hit while enabled in this fashion, it becomes disabled."),
7733 add_prefix_cmd ("disable", class_breakpoint
, disable_command
, _("\
7734 Disable some breakpoints.\n\
7735 Arguments are breakpoint numbers with spaces in between.\n\
7736 To disable all breakpoints, give no argument.\n\
7737 A disabled breakpoint is not forgotten, but has no effect until reenabled."),
7738 &disablelist
, "disable ", 1, &cmdlist
);
7739 add_com_alias ("dis", "disable", class_breakpoint
, 1);
7740 add_com_alias ("disa", "disable", class_breakpoint
, 1);
7742 add_com ("sb", class_breakpoint
, disable_command
, _("\
7743 Disable some breakpoints.\n\
7744 Arguments are breakpoint numbers with spaces in between.\n\
7745 To disable all breakpoints, give no argument.\n\
7746 A disabled breakpoint is not forgotten, but has no effect until reenabled."));
7748 add_cmd ("breakpoints", class_alias
, disable_command
, _("\
7749 Disable some breakpoints.\n\
7750 Arguments are breakpoint numbers with spaces in between.\n\
7751 To disable all breakpoints, give no argument.\n\
7752 A disabled breakpoint is not forgotten, but has no effect until reenabled.\n\
7753 This command may be abbreviated \"disable\"."),
7756 add_prefix_cmd ("delete", class_breakpoint
, delete_command
, _("\
7757 Delete some breakpoints or auto-display expressions.\n\
7758 Arguments are breakpoint numbers with spaces in between.\n\
7759 To delete all breakpoints, give no argument.\n\
7761 Also a prefix command for deletion of other GDB objects.\n\
7762 The \"unset\" command is also an alias for \"delete\"."),
7763 &deletelist
, "delete ", 1, &cmdlist
);
7764 add_com_alias ("d", "delete", class_breakpoint
, 1);
7766 add_com ("db", class_breakpoint
, delete_command
, _("\
7767 Delete some breakpoints.\n\
7768 Arguments are breakpoint numbers with spaces in between.\n\
7769 To delete all breakpoints, give no argument.\n"));
7771 add_cmd ("breakpoints", class_alias
, delete_command
, _("\
7772 Delete some breakpoints or auto-display expressions.\n\
7773 Arguments are breakpoint numbers with spaces in between.\n\
7774 To delete all breakpoints, give no argument.\n\
7775 This command may be abbreviated \"delete\"."),
7778 add_com ("clear", class_breakpoint
, clear_command
, _("\
7779 Clear breakpoint at specified line or function.\n\
7780 Argument may be line number, function name, or \"*\" and an address.\n\
7781 If line number is specified, all breakpoints in that line are cleared.\n\
7782 If function is specified, breakpoints at beginning of function are cleared.\n\
7783 If an address is specified, breakpoints at that address are cleared.\n\
7785 With no argument, clears all breakpoints in the line that the selected frame\n\
7788 See also the \"delete\" command which clears breakpoints by number."));
7790 c
= add_com ("break", class_breakpoint
, break_command
, _("\
7791 Set breakpoint at specified line or function.\n\
7792 Argument may be line number, function name, or \"*\" and an address.\n\
7793 If line number is specified, break at start of code for that line.\n\
7794 If function is specified, break at start of code for that function.\n\
7795 If an address is specified, break at that exact address.\n\
7796 With no arg, uses current execution address of selected stack frame.\n\
7797 This is useful for breaking on return to a stack frame.\n\
7799 Multiple breakpoints at one place are permitted, and useful if conditional.\n\
7801 Do \"help breakpoints\" for info on other commands dealing with breakpoints."));
7802 set_cmd_completer (c
, location_completer
);
7804 add_com_alias ("b", "break", class_run
, 1);
7805 add_com_alias ("br", "break", class_run
, 1);
7806 add_com_alias ("bre", "break", class_run
, 1);
7807 add_com_alias ("brea", "break", class_run
, 1);
7811 add_com_alias ("ba", "break", class_breakpoint
, 1);
7812 add_com_alias ("bu", "ubreak", class_breakpoint
, 1);
7817 add_abbrev_prefix_cmd ("stop", class_breakpoint
, stop_command
, _("\
7818 Break in function/address or break at a line in the current file."),
7819 &stoplist
, "stop ", 1, &cmdlist
);
7820 add_cmd ("in", class_breakpoint
, stopin_command
,
7821 _("Break in function or address."), &stoplist
);
7822 add_cmd ("at", class_breakpoint
, stopat_command
,
7823 _("Break at a line in the current file."), &stoplist
);
7824 add_com ("status", class_info
, breakpoints_info
, _("\
7825 Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
7826 The \"Type\" column indicates one of:\n\
7827 \tbreakpoint - normal breakpoint\n\
7828 \twatchpoint - watchpoint\n\
7829 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
7830 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
7831 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
7832 address and file/line number respectively.\n\
7834 Convenience variable \"$_\" and default examine address for \"x\"\n\
7835 are set to the address of the last breakpoint listed.\n\n\
7836 Convenience variable \"$bpnum\" contains the number of the last\n\
7840 add_info ("breakpoints", breakpoints_info
, _("\
7841 Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
7842 The \"Type\" column indicates one of:\n\
7843 \tbreakpoint - normal breakpoint\n\
7844 \twatchpoint - watchpoint\n\
7845 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
7846 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
7847 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
7848 address and file/line number respectively.\n\
7850 Convenience variable \"$_\" and default examine address for \"x\"\n\
7851 are set to the address of the last breakpoint listed.\n\n\
7852 Convenience variable \"$bpnum\" contains the number of the last\n\
7856 add_com ("lb", class_breakpoint
, breakpoints_info
, _("\
7857 Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
7858 The \"Type\" column indicates one of:\n\
7859 \tbreakpoint - normal breakpoint\n\
7860 \twatchpoint - watchpoint\n\
7861 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
7862 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
7863 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
7864 address and file/line number respectively.\n\
7866 Convenience variable \"$_\" and default examine address for \"x\"\n\
7867 are set to the address of the last breakpoint listed.\n\n\
7868 Convenience variable \"$bpnum\" contains the number of the last\n\
7871 add_cmd ("breakpoints", class_maintenance
, maintenance_info_breakpoints
, _("\
7872 Status of all breakpoints, or breakpoint number NUMBER.\n\
7873 The \"Type\" column indicates one of:\n\
7874 \tbreakpoint - normal breakpoint\n\
7875 \twatchpoint - watchpoint\n\
7876 \tlongjmp - internal breakpoint used to step through longjmp()\n\
7877 \tlongjmp resume - internal breakpoint at the target of longjmp()\n\
7878 \tuntil - internal breakpoint used by the \"until\" command\n\
7879 \tfinish - internal breakpoint used by the \"finish\" command\n\
7880 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
7881 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
7882 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
7883 address and file/line number respectively.\n\
7885 Convenience variable \"$_\" and default examine address for \"x\"\n\
7886 are set to the address of the last breakpoint listed.\n\
7888 Convenience variable \"$bpnum\" contains the number of the last\n\
7890 &maintenanceinfolist
);
7892 add_com ("catch", class_breakpoint
, catch_command
, _("\
7893 Set catchpoints to catch events.\n\
7894 Raised signals may be caught:\n\
7895 \tcatch signal - all signals\n\
7896 \tcatch signal <signame> - a particular signal\n\
7897 Raised exceptions may be caught:\n\
7898 \tcatch throw - all exceptions, when thrown\n\
7899 \tcatch throw <exceptname> - a particular exception, when thrown\n\
7900 \tcatch catch - all exceptions, when caught\n\
7901 \tcatch catch <exceptname> - a particular exception, when caught\n\
7902 Thread or process events may be caught:\n\
7903 \tcatch thread_start - any threads, just after creation\n\
7904 \tcatch thread_exit - any threads, just before expiration\n\
7905 \tcatch thread_join - any threads, just after joins\n\
7906 Process events may be caught:\n\
7907 \tcatch start - any processes, just after creation\n\
7908 \tcatch exit - any processes, just before expiration\n\
7909 \tcatch fork - calls to fork()\n\
7910 \tcatch vfork - calls to vfork()\n\
7911 \tcatch exec - calls to exec()\n\
7912 Dynamically-linked library events may be caught:\n\
7913 \tcatch load - loads of any library\n\
7914 \tcatch load <libname> - loads of a particular library\n\
7915 \tcatch unload - unloads of any library\n\
7916 \tcatch unload <libname> - unloads of a particular library\n\
7917 The act of your program's execution stopping may also be caught:\n\
7919 C++ exceptions may be caught:\n\
7920 \tcatch throw - all exceptions, when thrown\n\
7921 \tcatch catch - all exceptions, when caught\n\
7923 Do \"help set follow-fork-mode\" for info on debugging your program\n\
7924 after a fork or vfork is caught.\n\n\
7925 Do \"help breakpoints\" for info on other commands dealing with breakpoints."));
7927 add_com ("tcatch", class_breakpoint
, tcatch_command
, _("\
7928 Set temporary catchpoints to catch events.\n\
7929 Args like \"catch\" command.\n\
7930 Like \"catch\" except the catchpoint is only temporary,\n\
7931 so it will be deleted when hit. Equivalent to \"catch\" followed\n\
7932 by using \"enable delete\" on the catchpoint number."));
7934 c
= add_com ("watch", class_breakpoint
, watch_command
, _("\
7935 Set a watchpoint for an expression.\n\
7936 A watchpoint stops execution of your program whenever the value of\n\
7937 an expression changes."));
7938 set_cmd_completer (c
, location_completer
);
7940 c
= add_com ("rwatch", class_breakpoint
, rwatch_command
, _("\
7941 Set a read watchpoint for an expression.\n\
7942 A watchpoint stops execution of your program whenever the value of\n\
7943 an expression is read."));
7944 set_cmd_completer (c
, location_completer
);
7946 c
= add_com ("awatch", class_breakpoint
, awatch_command
, _("\
7947 Set a watchpoint for an expression.\n\
7948 A watchpoint stops execution of your program whenever the value of\n\
7949 an expression is either read or written."));
7950 set_cmd_completer (c
, location_completer
);
7952 add_info ("watchpoints", breakpoints_info
,
7953 _("Synonym for ``info breakpoints''."));
7956 /* XXX: cagney/2005-02-23: This should be a boolean, and should
7957 respond to changes - contrary to the description. */
7958 add_setshow_zinteger_cmd ("can-use-hw-watchpoints", class_support
,
7959 &can_use_hw_watchpoints
, _("\
7960 Set debugger's willingness to use watchpoint hardware."), _("\
7961 Show debugger's willingness to use watchpoint hardware."), _("\
7962 If zero, gdb will not use hardware for new watchpoints, even if\n\
7963 such is available. (However, any hardware watchpoints that were\n\
7964 created before setting this to nonzero, will continue to use watchpoint\n\
7967 show_can_use_hw_watchpoints
,
7968 &setlist
, &showlist
);
7970 can_use_hw_watchpoints
= 1;
7972 add_prefix_cmd ("breakpoint", class_maintenance
, set_breakpoint_cmd
, _("\
7973 Breakpoint specific settings\n\
7974 Configure various breakpoint-specific variables such as\n\
7975 pending breakpoint behavior"),
7976 &breakpoint_set_cmdlist
, "set breakpoint ",
7977 0/*allow-unknown*/, &setlist
);
7978 add_prefix_cmd ("breakpoint", class_maintenance
, show_breakpoint_cmd
, _("\
7979 Breakpoint specific settings\n\
7980 Configure various breakpoint-specific variables such as\n\
7981 pending breakpoint behavior"),
7982 &breakpoint_show_cmdlist
, "show breakpoint ",
7983 0/*allow-unknown*/, &showlist
);
7985 add_setshow_auto_boolean_cmd ("pending", no_class
,
7986 &pending_break_support
, _("\
7987 Set debugger's behavior regarding pending breakpoints."), _("\
7988 Show debugger's behavior regarding pending breakpoints."), _("\
7989 If on, an unrecognized breakpoint location will cause gdb to create a\n\
7990 pending breakpoint. If off, an unrecognized breakpoint location results in\n\
7991 an error. If auto, an unrecognized breakpoint location results in a\n\
7992 user-query to see if a pending breakpoint should be created."),
7994 show_pending_break_support
,
7995 &breakpoint_set_cmdlist
,
7996 &breakpoint_show_cmdlist
);
7998 pending_break_support
= AUTO_BOOLEAN_AUTO
;