1 /* Everything about breakpoints, for GDB.
3 Copyright (C) 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994,
4 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006,
6 Free Software Foundation, Inc.
8 This file is part of GDB.
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 2 of the License, or
13 (at your option) any later version.
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program; if not, write to the Free Software
22 Foundation, Inc., 51 Franklin Street, Fifth Floor,
23 Boston, MA 02110-1301, USA. */
29 #include "breakpoint.h"
31 #include "expression.h"
37 #include "gdbthread.h"
40 #include "gdb_string.h"
47 #include "completer.h"
50 #include "cli/cli-script.h"
51 #include "gdb_assert.h"
56 #include "exceptions.h"
60 #include "gdb-events.h"
61 #include "mi/mi-common.h"
63 /* Prototypes for local functions. */
65 static void until_break_command_continuation (struct continuation_arg
*arg
);
67 static void catch_command_1 (char *, int, int);
69 static void enable_delete_command (char *, int);
71 static void enable_delete_breakpoint (struct breakpoint
*);
73 static void enable_once_command (char *, int);
75 static void enable_once_breakpoint (struct breakpoint
*);
77 static void disable_command (char *, int);
79 static void enable_command (char *, int);
81 static void map_breakpoint_numbers (char *, void (*)(struct breakpoint
*));
83 static void ignore_command (char *, int);
85 static int breakpoint_re_set_one (void *);
87 static void clear_command (char *, int);
89 static void catch_command (char *, int);
91 static void watch_command (char *, int);
93 static int can_use_hardware_watchpoint (struct value
*);
95 static int break_command_1 (char *, int, int, struct breakpoint
*);
97 static void mention (struct breakpoint
*);
99 struct breakpoint
*set_raw_breakpoint (struct symtab_and_line
, enum bptype
);
101 static void check_duplicates (struct breakpoint
*);
103 static void breakpoint_adjustment_warning (CORE_ADDR
, CORE_ADDR
, int, int);
105 static CORE_ADDR
adjust_breakpoint_address (CORE_ADDR bpaddr
,
108 static void describe_other_breakpoints (CORE_ADDR
, asection
*, int);
110 static void breakpoints_info (char *, int);
112 static void breakpoint_1 (int, int);
114 static bpstat
bpstat_alloc (struct breakpoint
*, bpstat
);
116 static int breakpoint_cond_eval (void *);
118 static void cleanup_executing_breakpoints (void *);
120 static void commands_command (char *, int);
122 static void condition_command (char *, int);
124 static int get_number_trailer (char **, int);
126 void set_breakpoint_count (int);
135 static int remove_breakpoint (struct bp_location
*, insertion_state_t
);
137 static enum print_stop_action
print_it_typical (bpstat
);
139 static enum print_stop_action
print_bp_stop_message (bpstat bs
);
143 enum exception_event_kind kind
;
146 args_for_catchpoint_enable
;
148 static int watchpoint_check (void *);
150 static int cover_target_enable_exception_callback (void *);
152 static void maintenance_info_breakpoints (char *, int);
154 static void create_longjmp_breakpoint (char *);
156 static void create_overlay_event_breakpoint (char *);
158 static int hw_breakpoint_used_count (void);
160 static int hw_watchpoint_used_count (enum bptype
, int *);
162 static void hbreak_command (char *, int);
164 static void thbreak_command (char *, int);
166 static void watch_command_1 (char *, int, int);
168 static void rwatch_command (char *, int);
170 static void awatch_command (char *, int);
172 static void do_enable_breakpoint (struct breakpoint
*, enum bpdisp
);
174 static void solib_load_unload_1 (char *hookname
,
177 char *cond_string
, enum bptype bp_kind
);
179 static void create_fork_vfork_event_catchpoint (int tempflag
,
181 enum bptype bp_kind
);
183 static void stop_command (char *arg
, int from_tty
);
185 static void stopin_command (char *arg
, int from_tty
);
187 static void stopat_command (char *arg
, int from_tty
);
189 static char *ep_find_event_name_end (char *arg
);
191 static char *ep_parse_optional_if_clause (char **arg
);
193 static char *ep_parse_optional_filename (char **arg
);
195 static void create_exception_catchpoint (int tempflag
, char *cond_string
,
196 enum exception_event_kind ex_event
,
197 struct symtab_and_line
*sal
);
199 static void catch_exception_command_1 (enum exception_event_kind ex_event
,
200 char *arg
, int tempflag
, int from_tty
);
202 static void tcatch_command (char *arg
, int from_tty
);
204 static void ep_skip_leading_whitespace (char **s
);
206 /* Prototypes for exported functions. */
208 /* If FALSE, gdb will not use hardware support for watchpoints, even
209 if such is available. */
210 static int can_use_hw_watchpoints
;
213 show_can_use_hw_watchpoints (struct ui_file
*file
, int from_tty
,
214 struct cmd_list_element
*c
,
217 fprintf_filtered (file
, _("\
218 Debugger's willingness to use watchpoint hardware is %s.\n"),
222 /* If AUTO_BOOLEAN_FALSE, gdb will not attempt to create pending breakpoints.
223 If AUTO_BOOLEAN_TRUE, gdb will automatically create pending breakpoints
224 for unrecognized breakpoint locations.
225 If AUTO_BOOLEAN_AUTO, gdb will query when breakpoints are unrecognized. */
226 static enum auto_boolean pending_break_support
;
228 show_pending_break_support (struct ui_file
*file
, int from_tty
,
229 struct cmd_list_element
*c
,
232 fprintf_filtered (file
, _("\
233 Debugger's behavior regarding pending breakpoints is %s.\n"),
237 /* If 1, gdb will automatically use hardware breakpoints for breakpoints
238 set with "break" but falling in read-only memory.
239 If 0, gdb will warn about such breakpoints, but won't automatically
240 use hardware breakpoints. */
241 static int automatic_hardware_breakpoints
;
243 show_automatic_hardware_breakpoints (struct ui_file
*file
, int from_tty
,
244 struct cmd_list_element
*c
,
247 fprintf_filtered (file
, _("\
248 Automatic usage of hardware breakpoints is %s.\n"),
253 void _initialize_breakpoint (void);
255 extern int addressprint
; /* Print machine addresses? */
257 /* Are we executing breakpoint commands? */
258 static int executing_breakpoint_commands
;
260 /* Are overlay event breakpoints enabled? */
261 static int overlay_events_enabled
;
263 /* Walk the following statement or block through all breakpoints.
264 ALL_BREAKPOINTS_SAFE does so even if the statment deletes the current
267 #define ALL_BREAKPOINTS(B) for (B = breakpoint_chain; B; B = B->next)
269 #define ALL_BREAKPOINTS_SAFE(B,TMP) \
270 for (B = breakpoint_chain; \
271 B ? (TMP=B->next, 1): 0; \
274 /* Similar iterators for the low-level breakpoints. */
276 #define ALL_BP_LOCATIONS(B) for (B = bp_location_chain; B; B = B->next)
278 #define ALL_BP_LOCATIONS_SAFE(B,TMP) \
279 for (B = bp_location_chain; \
280 B ? (TMP=B->next, 1): 0; \
283 /* True if breakpoint hit counts should be displayed in breakpoint info. */
285 int show_breakpoint_hit_counts
= 1;
287 /* Chains of all breakpoints defined. */
289 struct breakpoint
*breakpoint_chain
;
291 struct bp_location
*bp_location_chain
;
293 /* Number of last breakpoint made. */
295 int breakpoint_count
;
297 /* Pointer to current exception event record */
298 static struct exception_event_record
*current_exception_event
;
300 /* Indicator of whether exception catchpoints should be nuked between
301 runs of a program. */
302 int deprecated_exception_catchpoints_are_fragile
= 0;
304 /* Indicator of when exception catchpoints set-up should be
305 reinitialized -- e.g. when program is re-run. */
306 int deprecated_exception_support_initialized
= 0;
308 /* This function returns a pointer to the string representation of the
309 pathname of the dynamically-linked library that has just been
312 This function must be used only when SOLIB_HAVE_LOAD_EVENT is TRUE,
313 or undefined results are guaranteed.
315 This string's contents are only valid immediately after the
316 inferior has stopped in the dynamic linker hook, and becomes
317 invalid as soon as the inferior is continued. Clients should make
318 a copy of this string if they wish to continue the inferior and
319 then access the string. */
321 #ifndef SOLIB_LOADED_LIBRARY_PATHNAME
322 #define SOLIB_LOADED_LIBRARY_PATHNAME(pid) ""
325 /* This function returns a pointer to the string representation of the
326 pathname of the dynamically-linked library that has just been
329 This function must be used only when SOLIB_HAVE_UNLOAD_EVENT is
330 TRUE, or undefined results are guaranteed.
332 This string's contents are only valid immediately after the
333 inferior has stopped in the dynamic linker hook, and becomes
334 invalid as soon as the inferior is continued. Clients should make
335 a copy of this string if they wish to continue the inferior and
336 then access the string. */
338 #ifndef SOLIB_UNLOADED_LIBRARY_PATHNAME
339 #define SOLIB_UNLOADED_LIBRARY_PATHNAME(pid) ""
342 /* This function is called by the "catch load" command. It allows the
343 debugger to be notified by the dynamic linker when a specified
344 library file (or any library file, if filename is NULL) is loaded. */
346 #ifndef SOLIB_CREATE_CATCH_LOAD_HOOK
347 #define SOLIB_CREATE_CATCH_LOAD_HOOK(pid,tempflag,filename,cond_string) \
348 error (_("catch of library loads not yet implemented on this platform"))
351 /* This function is called by the "catch unload" command. It allows
352 the debugger to be notified by the dynamic linker when a specified
353 library file (or any library file, if filename is NULL) is
356 #ifndef SOLIB_CREATE_CATCH_UNLOAD_HOOK
357 #define SOLIB_CREATE_CATCH_UNLOAD_HOOK(pid, tempflag, filename, cond_string) \
358 error (_("catch of library unloads not yet implemented on this platform"))
361 /* Return whether a breakpoint is an active enabled breakpoint. */
363 breakpoint_enabled (struct breakpoint
*b
)
365 return (b
->enable_state
== bp_enabled
&& !b
->pending
);
368 /* Set breakpoint count to NUM. */
371 set_breakpoint_count (int num
)
373 breakpoint_count
= num
;
374 set_internalvar (lookup_internalvar ("bpnum"),
375 value_from_longest (builtin_type_int
, (LONGEST
) num
));
378 /* Used in run_command to zero the hit count when a new run starts. */
381 clear_breakpoint_hit_counts (void)
383 struct breakpoint
*b
;
389 /* Default address, symtab and line to put a breakpoint at
390 for "break" command with no arg.
391 if default_breakpoint_valid is zero, the other three are
392 not valid, and "break" with no arg is an error.
394 This set by print_stack_frame, which calls set_default_breakpoint. */
396 int default_breakpoint_valid
;
397 CORE_ADDR default_breakpoint_address
;
398 struct symtab
*default_breakpoint_symtab
;
399 int default_breakpoint_line
;
401 /* *PP is a string denoting a breakpoint. Get the number of the breakpoint.
402 Advance *PP after the string and any trailing whitespace.
404 Currently the string can either be a number or "$" followed by the name
405 of a convenience variable. Making it an expression wouldn't work well
406 for map_breakpoint_numbers (e.g. "4 + 5 + 6").
408 TRAILER is a character which can be found after the number; most
409 commonly this is `-'. If you don't want a trailer, use \0. */
411 get_number_trailer (char **pp
, int trailer
)
413 int retval
= 0; /* default */
417 /* Empty line means refer to the last breakpoint. */
418 return breakpoint_count
;
421 /* Make a copy of the name, so we can null-terminate it
422 to pass to lookup_internalvar(). */
427 while (isalnum (*p
) || *p
== '_')
429 varname
= (char *) alloca (p
- start
+ 1);
430 strncpy (varname
, start
, p
- start
);
431 varname
[p
- start
] = '\0';
432 val
= value_of_internalvar (lookup_internalvar (varname
));
433 if (TYPE_CODE (value_type (val
)) == TYPE_CODE_INT
)
434 retval
= (int) value_as_long (val
);
437 printf_filtered (_("Convenience variable must have integer value.\n"));
445 while (*p
>= '0' && *p
<= '9')
448 /* There is no number here. (e.g. "cond a == b"). */
450 /* Skip non-numeric token */
451 while (*p
&& !isspace((int) *p
))
453 /* Return zero, which caller must interpret as error. */
459 if (!(isspace (*p
) || *p
== '\0' || *p
== trailer
))
461 /* Trailing junk: return 0 and let caller print error msg. */
462 while (!(isspace (*p
) || *p
== '\0' || *p
== trailer
))
473 /* Like get_number_trailer, but don't allow a trailer. */
475 get_number (char **pp
)
477 return get_number_trailer (pp
, '\0');
480 /* Parse a number or a range.
481 * A number will be of the form handled by get_number.
482 * A range will be of the form <number1> - <number2>, and
483 * will represent all the integers between number1 and number2,
486 * While processing a range, this fuction is called iteratively;
487 * At each call it will return the next value in the range.
489 * At the beginning of parsing a range, the char pointer PP will
490 * be advanced past <number1> and left pointing at the '-' token.
491 * Subsequent calls will not advance the pointer until the range
492 * is completed. The call that completes the range will advance
493 * pointer PP past <number2>.
497 get_number_or_range (char **pp
)
499 static int last_retval
, end_value
;
500 static char *end_ptr
;
501 static int in_range
= 0;
505 /* Default case: pp is pointing either to a solo number,
506 or to the first number of a range. */
507 last_retval
= get_number_trailer (pp
, '-');
512 /* This is the start of a range (<number1> - <number2>).
513 Skip the '-', parse and remember the second number,
514 and also remember the end of the final token. */
518 while (isspace ((int) *end_ptr
))
519 end_ptr
++; /* skip white space */
520 end_value
= get_number (temp
);
521 if (end_value
< last_retval
)
523 error (_("inverted range"));
525 else if (end_value
== last_retval
)
527 /* degenerate range (number1 == number2). Advance the
528 token pointer so that the range will be treated as a
537 error (_("negative value"));
540 /* pp points to the '-' that betokens a range. All
541 number-parsing has already been done. Return the next
542 integer value (one greater than the saved previous value).
543 Do not advance the token pointer 'pp' until the end of range
546 if (++last_retval
== end_value
)
548 /* End of range reached; advance token pointer. */
558 /* condition N EXP -- set break condition of breakpoint N to EXP. */
561 condition_command (char *arg
, int from_tty
)
563 struct breakpoint
*b
;
568 error_no_arg (_("breakpoint number"));
571 bnum
= get_number (&p
);
573 error (_("Bad breakpoint argument: '%s'"), arg
);
576 if (b
->number
== bnum
)
583 if (b
->cond_string
!= NULL
)
584 xfree (b
->cond_string
);
589 b
->cond_string
= NULL
;
591 printf_filtered (_("Breakpoint %d now unconditional.\n"), bnum
);
596 /* I don't know if it matters whether this is the string the user
597 typed in or the decompiled expression. */
598 b
->cond_string
= savestring (arg
, strlen (arg
));
601 b
->cond
= parse_exp_1 (&arg
, block_for_pc (b
->loc
->address
), 0);
603 error (_("Junk at end of expression"));
606 breakpoints_changed ();
607 breakpoint_modify_event (b
->number
);
611 error (_("No breakpoint number %d."), bnum
);
615 commands_command (char *arg
, int from_tty
)
617 struct breakpoint
*b
;
620 struct command_line
*l
;
622 /* If we allowed this, we would have problems with when to
623 free the storage, if we change the commands currently
626 if (executing_breakpoint_commands
)
627 error (_("Can't use the \"commands\" command among a breakpoint's commands."));
630 bnum
= get_number (&p
);
633 error (_("Unexpected extra arguments following breakpoint number."));
636 if (b
->number
== bnum
)
638 char *tmpbuf
= xstrprintf ("Type commands for when breakpoint %d is hit, one per line.",
640 struct cleanup
*cleanups
= make_cleanup (xfree
, tmpbuf
);
641 l
= read_command_lines (tmpbuf
, from_tty
);
642 do_cleanups (cleanups
);
643 free_command_lines (&b
->commands
);
645 breakpoints_changed ();
646 breakpoint_modify_event (b
->number
);
649 error (_("No breakpoint number %d."), bnum
);
652 /* Like target_read_memory() but if breakpoints are inserted, return
653 the shadow contents instead of the breakpoints themselves.
655 Read "memory data" from whatever target or inferior we have.
656 Returns zero if successful, errno value if not. EIO is used
657 for address out of bounds. If breakpoints are inserted, returns
658 shadow contents, not the breakpoints themselves. From breakpoint.c. */
661 read_memory_nobpt (CORE_ADDR memaddr
, gdb_byte
*myaddr
, unsigned len
)
664 struct bp_location
*b
;
665 CORE_ADDR bp_addr
= 0;
668 if (BREAKPOINT_FROM_PC (&bp_addr
, &bp_size
) == NULL
)
669 /* No breakpoints on this machine. */
670 return target_read_memory (memaddr
, myaddr
, len
);
674 if (b
->owner
->type
== bp_none
)
675 warning (_("reading through apparently deleted breakpoint #%d?"),
678 if (b
->loc_type
!= bp_loc_software_breakpoint
)
682 /* Addresses and length of the part of the breakpoint that
684 bp_addr
= b
->target_info
.placed_address
;
685 bp_size
= b
->target_info
.shadow_len
;
687 /* bp isn't valid, or doesn't shadow memory. */
689 if (bp_addr
+ bp_size
<= memaddr
)
690 /* The breakpoint is entirely before the chunk of memory we
693 if (bp_addr
>= memaddr
+ len
)
694 /* The breakpoint is entirely after the chunk of memory we are
697 /* Copy the breakpoint from the shadow contents, and recurse for
698 the things before and after. */
700 /* Offset within shadow_contents. */
703 if (bp_addr
< memaddr
)
705 /* Only copy the second part of the breakpoint. */
706 bp_size
-= memaddr
- bp_addr
;
707 bptoffset
= memaddr
- bp_addr
;
711 if (bp_addr
+ bp_size
> memaddr
+ len
)
713 /* Only copy the first part of the breakpoint. */
714 bp_size
-= (bp_addr
+ bp_size
) - (memaddr
+ len
);
717 memcpy (myaddr
+ bp_addr
- memaddr
,
718 b
->target_info
.shadow_contents
+ bptoffset
, bp_size
);
720 if (bp_addr
> memaddr
)
722 /* Copy the section of memory before the breakpoint. */
723 status
= read_memory_nobpt (memaddr
, myaddr
, bp_addr
- memaddr
);
728 if (bp_addr
+ bp_size
< memaddr
+ len
)
730 /* Copy the section of memory after the breakpoint. */
731 status
= read_memory_nobpt (bp_addr
+ bp_size
,
732 myaddr
+ bp_addr
+ bp_size
- memaddr
,
733 memaddr
+ len
- (bp_addr
+ bp_size
));
740 /* Nothing overlaps. Just call read_memory_noerr. */
741 return target_read_memory (memaddr
, myaddr
, len
);
745 /* A wrapper function for inserting catchpoints. */
747 insert_catchpoint (struct ui_out
*uo
, void *args
)
749 struct breakpoint
*b
= (struct breakpoint
*) args
;
755 target_insert_fork_catchpoint (PIDGET (inferior_ptid
));
758 target_insert_vfork_catchpoint (PIDGET (inferior_ptid
));
761 target_insert_exec_catchpoint (PIDGET (inferior_ptid
));
764 internal_error (__FILE__
, __LINE__
, _("unknown breakpoint type"));
769 /* Helper routine: free the value chain for a breakpoint (watchpoint). */
772 free_valchain (struct bp_location
*b
)
777 /* Free the saved value chain. We will construct a new one
778 the next time the watchpoint is inserted. */
779 for (v
= b
->owner
->val_chain
; v
; v
= n
)
784 b
->owner
->val_chain
= NULL
;
787 /* Insert a low-level "breakpoint" of some type. BPT is the breakpoint.
788 Any error messages are printed to TMP_ERROR_STREAM; and DISABLED_BREAKS,
789 PROCESS_WARNING, and HW_BREAKPOINT_ERROR are used to report problems.
791 NOTE drow/2003-09-09: This routine could be broken down to an object-style
792 method for each breakpoint or catchpoint type. */
794 insert_bp_location (struct bp_location
*bpt
,
795 struct ui_file
*tmp_error_stream
,
796 int *disabled_breaks
, int *process_warning
,
797 int *hw_breakpoint_error
)
801 /* Permanent breakpoints cannot be inserted or removed. Disabled
802 breakpoints should not be inserted. */
803 if (!breakpoint_enabled (bpt
->owner
))
806 if (bpt
->inserted
|| bpt
->duplicate
)
809 /* Initialize the target-specific information. */
810 memset (&bpt
->target_info
, 0, sizeof (bpt
->target_info
));
811 bpt
->target_info
.placed_address
= bpt
->address
;
813 if (bpt
->loc_type
== bp_loc_software_breakpoint
814 || bpt
->loc_type
== bp_loc_hardware_breakpoint
)
816 if (bpt
->owner
->type
!= bp_hardware_breakpoint
)
818 /* If the explicitly specified breakpoint type
819 is not hardware breakpoint, check the memory map to see
820 if the breakpoint address is in read only memory or not.
821 Two important cases are:
822 - location type is not hardware breakpoint, memory
823 is readonly. We change the type of the location to
825 - location type is hardware breakpoint, memory is read-write.
826 This means we've previously made the location hardware one, but
827 then the memory map changed, so we undo.
829 When breakpoints are removed, remove_breakpoints will
830 use location types we've just set here, the only possible
831 problem is that memory map has changed during running program,
832 but it's not going to work anyway with current gdb. */
833 struct mem_region
*mr
834 = lookup_mem_region (bpt
->target_info
.placed_address
);
838 if (automatic_hardware_breakpoints
)
841 enum bp_loc_type new_type
;
843 if (mr
->attrib
.mode
!= MEM_RW
)
844 new_type
= bp_loc_hardware_breakpoint
;
846 new_type
= bp_loc_software_breakpoint
;
848 if (new_type
!= bpt
->loc_type
)
851 bpt
->loc_type
= new_type
;
854 fprintf_filtered (gdb_stdout
, _("\
855 Note: automatically using hardware breakpoints for read-only addresses.\n"));
860 else if (bpt
->loc_type
== bp_loc_software_breakpoint
861 && mr
->attrib
.mode
!= MEM_RW
)
862 warning (_("cannot set software breakpoint at readonly address %s"),
863 paddr (bpt
->address
));
867 /* First check to see if we have to handle an overlay. */
868 if (overlay_debugging
== ovly_off
869 || bpt
->section
== NULL
870 || !(section_is_overlay (bpt
->section
)))
872 /* No overlay handling: just set the breakpoint. */
874 if (bpt
->loc_type
== bp_loc_hardware_breakpoint
)
875 val
= target_insert_hw_breakpoint (&bpt
->target_info
);
877 val
= target_insert_breakpoint (&bpt
->target_info
);
881 /* This breakpoint is in an overlay section.
882 Shall we set a breakpoint at the LMA? */
883 if (!overlay_events_enabled
)
885 /* Yes -- overlay event support is not active,
886 so we must try to set a breakpoint at the LMA.
887 This will not work for a hardware breakpoint. */
888 if (bpt
->loc_type
== bp_loc_hardware_breakpoint
)
889 warning (_("hardware breakpoint %d not supported in overlay!"),
893 CORE_ADDR addr
= overlay_unmapped_address (bpt
->address
,
895 /* Set a software (trap) breakpoint at the LMA. */
896 bpt
->overlay_target_info
= bpt
->target_info
;
897 bpt
->overlay_target_info
.placed_address
= addr
;
898 val
= target_insert_breakpoint (&bpt
->overlay_target_info
);
900 fprintf_unfiltered (tmp_error_stream
,
901 "Overlay breakpoint %d failed: in ROM?",
905 /* Shall we set a breakpoint at the VMA? */
906 if (section_is_mapped (bpt
->section
))
908 /* Yes. This overlay section is mapped into memory. */
909 if (bpt
->loc_type
== bp_loc_hardware_breakpoint
)
910 val
= target_insert_hw_breakpoint (&bpt
->target_info
);
912 val
= target_insert_breakpoint (&bpt
->target_info
);
916 /* No. This breakpoint will not be inserted.
917 No error, but do not mark the bp as 'inserted'. */
924 /* Can't set the breakpoint. */
926 #if defined (DISABLE_UNSETTABLE_BREAK)
927 DISABLE_UNSETTABLE_BREAK (bpt
->address
)
929 solib_address (bpt
->address
)
933 /* See also: disable_breakpoints_in_shlibs. */
935 bpt
->owner
->enable_state
= bp_shlib_disabled
;
936 if (!*disabled_breaks
)
938 fprintf_unfiltered (tmp_error_stream
,
939 "Cannot insert breakpoint %d.\n",
941 fprintf_unfiltered (tmp_error_stream
,
942 "Temporarily disabling shared library breakpoints:\n");
944 *disabled_breaks
= 1;
945 fprintf_unfiltered (tmp_error_stream
,
946 "breakpoint #%d\n", bpt
->owner
->number
);
950 #ifdef ONE_PROCESS_WRITETEXT
951 *process_warning
= 1;
953 if (bpt
->loc_type
== bp_loc_hardware_breakpoint
)
955 *hw_breakpoint_error
= 1;
956 fprintf_unfiltered (tmp_error_stream
,
957 "Cannot insert hardware breakpoint %d.\n",
962 fprintf_unfiltered (tmp_error_stream
,
963 "Cannot insert breakpoint %d.\n",
965 fprintf_filtered (tmp_error_stream
,
966 "Error accessing memory address ");
967 deprecated_print_address_numeric (bpt
->address
, 1, tmp_error_stream
);
968 fprintf_filtered (tmp_error_stream
, ": %s.\n",
969 safe_strerror (val
));
980 else if (bpt
->loc_type
== bp_loc_hardware_watchpoint
981 /* NOTE drow/2003-09-08: This state only exists for removing
982 watchpoints. It's not clear that it's necessary... */
983 && bpt
->owner
->disposition
!= disp_del_at_next_stop
)
985 /* FIXME drow/2003-09-08: This code sets multiple hardware watchpoints
986 based on the expression. Ideally this should happen at a higher level,
987 and there should be one bp_location for each computed address we
988 must watch. As soon as a many-to-one mapping is available I'll
991 int within_current_scope
;
992 struct value
*mark
= value_mark ();
994 struct frame_id saved_frame_id
;
996 /* Save the current frame's ID so we can restore it after
997 evaluating the watchpoint expression on its own frame. */
998 /* FIXME drow/2003-09-09: It would be nice if evaluate_expression
999 took a frame parameter, so that we didn't have to change the
1001 saved_frame_id
= get_frame_id (deprecated_selected_frame
);
1003 /* Determine if the watchpoint is within scope. */
1004 if (bpt
->owner
->exp_valid_block
== NULL
)
1005 within_current_scope
= 1;
1008 struct frame_info
*fi
;
1009 fi
= frame_find_by_id (bpt
->owner
->watchpoint_frame
);
1010 within_current_scope
= (fi
!= NULL
);
1011 if (within_current_scope
)
1015 if (within_current_scope
)
1017 free_valchain (bpt
);
1019 /* Evaluate the expression and cut the chain of values
1020 produced off from the value chain.
1022 Make sure the value returned isn't lazy; we use
1023 laziness to determine what memory GDB actually needed
1024 in order to compute the value of the expression. */
1025 v
= evaluate_expression (bpt
->owner
->exp
);
1027 value_release_to_mark (mark
);
1029 bpt
->owner
->val_chain
= v
;
1032 /* Look at each value on the value chain. */
1033 for (; v
; v
= value_next (v
))
1035 /* If it's a memory location, and GDB actually needed
1036 its contents to evaluate the expression, then we
1038 if (VALUE_LVAL (v
) == lval_memory
1039 && ! value_lazy (v
))
1041 struct type
*vtype
= check_typedef (value_type (v
));
1043 /* We only watch structs and arrays if user asked
1044 for it explicitly, never if they just happen to
1045 appear in the middle of some value chain. */
1046 if (v
== bpt
->owner
->val_chain
1047 || (TYPE_CODE (vtype
) != TYPE_CODE_STRUCT
1048 && TYPE_CODE (vtype
) != TYPE_CODE_ARRAY
))
1053 addr
= VALUE_ADDRESS (v
) + value_offset (v
);
1054 len
= TYPE_LENGTH (value_type (v
));
1056 if (bpt
->owner
->type
== bp_read_watchpoint
)
1058 else if (bpt
->owner
->type
== bp_access_watchpoint
)
1061 val
= target_insert_watchpoint (addr
, len
, type
);
1064 /* Don't exit the loop, try to insert
1065 every value on the value chain. That's
1066 because we will be removing all the
1067 watches below, and removing a
1068 watchpoint we didn't insert could have
1076 /* Failure to insert a watchpoint on any memory value in the
1077 value chain brings us here. */
1080 remove_breakpoint (bpt
, mark_uninserted
);
1081 *hw_breakpoint_error
= 1;
1082 fprintf_unfiltered (tmp_error_stream
,
1083 "Could not insert hardware watchpoint %d.\n",
1084 bpt
->owner
->number
);
1090 printf_filtered (_("\
1091 Hardware watchpoint %d deleted because the program has left the block \n\
1092 in which its expression is valid.\n"),
1093 bpt
->owner
->number
);
1094 if (bpt
->owner
->related_breakpoint
)
1095 bpt
->owner
->related_breakpoint
->disposition
= disp_del_at_next_stop
;
1096 bpt
->owner
->disposition
= disp_del_at_next_stop
;
1099 /* Restore the selected frame. */
1100 select_frame (frame_find_by_id (saved_frame_id
));
1105 else if (ep_is_exception_catchpoint (bpt
->owner
))
1107 /* FIXME drow/2003-09-09: This code sets both a catchpoint and a
1108 breakpoint. Once again, it would be better if this was represented
1109 as two bp_locations. */
1111 /* If we get here, we must have a callback mechanism for exception
1112 events -- with g++ style embedded label support, we insert
1113 ordinary breakpoints and not catchpoints. */
1114 val
= target_insert_breakpoint (&bpt
->target_info
);
1117 /* Couldn't set breakpoint for some reason */
1118 fprintf_unfiltered (tmp_error_stream
,
1119 "Cannot insert catchpoint %d; disabling it.\n",
1120 bpt
->owner
->number
);
1121 fprintf_filtered (tmp_error_stream
,
1122 "Error accessing memory address ");
1123 deprecated_print_address_numeric (bpt
->address
, 1, tmp_error_stream
);
1124 fprintf_filtered (tmp_error_stream
, ": %s.\n",
1125 safe_strerror (val
));
1126 bpt
->owner
->enable_state
= bp_disabled
;
1130 /* Bp set, now make sure callbacks are enabled */
1131 /* Format possible error msg */
1132 char *message
= xstrprintf ("Error inserting catchpoint %d:\n",
1133 bpt
->owner
->number
);
1134 struct cleanup
*cleanups
= make_cleanup (xfree
, message
);
1136 args_for_catchpoint_enable args
;
1137 args
.kind
= bpt
->owner
->type
== bp_catch_catch
?
1138 EX_EVENT_CATCH
: EX_EVENT_THROW
;
1140 val
= catch_errors (cover_target_enable_exception_callback
,
1141 &args
, message
, RETURN_MASK_ALL
);
1142 do_cleanups (cleanups
);
1143 if (val
!= 0 && val
!= -1)
1146 /* Check if something went wrong; val == 0 can be ignored */
1149 /* something went wrong */
1150 fprintf_unfiltered (tmp_error_stream
,
1151 "Cannot insert catchpoint %d; disabling it.\n",
1152 bpt
->owner
->number
);
1153 bpt
->owner
->enable_state
= bp_disabled
;
1160 else if (bpt
->owner
->type
== bp_catch_fork
1161 || bpt
->owner
->type
== bp_catch_vfork
1162 || bpt
->owner
->type
== bp_catch_exec
)
1164 struct gdb_exception e
= catch_exception (uiout
, insert_catchpoint
,
1165 bpt
->owner
, RETURN_MASK_ERROR
);
1166 exception_fprintf (gdb_stderr
, e
, "warning: inserting catchpoint %d: ",
1167 bpt
->owner
->number
);
1169 bpt
->owner
->enable_state
= bp_disabled
;
1173 /* We've already printed an error message if there was a problem
1174 inserting this catchpoint, and we've disabled the catchpoint,
1175 so just return success. */
1182 /* insert_breakpoints is used when starting or continuing the program.
1183 remove_breakpoints is used when the program stops.
1184 Both return zero if successful,
1185 or an `errno' value if could not write the inferior. */
1188 insert_breakpoints (void)
1190 struct bp_location
*b
, *temp
;
1191 int return_val
= 0; /* return success code. */
1193 int disabled_breaks
= 0;
1194 int hw_breakpoint_error
= 0;
1195 int process_warning
= 0;
1197 struct ui_file
*tmp_error_stream
= mem_fileopen ();
1198 make_cleanup_ui_file_delete (tmp_error_stream
);
1200 /* Explicitly mark the warning -- this will only be printed if
1201 there was an error. */
1202 fprintf_unfiltered (tmp_error_stream
, "Warning:\n");
1204 ALL_BP_LOCATIONS_SAFE (b
, temp
)
1206 /* Permanent breakpoints cannot be inserted or removed. Disabled
1207 breakpoints should not be inserted. */
1208 if (!breakpoint_enabled (b
->owner
))
1211 /* There is no point inserting thread-specific breakpoints if the
1212 thread no longer exists. */
1213 if (b
->owner
->thread
!= -1
1214 && !valid_thread_id (b
->owner
->thread
))
1217 /* FIXME drow/2003-10-07: This code should be pushed elsewhere when
1218 hardware watchpoints are split into multiple loc breakpoints. */
1219 if ((b
->loc_type
== bp_loc_hardware_watchpoint
1220 || b
->owner
->type
== bp_watchpoint
) && !b
->owner
->val
)
1223 val
= evaluate_expression (b
->owner
->exp
);
1224 release_value (val
);
1225 if (value_lazy (val
))
1226 value_fetch_lazy (val
);
1227 b
->owner
->val
= val
;
1230 val
= insert_bp_location (b
, tmp_error_stream
,
1231 &disabled_breaks
, &process_warning
,
1232 &hw_breakpoint_error
);
1239 /* If a hardware breakpoint or watchpoint was inserted, add a
1240 message about possibly exhausted resources. */
1241 if (hw_breakpoint_error
)
1243 fprintf_unfiltered (tmp_error_stream
,
1244 "Could not insert hardware breakpoints:\n\
1245 You may have requested too many hardware breakpoints/watchpoints.\n");
1247 #ifdef ONE_PROCESS_WRITETEXT
1248 if (process_warning
)
1249 fprintf_unfiltered (tmp_error_stream
,
1250 "The same program may be running in another process.");
1252 target_terminal_ours_for_output ();
1253 error_stream (tmp_error_stream
);
1259 remove_breakpoints (void)
1261 struct bp_location
*b
;
1264 ALL_BP_LOCATIONS (b
)
1268 val
= remove_breakpoint (b
, mark_uninserted
);
1277 remove_hw_watchpoints (void)
1279 struct bp_location
*b
;
1282 ALL_BP_LOCATIONS (b
)
1284 if (b
->inserted
&& b
->loc_type
== bp_loc_hardware_watchpoint
)
1286 val
= remove_breakpoint (b
, mark_uninserted
);
1295 reattach_breakpoints (int pid
)
1297 struct bp_location
*b
;
1299 struct cleanup
*old_chain
= save_inferior_ptid ();
1301 /* Set inferior_ptid; remove_breakpoint uses this global. */
1302 inferior_ptid
= pid_to_ptid (pid
);
1303 ALL_BP_LOCATIONS (b
)
1307 remove_breakpoint (b
, mark_inserted
);
1308 /* Note: since we insert a breakpoint right after removing,
1309 any decisions about automatically using hardware breakpoints
1310 made in insert_bp_location are preserved. */
1311 if (b
->loc_type
== bp_loc_hardware_breakpoint
)
1312 val
= target_insert_hw_breakpoint (&b
->target_info
);
1314 val
= target_insert_breakpoint (&b
->target_info
);
1315 /* FIXME drow/2003-10-07: This doesn't handle any other kinds of
1316 breakpoints. It's wrong for watchpoints, for example. */
1319 do_cleanups (old_chain
);
1324 do_cleanups (old_chain
);
1329 update_breakpoints_after_exec (void)
1331 struct breakpoint
*b
;
1332 struct breakpoint
*temp
;
1334 /* Doing this first prevents the badness of having delete_breakpoint()
1335 write a breakpoint's current "shadow contents" to lift the bp. That
1336 shadow is NOT valid after an exec()! */
1337 mark_breakpoints_out ();
1339 ALL_BREAKPOINTS_SAFE (b
, temp
)
1341 /* Solib breakpoints must be explicitly reset after an exec(). */
1342 if (b
->type
== bp_shlib_event
)
1344 delete_breakpoint (b
);
1348 /* Thread event breakpoints must be set anew after an exec(),
1349 as must overlay event breakpoints. */
1350 if (b
->type
== bp_thread_event
|| b
->type
== bp_overlay_event
)
1352 delete_breakpoint (b
);
1356 /* Step-resume breakpoints are meaningless after an exec(). */
1357 if (b
->type
== bp_step_resume
)
1359 delete_breakpoint (b
);
1363 /* Ditto the sigtramp handler breakpoints. */
1364 if (b
->type
== bp_through_sigtramp
)
1366 delete_breakpoint (b
);
1370 /* Ditto the exception-handling catchpoints. */
1371 if ((b
->type
== bp_catch_catch
) || (b
->type
== bp_catch_throw
))
1373 delete_breakpoint (b
);
1377 /* Don't delete an exec catchpoint, because else the inferior
1378 won't stop when it ought!
1380 Similarly, we probably ought to keep vfork catchpoints, 'cause
1381 on this target, we may not be able to stop when the vfork is
1382 seen, but only when the subsequent exec is seen. (And because
1383 deleting fork catchpoints here but not vfork catchpoints will
1384 seem mysterious to users, keep those too.)
1386 ??rehrauer: Let's hope that merely clearing out this catchpoint's
1387 target address field, if any, is sufficient to have it be reset
1388 automagically. Certainly on HP-UX that's true.
1390 Jim Blandy <jimb@redhat.com>: Actually, zero is a perfectly
1391 valid code address on some platforms (like the mn10300
1392 simulators). We shouldn't assign any special interpretation to
1393 a breakpoint with a zero address. And in fact, GDB doesn't ---
1394 I can't see what that comment above is talking about. As far
1395 as I can tell, setting the address of a
1396 bp_catch_exec/bp_catch_vfork/bp_catch_fork breakpoint to zero
1397 is meaningless, since those are implemented with HP-UX kernel
1398 hackery, not by storing breakpoint instructions somewhere. */
1399 if ((b
->type
== bp_catch_exec
) ||
1400 (b
->type
== bp_catch_vfork
) ||
1401 (b
->type
== bp_catch_fork
))
1403 b
->loc
->address
= (CORE_ADDR
) 0;
1407 /* bp_finish is a special case. The only way we ought to be able
1408 to see one of these when an exec() has happened, is if the user
1409 caught a vfork, and then said "finish". Ordinarily a finish just
1410 carries them to the call-site of the current callee, by setting
1411 a temporary bp there and resuming. But in this case, the finish
1412 will carry them entirely through the vfork & exec.
1414 We don't want to allow a bp_finish to remain inserted now. But
1415 we can't safely delete it, 'cause finish_command has a handle to
1416 the bp on a bpstat, and will later want to delete it. There's a
1417 chance (and I've seen it happen) that if we delete the bp_finish
1418 here, that its storage will get reused by the time finish_command
1419 gets 'round to deleting the "use to be a bp_finish" breakpoint.
1420 We really must allow finish_command to delete a bp_finish.
1422 In the absense of a general solution for the "how do we know
1423 it's safe to delete something others may have handles to?"
1424 problem, what we'll do here is just uninsert the bp_finish, and
1425 let finish_command delete it.
1427 (We know the bp_finish is "doomed" in the sense that it's
1428 momentary, and will be deleted as soon as finish_command sees
1429 the inferior stopped. So it doesn't matter that the bp's
1430 address is probably bogus in the new a.out, unlike e.g., the
1431 solib breakpoints.) */
1433 if (b
->type
== bp_finish
)
1438 /* Without a symbolic address, we have little hope of the
1439 pre-exec() address meaning the same thing in the post-exec()
1441 if (b
->addr_string
== NULL
)
1443 delete_breakpoint (b
);
1447 /* If this breakpoint has survived the above battery of checks, then
1448 it must have a symbolic address. Be sure that it gets reevaluated
1449 to a target address, rather than reusing the old evaluation.
1451 Jim Blandy <jimb@redhat.com>: As explained above in the comment
1452 for bp_catch_exec and friends, I'm pretty sure this is entirely
1453 unnecessary. A call to breakpoint_re_set_one always recomputes
1454 the breakpoint's address from scratch, or deletes it if it can't.
1455 So I think this assignment could be deleted without effect. */
1456 b
->loc
->address
= (CORE_ADDR
) 0;
1458 /* FIXME what about longjmp breakpoints? Re-create them here? */
1459 create_overlay_event_breakpoint ("_ovly_debug_event");
1463 detach_breakpoints (int pid
)
1465 struct bp_location
*b
;
1467 struct cleanup
*old_chain
= save_inferior_ptid ();
1469 if (pid
== PIDGET (inferior_ptid
))
1470 error (_("Cannot detach breakpoints of inferior_ptid"));
1472 /* Set inferior_ptid; remove_breakpoint uses this global. */
1473 inferior_ptid
= pid_to_ptid (pid
);
1474 ALL_BP_LOCATIONS (b
)
1478 val
= remove_breakpoint (b
, mark_inserted
);
1481 do_cleanups (old_chain
);
1486 do_cleanups (old_chain
);
1491 remove_breakpoint (struct bp_location
*b
, insertion_state_t is
)
1495 if (b
->owner
->enable_state
== bp_permanent
)
1496 /* Permanent breakpoints cannot be inserted or removed. */
1499 if (b
->owner
->type
== bp_none
)
1500 warning (_("attempted to remove apparently deleted breakpoint #%d?"),
1503 if (b
->loc_type
== bp_loc_software_breakpoint
1504 || b
->loc_type
== bp_loc_hardware_breakpoint
)
1506 /* "Normal" instruction breakpoint: either the standard
1507 trap-instruction bp (bp_breakpoint), or a
1508 bp_hardware_breakpoint. */
1510 /* First check to see if we have to handle an overlay. */
1511 if (overlay_debugging
== ovly_off
1512 || b
->section
== NULL
1513 || !(section_is_overlay (b
->section
)))
1515 /* No overlay handling: just remove the breakpoint. */
1517 if (b
->loc_type
== bp_loc_hardware_breakpoint
)
1518 val
= target_remove_hw_breakpoint (&b
->target_info
);
1520 val
= target_remove_breakpoint (&b
->target_info
);
1524 /* This breakpoint is in an overlay section.
1525 Did we set a breakpoint at the LMA? */
1526 if (!overlay_events_enabled
)
1528 /* Yes -- overlay event support is not active, so we
1529 should have set a breakpoint at the LMA. Remove it.
1531 /* Ignore any failures: if the LMA is in ROM, we will
1532 have already warned when we failed to insert it. */
1533 if (b
->loc_type
== bp_loc_hardware_breakpoint
)
1534 target_remove_hw_breakpoint (&b
->overlay_target_info
);
1536 target_remove_breakpoint (&b
->overlay_target_info
);
1538 /* Did we set a breakpoint at the VMA?
1539 If so, we will have marked the breakpoint 'inserted'. */
1542 /* Yes -- remove it. Previously we did not bother to
1543 remove the breakpoint if the section had been
1544 unmapped, but let's not rely on that being safe. We
1545 don't know what the overlay manager might do. */
1546 if (b
->loc_type
== bp_loc_hardware_breakpoint
)
1547 val
= target_remove_hw_breakpoint (&b
->target_info
);
1549 val
= target_remove_breakpoint (&b
->target_info
);
1553 /* No -- not inserted, so no need to remove. No error. */
1559 b
->inserted
= (is
== mark_inserted
);
1561 else if (b
->loc_type
== bp_loc_hardware_watchpoint
1562 && breakpoint_enabled (b
->owner
)
1568 b
->inserted
= (is
== mark_inserted
);
1569 /* Walk down the saved value chain. */
1570 for (v
= b
->owner
->val_chain
; v
; v
= value_next (v
))
1572 /* For each memory reference remove the watchpoint
1574 if (VALUE_LVAL (v
) == lval_memory
1575 && ! value_lazy (v
))
1577 struct type
*vtype
= check_typedef (value_type (v
));
1579 if (v
== b
->owner
->val_chain
1580 || (TYPE_CODE (vtype
) != TYPE_CODE_STRUCT
1581 && TYPE_CODE (vtype
) != TYPE_CODE_ARRAY
))
1586 addr
= VALUE_ADDRESS (v
) + value_offset (v
);
1587 len
= TYPE_LENGTH (value_type (v
));
1589 if (b
->owner
->type
== bp_read_watchpoint
)
1591 else if (b
->owner
->type
== bp_access_watchpoint
)
1594 val
= target_remove_watchpoint (addr
, len
, type
);
1601 /* Failure to remove any of the hardware watchpoints comes here. */
1602 if ((is
== mark_uninserted
) && (b
->inserted
))
1603 warning (_("Could not remove hardware watchpoint %d."),
1606 else if ((b
->owner
->type
== bp_catch_fork
||
1607 b
->owner
->type
== bp_catch_vfork
||
1608 b
->owner
->type
== bp_catch_exec
)
1609 && breakpoint_enabled (b
->owner
)
1613 switch (b
->owner
->type
)
1616 val
= target_remove_fork_catchpoint (PIDGET (inferior_ptid
));
1618 case bp_catch_vfork
:
1619 val
= target_remove_vfork_catchpoint (PIDGET (inferior_ptid
));
1622 val
= target_remove_exec_catchpoint (PIDGET (inferior_ptid
));
1625 warning (_("Internal error, %s line %d."), __FILE__
, __LINE__
);
1630 b
->inserted
= (is
== mark_inserted
);
1632 else if ((b
->owner
->type
== bp_catch_catch
||
1633 b
->owner
->type
== bp_catch_throw
)
1634 && breakpoint_enabled (b
->owner
)
1637 val
= target_remove_breakpoint (&b
->target_info
);
1640 b
->inserted
= (is
== mark_inserted
);
1646 /* Clear the "inserted" flag in all breakpoints. */
1649 mark_breakpoints_out (void)
1651 struct bp_location
*bpt
;
1653 ALL_BP_LOCATIONS (bpt
)
1657 /* Clear the "inserted" flag in all breakpoints and delete any
1658 breakpoints which should go away between runs of the program.
1660 Plus other such housekeeping that has to be done for breakpoints
1663 Note: this function gets called at the end of a run (by
1664 generic_mourn_inferior) and when a run begins (by
1665 init_wait_for_inferior). */
1670 breakpoint_init_inferior (enum inf_context context
)
1672 struct breakpoint
*b
, *temp
;
1673 struct bp_location
*bpt
;
1674 static int warning_needed
= 0;
1676 ALL_BP_LOCATIONS (bpt
)
1679 ALL_BREAKPOINTS_SAFE (b
, temp
)
1684 case bp_watchpoint_scope
:
1686 /* If the call dummy breakpoint is at the entry point it will
1687 cause problems when the inferior is rerun, so we better
1690 Also get rid of scope breakpoints. */
1691 delete_breakpoint (b
);
1695 case bp_hardware_watchpoint
:
1696 case bp_read_watchpoint
:
1697 case bp_access_watchpoint
:
1699 /* Likewise for watchpoints on local expressions. */
1700 if (b
->exp_valid_block
!= NULL
)
1701 delete_breakpoint (b
);
1702 if (context
== inf_starting
)
1704 /* Reset val field to force reread of starting value
1705 in insert_breakpoints. */
1707 value_free (b
->val
);
1712 /* Likewise for exception catchpoints in dynamic-linked
1713 executables where required */
1714 if (ep_is_exception_catchpoint (b
)
1715 && deprecated_exception_catchpoints_are_fragile
)
1718 delete_breakpoint (b
);
1724 if (deprecated_exception_catchpoints_are_fragile
)
1725 deprecated_exception_support_initialized
= 0;
1727 /* Don't issue the warning unless it's really needed... */
1728 if (warning_needed
&& (context
!= inf_exited
))
1730 warning (_("Exception catchpoints from last run were deleted.\n"
1731 "You must reinsert them explicitly."));
1736 /* breakpoint_here_p (PC) returns non-zero if an enabled breakpoint
1737 exists at PC. It returns ordinary_breakpoint_here if it's an
1738 ordinary breakpoint, or permanent_breakpoint_here if it's a
1739 permanent breakpoint.
1740 - When continuing from a location with an ordinary breakpoint, we
1741 actually single step once before calling insert_breakpoints.
1742 - When continuing from a localion with a permanent breakpoint, we
1743 need to use the `SKIP_PERMANENT_BREAKPOINT' macro, provided by
1744 the target, to advance the PC past the breakpoint. */
1746 enum breakpoint_here
1747 breakpoint_here_p (CORE_ADDR pc
)
1749 struct bp_location
*bpt
;
1750 int any_breakpoint_here
= 0;
1752 ALL_BP_LOCATIONS (bpt
)
1754 if (bpt
->loc_type
!= bp_loc_software_breakpoint
1755 && bpt
->loc_type
!= bp_loc_hardware_breakpoint
)
1758 if ((breakpoint_enabled (bpt
->owner
)
1759 || bpt
->owner
->enable_state
== bp_permanent
)
1760 && bpt
->address
== pc
) /* bp is enabled and matches pc */
1762 if (overlay_debugging
1763 && section_is_overlay (bpt
->section
)
1764 && !section_is_mapped (bpt
->section
))
1765 continue; /* unmapped overlay -- can't be a match */
1766 else if (bpt
->owner
->enable_state
== bp_permanent
)
1767 return permanent_breakpoint_here
;
1769 any_breakpoint_here
= 1;
1773 return any_breakpoint_here
? ordinary_breakpoint_here
: 0;
1777 /* breakpoint_inserted_here_p (PC) is just like breakpoint_here_p(),
1778 but it only returns true if there is actually a breakpoint inserted
1782 breakpoint_inserted_here_p (CORE_ADDR pc
)
1784 struct bp_location
*bpt
;
1786 ALL_BP_LOCATIONS (bpt
)
1788 if (bpt
->loc_type
!= bp_loc_software_breakpoint
1789 && bpt
->loc_type
!= bp_loc_hardware_breakpoint
)
1793 && bpt
->address
== pc
) /* bp is inserted and matches pc */
1795 if (overlay_debugging
1796 && section_is_overlay (bpt
->section
)
1797 && !section_is_mapped (bpt
->section
))
1798 continue; /* unmapped overlay -- can't be a match */
1807 /* This function returns non-zero iff there is a software breakpoint
1811 software_breakpoint_inserted_here_p (CORE_ADDR pc
)
1813 struct bp_location
*bpt
;
1814 int any_breakpoint_here
= 0;
1816 ALL_BP_LOCATIONS (bpt
)
1818 if (bpt
->loc_type
!= bp_loc_software_breakpoint
)
1821 if ((breakpoint_enabled (bpt
->owner
)
1822 || bpt
->owner
->enable_state
== bp_permanent
)
1824 && bpt
->address
== pc
) /* bp is enabled and matches pc */
1826 if (overlay_debugging
1827 && section_is_overlay (bpt
->section
)
1828 && !section_is_mapped (bpt
->section
))
1829 continue; /* unmapped overlay -- can't be a match */
1838 /* breakpoint_thread_match (PC, PTID) returns true if the breakpoint at
1839 PC is valid for process/thread PTID. */
1842 breakpoint_thread_match (CORE_ADDR pc
, ptid_t ptid
)
1844 struct bp_location
*bpt
;
1847 thread
= pid_to_thread_id (ptid
);
1849 ALL_BP_LOCATIONS (bpt
)
1851 if (bpt
->loc_type
!= bp_loc_software_breakpoint
1852 && bpt
->loc_type
!= bp_loc_hardware_breakpoint
)
1855 if ((breakpoint_enabled (bpt
->owner
)
1856 || bpt
->owner
->enable_state
== bp_permanent
)
1857 && bpt
->address
== pc
1858 && (bpt
->owner
->thread
== -1 || bpt
->owner
->thread
== thread
))
1860 if (overlay_debugging
1861 && section_is_overlay (bpt
->section
)
1862 && !section_is_mapped (bpt
->section
))
1863 continue; /* unmapped overlay -- can't be a match */
1873 /* bpstat stuff. External routines' interfaces are documented
1877 ep_is_catchpoint (struct breakpoint
*ep
)
1880 (ep
->type
== bp_catch_load
)
1881 || (ep
->type
== bp_catch_unload
)
1882 || (ep
->type
== bp_catch_fork
)
1883 || (ep
->type
== bp_catch_vfork
)
1884 || (ep
->type
== bp_catch_exec
)
1885 || (ep
->type
== bp_catch_catch
)
1886 || (ep
->type
== bp_catch_throw
);
1888 /* ??rehrauer: Add more kinds here, as are implemented... */
1892 ep_is_shlib_catchpoint (struct breakpoint
*ep
)
1895 (ep
->type
== bp_catch_load
)
1896 || (ep
->type
== bp_catch_unload
);
1900 ep_is_exception_catchpoint (struct breakpoint
*ep
)
1903 (ep
->type
== bp_catch_catch
)
1904 || (ep
->type
== bp_catch_throw
);
1907 /* Clear a bpstat so that it says we are not at any breakpoint.
1908 Also free any storage that is part of a bpstat. */
1911 bpstat_clear (bpstat
*bsp
)
1922 if (p
->old_val
!= NULL
)
1923 value_free (p
->old_val
);
1924 free_command_lines (&p
->commands
);
1931 /* Return a copy of a bpstat. Like "bs1 = bs2" but all storage that
1932 is part of the bpstat is copied as well. */
1935 bpstat_copy (bpstat bs
)
1939 bpstat retval
= NULL
;
1944 for (; bs
!= NULL
; bs
= bs
->next
)
1946 tmp
= (bpstat
) xmalloc (sizeof (*tmp
));
1947 memcpy (tmp
, bs
, sizeof (*tmp
));
1948 if (bs
->commands
!= NULL
)
1949 tmp
->commands
= copy_command_lines (bs
->commands
);
1950 if (bs
->old_val
!= NULL
)
1951 tmp
->old_val
= value_copy (bs
->old_val
);
1954 /* This is the first thing in the chain. */
1964 /* Find the bpstat associated with this breakpoint */
1967 bpstat_find_breakpoint (bpstat bsp
, struct breakpoint
*breakpoint
)
1972 for (; bsp
!= NULL
; bsp
= bsp
->next
)
1974 if (bsp
->breakpoint_at
== breakpoint
)
1980 /* Find a step_resume breakpoint associated with this bpstat.
1981 (If there are multiple step_resume bp's on the list, this function
1982 will arbitrarily pick one.)
1984 It is an error to use this function if BPSTAT doesn't contain a
1985 step_resume breakpoint.
1987 See wait_for_inferior's use of this function. */
1989 bpstat_find_step_resume_breakpoint (bpstat bsp
)
1993 gdb_assert (bsp
!= NULL
);
1995 current_thread
= pid_to_thread_id (inferior_ptid
);
1997 for (; bsp
!= NULL
; bsp
= bsp
->next
)
1999 if ((bsp
->breakpoint_at
!= NULL
) &&
2000 (bsp
->breakpoint_at
->type
== bp_step_resume
) &&
2001 (bsp
->breakpoint_at
->thread
== current_thread
||
2002 bsp
->breakpoint_at
->thread
== -1))
2003 return bsp
->breakpoint_at
;
2006 internal_error (__FILE__
, __LINE__
, _("No step_resume breakpoint found."));
2010 /* Return the breakpoint number of the first breakpoint we are stopped
2011 at. *BSP upon return is a bpstat which points to the remaining
2012 breakpoints stopped at (but which is not guaranteed to be good for
2013 anything but further calls to bpstat_num).
2014 Return 0 if passed a bpstat which does not indicate any breakpoints. */
2017 bpstat_num (bpstat
*bsp
)
2019 struct breakpoint
*b
;
2022 return 0; /* No more breakpoint values */
2025 b
= (*bsp
)->breakpoint_at
;
2026 *bsp
= (*bsp
)->next
;
2028 return -1; /* breakpoint that's been deleted since */
2030 return b
->number
; /* We have its number */
2034 /* Modify BS so that the actions will not be performed. */
2037 bpstat_clear_actions (bpstat bs
)
2039 for (; bs
!= NULL
; bs
= bs
->next
)
2041 free_command_lines (&bs
->commands
);
2042 if (bs
->old_val
!= NULL
)
2044 value_free (bs
->old_val
);
2050 /* Stub for cleaning up our state if we error-out of a breakpoint command */
2052 cleanup_executing_breakpoints (void *ignore
)
2054 executing_breakpoint_commands
= 0;
2057 /* Execute all the commands associated with all the breakpoints at this
2058 location. Any of these commands could cause the process to proceed
2059 beyond this point, etc. We look out for such changes by checking
2060 the global "breakpoint_proceeded" after each command. */
2063 bpstat_do_actions (bpstat
*bsp
)
2066 struct cleanup
*old_chain
;
2068 /* Avoid endless recursion if a `source' command is contained
2070 if (executing_breakpoint_commands
)
2073 executing_breakpoint_commands
= 1;
2074 old_chain
= make_cleanup (cleanup_executing_breakpoints
, 0);
2077 /* Note that (as of this writing), our callers all appear to
2078 be passing us the address of global stop_bpstat. And, if
2079 our calls to execute_control_command cause the inferior to
2080 proceed, that global (and hence, *bsp) will change.
2082 We must be careful to not touch *bsp unless the inferior
2083 has not proceeded. */
2085 /* This pointer will iterate over the list of bpstat's. */
2088 breakpoint_proceeded
= 0;
2089 for (; bs
!= NULL
; bs
= bs
->next
)
2091 struct command_line
*cmd
;
2092 struct cleanup
*this_cmd_tree_chain
;
2094 /* Take ownership of the BSP's command tree, if it has one.
2096 The command tree could legitimately contain commands like
2097 'step' and 'next', which call clear_proceed_status, which
2098 frees stop_bpstat's command tree. To make sure this doesn't
2099 free the tree we're executing out from under us, we need to
2100 take ownership of the tree ourselves. Since a given bpstat's
2101 commands are only executed once, we don't need to copy it; we
2102 can clear the pointer in the bpstat, and make sure we free
2103 the tree when we're done. */
2106 this_cmd_tree_chain
= make_cleanup_free_command_lines (&cmd
);
2110 execute_control_command (cmd
);
2112 if (breakpoint_proceeded
)
2118 /* We can free this command tree now. */
2119 do_cleanups (this_cmd_tree_chain
);
2121 if (breakpoint_proceeded
)
2122 /* The inferior is proceeded by the command; bomb out now.
2123 The bpstat chain has been blown away by wait_for_inferior.
2124 But since execution has stopped again, there is a new bpstat
2125 to look at, so start over. */
2128 do_cleanups (old_chain
);
2131 /* This is the normal print function for a bpstat. In the future,
2132 much of this logic could (should?) be moved to bpstat_stop_status,
2133 by having it set different print_it values.
2135 Current scheme: When we stop, bpstat_print() is called. It loops
2136 through the bpstat list of things causing this stop, calling the
2137 print_bp_stop_message function on each one. The behavior of the
2138 print_bp_stop_message function depends on the print_it field of
2139 bpstat. If such field so indicates, call this function here.
2141 Return values from this routine (ultimately used by bpstat_print()
2142 and normal_stop() to decide what to do):
2143 PRINT_NOTHING: Means we already printed all we needed to print,
2144 don't print anything else.
2145 PRINT_SRC_ONLY: Means we printed something, and we do *not* desire
2146 that something to be followed by a location.
2147 PRINT_SCR_AND_LOC: Means we printed something, and we *do* desire
2148 that something to be followed by a location.
2149 PRINT_UNKNOWN: Means we printed nothing or we need to do some more
2152 static enum print_stop_action
2153 print_it_typical (bpstat bs
)
2155 struct cleanup
*old_chain
, *ui_out_chain
;
2156 struct ui_stream
*stb
;
2157 stb
= ui_out_stream_new (uiout
);
2158 old_chain
= make_cleanup_ui_out_stream_delete (stb
);
2159 /* bs->breakpoint_at can be NULL if it was a momentary breakpoint
2160 which has since been deleted. */
2161 if (bs
->breakpoint_at
== NULL
)
2162 return PRINT_UNKNOWN
;
2164 switch (bs
->breakpoint_at
->type
)
2167 case bp_hardware_breakpoint
:
2168 if (bs
->breakpoint_at
->loc
->address
!= bs
->breakpoint_at
->loc
->requested_address
)
2169 breakpoint_adjustment_warning (bs
->breakpoint_at
->loc
->requested_address
,
2170 bs
->breakpoint_at
->loc
->address
,
2171 bs
->breakpoint_at
->number
, 1);
2172 annotate_breakpoint (bs
->breakpoint_at
->number
);
2173 ui_out_text (uiout
, "\nBreakpoint ");
2174 if (ui_out_is_mi_like_p (uiout
))
2175 ui_out_field_string (uiout
, "reason",
2176 async_reason_lookup (EXEC_ASYNC_BREAKPOINT_HIT
));
2177 ui_out_field_int (uiout
, "bkptno", bs
->breakpoint_at
->number
);
2178 ui_out_text (uiout
, ", ");
2179 return PRINT_SRC_AND_LOC
;
2182 case bp_shlib_event
:
2183 /* Did we stop because the user set the stop_on_solib_events
2184 variable? (If so, we report this as a generic, "Stopped due
2185 to shlib event" message.) */
2186 printf_filtered (_("Stopped due to shared library event\n"));
2187 return PRINT_NOTHING
;
2190 case bp_thread_event
:
2191 /* Not sure how we will get here.
2192 GDB should not stop for these breakpoints. */
2193 printf_filtered (_("Thread Event Breakpoint: gdb should not stop!\n"));
2194 return PRINT_NOTHING
;
2197 case bp_overlay_event
:
2198 /* By analogy with the thread event, GDB should not stop for these. */
2199 printf_filtered (_("Overlay Event Breakpoint: gdb should not stop!\n"));
2200 return PRINT_NOTHING
;
2204 annotate_catchpoint (bs
->breakpoint_at
->number
);
2205 printf_filtered (_("\nCatchpoint %d (loaded %s), "),
2206 bs
->breakpoint_at
->number
,
2207 bs
->breakpoint_at
->triggered_dll_pathname
);
2208 return PRINT_SRC_AND_LOC
;
2211 case bp_catch_unload
:
2212 annotate_catchpoint (bs
->breakpoint_at
->number
);
2213 printf_filtered (_("\nCatchpoint %d (unloaded %s), "),
2214 bs
->breakpoint_at
->number
,
2215 bs
->breakpoint_at
->triggered_dll_pathname
);
2216 return PRINT_SRC_AND_LOC
;
2220 annotate_catchpoint (bs
->breakpoint_at
->number
);
2221 printf_filtered (_("\nCatchpoint %d (forked process %d), "),
2222 bs
->breakpoint_at
->number
,
2223 bs
->breakpoint_at
->forked_inferior_pid
);
2224 return PRINT_SRC_AND_LOC
;
2227 case bp_catch_vfork
:
2228 annotate_catchpoint (bs
->breakpoint_at
->number
);
2229 printf_filtered (_("\nCatchpoint %d (vforked process %d), "),
2230 bs
->breakpoint_at
->number
,
2231 bs
->breakpoint_at
->forked_inferior_pid
);
2232 return PRINT_SRC_AND_LOC
;
2236 annotate_catchpoint (bs
->breakpoint_at
->number
);
2237 printf_filtered (_("\nCatchpoint %d (exec'd %s), "),
2238 bs
->breakpoint_at
->number
,
2239 bs
->breakpoint_at
->exec_pathname
);
2240 return PRINT_SRC_AND_LOC
;
2243 case bp_catch_catch
:
2244 if (current_exception_event
&&
2245 (CURRENT_EXCEPTION_KIND
== EX_EVENT_CATCH
))
2247 annotate_catchpoint (bs
->breakpoint_at
->number
);
2248 printf_filtered (_("\nCatchpoint %d (exception caught), "),
2249 bs
->breakpoint_at
->number
);
2250 if (CURRENT_EXCEPTION_THROW_PC
&& CURRENT_EXCEPTION_THROW_LINE
)
2251 printf_filtered (_("throw location %s:%d, "),
2252 CURRENT_EXCEPTION_THROW_FILE
,
2253 CURRENT_EXCEPTION_THROW_LINE
);
2255 printf_filtered (_("throw location unknown, "));
2257 if (CURRENT_EXCEPTION_CATCH_PC
&& CURRENT_EXCEPTION_CATCH_LINE
)
2258 printf_filtered (_("catch location %s:%d\n"),
2259 CURRENT_EXCEPTION_CATCH_FILE
,
2260 CURRENT_EXCEPTION_CATCH_LINE
);
2262 printf_filtered (_("catch location unknown\n"));
2264 /* don't bother to print location frame info */
2265 return PRINT_SRC_ONLY
;
2269 /* really throw, some other bpstat will handle it */
2270 return PRINT_UNKNOWN
;
2274 case bp_catch_throw
:
2275 if (current_exception_event
&&
2276 (CURRENT_EXCEPTION_KIND
== EX_EVENT_THROW
))
2278 annotate_catchpoint (bs
->breakpoint_at
->number
);
2279 printf_filtered (_("\nCatchpoint %d (exception thrown), "),
2280 bs
->breakpoint_at
->number
);
2281 if (CURRENT_EXCEPTION_THROW_PC
&& CURRENT_EXCEPTION_THROW_LINE
)
2282 printf_filtered (_("throw location %s:%d, "),
2283 CURRENT_EXCEPTION_THROW_FILE
,
2284 CURRENT_EXCEPTION_THROW_LINE
);
2286 printf_filtered (_("throw location unknown, "));
2288 if (CURRENT_EXCEPTION_CATCH_PC
&& CURRENT_EXCEPTION_CATCH_LINE
)
2289 printf_filtered (_("catch location %s:%d\n"),
2290 CURRENT_EXCEPTION_CATCH_FILE
,
2291 CURRENT_EXCEPTION_CATCH_LINE
);
2293 printf_filtered (_("catch location unknown\n"));
2295 /* don't bother to print location frame info */
2296 return PRINT_SRC_ONLY
;
2300 /* really catch, some other bpstat will handle it */
2301 return PRINT_UNKNOWN
;
2306 case bp_hardware_watchpoint
:
2307 if (bs
->old_val
!= NULL
)
2309 annotate_watchpoint (bs
->breakpoint_at
->number
);
2310 if (ui_out_is_mi_like_p (uiout
))
2313 async_reason_lookup (EXEC_ASYNC_WATCHPOINT_TRIGGER
));
2314 mention (bs
->breakpoint_at
);
2315 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "value");
2316 ui_out_text (uiout
, "\nOld value = ");
2317 value_print (bs
->old_val
, stb
->stream
, 0, Val_pretty_default
);
2318 ui_out_field_stream (uiout
, "old", stb
);
2319 ui_out_text (uiout
, "\nNew value = ");
2320 value_print (bs
->breakpoint_at
->val
, stb
->stream
, 0, Val_pretty_default
);
2321 ui_out_field_stream (uiout
, "new", stb
);
2322 do_cleanups (ui_out_chain
);
2323 ui_out_text (uiout
, "\n");
2324 value_free (bs
->old_val
);
2327 /* More than one watchpoint may have been triggered. */
2328 return PRINT_UNKNOWN
;
2331 case bp_read_watchpoint
:
2332 if (ui_out_is_mi_like_p (uiout
))
2335 async_reason_lookup (EXEC_ASYNC_READ_WATCHPOINT_TRIGGER
));
2336 mention (bs
->breakpoint_at
);
2337 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "value");
2338 ui_out_text (uiout
, "\nValue = ");
2339 value_print (bs
->breakpoint_at
->val
, stb
->stream
, 0, Val_pretty_default
);
2340 ui_out_field_stream (uiout
, "value", stb
);
2341 do_cleanups (ui_out_chain
);
2342 ui_out_text (uiout
, "\n");
2343 return PRINT_UNKNOWN
;
2346 case bp_access_watchpoint
:
2347 if (bs
->old_val
!= NULL
)
2349 annotate_watchpoint (bs
->breakpoint_at
->number
);
2350 if (ui_out_is_mi_like_p (uiout
))
2353 async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER
));
2354 mention (bs
->breakpoint_at
);
2355 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "value");
2356 ui_out_text (uiout
, "\nOld value = ");
2357 value_print (bs
->old_val
, stb
->stream
, 0, Val_pretty_default
);
2358 ui_out_field_stream (uiout
, "old", stb
);
2359 value_free (bs
->old_val
);
2361 ui_out_text (uiout
, "\nNew value = ");
2365 mention (bs
->breakpoint_at
);
2366 if (ui_out_is_mi_like_p (uiout
))
2369 async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER
));
2370 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "value");
2371 ui_out_text (uiout
, "\nValue = ");
2373 value_print (bs
->breakpoint_at
->val
, stb
->stream
, 0,Val_pretty_default
);
2374 ui_out_field_stream (uiout
, "new", stb
);
2375 do_cleanups (ui_out_chain
);
2376 ui_out_text (uiout
, "\n");
2377 return PRINT_UNKNOWN
;
2380 /* Fall through, we don't deal with these types of breakpoints
2384 if (ui_out_is_mi_like_p (uiout
))
2387 async_reason_lookup (EXEC_ASYNC_FUNCTION_FINISHED
));
2388 return PRINT_UNKNOWN
;
2392 if (ui_out_is_mi_like_p (uiout
))
2395 async_reason_lookup (EXEC_ASYNC_LOCATION_REACHED
));
2396 return PRINT_UNKNOWN
;
2401 case bp_longjmp_resume
:
2402 case bp_step_resume
:
2403 case bp_through_sigtramp
:
2404 case bp_watchpoint_scope
:
2407 return PRINT_UNKNOWN
;
2411 /* Generic routine for printing messages indicating why we
2412 stopped. The behavior of this function depends on the value
2413 'print_it' in the bpstat structure. Under some circumstances we
2414 may decide not to print anything here and delegate the task to
2417 static enum print_stop_action
2418 print_bp_stop_message (bpstat bs
)
2420 switch (bs
->print_it
)
2423 /* Nothing should be printed for this bpstat entry. */
2424 return PRINT_UNKNOWN
;
2428 /* We still want to print the frame, but we already printed the
2429 relevant messages. */
2430 return PRINT_SRC_AND_LOC
;
2433 case print_it_normal
:
2434 /* Normal case. Call the breakpoint's print_it method, or
2435 print_it_typical. */
2436 if (bs
->breakpoint_at
!= NULL
&& bs
->breakpoint_at
->ops
!= NULL
2437 && bs
->breakpoint_at
->ops
->print_it
!= NULL
)
2438 return bs
->breakpoint_at
->ops
->print_it (bs
->breakpoint_at
);
2440 return print_it_typical (bs
);
2444 internal_error (__FILE__
, __LINE__
,
2445 _("print_bp_stop_message: unrecognized enum value"));
2450 /* Print a message indicating what happened. This is called from
2451 normal_stop(). The input to this routine is the head of the bpstat
2452 list - a list of the eventpoints that caused this stop. This
2453 routine calls the generic print routine for printing a message
2454 about reasons for stopping. This will print (for example) the
2455 "Breakpoint n," part of the output. The return value of this
2458 PRINT_UNKNOWN: Means we printed nothing
2459 PRINT_SRC_AND_LOC: Means we printed something, and expect subsequent
2460 code to print the location. An example is
2461 "Breakpoint 1, " which should be followed by
2463 PRINT_SRC_ONLY: Means we printed something, but there is no need
2464 to also print the location part of the message.
2465 An example is the catch/throw messages, which
2466 don't require a location appended to the end.
2467 PRINT_NOTHING: We have done some printing and we don't need any
2468 further info to be printed.*/
2470 enum print_stop_action
2471 bpstat_print (bpstat bs
)
2475 /* Maybe another breakpoint in the chain caused us to stop.
2476 (Currently all watchpoints go on the bpstat whether hit or not.
2477 That probably could (should) be changed, provided care is taken
2478 with respect to bpstat_explains_signal). */
2479 for (; bs
; bs
= bs
->next
)
2481 val
= print_bp_stop_message (bs
);
2482 if (val
== PRINT_SRC_ONLY
2483 || val
== PRINT_SRC_AND_LOC
2484 || val
== PRINT_NOTHING
)
2488 /* We reached the end of the chain, or we got a null BS to start
2489 with and nothing was printed. */
2490 return PRINT_UNKNOWN
;
2493 /* Evaluate the expression EXP and return 1 if value is zero.
2494 This is used inside a catch_errors to evaluate the breakpoint condition.
2495 The argument is a "struct expression *" that has been cast to char * to
2496 make it pass through catch_errors. */
2499 breakpoint_cond_eval (void *exp
)
2501 struct value
*mark
= value_mark ();
2502 int i
= !value_true (evaluate_expression ((struct expression
*) exp
));
2503 value_free_to_mark (mark
);
2507 /* Allocate a new bpstat and chain it to the current one. */
2510 bpstat_alloc (struct breakpoint
*b
, bpstat cbs
/* Current "bs" value */ )
2514 bs
= (bpstat
) xmalloc (sizeof (*bs
));
2516 bs
->breakpoint_at
= b
;
2517 /* If the condition is false, etc., don't do the commands. */
2518 bs
->commands
= NULL
;
2520 bs
->print_it
= print_it_normal
;
2524 /* Possible return values for watchpoint_check (this can't be an enum
2525 because of check_errors). */
2526 /* The watchpoint has been deleted. */
2527 #define WP_DELETED 1
2528 /* The value has changed. */
2529 #define WP_VALUE_CHANGED 2
2530 /* The value has not changed. */
2531 #define WP_VALUE_NOT_CHANGED 3
2533 #define BP_TEMPFLAG 1
2534 #define BP_HARDWAREFLAG 2
2536 /* Check watchpoint condition. */
2539 watchpoint_check (void *p
)
2541 bpstat bs
= (bpstat
) p
;
2542 struct breakpoint
*b
;
2543 struct frame_info
*fr
;
2544 int within_current_scope
;
2546 b
= bs
->breakpoint_at
;
2548 if (b
->exp_valid_block
== NULL
)
2549 within_current_scope
= 1;
2552 /* There is no current frame at this moment. If we're going to have
2553 any chance of handling watchpoints on local variables, we'll need
2554 the frame chain (so we can determine if we're in scope). */
2555 reinit_frame_cache ();
2556 fr
= frame_find_by_id (b
->watchpoint_frame
);
2557 within_current_scope
= (fr
!= NULL
);
2559 /* If we've gotten confused in the unwinder, we might have
2560 returned a frame that can't describe this variable. */
2561 if (within_current_scope
2562 && block_function (b
->exp_valid_block
) != get_frame_function (fr
))
2563 within_current_scope
= 0;
2565 /* in_function_epilogue_p() returns a non-zero value if we're still
2566 in the function but the stack frame has already been invalidated.
2567 Since we can't rely on the values of local variables after the
2568 stack has been destroyed, we are treating the watchpoint in that
2569 state as `not changed' without further checking.
2571 vinschen/2003-09-04: The former implementation left out the case
2572 that the watchpoint frame couldn't be found by frame_find_by_id()
2573 because the current PC is currently in an epilogue. Calling
2574 gdbarch_in_function_epilogue_p() also when fr == NULL fixes that. */
2575 if ((!within_current_scope
|| fr
== get_current_frame ())
2576 && gdbarch_in_function_epilogue_p (current_gdbarch
, read_pc ()))
2577 return WP_VALUE_NOT_CHANGED
;
2578 if (fr
&& within_current_scope
)
2579 /* If we end up stopping, the current frame will get selected
2580 in normal_stop. So this call to select_frame won't affect
2585 if (within_current_scope
)
2587 /* We use value_{,free_to_}mark because it could be a
2588 *long* time before we return to the command level and
2589 call free_all_values. We can't call free_all_values because
2590 we might be in the middle of evaluating a function call. */
2592 struct value
*mark
= value_mark ();
2593 struct value
*new_val
= evaluate_expression (bs
->breakpoint_at
->exp
);
2594 if (!value_equal (b
->val
, new_val
))
2596 release_value (new_val
);
2597 value_free_to_mark (mark
);
2598 bs
->old_val
= b
->val
;
2600 /* We will stop here */
2601 return WP_VALUE_CHANGED
;
2605 /* Nothing changed, don't do anything. */
2606 value_free_to_mark (mark
);
2607 /* We won't stop here */
2608 return WP_VALUE_NOT_CHANGED
;
2613 /* This seems like the only logical thing to do because
2614 if we temporarily ignored the watchpoint, then when
2615 we reenter the block in which it is valid it contains
2616 garbage (in the case of a function, it may have two
2617 garbage values, one before and one after the prologue).
2618 So we can't even detect the first assignment to it and
2619 watch after that (since the garbage may or may not equal
2620 the first value assigned). */
2621 /* We print all the stop information in print_it_typical(), but
2622 in this case, by the time we call print_it_typical() this bp
2623 will be deleted already. So we have no choice but print the
2624 information here. */
2625 if (ui_out_is_mi_like_p (uiout
))
2627 (uiout
, "reason", async_reason_lookup (EXEC_ASYNC_WATCHPOINT_SCOPE
));
2628 ui_out_text (uiout
, "\nWatchpoint ");
2629 ui_out_field_int (uiout
, "wpnum", bs
->breakpoint_at
->number
);
2630 ui_out_text (uiout
, " deleted because the program has left the block in\n\
2631 which its expression is valid.\n");
2633 if (b
->related_breakpoint
)
2634 b
->related_breakpoint
->disposition
= disp_del_at_next_stop
;
2635 b
->disposition
= disp_del_at_next_stop
;
2641 /* Get a bpstat associated with having just stopped at address
2642 BP_ADDR in thread PTID. STOPPED_BY_WATCHPOINT is 1 if the
2643 target thinks we stopped due to a hardware watchpoint, 0 if we
2644 know we did not trigger a hardware watchpoint, and -1 if we do not know. */
2646 /* Determine whether we stopped at a breakpoint, etc, or whether we
2647 don't understand this stop. Result is a chain of bpstat's such that:
2649 if we don't understand the stop, the result is a null pointer.
2651 if we understand why we stopped, the result is not null.
2653 Each element of the chain refers to a particular breakpoint or
2654 watchpoint at which we have stopped. (We may have stopped for
2655 several reasons concurrently.)
2657 Each element of the chain has valid next, breakpoint_at,
2658 commands, FIXME??? fields. */
2661 bpstat_stop_status (CORE_ADDR bp_addr
, ptid_t ptid
, int stopped_by_watchpoint
)
2663 struct breakpoint
*b
, *temp
;
2664 /* True if we've hit a breakpoint (as opposed to a watchpoint). */
2665 int real_breakpoint
= 0;
2666 /* Root of the chain of bpstat's */
2667 struct bpstats root_bs
[1];
2668 /* Pointer to the last thing in the chain currently. */
2669 bpstat bs
= root_bs
;
2670 int thread_id
= pid_to_thread_id (ptid
);
2672 ALL_BREAKPOINTS_SAFE (b
, temp
)
2674 if (!breakpoint_enabled (b
) && b
->enable_state
!= bp_permanent
)
2677 if (b
->type
!= bp_watchpoint
2678 && b
->type
!= bp_hardware_watchpoint
2679 && b
->type
!= bp_read_watchpoint
2680 && b
->type
!= bp_access_watchpoint
2681 && b
->type
!= bp_hardware_breakpoint
2682 && b
->type
!= bp_catch_fork
2683 && b
->type
!= bp_catch_vfork
2684 && b
->type
!= bp_catch_exec
2685 && b
->type
!= bp_catch_catch
2686 && b
->type
!= bp_catch_throw
) /* a non-watchpoint bp */
2688 if (b
->loc
->address
!= bp_addr
) /* address doesn't match */
2690 if (overlay_debugging
/* unmapped overlay section */
2691 && section_is_overlay (b
->loc
->section
)
2692 && !section_is_mapped (b
->loc
->section
))
2696 /* Continuable hardware watchpoints are treated as non-existent if the
2697 reason we stopped wasn't a hardware watchpoint (we didn't stop on
2698 some data address). Otherwise gdb won't stop on a break instruction
2699 in the code (not from a breakpoint) when a hardware watchpoint has
2702 if ((b
->type
== bp_hardware_watchpoint
2703 || b
->type
== bp_read_watchpoint
2704 || b
->type
== bp_access_watchpoint
)
2705 && !stopped_by_watchpoint
)
2708 if (b
->type
== bp_hardware_breakpoint
)
2710 if (b
->loc
->address
!= bp_addr
)
2712 if (overlay_debugging
/* unmapped overlay section */
2713 && section_is_overlay (b
->loc
->section
)
2714 && !section_is_mapped (b
->loc
->section
))
2718 /* Is this a catchpoint of a load or unload? If so, did we
2719 get a load or unload of the specified library? If not,
2721 if ((b
->type
== bp_catch_load
)
2722 #if defined(SOLIB_HAVE_LOAD_EVENT)
2723 && (!SOLIB_HAVE_LOAD_EVENT (PIDGET (inferior_ptid
))
2724 || ((b
->dll_pathname
!= NULL
)
2725 && (strcmp (b
->dll_pathname
,
2726 SOLIB_LOADED_LIBRARY_PATHNAME (
2727 PIDGET (inferior_ptid
)))
2733 if ((b
->type
== bp_catch_unload
)
2734 #if defined(SOLIB_HAVE_UNLOAD_EVENT)
2735 && (!SOLIB_HAVE_UNLOAD_EVENT (PIDGET (inferior_ptid
))
2736 || ((b
->dll_pathname
!= NULL
)
2737 && (strcmp (b
->dll_pathname
,
2738 SOLIB_UNLOADED_LIBRARY_PATHNAME (
2739 PIDGET (inferior_ptid
)))
2745 if ((b
->type
== bp_catch_fork
)
2746 && !inferior_has_forked (PIDGET (inferior_ptid
),
2747 &b
->forked_inferior_pid
))
2750 if ((b
->type
== bp_catch_vfork
)
2751 && !inferior_has_vforked (PIDGET (inferior_ptid
),
2752 &b
->forked_inferior_pid
))
2755 if ((b
->type
== bp_catch_exec
)
2756 && !inferior_has_execd (PIDGET (inferior_ptid
), &b
->exec_pathname
))
2759 if (ep_is_exception_catchpoint (b
) &&
2760 !(current_exception_event
= target_get_current_exception_event ()))
2763 /* Come here if it's a watchpoint, or if the break address matches */
2765 bs
= bpstat_alloc (b
, bs
); /* Alloc a bpstat to explain stop */
2767 /* Watchpoints may change this, if not found to have triggered. */
2771 if (b
->type
== bp_watchpoint
||
2772 b
->type
== bp_hardware_watchpoint
)
2774 char *message
= xstrprintf ("Error evaluating expression for watchpoint %d\n",
2776 struct cleanup
*cleanups
= make_cleanup (xfree
, message
);
2777 int e
= catch_errors (watchpoint_check
, bs
, message
,
2779 do_cleanups (cleanups
);
2783 /* We've already printed what needs to be printed. */
2784 /* Actually this is superfluous, because by the time we
2785 call print_it_typical() the wp will be already deleted,
2786 and the function will return immediately. */
2787 bs
->print_it
= print_it_done
;
2790 case WP_VALUE_CHANGED
:
2794 case WP_VALUE_NOT_CHANGED
:
2796 bs
->print_it
= print_it_noop
;
2803 /* Error from catch_errors. */
2804 printf_filtered (_("Watchpoint %d deleted.\n"), b
->number
);
2805 if (b
->related_breakpoint
)
2806 b
->related_breakpoint
->disposition
= disp_del_at_next_stop
;
2807 b
->disposition
= disp_del_at_next_stop
;
2808 /* We've already printed what needs to be printed. */
2809 bs
->print_it
= print_it_done
;
2815 else if (b
->type
== bp_read_watchpoint
||
2816 b
->type
== bp_access_watchpoint
)
2822 if (!target_stopped_data_address (¤t_target
, &addr
))
2824 for (v
= b
->val_chain
; v
; v
= value_next (v
))
2826 if (VALUE_LVAL (v
) == lval_memory
2827 && ! value_lazy (v
))
2829 struct type
*vtype
= check_typedef (value_type (v
));
2831 if (v
== b
->val_chain
2832 || (TYPE_CODE (vtype
) != TYPE_CODE_STRUCT
2833 && TYPE_CODE (vtype
) != TYPE_CODE_ARRAY
))
2837 vaddr
= VALUE_ADDRESS (v
) + value_offset (v
);
2838 /* Exact match not required. Within range is
2840 if (addr
>= vaddr
&&
2841 addr
< vaddr
+ TYPE_LENGTH (value_type (v
)))
2848 char *message
= xstrprintf ("Error evaluating expression for watchpoint %d\n",
2850 struct cleanup
*cleanups
= make_cleanup (xfree
, message
);
2851 int e
= catch_errors (watchpoint_check
, bs
, message
,
2853 do_cleanups (cleanups
);
2857 /* We've already printed what needs to be printed. */
2858 bs
->print_it
= print_it_done
;
2861 case WP_VALUE_CHANGED
:
2862 if (b
->type
== bp_read_watchpoint
)
2864 /* Don't stop: read watchpoints shouldn't fire if
2865 the value has changed. This is for targets
2866 which cannot set read-only watchpoints. */
2867 bs
->print_it
= print_it_noop
;
2873 case WP_VALUE_NOT_CHANGED
:
2880 /* Error from catch_errors. */
2881 printf_filtered (_("Watchpoint %d deleted.\n"), b
->number
);
2882 if (b
->related_breakpoint
)
2883 b
->related_breakpoint
->disposition
= disp_del_at_next_stop
;
2884 b
->disposition
= disp_del_at_next_stop
;
2885 /* We've already printed what needs to be printed. */
2886 bs
->print_it
= print_it_done
;
2890 else /* found == 0 */
2892 /* This is a case where some watchpoint(s) triggered,
2893 but not at the address of this watchpoint (FOUND
2894 was left zero). So don't print anything for this
2896 bs
->print_it
= print_it_noop
;
2903 /* By definition, an encountered breakpoint is a triggered
2907 real_breakpoint
= 1;
2910 if (frame_id_p (b
->frame_id
)
2911 && !frame_id_eq (b
->frame_id
, get_frame_id (get_current_frame ())))
2915 int value_is_zero
= 0;
2919 /* Need to select the frame, with all that implies
2920 so that the conditions will have the right context. */
2921 select_frame (get_current_frame ());
2923 = catch_errors (breakpoint_cond_eval
, (b
->cond
),
2924 "Error in testing breakpoint condition:\n",
2926 /* FIXME-someday, should give breakpoint # */
2929 if (b
->cond
&& value_is_zero
)
2932 /* Don't consider this a hit. */
2935 else if (b
->thread
!= -1 && b
->thread
!= thread_id
)
2938 /* Don't consider this a hit. */
2941 else if (b
->ignore_count
> 0)
2944 annotate_ignore_count_change ();
2949 /* We will stop here */
2950 if (b
->disposition
== disp_disable
)
2951 b
->enable_state
= bp_disabled
;
2954 bs
->commands
= b
->commands
;
2956 (strcmp ("silent", bs
->commands
->line
) == 0
2957 || (xdb_commands
&& strcmp ("Q", bs
->commands
->line
) == 0)))
2959 bs
->commands
= bs
->commands
->next
;
2962 bs
->commands
= copy_command_lines (bs
->commands
);
2965 /* Print nothing for this entry if we dont stop or if we dont print. */
2966 if (bs
->stop
== 0 || bs
->print
== 0)
2967 bs
->print_it
= print_it_noop
;
2970 bs
->next
= NULL
; /* Terminate the chain */
2971 bs
= root_bs
->next
; /* Re-grab the head of the chain */
2973 /* The value of a hardware watchpoint hasn't changed, but the
2974 intermediate memory locations we are watching may have. */
2975 if (bs
&& !bs
->stop
&&
2976 (bs
->breakpoint_at
->type
== bp_hardware_watchpoint
||
2977 bs
->breakpoint_at
->type
== bp_read_watchpoint
||
2978 bs
->breakpoint_at
->type
== bp_access_watchpoint
))
2980 remove_breakpoints ();
2981 insert_breakpoints ();
2986 /* Tell what to do about this bpstat. */
2988 bpstat_what (bpstat bs
)
2990 /* Classify each bpstat as one of the following. */
2993 /* This bpstat element has no effect on the main_action. */
2996 /* There was a watchpoint, stop but don't print. */
2999 /* There was a watchpoint, stop and print. */
3002 /* There was a breakpoint but we're not stopping. */
3005 /* There was a breakpoint, stop but don't print. */
3008 /* There was a breakpoint, stop and print. */
3011 /* We hit the longjmp breakpoint. */
3014 /* We hit the longjmp_resume breakpoint. */
3017 /* We hit the step_resume breakpoint. */
3020 /* We hit the through_sigtramp breakpoint. */
3023 /* We hit the shared library event breakpoint. */
3026 /* We caught a shared library event. */
3029 /* This is just used to count how many enums there are. */
3033 /* Here is the table which drives this routine. So that we can
3034 format it pretty, we define some abbreviations for the
3035 enum bpstat_what codes. */
3036 #define kc BPSTAT_WHAT_KEEP_CHECKING
3037 #define ss BPSTAT_WHAT_STOP_SILENT
3038 #define sn BPSTAT_WHAT_STOP_NOISY
3039 #define sgl BPSTAT_WHAT_SINGLE
3040 #define slr BPSTAT_WHAT_SET_LONGJMP_RESUME
3041 #define clr BPSTAT_WHAT_CLEAR_LONGJMP_RESUME
3042 #define clrs BPSTAT_WHAT_CLEAR_LONGJMP_RESUME_SINGLE
3043 #define sr BPSTAT_WHAT_STEP_RESUME
3044 #define ts BPSTAT_WHAT_THROUGH_SIGTRAMP
3045 #define shl BPSTAT_WHAT_CHECK_SHLIBS
3046 #define shlr BPSTAT_WHAT_CHECK_SHLIBS_RESUME_FROM_HOOK
3048 /* "Can't happen." Might want to print an error message.
3049 abort() is not out of the question, but chances are GDB is just
3050 a bit confused, not unusable. */
3051 #define err BPSTAT_WHAT_STOP_NOISY
3053 /* Given an old action and a class, come up with a new action. */
3054 /* One interesting property of this table is that wp_silent is the same
3055 as bp_silent and wp_noisy is the same as bp_noisy. That is because
3056 after stopping, the check for whether to step over a breakpoint
3057 (BPSTAT_WHAT_SINGLE type stuff) is handled in proceed() without
3058 reference to how we stopped. We retain separate wp_silent and
3059 bp_silent codes in case we want to change that someday.
3061 Another possibly interesting property of this table is that
3062 there's a partial ordering, priority-like, of the actions. Once
3063 you've decided that some action is appropriate, you'll never go
3064 back and decide something of a lower priority is better. The
3067 kc < clr sgl shl shlr slr sn sr ss ts
3068 sgl < clrs shl shlr slr sn sr ss ts
3069 slr < err shl shlr sn sr ss ts
3070 clr < clrs err shl shlr sn sr ss ts
3071 clrs < err shl shlr sn sr ss ts
3072 ss < shl shlr sn sr ts
3079 What I think this means is that we don't need a damned table
3080 here. If you just put the rows and columns in the right order,
3081 it'd look awfully regular. We could simply walk the bpstat list
3082 and choose the highest priority action we find, with a little
3083 logic to handle the 'err' cases, and the CLEAR_LONGJMP_RESUME/
3084 CLEAR_LONGJMP_RESUME_SINGLE distinction (which breakpoint.h says
3085 is messy anyway). */
3087 /* step_resume entries: a step resume breakpoint overrides another
3088 breakpoint of signal handling (see comment in wait_for_inferior
3089 at where we set the step_resume breakpoint). */
3090 /* We handle the through_sigtramp_breakpoint the same way; having both
3091 one of those and a step_resume_breakpoint is probably very rare (?). */
3093 static const enum bpstat_what_main_action
3094 table
[(int) class_last
][(int) BPSTAT_WHAT_LAST
] =
3097 /* kc ss sn sgl slr clr clrs sr ts shl shlr
3100 {kc
, ss
, sn
, sgl
, slr
, clr
, clrs
, sr
, ts
, shl
, shlr
},
3102 {ss
, ss
, sn
, ss
, ss
, ss
, ss
, sr
, ts
, shl
, shlr
},
3104 {sn
, sn
, sn
, sn
, sn
, sn
, sn
, sr
, ts
, shl
, shlr
},
3106 {sgl
, ss
, sn
, sgl
, slr
, clrs
, clrs
, sr
, ts
, shl
, shlr
},
3108 {ss
, ss
, sn
, ss
, ss
, ss
, ss
, sr
, ts
, shl
, shlr
},
3110 {sn
, sn
, sn
, sn
, sn
, sn
, sn
, sr
, ts
, shl
, shlr
},
3112 {slr
, ss
, sn
, slr
, slr
, err
, err
, sr
, ts
, shl
, shlr
},
3114 {clr
, ss
, sn
, clrs
, err
, err
, err
, sr
, ts
, shl
, shlr
},
3116 {sr
, sr
, sr
, sr
, sr
, sr
, sr
, sr
, ts
, shl
, shlr
},
3118 {ts
, ts
, ts
, ts
, ts
, ts
, ts
, ts
, ts
, shl
, shlr
},
3120 {shl
, shl
, shl
, shl
, shl
, shl
, shl
, shl
, ts
, shl
, shlr
},
3122 {shlr
, shlr
, shlr
, shlr
, shlr
, shlr
, shlr
, shlr
, ts
, shlr
, shlr
}
3137 enum bpstat_what_main_action current_action
= BPSTAT_WHAT_KEEP_CHECKING
;
3138 struct bpstat_what retval
;
3140 retval
.call_dummy
= 0;
3141 for (; bs
!= NULL
; bs
= bs
->next
)
3143 enum class bs_class
= no_effect
;
3144 if (bs
->breakpoint_at
== NULL
)
3145 /* I suspect this can happen if it was a momentary breakpoint
3146 which has since been deleted. */
3148 switch (bs
->breakpoint_at
->type
)
3154 case bp_hardware_breakpoint
:
3160 bs_class
= bp_noisy
;
3162 bs_class
= bp_silent
;
3165 bs_class
= bp_nostop
;
3168 case bp_hardware_watchpoint
:
3169 case bp_read_watchpoint
:
3170 case bp_access_watchpoint
:
3174 bs_class
= wp_noisy
;
3176 bs_class
= wp_silent
;
3179 /* There was a watchpoint, but we're not stopping.
3180 This requires no further action. */
3181 bs_class
= no_effect
;
3184 bs_class
= long_jump
;
3186 case bp_longjmp_resume
:
3187 bs_class
= long_resume
;
3189 case bp_step_resume
:
3192 bs_class
= step_resume
;
3195 /* It is for the wrong frame. */
3196 bs_class
= bp_nostop
;
3198 case bp_through_sigtramp
:
3199 bs_class
= through_sig
;
3201 case bp_watchpoint_scope
:
3202 bs_class
= bp_nostop
;
3204 case bp_shlib_event
:
3205 bs_class
= shlib_event
;
3207 case bp_thread_event
:
3208 case bp_overlay_event
:
3209 bs_class
= bp_nostop
;
3212 case bp_catch_unload
:
3213 /* Only if this catchpoint triggered should we cause the
3214 step-out-of-dld behaviour. Otherwise, we ignore this
3217 bs_class
= catch_shlib_event
;
3219 bs_class
= no_effect
;
3222 case bp_catch_vfork
:
3227 bs_class
= bp_noisy
;
3229 bs_class
= bp_silent
;
3232 /* There was a catchpoint, but we're not stopping.
3233 This requires no further action. */
3234 bs_class
= no_effect
;
3236 case bp_catch_catch
:
3237 if (!bs
->stop
|| CURRENT_EXCEPTION_KIND
!= EX_EVENT_CATCH
)
3238 bs_class
= bp_nostop
;
3240 bs_class
= bs
->print
? bp_noisy
: bp_silent
;
3242 case bp_catch_throw
:
3243 if (!bs
->stop
|| CURRENT_EXCEPTION_KIND
!= EX_EVENT_THROW
)
3244 bs_class
= bp_nostop
;
3246 bs_class
= bs
->print
? bp_noisy
: bp_silent
;
3249 /* Make sure the action is stop (silent or noisy),
3250 so infrun.c pops the dummy frame. */
3251 bs_class
= bp_silent
;
3252 retval
.call_dummy
= 1;
3255 current_action
= table
[(int) bs_class
][(int) current_action
];
3257 retval
.main_action
= current_action
;
3261 /* Nonzero if we should step constantly (e.g. watchpoints on machines
3262 without hardware support). This isn't related to a specific bpstat,
3263 just to things like whether watchpoints are set. */
3266 bpstat_should_step (void)
3268 struct breakpoint
*b
;
3270 if (breakpoint_enabled (b
) && b
->type
== bp_watchpoint
)
3275 /* Nonzero if there are enabled hardware watchpoints. */
3277 bpstat_have_active_hw_watchpoints (void)
3279 struct bp_location
*bpt
;
3280 ALL_BP_LOCATIONS (bpt
)
3281 if (breakpoint_enabled (bpt
->owner
)
3283 && bpt
->loc_type
== bp_loc_hardware_watchpoint
)
3289 /* Given a bpstat that records zero or more triggered eventpoints, this
3290 function returns another bpstat which contains only the catchpoints
3291 on that first list, if any. */
3293 bpstat_get_triggered_catchpoints (bpstat ep_list
, bpstat
*cp_list
)
3295 struct bpstats root_bs
[1];
3296 bpstat bs
= root_bs
;
3297 struct breakpoint
*ep
;
3300 bpstat_clear (cp_list
);
3301 root_bs
->next
= NULL
;
3303 for (; ep_list
!= NULL
; ep_list
= ep_list
->next
)
3305 /* Is this eventpoint a catchpoint? If not, ignore it. */
3306 ep
= ep_list
->breakpoint_at
;
3309 if ((ep
->type
!= bp_catch_load
) &&
3310 (ep
->type
!= bp_catch_unload
) &&
3311 (ep
->type
!= bp_catch_catch
) &&
3312 (ep
->type
!= bp_catch_throw
))
3313 /* pai: (temp) ADD fork/vfork here!! */
3316 /* Yes; add it to the list. */
3317 bs
= bpstat_alloc (ep
, bs
);
3322 #if defined(SOLIB_ADD)
3323 /* Also, for each triggered catchpoint, tag it with the name of
3324 the library that caused this trigger. (We copy the name now,
3325 because it's only guaranteed to be available NOW, when the
3326 catchpoint triggers. Clients who may wish to know the name
3327 later must get it from the catchpoint itself.) */
3328 if (ep
->triggered_dll_pathname
!= NULL
)
3329 xfree (ep
->triggered_dll_pathname
);
3330 if (ep
->type
== bp_catch_load
)
3331 dll_pathname
= SOLIB_LOADED_LIBRARY_PATHNAME (
3332 PIDGET (inferior_ptid
));
3334 dll_pathname
= SOLIB_UNLOADED_LIBRARY_PATHNAME (
3335 PIDGET (inferior_ptid
));
3337 dll_pathname
= NULL
;
3341 ep
->triggered_dll_pathname
= (char *)
3342 xmalloc (strlen (dll_pathname
) + 1);
3343 strcpy (ep
->triggered_dll_pathname
, dll_pathname
);
3346 ep
->triggered_dll_pathname
= NULL
;
3352 /* Print B to gdb_stdout. */
3354 print_one_breakpoint (struct breakpoint
*b
,
3355 CORE_ADDR
*last_addr
)
3357 struct command_line
*l
;
3359 struct ep_type_description
3364 static struct ep_type_description bptypes
[] =
3366 {bp_none
, "?deleted?"},
3367 {bp_breakpoint
, "breakpoint"},
3368 {bp_hardware_breakpoint
, "hw breakpoint"},
3369 {bp_until
, "until"},
3370 {bp_finish
, "finish"},
3371 {bp_watchpoint
, "watchpoint"},
3372 {bp_hardware_watchpoint
, "hw watchpoint"},
3373 {bp_read_watchpoint
, "read watchpoint"},
3374 {bp_access_watchpoint
, "acc watchpoint"},
3375 {bp_longjmp
, "longjmp"},
3376 {bp_longjmp_resume
, "longjmp resume"},
3377 {bp_step_resume
, "step resume"},
3378 {bp_through_sigtramp
, "sigtramp"},
3379 {bp_watchpoint_scope
, "watchpoint scope"},
3380 {bp_call_dummy
, "call dummy"},
3381 {bp_shlib_event
, "shlib events"},
3382 {bp_thread_event
, "thread events"},
3383 {bp_overlay_event
, "overlay events"},
3384 {bp_catch_load
, "catch load"},
3385 {bp_catch_unload
, "catch unload"},
3386 {bp_catch_fork
, "catch fork"},
3387 {bp_catch_vfork
, "catch vfork"},
3388 {bp_catch_exec
, "catch exec"},
3389 {bp_catch_catch
, "catch catch"},
3390 {bp_catch_throw
, "catch throw"}
3393 static char *bpdisps
[] =
3394 {"del", "dstp", "dis", "keep"};
3395 static char bpenables
[] = "nynny";
3396 char wrap_indent
[80];
3397 struct ui_stream
*stb
= ui_out_stream_new (uiout
);
3398 struct cleanup
*old_chain
= make_cleanup_ui_out_stream_delete (stb
);
3399 struct cleanup
*bkpt_chain
;
3402 bkpt_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "bkpt");
3406 ui_out_field_int (uiout
, "number", b
->number
);
3410 if (((int) b
->type
> (sizeof (bptypes
) / sizeof (bptypes
[0])))
3411 || ((int) b
->type
!= bptypes
[(int) b
->type
].type
))
3412 internal_error (__FILE__
, __LINE__
,
3413 _("bptypes table does not describe type #%d."),
3415 ui_out_field_string (uiout
, "type", bptypes
[(int) b
->type
].description
);
3419 ui_out_field_string (uiout
, "disp", bpdisps
[(int) b
->disposition
]);
3423 ui_out_field_fmt (uiout
, "enabled", "%c", bpenables
[(int) b
->enable_state
]);
3424 ui_out_spaces (uiout
, 2);
3427 strcpy (wrap_indent
, " ");
3430 if (TARGET_ADDR_BIT
<= 32)
3431 strcat (wrap_indent
, " ");
3433 strcat (wrap_indent
, " ");
3436 if (b
->ops
!= NULL
&& b
->ops
->print_one
!= NULL
)
3437 b
->ops
->print_one (b
, last_addr
);
3442 internal_error (__FILE__
, __LINE__
,
3443 _("print_one_breakpoint: bp_none encountered\n"));
3447 case bp_hardware_watchpoint
:
3448 case bp_read_watchpoint
:
3449 case bp_access_watchpoint
:
3450 /* Field 4, the address, is omitted (which makes the columns
3451 not line up too nicely with the headers, but the effect
3452 is relatively readable). */
3454 ui_out_field_skip (uiout
, "addr");
3456 print_expression (b
->exp
, stb
->stream
);
3457 ui_out_field_stream (uiout
, "what", stb
);
3461 case bp_catch_unload
:
3462 /* Field 4, the address, is omitted (which makes the columns
3463 not line up too nicely with the headers, but the effect
3464 is relatively readable). */
3466 ui_out_field_skip (uiout
, "addr");
3468 if (b
->dll_pathname
== NULL
)
3470 ui_out_field_string (uiout
, "what", "<any library>");
3471 ui_out_spaces (uiout
, 1);
3475 ui_out_text (uiout
, "library \"");
3476 ui_out_field_string (uiout
, "what", b
->dll_pathname
);
3477 ui_out_text (uiout
, "\" ");
3482 case bp_catch_vfork
:
3483 /* Field 4, the address, is omitted (which makes the columns
3484 not line up too nicely with the headers, but the effect
3485 is relatively readable). */
3487 ui_out_field_skip (uiout
, "addr");
3489 if (b
->forked_inferior_pid
!= 0)
3491 ui_out_text (uiout
, "process ");
3492 ui_out_field_int (uiout
, "what", b
->forked_inferior_pid
);
3493 ui_out_spaces (uiout
, 1);
3498 /* Field 4, the address, is omitted (which makes the columns
3499 not line up too nicely with the headers, but the effect
3500 is relatively readable). */
3502 ui_out_field_skip (uiout
, "addr");
3504 if (b
->exec_pathname
!= NULL
)
3506 ui_out_text (uiout
, "program \"");
3507 ui_out_field_string (uiout
, "what", b
->exec_pathname
);
3508 ui_out_text (uiout
, "\" ");
3512 case bp_catch_catch
:
3513 /* Field 4, the address, is omitted (which makes the columns
3514 not line up too nicely with the headers, but the effect
3515 is relatively readable). */
3517 ui_out_field_skip (uiout
, "addr");
3519 ui_out_field_string (uiout
, "what", "exception catch");
3520 ui_out_spaces (uiout
, 1);
3523 case bp_catch_throw
:
3524 /* Field 4, the address, is omitted (which makes the columns
3525 not line up too nicely with the headers, but the effect
3526 is relatively readable). */
3528 ui_out_field_skip (uiout
, "addr");
3530 ui_out_field_string (uiout
, "what", "exception throw");
3531 ui_out_spaces (uiout
, 1);
3535 case bp_hardware_breakpoint
:
3539 case bp_longjmp_resume
:
3540 case bp_step_resume
:
3541 case bp_through_sigtramp
:
3542 case bp_watchpoint_scope
:
3544 case bp_shlib_event
:
3545 case bp_thread_event
:
3546 case bp_overlay_event
:
3551 ui_out_field_string (uiout
, "addr", "<PENDING>");
3553 ui_out_field_core_addr (uiout
, "addr", b
->loc
->address
);
3556 *last_addr
= b
->loc
->address
;
3559 sym
= find_pc_sect_function (b
->loc
->address
, b
->loc
->section
);
3562 ui_out_text (uiout
, "in ");
3563 ui_out_field_string (uiout
, "func",
3564 SYMBOL_PRINT_NAME (sym
));
3565 ui_out_wrap_hint (uiout
, wrap_indent
);
3566 ui_out_text (uiout
, " at ");
3568 ui_out_field_string (uiout
, "file", b
->source_file
);
3569 ui_out_text (uiout
, ":");
3571 if (ui_out_is_mi_like_p (uiout
))
3573 struct symtab_and_line sal
= find_pc_line (b
->loc
->address
, 0);
3574 char *fullname
= symtab_to_fullname (sal
.symtab
);
3577 ui_out_field_string (uiout
, "fullname", fullname
);
3580 ui_out_field_int (uiout
, "line", b
->line_number
);
3582 else if (b
->pending
)
3584 ui_out_field_string (uiout
, "pending", b
->addr_string
);
3588 print_address_symbolic (b
->loc
->address
, stb
->stream
, demangle
, "");
3589 ui_out_field_stream (uiout
, "at", stb
);
3594 if (b
->thread
!= -1)
3596 /* FIXME: This seems to be redundant and lost here; see the
3597 "stop only in" line a little further down. */
3598 ui_out_text (uiout
, " thread ");
3599 ui_out_field_int (uiout
, "thread", b
->thread
);
3602 ui_out_text (uiout
, "\n");
3604 if (frame_id_p (b
->frame_id
))
3607 ui_out_text (uiout
, "\tstop only in stack frame at ");
3608 /* FIXME: cagney/2002-12-01: Shouldn't be poeking around inside
3610 ui_out_field_core_addr (uiout
, "frame", b
->frame_id
.stack_addr
);
3611 ui_out_text (uiout
, "\n");
3614 if (b
->cond
&& !ada_exception_catchpoint_p (b
))
3616 /* We do not print the condition for Ada exception catchpoints
3617 because the condition is an internal implementation detail
3618 that we do not want to expose to the user. */
3620 ui_out_text (uiout
, "\tstop only if ");
3621 print_expression (b
->cond
, stb
->stream
);
3622 ui_out_field_stream (uiout
, "cond", stb
);
3623 ui_out_text (uiout
, "\n");
3626 if (b
->pending
&& b
->cond_string
)
3629 ui_out_text (uiout
, "\tstop only if ");
3630 ui_out_field_string (uiout
, "cond", b
->cond_string
);
3631 ui_out_text (uiout
, "\n");
3634 if (b
->thread
!= -1)
3636 /* FIXME should make an annotation for this */
3637 ui_out_text (uiout
, "\tstop only in thread ");
3638 ui_out_field_int (uiout
, "thread", b
->thread
);
3639 ui_out_text (uiout
, "\n");
3642 if (show_breakpoint_hit_counts
&& b
->hit_count
)
3644 /* FIXME should make an annotation for this */
3645 if (ep_is_catchpoint (b
))
3646 ui_out_text (uiout
, "\tcatchpoint");
3648 ui_out_text (uiout
, "\tbreakpoint");
3649 ui_out_text (uiout
, " already hit ");
3650 ui_out_field_int (uiout
, "times", b
->hit_count
);
3651 if (b
->hit_count
== 1)
3652 ui_out_text (uiout
, " time\n");
3654 ui_out_text (uiout
, " times\n");
3657 /* Output the count also if it is zero, but only if this is
3658 mi. FIXME: Should have a better test for this. */
3659 if (ui_out_is_mi_like_p (uiout
))
3660 if (show_breakpoint_hit_counts
&& b
->hit_count
== 0)
3661 ui_out_field_int (uiout
, "times", b
->hit_count
);
3663 if (b
->ignore_count
)
3666 ui_out_text (uiout
, "\tignore next ");
3667 ui_out_field_int (uiout
, "ignore", b
->ignore_count
);
3668 ui_out_text (uiout
, " hits\n");
3671 if ((l
= b
->commands
))
3673 struct cleanup
*script_chain
;
3676 script_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "script");
3677 print_command_lines (uiout
, l
, 4);
3678 do_cleanups (script_chain
);
3680 do_cleanups (bkpt_chain
);
3681 do_cleanups (old_chain
);
3684 struct captured_breakpoint_query_args
3690 do_captured_breakpoint_query (struct ui_out
*uiout
, void *data
)
3692 struct captured_breakpoint_query_args
*args
= data
;
3693 struct breakpoint
*b
;
3694 CORE_ADDR dummy_addr
= 0;
3697 if (args
->bnum
== b
->number
)
3699 print_one_breakpoint (b
, &dummy_addr
);
3707 gdb_breakpoint_query (struct ui_out
*uiout
, int bnum
, char **error_message
)
3709 struct captured_breakpoint_query_args args
;
3711 /* For the moment we don't trust print_one_breakpoint() to not throw
3713 return catch_exceptions_with_msg (uiout
, do_captured_breakpoint_query
, &args
,
3714 error_message
, RETURN_MASK_ALL
);
3717 /* Return non-zero if B is user settable (breakpoints, watchpoints,
3718 catchpoints, et.al.). */
3721 user_settable_breakpoint (const struct breakpoint
*b
)
3723 return (b
->type
== bp_breakpoint
3724 || b
->type
== bp_catch_load
3725 || b
->type
== bp_catch_unload
3726 || b
->type
== bp_catch_fork
3727 || b
->type
== bp_catch_vfork
3728 || b
->type
== bp_catch_exec
3729 || b
->type
== bp_catch_catch
3730 || b
->type
== bp_catch_throw
3731 || b
->type
== bp_hardware_breakpoint
3732 || b
->type
== bp_watchpoint
3733 || b
->type
== bp_read_watchpoint
3734 || b
->type
== bp_access_watchpoint
3735 || b
->type
== bp_hardware_watchpoint
);
3738 /* Print information on user settable breakpoint (watchpoint, etc)
3739 number BNUM. If BNUM is -1 print all user settable breakpoints.
3740 If ALLFLAG is non-zero, include non- user settable breakpoints. */
3743 breakpoint_1 (int bnum
, int allflag
)
3745 struct breakpoint
*b
;
3746 CORE_ADDR last_addr
= (CORE_ADDR
) -1;
3747 int nr_printable_breakpoints
;
3748 struct cleanup
*bkpttbl_chain
;
3750 /* Compute the number of rows in the table. */
3751 nr_printable_breakpoints
= 0;
3754 || bnum
== b
->number
)
3756 if (allflag
|| user_settable_breakpoint (b
))
3757 nr_printable_breakpoints
++;
3762 = make_cleanup_ui_out_table_begin_end (uiout
, 6, nr_printable_breakpoints
,
3766 = make_cleanup_ui_out_table_begin_end (uiout
, 5, nr_printable_breakpoints
,
3769 if (nr_printable_breakpoints
> 0)
3770 annotate_breakpoints_headers ();
3771 if (nr_printable_breakpoints
> 0)
3773 ui_out_table_header (uiout
, 3, ui_left
, "number", "Num"); /* 1 */
3774 if (nr_printable_breakpoints
> 0)
3776 ui_out_table_header (uiout
, 14, ui_left
, "type", "Type"); /* 2 */
3777 if (nr_printable_breakpoints
> 0)
3779 ui_out_table_header (uiout
, 4, ui_left
, "disp", "Disp"); /* 3 */
3780 if (nr_printable_breakpoints
> 0)
3782 ui_out_table_header (uiout
, 3, ui_left
, "enabled", "Enb"); /* 4 */
3785 if (nr_printable_breakpoints
> 0)
3787 if (TARGET_ADDR_BIT
<= 32)
3788 ui_out_table_header (uiout
, 10, ui_left
, "addr", "Address");/* 5 */
3790 ui_out_table_header (uiout
, 18, ui_left
, "addr", "Address");/* 5 */
3792 if (nr_printable_breakpoints
> 0)
3794 ui_out_table_header (uiout
, 40, ui_noalign
, "what", "What"); /* 6 */
3795 ui_out_table_body (uiout
);
3796 if (nr_printable_breakpoints
> 0)
3797 annotate_breakpoints_table ();
3801 || bnum
== b
->number
)
3803 /* We only print out user settable breakpoints unless the
3805 if (allflag
|| user_settable_breakpoint (b
))
3806 print_one_breakpoint (b
, &last_addr
);
3809 do_cleanups (bkpttbl_chain
);
3811 if (nr_printable_breakpoints
== 0)
3814 ui_out_message (uiout
, 0, "No breakpoints or watchpoints.\n");
3816 ui_out_message (uiout
, 0, "No breakpoint or watchpoint number %d.\n",
3821 /* Compare against (CORE_ADDR)-1 in case some compiler decides
3822 that a comparison of an unsigned with -1 is always false. */
3823 if (last_addr
!= (CORE_ADDR
) -1)
3824 set_next_address (last_addr
);
3827 /* FIXME? Should this be moved up so that it is only called when
3828 there have been breakpoints? */
3829 annotate_breakpoints_table_end ();
3833 breakpoints_info (char *bnum_exp
, int from_tty
)
3838 bnum
= parse_and_eval_long (bnum_exp
);
3840 breakpoint_1 (bnum
, 0);
3844 maintenance_info_breakpoints (char *bnum_exp
, int from_tty
)
3849 bnum
= parse_and_eval_long (bnum_exp
);
3851 breakpoint_1 (bnum
, 1);
3854 /* Print a message describing any breakpoints set at PC. */
3857 describe_other_breakpoints (CORE_ADDR pc
, asection
*section
, int thread
)
3860 struct breakpoint
*b
;
3863 if (b
->loc
->address
== pc
) /* address match / overlay match */
3864 if (!b
->pending
&& (!overlay_debugging
|| b
->loc
->section
== section
))
3869 printf_filtered (_("Note: breakpoint "));
3870 else /* if (others == ???) */
3871 printf_filtered (_("Note: breakpoints "));
3873 if (b
->loc
->address
== pc
) /* address match / overlay match */
3874 if (!b
->pending
&& (!overlay_debugging
|| b
->loc
->section
== section
))
3877 printf_filtered ("%d", b
->number
);
3878 if (b
->thread
== -1 && thread
!= -1)
3879 printf_filtered (" (all threads)");
3880 else if (b
->thread
!= -1)
3881 printf_filtered (" (thread %d)", b
->thread
);
3882 printf_filtered ("%s%s ",
3883 ((b
->enable_state
== bp_disabled
||
3884 b
->enable_state
== bp_shlib_disabled
||
3885 b
->enable_state
== bp_call_disabled
)
3887 : b
->enable_state
== bp_permanent
3891 : ((others
== 1) ? " and" : ""));
3893 printf_filtered (_("also set at pc "));
3894 deprecated_print_address_numeric (pc
, 1, gdb_stdout
);
3895 printf_filtered (".\n");
3899 /* Set the default place to put a breakpoint
3900 for the `break' command with no arguments. */
3903 set_default_breakpoint (int valid
, CORE_ADDR addr
, struct symtab
*symtab
,
3906 default_breakpoint_valid
= valid
;
3907 default_breakpoint_address
= addr
;
3908 default_breakpoint_symtab
= symtab
;
3909 default_breakpoint_line
= line
;
3912 /* Return true iff it is meaningful to use the address member of
3913 BPT. For some breakpoint types, the address member is irrelevant
3914 and it makes no sense to attempt to compare it to other addresses
3915 (or use it for any other purpose either).
3917 More specifically, each of the following breakpoint types will always
3918 have a zero valued address and we don't want check_duplicates() to mark
3919 breakpoints of any of these types to be a duplicate of an actual
3920 breakpoint at address zero:
3923 bp_hardware_watchpoint
3925 bp_access_watchpoint
3932 breakpoint_address_is_meaningful (struct breakpoint
*bpt
)
3934 enum bptype type
= bpt
->type
;
3936 return (type
!= bp_watchpoint
3937 && type
!= bp_hardware_watchpoint
3938 && type
!= bp_read_watchpoint
3939 && type
!= bp_access_watchpoint
3940 && type
!= bp_catch_exec
3941 && type
!= bp_longjmp_resume
3942 && type
!= bp_catch_fork
3943 && type
!= bp_catch_vfork
);
3946 /* Rescan breakpoints at the same address and section as BPT,
3947 marking the first one as "first" and any others as "duplicates".
3948 This is so that the bpt instruction is only inserted once.
3949 If we have a permanent breakpoint at the same place as BPT, make
3950 that one the official one, and the rest as duplicates. */
3953 check_duplicates (struct breakpoint
*bpt
)
3955 struct bp_location
*b
;
3957 struct bp_location
*perm_bp
= 0;
3958 CORE_ADDR address
= bpt
->loc
->address
;
3959 asection
*section
= bpt
->loc
->section
;
3961 if (! breakpoint_address_is_meaningful (bpt
))
3964 ALL_BP_LOCATIONS (b
)
3965 if (b
->owner
->enable_state
!= bp_disabled
3966 && b
->owner
->enable_state
!= bp_shlib_disabled
3967 && !b
->owner
->pending
3968 && b
->owner
->enable_state
!= bp_call_disabled
3969 && b
->address
== address
/* address / overlay match */
3970 && (!overlay_debugging
|| b
->section
== section
)
3971 && breakpoint_address_is_meaningful (b
->owner
))
3973 /* Have we found a permanent breakpoint? */
3974 if (b
->owner
->enable_state
== bp_permanent
)
3981 b
->duplicate
= count
> 1;
3984 /* If we found a permanent breakpoint at this address, go over the
3985 list again and declare all the other breakpoints there to be the
3989 perm_bp
->duplicate
= 0;
3991 /* Permanent breakpoint should always be inserted. */
3992 if (! perm_bp
->inserted
)
3993 internal_error (__FILE__
, __LINE__
,
3994 _("allegedly permanent breakpoint is not "
3995 "actually inserted"));
3997 ALL_BP_LOCATIONS (b
)
4000 if (b
->owner
->enable_state
!= bp_disabled
4001 && b
->owner
->enable_state
!= bp_shlib_disabled
4002 && !b
->owner
->pending
4003 && b
->owner
->enable_state
!= bp_call_disabled
4004 && b
->address
== address
/* address / overlay match */
4005 && (!overlay_debugging
|| b
->section
== section
)
4006 && breakpoint_address_is_meaningful (b
->owner
))
4009 internal_error (__FILE__
, __LINE__
,
4010 _("another breakpoint was inserted on top of "
4011 "a permanent breakpoint"));
4020 breakpoint_adjustment_warning (CORE_ADDR from_addr
, CORE_ADDR to_addr
,
4021 int bnum
, int have_bnum
)
4026 strcpy (astr1
, hex_string_custom ((unsigned long) from_addr
, 8));
4027 strcpy (astr2
, hex_string_custom ((unsigned long) to_addr
, 8));
4029 warning (_("Breakpoint %d address previously adjusted from %s to %s."),
4030 bnum
, astr1
, astr2
);
4032 warning (_("Breakpoint address adjusted from %s to %s."), astr1
, astr2
);
4035 /* Adjust a breakpoint's address to account for architectural constraints
4036 on breakpoint placement. Return the adjusted address. Note: Very
4037 few targets require this kind of adjustment. For most targets,
4038 this function is simply the identity function. */
4041 adjust_breakpoint_address (CORE_ADDR bpaddr
, enum bptype bptype
)
4043 if (!gdbarch_adjust_breakpoint_address_p (current_gdbarch
))
4045 /* Very few targets need any kind of breakpoint adjustment. */
4048 else if (bptype
== bp_watchpoint
4049 || bptype
== bp_hardware_watchpoint
4050 || bptype
== bp_read_watchpoint
4051 || bptype
== bp_access_watchpoint
4052 || bptype
== bp_catch_fork
4053 || bptype
== bp_catch_vfork
4054 || bptype
== bp_catch_exec
)
4056 /* Watchpoints and the various bp_catch_* eventpoints should not
4057 have their addresses modified. */
4062 CORE_ADDR adjusted_bpaddr
;
4064 /* Some targets have architectural constraints on the placement
4065 of breakpoint instructions. Obtain the adjusted address. */
4066 adjusted_bpaddr
= gdbarch_adjust_breakpoint_address (current_gdbarch
,
4069 /* An adjusted breakpoint address can significantly alter
4070 a user's expectations. Print a warning if an adjustment
4072 if (adjusted_bpaddr
!= bpaddr
)
4073 breakpoint_adjustment_warning (bpaddr
, adjusted_bpaddr
, 0, 0);
4075 return adjusted_bpaddr
;
4079 /* Allocate a struct bp_location. */
4081 static struct bp_location
*
4082 allocate_bp_location (struct breakpoint
*bpt
, enum bptype bp_type
)
4084 struct bp_location
*loc
, *loc_p
;
4086 loc
= xmalloc (sizeof (struct bp_location
));
4087 memset (loc
, 0, sizeof (*loc
));
4097 case bp_longjmp_resume
:
4098 case bp_step_resume
:
4099 case bp_through_sigtramp
:
4100 case bp_watchpoint_scope
:
4102 case bp_shlib_event
:
4103 case bp_thread_event
:
4104 case bp_overlay_event
:
4106 case bp_catch_unload
:
4107 loc
->loc_type
= bp_loc_software_breakpoint
;
4109 case bp_hardware_breakpoint
:
4110 loc
->loc_type
= bp_loc_hardware_breakpoint
;
4112 case bp_hardware_watchpoint
:
4113 case bp_read_watchpoint
:
4114 case bp_access_watchpoint
:
4115 loc
->loc_type
= bp_loc_hardware_watchpoint
;
4119 case bp_catch_vfork
:
4121 case bp_catch_catch
:
4122 case bp_catch_throw
:
4123 loc
->loc_type
= bp_loc_other
;
4126 internal_error (__FILE__
, __LINE__
, _("unknown breakpoint type"));
4129 /* Add this breakpoint to the end of the chain. */
4131 loc_p
= bp_location_chain
;
4133 bp_location_chain
= loc
;
4137 loc_p
= loc_p
->next
;
4144 /* set_raw_breakpoint() is a low level routine for allocating and
4145 partially initializing a breakpoint of type BPTYPE. The newly
4146 created breakpoint's address, section, source file name, and line
4147 number are provided by SAL. The newly created and partially
4148 initialized breakpoint is added to the breakpoint chain and
4149 is also returned as the value of this function.
4151 It is expected that the caller will complete the initialization of
4152 the newly created breakpoint struct as well as output any status
4153 information regarding the creation of a new breakpoint. In
4154 particular, set_raw_breakpoint() does NOT set the breakpoint
4155 number! Care should be taken to not allow an error() to occur
4156 prior to completing the initialization of the breakpoint. If this
4157 should happen, a bogus breakpoint will be left on the chain. */
4160 set_raw_breakpoint (struct symtab_and_line sal
, enum bptype bptype
)
4162 struct breakpoint
*b
, *b1
;
4164 b
= (struct breakpoint
*) xmalloc (sizeof (struct breakpoint
));
4165 memset (b
, 0, sizeof (*b
));
4166 b
->loc
= allocate_bp_location (b
, bptype
);
4167 b
->loc
->requested_address
= sal
.pc
;
4168 b
->loc
->address
= adjust_breakpoint_address (b
->loc
->requested_address
,
4170 if (sal
.symtab
== NULL
)
4171 b
->source_file
= NULL
;
4173 b
->source_file
= savestring (sal
.symtab
->filename
,
4174 strlen (sal
.symtab
->filename
));
4175 b
->loc
->section
= sal
.section
;
4177 b
->language
= current_language
->la_language
;
4178 b
->input_radix
= input_radix
;
4180 b
->line_number
= sal
.line
;
4181 b
->enable_state
= bp_enabled
;
4184 b
->ignore_count
= 0;
4186 b
->frame_id
= null_frame_id
;
4187 b
->dll_pathname
= NULL
;
4188 b
->triggered_dll_pathname
= NULL
;
4189 b
->forked_inferior_pid
= 0;
4190 b
->exec_pathname
= NULL
;
4194 /* Add this breakpoint to the end of the chain
4195 so that a list of breakpoints will come out in order
4196 of increasing numbers. */
4198 b1
= breakpoint_chain
;
4200 breakpoint_chain
= b
;
4208 check_duplicates (b
);
4209 breakpoints_changed ();
4215 /* Note that the breakpoint object B describes a permanent breakpoint
4216 instruction, hard-wired into the inferior's code. */
4218 make_breakpoint_permanent (struct breakpoint
*b
)
4220 b
->enable_state
= bp_permanent
;
4222 /* By definition, permanent breakpoints are already present in the code. */
4223 b
->loc
->inserted
= 1;
4226 static struct breakpoint
*
4227 create_internal_breakpoint (CORE_ADDR address
, enum bptype type
)
4229 static int internal_breakpoint_number
= -1;
4230 struct symtab_and_line sal
;
4231 struct breakpoint
*b
;
4233 init_sal (&sal
); /* initialize to zeroes */
4236 sal
.section
= find_pc_overlay (sal
.pc
);
4238 b
= set_raw_breakpoint (sal
, type
);
4239 b
->number
= internal_breakpoint_number
--;
4240 b
->disposition
= disp_donttouch
;
4247 create_longjmp_breakpoint (char *func_name
)
4249 struct breakpoint
*b
;
4250 struct minimal_symbol
*m
;
4252 if (func_name
== NULL
)
4253 b
= create_internal_breakpoint (0, bp_longjmp_resume
);
4256 if ((m
= lookup_minimal_symbol_text (func_name
, NULL
)) == NULL
)
4259 b
= create_internal_breakpoint (SYMBOL_VALUE_ADDRESS (m
), bp_longjmp
);
4262 b
->enable_state
= bp_disabled
;
4265 b
->addr_string
= xstrdup (func_name
);
4268 /* Call this routine when stepping and nexting to enable a breakpoint
4269 if we do a longjmp(). When we hit that breakpoint, call
4270 set_longjmp_resume_breakpoint() to figure out where we are going. */
4273 enable_longjmp_breakpoint (void)
4275 struct breakpoint
*b
;
4278 if (b
->type
== bp_longjmp
)
4280 b
->enable_state
= bp_enabled
;
4281 check_duplicates (b
);
4286 disable_longjmp_breakpoint (void)
4288 struct breakpoint
*b
;
4291 if (b
->type
== bp_longjmp
4292 || b
->type
== bp_longjmp_resume
)
4294 b
->enable_state
= bp_disabled
;
4295 check_duplicates (b
);
4300 create_overlay_event_breakpoint (char *func_name
)
4302 struct breakpoint
*b
;
4303 struct minimal_symbol
*m
;
4305 if ((m
= lookup_minimal_symbol_text (func_name
, NULL
)) == NULL
)
4308 b
= create_internal_breakpoint (SYMBOL_VALUE_ADDRESS (m
),
4310 b
->addr_string
= xstrdup (func_name
);
4312 if (overlay_debugging
== ovly_auto
)
4314 b
->enable_state
= bp_enabled
;
4315 overlay_events_enabled
= 1;
4319 b
->enable_state
= bp_disabled
;
4320 overlay_events_enabled
= 0;
4325 enable_overlay_breakpoints (void)
4327 struct breakpoint
*b
;
4330 if (b
->type
== bp_overlay_event
)
4332 b
->enable_state
= bp_enabled
;
4333 check_duplicates (b
);
4334 overlay_events_enabled
= 1;
4339 disable_overlay_breakpoints (void)
4341 struct breakpoint
*b
;
4344 if (b
->type
== bp_overlay_event
)
4346 b
->enable_state
= bp_disabled
;
4347 check_duplicates (b
);
4348 overlay_events_enabled
= 0;
4353 create_thread_event_breakpoint (CORE_ADDR address
)
4355 struct breakpoint
*b
;
4357 b
= create_internal_breakpoint (address
, bp_thread_event
);
4359 b
->enable_state
= bp_enabled
;
4360 /* addr_string has to be used or breakpoint_re_set will delete me. */
4361 b
->addr_string
= xstrprintf ("*0x%s", paddr (b
->loc
->address
));
4367 remove_thread_event_breakpoints (void)
4369 struct breakpoint
*b
, *temp
;
4371 ALL_BREAKPOINTS_SAFE (b
, temp
)
4372 if (b
->type
== bp_thread_event
)
4373 delete_breakpoint (b
);
4376 struct captured_parse_breakpoint_args
4379 struct symtabs_and_lines
*sals_p
;
4380 char ***addr_string_p
;
4384 struct lang_and_radix
4390 /* Cleanup helper routine to restore the current language and
4393 do_restore_lang_radix_cleanup (void *old
)
4395 struct lang_and_radix
*p
= old
;
4396 set_language (p
->lang
);
4397 input_radix
= p
->radix
;
4400 /* Try and resolve a pending breakpoint. */
4402 resolve_pending_breakpoint (struct breakpoint
*b
)
4404 /* Try and reparse the breakpoint in case the shared library
4406 struct symtabs_and_lines sals
;
4407 struct symtab_and_line pending_sal
;
4408 char **cond_string
= (char **) NULL
;
4409 char *copy_arg
= b
->addr_string
;
4414 struct ui_file
*old_gdb_stderr
;
4415 struct lang_and_radix old_lr
;
4416 struct cleanup
*old_chain
;
4418 /* Set language, input-radix, then reissue breakpoint command.
4419 Ensure the language and input-radix are restored afterwards. */
4420 old_lr
.lang
= current_language
->la_language
;
4421 old_lr
.radix
= input_radix
;
4422 old_chain
= make_cleanup (do_restore_lang_radix_cleanup
, &old_lr
);
4424 set_language (b
->language
);
4425 input_radix
= b
->input_radix
;
4426 rc
= break_command_1 (b
->addr_string
, b
->flag
, b
->from_tty
, b
);
4428 if (rc
== GDB_RC_OK
)
4429 /* Pending breakpoint has been resolved. */
4430 printf_filtered (_("Pending breakpoint \"%s\" resolved\n"), b
->addr_string
);
4432 do_cleanups (old_chain
);
4437 remove_solib_event_breakpoints (void)
4439 struct breakpoint
*b
, *temp
;
4441 ALL_BREAKPOINTS_SAFE (b
, temp
)
4442 if (b
->type
== bp_shlib_event
)
4443 delete_breakpoint (b
);
4447 create_solib_event_breakpoint (CORE_ADDR address
)
4449 struct breakpoint
*b
;
4451 b
= create_internal_breakpoint (address
, bp_shlib_event
);
4455 /* Disable any breakpoints that are on code in shared libraries. Only
4456 apply to enabled breakpoints, disabled ones can just stay disabled. */
4459 disable_breakpoints_in_shlibs (int silent
)
4461 struct breakpoint
*b
;
4462 int disabled_shlib_breaks
= 0;
4464 /* See also: insert_breakpoints, under DISABLE_UNSETTABLE_BREAK. */
4467 if (((b
->type
== bp_breakpoint
) || (b
->type
== bp_hardware_breakpoint
))
4468 && breakpoint_enabled (b
) && !b
->loc
->duplicate
4470 && PC_SOLIB (b
->loc
->address
)
4472 && solib_address (b
->loc
->address
)
4476 b
->enable_state
= bp_shlib_disabled
;
4479 if (!disabled_shlib_breaks
)
4481 target_terminal_ours_for_output ();
4482 warning (_("Temporarily disabling shared library breakpoints:"));
4484 disabled_shlib_breaks
= 1;
4485 warning (_("breakpoint #%d "), b
->number
);
4491 /* Disable any breakpoints that are in in an unloaded shared library. Only
4492 apply to enabled breakpoints, disabled ones can just stay disabled. */
4495 disable_breakpoints_in_unloaded_shlib (struct so_list
*solib
)
4497 struct breakpoint
*b
;
4498 int disabled_shlib_breaks
= 0;
4500 /* See also: insert_breakpoints, under DISABLE_UNSETTABLE_BREAK. */
4503 if ((b
->loc
->loc_type
== bp_loc_hardware_breakpoint
4504 || b
->loc
->loc_type
== bp_loc_software_breakpoint
)
4505 && breakpoint_enabled (b
) && !b
->loc
->duplicate
)
4508 char *so_name
= PC_SOLIB (b
->loc
->address
);
4510 char *so_name
= solib_address (b
->loc
->address
);
4512 if (so_name
&& !strcmp (so_name
, solib
->so_name
))
4514 b
->enable_state
= bp_shlib_disabled
;
4515 /* At this point, we cannot rely on remove_breakpoint
4516 succeeding so we must mark the breakpoint as not inserted
4517 to prevent future errors occurring in remove_breakpoints. */
4518 b
->loc
->inserted
= 0;
4519 if (!disabled_shlib_breaks
)
4521 target_terminal_ours_for_output ();
4522 warning (_("Temporarily disabling breakpoints for unloaded shared library \"%s\""),
4525 disabled_shlib_breaks
= 1;
4531 /* Try to reenable any breakpoints in shared libraries. */
4533 re_enable_breakpoints_in_shlibs (void)
4535 struct breakpoint
*b
, *tmp
;
4537 ALL_BREAKPOINTS_SAFE (b
, tmp
)
4539 if (b
->enable_state
== bp_shlib_disabled
)
4544 /* Do not reenable the breakpoint if the shared library is
4545 still not mapped in. */
4547 lib
= PC_SOLIB (b
->loc
->address
);
4549 lib
= solib_address (b
->loc
->address
);
4551 if (lib
!= NULL
&& target_read_memory (b
->loc
->address
, buf
, 1) == 0)
4552 b
->enable_state
= bp_enabled
;
4554 else if (b
->pending
&& (b
->enable_state
== bp_enabled
))
4556 if (resolve_pending_breakpoint (b
) == GDB_RC_OK
)
4557 delete_breakpoint (b
);
4563 solib_load_unload_1 (char *hookname
, int tempflag
, char *dll_pathname
,
4564 char *cond_string
, enum bptype bp_kind
)
4566 struct breakpoint
*b
;
4567 struct symtabs_and_lines sals
;
4568 struct cleanup
*old_chain
;
4569 struct cleanup
*canonical_strings_chain
= NULL
;
4570 char *addr_start
= hookname
;
4571 char *addr_end
= NULL
;
4572 char **canonical
= (char **) NULL
;
4573 int thread
= -1; /* All threads. */
4575 /* Set a breakpoint on the specified hook. */
4576 sals
= decode_line_1 (&hookname
, 1, (struct symtab
*) NULL
,
4577 0, &canonical
, NULL
);
4578 addr_end
= hookname
;
4580 if (sals
.nelts
== 0)
4582 warning (_("Unable to set a breakpoint on dynamic linker callback.\n"
4583 "Suggest linking with /opt/langtools/lib/end.o.\n"
4584 "GDB will be unable to track shl_load/shl_unload calls."));
4587 if (sals
.nelts
!= 1)
4589 warning (_("Unable to set unique breakpoint on dynamic linker callback.\n"
4590 "GDB will be unable to track shl_load/shl_unload calls."));
4594 /* Make sure that all storage allocated in decode_line_1 gets freed
4595 in case the following errors out. */
4596 old_chain
= make_cleanup (xfree
, sals
.sals
);
4597 if (canonical
!= (char **) NULL
)
4599 make_cleanup (xfree
, canonical
);
4600 canonical_strings_chain
= make_cleanup (null_cleanup
, 0);
4601 if (canonical
[0] != NULL
)
4602 make_cleanup (xfree
, canonical
[0]);
4605 resolve_sal_pc (&sals
.sals
[0]);
4607 /* Remove the canonical strings from the cleanup, they are needed below. */
4608 if (canonical
!= (char **) NULL
)
4609 discard_cleanups (canonical_strings_chain
);
4611 b
= set_raw_breakpoint (sals
.sals
[0], bp_kind
);
4612 set_breakpoint_count (breakpoint_count
+ 1);
4613 b
->number
= breakpoint_count
;
4615 b
->cond_string
= (cond_string
== NULL
) ?
4616 NULL
: savestring (cond_string
, strlen (cond_string
));
4619 if (canonical
!= (char **) NULL
&& canonical
[0] != NULL
)
4620 b
->addr_string
= canonical
[0];
4621 else if (addr_start
)
4622 b
->addr_string
= savestring (addr_start
, addr_end
- addr_start
);
4624 b
->enable_state
= bp_enabled
;
4625 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
4627 if (dll_pathname
== NULL
)
4628 b
->dll_pathname
= NULL
;
4631 b
->dll_pathname
= (char *) xmalloc (strlen (dll_pathname
) + 1);
4632 strcpy (b
->dll_pathname
, dll_pathname
);
4636 do_cleanups (old_chain
);
4640 create_solib_load_event_breakpoint (char *hookname
, int tempflag
,
4641 char *dll_pathname
, char *cond_string
)
4643 solib_load_unload_1 (hookname
, tempflag
, dll_pathname
,
4644 cond_string
, bp_catch_load
);
4648 create_solib_unload_event_breakpoint (char *hookname
, int tempflag
,
4649 char *dll_pathname
, char *cond_string
)
4651 solib_load_unload_1 (hookname
, tempflag
, dll_pathname
,
4652 cond_string
, bp_catch_unload
);
4656 create_fork_vfork_event_catchpoint (int tempflag
, char *cond_string
,
4657 enum bptype bp_kind
)
4659 struct symtab_and_line sal
;
4660 struct breakpoint
*b
;
4661 int thread
= -1; /* All threads. */
4668 b
= set_raw_breakpoint (sal
, bp_kind
);
4669 set_breakpoint_count (breakpoint_count
+ 1);
4670 b
->number
= breakpoint_count
;
4672 b
->cond_string
= (cond_string
== NULL
) ?
4673 NULL
: savestring (cond_string
, strlen (cond_string
));
4675 b
->addr_string
= NULL
;
4676 b
->enable_state
= bp_enabled
;
4677 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
4678 b
->forked_inferior_pid
= 0;
4684 create_fork_event_catchpoint (int tempflag
, char *cond_string
)
4686 create_fork_vfork_event_catchpoint (tempflag
, cond_string
, bp_catch_fork
);
4690 create_vfork_event_catchpoint (int tempflag
, char *cond_string
)
4692 create_fork_vfork_event_catchpoint (tempflag
, cond_string
, bp_catch_vfork
);
4696 create_exec_event_catchpoint (int tempflag
, char *cond_string
)
4698 struct symtab_and_line sal
;
4699 struct breakpoint
*b
;
4700 int thread
= -1; /* All threads. */
4707 b
= set_raw_breakpoint (sal
, bp_catch_exec
);
4708 set_breakpoint_count (breakpoint_count
+ 1);
4709 b
->number
= breakpoint_count
;
4711 b
->cond_string
= (cond_string
== NULL
) ?
4712 NULL
: savestring (cond_string
, strlen (cond_string
));
4714 b
->addr_string
= NULL
;
4715 b
->enable_state
= bp_enabled
;
4716 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
4722 hw_breakpoint_used_count (void)
4724 struct breakpoint
*b
;
4729 if (b
->type
== bp_hardware_breakpoint
&& b
->enable_state
== bp_enabled
)
4737 hw_watchpoint_used_count (enum bptype type
, int *other_type_used
)
4739 struct breakpoint
*b
;
4742 *other_type_used
= 0;
4745 if (breakpoint_enabled (b
))
4747 if (b
->type
== type
)
4749 else if ((b
->type
== bp_hardware_watchpoint
||
4750 b
->type
== bp_read_watchpoint
||
4751 b
->type
== bp_access_watchpoint
))
4752 *other_type_used
= 1;
4758 /* Call this after hitting the longjmp() breakpoint. Use this to set
4759 a new breakpoint at the target of the jmp_buf.
4761 FIXME - This ought to be done by setting a temporary breakpoint
4762 that gets deleted automatically... */
4765 set_longjmp_resume_breakpoint (CORE_ADDR pc
, struct frame_id frame_id
)
4767 struct breakpoint
*b
;
4770 if (b
->type
== bp_longjmp_resume
)
4772 b
->loc
->requested_address
= pc
;
4773 b
->loc
->address
= adjust_breakpoint_address (b
->loc
->requested_address
,
4775 b
->enable_state
= bp_enabled
;
4776 b
->frame_id
= frame_id
;
4777 check_duplicates (b
);
4783 disable_watchpoints_before_interactive_call_start (void)
4785 struct breakpoint
*b
;
4789 if (((b
->type
== bp_watchpoint
)
4790 || (b
->type
== bp_hardware_watchpoint
)
4791 || (b
->type
== bp_read_watchpoint
)
4792 || (b
->type
== bp_access_watchpoint
)
4793 || ep_is_exception_catchpoint (b
))
4794 && breakpoint_enabled (b
))
4796 b
->enable_state
= bp_call_disabled
;
4797 check_duplicates (b
);
4803 enable_watchpoints_after_interactive_call_stop (void)
4805 struct breakpoint
*b
;
4809 if (((b
->type
== bp_watchpoint
)
4810 || (b
->type
== bp_hardware_watchpoint
)
4811 || (b
->type
== bp_read_watchpoint
)
4812 || (b
->type
== bp_access_watchpoint
)
4813 || ep_is_exception_catchpoint (b
))
4814 && (b
->enable_state
== bp_call_disabled
))
4816 b
->enable_state
= bp_enabled
;
4817 check_duplicates (b
);
4823 /* Set a breakpoint that will evaporate an end of command
4824 at address specified by SAL.
4825 Restrict it to frame FRAME if FRAME is nonzero. */
4828 set_momentary_breakpoint (struct symtab_and_line sal
, struct frame_id frame_id
,
4831 struct breakpoint
*b
;
4832 b
= set_raw_breakpoint (sal
, type
);
4833 b
->enable_state
= bp_enabled
;
4834 b
->disposition
= disp_donttouch
;
4835 b
->frame_id
= frame_id
;
4837 /* If we're debugging a multi-threaded program, then we
4838 want momentary breakpoints to be active in only a
4839 single thread of control. */
4840 if (in_thread_list (inferior_ptid
))
4841 b
->thread
= pid_to_thread_id (inferior_ptid
);
4847 /* Tell the user we have just set a breakpoint B. */
4850 mention (struct breakpoint
*b
)
4853 struct cleanup
*old_chain
, *ui_out_chain
;
4854 struct ui_stream
*stb
;
4856 stb
= ui_out_stream_new (uiout
);
4857 old_chain
= make_cleanup_ui_out_stream_delete (stb
);
4859 /* FIXME: This is misplaced; mention() is called by things (like
4860 hitting a watchpoint) other than breakpoint creation. It should
4861 be possible to clean this up and at the same time replace the
4862 random calls to breakpoint_changed with this hook, as has already
4863 been done for deprecated_delete_breakpoint_hook and so on. */
4864 if (deprecated_create_breakpoint_hook
)
4865 deprecated_create_breakpoint_hook (b
);
4866 breakpoint_create_event (b
->number
);
4868 if (b
->ops
!= NULL
&& b
->ops
->print_mention
!= NULL
)
4869 b
->ops
->print_mention (b
);
4874 printf_filtered (_("(apparently deleted?) Eventpoint %d: "), b
->number
);
4877 ui_out_text (uiout
, "Watchpoint ");
4878 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "wpt");
4879 ui_out_field_int (uiout
, "number", b
->number
);
4880 ui_out_text (uiout
, ": ");
4881 print_expression (b
->exp
, stb
->stream
);
4882 ui_out_field_stream (uiout
, "exp", stb
);
4883 do_cleanups (ui_out_chain
);
4885 case bp_hardware_watchpoint
:
4886 ui_out_text (uiout
, "Hardware watchpoint ");
4887 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "wpt");
4888 ui_out_field_int (uiout
, "number", b
->number
);
4889 ui_out_text (uiout
, ": ");
4890 print_expression (b
->exp
, stb
->stream
);
4891 ui_out_field_stream (uiout
, "exp", stb
);
4892 do_cleanups (ui_out_chain
);
4894 case bp_read_watchpoint
:
4895 ui_out_text (uiout
, "Hardware read watchpoint ");
4896 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "hw-rwpt");
4897 ui_out_field_int (uiout
, "number", b
->number
);
4898 ui_out_text (uiout
, ": ");
4899 print_expression (b
->exp
, stb
->stream
);
4900 ui_out_field_stream (uiout
, "exp", stb
);
4901 do_cleanups (ui_out_chain
);
4903 case bp_access_watchpoint
:
4904 ui_out_text (uiout
, "Hardware access (read/write) watchpoint ");
4905 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "hw-awpt");
4906 ui_out_field_int (uiout
, "number", b
->number
);
4907 ui_out_text (uiout
, ": ");
4908 print_expression (b
->exp
, stb
->stream
);
4909 ui_out_field_stream (uiout
, "exp", stb
);
4910 do_cleanups (ui_out_chain
);
4913 if (ui_out_is_mi_like_p (uiout
))
4918 printf_filtered (_("Breakpoint %d"), b
->number
);
4921 case bp_hardware_breakpoint
:
4922 if (ui_out_is_mi_like_p (uiout
))
4927 printf_filtered (_("Hardware assisted breakpoint %d"), b
->number
);
4931 case bp_catch_unload
:
4932 printf_filtered (_("Catchpoint %d (%s %s)"),
4934 (b
->type
== bp_catch_load
) ? "load" : "unload",
4935 (b
->dll_pathname
!= NULL
) ?
4936 b
->dll_pathname
: "<any library>");
4939 case bp_catch_vfork
:
4940 printf_filtered (_("Catchpoint %d (%s)"),
4942 (b
->type
== bp_catch_fork
) ? "fork" : "vfork");
4945 printf_filtered (_("Catchpoint %d (exec)"),
4948 case bp_catch_catch
:
4949 case bp_catch_throw
:
4950 printf_filtered (_("Catchpoint %d (%s)"),
4952 (b
->type
== bp_catch_catch
) ? "catch" : "throw");
4958 case bp_longjmp_resume
:
4959 case bp_step_resume
:
4960 case bp_through_sigtramp
:
4962 case bp_watchpoint_scope
:
4963 case bp_shlib_event
:
4964 case bp_thread_event
:
4965 case bp_overlay_event
:
4971 /* i18n: cagney/2005-02-11: Below needs to be merged into a
4975 printf_filtered (_(" (%s) pending."), b
->addr_string
);
4979 if (addressprint
|| b
->source_file
== NULL
)
4981 printf_filtered (" at ");
4982 deprecated_print_address_numeric (b
->loc
->address
, 1, gdb_stdout
);
4985 printf_filtered (": file %s, line %d.",
4986 b
->source_file
, b
->line_number
);
4989 do_cleanups (old_chain
);
4990 if (ui_out_is_mi_like_p (uiout
))
4992 printf_filtered ("\n");
4996 /* Add SALS.nelts breakpoints to the breakpoint table. For each
4997 SALS.sal[i] breakpoint, include the corresponding ADDR_STRING[i],
4998 COND[i] and COND_STRING[i] values.
5000 The parameter PENDING_BP points to a pending breakpoint that is
5001 the basis of the breakpoints currently being created. The pending
5002 breakpoint may contain a separate condition string or commands
5003 that were added after the initial pending breakpoint was created.
5005 NOTE: If the function succeeds, the caller is expected to cleanup
5006 the arrays ADDR_STRING, COND_STRING, COND and SALS (but not the
5007 array contents). If the function fails (error() is called), the
5008 caller is expected to cleanups both the ADDR_STRING, COND_STRING,
5009 COND and SALS arrays and each of those arrays contents. */
5012 create_breakpoints (struct symtabs_and_lines sals
, char **addr_string
,
5013 struct expression
**cond
, char **cond_string
,
5014 enum bptype type
, enum bpdisp disposition
,
5015 int thread
, int ignore_count
, int from_tty
,
5016 struct breakpoint
*pending_bp
)
5018 if (type
== bp_hardware_breakpoint
)
5020 int i
= hw_breakpoint_used_count ();
5021 int target_resources_ok
=
5022 TARGET_CAN_USE_HARDWARE_WATCHPOINT (bp_hardware_breakpoint
,
5024 if (target_resources_ok
== 0)
5025 error (_("No hardware breakpoint support in the target."));
5026 else if (target_resources_ok
< 0)
5027 error (_("Hardware breakpoints used exceeds limit."));
5030 /* Now set all the breakpoints. */
5033 for (i
= 0; i
< sals
.nelts
; i
++)
5035 struct breakpoint
*b
;
5036 struct symtab_and_line sal
= sals
.sals
[i
];
5039 describe_other_breakpoints (sal
.pc
, sal
.section
, thread
);
5041 b
= set_raw_breakpoint (sal
, type
);
5042 set_breakpoint_count (breakpoint_count
+ 1);
5043 b
->number
= breakpoint_count
;
5047 b
->addr_string
= addr_string
[i
];
5049 /* addr_string has to be used or breakpoint_re_set will delete
5051 b
->addr_string
= xstrprintf ("*0x%s", paddr (b
->loc
->address
));
5052 b
->cond_string
= cond_string
[i
];
5053 b
->ignore_count
= ignore_count
;
5054 b
->enable_state
= bp_enabled
;
5055 b
->disposition
= disposition
;
5056 /* If resolving a pending breakpoint, a check must be made to see if
5057 the user has specified a new condition or commands for the
5058 breakpoint. A new condition will override any condition that was
5059 initially specified with the initial breakpoint command. */
5063 if (pending_bp
->cond_string
)
5065 arg
= pending_bp
->cond_string
;
5066 b
->cond_string
= savestring (arg
, strlen (arg
));
5067 b
->cond
= parse_exp_1 (&arg
, block_for_pc (b
->loc
->address
), 0);
5069 error (_("Junk at end of pending breakpoint condition expression"));
5071 /* If there are commands associated with the breakpoint, they should
5073 if (pending_bp
->commands
)
5074 b
->commands
= copy_command_lines (pending_bp
->commands
);
5076 /* We have to copy over the ignore_count and thread as well. */
5077 b
->ignore_count
= pending_bp
->ignore_count
;
5078 b
->thread
= pending_bp
->thread
;
5085 /* Parse ARG which is assumed to be a SAL specification possibly
5086 followed by conditionals. On return, SALS contains an array of SAL
5087 addresses found. ADDR_STRING contains a vector of (canonical)
5088 address strings. ARG points to the end of the SAL. */
5091 parse_breakpoint_sals (char **address
,
5092 struct symtabs_and_lines
*sals
,
5093 char ***addr_string
,
5096 char *addr_start
= *address
;
5097 *addr_string
= NULL
;
5098 /* If no arg given, or if first arg is 'if ', use the default
5100 if ((*address
) == NULL
5101 || (strncmp ((*address
), "if", 2) == 0 && isspace ((*address
)[2])))
5103 if (default_breakpoint_valid
)
5105 struct symtab_and_line sal
;
5106 init_sal (&sal
); /* initialize to zeroes */
5107 sals
->sals
= (struct symtab_and_line
*)
5108 xmalloc (sizeof (struct symtab_and_line
));
5109 sal
.pc
= default_breakpoint_address
;
5110 sal
.line
= default_breakpoint_line
;
5111 sal
.symtab
= default_breakpoint_symtab
;
5112 sal
.section
= find_pc_overlay (sal
.pc
);
5113 sals
->sals
[0] = sal
;
5117 error (_("No default breakpoint address now."));
5121 /* Force almost all breakpoints to be in terms of the
5122 current_source_symtab (which is decode_line_1's default). This
5123 should produce the results we want almost all of the time while
5124 leaving default_breakpoint_* alone.
5125 ObjC: However, don't match an Objective-C method name which
5126 may have a '+' or '-' succeeded by a '[' */
5128 struct symtab_and_line cursal
= get_current_source_symtab_and_line ();
5130 if (default_breakpoint_valid
5132 || ((strchr ("+-", (*address
)[0]) != NULL
)
5133 && ((*address
)[1] != '['))))
5134 *sals
= decode_line_1 (address
, 1, default_breakpoint_symtab
,
5135 default_breakpoint_line
, addr_string
,
5138 *sals
= decode_line_1 (address
, 1, (struct symtab
*) NULL
, 0,
5139 addr_string
, not_found_ptr
);
5141 /* For any SAL that didn't have a canonical string, fill one in. */
5142 if (sals
->nelts
> 0 && *addr_string
== NULL
)
5143 *addr_string
= xcalloc (sals
->nelts
, sizeof (char **));
5144 if (addr_start
!= (*address
))
5147 for (i
= 0; i
< sals
->nelts
; i
++)
5149 /* Add the string if not present. */
5150 if ((*addr_string
)[i
] == NULL
)
5151 (*addr_string
)[i
] = savestring (addr_start
, (*address
) - addr_start
);
5157 /* Convert each SAL into a real PC. Verify that the PC can be
5158 inserted as a breakpoint. If it can't throw an error. */
5161 breakpoint_sals_to_pc (struct symtabs_and_lines
*sals
,
5165 for (i
= 0; i
< sals
->nelts
; i
++)
5167 resolve_sal_pc (&sals
->sals
[i
]);
5169 /* It's possible for the PC to be nonzero, but still an illegal
5170 value on some targets.
5172 For example, on HP-UX if you start gdb, and before running the
5173 inferior you try to set a breakpoint on a shared library function
5174 "foo" where the inferior doesn't call "foo" directly but does
5175 pass its address to another function call, then we do find a
5176 minimal symbol for the "foo", but it's address is invalid.
5177 (Appears to be an index into a table that the loader sets up
5178 when the inferior is run.)
5180 Give the target a chance to bless sals.sals[i].pc before we
5181 try to make a breakpoint for it. */
5182 #ifdef DEPRECATED_PC_REQUIRES_RUN_BEFORE_USE
5183 if (DEPRECATED_PC_REQUIRES_RUN_BEFORE_USE (sals
->sals
[i
].pc
))
5185 if (address
== NULL
)
5186 error (_("Cannot break without a running program."));
5188 error (_("Cannot break on %s without a running program."),
5196 do_captured_parse_breakpoint (struct ui_out
*ui
, void *data
)
5198 struct captured_parse_breakpoint_args
*args
= data
;
5200 parse_breakpoint_sals (args
->arg_p
, args
->sals_p
, args
->addr_string_p
,
5201 args
->not_found_ptr
);
5204 /* Set a breakpoint according to ARG (function, linenum or *address)
5205 flag: first bit : 0 non-temporary, 1 temporary.
5206 second bit : 0 normal breakpoint, 1 hardware breakpoint.
5208 PENDING_BP is non-NULL when this function is being called to resolve
5209 a pending breakpoint. */
5212 break_command_1 (char *arg
, int flag
, int from_tty
, struct breakpoint
*pending_bp
)
5214 struct gdb_exception e
;
5215 int tempflag
, hardwareflag
;
5216 struct symtabs_and_lines sals
;
5217 struct expression
**cond
= 0;
5218 struct symtab_and_line pending_sal
;
5219 char **cond_string
= (char **) NULL
;
5222 char *addr_start
= arg
;
5224 struct cleanup
*old_chain
;
5225 struct cleanup
*breakpoint_chain
= NULL
;
5226 struct captured_parse_breakpoint_args parse_args
;
5230 int ignore_count
= 0;
5233 hardwareflag
= flag
& BP_HARDWAREFLAG
;
5234 tempflag
= flag
& BP_TEMPFLAG
;
5240 parse_args
.arg_p
= &arg
;
5241 parse_args
.sals_p
= &sals
;
5242 parse_args
.addr_string_p
= &addr_string
;
5243 parse_args
.not_found_ptr
= ¬_found
;
5245 e
= catch_exception (uiout
, do_captured_parse_breakpoint
,
5246 &parse_args
, RETURN_MASK_ALL
);
5248 /* If caller is interested in rc value from parse, set value. */
5252 exception_print (gdb_stderr
, e
);
5257 case NOT_FOUND_ERROR
:
5258 /* If called to resolve pending breakpoint, just return
5263 exception_print (gdb_stderr
, e
);
5265 /* If pending breakpoint support is turned off, throw
5268 if (pending_break_support
== AUTO_BOOLEAN_FALSE
)
5269 deprecated_throw_reason (RETURN_ERROR
);
5271 /* If pending breakpoint support is auto query and the user
5272 selects no, then simply return the error code. */
5273 if (pending_break_support
== AUTO_BOOLEAN_AUTO
&&
5274 !nquery ("Make breakpoint pending on future shared library load? "))
5277 /* At this point, either the user was queried about setting
5278 a pending breakpoint and selected yes, or pending
5279 breakpoint behavior is on and thus a pending breakpoint
5280 is defaulted on behalf of the user. */
5281 copy_arg
= xstrdup (addr_start
);
5282 addr_string
= ©_arg
;
5284 sals
.sals
= &pending_sal
;
5289 exception_print (gdb_stderr
, e
);
5297 /* Create a chain of things that always need to be cleaned up. */
5298 old_chain
= make_cleanup (null_cleanup
, 0);
5302 /* Make sure that all storage allocated to SALS gets freed. */
5303 make_cleanup (xfree
, sals
.sals
);
5305 /* Cleanup the addr_string array but not its contents. */
5306 make_cleanup (xfree
, addr_string
);
5309 /* Allocate space for all the cond expressions. */
5310 cond
= xcalloc (sals
.nelts
, sizeof (struct expression
*));
5311 make_cleanup (xfree
, cond
);
5313 /* Allocate space for all the cond strings. */
5314 cond_string
= xcalloc (sals
.nelts
, sizeof (char **));
5315 make_cleanup (xfree
, cond_string
);
5317 /* ----------------------------- SNIP -----------------------------
5318 Anything added to the cleanup chain beyond this point is assumed
5319 to be part of a breakpoint. If the breakpoint create succeeds
5320 then the memory is not reclaimed. */
5321 breakpoint_chain
= make_cleanup (null_cleanup
, 0);
5323 /* Mark the contents of the addr_string for cleanup. These go on
5324 the breakpoint_chain and only occure if the breakpoint create
5326 for (i
= 0; i
< sals
.nelts
; i
++)
5328 if (addr_string
[i
] != NULL
)
5329 make_cleanup (xfree
, addr_string
[i
]);
5332 /* Resolve all line numbers to PC's and verify that the addresses
5333 are ok for the target. */
5335 breakpoint_sals_to_pc (&sals
, addr_start
);
5337 /* Verify that condition can be parsed, before setting any
5338 breakpoints. Allocate a separate condition expression for each
5340 thread
= -1; /* No specific thread yet */
5343 for (i
= 0; i
< sals
.nelts
; i
++)
5350 char *cond_start
= NULL
;
5351 char *cond_end
= NULL
;
5352 while (*tok
== ' ' || *tok
== '\t')
5357 while (*end_tok
!= ' ' && *end_tok
!= '\t' && *end_tok
!= '\000')
5360 toklen
= end_tok
- tok
;
5362 if (toklen
>= 1 && strncmp (tok
, "if", toklen
) == 0)
5364 tok
= cond_start
= end_tok
+ 1;
5365 cond
[i
] = parse_exp_1 (&tok
, block_for_pc (sals
.sals
[i
].pc
),
5367 make_cleanup (xfree
, cond
[i
]);
5369 cond_string
[i
] = savestring (cond_start
,
5370 cond_end
- cond_start
);
5371 make_cleanup (xfree
, cond_string
[i
]);
5373 else if (toklen
>= 1 && strncmp (tok
, "thread", toklen
) == 0)
5379 thread
= strtol (tok
, &tok
, 0);
5381 error (_("Junk after thread keyword."));
5382 if (!valid_thread_id (thread
))
5383 error (_("Unknown thread %d."), thread
);
5386 error (_("Junk at end of arguments."));
5389 create_breakpoints (sals
, addr_string
, cond
, cond_string
,
5390 hardwareflag
? bp_hardware_breakpoint
5392 tempflag
? disp_del
: disp_donttouch
,
5393 thread
, ignore_count
, from_tty
,
5398 struct symtab_and_line sal
;
5399 struct breakpoint
*b
;
5404 make_cleanup (xfree
, copy_arg
);
5406 b
= set_raw_breakpoint (sal
, hardwareflag
? bp_hardware_breakpoint
5408 set_breakpoint_count (breakpoint_count
+ 1);
5409 b
->number
= breakpoint_count
;
5412 b
->addr_string
= *addr_string
;
5413 b
->cond_string
= *cond_string
;
5414 b
->ignore_count
= ignore_count
;
5416 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
5417 b
->from_tty
= from_tty
;
5423 warning (_("Multiple breakpoints were set.\n"
5424 "Use the \"delete\" command to delete unwanted breakpoints."));
5425 /* That's it. Discard the cleanups for data inserted into the
5427 discard_cleanups (breakpoint_chain
);
5428 /* But cleanup everything else. */
5429 do_cleanups (old_chain
);
5434 /* Set a breakpoint of TYPE/DISPOSITION according to ARG (function,
5435 linenum or *address) with COND and IGNORE_COUNT. */
5437 struct captured_breakpoint_args
5448 do_captured_breakpoint (struct ui_out
*uiout
, void *data
)
5450 struct captured_breakpoint_args
*args
= data
;
5451 struct symtabs_and_lines sals
;
5452 struct expression
**cond
;
5453 struct cleanup
*old_chain
;
5454 struct cleanup
*breakpoint_chain
= NULL
;
5461 /* Parse the source and lines spec. Delay check that the expression
5462 didn't contain trailing garbage until after cleanups are in
5466 address_end
= args
->address
;
5468 parse_breakpoint_sals (&address_end
, &sals
, &addr_string
, 0);
5473 /* Create a chain of things at always need to be cleaned up. */
5474 old_chain
= make_cleanup (null_cleanup
, 0);
5476 /* Always have a addr_string array, even if it is empty. */
5477 make_cleanup (xfree
, addr_string
);
5479 /* Make sure that all storage allocated to SALS gets freed. */
5480 make_cleanup (xfree
, sals
.sals
);
5482 /* Allocate space for all the cond expressions. */
5483 cond
= xcalloc (sals
.nelts
, sizeof (struct expression
*));
5484 make_cleanup (xfree
, cond
);
5486 /* Allocate space for all the cond strings. */
5487 cond_string
= xcalloc (sals
.nelts
, sizeof (char **));
5488 make_cleanup (xfree
, cond_string
);
5490 /* ----------------------------- SNIP -----------------------------
5491 Anything added to the cleanup chain beyond this point is assumed
5492 to be part of a breakpoint. If the breakpoint create goes
5493 through then that memory is not cleaned up. */
5494 breakpoint_chain
= make_cleanup (null_cleanup
, 0);
5496 /* Mark the contents of the addr_string for cleanup. These go on
5497 the breakpoint_chain and only occure if the breakpoint create
5499 for (i
= 0; i
< sals
.nelts
; i
++)
5501 if (addr_string
[i
] != NULL
)
5502 make_cleanup (xfree
, addr_string
[i
]);
5505 /* Wait until now before checking for garbage at the end of the
5506 address. That way cleanups can take care of freeing any
5508 if (*address_end
!= '\0')
5509 error (_("Garbage %s following breakpoint address"), address_end
);
5511 /* Resolve all line numbers to PC's. */
5512 breakpoint_sals_to_pc (&sals
, args
->address
);
5514 /* Verify that conditions can be parsed, before setting any
5516 for (i
= 0; i
< sals
.nelts
; i
++)
5518 if (args
->condition
!= NULL
)
5520 char *tok
= args
->condition
;
5521 cond
[i
] = parse_exp_1 (&tok
, block_for_pc (sals
.sals
[i
].pc
), 0);
5523 error (_("Garbage %s follows condition"), tok
);
5524 make_cleanup (xfree
, cond
[i
]);
5525 cond_string
[i
] = xstrdup (args
->condition
);
5529 create_breakpoints (sals
, addr_string
, cond
, cond_string
,
5530 args
->hardwareflag
? bp_hardware_breakpoint
: bp_breakpoint
,
5531 args
->tempflag
? disp_del
: disp_donttouch
,
5532 args
->thread
, args
->ignore_count
, 0/*from-tty*/,
5533 NULL
/*pending_bp*/);
5535 /* That's it. Discard the cleanups for data inserted into the
5537 discard_cleanups (breakpoint_chain
);
5538 /* But cleanup everything else. */
5539 do_cleanups (old_chain
);
5544 gdb_breakpoint (char *address
, char *condition
,
5545 int hardwareflag
, int tempflag
,
5546 int thread
, int ignore_count
,
5547 char **error_message
)
5549 struct captured_breakpoint_args args
;
5550 args
.address
= address
;
5551 args
.condition
= condition
;
5552 args
.hardwareflag
= hardwareflag
;
5553 args
.tempflag
= tempflag
;
5554 args
.thread
= thread
;
5555 args
.ignore_count
= ignore_count
;
5556 return catch_exceptions_with_msg (uiout
, do_captured_breakpoint
, &args
,
5557 error_message
, RETURN_MASK_ALL
);
5561 /* Helper function for break_command_1 and disassemble_command. */
5564 resolve_sal_pc (struct symtab_and_line
*sal
)
5568 if (sal
->pc
== 0 && sal
->symtab
!= NULL
)
5570 if (!find_line_pc (sal
->symtab
, sal
->line
, &pc
))
5571 error (_("No line %d in file \"%s\"."),
5572 sal
->line
, sal
->symtab
->filename
);
5576 if (sal
->section
== 0 && sal
->symtab
!= NULL
)
5578 struct blockvector
*bv
;
5583 bv
= blockvector_for_pc_sect (sal
->pc
, 0, &index
, sal
->symtab
);
5586 b
= BLOCKVECTOR_BLOCK (bv
, index
);
5587 sym
= block_function (b
);
5590 fixup_symbol_section (sym
, sal
->symtab
->objfile
);
5591 sal
->section
= SYMBOL_BFD_SECTION (sym
);
5595 /* It really is worthwhile to have the section, so we'll just
5596 have to look harder. This case can be executed if we have
5597 line numbers but no functions (as can happen in assembly
5600 struct minimal_symbol
*msym
;
5602 msym
= lookup_minimal_symbol_by_pc (sal
->pc
);
5604 sal
->section
= SYMBOL_BFD_SECTION (msym
);
5611 break_command (char *arg
, int from_tty
)
5613 break_command_1 (arg
, 0, from_tty
, NULL
);
5617 tbreak_command (char *arg
, int from_tty
)
5619 break_command_1 (arg
, BP_TEMPFLAG
, from_tty
, NULL
);
5623 hbreak_command (char *arg
, int from_tty
)
5625 break_command_1 (arg
, BP_HARDWAREFLAG
, from_tty
, NULL
);
5629 thbreak_command (char *arg
, int from_tty
)
5631 break_command_1 (arg
, (BP_TEMPFLAG
| BP_HARDWAREFLAG
), from_tty
, NULL
);
5635 stop_command (char *arg
, int from_tty
)
5637 printf_filtered (_("Specify the type of breakpoint to set.\n\
5638 Usage: stop in <function | address>\n\
5639 stop at <line>\n"));
5643 stopin_command (char *arg
, int from_tty
)
5647 if (arg
== (char *) NULL
)
5649 else if (*arg
!= '*')
5654 /* look for a ':'. If this is a line number specification, then
5655 say it is bad, otherwise, it should be an address or
5656 function/method name */
5657 while (*argptr
&& !hasColon
)
5659 hasColon
= (*argptr
== ':');
5664 badInput
= (*argptr
!= ':'); /* Not a class::method */
5666 badInput
= isdigit (*arg
); /* a simple line number */
5670 printf_filtered (_("Usage: stop in <function | address>\n"));
5672 break_command_1 (arg
, 0, from_tty
, NULL
);
5676 stopat_command (char *arg
, int from_tty
)
5680 if (arg
== (char *) NULL
|| *arg
== '*') /* no line number */
5687 /* look for a ':'. If there is a '::' then get out, otherwise
5688 it is probably a line number. */
5689 while (*argptr
&& !hasColon
)
5691 hasColon
= (*argptr
== ':');
5696 badInput
= (*argptr
== ':'); /* we have class::method */
5698 badInput
= !isdigit (*arg
); /* not a line number */
5702 printf_filtered (_("Usage: stop at <line>\n"));
5704 break_command_1 (arg
, 0, from_tty
, NULL
);
5707 /* accessflag: hw_write: watch write,
5708 hw_read: watch read,
5709 hw_access: watch access (read or write) */
5711 watch_command_1 (char *arg
, int accessflag
, int from_tty
)
5713 struct breakpoint
*b
;
5714 struct symtab_and_line sal
;
5715 struct expression
*exp
;
5716 struct block
*exp_valid_block
;
5717 struct value
*val
, *mark
;
5718 struct frame_info
*frame
;
5719 struct frame_info
*prev_frame
= NULL
;
5720 char *exp_start
= NULL
;
5721 char *exp_end
= NULL
;
5722 char *tok
, *end_tok
;
5724 char *cond_start
= NULL
;
5725 char *cond_end
= NULL
;
5726 struct expression
*cond
= NULL
;
5727 int i
, other_type_used
, target_resources_ok
= 0;
5728 enum bptype bp_type
;
5731 init_sal (&sal
); /* initialize to zeroes */
5733 /* Parse arguments. */
5734 innermost_block
= NULL
;
5736 exp
= parse_exp_1 (&arg
, 0, 0);
5738 exp_valid_block
= innermost_block
;
5739 mark
= value_mark ();
5740 val
= evaluate_expression (exp
);
5741 release_value (val
);
5742 if (value_lazy (val
))
5743 value_fetch_lazy (val
);
5746 while (*tok
== ' ' || *tok
== '\t')
5750 while (*end_tok
!= ' ' && *end_tok
!= '\t' && *end_tok
!= '\000')
5753 toklen
= end_tok
- tok
;
5754 if (toklen
>= 1 && strncmp (tok
, "if", toklen
) == 0)
5756 tok
= cond_start
= end_tok
+ 1;
5757 cond
= parse_exp_1 (&tok
, 0, 0);
5761 error (_("Junk at end of command."));
5763 if (accessflag
== hw_read
)
5764 bp_type
= bp_read_watchpoint
;
5765 else if (accessflag
== hw_access
)
5766 bp_type
= bp_access_watchpoint
;
5768 bp_type
= bp_hardware_watchpoint
;
5770 mem_cnt
= can_use_hardware_watchpoint (val
);
5771 if (mem_cnt
== 0 && bp_type
!= bp_hardware_watchpoint
)
5772 error (_("Expression cannot be implemented with read/access watchpoint."));
5775 i
= hw_watchpoint_used_count (bp_type
, &other_type_used
);
5776 target_resources_ok
=
5777 TARGET_CAN_USE_HARDWARE_WATCHPOINT (bp_type
, i
+ mem_cnt
,
5779 if (target_resources_ok
== 0 && bp_type
!= bp_hardware_watchpoint
)
5780 error (_("Target does not support this type of hardware watchpoint."));
5782 if (target_resources_ok
< 0 && bp_type
!= bp_hardware_watchpoint
)
5783 error (_("Target can only support one kind of HW watchpoint at a time."));
5786 #if defined(HPUXHPPA)
5787 /* On HP-UX if you set a h/w
5788 watchpoint before the "run" command, the inferior dies with a e.g.,
5789 SIGILL once you start it. I initially believed this was due to a
5790 bad interaction between page protection traps and the initial
5791 startup sequence by the dynamic linker.
5793 However, I tried avoiding that by having HP-UX's implementation of
5794 TARGET_CAN_USE_HW_WATCHPOINT return FALSE if there was no inferior_ptid
5795 yet, which forced slow watches before a "run" or "attach", and it
5796 still fails somewhere in the startup code.
5798 Until I figure out what's happening, I'm disallowing watches altogether
5799 before the "run" or "attach" command. We'll tell the user they must
5800 set watches after getting the program started. */
5801 if (!target_has_execution
)
5803 warning (_("can't do that without a running program; try \"break main\"), \"run\" first");
5806 #endif /* HPUXHPPA */
5808 /* Change the type of breakpoint to an ordinary watchpoint if a hardware
5809 watchpoint could not be set. */
5810 if (!mem_cnt
|| target_resources_ok
<= 0)
5811 bp_type
= bp_watchpoint
;
5813 /* Now set up the breakpoint. */
5814 b
= set_raw_breakpoint (sal
, bp_type
);
5815 set_breakpoint_count (breakpoint_count
+ 1);
5816 b
->number
= breakpoint_count
;
5817 b
->disposition
= disp_donttouch
;
5819 b
->exp_valid_block
= exp_valid_block
;
5820 b
->exp_string
= savestring (exp_start
, exp_end
- exp_start
);
5824 b
->cond_string
= savestring (cond_start
, cond_end
- cond_start
);
5828 frame
= block_innermost_frame (exp_valid_block
);
5831 prev_frame
= get_prev_frame (frame
);
5832 b
->watchpoint_frame
= get_frame_id (frame
);
5836 memset (&b
->watchpoint_frame
, 0, sizeof (b
->watchpoint_frame
));
5839 /* If the expression is "local", then set up a "watchpoint scope"
5840 breakpoint at the point where we've left the scope of the watchpoint
5842 if (innermost_block
)
5846 struct breakpoint
*scope_breakpoint
;
5847 scope_breakpoint
= create_internal_breakpoint (get_frame_pc (prev_frame
),
5848 bp_watchpoint_scope
);
5850 scope_breakpoint
->enable_state
= bp_enabled
;
5852 /* Automatically delete the breakpoint when it hits. */
5853 scope_breakpoint
->disposition
= disp_del
;
5855 /* Only break in the proper frame (help with recursion). */
5856 scope_breakpoint
->frame_id
= get_frame_id (prev_frame
);
5858 /* Set the address at which we will stop. */
5859 scope_breakpoint
->loc
->requested_address
5860 = get_frame_pc (prev_frame
);
5861 scope_breakpoint
->loc
->address
5862 = adjust_breakpoint_address (scope_breakpoint
->loc
->requested_address
,
5863 scope_breakpoint
->type
);
5865 /* The scope breakpoint is related to the watchpoint. We
5866 will need to act on them together. */
5867 b
->related_breakpoint
= scope_breakpoint
;
5870 value_free_to_mark (mark
);
5874 /* Return count of locations need to be watched and can be handled
5875 in hardware. If the watchpoint can not be handled
5876 in hardware return zero. */
5879 can_use_hardware_watchpoint (struct value
*v
)
5881 int found_memory_cnt
= 0;
5882 struct value
*head
= v
;
5884 /* Did the user specifically forbid us to use hardware watchpoints? */
5885 if (!can_use_hw_watchpoints
)
5888 /* Make sure that the value of the expression depends only upon
5889 memory contents, and values computed from them within GDB. If we
5890 find any register references or function calls, we can't use a
5891 hardware watchpoint.
5893 The idea here is that evaluating an expression generates a series
5894 of values, one holding the value of every subexpression. (The
5895 expression a*b+c has five subexpressions: a, b, a*b, c, and
5896 a*b+c.) GDB's values hold almost enough information to establish
5897 the criteria given above --- they identify memory lvalues,
5898 register lvalues, computed values, etcetera. So we can evaluate
5899 the expression, and then scan the chain of values that leaves
5900 behind to decide whether we can detect any possible change to the
5901 expression's final value using only hardware watchpoints.
5903 However, I don't think that the values returned by inferior
5904 function calls are special in any way. So this function may not
5905 notice that an expression involving an inferior function call
5906 can't be watched with hardware watchpoints. FIXME. */
5907 for (; v
; v
= value_next (v
))
5909 if (VALUE_LVAL (v
) == lval_memory
)
5912 /* A lazy memory lvalue is one that GDB never needed to fetch;
5913 we either just used its address (e.g., `a' in `a.b') or
5914 we never needed it at all (e.g., `a' in `a,b'). */
5918 /* Ahh, memory we actually used! Check if we can cover
5919 it with hardware watchpoints. */
5920 struct type
*vtype
= check_typedef (value_type (v
));
5922 /* We only watch structs and arrays if user asked for it
5923 explicitly, never if they just happen to appear in a
5924 middle of some value chain. */
5926 || (TYPE_CODE (vtype
) != TYPE_CODE_STRUCT
5927 && TYPE_CODE (vtype
) != TYPE_CODE_ARRAY
))
5929 CORE_ADDR vaddr
= VALUE_ADDRESS (v
) + value_offset (v
);
5930 int len
= TYPE_LENGTH (value_type (v
));
5932 if (!TARGET_REGION_OK_FOR_HW_WATCHPOINT (vaddr
, len
))
5939 else if (VALUE_LVAL (v
) != not_lval
5940 && deprecated_value_modifiable (v
) == 0)
5941 return 0; /* ??? What does this represent? */
5942 else if (VALUE_LVAL (v
) == lval_register
)
5943 return 0; /* cannot watch a register with a HW watchpoint */
5946 /* The expression itself looks suitable for using a hardware
5947 watchpoint, but give the target machine a chance to reject it. */
5948 return found_memory_cnt
;
5952 watch_command_wrapper (char *arg
, int from_tty
)
5954 watch_command (arg
, from_tty
);
5958 watch_command (char *arg
, int from_tty
)
5960 watch_command_1 (arg
, hw_write
, from_tty
);
5964 rwatch_command_wrapper (char *arg
, int from_tty
)
5966 rwatch_command (arg
, from_tty
);
5970 rwatch_command (char *arg
, int from_tty
)
5972 watch_command_1 (arg
, hw_read
, from_tty
);
5976 awatch_command_wrapper (char *arg
, int from_tty
)
5978 awatch_command (arg
, from_tty
);
5982 awatch_command (char *arg
, int from_tty
)
5984 watch_command_1 (arg
, hw_access
, from_tty
);
5988 /* Helper routines for the until_command routine in infcmd.c. Here
5989 because it uses the mechanisms of breakpoints. */
5991 /* This function is called by fetch_inferior_event via the
5992 cmd_continuation pointer, to complete the until command. It takes
5993 care of cleaning up the temporary breakpoints set up by the until
5996 until_break_command_continuation (struct continuation_arg
*arg
)
5998 struct cleanup
*cleanups
;
6000 cleanups
= (struct cleanup
*) arg
->data
.pointer
;
6001 do_exec_cleanups (cleanups
);
6005 until_break_command (char *arg
, int from_tty
, int anywhere
)
6007 struct symtabs_and_lines sals
;
6008 struct symtab_and_line sal
;
6009 struct frame_info
*prev_frame
= get_prev_frame (deprecated_selected_frame
);
6010 struct breakpoint
*breakpoint
;
6011 struct cleanup
*old_chain
;
6012 struct continuation_arg
*arg1
;
6015 clear_proceed_status ();
6017 /* Set a breakpoint where the user wants it and at return from
6020 if (default_breakpoint_valid
)
6021 sals
= decode_line_1 (&arg
, 1, default_breakpoint_symtab
,
6022 default_breakpoint_line
, (char ***) NULL
, NULL
);
6024 sals
= decode_line_1 (&arg
, 1, (struct symtab
*) NULL
,
6025 0, (char ***) NULL
, NULL
);
6027 if (sals
.nelts
!= 1)
6028 error (_("Couldn't get information on specified line."));
6031 xfree (sals
.sals
); /* malloc'd, so freed */
6034 error (_("Junk at end of arguments."));
6036 resolve_sal_pc (&sal
);
6039 /* If the user told us to continue until a specified location,
6040 we don't specify a frame at which we need to stop. */
6041 breakpoint
= set_momentary_breakpoint (sal
, null_frame_id
, bp_until
);
6043 /* Otherwise, specify the current frame, because we want to stop only
6044 at the very same frame. */
6045 breakpoint
= set_momentary_breakpoint (sal
,
6046 get_frame_id (deprecated_selected_frame
),
6049 if (!target_can_async_p ())
6050 old_chain
= make_cleanup_delete_breakpoint (breakpoint
);
6052 old_chain
= make_exec_cleanup_delete_breakpoint (breakpoint
);
6054 /* If we are running asynchronously, and the target supports async
6055 execution, we are not waiting for the target to stop, in the call
6056 tp proceed, below. This means that we cannot delete the
6057 brekpoints until the target has actually stopped. The only place
6058 where we get a chance to do that is in fetch_inferior_event, so
6059 we must set things up for that. */
6061 if (target_can_async_p ())
6063 /* In this case the arg for the continuation is just the point
6064 in the exec_cleanups chain from where to start doing
6065 cleanups, because all the continuation does is the cleanups in
6066 the exec_cleanup_chain. */
6068 (struct continuation_arg
*) xmalloc (sizeof (struct continuation_arg
));
6070 arg1
->data
.pointer
= old_chain
;
6072 add_continuation (until_break_command_continuation
, arg1
);
6075 /* Keep within the current frame, or in frames called by the current
6079 sal
= find_pc_line (get_frame_pc (prev_frame
), 0);
6080 sal
.pc
= get_frame_pc (prev_frame
);
6081 breakpoint
= set_momentary_breakpoint (sal
, get_frame_id (prev_frame
),
6083 if (!target_can_async_p ())
6084 make_cleanup_delete_breakpoint (breakpoint
);
6086 make_exec_cleanup_delete_breakpoint (breakpoint
);
6089 proceed (-1, TARGET_SIGNAL_DEFAULT
, 0);
6090 /* Do the cleanups now, anly if we are not running asynchronously,
6091 of if we are, but the target is still synchronous. */
6092 if (!target_can_async_p ())
6093 do_cleanups (old_chain
);
6097 ep_skip_leading_whitespace (char **s
)
6099 if ((s
== NULL
) || (*s
== NULL
))
6101 while (isspace (**s
))
6105 /* This function examines a string, and attempts to find a token
6106 that might be an event name in the leading characters. If a
6107 possible match is found, a pointer to the last character of
6108 the token is returned. Else, NULL is returned. */
6111 ep_find_event_name_end (char *arg
)
6114 char *event_name_end
= NULL
;
6116 /* If we could depend upon the presense of strrpbrk, we'd use that... */
6120 /* We break out of the loop when we find a token delimiter.
6121 Basically, we're looking for alphanumerics and underscores;
6122 anything else delimites the token. */
6125 if (!isalnum (*s
) && (*s
!= '_'))
6131 return event_name_end
;
6135 /* This function attempts to parse an optional "if <cond>" clause
6136 from the arg string. If one is not found, it returns NULL.
6138 Else, it returns a pointer to the condition string. (It does not
6139 attempt to evaluate the string against a particular block.) And,
6140 it updates arg to point to the first character following the parsed
6141 if clause in the arg string. */
6144 ep_parse_optional_if_clause (char **arg
)
6148 if (((*arg
)[0] != 'i') || ((*arg
)[1] != 'f') || !isspace ((*arg
)[2]))
6151 /* Skip the "if" keyword. */
6154 /* Skip any extra leading whitespace, and record the start of the
6155 condition string. */
6156 ep_skip_leading_whitespace (arg
);
6159 /* Assume that the condition occupies the remainder of the arg string. */
6160 (*arg
) += strlen (cond_string
);
6165 /* This function attempts to parse an optional filename from the arg
6166 string. If one is not found, it returns NULL.
6168 Else, it returns a pointer to the parsed filename. (This function
6169 makes no attempt to verify that a file of that name exists, or is
6170 accessible.) And, it updates arg to point to the first character
6171 following the parsed filename in the arg string.
6173 Note that clients needing to preserve the returned filename for
6174 future access should copy it to their own buffers. */
6176 ep_parse_optional_filename (char **arg
)
6178 static char filename
[1024];
6183 if ((*arg_p
== '\0') || isspace (*arg_p
))
6201 /* Commands to deal with catching events, such as signals, exceptions,
6202 process start/exit, etc. */
6206 catch_fork
, catch_vfork
6211 catch_fork_command_1 (catch_fork_kind fork_kind
, char *arg
, int tempflag
,
6214 char *cond_string
= NULL
;
6216 ep_skip_leading_whitespace (&arg
);
6218 /* The allowed syntax is:
6220 catch [v]fork if <cond>
6222 First, check if there's an if clause. */
6223 cond_string
= ep_parse_optional_if_clause (&arg
);
6225 if ((*arg
!= '\0') && !isspace (*arg
))
6226 error (_("Junk at end of arguments."));
6228 /* If this target supports it, create a fork or vfork catchpoint
6229 and enable reporting of such events. */
6233 create_fork_event_catchpoint (tempflag
, cond_string
);
6236 create_vfork_event_catchpoint (tempflag
, cond_string
);
6239 error (_("unsupported or unknown fork kind; cannot catch it"));
6245 catch_exec_command_1 (char *arg
, int tempflag
, int from_tty
)
6247 char *cond_string
= NULL
;
6249 ep_skip_leading_whitespace (&arg
);
6251 /* The allowed syntax is:
6253 catch exec if <cond>
6255 First, check if there's an if clause. */
6256 cond_string
= ep_parse_optional_if_clause (&arg
);
6258 if ((*arg
!= '\0') && !isspace (*arg
))
6259 error (_("Junk at end of arguments."));
6261 /* If this target supports it, create an exec catchpoint
6262 and enable reporting of such events. */
6263 create_exec_event_catchpoint (tempflag
, cond_string
);
6267 catch_load_command_1 (char *arg
, int tempflag
, int from_tty
)
6269 char *dll_pathname
= NULL
;
6270 char *cond_string
= NULL
;
6272 ep_skip_leading_whitespace (&arg
);
6274 /* The allowed syntax is:
6276 catch load if <cond>
6277 catch load <filename>
6278 catch load <filename> if <cond>
6280 The user is not allowed to specify the <filename> after an
6283 We'll ignore the pathological case of a file named "if".
6285 First, check if there's an if clause. If so, then there
6286 cannot be a filename. */
6287 cond_string
= ep_parse_optional_if_clause (&arg
);
6289 /* If there was an if clause, then there cannot be a filename.
6290 Else, there might be a filename and an if clause. */
6291 if (cond_string
== NULL
)
6293 dll_pathname
= ep_parse_optional_filename (&arg
);
6294 ep_skip_leading_whitespace (&arg
);
6295 cond_string
= ep_parse_optional_if_clause (&arg
);
6298 if ((*arg
!= '\0') && !isspace (*arg
))
6299 error (_("Junk at end of arguments."));
6301 /* Create a load breakpoint that only triggers when a load of
6302 the specified dll (or any dll, if no pathname was specified)
6304 SOLIB_CREATE_CATCH_LOAD_HOOK (PIDGET (inferior_ptid
), tempflag
,
6305 dll_pathname
, cond_string
);
6309 catch_unload_command_1 (char *arg
, int tempflag
, int from_tty
)
6311 char *dll_pathname
= NULL
;
6312 char *cond_string
= NULL
;
6314 ep_skip_leading_whitespace (&arg
);
6316 /* The allowed syntax is:
6318 catch unload if <cond>
6319 catch unload <filename>
6320 catch unload <filename> if <cond>
6322 The user is not allowed to specify the <filename> after an
6325 We'll ignore the pathological case of a file named "if".
6327 First, check if there's an if clause. If so, then there
6328 cannot be a filename. */
6329 cond_string
= ep_parse_optional_if_clause (&arg
);
6331 /* If there was an if clause, then there cannot be a filename.
6332 Else, there might be a filename and an if clause. */
6333 if (cond_string
== NULL
)
6335 dll_pathname
= ep_parse_optional_filename (&arg
);
6336 ep_skip_leading_whitespace (&arg
);
6337 cond_string
= ep_parse_optional_if_clause (&arg
);
6340 if ((*arg
!= '\0') && !isspace (*arg
))
6341 error (_("Junk at end of arguments."));
6343 /* Create an unload breakpoint that only triggers when an unload of
6344 the specified dll (or any dll, if no pathname was specified)
6346 SOLIB_CREATE_CATCH_UNLOAD_HOOK (PIDGET (inferior_ptid
), tempflag
,
6347 dll_pathname
, cond_string
);
6350 /* Commands to deal with catching exceptions. */
6352 /* Set a breakpoint at the specified callback routine for an
6353 exception event callback */
6356 create_exception_catchpoint (int tempflag
, char *cond_string
,
6357 enum exception_event_kind ex_event
,
6358 struct symtab_and_line
*sal
)
6360 struct breakpoint
*b
;
6361 int thread
= -1; /* All threads. */
6364 if (!sal
) /* no exception support? */
6369 case EX_EVENT_THROW
:
6370 bptype
= bp_catch_throw
;
6372 case EX_EVENT_CATCH
:
6373 bptype
= bp_catch_catch
;
6375 default: /* error condition */
6376 error (_("Internal error -- invalid catchpoint kind"));
6379 b
= set_raw_breakpoint (*sal
, bptype
);
6380 set_breakpoint_count (breakpoint_count
+ 1);
6381 b
->number
= breakpoint_count
;
6383 b
->cond_string
= (cond_string
== NULL
) ?
6384 NULL
: savestring (cond_string
, strlen (cond_string
));
6386 b
->addr_string
= NULL
;
6387 b
->enable_state
= bp_enabled
;
6388 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
6392 static enum print_stop_action
6393 print_exception_catchpoint (struct breakpoint
*b
)
6395 annotate_catchpoint (b
->number
);
6397 if (strstr (b
->addr_string
, "throw") != NULL
)
6398 printf_filtered (_("\nCatchpoint %d (exception thrown)\n"),
6401 printf_filtered (_("\nCatchpoint %d (exception caught)\n"),
6404 return PRINT_SRC_AND_LOC
;
6408 print_one_exception_catchpoint (struct breakpoint
*b
, CORE_ADDR
*last_addr
)
6413 ui_out_field_core_addr (uiout
, "addr", b
->loc
->address
);
6416 *last_addr
= b
->loc
->address
;
6417 if (strstr (b
->addr_string
, "throw") != NULL
)
6418 ui_out_field_string (uiout
, "what", "exception throw");
6420 ui_out_field_string (uiout
, "what", "exception catch");
6424 print_mention_exception_catchpoint (struct breakpoint
*b
)
6426 if (strstr (b
->addr_string
, "throw") != NULL
)
6427 printf_filtered (_("Catchpoint %d (throw)"), b
->number
);
6429 printf_filtered (_("Catchpoint %d (catch)"), b
->number
);
6432 static struct breakpoint_ops gnu_v3_exception_catchpoint_ops
= {
6433 print_exception_catchpoint
,
6434 print_one_exception_catchpoint
,
6435 print_mention_exception_catchpoint
6439 handle_gnu_v3_exceptions (int tempflag
, char *cond_string
,
6440 enum exception_event_kind ex_event
, int from_tty
)
6442 char *trigger_func_name
, *nameptr
;
6443 struct symtabs_and_lines sals
;
6444 struct breakpoint
*b
;
6446 if (ex_event
== EX_EVENT_CATCH
)
6447 trigger_func_name
= xstrdup ("__cxa_begin_catch");
6449 trigger_func_name
= xstrdup ("__cxa_throw");
6451 nameptr
= trigger_func_name
;
6452 sals
= decode_line_1 (&nameptr
, 1, NULL
, 0, NULL
, NULL
);
6453 if (sals
.nelts
== 0)
6455 xfree (trigger_func_name
);
6459 b
= set_raw_breakpoint (sals
.sals
[0], bp_breakpoint
);
6460 set_breakpoint_count (breakpoint_count
+ 1);
6461 b
->number
= breakpoint_count
;
6463 b
->cond_string
= (cond_string
== NULL
) ?
6464 NULL
: savestring (cond_string
, strlen (cond_string
));
6466 b
->addr_string
= trigger_func_name
;
6467 b
->enable_state
= bp_enabled
;
6468 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
6469 b
->ops
= &gnu_v3_exception_catchpoint_ops
;
6476 /* Deal with "catch catch" and "catch throw" commands */
6479 catch_exception_command_1 (enum exception_event_kind ex_event
, char *arg
,
6480 int tempflag
, int from_tty
)
6482 char *cond_string
= NULL
;
6483 struct symtab_and_line
*sal
= NULL
;
6485 ep_skip_leading_whitespace (&arg
);
6487 cond_string
= ep_parse_optional_if_clause (&arg
);
6489 if ((*arg
!= '\0') && !isspace (*arg
))
6490 error (_("Junk at end of arguments."));
6492 if ((ex_event
!= EX_EVENT_THROW
) &&
6493 (ex_event
!= EX_EVENT_CATCH
))
6494 error (_("Unsupported or unknown exception event; cannot catch it"));
6496 if (handle_gnu_v3_exceptions (tempflag
, cond_string
, ex_event
, from_tty
))
6499 /* See if we can find a callback routine */
6500 sal
= target_enable_exception_callback (ex_event
, 1);
6504 /* We have callbacks from the runtime system for exceptions.
6505 Set a breakpoint on the sal found, if no errors */
6506 if (sal
!= (struct symtab_and_line
*) -1)
6507 create_exception_catchpoint (tempflag
, cond_string
, ex_event
, sal
);
6509 return; /* something went wrong with setting up callbacks */
6512 warning (_("Unsupported with this platform/compiler combination."));
6515 /* Create a breakpoint struct for Ada exception catchpoints. */
6518 create_ada_exception_breakpoint (struct symtab_and_line sal
,
6522 struct expression
*cond
,
6523 struct breakpoint_ops
*ops
,
6527 struct breakpoint
*b
;
6531 describe_other_breakpoints (sal
.pc
, sal
.section
, -1);
6532 /* FIXME: brobecker/2006-12-28: Actually, re-implement a special
6533 version for exception catchpoints, because two catchpoints
6534 used for different exception names will use the same address.
6535 In this case, a "breakpoint ... also set at..." warning is
6536 unproductive. Besides. the warning phrasing is also a bit
6537 inapropriate, we should use the word catchpoint, and tell
6538 the user what type of catchpoint it is. The above is good
6539 enough for now, though. */
6542 b
= set_raw_breakpoint (sal
, bp_breakpoint
);
6543 set_breakpoint_count (breakpoint_count
+ 1);
6545 b
->enable_state
= bp_enabled
;
6546 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
6547 b
->number
= breakpoint_count
;
6548 b
->ignore_count
= 0;
6550 b
->addr_string
= addr_string
;
6551 b
->language
= language_ada
;
6552 b
->cond_string
= cond_string
;
6553 b
->exp_string
= exp_string
;
6556 b
->from_tty
= from_tty
;
6561 /* Implement the "catch exception" command. */
6564 catch_ada_exception_command (char *arg
, int tempflag
, int from_tty
)
6566 struct symtab_and_line sal
;
6568 char *addr_string
= NULL
;
6569 char *exp_string
= NULL
;
6570 char *cond_string
= NULL
;
6571 struct expression
*cond
= NULL
;
6572 struct breakpoint_ops
*ops
= NULL
;
6574 sal
= ada_decode_exception_location (arg
, &addr_string
, &exp_string
,
6575 &cond_string
, &cond
, &ops
);
6576 create_ada_exception_breakpoint (sal
, addr_string
, exp_string
,
6577 cond_string
, cond
, ops
, tempflag
,
6581 /* Implement the "catch assert" command. */
6584 catch_assert_command (char *arg
, int tempflag
, int from_tty
)
6586 struct symtab_and_line sal
;
6587 char *addr_string
= NULL
;
6588 struct breakpoint_ops
*ops
= NULL
;
6590 sal
= ada_decode_assert_location (arg
, &addr_string
, &ops
);
6591 create_ada_exception_breakpoint (sal
, addr_string
, NULL
, NULL
, NULL
, ops
,
6592 tempflag
, from_tty
);
6595 /* Cover routine to allow wrapping target_enable_exception_catchpoints
6596 inside a catch_errors */
6599 cover_target_enable_exception_callback (void *arg
)
6601 args_for_catchpoint_enable
*args
= arg
;
6602 struct symtab_and_line
*sal
;
6603 sal
= target_enable_exception_callback (args
->kind
, args
->enable_p
);
6606 else if (sal
== (struct symtab_and_line
*) -1)
6609 return 1; /*is valid */
6613 catch_command_1 (char *arg
, int tempflag
, int from_tty
)
6616 /* The first argument may be an event name, such as "start" or "load".
6617 If so, then handle it as such. If it doesn't match an event name,
6618 then attempt to interpret it as an exception name. (This latter is
6619 the v4.16-and-earlier GDB meaning of the "catch" command.)
6621 First, try to find the bounds of what might be an event name. */
6622 char *arg1_start
= arg
;
6626 if (arg1_start
== NULL
)
6628 /* Old behaviour was to use pre-v-4.16 syntax */
6629 /* catch_throw_command_1 (arg1_start, tempflag, from_tty); */
6631 /* Now, this is not allowed */
6632 error (_("Catch requires an event name."));
6635 arg1_end
= ep_find_event_name_end (arg1_start
);
6636 if (arg1_end
== NULL
)
6637 error (_("catch requires an event"));
6638 arg1_length
= arg1_end
+ 1 - arg1_start
;
6640 /* Try to match what we found against known event names. */
6641 if (strncmp (arg1_start
, "signal", arg1_length
) == 0)
6643 error (_("Catch of signal not yet implemented"));
6645 else if (strncmp (arg1_start
, "catch", arg1_length
) == 0)
6647 catch_exception_command_1 (EX_EVENT_CATCH
, arg1_end
+ 1,
6648 tempflag
, from_tty
);
6650 else if (strncmp (arg1_start
, "throw", arg1_length
) == 0)
6652 catch_exception_command_1 (EX_EVENT_THROW
, arg1_end
+ 1,
6653 tempflag
, from_tty
);
6655 else if (strncmp (arg1_start
, "thread_start", arg1_length
) == 0)
6657 error (_("Catch of thread_start not yet implemented"));
6659 else if (strncmp (arg1_start
, "thread_exit", arg1_length
) == 0)
6661 error (_("Catch of thread_exit not yet implemented"));
6663 else if (strncmp (arg1_start
, "thread_join", arg1_length
) == 0)
6665 error (_("Catch of thread_join not yet implemented"));
6667 else if (strncmp (arg1_start
, "start", arg1_length
) == 0)
6669 error (_("Catch of start not yet implemented"));
6671 else if (strncmp (arg1_start
, "exit", arg1_length
) == 0)
6673 error (_("Catch of exit not yet implemented"));
6675 else if (strncmp (arg1_start
, "fork", arg1_length
) == 0)
6677 catch_fork_command_1 (catch_fork
, arg1_end
+ 1, tempflag
, from_tty
);
6679 else if (strncmp (arg1_start
, "vfork", arg1_length
) == 0)
6681 catch_fork_command_1 (catch_vfork
, arg1_end
+ 1, tempflag
, from_tty
);
6683 else if (strncmp (arg1_start
, "exec", arg1_length
) == 0)
6685 catch_exec_command_1 (arg1_end
+ 1, tempflag
, from_tty
);
6687 else if (strncmp (arg1_start
, "load", arg1_length
) == 0)
6689 catch_load_command_1 (arg1_end
+ 1, tempflag
, from_tty
);
6691 else if (strncmp (arg1_start
, "unload", arg1_length
) == 0)
6693 catch_unload_command_1 (arg1_end
+ 1, tempflag
, from_tty
);
6695 else if (strncmp (arg1_start
, "stop", arg1_length
) == 0)
6697 error (_("Catch of stop not yet implemented"));
6699 else if (strncmp (arg1_start
, "exception", arg1_length
) == 0)
6701 catch_ada_exception_command (arg1_end
+ 1, tempflag
, from_tty
);
6704 else if (strncmp (arg1_start
, "assert", arg1_length
) == 0)
6706 catch_assert_command (arg1_end
+ 1, tempflag
, from_tty
);
6709 /* This doesn't appear to be an event name */
6713 /* Pre-v.4.16 behaviour was to treat the argument
6714 as the name of an exception */
6715 /* catch_throw_command_1 (arg1_start, tempflag, from_tty); */
6716 /* Now this is not allowed */
6717 error (_("Unknown event kind specified for catch"));
6722 /* Used by the gui, could be made a worker for other things. */
6725 set_breakpoint_sal (struct symtab_and_line sal
)
6727 struct breakpoint
*b
;
6728 b
= set_raw_breakpoint (sal
, bp_breakpoint
);
6729 set_breakpoint_count (breakpoint_count
+ 1);
6730 b
->number
= breakpoint_count
;
6737 catch_command (char *arg
, int from_tty
)
6739 catch_command_1 (arg
, 0, from_tty
);
6744 tcatch_command (char *arg
, int from_tty
)
6746 catch_command_1 (arg
, 1, from_tty
);
6749 /* Delete breakpoints by address or line. */
6752 clear_command (char *arg
, int from_tty
)
6754 struct breakpoint
*b
, *tmp
, *prev
, *found
;
6756 struct symtabs_and_lines sals
;
6757 struct symtab_and_line sal
;
6762 sals
= decode_line_spec (arg
, 1);
6767 sals
.sals
= (struct symtab_and_line
*)
6768 xmalloc (sizeof (struct symtab_and_line
));
6769 make_cleanup (xfree
, sals
.sals
);
6770 init_sal (&sal
); /* initialize to zeroes */
6771 sal
.line
= default_breakpoint_line
;
6772 sal
.symtab
= default_breakpoint_symtab
;
6773 sal
.pc
= default_breakpoint_address
;
6774 if (sal
.symtab
== 0)
6775 error (_("No source file specified."));
6783 /* For each line spec given, delete bps which correspond
6784 to it. Do it in two passes, solely to preserve the current
6785 behavior that from_tty is forced true if we delete more than
6789 for (i
= 0; i
< sals
.nelts
; i
++)
6791 /* If exact pc given, clear bpts at that pc.
6792 If line given (pc == 0), clear all bpts on specified line.
6793 If defaulting, clear all bpts on default line
6796 defaulting sal.pc != 0 tests to do
6801 1 0 <can't happen> */
6806 /* Find all matching breakpoints, remove them from the
6807 breakpoint chain, and add them to the 'found' chain. */
6808 ALL_BREAKPOINTS_SAFE (b
, tmp
)
6810 /* Are we going to delete b? */
6811 if (b
->type
!= bp_none
6812 && b
->type
!= bp_watchpoint
6813 && b
->type
!= bp_hardware_watchpoint
6814 && b
->type
!= bp_read_watchpoint
6815 && b
->type
!= bp_access_watchpoint
6816 /* Not if b is a watchpoint of any sort... */
6817 && (((sal
.pc
&& (b
->loc
->address
== sal
.pc
))
6818 && (!section_is_overlay (b
->loc
->section
)
6819 || b
->loc
->section
== sal
.section
))
6820 /* Yes, if sal.pc matches b (modulo overlays). */
6821 || ((default_match
|| (0 == sal
.pc
))
6822 && b
->source_file
!= NULL
6823 && sal
.symtab
!= NULL
6824 && strcmp (b
->source_file
, sal
.symtab
->filename
) == 0
6825 && b
->line_number
== sal
.line
)))
6826 /* Yes, if sal source file and line matches b. */
6828 /* Remove it from breakpoint_chain... */
6829 if (b
== breakpoint_chain
)
6831 /* b is at the head of the list */
6832 breakpoint_chain
= b
->next
;
6836 prev
->next
= b
->next
;
6838 /* And add it to 'found' chain. */
6844 /* Keep b, and keep a pointer to it. */
6849 /* Now go thru the 'found' chain and delete them. */
6853 error (_("No breakpoint at %s."), arg
);
6855 error (_("No breakpoint at this line."));
6859 from_tty
= 1; /* Always report if deleted more than one */
6863 printf_unfiltered (_("Deleted breakpoint "));
6865 printf_unfiltered (_("Deleted breakpoints "));
6867 breakpoints_changed ();
6871 printf_unfiltered ("%d ", found
->number
);
6873 delete_breakpoint (found
);
6877 putchar_unfiltered ('\n');
6880 /* Delete breakpoint in BS if they are `delete' breakpoints and
6881 all breakpoints that are marked for deletion, whether hit or not.
6882 This is called after any breakpoint is hit, or after errors. */
6885 breakpoint_auto_delete (bpstat bs
)
6887 struct breakpoint
*b
, *temp
;
6889 for (; bs
; bs
= bs
->next
)
6890 if (bs
->breakpoint_at
&& bs
->breakpoint_at
->disposition
== disp_del
6892 delete_breakpoint (bs
->breakpoint_at
);
6894 ALL_BREAKPOINTS_SAFE (b
, temp
)
6896 if (b
->disposition
== disp_del_at_next_stop
)
6897 delete_breakpoint (b
);
6901 /* Delete a breakpoint and clean up all traces of it in the data
6905 delete_breakpoint (struct breakpoint
*bpt
)
6907 struct breakpoint
*b
;
6909 struct bp_location
*loc
;
6911 gdb_assert (bpt
!= NULL
);
6913 /* Has this bp already been deleted? This can happen because multiple
6914 lists can hold pointers to bp's. bpstat lists are especial culprits.
6916 One example of this happening is a watchpoint's scope bp. When the
6917 scope bp triggers, we notice that the watchpoint is out of scope, and
6918 delete it. We also delete its scope bp. But the scope bp is marked
6919 "auto-deleting", and is already on a bpstat. That bpstat is then
6920 checked for auto-deleting bp's, which are deleted.
6922 A real solution to this problem might involve reference counts in bp's,
6923 and/or giving them pointers back to their referencing bpstat's, and
6924 teaching delete_breakpoint to only free a bp's storage when no more
6925 references were extent. A cheaper bandaid was chosen. */
6926 if (bpt
->type
== bp_none
)
6929 if (deprecated_delete_breakpoint_hook
)
6930 deprecated_delete_breakpoint_hook (bpt
);
6931 breakpoint_delete_event (bpt
->number
);
6933 if (bpt
->loc
->inserted
)
6934 remove_breakpoint (bpt
->loc
, mark_inserted
);
6936 free_valchain (bpt
->loc
);
6938 if (breakpoint_chain
== bpt
)
6939 breakpoint_chain
= bpt
->next
;
6941 if (bp_location_chain
== bpt
->loc
)
6942 bp_location_chain
= bpt
->loc
->next
;
6944 /* If we have callback-style exception catchpoints, don't go through
6945 the adjustments to the C++ runtime library etc. if the inferior
6946 isn't actually running. target_enable_exception_callback for a
6947 null target ops vector gives an undesirable error message, so we
6948 check here and avoid it. Since currently (1997-09-17) only HP-UX aCC's
6949 exceptions are supported in this way, it's OK for now. FIXME */
6950 if (ep_is_exception_catchpoint (bpt
) && target_has_execution
)
6952 /* Format possible error msg */
6953 char *message
= xstrprintf ("Error in deleting catchpoint %d:\n",
6955 struct cleanup
*cleanups
= make_cleanup (xfree
, message
);
6956 args_for_catchpoint_enable args
;
6957 args
.kind
= bpt
->type
== bp_catch_catch
?
6958 EX_EVENT_CATCH
: EX_EVENT_THROW
;
6960 catch_errors (cover_target_enable_exception_callback
, &args
,
6961 message
, RETURN_MASK_ALL
);
6962 do_cleanups (cleanups
);
6969 b
->next
= bpt
->next
;
6973 ALL_BP_LOCATIONS (loc
)
6974 if (loc
->next
== bpt
->loc
)
6976 loc
->next
= bpt
->loc
->next
;
6980 check_duplicates (bpt
);
6981 /* If this breakpoint was inserted, and there is another breakpoint
6982 at the same address, we need to insert the other breakpoint. */
6983 if (bpt
->loc
->inserted
6984 && bpt
->type
!= bp_hardware_watchpoint
6985 && bpt
->type
!= bp_read_watchpoint
6986 && bpt
->type
!= bp_access_watchpoint
6987 && bpt
->type
!= bp_catch_fork
6988 && bpt
->type
!= bp_catch_vfork
6989 && bpt
->type
!= bp_catch_exec
)
6992 if (b
->loc
->address
== bpt
->loc
->address
6993 && b
->loc
->section
== bpt
->loc
->section
6994 && !b
->loc
->duplicate
6995 && b
->enable_state
!= bp_disabled
6996 && b
->enable_state
!= bp_shlib_disabled
6998 && b
->enable_state
!= bp_call_disabled
)
7002 /* We should never reach this point if there is a permanent
7003 breakpoint at the same address as the one being deleted.
7004 If there is a permanent breakpoint somewhere, it should
7005 always be the only one inserted. */
7006 if (b
->enable_state
== bp_permanent
)
7007 internal_error (__FILE__
, __LINE__
,
7008 _("another breakpoint was inserted on top of "
7009 "a permanent breakpoint"));
7011 memset (&b
->loc
->target_info
, 0, sizeof (b
->loc
->target_info
));
7012 b
->loc
->target_info
.placed_address
= b
->loc
->address
;
7013 if (b
->type
== bp_hardware_breakpoint
)
7014 val
= target_insert_hw_breakpoint (&b
->loc
->target_info
);
7016 val
= target_insert_breakpoint (&b
->loc
->target_info
);
7018 /* If there was an error in the insert, print a message, then stop execution. */
7021 struct ui_file
*tmp_error_stream
= mem_fileopen ();
7022 make_cleanup_ui_file_delete (tmp_error_stream
);
7025 if (b
->type
== bp_hardware_breakpoint
)
7027 fprintf_unfiltered (tmp_error_stream
,
7028 "Cannot insert hardware breakpoint %d.\n"
7029 "You may have requested too many hardware breakpoints.\n",
7034 fprintf_unfiltered (tmp_error_stream
, "Cannot insert breakpoint %d.\n", b
->number
);
7035 fprintf_filtered (tmp_error_stream
, "Error accessing memory address ");
7036 deprecated_print_address_numeric (b
->loc
->address
, 1, tmp_error_stream
);
7037 fprintf_filtered (tmp_error_stream
, ": %s.\n",
7038 safe_strerror (val
));
7041 fprintf_unfiltered (tmp_error_stream
,"The same program may be running in another process.");
7042 target_terminal_ours_for_output ();
7043 error_stream(tmp_error_stream
);
7046 b
->loc
->inserted
= 1;
7050 free_command_lines (&bpt
->commands
);
7053 if (bpt
->cond_string
!= NULL
)
7054 xfree (bpt
->cond_string
);
7055 if (bpt
->addr_string
!= NULL
)
7056 xfree (bpt
->addr_string
);
7057 if (bpt
->exp
!= NULL
)
7059 if (bpt
->exp_string
!= NULL
)
7060 xfree (bpt
->exp_string
);
7061 if (bpt
->val
!= NULL
)
7062 value_free (bpt
->val
);
7063 if (bpt
->source_file
!= NULL
)
7064 xfree (bpt
->source_file
);
7065 if (bpt
->dll_pathname
!= NULL
)
7066 xfree (bpt
->dll_pathname
);
7067 if (bpt
->triggered_dll_pathname
!= NULL
)
7068 xfree (bpt
->triggered_dll_pathname
);
7069 if (bpt
->exec_pathname
!= NULL
)
7070 xfree (bpt
->exec_pathname
);
7072 /* Be sure no bpstat's are pointing at it after it's been freed. */
7073 /* FIXME, how can we find all bpstat's?
7074 We just check stop_bpstat for now. */
7075 for (bs
= stop_bpstat
; bs
; bs
= bs
->next
)
7076 if (bs
->breakpoint_at
== bpt
)
7078 bs
->breakpoint_at
= NULL
;
7080 /* bs->commands will be freed later. */
7082 /* On the chance that someone will soon try again to delete this same
7083 bp, we mark it as deleted before freeing its storage. */
7084 bpt
->type
= bp_none
;
7091 do_delete_breakpoint_cleanup (void *b
)
7093 delete_breakpoint (b
);
7097 make_cleanup_delete_breakpoint (struct breakpoint
*b
)
7099 return make_cleanup (do_delete_breakpoint_cleanup
, b
);
7103 make_exec_cleanup_delete_breakpoint (struct breakpoint
*b
)
7105 return make_exec_cleanup (do_delete_breakpoint_cleanup
, b
);
7109 delete_command (char *arg
, int from_tty
)
7111 struct breakpoint
*b
, *temp
;
7117 int breaks_to_delete
= 0;
7119 /* Delete all breakpoints if no argument.
7120 Do not delete internal or call-dummy breakpoints, these
7121 have to be deleted with an explicit breakpoint number argument. */
7124 if (b
->type
!= bp_call_dummy
&&
7125 b
->type
!= bp_shlib_event
&&
7126 b
->type
!= bp_thread_event
&&
7127 b
->type
!= bp_overlay_event
&&
7129 breaks_to_delete
= 1;
7132 /* Ask user only if there are some breakpoints to delete. */
7134 || (breaks_to_delete
&& query (_("Delete all breakpoints? "))))
7136 ALL_BREAKPOINTS_SAFE (b
, temp
)
7138 if (b
->type
!= bp_call_dummy
&&
7139 b
->type
!= bp_shlib_event
&&
7140 b
->type
!= bp_thread_event
&&
7141 b
->type
!= bp_overlay_event
&&
7143 delete_breakpoint (b
);
7148 map_breakpoint_numbers (arg
, delete_breakpoint
);
7151 /* Reset a breakpoint given it's struct breakpoint * BINT.
7152 The value we return ends up being the return value from catch_errors.
7153 Unused in this case. */
7156 breakpoint_re_set_one (void *bint
)
7158 /* get past catch_errs */
7159 struct breakpoint
*b
= (struct breakpoint
*) bint
;
7163 int *not_found_ptr
= NULL
;
7164 struct symtabs_and_lines sals
;
7166 enum enable_state save_enable
;
7171 warning (_("attempted to reset apparently deleted breakpoint #%d?"),
7175 case bp_hardware_breakpoint
:
7177 case bp_catch_unload
:
7178 if (b
->addr_string
== NULL
)
7180 /* Anything without a string can't be re-set. */
7181 delete_breakpoint (b
);
7184 /* HACK: cagney/2001-11-11: kettenis/2001-11-11: MarkK wrote:
7186 ``And a hack it is, although Apple's Darwin version of GDB
7187 contains an almost identical hack to implement a "future
7188 break" command. It seems to work in many real world cases,
7189 but it is easy to come up with a test case where the patch
7190 doesn't help at all.''
7192 ``It seems that the way GDB implements breakpoints - in -
7193 shared - libraries was designed for a.out shared library
7194 systems (SunOS 4) where shared libraries were loaded at a
7195 fixed address in memory. Since ELF shared libraries can (and
7196 will) be loaded at any address in memory, things break.
7197 Fixing this is not trivial. Therefore, I'm not sure whether
7198 we should add this hack to the branch only. I cannot
7199 guarantee that things will be fixed on the trunk in the near
7202 In case we have a problem, disable this breakpoint. We'll
7203 restore its status if we succeed. Don't disable a
7204 shlib_disabled breakpoint though. There's a fair chance we
7205 can't re-set it if the shared library it's in hasn't been
7211 save_enable
= b
->enable_state
;
7212 if (b
->enable_state
!= bp_shlib_disabled
)
7213 b
->enable_state
= bp_disabled
;
7215 /* If resetting a shlib-disabled breakpoint, we don't want to
7216 see an error message if it is not found since we will expect
7217 this to occur until the shared library is finally reloaded.
7218 We accomplish this by giving decode_line_1 a pointer to use
7219 for silent notification that the symbol is not found. */
7220 not_found_ptr
= ¬_found
;
7222 set_language (b
->language
);
7223 input_radix
= b
->input_radix
;
7225 sals
= decode_line_1 (&s
, 1, (struct symtab
*) NULL
, 0, (char ***) NULL
,
7227 for (i
= 0; i
< sals
.nelts
; i
++)
7229 resolve_sal_pc (&sals
.sals
[i
]);
7231 /* Reparse conditions, they might contain references to the
7233 if (b
->cond_string
!= NULL
)
7239 /* Avoid re-freeing b->exp if an error during the call
7243 b
->cond
= parse_exp_1 (&s
, block_for_pc (sals
.sals
[i
].pc
), 0);
7246 /* We need to re-set the breakpoint if the address changes... */
7247 if (b
->loc
->address
!= sals
.sals
[i
].pc
7248 /* ...or new and old breakpoints both have source files, and
7249 the source file name or the line number changes... */
7250 || (b
->source_file
!= NULL
7251 && sals
.sals
[i
].symtab
!= NULL
7252 && (strcmp (b
->source_file
, sals
.sals
[i
].symtab
->filename
) != 0
7253 || b
->line_number
!= sals
.sals
[i
].line
)
7255 /* ...or we switch between having a source file and not having
7257 || ((b
->source_file
== NULL
) != (sals
.sals
[i
].symtab
== NULL
))
7260 if (b
->source_file
!= NULL
)
7261 xfree (b
->source_file
);
7262 if (sals
.sals
[i
].symtab
== NULL
)
7263 b
->source_file
= NULL
;
7266 savestring (sals
.sals
[i
].symtab
->filename
,
7267 strlen (sals
.sals
[i
].symtab
->filename
));
7268 b
->line_number
= sals
.sals
[i
].line
;
7269 b
->loc
->requested_address
= sals
.sals
[i
].pc
;
7271 = adjust_breakpoint_address (b
->loc
->requested_address
,
7274 /* Used to check for duplicates here, but that can
7275 cause trouble, as it doesn't check for disabled
7280 /* Might be better to do this just once per breakpoint_re_set,
7281 rather than once for every breakpoint. */
7282 breakpoints_changed ();
7284 b
->loc
->section
= sals
.sals
[i
].section
;
7285 b
->enable_state
= save_enable
; /* Restore it, this worked. */
7288 /* Now that this is re-enabled, check_duplicates
7290 check_duplicates (b
);
7297 case bp_hardware_watchpoint
:
7298 case bp_read_watchpoint
:
7299 case bp_access_watchpoint
:
7300 innermost_block
= NULL
;
7301 /* The issue arises of what context to evaluate this in. The
7302 same one as when it was set, but what does that mean when
7303 symbols have been re-read? We could save the filename and
7304 functionname, but if the context is more local than that, the
7305 best we could do would be something like how many levels deep
7306 and which index at that particular level, but that's going to
7307 be less stable than filenames or function names. */
7309 /* So for now, just use a global context. */
7313 /* Avoid re-freeing b->exp if an error during the call to
7314 parse_expression. */
7317 b
->exp
= parse_expression (b
->exp_string
);
7318 b
->exp_valid_block
= innermost_block
;
7319 mark
= value_mark ();
7322 value_free (b
->val
);
7323 /* Avoid re-freeing b->val if an error during the call to
7324 evaluate_expression. */
7327 b
->val
= evaluate_expression (b
->exp
);
7328 release_value (b
->val
);
7329 if (value_lazy (b
->val
) && breakpoint_enabled (b
))
7330 value_fetch_lazy (b
->val
);
7332 if (b
->cond_string
!= NULL
)
7338 /* Avoid re-freeing b->exp if an error during the call
7342 b
->cond
= parse_exp_1 (&s
, (struct block
*) 0, 0);
7344 if (breakpoint_enabled (b
))
7346 value_free_to_mark (mark
);
7348 case bp_catch_catch
:
7349 case bp_catch_throw
:
7351 /* We needn't really do anything to reset these, since the mask
7352 that requests them is unaffected by e.g., new libraries being
7355 case bp_catch_vfork
:
7360 printf_filtered (_("Deleting unknown breakpoint type %d\n"), b
->type
);
7362 /* Delete longjmp and overlay event breakpoints; they will be
7363 reset later by breakpoint_re_set. */
7365 case bp_longjmp_resume
:
7366 case bp_overlay_event
:
7367 delete_breakpoint (b
);
7370 /* This breakpoint is special, it's set up when the inferior
7371 starts and we really don't want to touch it. */
7372 case bp_shlib_event
:
7374 /* Like bp_shlib_event, this breakpoint type is special.
7375 Once it is set up, we do not want to touch it. */
7376 case bp_thread_event
:
7378 /* Keep temporary breakpoints, which can be encountered when we step
7379 over a dlopen call and SOLIB_ADD is resetting the breakpoints.
7380 Otherwise these should have been blown away via the cleanup chain
7381 or by breakpoint_init_inferior when we rerun the executable. */
7384 case bp_watchpoint_scope
:
7386 case bp_step_resume
:
7393 /* Re-set all breakpoints after symbols have been re-loaded. */
7395 breakpoint_re_set (void)
7397 struct breakpoint
*b
, *temp
;
7398 enum language save_language
;
7399 int save_input_radix
;
7401 save_language
= current_language
->la_language
;
7402 save_input_radix
= input_radix
;
7403 ALL_BREAKPOINTS_SAFE (b
, temp
)
7405 /* Format possible error msg */
7406 char *message
= xstrprintf ("Error in re-setting breakpoint %d:\n",
7408 struct cleanup
*cleanups
= make_cleanup (xfree
, message
);
7409 catch_errors (breakpoint_re_set_one
, b
, message
, RETURN_MASK_ALL
);
7410 do_cleanups (cleanups
);
7412 set_language (save_language
);
7413 input_radix
= save_input_radix
;
7415 if (GET_LONGJMP_TARGET_P ())
7417 create_longjmp_breakpoint ("longjmp");
7418 create_longjmp_breakpoint ("_longjmp");
7419 create_longjmp_breakpoint ("siglongjmp");
7420 create_longjmp_breakpoint ("_siglongjmp");
7421 create_longjmp_breakpoint (NULL
);
7424 create_overlay_event_breakpoint ("_ovly_debug_event");
7427 /* Reset the thread number of this breakpoint:
7429 - If the breakpoint is for all threads, leave it as-is.
7430 - Else, reset it to the current thread for inferior_ptid. */
7432 breakpoint_re_set_thread (struct breakpoint
*b
)
7434 if (b
->thread
!= -1)
7436 if (in_thread_list (inferior_ptid
))
7437 b
->thread
= pid_to_thread_id (inferior_ptid
);
7441 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
7442 If from_tty is nonzero, it prints a message to that effect,
7443 which ends with a period (no newline). */
7446 set_ignore_count (int bptnum
, int count
, int from_tty
)
7448 struct breakpoint
*b
;
7454 if (b
->number
== bptnum
)
7456 b
->ignore_count
= count
;
7460 printf_filtered (_("Will stop next time breakpoint %d is reached."),
7462 else if (count
== 1)
7463 printf_filtered (_("Will ignore next crossing of breakpoint %d."),
7466 printf_filtered (_("Will ignore next %d crossings of breakpoint %d."),
7469 breakpoints_changed ();
7470 breakpoint_modify_event (b
->number
);
7474 error (_("No breakpoint number %d."), bptnum
);
7477 /* Clear the ignore counts of all breakpoints. */
7479 breakpoint_clear_ignore_counts (void)
7481 struct breakpoint
*b
;
7484 b
->ignore_count
= 0;
7487 /* Command to set ignore-count of breakpoint N to COUNT. */
7490 ignore_command (char *args
, int from_tty
)
7496 error_no_arg (_("a breakpoint number"));
7498 num
= get_number (&p
);
7500 error (_("bad breakpoint number: '%s'"), args
);
7502 error (_("Second argument (specified ignore-count) is missing."));
7504 set_ignore_count (num
,
7505 longest_to_int (value_as_long (parse_and_eval (p
))),
7508 printf_filtered ("\n");
7511 /* Call FUNCTION on each of the breakpoints
7512 whose numbers are given in ARGS. */
7515 map_breakpoint_numbers (char *args
, void (*function
) (struct breakpoint
*))
7520 struct breakpoint
*b
, *tmp
;
7524 error_no_arg (_("one or more breakpoint numbers"));
7531 num
= get_number_or_range (&p1
);
7534 warning (_("bad breakpoint number at or near '%s'"), p
);
7538 ALL_BREAKPOINTS_SAFE (b
, tmp
)
7539 if (b
->number
== num
)
7541 struct breakpoint
*related_breakpoint
= b
->related_breakpoint
;
7544 if (related_breakpoint
)
7545 function (related_breakpoint
);
7549 printf_unfiltered (_("No breakpoint number %d.\n"), num
);
7555 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
7556 If from_tty is nonzero, it prints a message to that effect,
7557 which ends with a period (no newline). */
7560 disable_breakpoint (struct breakpoint
*bpt
)
7562 /* Never disable a watchpoint scope breakpoint; we want to
7563 hit them when we leave scope so we can delete both the
7564 watchpoint and its scope breakpoint at that time. */
7565 if (bpt
->type
== bp_watchpoint_scope
)
7568 /* You can't disable permanent breakpoints. */
7569 if (bpt
->enable_state
== bp_permanent
)
7572 bpt
->enable_state
= bp_disabled
;
7574 check_duplicates (bpt
);
7576 if (deprecated_modify_breakpoint_hook
)
7577 deprecated_modify_breakpoint_hook (bpt
);
7578 breakpoint_modify_event (bpt
->number
);
7582 disable_command (char *args
, int from_tty
)
7584 struct breakpoint
*bpt
;
7586 ALL_BREAKPOINTS (bpt
)
7590 warning (_("attempted to disable apparently deleted breakpoint #%d?"),
7595 case bp_catch_unload
:
7597 case bp_catch_vfork
:
7599 case bp_catch_catch
:
7600 case bp_catch_throw
:
7601 case bp_hardware_breakpoint
:
7603 case bp_hardware_watchpoint
:
7604 case bp_read_watchpoint
:
7605 case bp_access_watchpoint
:
7606 disable_breakpoint (bpt
);
7611 map_breakpoint_numbers (args
, disable_breakpoint
);
7615 do_enable_breakpoint (struct breakpoint
*bpt
, enum bpdisp disposition
)
7617 int target_resources_ok
, other_type_used
;
7620 if (bpt
->type
== bp_hardware_breakpoint
)
7623 i
= hw_breakpoint_used_count ();
7624 target_resources_ok
=
7625 TARGET_CAN_USE_HARDWARE_WATCHPOINT (bp_hardware_breakpoint
,
7627 if (target_resources_ok
== 0)
7628 error (_("No hardware breakpoint support in the target."));
7629 else if (target_resources_ok
< 0)
7630 error (_("Hardware breakpoints used exceeds limit."));
7635 if (bpt
->enable_state
!= bp_enabled
)
7637 /* When enabling a pending breakpoint, we need to check if the breakpoint
7638 is resolvable since shared libraries could have been loaded
7639 after the breakpoint was disabled. */
7640 breakpoints_changed ();
7641 if (resolve_pending_breakpoint (bpt
) == GDB_RC_OK
)
7643 delete_breakpoint (bpt
);
7646 bpt
->enable_state
= bp_enabled
;
7647 bpt
->disposition
= disposition
;
7650 else /* Not a pending breakpoint. */
7652 if (bpt
->enable_state
!= bp_permanent
)
7653 bpt
->enable_state
= bp_enabled
;
7654 bpt
->disposition
= disposition
;
7655 check_duplicates (bpt
);
7656 breakpoints_changed ();
7658 if (bpt
->type
== bp_watchpoint
||
7659 bpt
->type
== bp_hardware_watchpoint
||
7660 bpt
->type
== bp_read_watchpoint
||
7661 bpt
->type
== bp_access_watchpoint
)
7663 struct frame_id saved_frame_id
;
7665 saved_frame_id
= get_frame_id (get_selected_frame (NULL
));
7666 if (bpt
->exp_valid_block
!= NULL
)
7668 struct frame_info
*fr
=
7669 fr
= frame_find_by_id (bpt
->watchpoint_frame
);
7672 printf_filtered (_("\
7673 Cannot enable watchpoint %d because the block in which its expression\n\
7674 is valid is not currently in scope.\n"), bpt
->number
);
7675 bpt
->enable_state
= bp_disabled
;
7681 value_free (bpt
->val
);
7682 mark
= value_mark ();
7683 bpt
->val
= evaluate_expression (bpt
->exp
);
7684 release_value (bpt
->val
);
7685 if (value_lazy (bpt
->val
))
7686 value_fetch_lazy (bpt
->val
);
7688 if (bpt
->type
== bp_hardware_watchpoint
||
7689 bpt
->type
== bp_read_watchpoint
||
7690 bpt
->type
== bp_access_watchpoint
)
7692 int i
= hw_watchpoint_used_count (bpt
->type
, &other_type_used
);
7693 int mem_cnt
= can_use_hardware_watchpoint (bpt
->val
);
7695 /* Hack around 'unused var' error for some targets here */
7696 (void) mem_cnt
, (void) i
;
7697 target_resources_ok
= TARGET_CAN_USE_HARDWARE_WATCHPOINT (
7698 bpt
->type
, i
+ mem_cnt
, other_type_used
);
7699 /* we can consider of type is bp_hardware_watchpoint, convert to
7700 bp_watchpoint in the following condition */
7701 if (target_resources_ok
< 0)
7703 printf_filtered (_("\
7704 Cannot enable watchpoint %d because target watch resources\n\
7705 have been allocated for other watchpoints.\n"), bpt
->number
);
7706 bpt
->enable_state
= bp_disabled
;
7707 value_free_to_mark (mark
);
7712 select_frame (frame_find_by_id (saved_frame_id
));
7713 value_free_to_mark (mark
);
7717 if (deprecated_modify_breakpoint_hook
)
7718 deprecated_modify_breakpoint_hook (bpt
);
7719 breakpoint_modify_event (bpt
->number
);
7723 enable_breakpoint (struct breakpoint
*bpt
)
7725 do_enable_breakpoint (bpt
, bpt
->disposition
);
7728 /* The enable command enables the specified breakpoints (or all defined
7729 breakpoints) so they once again become (or continue to be) effective
7730 in stopping the inferior. */
7733 enable_command (char *args
, int from_tty
)
7735 struct breakpoint
*bpt
;
7737 ALL_BREAKPOINTS (bpt
)
7741 warning (_("attempted to enable apparently deleted breakpoint #%d?"),
7746 case bp_catch_unload
:
7748 case bp_catch_vfork
:
7750 case bp_catch_catch
:
7751 case bp_catch_throw
:
7752 case bp_hardware_breakpoint
:
7754 case bp_hardware_watchpoint
:
7755 case bp_read_watchpoint
:
7756 case bp_access_watchpoint
:
7757 enable_breakpoint (bpt
);
7762 map_breakpoint_numbers (args
, enable_breakpoint
);
7766 enable_once_breakpoint (struct breakpoint
*bpt
)
7768 do_enable_breakpoint (bpt
, disp_disable
);
7772 enable_once_command (char *args
, int from_tty
)
7774 map_breakpoint_numbers (args
, enable_once_breakpoint
);
7778 enable_delete_breakpoint (struct breakpoint
*bpt
)
7780 do_enable_breakpoint (bpt
, disp_del
);
7784 enable_delete_command (char *args
, int from_tty
)
7786 map_breakpoint_numbers (args
, enable_delete_breakpoint
);
7790 set_breakpoint_cmd (char *args
, int from_tty
)
7795 show_breakpoint_cmd (char *args
, int from_tty
)
7799 /* Use default_breakpoint_'s, or nothing if they aren't valid. */
7801 struct symtabs_and_lines
7802 decode_line_spec_1 (char *string
, int funfirstline
)
7804 struct symtabs_and_lines sals
;
7806 error (_("Empty line specification."));
7807 if (default_breakpoint_valid
)
7808 sals
= decode_line_1 (&string
, funfirstline
,
7809 default_breakpoint_symtab
,
7810 default_breakpoint_line
,
7811 (char ***) NULL
, NULL
);
7813 sals
= decode_line_1 (&string
, funfirstline
,
7814 (struct symtab
*) NULL
, 0, (char ***) NULL
, NULL
);
7816 error (_("Junk at end of line specification: %s"), string
);
7820 /* Create and insert a raw software breakpoint at PC. Return an
7821 identifier, which should be used to remove the breakpoint later.
7822 In general, places which call this should be using something on the
7823 breakpoint chain instead; this function should be eliminated
7827 deprecated_insert_raw_breakpoint (CORE_ADDR pc
)
7829 struct bp_target_info
*bp_tgt
;
7831 bp_tgt
= xmalloc (sizeof (struct bp_target_info
));
7832 memset (bp_tgt
, 0, sizeof (struct bp_target_info
));
7834 bp_tgt
->placed_address
= pc
;
7835 if (target_insert_breakpoint (bp_tgt
) != 0)
7837 /* Could not insert the breakpoint. */
7845 /* Remove a breakpoint BP inserted by deprecated_insert_raw_breakpoint. */
7848 deprecated_remove_raw_breakpoint (void *bp
)
7850 struct bp_target_info
*bp_tgt
= bp
;
7853 ret
= target_remove_breakpoint (bp_tgt
);
7859 /* One (or perhaps two) breakpoints used for software single stepping. */
7861 static void *single_step_breakpoints
[2];
7863 /* Create and insert a breakpoint for software single step. */
7866 insert_single_step_breakpoint (CORE_ADDR next_pc
)
7870 if (single_step_breakpoints
[0] == NULL
)
7871 bpt_p
= &single_step_breakpoints
[0];
7874 gdb_assert (single_step_breakpoints
[1] == NULL
);
7875 bpt_p
= &single_step_breakpoints
[1];
7878 /* NOTE drow/2006-04-11: A future improvement to this function would be
7879 to only create the breakpoints once, and actually put them on the
7880 breakpoint chain. That would let us use set_raw_breakpoint. We could
7881 adjust the addresses each time they were needed. Doing this requires
7882 corresponding changes elsewhere where single step breakpoints are
7883 handled, however. So, for now, we use this. */
7885 *bpt_p
= deprecated_insert_raw_breakpoint (next_pc
);
7887 error (_("Could not insert single-step breakpoint at 0x%s"),
7888 paddr_nz (next_pc
));
7891 /* Remove and delete any breakpoints used for software single step. */
7894 remove_single_step_breakpoints (void)
7896 gdb_assert (single_step_breakpoints
[0] != NULL
);
7898 /* See insert_single_step_breakpoint for more about this deprecated
7900 deprecated_remove_raw_breakpoint (single_step_breakpoints
[0]);
7901 single_step_breakpoints
[0] = NULL
;
7903 if (single_step_breakpoints
[1] != NULL
)
7905 deprecated_remove_raw_breakpoint (single_step_breakpoints
[1]);
7906 single_step_breakpoints
[1] = NULL
;
7911 /* This help string is used for the break, hbreak, tbreak and thbreak commands.
7912 It is defined as a macro to prevent duplication.
7913 COMMAND should be a string constant containing the name of the command. */
7914 #define BREAK_ARGS_HELP(command) \
7915 command" [LOCATION] [thread THREADNUM] [if CONDITION]\n\
7916 LOCATION may be a line number, function name, or \"*\" and an address.\n\
7917 If a line number is specified, break at start of code for that line.\n\
7918 If a function is specified, break at start of code for that function.\n\
7919 If an address is specified, break at that exact address.\n\
7920 With no LOCATION, uses current execution address of selected stack frame.\n\
7921 This is useful for breaking on return to a stack frame.\n\
7923 THREADNUM is the number from \"info threads\".\n\
7924 CONDITION is a boolean expression.\n\
7926 Multiple breakpoints at one place are permitted, and useful if conditional.\n\
7928 Do \"help breakpoints\" for info on other commands dealing with breakpoints."
7931 _initialize_breakpoint (void)
7933 static struct cmd_list_element
*breakpoint_set_cmdlist
;
7934 static struct cmd_list_element
*breakpoint_show_cmdlist
;
7935 struct cmd_list_element
*c
;
7937 observer_attach_solib_unloaded (disable_breakpoints_in_unloaded_shlib
);
7939 breakpoint_chain
= 0;
7940 /* Don't bother to call set_breakpoint_count. $bpnum isn't useful
7941 before a breakpoint is set. */
7942 breakpoint_count
= 0;
7944 add_com ("ignore", class_breakpoint
, ignore_command
, _("\
7945 Set ignore-count of breakpoint number N to COUNT.\n\
7946 Usage is `ignore N COUNT'."));
7948 add_com_alias ("bc", "ignore", class_breakpoint
, 1);
7950 add_com ("commands", class_breakpoint
, commands_command
, _("\
7951 Set commands to be executed when a breakpoint is hit.\n\
7952 Give breakpoint number as argument after \"commands\".\n\
7953 With no argument, the targeted breakpoint is the last one set.\n\
7954 The commands themselves follow starting on the next line.\n\
7955 Type a line containing \"end\" to indicate the end of them.\n\
7956 Give \"silent\" as the first line to make the breakpoint silent;\n\
7957 then no output is printed when it is hit, except what the commands print."));
7959 add_com ("condition", class_breakpoint
, condition_command
, _("\
7960 Specify breakpoint number N to break only if COND is true.\n\
7961 Usage is `condition N COND', where N is an integer and COND is an\n\
7962 expression to be evaluated whenever breakpoint N is reached."));
7964 c
= add_com ("tbreak", class_breakpoint
, tbreak_command
, _("\
7965 Set a temporary breakpoint.\n\
7966 Like \"break\" except the breakpoint is only temporary,\n\
7967 so it will be deleted when hit. Equivalent to \"break\" followed\n\
7968 by using \"enable delete\" on the breakpoint number.\n\
7970 BREAK_ARGS_HELP ("tbreak")));
7971 set_cmd_completer (c
, location_completer
);
7973 c
= add_com ("hbreak", class_breakpoint
, hbreak_command
, _("\
7974 Set a hardware assisted breakpoint.\n\
7975 Like \"break\" except the breakpoint requires hardware support,\n\
7976 some target hardware may not have this support.\n\
7978 BREAK_ARGS_HELP ("hbreak")));
7979 set_cmd_completer (c
, location_completer
);
7981 c
= add_com ("thbreak", class_breakpoint
, thbreak_command
, _("\
7982 Set a temporary hardware assisted breakpoint.\n\
7983 Like \"hbreak\" except the breakpoint is only temporary,\n\
7984 so it will be deleted when hit.\n\
7986 BREAK_ARGS_HELP ("thbreak")));
7987 set_cmd_completer (c
, location_completer
);
7989 add_prefix_cmd ("enable", class_breakpoint
, enable_command
, _("\
7990 Enable some breakpoints.\n\
7991 Give breakpoint numbers (separated by spaces) as arguments.\n\
7992 With no subcommand, breakpoints are enabled until you command otherwise.\n\
7993 This is used to cancel the effect of the \"disable\" command.\n\
7994 With a subcommand you can enable temporarily."),
7995 &enablelist
, "enable ", 1, &cmdlist
);
7997 add_com ("ab", class_breakpoint
, enable_command
, _("\
7998 Enable some breakpoints.\n\
7999 Give breakpoint numbers (separated by spaces) as arguments.\n\
8000 With no subcommand, breakpoints are enabled until you command otherwise.\n\
8001 This is used to cancel the effect of the \"disable\" command.\n\
8002 With a subcommand you can enable temporarily."));
8004 add_com_alias ("en", "enable", class_breakpoint
, 1);
8006 add_abbrev_prefix_cmd ("breakpoints", class_breakpoint
, enable_command
, _("\
8007 Enable some breakpoints.\n\
8008 Give breakpoint numbers (separated by spaces) as arguments.\n\
8009 This is used to cancel the effect of the \"disable\" command.\n\
8010 May be abbreviated to simply \"enable\".\n"),
8011 &enablebreaklist
, "enable breakpoints ", 1, &enablelist
);
8013 add_cmd ("once", no_class
, enable_once_command
, _("\
8014 Enable breakpoints for one hit. Give breakpoint numbers.\n\
8015 If a breakpoint is hit while enabled in this fashion, it becomes disabled."),
8018 add_cmd ("delete", no_class
, enable_delete_command
, _("\
8019 Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
8020 If a breakpoint is hit while enabled in this fashion, it is deleted."),
8023 add_cmd ("delete", no_class
, enable_delete_command
, _("\
8024 Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
8025 If a breakpoint is hit while enabled in this fashion, it is deleted."),
8028 add_cmd ("once", no_class
, enable_once_command
, _("\
8029 Enable breakpoints for one hit. Give breakpoint numbers.\n\
8030 If a breakpoint is hit while enabled in this fashion, it becomes disabled."),
8033 add_prefix_cmd ("disable", class_breakpoint
, disable_command
, _("\
8034 Disable some breakpoints.\n\
8035 Arguments are breakpoint numbers with spaces in between.\n\
8036 To disable all breakpoints, give no argument.\n\
8037 A disabled breakpoint is not forgotten, but has no effect until reenabled."),
8038 &disablelist
, "disable ", 1, &cmdlist
);
8039 add_com_alias ("dis", "disable", class_breakpoint
, 1);
8040 add_com_alias ("disa", "disable", class_breakpoint
, 1);
8042 add_com ("sb", class_breakpoint
, disable_command
, _("\
8043 Disable some breakpoints.\n\
8044 Arguments are breakpoint numbers with spaces in between.\n\
8045 To disable all breakpoints, give no argument.\n\
8046 A disabled breakpoint is not forgotten, but has no effect until reenabled."));
8048 add_cmd ("breakpoints", class_alias
, disable_command
, _("\
8049 Disable some breakpoints.\n\
8050 Arguments are breakpoint numbers with spaces in between.\n\
8051 To disable all breakpoints, give no argument.\n\
8052 A disabled breakpoint is not forgotten, but has no effect until reenabled.\n\
8053 This command may be abbreviated \"disable\"."),
8056 add_prefix_cmd ("delete", class_breakpoint
, delete_command
, _("\
8057 Delete some breakpoints or auto-display expressions.\n\
8058 Arguments are breakpoint numbers with spaces in between.\n\
8059 To delete all breakpoints, give no argument.\n\
8061 Also a prefix command for deletion of other GDB objects.\n\
8062 The \"unset\" command is also an alias for \"delete\"."),
8063 &deletelist
, "delete ", 1, &cmdlist
);
8064 add_com_alias ("d", "delete", class_breakpoint
, 1);
8065 add_com_alias ("del", "delete", class_breakpoint
, 1);
8067 add_com ("db", class_breakpoint
, delete_command
, _("\
8068 Delete some breakpoints.\n\
8069 Arguments are breakpoint numbers with spaces in between.\n\
8070 To delete all breakpoints, give no argument.\n"));
8072 add_cmd ("breakpoints", class_alias
, delete_command
, _("\
8073 Delete some breakpoints or auto-display expressions.\n\
8074 Arguments are breakpoint numbers with spaces in between.\n\
8075 To delete all breakpoints, give no argument.\n\
8076 This command may be abbreviated \"delete\"."),
8079 add_com ("clear", class_breakpoint
, clear_command
, _("\
8080 Clear breakpoint at specified line or function.\n\
8081 Argument may be line number, function name, or \"*\" and an address.\n\
8082 If line number is specified, all breakpoints in that line are cleared.\n\
8083 If function is specified, breakpoints at beginning of function are cleared.\n\
8084 If an address is specified, breakpoints at that address are cleared.\n\
8086 With no argument, clears all breakpoints in the line that the selected frame\n\
8089 See also the \"delete\" command which clears breakpoints by number."));
8091 c
= add_com ("break", class_breakpoint
, break_command
, _("\
8092 Set breakpoint at specified line or function.\n"
8093 BREAK_ARGS_HELP ("break")));
8094 set_cmd_completer (c
, location_completer
);
8096 add_com_alias ("b", "break", class_run
, 1);
8097 add_com_alias ("br", "break", class_run
, 1);
8098 add_com_alias ("bre", "break", class_run
, 1);
8099 add_com_alias ("brea", "break", class_run
, 1);
8103 add_com_alias ("ba", "break", class_breakpoint
, 1);
8104 add_com_alias ("bu", "ubreak", class_breakpoint
, 1);
8109 add_abbrev_prefix_cmd ("stop", class_breakpoint
, stop_command
, _("\
8110 Break in function/address or break at a line in the current file."),
8111 &stoplist
, "stop ", 1, &cmdlist
);
8112 add_cmd ("in", class_breakpoint
, stopin_command
,
8113 _("Break in function or address."), &stoplist
);
8114 add_cmd ("at", class_breakpoint
, stopat_command
,
8115 _("Break at a line in the current file."), &stoplist
);
8116 add_com ("status", class_info
, breakpoints_info
, _("\
8117 Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
8118 The \"Type\" column indicates one of:\n\
8119 \tbreakpoint - normal breakpoint\n\
8120 \twatchpoint - watchpoint\n\
8121 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
8122 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
8123 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
8124 address and file/line number respectively.\n\
8126 Convenience variable \"$_\" and default examine address for \"x\"\n\
8127 are set to the address of the last breakpoint listed.\n\n\
8128 Convenience variable \"$bpnum\" contains the number of the last\n\
8132 add_info ("breakpoints", breakpoints_info
, _("\
8133 Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
8134 The \"Type\" column indicates one of:\n\
8135 \tbreakpoint - normal breakpoint\n\
8136 \twatchpoint - watchpoint\n\
8137 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
8138 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
8139 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
8140 address and file/line number respectively.\n\
8142 Convenience variable \"$_\" and default examine address for \"x\"\n\
8143 are set to the address of the last breakpoint listed.\n\n\
8144 Convenience variable \"$bpnum\" contains the number of the last\n\
8148 add_com ("lb", class_breakpoint
, breakpoints_info
, _("\
8149 Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
8150 The \"Type\" column indicates one of:\n\
8151 \tbreakpoint - normal breakpoint\n\
8152 \twatchpoint - watchpoint\n\
8153 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
8154 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
8155 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
8156 address and file/line number respectively.\n\
8158 Convenience variable \"$_\" and default examine address for \"x\"\n\
8159 are set to the address of the last breakpoint listed.\n\n\
8160 Convenience variable \"$bpnum\" contains the number of the last\n\
8163 add_cmd ("breakpoints", class_maintenance
, maintenance_info_breakpoints
, _("\
8164 Status of all breakpoints, or breakpoint number NUMBER.\n\
8165 The \"Type\" column indicates one of:\n\
8166 \tbreakpoint - normal breakpoint\n\
8167 \twatchpoint - watchpoint\n\
8168 \tlongjmp - internal breakpoint used to step through longjmp()\n\
8169 \tlongjmp resume - internal breakpoint at the target of longjmp()\n\
8170 \tuntil - internal breakpoint used by the \"until\" command\n\
8171 \tfinish - internal breakpoint used by the \"finish\" command\n\
8172 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
8173 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
8174 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
8175 address and file/line number respectively.\n\
8177 Convenience variable \"$_\" and default examine address for \"x\"\n\
8178 are set to the address of the last breakpoint listed.\n\
8180 Convenience variable \"$bpnum\" contains the number of the last\n\
8182 &maintenanceinfolist
);
8184 add_com ("catch", class_breakpoint
, catch_command
, _("\
8185 Set catchpoints to catch events.\n\
8186 Raised signals may be caught:\n\
8187 \tcatch signal - all signals\n\
8188 \tcatch signal <signame> - a particular signal\n\
8189 Raised exceptions may be caught:\n\
8190 \tcatch throw - all exceptions, when thrown\n\
8191 \tcatch throw <exceptname> - a particular exception, when thrown\n\
8192 \tcatch catch - all exceptions, when caught\n\
8193 \tcatch catch <exceptname> - a particular exception, when caught\n\
8194 Thread or process events may be caught:\n\
8195 \tcatch thread_start - any threads, just after creation\n\
8196 \tcatch thread_exit - any threads, just before expiration\n\
8197 \tcatch thread_join - any threads, just after joins\n\
8198 Process events may be caught:\n\
8199 \tcatch start - any processes, just after creation\n\
8200 \tcatch exit - any processes, just before expiration\n\
8201 \tcatch fork - calls to fork()\n\
8202 \tcatch vfork - calls to vfork()\n\
8203 \tcatch exec - calls to exec()\n\
8204 Dynamically-linked library events may be caught:\n\
8205 \tcatch load - loads of any library\n\
8206 \tcatch load <libname> - loads of a particular library\n\
8207 \tcatch unload - unloads of any library\n\
8208 \tcatch unload <libname> - unloads of a particular library\n\
8209 The act of your program's execution stopping may also be caught:\n\
8211 C++ exceptions may be caught:\n\
8212 \tcatch throw - all exceptions, when thrown\n\
8213 \tcatch catch - all exceptions, when caught\n\
8214 Ada exceptions may be caught:\n\
8215 \tcatch exception - all exceptions, when raised\n\
8216 \tcatch exception <name> - a particular exception, when raised\n\
8217 \tcatch exception unhandled - all unhandled exceptions, when raised\n\
8218 \tcatch assert - all failed assertions, when raised\n\
8220 Do \"help set follow-fork-mode\" for info on debugging your program\n\
8221 after a fork or vfork is caught.\n\n\
8222 Do \"help breakpoints\" for info on other commands dealing with breakpoints."));
8224 add_com ("tcatch", class_breakpoint
, tcatch_command
, _("\
8225 Set temporary catchpoints to catch events.\n\
8226 Args like \"catch\" command.\n\
8227 Like \"catch\" except the catchpoint is only temporary,\n\
8228 so it will be deleted when hit. Equivalent to \"catch\" followed\n\
8229 by using \"enable delete\" on the catchpoint number."));
8231 c
= add_com ("watch", class_breakpoint
, watch_command
, _("\
8232 Set a watchpoint for an expression.\n\
8233 A watchpoint stops execution of your program whenever the value of\n\
8234 an expression changes."));
8235 set_cmd_completer (c
, location_completer
);
8237 c
= add_com ("rwatch", class_breakpoint
, rwatch_command
, _("\
8238 Set a read watchpoint for an expression.\n\
8239 A watchpoint stops execution of your program whenever the value of\n\
8240 an expression is read."));
8241 set_cmd_completer (c
, location_completer
);
8243 c
= add_com ("awatch", class_breakpoint
, awatch_command
, _("\
8244 Set a watchpoint for an expression.\n\
8245 A watchpoint stops execution of your program whenever the value of\n\
8246 an expression is either read or written."));
8247 set_cmd_completer (c
, location_completer
);
8249 add_info ("watchpoints", breakpoints_info
,
8250 _("Synonym for ``info breakpoints''."));
8253 /* XXX: cagney/2005-02-23: This should be a boolean, and should
8254 respond to changes - contrary to the description. */
8255 add_setshow_zinteger_cmd ("can-use-hw-watchpoints", class_support
,
8256 &can_use_hw_watchpoints
, _("\
8257 Set debugger's willingness to use watchpoint hardware."), _("\
8258 Show debugger's willingness to use watchpoint hardware."), _("\
8259 If zero, gdb will not use hardware for new watchpoints, even if\n\
8260 such is available. (However, any hardware watchpoints that were\n\
8261 created before setting this to nonzero, will continue to use watchpoint\n\
8264 show_can_use_hw_watchpoints
,
8265 &setlist
, &showlist
);
8267 can_use_hw_watchpoints
= 1;
8269 add_prefix_cmd ("breakpoint", class_maintenance
, set_breakpoint_cmd
, _("\
8270 Breakpoint specific settings\n\
8271 Configure various breakpoint-specific variables such as\n\
8272 pending breakpoint behavior"),
8273 &breakpoint_set_cmdlist
, "set breakpoint ",
8274 0/*allow-unknown*/, &setlist
);
8275 add_prefix_cmd ("breakpoint", class_maintenance
, show_breakpoint_cmd
, _("\
8276 Breakpoint specific settings\n\
8277 Configure various breakpoint-specific variables such as\n\
8278 pending breakpoint behavior"),
8279 &breakpoint_show_cmdlist
, "show breakpoint ",
8280 0/*allow-unknown*/, &showlist
);
8282 add_setshow_auto_boolean_cmd ("pending", no_class
,
8283 &pending_break_support
, _("\
8284 Set debugger's behavior regarding pending breakpoints."), _("\
8285 Show debugger's behavior regarding pending breakpoints."), _("\
8286 If on, an unrecognized breakpoint location will cause gdb to create a\n\
8287 pending breakpoint. If off, an unrecognized breakpoint location results in\n\
8288 an error. If auto, an unrecognized breakpoint location results in a\n\
8289 user-query to see if a pending breakpoint should be created."),
8291 show_pending_break_support
,
8292 &breakpoint_set_cmdlist
,
8293 &breakpoint_show_cmdlist
);
8295 pending_break_support
= AUTO_BOOLEAN_AUTO
;
8297 add_setshow_boolean_cmd ("auto-hw", no_class
,
8298 &automatic_hardware_breakpoints
, _("\
8299 Set automatic usage of hardware breakpoints."), _("\
8300 Show automatic usage of hardware breakpoints."), _("\
8301 If set, the debugger will automatically use hardware breakpoints for\n\
8302 breakpoints set with \"break\" but falling in read-only memory. If not set,\n\
8303 a warning will be emitted for such breakpoints."),
8305 show_automatic_hardware_breakpoints
,
8306 &breakpoint_set_cmdlist
,
8307 &breakpoint_show_cmdlist
);
8309 automatic_hardware_breakpoints
= 1;