1 /* Everything about breakpoints, for GDB.
3 Copyright (C) 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
4 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007
5 Free Software Foundation, Inc.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 51 Franklin Street, Fifth Floor,
22 Boston, MA 02110-1301, USA. */
28 #include "breakpoint.h"
30 #include "expression.h"
36 #include "gdbthread.h"
39 #include "gdb_string.h"
46 #include "completer.h"
49 #include "cli/cli-script.h"
50 #include "gdb_assert.h"
55 #include "exceptions.h"
59 #include "gdb-events.h"
60 #include "mi/mi-common.h"
62 /* Prototypes for local functions. */
64 static void until_break_command_continuation (struct continuation_arg
*arg
);
66 static void catch_command_1 (char *, int, int);
68 static void enable_delete_command (char *, int);
70 static void enable_delete_breakpoint (struct breakpoint
*);
72 static void enable_once_command (char *, int);
74 static void enable_once_breakpoint (struct breakpoint
*);
76 static void disable_command (char *, int);
78 static void enable_command (char *, int);
80 static void map_breakpoint_numbers (char *, void (*)(struct breakpoint
*));
82 static void ignore_command (char *, int);
84 static int breakpoint_re_set_one (void *);
86 static void clear_command (char *, int);
88 static void catch_command (char *, int);
90 static void watch_command (char *, int);
92 static int can_use_hardware_watchpoint (struct value
*);
94 static int break_command_1 (char *, int, int, struct breakpoint
*);
96 static void mention (struct breakpoint
*);
98 struct breakpoint
*set_raw_breakpoint (struct symtab_and_line
, enum bptype
);
100 static void check_duplicates (struct breakpoint
*);
102 static void breakpoint_adjustment_warning (CORE_ADDR
, CORE_ADDR
, int, int);
104 static CORE_ADDR
adjust_breakpoint_address (CORE_ADDR bpaddr
,
107 static void describe_other_breakpoints (CORE_ADDR
, asection
*, int);
109 static void breakpoints_info (char *, int);
111 static void breakpoint_1 (int, int);
113 static bpstat
bpstat_alloc (struct breakpoint
*, bpstat
);
115 static int breakpoint_cond_eval (void *);
117 static void cleanup_executing_breakpoints (void *);
119 static void commands_command (char *, int);
121 static void condition_command (char *, int);
123 static int get_number_trailer (char **, int);
125 void set_breakpoint_count (int);
134 static int remove_breakpoint (struct bp_location
*, insertion_state_t
);
136 static enum print_stop_action
print_it_typical (bpstat
);
138 static enum print_stop_action
print_bp_stop_message (bpstat bs
);
142 enum exception_event_kind kind
;
145 args_for_catchpoint_enable
;
147 static int watchpoint_check (void *);
149 static int cover_target_enable_exception_callback (void *);
151 static void maintenance_info_breakpoints (char *, int);
153 static void create_longjmp_breakpoint (char *);
155 static void create_overlay_event_breakpoint (char *);
157 static int hw_breakpoint_used_count (void);
159 static int hw_watchpoint_used_count (enum bptype
, int *);
161 static void hbreak_command (char *, int);
163 static void thbreak_command (char *, int);
165 static void watch_command_1 (char *, int, int);
167 static void rwatch_command (char *, int);
169 static void awatch_command (char *, int);
171 static void do_enable_breakpoint (struct breakpoint
*, enum bpdisp
);
173 static void solib_load_unload_1 (char *hookname
,
176 char *cond_string
, enum bptype bp_kind
);
178 static void create_fork_vfork_event_catchpoint (int tempflag
,
180 enum bptype bp_kind
);
182 static void stop_command (char *arg
, int from_tty
);
184 static void stopin_command (char *arg
, int from_tty
);
186 static void stopat_command (char *arg
, int from_tty
);
188 static char *ep_find_event_name_end (char *arg
);
190 static char *ep_parse_optional_if_clause (char **arg
);
192 static char *ep_parse_optional_filename (char **arg
);
194 static void create_exception_catchpoint (int tempflag
, char *cond_string
,
195 enum exception_event_kind ex_event
,
196 struct symtab_and_line
*sal
);
198 static void catch_exception_command_1 (enum exception_event_kind ex_event
,
199 char *arg
, int tempflag
, int from_tty
);
201 static void tcatch_command (char *arg
, int from_tty
);
203 static void ep_skip_leading_whitespace (char **s
);
205 /* Prototypes for exported functions. */
207 /* If FALSE, gdb will not use hardware support for watchpoints, even
208 if such is available. */
209 static int can_use_hw_watchpoints
;
212 show_can_use_hw_watchpoints (struct ui_file
*file
, int from_tty
,
213 struct cmd_list_element
*c
,
216 fprintf_filtered (file
, _("\
217 Debugger's willingness to use watchpoint hardware is %s.\n"),
221 /* If AUTO_BOOLEAN_FALSE, gdb will not attempt to create pending breakpoints.
222 If AUTO_BOOLEAN_TRUE, gdb will automatically create pending breakpoints
223 for unrecognized breakpoint locations.
224 If AUTO_BOOLEAN_AUTO, gdb will query when breakpoints are unrecognized. */
225 static enum auto_boolean pending_break_support
;
227 show_pending_break_support (struct ui_file
*file
, int from_tty
,
228 struct cmd_list_element
*c
,
231 fprintf_filtered (file
, _("\
232 Debugger's behavior regarding pending breakpoints is %s.\n"),
236 /* If 1, gdb will automatically use hardware breakpoints for breakpoints
237 set with "break" but falling in read-only memory.
238 If 0, gdb will warn about such breakpoints, but won't automatically
239 use hardware breakpoints. */
240 static int automatic_hardware_breakpoints
;
242 show_automatic_hardware_breakpoints (struct ui_file
*file
, int from_tty
,
243 struct cmd_list_element
*c
,
246 fprintf_filtered (file
, _("\
247 Automatic usage of hardware breakpoints is %s.\n"),
252 void _initialize_breakpoint (void);
254 extern int addressprint
; /* Print machine addresses? */
256 /* Are we executing breakpoint commands? */
257 static int executing_breakpoint_commands
;
259 /* Are overlay event breakpoints enabled? */
260 static int overlay_events_enabled
;
262 /* Walk the following statement or block through all breakpoints.
263 ALL_BREAKPOINTS_SAFE does so even if the statment deletes the current
266 #define ALL_BREAKPOINTS(B) for (B = breakpoint_chain; B; B = B->next)
268 #define ALL_BREAKPOINTS_SAFE(B,TMP) \
269 for (B = breakpoint_chain; \
270 B ? (TMP=B->next, 1): 0; \
273 /* Similar iterators for the low-level breakpoints. */
275 #define ALL_BP_LOCATIONS(B) for (B = bp_location_chain; B; B = B->next)
277 #define ALL_BP_LOCATIONS_SAFE(B,TMP) \
278 for (B = bp_location_chain; \
279 B ? (TMP=B->next, 1): 0; \
282 /* True if breakpoint hit counts should be displayed in breakpoint info. */
284 int show_breakpoint_hit_counts
= 1;
286 /* Chains of all breakpoints defined. */
288 struct breakpoint
*breakpoint_chain
;
290 struct bp_location
*bp_location_chain
;
292 /* Number of last breakpoint made. */
294 int breakpoint_count
;
296 /* Pointer to current exception event record */
297 static struct exception_event_record
*current_exception_event
;
299 /* Indicator of whether exception catchpoints should be nuked between
300 runs of a program. */
301 int deprecated_exception_catchpoints_are_fragile
= 0;
303 /* Indicator of when exception catchpoints set-up should be
304 reinitialized -- e.g. when program is re-run. */
305 int deprecated_exception_support_initialized
= 0;
307 /* This function returns a pointer to the string representation of the
308 pathname of the dynamically-linked library that has just been
311 This function must be used only when SOLIB_HAVE_LOAD_EVENT is TRUE,
312 or undefined results are guaranteed.
314 This string's contents are only valid immediately after the
315 inferior has stopped in the dynamic linker hook, and becomes
316 invalid as soon as the inferior is continued. Clients should make
317 a copy of this string if they wish to continue the inferior and
318 then access the string. */
320 #ifndef SOLIB_LOADED_LIBRARY_PATHNAME
321 #define SOLIB_LOADED_LIBRARY_PATHNAME(pid) ""
324 /* This function returns a pointer to the string representation of the
325 pathname of the dynamically-linked library that has just been
328 This function must be used only when SOLIB_HAVE_UNLOAD_EVENT is
329 TRUE, or undefined results are guaranteed.
331 This string's contents are only valid immediately after the
332 inferior has stopped in the dynamic linker hook, and becomes
333 invalid as soon as the inferior is continued. Clients should make
334 a copy of this string if they wish to continue the inferior and
335 then access the string. */
337 #ifndef SOLIB_UNLOADED_LIBRARY_PATHNAME
338 #define SOLIB_UNLOADED_LIBRARY_PATHNAME(pid) ""
341 /* This function is called by the "catch load" command. It allows the
342 debugger to be notified by the dynamic linker when a specified
343 library file (or any library file, if filename is NULL) is loaded. */
345 #ifndef SOLIB_CREATE_CATCH_LOAD_HOOK
346 #define SOLIB_CREATE_CATCH_LOAD_HOOK(pid,tempflag,filename,cond_string) \
347 error (_("catch of library loads not yet implemented on this platform"))
350 /* This function is called by the "catch unload" command. It allows
351 the debugger to be notified by the dynamic linker when a specified
352 library file (or any library file, if filename is NULL) is
355 #ifndef SOLIB_CREATE_CATCH_UNLOAD_HOOK
356 #define SOLIB_CREATE_CATCH_UNLOAD_HOOK(pid, tempflag, filename, cond_string) \
357 error (_("catch of library unloads not yet implemented on this platform"))
360 /* Return whether a breakpoint is an active enabled breakpoint. */
362 breakpoint_enabled (struct breakpoint
*b
)
364 return (b
->enable_state
== bp_enabled
&& !b
->pending
);
367 /* Set breakpoint count to NUM. */
370 set_breakpoint_count (int num
)
372 breakpoint_count
= num
;
373 set_internalvar (lookup_internalvar ("bpnum"),
374 value_from_longest (builtin_type_int
, (LONGEST
) num
));
377 /* Used in run_command to zero the hit count when a new run starts. */
380 clear_breakpoint_hit_counts (void)
382 struct breakpoint
*b
;
388 /* Default address, symtab and line to put a breakpoint at
389 for "break" command with no arg.
390 if default_breakpoint_valid is zero, the other three are
391 not valid, and "break" with no arg is an error.
393 This set by print_stack_frame, which calls set_default_breakpoint. */
395 int default_breakpoint_valid
;
396 CORE_ADDR default_breakpoint_address
;
397 struct symtab
*default_breakpoint_symtab
;
398 int default_breakpoint_line
;
400 /* *PP is a string denoting a breakpoint. Get the number of the breakpoint.
401 Advance *PP after the string and any trailing whitespace.
403 Currently the string can either be a number or "$" followed by the name
404 of a convenience variable. Making it an expression wouldn't work well
405 for map_breakpoint_numbers (e.g. "4 + 5 + 6").
407 If the string is a NULL pointer, that denotes the last breakpoint.
409 TRAILER is a character which can be found after the number; most
410 commonly this is `-'. If you don't want a trailer, use \0. */
412 get_number_trailer (char **pp
, int trailer
)
414 int retval
= 0; /* default */
418 /* Empty line means refer to the last breakpoint. */
419 return breakpoint_count
;
422 /* Make a copy of the name, so we can null-terminate it
423 to pass to lookup_internalvar(). */
428 while (isalnum (*p
) || *p
== '_')
430 varname
= (char *) alloca (p
- start
+ 1);
431 strncpy (varname
, start
, p
- start
);
432 varname
[p
- start
] = '\0';
433 val
= value_of_internalvar (lookup_internalvar (varname
));
434 if (TYPE_CODE (value_type (val
)) == TYPE_CODE_INT
)
435 retval
= (int) value_as_long (val
);
438 printf_filtered (_("Convenience variable must have integer value.\n"));
446 while (*p
>= '0' && *p
<= '9')
449 /* There is no number here. (e.g. "cond a == b"). */
451 /* Skip non-numeric token */
452 while (*p
&& !isspace((int) *p
))
454 /* Return zero, which caller must interpret as error. */
460 if (!(isspace (*p
) || *p
== '\0' || *p
== trailer
))
462 /* Trailing junk: return 0 and let caller print error msg. */
463 while (!(isspace (*p
) || *p
== '\0' || *p
== trailer
))
474 /* Like get_number_trailer, but don't allow a trailer. */
476 get_number (char **pp
)
478 return get_number_trailer (pp
, '\0');
481 /* Parse a number or a range.
482 * A number will be of the form handled by get_number.
483 * A range will be of the form <number1> - <number2>, and
484 * will represent all the integers between number1 and number2,
487 * While processing a range, this fuction is called iteratively;
488 * At each call it will return the next value in the range.
490 * At the beginning of parsing a range, the char pointer PP will
491 * be advanced past <number1> and left pointing at the '-' token.
492 * Subsequent calls will not advance the pointer until the range
493 * is completed. The call that completes the range will advance
494 * pointer PP past <number2>.
498 get_number_or_range (char **pp
)
500 static int last_retval
, end_value
;
501 static char *end_ptr
;
502 static int in_range
= 0;
506 /* Default case: pp is pointing either to a solo number,
507 or to the first number of a range. */
508 last_retval
= get_number_trailer (pp
, '-');
513 /* This is the start of a range (<number1> - <number2>).
514 Skip the '-', parse and remember the second number,
515 and also remember the end of the final token. */
519 while (isspace ((int) *end_ptr
))
520 end_ptr
++; /* skip white space */
521 end_value
= get_number (temp
);
522 if (end_value
< last_retval
)
524 error (_("inverted range"));
526 else if (end_value
== last_retval
)
528 /* degenerate range (number1 == number2). Advance the
529 token pointer so that the range will be treated as a
538 error (_("negative value"));
541 /* pp points to the '-' that betokens a range. All
542 number-parsing has already been done. Return the next
543 integer value (one greater than the saved previous value).
544 Do not advance the token pointer 'pp' until the end of range
547 if (++last_retval
== end_value
)
549 /* End of range reached; advance token pointer. */
559 /* condition N EXP -- set break condition of breakpoint N to EXP. */
562 condition_command (char *arg
, int from_tty
)
564 struct breakpoint
*b
;
569 error_no_arg (_("breakpoint number"));
572 bnum
= get_number (&p
);
574 error (_("Bad breakpoint argument: '%s'"), arg
);
577 if (b
->number
== bnum
)
584 if (b
->cond_string
!= NULL
)
585 xfree (b
->cond_string
);
590 b
->cond_string
= NULL
;
592 printf_filtered (_("Breakpoint %d now unconditional.\n"), bnum
);
597 /* I don't know if it matters whether this is the string the user
598 typed in or the decompiled expression. */
599 b
->cond_string
= savestring (arg
, strlen (arg
));
602 b
->cond
= parse_exp_1 (&arg
, block_for_pc (b
->loc
->address
), 0);
604 error (_("Junk at end of expression"));
607 breakpoints_changed ();
608 breakpoint_modify_event (b
->number
);
612 error (_("No breakpoint number %d."), bnum
);
616 commands_command (char *arg
, int from_tty
)
618 struct breakpoint
*b
;
621 struct command_line
*l
;
623 /* If we allowed this, we would have problems with when to
624 free the storage, if we change the commands currently
627 if (executing_breakpoint_commands
)
628 error (_("Can't use the \"commands\" command among a breakpoint's commands."));
631 bnum
= get_number (&p
);
634 error (_("Unexpected extra arguments following breakpoint number."));
637 if (b
->number
== bnum
)
639 char *tmpbuf
= xstrprintf ("Type commands for when breakpoint %d is hit, one per line.",
641 struct cleanup
*cleanups
= make_cleanup (xfree
, tmpbuf
);
642 l
= read_command_lines (tmpbuf
, from_tty
);
643 do_cleanups (cleanups
);
644 free_command_lines (&b
->commands
);
646 breakpoints_changed ();
647 breakpoint_modify_event (b
->number
);
650 error (_("No breakpoint number %d."), bnum
);
653 /* Like commands_command, but instead of reading the commands from
654 input stream, takes them from an already parsed command structure.
656 This is used by cli-script.c to DTRT with breakpoint commands
657 that are part of if and while bodies. */
658 enum command_control_type
659 commands_from_control_command (char *arg
, struct command_line
*cmd
)
661 struct breakpoint
*b
;
665 /* If we allowed this, we would have problems with when to
666 free the storage, if we change the commands currently
669 if (executing_breakpoint_commands
)
670 error (_("Can't use the \"commands\" command among a breakpoint's commands."));
672 /* An empty string for the breakpoint number means the last
673 breakpoint, but get_number expects a NULL pointer. */
678 bnum
= get_number (&p
);
681 error (_("Unexpected extra arguments following breakpoint number."));
684 if (b
->number
== bnum
)
686 free_command_lines (&b
->commands
);
687 if (cmd
->body_count
!= 1)
688 error (_("Invalid \"commands\" block structure."));
689 /* We need to copy the commands because if/while will free the
690 list after it finishes execution. */
691 b
->commands
= copy_command_lines (cmd
->body_list
[0]);
692 breakpoints_changed ();
693 breakpoint_modify_event (b
->number
);
694 return simple_control
;
696 error (_("No breakpoint number %d."), bnum
);
699 /* Like target_read_memory() but if breakpoints are inserted, return
700 the shadow contents instead of the breakpoints themselves.
702 Read "memory data" from whatever target or inferior we have.
703 Returns zero if successful, errno value if not. EIO is used
704 for address out of bounds. If breakpoints are inserted, returns
705 shadow contents, not the breakpoints themselves. From breakpoint.c. */
708 read_memory_nobpt (CORE_ADDR memaddr
, gdb_byte
*myaddr
, unsigned len
)
711 struct bp_location
*b
;
712 CORE_ADDR bp_addr
= 0;
715 if (BREAKPOINT_FROM_PC (&bp_addr
, &bp_size
) == NULL
)
716 /* No breakpoints on this machine. */
717 return target_read_memory (memaddr
, myaddr
, len
);
721 if (b
->owner
->type
== bp_none
)
722 warning (_("reading through apparently deleted breakpoint #%d?"),
725 if (b
->loc_type
!= bp_loc_software_breakpoint
)
729 /* Addresses and length of the part of the breakpoint that
731 bp_addr
= b
->target_info
.placed_address
;
732 bp_size
= b
->target_info
.shadow_len
;
734 /* bp isn't valid, or doesn't shadow memory. */
736 if (bp_addr
+ bp_size
<= memaddr
)
737 /* The breakpoint is entirely before the chunk of memory we
740 if (bp_addr
>= memaddr
+ len
)
741 /* The breakpoint is entirely after the chunk of memory we are
744 /* Copy the breakpoint from the shadow contents, and recurse for
745 the things before and after. */
747 /* Offset within shadow_contents. */
750 if (bp_addr
< memaddr
)
752 /* Only copy the second part of the breakpoint. */
753 bp_size
-= memaddr
- bp_addr
;
754 bptoffset
= memaddr
- bp_addr
;
758 if (bp_addr
+ bp_size
> memaddr
+ len
)
760 /* Only copy the first part of the breakpoint. */
761 bp_size
-= (bp_addr
+ bp_size
) - (memaddr
+ len
);
764 memcpy (myaddr
+ bp_addr
- memaddr
,
765 b
->target_info
.shadow_contents
+ bptoffset
, bp_size
);
767 if (bp_addr
> memaddr
)
769 /* Copy the section of memory before the breakpoint. */
770 status
= read_memory_nobpt (memaddr
, myaddr
, bp_addr
- memaddr
);
775 if (bp_addr
+ bp_size
< memaddr
+ len
)
777 /* Copy the section of memory after the breakpoint. */
778 status
= read_memory_nobpt (bp_addr
+ bp_size
,
779 myaddr
+ bp_addr
+ bp_size
- memaddr
,
780 memaddr
+ len
- (bp_addr
+ bp_size
));
787 /* Nothing overlaps. Just call read_memory_noerr. */
788 return target_read_memory (memaddr
, myaddr
, len
);
792 /* A wrapper function for inserting catchpoints. */
794 insert_catchpoint (struct ui_out
*uo
, void *args
)
796 struct breakpoint
*b
= (struct breakpoint
*) args
;
802 target_insert_fork_catchpoint (PIDGET (inferior_ptid
));
805 target_insert_vfork_catchpoint (PIDGET (inferior_ptid
));
808 target_insert_exec_catchpoint (PIDGET (inferior_ptid
));
811 internal_error (__FILE__
, __LINE__
, _("unknown breakpoint type"));
816 /* Helper routine: free the value chain for a breakpoint (watchpoint). */
819 free_valchain (struct bp_location
*b
)
824 /* Free the saved value chain. We will construct a new one
825 the next time the watchpoint is inserted. */
826 for (v
= b
->owner
->val_chain
; v
; v
= n
)
831 b
->owner
->val_chain
= NULL
;
834 /* Insert a low-level "breakpoint" of some type. BPT is the breakpoint.
835 Any error messages are printed to TMP_ERROR_STREAM; and DISABLED_BREAKS,
836 PROCESS_WARNING, and HW_BREAKPOINT_ERROR are used to report problems.
838 NOTE drow/2003-09-09: This routine could be broken down to an object-style
839 method for each breakpoint or catchpoint type. */
841 insert_bp_location (struct bp_location
*bpt
,
842 struct ui_file
*tmp_error_stream
,
843 int *disabled_breaks
, int *process_warning
,
844 int *hw_breakpoint_error
)
848 /* Permanent breakpoints cannot be inserted or removed. Disabled
849 breakpoints should not be inserted. */
850 if (!breakpoint_enabled (bpt
->owner
))
853 if (bpt
->inserted
|| bpt
->duplicate
)
856 /* Initialize the target-specific information. */
857 memset (&bpt
->target_info
, 0, sizeof (bpt
->target_info
));
858 bpt
->target_info
.placed_address
= bpt
->address
;
860 if (bpt
->loc_type
== bp_loc_software_breakpoint
861 || bpt
->loc_type
== bp_loc_hardware_breakpoint
)
863 if (bpt
->owner
->type
!= bp_hardware_breakpoint
)
865 /* If the explicitly specified breakpoint type
866 is not hardware breakpoint, check the memory map to see
867 if the breakpoint address is in read only memory or not.
868 Two important cases are:
869 - location type is not hardware breakpoint, memory
870 is readonly. We change the type of the location to
872 - location type is hardware breakpoint, memory is read-write.
873 This means we've previously made the location hardware one, but
874 then the memory map changed, so we undo.
876 When breakpoints are removed, remove_breakpoints will
877 use location types we've just set here, the only possible
878 problem is that memory map has changed during running program,
879 but it's not going to work anyway with current gdb. */
880 struct mem_region
*mr
881 = lookup_mem_region (bpt
->target_info
.placed_address
);
885 if (automatic_hardware_breakpoints
)
888 enum bp_loc_type new_type
;
890 if (mr
->attrib
.mode
!= MEM_RW
)
891 new_type
= bp_loc_hardware_breakpoint
;
893 new_type
= bp_loc_software_breakpoint
;
895 if (new_type
!= bpt
->loc_type
)
898 bpt
->loc_type
= new_type
;
901 fprintf_filtered (gdb_stdout
, _("\
902 Note: automatically using hardware breakpoints for read-only addresses.\n"));
907 else if (bpt
->loc_type
== bp_loc_software_breakpoint
908 && mr
->attrib
.mode
!= MEM_RW
)
909 warning (_("cannot set software breakpoint at readonly address %s"),
910 paddr (bpt
->address
));
914 /* First check to see if we have to handle an overlay. */
915 if (overlay_debugging
== ovly_off
916 || bpt
->section
== NULL
917 || !(section_is_overlay (bpt
->section
)))
919 /* No overlay handling: just set the breakpoint. */
921 if (bpt
->loc_type
== bp_loc_hardware_breakpoint
)
922 val
= target_insert_hw_breakpoint (&bpt
->target_info
);
924 val
= target_insert_breakpoint (&bpt
->target_info
);
928 /* This breakpoint is in an overlay section.
929 Shall we set a breakpoint at the LMA? */
930 if (!overlay_events_enabled
)
932 /* Yes -- overlay event support is not active,
933 so we must try to set a breakpoint at the LMA.
934 This will not work for a hardware breakpoint. */
935 if (bpt
->loc_type
== bp_loc_hardware_breakpoint
)
936 warning (_("hardware breakpoint %d not supported in overlay!"),
940 CORE_ADDR addr
= overlay_unmapped_address (bpt
->address
,
942 /* Set a software (trap) breakpoint at the LMA. */
943 bpt
->overlay_target_info
= bpt
->target_info
;
944 bpt
->overlay_target_info
.placed_address
= addr
;
945 val
= target_insert_breakpoint (&bpt
->overlay_target_info
);
947 fprintf_unfiltered (tmp_error_stream
,
948 "Overlay breakpoint %d failed: in ROM?",
952 /* Shall we set a breakpoint at the VMA? */
953 if (section_is_mapped (bpt
->section
))
955 /* Yes. This overlay section is mapped into memory. */
956 if (bpt
->loc_type
== bp_loc_hardware_breakpoint
)
957 val
= target_insert_hw_breakpoint (&bpt
->target_info
);
959 val
= target_insert_breakpoint (&bpt
->target_info
);
963 /* No. This breakpoint will not be inserted.
964 No error, but do not mark the bp as 'inserted'. */
971 /* Can't set the breakpoint. */
973 #if defined (DISABLE_UNSETTABLE_BREAK)
974 DISABLE_UNSETTABLE_BREAK (bpt
->address
)
976 solib_address (bpt
->address
)
980 /* See also: disable_breakpoints_in_shlibs. */
982 bpt
->owner
->enable_state
= bp_shlib_disabled
;
983 if (!*disabled_breaks
)
985 fprintf_unfiltered (tmp_error_stream
,
986 "Cannot insert breakpoint %d.\n",
988 fprintf_unfiltered (tmp_error_stream
,
989 "Temporarily disabling shared library breakpoints:\n");
991 *disabled_breaks
= 1;
992 fprintf_unfiltered (tmp_error_stream
,
993 "breakpoint #%d\n", bpt
->owner
->number
);
997 #ifdef ONE_PROCESS_WRITETEXT
998 *process_warning
= 1;
1000 if (bpt
->loc_type
== bp_loc_hardware_breakpoint
)
1002 *hw_breakpoint_error
= 1;
1003 fprintf_unfiltered (tmp_error_stream
,
1004 "Cannot insert hardware breakpoint %d.\n",
1005 bpt
->owner
->number
);
1009 fprintf_unfiltered (tmp_error_stream
,
1010 "Cannot insert breakpoint %d.\n",
1011 bpt
->owner
->number
);
1012 fprintf_filtered (tmp_error_stream
,
1013 "Error accessing memory address ");
1014 deprecated_print_address_numeric (bpt
->address
, 1, tmp_error_stream
);
1015 fprintf_filtered (tmp_error_stream
, ": %s.\n",
1016 safe_strerror (val
));
1027 else if (bpt
->loc_type
== bp_loc_hardware_watchpoint
1028 /* NOTE drow/2003-09-08: This state only exists for removing
1029 watchpoints. It's not clear that it's necessary... */
1030 && bpt
->owner
->disposition
!= disp_del_at_next_stop
)
1032 /* FIXME drow/2003-09-08: This code sets multiple hardware watchpoints
1033 based on the expression. Ideally this should happen at a higher level,
1034 and there should be one bp_location for each computed address we
1035 must watch. As soon as a many-to-one mapping is available I'll
1038 int within_current_scope
;
1039 struct value
*mark
= value_mark ();
1041 struct frame_id saved_frame_id
;
1043 /* Save the current frame's ID so we can restore it after
1044 evaluating the watchpoint expression on its own frame. */
1045 /* FIXME drow/2003-09-09: It would be nice if evaluate_expression
1046 took a frame parameter, so that we didn't have to change the
1048 saved_frame_id
= get_frame_id (get_selected_frame (NULL
));
1050 /* Determine if the watchpoint is within scope. */
1051 if (bpt
->owner
->exp_valid_block
== NULL
)
1052 within_current_scope
= 1;
1055 struct frame_info
*fi
;
1056 fi
= frame_find_by_id (bpt
->owner
->watchpoint_frame
);
1057 within_current_scope
= (fi
!= NULL
);
1058 if (within_current_scope
)
1062 if (within_current_scope
)
1064 free_valchain (bpt
);
1066 /* Evaluate the expression and cut the chain of values
1067 produced off from the value chain.
1069 Make sure the value returned isn't lazy; we use
1070 laziness to determine what memory GDB actually needed
1071 in order to compute the value of the expression. */
1072 v
= evaluate_expression (bpt
->owner
->exp
);
1074 value_release_to_mark (mark
);
1076 bpt
->owner
->val_chain
= v
;
1079 /* Look at each value on the value chain. */
1080 for (; v
; v
= value_next (v
))
1082 /* If it's a memory location, and GDB actually needed
1083 its contents to evaluate the expression, then we
1085 if (VALUE_LVAL (v
) == lval_memory
1086 && ! value_lazy (v
))
1088 struct type
*vtype
= check_typedef (value_type (v
));
1090 /* We only watch structs and arrays if user asked
1091 for it explicitly, never if they just happen to
1092 appear in the middle of some value chain. */
1093 if (v
== bpt
->owner
->val_chain
1094 || (TYPE_CODE (vtype
) != TYPE_CODE_STRUCT
1095 && TYPE_CODE (vtype
) != TYPE_CODE_ARRAY
))
1100 addr
= VALUE_ADDRESS (v
) + value_offset (v
);
1101 len
= TYPE_LENGTH (value_type (v
));
1103 if (bpt
->owner
->type
== bp_read_watchpoint
)
1105 else if (bpt
->owner
->type
== bp_access_watchpoint
)
1108 val
= target_insert_watchpoint (addr
, len
, type
);
1111 /* Don't exit the loop, try to insert
1112 every value on the value chain. That's
1113 because we will be removing all the
1114 watches below, and removing a
1115 watchpoint we didn't insert could have
1123 /* Failure to insert a watchpoint on any memory value in the
1124 value chain brings us here. */
1127 remove_breakpoint (bpt
, mark_uninserted
);
1128 *hw_breakpoint_error
= 1;
1129 fprintf_unfiltered (tmp_error_stream
,
1130 "Could not insert hardware watchpoint %d.\n",
1131 bpt
->owner
->number
);
1137 printf_filtered (_("\
1138 Hardware watchpoint %d deleted because the program has left the block \n\
1139 in which its expression is valid.\n"),
1140 bpt
->owner
->number
);
1141 if (bpt
->owner
->related_breakpoint
)
1142 bpt
->owner
->related_breakpoint
->disposition
= disp_del_at_next_stop
;
1143 bpt
->owner
->disposition
= disp_del_at_next_stop
;
1146 /* Restore the selected frame. */
1147 select_frame (frame_find_by_id (saved_frame_id
));
1152 else if (ep_is_exception_catchpoint (bpt
->owner
))
1154 /* FIXME drow/2003-09-09: This code sets both a catchpoint and a
1155 breakpoint. Once again, it would be better if this was represented
1156 as two bp_locations. */
1158 /* If we get here, we must have a callback mechanism for exception
1159 events -- with g++ style embedded label support, we insert
1160 ordinary breakpoints and not catchpoints. */
1161 val
= target_insert_breakpoint (&bpt
->target_info
);
1164 /* Couldn't set breakpoint for some reason */
1165 fprintf_unfiltered (tmp_error_stream
,
1166 "Cannot insert catchpoint %d; disabling it.\n",
1167 bpt
->owner
->number
);
1168 fprintf_filtered (tmp_error_stream
,
1169 "Error accessing memory address ");
1170 deprecated_print_address_numeric (bpt
->address
, 1, tmp_error_stream
);
1171 fprintf_filtered (tmp_error_stream
, ": %s.\n",
1172 safe_strerror (val
));
1173 bpt
->owner
->enable_state
= bp_disabled
;
1177 /* Bp set, now make sure callbacks are enabled */
1178 /* Format possible error msg */
1179 char *message
= xstrprintf ("Error inserting catchpoint %d:\n",
1180 bpt
->owner
->number
);
1181 struct cleanup
*cleanups
= make_cleanup (xfree
, message
);
1183 args_for_catchpoint_enable args
;
1184 args
.kind
= bpt
->owner
->type
== bp_catch_catch
?
1185 EX_EVENT_CATCH
: EX_EVENT_THROW
;
1187 val
= catch_errors (cover_target_enable_exception_callback
,
1188 &args
, message
, RETURN_MASK_ALL
);
1189 do_cleanups (cleanups
);
1190 if (val
!= 0 && val
!= -1)
1193 /* Check if something went wrong; val == 0 can be ignored */
1196 /* something went wrong */
1197 fprintf_unfiltered (tmp_error_stream
,
1198 "Cannot insert catchpoint %d; disabling it.\n",
1199 bpt
->owner
->number
);
1200 bpt
->owner
->enable_state
= bp_disabled
;
1207 else if (bpt
->owner
->type
== bp_catch_fork
1208 || bpt
->owner
->type
== bp_catch_vfork
1209 || bpt
->owner
->type
== bp_catch_exec
)
1211 struct gdb_exception e
= catch_exception (uiout
, insert_catchpoint
,
1212 bpt
->owner
, RETURN_MASK_ERROR
);
1213 exception_fprintf (gdb_stderr
, e
, "warning: inserting catchpoint %d: ",
1214 bpt
->owner
->number
);
1216 bpt
->owner
->enable_state
= bp_disabled
;
1220 /* We've already printed an error message if there was a problem
1221 inserting this catchpoint, and we've disabled the catchpoint,
1222 so just return success. */
1229 /* insert_breakpoints is used when starting or continuing the program.
1230 remove_breakpoints is used when the program stops.
1231 Both return zero if successful,
1232 or an `errno' value if could not write the inferior. */
1235 insert_breakpoints (void)
1237 struct bp_location
*b
, *temp
;
1238 int return_val
= 0; /* return success code. */
1240 int disabled_breaks
= 0;
1241 int hw_breakpoint_error
= 0;
1242 int process_warning
= 0;
1244 struct ui_file
*tmp_error_stream
= mem_fileopen ();
1245 make_cleanup_ui_file_delete (tmp_error_stream
);
1247 /* Explicitly mark the warning -- this will only be printed if
1248 there was an error. */
1249 fprintf_unfiltered (tmp_error_stream
, "Warning:\n");
1251 ALL_BP_LOCATIONS_SAFE (b
, temp
)
1253 /* Permanent breakpoints cannot be inserted or removed. Disabled
1254 breakpoints should not be inserted. */
1255 if (!breakpoint_enabled (b
->owner
))
1258 /* There is no point inserting thread-specific breakpoints if the
1259 thread no longer exists. */
1260 if (b
->owner
->thread
!= -1
1261 && !valid_thread_id (b
->owner
->thread
))
1264 /* FIXME drow/2003-10-07: This code should be pushed elsewhere when
1265 hardware watchpoints are split into multiple loc breakpoints. */
1266 if ((b
->loc_type
== bp_loc_hardware_watchpoint
1267 || b
->owner
->type
== bp_watchpoint
) && !b
->owner
->val
)
1270 val
= evaluate_expression (b
->owner
->exp
);
1271 release_value (val
);
1272 if (value_lazy (val
))
1273 value_fetch_lazy (val
);
1274 b
->owner
->val
= val
;
1277 val
= insert_bp_location (b
, tmp_error_stream
,
1278 &disabled_breaks
, &process_warning
,
1279 &hw_breakpoint_error
);
1286 /* If a hardware breakpoint or watchpoint was inserted, add a
1287 message about possibly exhausted resources. */
1288 if (hw_breakpoint_error
)
1290 fprintf_unfiltered (tmp_error_stream
,
1291 "Could not insert hardware breakpoints:\n\
1292 You may have requested too many hardware breakpoints/watchpoints.\n");
1294 #ifdef ONE_PROCESS_WRITETEXT
1295 if (process_warning
)
1296 fprintf_unfiltered (tmp_error_stream
,
1297 "The same program may be running in another process.");
1299 target_terminal_ours_for_output ();
1300 error_stream (tmp_error_stream
);
1306 remove_breakpoints (void)
1308 struct bp_location
*b
;
1311 ALL_BP_LOCATIONS (b
)
1315 val
= remove_breakpoint (b
, mark_uninserted
);
1324 remove_hw_watchpoints (void)
1326 struct bp_location
*b
;
1329 ALL_BP_LOCATIONS (b
)
1331 if (b
->inserted
&& b
->loc_type
== bp_loc_hardware_watchpoint
)
1333 val
= remove_breakpoint (b
, mark_uninserted
);
1342 reattach_breakpoints (int pid
)
1344 struct bp_location
*b
;
1346 struct cleanup
*old_chain
= save_inferior_ptid ();
1348 /* Set inferior_ptid; remove_breakpoint uses this global. */
1349 inferior_ptid
= pid_to_ptid (pid
);
1350 ALL_BP_LOCATIONS (b
)
1354 remove_breakpoint (b
, mark_inserted
);
1355 /* Note: since we insert a breakpoint right after removing,
1356 any decisions about automatically using hardware breakpoints
1357 made in insert_bp_location are preserved. */
1358 if (b
->loc_type
== bp_loc_hardware_breakpoint
)
1359 val
= target_insert_hw_breakpoint (&b
->target_info
);
1361 val
= target_insert_breakpoint (&b
->target_info
);
1362 /* FIXME drow/2003-10-07: This doesn't handle any other kinds of
1363 breakpoints. It's wrong for watchpoints, for example. */
1366 do_cleanups (old_chain
);
1371 do_cleanups (old_chain
);
1376 update_breakpoints_after_exec (void)
1378 struct breakpoint
*b
;
1379 struct breakpoint
*temp
;
1381 /* Doing this first prevents the badness of having delete_breakpoint()
1382 write a breakpoint's current "shadow contents" to lift the bp. That
1383 shadow is NOT valid after an exec()! */
1384 mark_breakpoints_out ();
1386 ALL_BREAKPOINTS_SAFE (b
, temp
)
1388 /* Solib breakpoints must be explicitly reset after an exec(). */
1389 if (b
->type
== bp_shlib_event
)
1391 delete_breakpoint (b
);
1395 /* Thread event breakpoints must be set anew after an exec(),
1396 as must overlay event breakpoints. */
1397 if (b
->type
== bp_thread_event
|| b
->type
== bp_overlay_event
)
1399 delete_breakpoint (b
);
1403 /* Step-resume breakpoints are meaningless after an exec(). */
1404 if (b
->type
== bp_step_resume
)
1406 delete_breakpoint (b
);
1410 /* Ditto the sigtramp handler breakpoints. */
1411 if (b
->type
== bp_through_sigtramp
)
1413 delete_breakpoint (b
);
1417 /* Ditto the exception-handling catchpoints. */
1418 if ((b
->type
== bp_catch_catch
) || (b
->type
== bp_catch_throw
))
1420 delete_breakpoint (b
);
1424 /* Don't delete an exec catchpoint, because else the inferior
1425 won't stop when it ought!
1427 Similarly, we probably ought to keep vfork catchpoints, 'cause
1428 on this target, we may not be able to stop when the vfork is
1429 seen, but only when the subsequent exec is seen. (And because
1430 deleting fork catchpoints here but not vfork catchpoints will
1431 seem mysterious to users, keep those too.)
1433 ??rehrauer: Let's hope that merely clearing out this catchpoint's
1434 target address field, if any, is sufficient to have it be reset
1435 automagically. Certainly on HP-UX that's true.
1437 Jim Blandy <jimb@redhat.com>: Actually, zero is a perfectly
1438 valid code address on some platforms (like the mn10300
1439 simulators). We shouldn't assign any special interpretation to
1440 a breakpoint with a zero address. And in fact, GDB doesn't ---
1441 I can't see what that comment above is talking about. As far
1442 as I can tell, setting the address of a
1443 bp_catch_exec/bp_catch_vfork/bp_catch_fork breakpoint to zero
1444 is meaningless, since those are implemented with HP-UX kernel
1445 hackery, not by storing breakpoint instructions somewhere. */
1446 if ((b
->type
== bp_catch_exec
) ||
1447 (b
->type
== bp_catch_vfork
) ||
1448 (b
->type
== bp_catch_fork
))
1450 b
->loc
->address
= (CORE_ADDR
) 0;
1454 /* bp_finish is a special case. The only way we ought to be able
1455 to see one of these when an exec() has happened, is if the user
1456 caught a vfork, and then said "finish". Ordinarily a finish just
1457 carries them to the call-site of the current callee, by setting
1458 a temporary bp there and resuming. But in this case, the finish
1459 will carry them entirely through the vfork & exec.
1461 We don't want to allow a bp_finish to remain inserted now. But
1462 we can't safely delete it, 'cause finish_command has a handle to
1463 the bp on a bpstat, and will later want to delete it. There's a
1464 chance (and I've seen it happen) that if we delete the bp_finish
1465 here, that its storage will get reused by the time finish_command
1466 gets 'round to deleting the "use to be a bp_finish" breakpoint.
1467 We really must allow finish_command to delete a bp_finish.
1469 In the absense of a general solution for the "how do we know
1470 it's safe to delete something others may have handles to?"
1471 problem, what we'll do here is just uninsert the bp_finish, and
1472 let finish_command delete it.
1474 (We know the bp_finish is "doomed" in the sense that it's
1475 momentary, and will be deleted as soon as finish_command sees
1476 the inferior stopped. So it doesn't matter that the bp's
1477 address is probably bogus in the new a.out, unlike e.g., the
1478 solib breakpoints.) */
1480 if (b
->type
== bp_finish
)
1485 /* Without a symbolic address, we have little hope of the
1486 pre-exec() address meaning the same thing in the post-exec()
1488 if (b
->addr_string
== NULL
)
1490 delete_breakpoint (b
);
1494 /* If this breakpoint has survived the above battery of checks, then
1495 it must have a symbolic address. Be sure that it gets reevaluated
1496 to a target address, rather than reusing the old evaluation.
1498 Jim Blandy <jimb@redhat.com>: As explained above in the comment
1499 for bp_catch_exec and friends, I'm pretty sure this is entirely
1500 unnecessary. A call to breakpoint_re_set_one always recomputes
1501 the breakpoint's address from scratch, or deletes it if it can't.
1502 So I think this assignment could be deleted without effect. */
1503 b
->loc
->address
= (CORE_ADDR
) 0;
1505 /* FIXME what about longjmp breakpoints? Re-create them here? */
1506 create_overlay_event_breakpoint ("_ovly_debug_event");
1510 detach_breakpoints (int pid
)
1512 struct bp_location
*b
;
1514 struct cleanup
*old_chain
= save_inferior_ptid ();
1516 if (pid
== PIDGET (inferior_ptid
))
1517 error (_("Cannot detach breakpoints of inferior_ptid"));
1519 /* Set inferior_ptid; remove_breakpoint uses this global. */
1520 inferior_ptid
= pid_to_ptid (pid
);
1521 ALL_BP_LOCATIONS (b
)
1525 val
= remove_breakpoint (b
, mark_inserted
);
1528 do_cleanups (old_chain
);
1533 do_cleanups (old_chain
);
1538 remove_breakpoint (struct bp_location
*b
, insertion_state_t is
)
1542 if (b
->owner
->enable_state
== bp_permanent
)
1543 /* Permanent breakpoints cannot be inserted or removed. */
1546 if (b
->owner
->type
== bp_none
)
1547 warning (_("attempted to remove apparently deleted breakpoint #%d?"),
1550 if (b
->loc_type
== bp_loc_software_breakpoint
1551 || b
->loc_type
== bp_loc_hardware_breakpoint
)
1553 /* "Normal" instruction breakpoint: either the standard
1554 trap-instruction bp (bp_breakpoint), or a
1555 bp_hardware_breakpoint. */
1557 /* First check to see if we have to handle an overlay. */
1558 if (overlay_debugging
== ovly_off
1559 || b
->section
== NULL
1560 || !(section_is_overlay (b
->section
)))
1562 /* No overlay handling: just remove the breakpoint. */
1564 if (b
->loc_type
== bp_loc_hardware_breakpoint
)
1565 val
= target_remove_hw_breakpoint (&b
->target_info
);
1567 val
= target_remove_breakpoint (&b
->target_info
);
1571 /* This breakpoint is in an overlay section.
1572 Did we set a breakpoint at the LMA? */
1573 if (!overlay_events_enabled
)
1575 /* Yes -- overlay event support is not active, so we
1576 should have set a breakpoint at the LMA. Remove it.
1578 /* Ignore any failures: if the LMA is in ROM, we will
1579 have already warned when we failed to insert it. */
1580 if (b
->loc_type
== bp_loc_hardware_breakpoint
)
1581 target_remove_hw_breakpoint (&b
->overlay_target_info
);
1583 target_remove_breakpoint (&b
->overlay_target_info
);
1585 /* Did we set a breakpoint at the VMA?
1586 If so, we will have marked the breakpoint 'inserted'. */
1589 /* Yes -- remove it. Previously we did not bother to
1590 remove the breakpoint if the section had been
1591 unmapped, but let's not rely on that being safe. We
1592 don't know what the overlay manager might do. */
1593 if (b
->loc_type
== bp_loc_hardware_breakpoint
)
1594 val
= target_remove_hw_breakpoint (&b
->target_info
);
1596 val
= target_remove_breakpoint (&b
->target_info
);
1600 /* No -- not inserted, so no need to remove. No error. */
1606 b
->inserted
= (is
== mark_inserted
);
1608 else if (b
->loc_type
== bp_loc_hardware_watchpoint
1609 && breakpoint_enabled (b
->owner
)
1615 b
->inserted
= (is
== mark_inserted
);
1616 /* Walk down the saved value chain. */
1617 for (v
= b
->owner
->val_chain
; v
; v
= value_next (v
))
1619 /* For each memory reference remove the watchpoint
1621 if (VALUE_LVAL (v
) == lval_memory
1622 && ! value_lazy (v
))
1624 struct type
*vtype
= check_typedef (value_type (v
));
1626 if (v
== b
->owner
->val_chain
1627 || (TYPE_CODE (vtype
) != TYPE_CODE_STRUCT
1628 && TYPE_CODE (vtype
) != TYPE_CODE_ARRAY
))
1633 addr
= VALUE_ADDRESS (v
) + value_offset (v
);
1634 len
= TYPE_LENGTH (value_type (v
));
1636 if (b
->owner
->type
== bp_read_watchpoint
)
1638 else if (b
->owner
->type
== bp_access_watchpoint
)
1641 val
= target_remove_watchpoint (addr
, len
, type
);
1648 /* Failure to remove any of the hardware watchpoints comes here. */
1649 if ((is
== mark_uninserted
) && (b
->inserted
))
1650 warning (_("Could not remove hardware watchpoint %d."),
1653 else if ((b
->owner
->type
== bp_catch_fork
||
1654 b
->owner
->type
== bp_catch_vfork
||
1655 b
->owner
->type
== bp_catch_exec
)
1656 && breakpoint_enabled (b
->owner
)
1660 switch (b
->owner
->type
)
1663 val
= target_remove_fork_catchpoint (PIDGET (inferior_ptid
));
1665 case bp_catch_vfork
:
1666 val
= target_remove_vfork_catchpoint (PIDGET (inferior_ptid
));
1669 val
= target_remove_exec_catchpoint (PIDGET (inferior_ptid
));
1672 warning (_("Internal error, %s line %d."), __FILE__
, __LINE__
);
1677 b
->inserted
= (is
== mark_inserted
);
1679 else if ((b
->owner
->type
== bp_catch_catch
||
1680 b
->owner
->type
== bp_catch_throw
)
1681 && breakpoint_enabled (b
->owner
)
1684 val
= target_remove_breakpoint (&b
->target_info
);
1687 b
->inserted
= (is
== mark_inserted
);
1693 /* Clear the "inserted" flag in all breakpoints. */
1696 mark_breakpoints_out (void)
1698 struct bp_location
*bpt
;
1700 ALL_BP_LOCATIONS (bpt
)
1704 /* Clear the "inserted" flag in all breakpoints and delete any
1705 breakpoints which should go away between runs of the program.
1707 Plus other such housekeeping that has to be done for breakpoints
1710 Note: this function gets called at the end of a run (by
1711 generic_mourn_inferior) and when a run begins (by
1712 init_wait_for_inferior). */
1717 breakpoint_init_inferior (enum inf_context context
)
1719 struct breakpoint
*b
, *temp
;
1720 struct bp_location
*bpt
;
1721 static int warning_needed
= 0;
1723 ALL_BP_LOCATIONS (bpt
)
1726 ALL_BREAKPOINTS_SAFE (b
, temp
)
1731 case bp_watchpoint_scope
:
1733 /* If the call dummy breakpoint is at the entry point it will
1734 cause problems when the inferior is rerun, so we better
1737 Also get rid of scope breakpoints. */
1738 delete_breakpoint (b
);
1742 case bp_hardware_watchpoint
:
1743 case bp_read_watchpoint
:
1744 case bp_access_watchpoint
:
1746 /* Likewise for watchpoints on local expressions. */
1747 if (b
->exp_valid_block
!= NULL
)
1748 delete_breakpoint (b
);
1749 if (context
== inf_starting
)
1751 /* Reset val field to force reread of starting value
1752 in insert_breakpoints. */
1754 value_free (b
->val
);
1759 /* Likewise for exception catchpoints in dynamic-linked
1760 executables where required */
1761 if (ep_is_exception_catchpoint (b
)
1762 && deprecated_exception_catchpoints_are_fragile
)
1765 delete_breakpoint (b
);
1771 if (deprecated_exception_catchpoints_are_fragile
)
1772 deprecated_exception_support_initialized
= 0;
1774 /* Don't issue the warning unless it's really needed... */
1775 if (warning_needed
&& (context
!= inf_exited
))
1777 warning (_("Exception catchpoints from last run were deleted.\n"
1778 "You must reinsert them explicitly."));
1783 /* breakpoint_here_p (PC) returns non-zero if an enabled breakpoint
1784 exists at PC. It returns ordinary_breakpoint_here if it's an
1785 ordinary breakpoint, or permanent_breakpoint_here if it's a
1786 permanent breakpoint.
1787 - When continuing from a location with an ordinary breakpoint, we
1788 actually single step once before calling insert_breakpoints.
1789 - When continuing from a localion with a permanent breakpoint, we
1790 need to use the `SKIP_PERMANENT_BREAKPOINT' macro, provided by
1791 the target, to advance the PC past the breakpoint. */
1793 enum breakpoint_here
1794 breakpoint_here_p (CORE_ADDR pc
)
1796 struct bp_location
*bpt
;
1797 int any_breakpoint_here
= 0;
1799 ALL_BP_LOCATIONS (bpt
)
1801 if (bpt
->loc_type
!= bp_loc_software_breakpoint
1802 && bpt
->loc_type
!= bp_loc_hardware_breakpoint
)
1805 if ((breakpoint_enabled (bpt
->owner
)
1806 || bpt
->owner
->enable_state
== bp_permanent
)
1807 && bpt
->address
== pc
) /* bp is enabled and matches pc */
1809 if (overlay_debugging
1810 && section_is_overlay (bpt
->section
)
1811 && !section_is_mapped (bpt
->section
))
1812 continue; /* unmapped overlay -- can't be a match */
1813 else if (bpt
->owner
->enable_state
== bp_permanent
)
1814 return permanent_breakpoint_here
;
1816 any_breakpoint_here
= 1;
1820 return any_breakpoint_here
? ordinary_breakpoint_here
: 0;
1824 /* breakpoint_inserted_here_p (PC) is just like breakpoint_here_p(),
1825 but it only returns true if there is actually a breakpoint inserted
1829 breakpoint_inserted_here_p (CORE_ADDR pc
)
1831 struct bp_location
*bpt
;
1833 ALL_BP_LOCATIONS (bpt
)
1835 if (bpt
->loc_type
!= bp_loc_software_breakpoint
1836 && bpt
->loc_type
!= bp_loc_hardware_breakpoint
)
1840 && bpt
->address
== pc
) /* bp is inserted and matches pc */
1842 if (overlay_debugging
1843 && section_is_overlay (bpt
->section
)
1844 && !section_is_mapped (bpt
->section
))
1845 continue; /* unmapped overlay -- can't be a match */
1854 /* This function returns non-zero iff there is a software breakpoint
1858 software_breakpoint_inserted_here_p (CORE_ADDR pc
)
1860 struct bp_location
*bpt
;
1861 int any_breakpoint_here
= 0;
1863 ALL_BP_LOCATIONS (bpt
)
1865 if (bpt
->loc_type
!= bp_loc_software_breakpoint
)
1868 if ((breakpoint_enabled (bpt
->owner
)
1869 || bpt
->owner
->enable_state
== bp_permanent
)
1871 && bpt
->address
== pc
) /* bp is enabled and matches pc */
1873 if (overlay_debugging
1874 && section_is_overlay (bpt
->section
)
1875 && !section_is_mapped (bpt
->section
))
1876 continue; /* unmapped overlay -- can't be a match */
1885 /* breakpoint_thread_match (PC, PTID) returns true if the breakpoint at
1886 PC is valid for process/thread PTID. */
1889 breakpoint_thread_match (CORE_ADDR pc
, ptid_t ptid
)
1891 struct bp_location
*bpt
;
1894 thread
= pid_to_thread_id (ptid
);
1896 ALL_BP_LOCATIONS (bpt
)
1898 if (bpt
->loc_type
!= bp_loc_software_breakpoint
1899 && bpt
->loc_type
!= bp_loc_hardware_breakpoint
)
1902 if ((breakpoint_enabled (bpt
->owner
)
1903 || bpt
->owner
->enable_state
== bp_permanent
)
1904 && bpt
->address
== pc
1905 && (bpt
->owner
->thread
== -1 || bpt
->owner
->thread
== thread
))
1907 if (overlay_debugging
1908 && section_is_overlay (bpt
->section
)
1909 && !section_is_mapped (bpt
->section
))
1910 continue; /* unmapped overlay -- can't be a match */
1920 /* bpstat stuff. External routines' interfaces are documented
1924 ep_is_catchpoint (struct breakpoint
*ep
)
1927 (ep
->type
== bp_catch_load
)
1928 || (ep
->type
== bp_catch_unload
)
1929 || (ep
->type
== bp_catch_fork
)
1930 || (ep
->type
== bp_catch_vfork
)
1931 || (ep
->type
== bp_catch_exec
)
1932 || (ep
->type
== bp_catch_catch
)
1933 || (ep
->type
== bp_catch_throw
);
1935 /* ??rehrauer: Add more kinds here, as are implemented... */
1939 ep_is_shlib_catchpoint (struct breakpoint
*ep
)
1942 (ep
->type
== bp_catch_load
)
1943 || (ep
->type
== bp_catch_unload
);
1947 ep_is_exception_catchpoint (struct breakpoint
*ep
)
1950 (ep
->type
== bp_catch_catch
)
1951 || (ep
->type
== bp_catch_throw
);
1954 /* Clear a bpstat so that it says we are not at any breakpoint.
1955 Also free any storage that is part of a bpstat. */
1958 bpstat_clear (bpstat
*bsp
)
1969 if (p
->old_val
!= NULL
)
1970 value_free (p
->old_val
);
1971 free_command_lines (&p
->commands
);
1978 /* Return a copy of a bpstat. Like "bs1 = bs2" but all storage that
1979 is part of the bpstat is copied as well. */
1982 bpstat_copy (bpstat bs
)
1986 bpstat retval
= NULL
;
1991 for (; bs
!= NULL
; bs
= bs
->next
)
1993 tmp
= (bpstat
) xmalloc (sizeof (*tmp
));
1994 memcpy (tmp
, bs
, sizeof (*tmp
));
1995 if (bs
->commands
!= NULL
)
1996 tmp
->commands
= copy_command_lines (bs
->commands
);
1997 if (bs
->old_val
!= NULL
)
1998 tmp
->old_val
= value_copy (bs
->old_val
);
2001 /* This is the first thing in the chain. */
2011 /* Find the bpstat associated with this breakpoint */
2014 bpstat_find_breakpoint (bpstat bsp
, struct breakpoint
*breakpoint
)
2019 for (; bsp
!= NULL
; bsp
= bsp
->next
)
2021 if (bsp
->breakpoint_at
== breakpoint
)
2027 /* Find a step_resume breakpoint associated with this bpstat.
2028 (If there are multiple step_resume bp's on the list, this function
2029 will arbitrarily pick one.)
2031 It is an error to use this function if BPSTAT doesn't contain a
2032 step_resume breakpoint.
2034 See wait_for_inferior's use of this function. */
2036 bpstat_find_step_resume_breakpoint (bpstat bsp
)
2040 gdb_assert (bsp
!= NULL
);
2042 current_thread
= pid_to_thread_id (inferior_ptid
);
2044 for (; bsp
!= NULL
; bsp
= bsp
->next
)
2046 if ((bsp
->breakpoint_at
!= NULL
) &&
2047 (bsp
->breakpoint_at
->type
== bp_step_resume
) &&
2048 (bsp
->breakpoint_at
->thread
== current_thread
||
2049 bsp
->breakpoint_at
->thread
== -1))
2050 return bsp
->breakpoint_at
;
2053 internal_error (__FILE__
, __LINE__
, _("No step_resume breakpoint found."));
2057 /* Return the breakpoint number of the first breakpoint we are stopped
2058 at. *BSP upon return is a bpstat which points to the remaining
2059 breakpoints stopped at (but which is not guaranteed to be good for
2060 anything but further calls to bpstat_num).
2061 Return 0 if passed a bpstat which does not indicate any breakpoints. */
2064 bpstat_num (bpstat
*bsp
)
2066 struct breakpoint
*b
;
2069 return 0; /* No more breakpoint values */
2072 b
= (*bsp
)->breakpoint_at
;
2073 *bsp
= (*bsp
)->next
;
2075 return -1; /* breakpoint that's been deleted since */
2077 return b
->number
; /* We have its number */
2081 /* Modify BS so that the actions will not be performed. */
2084 bpstat_clear_actions (bpstat bs
)
2086 for (; bs
!= NULL
; bs
= bs
->next
)
2088 free_command_lines (&bs
->commands
);
2089 if (bs
->old_val
!= NULL
)
2091 value_free (bs
->old_val
);
2097 /* Stub for cleaning up our state if we error-out of a breakpoint command */
2099 cleanup_executing_breakpoints (void *ignore
)
2101 executing_breakpoint_commands
= 0;
2104 /* Execute all the commands associated with all the breakpoints at this
2105 location. Any of these commands could cause the process to proceed
2106 beyond this point, etc. We look out for such changes by checking
2107 the global "breakpoint_proceeded" after each command. */
2110 bpstat_do_actions (bpstat
*bsp
)
2113 struct cleanup
*old_chain
;
2115 /* Avoid endless recursion if a `source' command is contained
2117 if (executing_breakpoint_commands
)
2120 executing_breakpoint_commands
= 1;
2121 old_chain
= make_cleanup (cleanup_executing_breakpoints
, 0);
2124 /* Note that (as of this writing), our callers all appear to
2125 be passing us the address of global stop_bpstat. And, if
2126 our calls to execute_control_command cause the inferior to
2127 proceed, that global (and hence, *bsp) will change.
2129 We must be careful to not touch *bsp unless the inferior
2130 has not proceeded. */
2132 /* This pointer will iterate over the list of bpstat's. */
2135 breakpoint_proceeded
= 0;
2136 for (; bs
!= NULL
; bs
= bs
->next
)
2138 struct command_line
*cmd
;
2139 struct cleanup
*this_cmd_tree_chain
;
2141 /* Take ownership of the BSP's command tree, if it has one.
2143 The command tree could legitimately contain commands like
2144 'step' and 'next', which call clear_proceed_status, which
2145 frees stop_bpstat's command tree. To make sure this doesn't
2146 free the tree we're executing out from under us, we need to
2147 take ownership of the tree ourselves. Since a given bpstat's
2148 commands are only executed once, we don't need to copy it; we
2149 can clear the pointer in the bpstat, and make sure we free
2150 the tree when we're done. */
2153 this_cmd_tree_chain
= make_cleanup_free_command_lines (&cmd
);
2157 execute_control_command (cmd
);
2159 if (breakpoint_proceeded
)
2165 /* We can free this command tree now. */
2166 do_cleanups (this_cmd_tree_chain
);
2168 if (breakpoint_proceeded
)
2169 /* The inferior is proceeded by the command; bomb out now.
2170 The bpstat chain has been blown away by wait_for_inferior.
2171 But since execution has stopped again, there is a new bpstat
2172 to look at, so start over. */
2175 do_cleanups (old_chain
);
2178 /* This is the normal print function for a bpstat. In the future,
2179 much of this logic could (should?) be moved to bpstat_stop_status,
2180 by having it set different print_it values.
2182 Current scheme: When we stop, bpstat_print() is called. It loops
2183 through the bpstat list of things causing this stop, calling the
2184 print_bp_stop_message function on each one. The behavior of the
2185 print_bp_stop_message function depends on the print_it field of
2186 bpstat. If such field so indicates, call this function here.
2188 Return values from this routine (ultimately used by bpstat_print()
2189 and normal_stop() to decide what to do):
2190 PRINT_NOTHING: Means we already printed all we needed to print,
2191 don't print anything else.
2192 PRINT_SRC_ONLY: Means we printed something, and we do *not* desire
2193 that something to be followed by a location.
2194 PRINT_SCR_AND_LOC: Means we printed something, and we *do* desire
2195 that something to be followed by a location.
2196 PRINT_UNKNOWN: Means we printed nothing or we need to do some more
2199 static enum print_stop_action
2200 print_it_typical (bpstat bs
)
2202 struct cleanup
*old_chain
, *ui_out_chain
;
2203 struct ui_stream
*stb
;
2204 stb
= ui_out_stream_new (uiout
);
2205 old_chain
= make_cleanup_ui_out_stream_delete (stb
);
2206 /* bs->breakpoint_at can be NULL if it was a momentary breakpoint
2207 which has since been deleted. */
2208 if (bs
->breakpoint_at
== NULL
)
2209 return PRINT_UNKNOWN
;
2211 switch (bs
->breakpoint_at
->type
)
2214 case bp_hardware_breakpoint
:
2215 if (bs
->breakpoint_at
->loc
->address
!= bs
->breakpoint_at
->loc
->requested_address
)
2216 breakpoint_adjustment_warning (bs
->breakpoint_at
->loc
->requested_address
,
2217 bs
->breakpoint_at
->loc
->address
,
2218 bs
->breakpoint_at
->number
, 1);
2219 annotate_breakpoint (bs
->breakpoint_at
->number
);
2220 ui_out_text (uiout
, "\nBreakpoint ");
2221 if (ui_out_is_mi_like_p (uiout
))
2222 ui_out_field_string (uiout
, "reason",
2223 async_reason_lookup (EXEC_ASYNC_BREAKPOINT_HIT
));
2224 ui_out_field_int (uiout
, "bkptno", bs
->breakpoint_at
->number
);
2225 ui_out_text (uiout
, ", ");
2226 return PRINT_SRC_AND_LOC
;
2229 case bp_shlib_event
:
2230 /* Did we stop because the user set the stop_on_solib_events
2231 variable? (If so, we report this as a generic, "Stopped due
2232 to shlib event" message.) */
2233 printf_filtered (_("Stopped due to shared library event\n"));
2234 return PRINT_NOTHING
;
2237 case bp_thread_event
:
2238 /* Not sure how we will get here.
2239 GDB should not stop for these breakpoints. */
2240 printf_filtered (_("Thread Event Breakpoint: gdb should not stop!\n"));
2241 return PRINT_NOTHING
;
2244 case bp_overlay_event
:
2245 /* By analogy with the thread event, GDB should not stop for these. */
2246 printf_filtered (_("Overlay Event Breakpoint: gdb should not stop!\n"));
2247 return PRINT_NOTHING
;
2251 annotate_catchpoint (bs
->breakpoint_at
->number
);
2252 printf_filtered (_("\nCatchpoint %d (loaded %s), "),
2253 bs
->breakpoint_at
->number
,
2254 bs
->breakpoint_at
->triggered_dll_pathname
);
2255 return PRINT_SRC_AND_LOC
;
2258 case bp_catch_unload
:
2259 annotate_catchpoint (bs
->breakpoint_at
->number
);
2260 printf_filtered (_("\nCatchpoint %d (unloaded %s), "),
2261 bs
->breakpoint_at
->number
,
2262 bs
->breakpoint_at
->triggered_dll_pathname
);
2263 return PRINT_SRC_AND_LOC
;
2267 annotate_catchpoint (bs
->breakpoint_at
->number
);
2268 printf_filtered (_("\nCatchpoint %d (forked process %d), "),
2269 bs
->breakpoint_at
->number
,
2270 bs
->breakpoint_at
->forked_inferior_pid
);
2271 return PRINT_SRC_AND_LOC
;
2274 case bp_catch_vfork
:
2275 annotate_catchpoint (bs
->breakpoint_at
->number
);
2276 printf_filtered (_("\nCatchpoint %d (vforked process %d), "),
2277 bs
->breakpoint_at
->number
,
2278 bs
->breakpoint_at
->forked_inferior_pid
);
2279 return PRINT_SRC_AND_LOC
;
2283 annotate_catchpoint (bs
->breakpoint_at
->number
);
2284 printf_filtered (_("\nCatchpoint %d (exec'd %s), "),
2285 bs
->breakpoint_at
->number
,
2286 bs
->breakpoint_at
->exec_pathname
);
2287 return PRINT_SRC_AND_LOC
;
2290 case bp_catch_catch
:
2291 if (current_exception_event
&&
2292 (CURRENT_EXCEPTION_KIND
== EX_EVENT_CATCH
))
2294 annotate_catchpoint (bs
->breakpoint_at
->number
);
2295 printf_filtered (_("\nCatchpoint %d (exception caught), "),
2296 bs
->breakpoint_at
->number
);
2297 if (CURRENT_EXCEPTION_THROW_PC
&& CURRENT_EXCEPTION_THROW_LINE
)
2298 printf_filtered (_("throw location %s:%d, "),
2299 CURRENT_EXCEPTION_THROW_FILE
,
2300 CURRENT_EXCEPTION_THROW_LINE
);
2302 printf_filtered (_("throw location unknown, "));
2304 if (CURRENT_EXCEPTION_CATCH_PC
&& CURRENT_EXCEPTION_CATCH_LINE
)
2305 printf_filtered (_("catch location %s:%d\n"),
2306 CURRENT_EXCEPTION_CATCH_FILE
,
2307 CURRENT_EXCEPTION_CATCH_LINE
);
2309 printf_filtered (_("catch location unknown\n"));
2311 /* don't bother to print location frame info */
2312 return PRINT_SRC_ONLY
;
2316 /* really throw, some other bpstat will handle it */
2317 return PRINT_UNKNOWN
;
2321 case bp_catch_throw
:
2322 if (current_exception_event
&&
2323 (CURRENT_EXCEPTION_KIND
== EX_EVENT_THROW
))
2325 annotate_catchpoint (bs
->breakpoint_at
->number
);
2326 printf_filtered (_("\nCatchpoint %d (exception thrown), "),
2327 bs
->breakpoint_at
->number
);
2328 if (CURRENT_EXCEPTION_THROW_PC
&& CURRENT_EXCEPTION_THROW_LINE
)
2329 printf_filtered (_("throw location %s:%d, "),
2330 CURRENT_EXCEPTION_THROW_FILE
,
2331 CURRENT_EXCEPTION_THROW_LINE
);
2333 printf_filtered (_("throw location unknown, "));
2335 if (CURRENT_EXCEPTION_CATCH_PC
&& CURRENT_EXCEPTION_CATCH_LINE
)
2336 printf_filtered (_("catch location %s:%d\n"),
2337 CURRENT_EXCEPTION_CATCH_FILE
,
2338 CURRENT_EXCEPTION_CATCH_LINE
);
2340 printf_filtered (_("catch location unknown\n"));
2342 /* don't bother to print location frame info */
2343 return PRINT_SRC_ONLY
;
2347 /* really catch, some other bpstat will handle it */
2348 return PRINT_UNKNOWN
;
2353 case bp_hardware_watchpoint
:
2354 if (bs
->old_val
!= NULL
)
2356 annotate_watchpoint (bs
->breakpoint_at
->number
);
2357 if (ui_out_is_mi_like_p (uiout
))
2360 async_reason_lookup (EXEC_ASYNC_WATCHPOINT_TRIGGER
));
2361 mention (bs
->breakpoint_at
);
2362 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "value");
2363 ui_out_text (uiout
, "\nOld value = ");
2364 value_print (bs
->old_val
, stb
->stream
, 0, Val_pretty_default
);
2365 ui_out_field_stream (uiout
, "old", stb
);
2366 ui_out_text (uiout
, "\nNew value = ");
2367 value_print (bs
->breakpoint_at
->val
, stb
->stream
, 0, Val_pretty_default
);
2368 ui_out_field_stream (uiout
, "new", stb
);
2369 do_cleanups (ui_out_chain
);
2370 ui_out_text (uiout
, "\n");
2371 value_free (bs
->old_val
);
2374 /* More than one watchpoint may have been triggered. */
2375 return PRINT_UNKNOWN
;
2378 case bp_read_watchpoint
:
2379 if (ui_out_is_mi_like_p (uiout
))
2382 async_reason_lookup (EXEC_ASYNC_READ_WATCHPOINT_TRIGGER
));
2383 mention (bs
->breakpoint_at
);
2384 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "value");
2385 ui_out_text (uiout
, "\nValue = ");
2386 value_print (bs
->breakpoint_at
->val
, stb
->stream
, 0, Val_pretty_default
);
2387 ui_out_field_stream (uiout
, "value", stb
);
2388 do_cleanups (ui_out_chain
);
2389 ui_out_text (uiout
, "\n");
2390 return PRINT_UNKNOWN
;
2393 case bp_access_watchpoint
:
2394 if (bs
->old_val
!= NULL
)
2396 annotate_watchpoint (bs
->breakpoint_at
->number
);
2397 if (ui_out_is_mi_like_p (uiout
))
2400 async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER
));
2401 mention (bs
->breakpoint_at
);
2402 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "value");
2403 ui_out_text (uiout
, "\nOld value = ");
2404 value_print (bs
->old_val
, stb
->stream
, 0, Val_pretty_default
);
2405 ui_out_field_stream (uiout
, "old", stb
);
2406 value_free (bs
->old_val
);
2408 ui_out_text (uiout
, "\nNew value = ");
2412 mention (bs
->breakpoint_at
);
2413 if (ui_out_is_mi_like_p (uiout
))
2416 async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER
));
2417 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "value");
2418 ui_out_text (uiout
, "\nValue = ");
2420 value_print (bs
->breakpoint_at
->val
, stb
->stream
, 0,Val_pretty_default
);
2421 ui_out_field_stream (uiout
, "new", stb
);
2422 do_cleanups (ui_out_chain
);
2423 ui_out_text (uiout
, "\n");
2424 return PRINT_UNKNOWN
;
2427 /* Fall through, we don't deal with these types of breakpoints
2431 if (ui_out_is_mi_like_p (uiout
))
2434 async_reason_lookup (EXEC_ASYNC_FUNCTION_FINISHED
));
2435 return PRINT_UNKNOWN
;
2439 if (ui_out_is_mi_like_p (uiout
))
2442 async_reason_lookup (EXEC_ASYNC_LOCATION_REACHED
));
2443 return PRINT_UNKNOWN
;
2448 case bp_longjmp_resume
:
2449 case bp_step_resume
:
2450 case bp_through_sigtramp
:
2451 case bp_watchpoint_scope
:
2454 return PRINT_UNKNOWN
;
2458 /* Generic routine for printing messages indicating why we
2459 stopped. The behavior of this function depends on the value
2460 'print_it' in the bpstat structure. Under some circumstances we
2461 may decide not to print anything here and delegate the task to
2464 static enum print_stop_action
2465 print_bp_stop_message (bpstat bs
)
2467 switch (bs
->print_it
)
2470 /* Nothing should be printed for this bpstat entry. */
2471 return PRINT_UNKNOWN
;
2475 /* We still want to print the frame, but we already printed the
2476 relevant messages. */
2477 return PRINT_SRC_AND_LOC
;
2480 case print_it_normal
:
2481 /* Normal case. Call the breakpoint's print_it method, or
2482 print_it_typical. */
2483 if (bs
->breakpoint_at
!= NULL
&& bs
->breakpoint_at
->ops
!= NULL
2484 && bs
->breakpoint_at
->ops
->print_it
!= NULL
)
2485 return bs
->breakpoint_at
->ops
->print_it (bs
->breakpoint_at
);
2487 return print_it_typical (bs
);
2491 internal_error (__FILE__
, __LINE__
,
2492 _("print_bp_stop_message: unrecognized enum value"));
2497 /* Print a message indicating what happened. This is called from
2498 normal_stop(). The input to this routine is the head of the bpstat
2499 list - a list of the eventpoints that caused this stop. This
2500 routine calls the generic print routine for printing a message
2501 about reasons for stopping. This will print (for example) the
2502 "Breakpoint n," part of the output. The return value of this
2505 PRINT_UNKNOWN: Means we printed nothing
2506 PRINT_SRC_AND_LOC: Means we printed something, and expect subsequent
2507 code to print the location. An example is
2508 "Breakpoint 1, " which should be followed by
2510 PRINT_SRC_ONLY: Means we printed something, but there is no need
2511 to also print the location part of the message.
2512 An example is the catch/throw messages, which
2513 don't require a location appended to the end.
2514 PRINT_NOTHING: We have done some printing and we don't need any
2515 further info to be printed.*/
2517 enum print_stop_action
2518 bpstat_print (bpstat bs
)
2522 /* Maybe another breakpoint in the chain caused us to stop.
2523 (Currently all watchpoints go on the bpstat whether hit or not.
2524 That probably could (should) be changed, provided care is taken
2525 with respect to bpstat_explains_signal). */
2526 for (; bs
; bs
= bs
->next
)
2528 val
= print_bp_stop_message (bs
);
2529 if (val
== PRINT_SRC_ONLY
2530 || val
== PRINT_SRC_AND_LOC
2531 || val
== PRINT_NOTHING
)
2535 /* We reached the end of the chain, or we got a null BS to start
2536 with and nothing was printed. */
2537 return PRINT_UNKNOWN
;
2540 /* Evaluate the expression EXP and return 1 if value is zero.
2541 This is used inside a catch_errors to evaluate the breakpoint condition.
2542 The argument is a "struct expression *" that has been cast to char * to
2543 make it pass through catch_errors. */
2546 breakpoint_cond_eval (void *exp
)
2548 struct value
*mark
= value_mark ();
2549 int i
= !value_true (evaluate_expression ((struct expression
*) exp
));
2550 value_free_to_mark (mark
);
2554 /* Allocate a new bpstat and chain it to the current one. */
2557 bpstat_alloc (struct breakpoint
*b
, bpstat cbs
/* Current "bs" value */ )
2561 bs
= (bpstat
) xmalloc (sizeof (*bs
));
2563 bs
->breakpoint_at
= b
;
2564 /* If the condition is false, etc., don't do the commands. */
2565 bs
->commands
= NULL
;
2567 bs
->print_it
= print_it_normal
;
2571 /* Possible return values for watchpoint_check (this can't be an enum
2572 because of check_errors). */
2573 /* The watchpoint has been deleted. */
2574 #define WP_DELETED 1
2575 /* The value has changed. */
2576 #define WP_VALUE_CHANGED 2
2577 /* The value has not changed. */
2578 #define WP_VALUE_NOT_CHANGED 3
2580 #define BP_TEMPFLAG 1
2581 #define BP_HARDWAREFLAG 2
2583 /* Check watchpoint condition. */
2586 watchpoint_check (void *p
)
2588 bpstat bs
= (bpstat
) p
;
2589 struct breakpoint
*b
;
2590 struct frame_info
*fr
;
2591 int within_current_scope
;
2593 b
= bs
->breakpoint_at
;
2595 if (b
->exp_valid_block
== NULL
)
2596 within_current_scope
= 1;
2599 /* There is no current frame at this moment. If we're going to have
2600 any chance of handling watchpoints on local variables, we'll need
2601 the frame chain (so we can determine if we're in scope). */
2602 reinit_frame_cache ();
2603 fr
= frame_find_by_id (b
->watchpoint_frame
);
2604 within_current_scope
= (fr
!= NULL
);
2606 /* If we've gotten confused in the unwinder, we might have
2607 returned a frame that can't describe this variable. */
2608 if (within_current_scope
2609 && block_function (b
->exp_valid_block
) != get_frame_function (fr
))
2610 within_current_scope
= 0;
2612 /* in_function_epilogue_p() returns a non-zero value if we're still
2613 in the function but the stack frame has already been invalidated.
2614 Since we can't rely on the values of local variables after the
2615 stack has been destroyed, we are treating the watchpoint in that
2616 state as `not changed' without further checking.
2618 vinschen/2003-09-04: The former implementation left out the case
2619 that the watchpoint frame couldn't be found by frame_find_by_id()
2620 because the current PC is currently in an epilogue. Calling
2621 gdbarch_in_function_epilogue_p() also when fr == NULL fixes that. */
2622 if ((!within_current_scope
|| fr
== get_current_frame ())
2623 && gdbarch_in_function_epilogue_p (current_gdbarch
, read_pc ()))
2624 return WP_VALUE_NOT_CHANGED
;
2625 if (fr
&& within_current_scope
)
2626 /* If we end up stopping, the current frame will get selected
2627 in normal_stop. So this call to select_frame won't affect
2632 if (within_current_scope
)
2634 /* We use value_{,free_to_}mark because it could be a
2635 *long* time before we return to the command level and
2636 call free_all_values. We can't call free_all_values because
2637 we might be in the middle of evaluating a function call. */
2639 struct value
*mark
= value_mark ();
2640 struct value
*new_val
= evaluate_expression (bs
->breakpoint_at
->exp
);
2641 if (!value_equal (b
->val
, new_val
))
2643 release_value (new_val
);
2644 value_free_to_mark (mark
);
2645 bs
->old_val
= b
->val
;
2647 /* We will stop here */
2648 return WP_VALUE_CHANGED
;
2652 /* Nothing changed, don't do anything. */
2653 value_free_to_mark (mark
);
2654 /* We won't stop here */
2655 return WP_VALUE_NOT_CHANGED
;
2660 /* This seems like the only logical thing to do because
2661 if we temporarily ignored the watchpoint, then when
2662 we reenter the block in which it is valid it contains
2663 garbage (in the case of a function, it may have two
2664 garbage values, one before and one after the prologue).
2665 So we can't even detect the first assignment to it and
2666 watch after that (since the garbage may or may not equal
2667 the first value assigned). */
2668 /* We print all the stop information in print_it_typical(), but
2669 in this case, by the time we call print_it_typical() this bp
2670 will be deleted already. So we have no choice but print the
2671 information here. */
2672 if (ui_out_is_mi_like_p (uiout
))
2674 (uiout
, "reason", async_reason_lookup (EXEC_ASYNC_WATCHPOINT_SCOPE
));
2675 ui_out_text (uiout
, "\nWatchpoint ");
2676 ui_out_field_int (uiout
, "wpnum", bs
->breakpoint_at
->number
);
2677 ui_out_text (uiout
, " deleted because the program has left the block in\n\
2678 which its expression is valid.\n");
2680 if (b
->related_breakpoint
)
2681 b
->related_breakpoint
->disposition
= disp_del_at_next_stop
;
2682 b
->disposition
= disp_del_at_next_stop
;
2688 /* Get a bpstat associated with having just stopped at address
2689 BP_ADDR in thread PTID. STOPPED_BY_WATCHPOINT is 1 if the
2690 target thinks we stopped due to a hardware watchpoint, 0 if we
2691 know we did not trigger a hardware watchpoint, and -1 if we do not know. */
2693 /* Determine whether we stopped at a breakpoint, etc, or whether we
2694 don't understand this stop. Result is a chain of bpstat's such that:
2696 if we don't understand the stop, the result is a null pointer.
2698 if we understand why we stopped, the result is not null.
2700 Each element of the chain refers to a particular breakpoint or
2701 watchpoint at which we have stopped. (We may have stopped for
2702 several reasons concurrently.)
2704 Each element of the chain has valid next, breakpoint_at,
2705 commands, FIXME??? fields. */
2708 bpstat_stop_status (CORE_ADDR bp_addr
, ptid_t ptid
, int stopped_by_watchpoint
)
2710 struct breakpoint
*b
, *temp
;
2711 /* True if we've hit a breakpoint (as opposed to a watchpoint). */
2712 int real_breakpoint
= 0;
2713 /* Root of the chain of bpstat's */
2714 struct bpstats root_bs
[1];
2715 /* Pointer to the last thing in the chain currently. */
2716 bpstat bs
= root_bs
;
2717 int thread_id
= pid_to_thread_id (ptid
);
2719 ALL_BREAKPOINTS_SAFE (b
, temp
)
2721 if (!breakpoint_enabled (b
) && b
->enable_state
!= bp_permanent
)
2724 if (b
->type
!= bp_watchpoint
2725 && b
->type
!= bp_hardware_watchpoint
2726 && b
->type
!= bp_read_watchpoint
2727 && b
->type
!= bp_access_watchpoint
2728 && b
->type
!= bp_hardware_breakpoint
2729 && b
->type
!= bp_catch_fork
2730 && b
->type
!= bp_catch_vfork
2731 && b
->type
!= bp_catch_exec
2732 && b
->type
!= bp_catch_catch
2733 && b
->type
!= bp_catch_throw
) /* a non-watchpoint bp */
2735 if (b
->loc
->address
!= bp_addr
) /* address doesn't match */
2737 if (overlay_debugging
/* unmapped overlay section */
2738 && section_is_overlay (b
->loc
->section
)
2739 && !section_is_mapped (b
->loc
->section
))
2743 /* Continuable hardware watchpoints are treated as non-existent if the
2744 reason we stopped wasn't a hardware watchpoint (we didn't stop on
2745 some data address). Otherwise gdb won't stop on a break instruction
2746 in the code (not from a breakpoint) when a hardware watchpoint has
2749 if ((b
->type
== bp_hardware_watchpoint
2750 || b
->type
== bp_read_watchpoint
2751 || b
->type
== bp_access_watchpoint
)
2752 && !stopped_by_watchpoint
)
2755 if (b
->type
== bp_hardware_breakpoint
)
2757 if (b
->loc
->address
!= bp_addr
)
2759 if (overlay_debugging
/* unmapped overlay section */
2760 && section_is_overlay (b
->loc
->section
)
2761 && !section_is_mapped (b
->loc
->section
))
2765 /* Is this a catchpoint of a load or unload? If so, did we
2766 get a load or unload of the specified library? If not,
2768 if ((b
->type
== bp_catch_load
)
2769 #if defined(SOLIB_HAVE_LOAD_EVENT)
2770 && (!SOLIB_HAVE_LOAD_EVENT (PIDGET (inferior_ptid
))
2771 || ((b
->dll_pathname
!= NULL
)
2772 && (strcmp (b
->dll_pathname
,
2773 SOLIB_LOADED_LIBRARY_PATHNAME (
2774 PIDGET (inferior_ptid
)))
2780 if ((b
->type
== bp_catch_unload
)
2781 #if defined(SOLIB_HAVE_UNLOAD_EVENT)
2782 && (!SOLIB_HAVE_UNLOAD_EVENT (PIDGET (inferior_ptid
))
2783 || ((b
->dll_pathname
!= NULL
)
2784 && (strcmp (b
->dll_pathname
,
2785 SOLIB_UNLOADED_LIBRARY_PATHNAME (
2786 PIDGET (inferior_ptid
)))
2792 if ((b
->type
== bp_catch_fork
)
2793 && !inferior_has_forked (PIDGET (inferior_ptid
),
2794 &b
->forked_inferior_pid
))
2797 if ((b
->type
== bp_catch_vfork
)
2798 && !inferior_has_vforked (PIDGET (inferior_ptid
),
2799 &b
->forked_inferior_pid
))
2802 if ((b
->type
== bp_catch_exec
)
2803 && !inferior_has_execd (PIDGET (inferior_ptid
), &b
->exec_pathname
))
2806 if (ep_is_exception_catchpoint (b
) &&
2807 !(current_exception_event
= target_get_current_exception_event ()))
2810 /* Come here if it's a watchpoint, or if the break address matches */
2812 bs
= bpstat_alloc (b
, bs
); /* Alloc a bpstat to explain stop */
2814 /* Watchpoints may change this, if not found to have triggered. */
2818 if (b
->type
== bp_watchpoint
||
2819 b
->type
== bp_hardware_watchpoint
)
2821 char *message
= xstrprintf ("Error evaluating expression for watchpoint %d\n",
2823 struct cleanup
*cleanups
= make_cleanup (xfree
, message
);
2824 int e
= catch_errors (watchpoint_check
, bs
, message
,
2826 do_cleanups (cleanups
);
2830 /* We've already printed what needs to be printed. */
2831 /* Actually this is superfluous, because by the time we
2832 call print_it_typical() the wp will be already deleted,
2833 and the function will return immediately. */
2834 bs
->print_it
= print_it_done
;
2837 case WP_VALUE_CHANGED
:
2841 case WP_VALUE_NOT_CHANGED
:
2843 bs
->print_it
= print_it_noop
;
2850 /* Error from catch_errors. */
2851 printf_filtered (_("Watchpoint %d deleted.\n"), b
->number
);
2852 if (b
->related_breakpoint
)
2853 b
->related_breakpoint
->disposition
= disp_del_at_next_stop
;
2854 b
->disposition
= disp_del_at_next_stop
;
2855 /* We've already printed what needs to be printed. */
2856 bs
->print_it
= print_it_done
;
2862 else if (b
->type
== bp_read_watchpoint
||
2863 b
->type
== bp_access_watchpoint
)
2869 if (!target_stopped_data_address (¤t_target
, &addr
))
2871 for (v
= b
->val_chain
; v
; v
= value_next (v
))
2873 if (VALUE_LVAL (v
) == lval_memory
2874 && ! value_lazy (v
))
2876 struct type
*vtype
= check_typedef (value_type (v
));
2878 if (v
== b
->val_chain
2879 || (TYPE_CODE (vtype
) != TYPE_CODE_STRUCT
2880 && TYPE_CODE (vtype
) != TYPE_CODE_ARRAY
))
2884 vaddr
= VALUE_ADDRESS (v
) + value_offset (v
);
2885 /* Exact match not required. Within range is
2887 if (addr
>= vaddr
&&
2888 addr
< vaddr
+ TYPE_LENGTH (value_type (v
)))
2895 char *message
= xstrprintf ("Error evaluating expression for watchpoint %d\n",
2897 struct cleanup
*cleanups
= make_cleanup (xfree
, message
);
2898 int e
= catch_errors (watchpoint_check
, bs
, message
,
2900 do_cleanups (cleanups
);
2904 /* We've already printed what needs to be printed. */
2905 bs
->print_it
= print_it_done
;
2908 case WP_VALUE_CHANGED
:
2909 if (b
->type
== bp_read_watchpoint
)
2911 /* Don't stop: read watchpoints shouldn't fire if
2912 the value has changed. This is for targets
2913 which cannot set read-only watchpoints. */
2914 bs
->print_it
= print_it_noop
;
2920 case WP_VALUE_NOT_CHANGED
:
2927 /* Error from catch_errors. */
2928 printf_filtered (_("Watchpoint %d deleted.\n"), b
->number
);
2929 if (b
->related_breakpoint
)
2930 b
->related_breakpoint
->disposition
= disp_del_at_next_stop
;
2931 b
->disposition
= disp_del_at_next_stop
;
2932 /* We've already printed what needs to be printed. */
2933 bs
->print_it
= print_it_done
;
2937 else /* found == 0 */
2939 /* This is a case where some watchpoint(s) triggered,
2940 but not at the address of this watchpoint (FOUND
2941 was left zero). So don't print anything for this
2943 bs
->print_it
= print_it_noop
;
2950 /* By definition, an encountered breakpoint is a triggered
2954 real_breakpoint
= 1;
2957 if (frame_id_p (b
->frame_id
)
2958 && !frame_id_eq (b
->frame_id
, get_frame_id (get_current_frame ())))
2962 int value_is_zero
= 0;
2966 /* Need to select the frame, with all that implies
2967 so that the conditions will have the right context. */
2968 select_frame (get_current_frame ());
2970 = catch_errors (breakpoint_cond_eval
, (b
->cond
),
2971 "Error in testing breakpoint condition:\n",
2973 /* FIXME-someday, should give breakpoint # */
2976 if (b
->cond
&& value_is_zero
)
2979 /* Don't consider this a hit. */
2982 else if (b
->thread
!= -1 && b
->thread
!= thread_id
)
2985 /* Don't consider this a hit. */
2988 else if (b
->ignore_count
> 0)
2991 annotate_ignore_count_change ();
2996 /* We will stop here */
2997 if (b
->disposition
== disp_disable
)
2998 b
->enable_state
= bp_disabled
;
3001 bs
->commands
= b
->commands
;
3003 (strcmp ("silent", bs
->commands
->line
) == 0
3004 || (xdb_commands
&& strcmp ("Q", bs
->commands
->line
) == 0)))
3006 bs
->commands
= bs
->commands
->next
;
3009 bs
->commands
= copy_command_lines (bs
->commands
);
3012 /* Print nothing for this entry if we dont stop or if we dont print. */
3013 if (bs
->stop
== 0 || bs
->print
== 0)
3014 bs
->print_it
= print_it_noop
;
3017 bs
->next
= NULL
; /* Terminate the chain */
3018 bs
= root_bs
->next
; /* Re-grab the head of the chain */
3020 /* The value of a hardware watchpoint hasn't changed, but the
3021 intermediate memory locations we are watching may have. */
3022 if (bs
&& !bs
->stop
&&
3023 (bs
->breakpoint_at
->type
== bp_hardware_watchpoint
||
3024 bs
->breakpoint_at
->type
== bp_read_watchpoint
||
3025 bs
->breakpoint_at
->type
== bp_access_watchpoint
))
3027 remove_breakpoints ();
3028 insert_breakpoints ();
3033 /* Tell what to do about this bpstat. */
3035 bpstat_what (bpstat bs
)
3037 /* Classify each bpstat as one of the following. */
3040 /* This bpstat element has no effect on the main_action. */
3043 /* There was a watchpoint, stop but don't print. */
3046 /* There was a watchpoint, stop and print. */
3049 /* There was a breakpoint but we're not stopping. */
3052 /* There was a breakpoint, stop but don't print. */
3055 /* There was a breakpoint, stop and print. */
3058 /* We hit the longjmp breakpoint. */
3061 /* We hit the longjmp_resume breakpoint. */
3064 /* We hit the step_resume breakpoint. */
3067 /* We hit the through_sigtramp breakpoint. */
3070 /* We hit the shared library event breakpoint. */
3073 /* We caught a shared library event. */
3076 /* This is just used to count how many enums there are. */
3080 /* Here is the table which drives this routine. So that we can
3081 format it pretty, we define some abbreviations for the
3082 enum bpstat_what codes. */
3083 #define kc BPSTAT_WHAT_KEEP_CHECKING
3084 #define ss BPSTAT_WHAT_STOP_SILENT
3085 #define sn BPSTAT_WHAT_STOP_NOISY
3086 #define sgl BPSTAT_WHAT_SINGLE
3087 #define slr BPSTAT_WHAT_SET_LONGJMP_RESUME
3088 #define clr BPSTAT_WHAT_CLEAR_LONGJMP_RESUME
3089 #define clrs BPSTAT_WHAT_CLEAR_LONGJMP_RESUME_SINGLE
3090 #define sr BPSTAT_WHAT_STEP_RESUME
3091 #define ts BPSTAT_WHAT_THROUGH_SIGTRAMP
3092 #define shl BPSTAT_WHAT_CHECK_SHLIBS
3093 #define shlr BPSTAT_WHAT_CHECK_SHLIBS_RESUME_FROM_HOOK
3095 /* "Can't happen." Might want to print an error message.
3096 abort() is not out of the question, but chances are GDB is just
3097 a bit confused, not unusable. */
3098 #define err BPSTAT_WHAT_STOP_NOISY
3100 /* Given an old action and a class, come up with a new action. */
3101 /* One interesting property of this table is that wp_silent is the same
3102 as bp_silent and wp_noisy is the same as bp_noisy. That is because
3103 after stopping, the check for whether to step over a breakpoint
3104 (BPSTAT_WHAT_SINGLE type stuff) is handled in proceed() without
3105 reference to how we stopped. We retain separate wp_silent and
3106 bp_silent codes in case we want to change that someday.
3108 Another possibly interesting property of this table is that
3109 there's a partial ordering, priority-like, of the actions. Once
3110 you've decided that some action is appropriate, you'll never go
3111 back and decide something of a lower priority is better. The
3114 kc < clr sgl shl shlr slr sn sr ss ts
3115 sgl < clrs shl shlr slr sn sr ss ts
3116 slr < err shl shlr sn sr ss ts
3117 clr < clrs err shl shlr sn sr ss ts
3118 clrs < err shl shlr sn sr ss ts
3119 ss < shl shlr sn sr ts
3126 What I think this means is that we don't need a damned table
3127 here. If you just put the rows and columns in the right order,
3128 it'd look awfully regular. We could simply walk the bpstat list
3129 and choose the highest priority action we find, with a little
3130 logic to handle the 'err' cases, and the CLEAR_LONGJMP_RESUME/
3131 CLEAR_LONGJMP_RESUME_SINGLE distinction (which breakpoint.h says
3132 is messy anyway). */
3134 /* step_resume entries: a step resume breakpoint overrides another
3135 breakpoint of signal handling (see comment in wait_for_inferior
3136 at where we set the step_resume breakpoint). */
3137 /* We handle the through_sigtramp_breakpoint the same way; having both
3138 one of those and a step_resume_breakpoint is probably very rare (?). */
3140 static const enum bpstat_what_main_action
3141 table
[(int) class_last
][(int) BPSTAT_WHAT_LAST
] =
3144 /* kc ss sn sgl slr clr clrs sr ts shl shlr
3147 {kc
, ss
, sn
, sgl
, slr
, clr
, clrs
, sr
, ts
, shl
, shlr
},
3149 {ss
, ss
, sn
, ss
, ss
, ss
, ss
, sr
, ts
, shl
, shlr
},
3151 {sn
, sn
, sn
, sn
, sn
, sn
, sn
, sr
, ts
, shl
, shlr
},
3153 {sgl
, ss
, sn
, sgl
, slr
, clrs
, clrs
, sr
, ts
, shl
, shlr
},
3155 {ss
, ss
, sn
, ss
, ss
, ss
, ss
, sr
, ts
, shl
, shlr
},
3157 {sn
, sn
, sn
, sn
, sn
, sn
, sn
, sr
, ts
, shl
, shlr
},
3159 {slr
, ss
, sn
, slr
, slr
, err
, err
, sr
, ts
, shl
, shlr
},
3161 {clr
, ss
, sn
, clrs
, err
, err
, err
, sr
, ts
, shl
, shlr
},
3163 {sr
, sr
, sr
, sr
, sr
, sr
, sr
, sr
, ts
, shl
, shlr
},
3165 {ts
, ts
, ts
, ts
, ts
, ts
, ts
, ts
, ts
, shl
, shlr
},
3167 {shl
, shl
, shl
, shl
, shl
, shl
, shl
, shl
, ts
, shl
, shlr
},
3169 {shlr
, shlr
, shlr
, shlr
, shlr
, shlr
, shlr
, shlr
, ts
, shlr
, shlr
}
3184 enum bpstat_what_main_action current_action
= BPSTAT_WHAT_KEEP_CHECKING
;
3185 struct bpstat_what retval
;
3187 retval
.call_dummy
= 0;
3188 for (; bs
!= NULL
; bs
= bs
->next
)
3190 enum class bs_class
= no_effect
;
3191 if (bs
->breakpoint_at
== NULL
)
3192 /* I suspect this can happen if it was a momentary breakpoint
3193 which has since been deleted. */
3195 switch (bs
->breakpoint_at
->type
)
3201 case bp_hardware_breakpoint
:
3207 bs_class
= bp_noisy
;
3209 bs_class
= bp_silent
;
3212 bs_class
= bp_nostop
;
3215 case bp_hardware_watchpoint
:
3216 case bp_read_watchpoint
:
3217 case bp_access_watchpoint
:
3221 bs_class
= wp_noisy
;
3223 bs_class
= wp_silent
;
3226 /* There was a watchpoint, but we're not stopping.
3227 This requires no further action. */
3228 bs_class
= no_effect
;
3231 bs_class
= long_jump
;
3233 case bp_longjmp_resume
:
3234 bs_class
= long_resume
;
3236 case bp_step_resume
:
3239 bs_class
= step_resume
;
3242 /* It is for the wrong frame. */
3243 bs_class
= bp_nostop
;
3245 case bp_through_sigtramp
:
3246 bs_class
= through_sig
;
3248 case bp_watchpoint_scope
:
3249 bs_class
= bp_nostop
;
3251 case bp_shlib_event
:
3252 bs_class
= shlib_event
;
3254 case bp_thread_event
:
3255 case bp_overlay_event
:
3256 bs_class
= bp_nostop
;
3259 case bp_catch_unload
:
3260 /* Only if this catchpoint triggered should we cause the
3261 step-out-of-dld behaviour. Otherwise, we ignore this
3264 bs_class
= catch_shlib_event
;
3266 bs_class
= no_effect
;
3269 case bp_catch_vfork
:
3274 bs_class
= bp_noisy
;
3276 bs_class
= bp_silent
;
3279 /* There was a catchpoint, but we're not stopping.
3280 This requires no further action. */
3281 bs_class
= no_effect
;
3283 case bp_catch_catch
:
3284 if (!bs
->stop
|| CURRENT_EXCEPTION_KIND
!= EX_EVENT_CATCH
)
3285 bs_class
= bp_nostop
;
3287 bs_class
= bs
->print
? bp_noisy
: bp_silent
;
3289 case bp_catch_throw
:
3290 if (!bs
->stop
|| CURRENT_EXCEPTION_KIND
!= EX_EVENT_THROW
)
3291 bs_class
= bp_nostop
;
3293 bs_class
= bs
->print
? bp_noisy
: bp_silent
;
3296 /* Make sure the action is stop (silent or noisy),
3297 so infrun.c pops the dummy frame. */
3298 bs_class
= bp_silent
;
3299 retval
.call_dummy
= 1;
3302 current_action
= table
[(int) bs_class
][(int) current_action
];
3304 retval
.main_action
= current_action
;
3308 /* Nonzero if we should step constantly (e.g. watchpoints on machines
3309 without hardware support). This isn't related to a specific bpstat,
3310 just to things like whether watchpoints are set. */
3313 bpstat_should_step (void)
3315 struct breakpoint
*b
;
3317 if (breakpoint_enabled (b
) && b
->type
== bp_watchpoint
)
3322 /* Nonzero if there are enabled hardware watchpoints. */
3324 bpstat_have_active_hw_watchpoints (void)
3326 struct bp_location
*bpt
;
3327 ALL_BP_LOCATIONS (bpt
)
3328 if (breakpoint_enabled (bpt
->owner
)
3330 && bpt
->loc_type
== bp_loc_hardware_watchpoint
)
3336 /* Given a bpstat that records zero or more triggered eventpoints, this
3337 function returns another bpstat which contains only the catchpoints
3338 on that first list, if any. */
3340 bpstat_get_triggered_catchpoints (bpstat ep_list
, bpstat
*cp_list
)
3342 struct bpstats root_bs
[1];
3343 bpstat bs
= root_bs
;
3344 struct breakpoint
*ep
;
3347 bpstat_clear (cp_list
);
3348 root_bs
->next
= NULL
;
3350 for (; ep_list
!= NULL
; ep_list
= ep_list
->next
)
3352 /* Is this eventpoint a catchpoint? If not, ignore it. */
3353 ep
= ep_list
->breakpoint_at
;
3356 if ((ep
->type
!= bp_catch_load
) &&
3357 (ep
->type
!= bp_catch_unload
) &&
3358 (ep
->type
!= bp_catch_catch
) &&
3359 (ep
->type
!= bp_catch_throw
))
3360 /* pai: (temp) ADD fork/vfork here!! */
3363 /* Yes; add it to the list. */
3364 bs
= bpstat_alloc (ep
, bs
);
3369 #if defined(SOLIB_ADD)
3370 /* Also, for each triggered catchpoint, tag it with the name of
3371 the library that caused this trigger. (We copy the name now,
3372 because it's only guaranteed to be available NOW, when the
3373 catchpoint triggers. Clients who may wish to know the name
3374 later must get it from the catchpoint itself.) */
3375 if (ep
->triggered_dll_pathname
!= NULL
)
3376 xfree (ep
->triggered_dll_pathname
);
3377 if (ep
->type
== bp_catch_load
)
3378 dll_pathname
= SOLIB_LOADED_LIBRARY_PATHNAME (
3379 PIDGET (inferior_ptid
));
3381 dll_pathname
= SOLIB_UNLOADED_LIBRARY_PATHNAME (
3382 PIDGET (inferior_ptid
));
3384 dll_pathname
= NULL
;
3388 ep
->triggered_dll_pathname
= (char *)
3389 xmalloc (strlen (dll_pathname
) + 1);
3390 strcpy (ep
->triggered_dll_pathname
, dll_pathname
);
3393 ep
->triggered_dll_pathname
= NULL
;
3399 /* Print B to gdb_stdout. */
3401 print_one_breakpoint (struct breakpoint
*b
,
3402 CORE_ADDR
*last_addr
)
3404 struct command_line
*l
;
3406 struct ep_type_description
3411 static struct ep_type_description bptypes
[] =
3413 {bp_none
, "?deleted?"},
3414 {bp_breakpoint
, "breakpoint"},
3415 {bp_hardware_breakpoint
, "hw breakpoint"},
3416 {bp_until
, "until"},
3417 {bp_finish
, "finish"},
3418 {bp_watchpoint
, "watchpoint"},
3419 {bp_hardware_watchpoint
, "hw watchpoint"},
3420 {bp_read_watchpoint
, "read watchpoint"},
3421 {bp_access_watchpoint
, "acc watchpoint"},
3422 {bp_longjmp
, "longjmp"},
3423 {bp_longjmp_resume
, "longjmp resume"},
3424 {bp_step_resume
, "step resume"},
3425 {bp_through_sigtramp
, "sigtramp"},
3426 {bp_watchpoint_scope
, "watchpoint scope"},
3427 {bp_call_dummy
, "call dummy"},
3428 {bp_shlib_event
, "shlib events"},
3429 {bp_thread_event
, "thread events"},
3430 {bp_overlay_event
, "overlay events"},
3431 {bp_catch_load
, "catch load"},
3432 {bp_catch_unload
, "catch unload"},
3433 {bp_catch_fork
, "catch fork"},
3434 {bp_catch_vfork
, "catch vfork"},
3435 {bp_catch_exec
, "catch exec"},
3436 {bp_catch_catch
, "catch catch"},
3437 {bp_catch_throw
, "catch throw"}
3440 static char *bpdisps
[] =
3441 {"del", "dstp", "dis", "keep"};
3442 static char bpenables
[] = "nynny";
3443 char wrap_indent
[80];
3444 struct ui_stream
*stb
= ui_out_stream_new (uiout
);
3445 struct cleanup
*old_chain
= make_cleanup_ui_out_stream_delete (stb
);
3446 struct cleanup
*bkpt_chain
;
3449 bkpt_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "bkpt");
3453 ui_out_field_int (uiout
, "number", b
->number
);
3457 if (((int) b
->type
> (sizeof (bptypes
) / sizeof (bptypes
[0])))
3458 || ((int) b
->type
!= bptypes
[(int) b
->type
].type
))
3459 internal_error (__FILE__
, __LINE__
,
3460 _("bptypes table does not describe type #%d."),
3462 ui_out_field_string (uiout
, "type", bptypes
[(int) b
->type
].description
);
3466 ui_out_field_string (uiout
, "disp", bpdisps
[(int) b
->disposition
]);
3470 ui_out_field_fmt (uiout
, "enabled", "%c", bpenables
[(int) b
->enable_state
]);
3471 ui_out_spaces (uiout
, 2);
3474 strcpy (wrap_indent
, " ");
3477 if (TARGET_ADDR_BIT
<= 32)
3478 strcat (wrap_indent
, " ");
3480 strcat (wrap_indent
, " ");
3483 if (b
->ops
!= NULL
&& b
->ops
->print_one
!= NULL
)
3484 b
->ops
->print_one (b
, last_addr
);
3489 internal_error (__FILE__
, __LINE__
,
3490 _("print_one_breakpoint: bp_none encountered\n"));
3494 case bp_hardware_watchpoint
:
3495 case bp_read_watchpoint
:
3496 case bp_access_watchpoint
:
3497 /* Field 4, the address, is omitted (which makes the columns
3498 not line up too nicely with the headers, but the effect
3499 is relatively readable). */
3501 ui_out_field_skip (uiout
, "addr");
3503 print_expression (b
->exp
, stb
->stream
);
3504 ui_out_field_stream (uiout
, "what", stb
);
3508 case bp_catch_unload
:
3509 /* Field 4, the address, is omitted (which makes the columns
3510 not line up too nicely with the headers, but the effect
3511 is relatively readable). */
3513 ui_out_field_skip (uiout
, "addr");
3515 if (b
->dll_pathname
== NULL
)
3517 ui_out_field_string (uiout
, "what", "<any library>");
3518 ui_out_spaces (uiout
, 1);
3522 ui_out_text (uiout
, "library \"");
3523 ui_out_field_string (uiout
, "what", b
->dll_pathname
);
3524 ui_out_text (uiout
, "\" ");
3529 case bp_catch_vfork
:
3530 /* Field 4, the address, is omitted (which makes the columns
3531 not line up too nicely with the headers, but the effect
3532 is relatively readable). */
3534 ui_out_field_skip (uiout
, "addr");
3536 if (b
->forked_inferior_pid
!= 0)
3538 ui_out_text (uiout
, "process ");
3539 ui_out_field_int (uiout
, "what", b
->forked_inferior_pid
);
3540 ui_out_spaces (uiout
, 1);
3545 /* Field 4, the address, is omitted (which makes the columns
3546 not line up too nicely with the headers, but the effect
3547 is relatively readable). */
3549 ui_out_field_skip (uiout
, "addr");
3551 if (b
->exec_pathname
!= NULL
)
3553 ui_out_text (uiout
, "program \"");
3554 ui_out_field_string (uiout
, "what", b
->exec_pathname
);
3555 ui_out_text (uiout
, "\" ");
3559 case bp_catch_catch
:
3560 /* Field 4, the address, is omitted (which makes the columns
3561 not line up too nicely with the headers, but the effect
3562 is relatively readable). */
3564 ui_out_field_skip (uiout
, "addr");
3566 ui_out_field_string (uiout
, "what", "exception catch");
3567 ui_out_spaces (uiout
, 1);
3570 case bp_catch_throw
:
3571 /* Field 4, the address, is omitted (which makes the columns
3572 not line up too nicely with the headers, but the effect
3573 is relatively readable). */
3575 ui_out_field_skip (uiout
, "addr");
3577 ui_out_field_string (uiout
, "what", "exception throw");
3578 ui_out_spaces (uiout
, 1);
3582 case bp_hardware_breakpoint
:
3586 case bp_longjmp_resume
:
3587 case bp_step_resume
:
3588 case bp_through_sigtramp
:
3589 case bp_watchpoint_scope
:
3591 case bp_shlib_event
:
3592 case bp_thread_event
:
3593 case bp_overlay_event
:
3598 ui_out_field_string (uiout
, "addr", "<PENDING>");
3600 ui_out_field_core_addr (uiout
, "addr", b
->loc
->address
);
3603 *last_addr
= b
->loc
->address
;
3606 sym
= find_pc_sect_function (b
->loc
->address
, b
->loc
->section
);
3609 ui_out_text (uiout
, "in ");
3610 ui_out_field_string (uiout
, "func",
3611 SYMBOL_PRINT_NAME (sym
));
3612 ui_out_wrap_hint (uiout
, wrap_indent
);
3613 ui_out_text (uiout
, " at ");
3615 ui_out_field_string (uiout
, "file", b
->source_file
);
3616 ui_out_text (uiout
, ":");
3618 if (ui_out_is_mi_like_p (uiout
))
3620 struct symtab_and_line sal
= find_pc_line (b
->loc
->address
, 0);
3621 char *fullname
= symtab_to_fullname (sal
.symtab
);
3624 ui_out_field_string (uiout
, "fullname", fullname
);
3627 ui_out_field_int (uiout
, "line", b
->line_number
);
3629 else if (b
->pending
)
3631 ui_out_field_string (uiout
, "pending", b
->addr_string
);
3635 print_address_symbolic (b
->loc
->address
, stb
->stream
, demangle
, "");
3636 ui_out_field_stream (uiout
, "at", stb
);
3641 if (b
->thread
!= -1)
3643 /* FIXME: This seems to be redundant and lost here; see the
3644 "stop only in" line a little further down. */
3645 ui_out_text (uiout
, " thread ");
3646 ui_out_field_int (uiout
, "thread", b
->thread
);
3649 ui_out_text (uiout
, "\n");
3651 if (frame_id_p (b
->frame_id
))
3654 ui_out_text (uiout
, "\tstop only in stack frame at ");
3655 /* FIXME: cagney/2002-12-01: Shouldn't be poeking around inside
3657 ui_out_field_core_addr (uiout
, "frame", b
->frame_id
.stack_addr
);
3658 ui_out_text (uiout
, "\n");
3661 if (b
->cond
&& !ada_exception_catchpoint_p (b
))
3663 /* We do not print the condition for Ada exception catchpoints
3664 because the condition is an internal implementation detail
3665 that we do not want to expose to the user. */
3667 ui_out_text (uiout
, "\tstop only if ");
3668 print_expression (b
->cond
, stb
->stream
);
3669 ui_out_field_stream (uiout
, "cond", stb
);
3670 ui_out_text (uiout
, "\n");
3673 if (b
->pending
&& b
->cond_string
)
3676 ui_out_text (uiout
, "\tstop only if ");
3677 ui_out_field_string (uiout
, "cond", b
->cond_string
);
3678 ui_out_text (uiout
, "\n");
3681 if (b
->thread
!= -1)
3683 /* FIXME should make an annotation for this */
3684 ui_out_text (uiout
, "\tstop only in thread ");
3685 ui_out_field_int (uiout
, "thread", b
->thread
);
3686 ui_out_text (uiout
, "\n");
3689 if (show_breakpoint_hit_counts
&& b
->hit_count
)
3691 /* FIXME should make an annotation for this */
3692 if (ep_is_catchpoint (b
))
3693 ui_out_text (uiout
, "\tcatchpoint");
3695 ui_out_text (uiout
, "\tbreakpoint");
3696 ui_out_text (uiout
, " already hit ");
3697 ui_out_field_int (uiout
, "times", b
->hit_count
);
3698 if (b
->hit_count
== 1)
3699 ui_out_text (uiout
, " time\n");
3701 ui_out_text (uiout
, " times\n");
3704 /* Output the count also if it is zero, but only if this is
3705 mi. FIXME: Should have a better test for this. */
3706 if (ui_out_is_mi_like_p (uiout
))
3707 if (show_breakpoint_hit_counts
&& b
->hit_count
== 0)
3708 ui_out_field_int (uiout
, "times", b
->hit_count
);
3710 if (b
->ignore_count
)
3713 ui_out_text (uiout
, "\tignore next ");
3714 ui_out_field_int (uiout
, "ignore", b
->ignore_count
);
3715 ui_out_text (uiout
, " hits\n");
3718 if ((l
= b
->commands
))
3720 struct cleanup
*script_chain
;
3723 script_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "script");
3724 print_command_lines (uiout
, l
, 4);
3725 do_cleanups (script_chain
);
3727 do_cleanups (bkpt_chain
);
3728 do_cleanups (old_chain
);
3731 struct captured_breakpoint_query_args
3737 do_captured_breakpoint_query (struct ui_out
*uiout
, void *data
)
3739 struct captured_breakpoint_query_args
*args
= data
;
3740 struct breakpoint
*b
;
3741 CORE_ADDR dummy_addr
= 0;
3744 if (args
->bnum
== b
->number
)
3746 print_one_breakpoint (b
, &dummy_addr
);
3754 gdb_breakpoint_query (struct ui_out
*uiout
, int bnum
, char **error_message
)
3756 struct captured_breakpoint_query_args args
;
3758 /* For the moment we don't trust print_one_breakpoint() to not throw
3760 return catch_exceptions_with_msg (uiout
, do_captured_breakpoint_query
, &args
,
3761 error_message
, RETURN_MASK_ALL
);
3764 /* Return non-zero if B is user settable (breakpoints, watchpoints,
3765 catchpoints, et.al.). */
3768 user_settable_breakpoint (const struct breakpoint
*b
)
3770 return (b
->type
== bp_breakpoint
3771 || b
->type
== bp_catch_load
3772 || b
->type
== bp_catch_unload
3773 || b
->type
== bp_catch_fork
3774 || b
->type
== bp_catch_vfork
3775 || b
->type
== bp_catch_exec
3776 || b
->type
== bp_catch_catch
3777 || b
->type
== bp_catch_throw
3778 || b
->type
== bp_hardware_breakpoint
3779 || b
->type
== bp_watchpoint
3780 || b
->type
== bp_read_watchpoint
3781 || b
->type
== bp_access_watchpoint
3782 || b
->type
== bp_hardware_watchpoint
);
3785 /* Print information on user settable breakpoint (watchpoint, etc)
3786 number BNUM. If BNUM is -1 print all user settable breakpoints.
3787 If ALLFLAG is non-zero, include non- user settable breakpoints. */
3790 breakpoint_1 (int bnum
, int allflag
)
3792 struct breakpoint
*b
;
3793 CORE_ADDR last_addr
= (CORE_ADDR
) -1;
3794 int nr_printable_breakpoints
;
3795 struct cleanup
*bkpttbl_chain
;
3797 /* Compute the number of rows in the table. */
3798 nr_printable_breakpoints
= 0;
3801 || bnum
== b
->number
)
3803 if (allflag
|| user_settable_breakpoint (b
))
3804 nr_printable_breakpoints
++;
3809 = make_cleanup_ui_out_table_begin_end (uiout
, 6, nr_printable_breakpoints
,
3813 = make_cleanup_ui_out_table_begin_end (uiout
, 5, nr_printable_breakpoints
,
3816 if (nr_printable_breakpoints
> 0)
3817 annotate_breakpoints_headers ();
3818 if (nr_printable_breakpoints
> 0)
3820 ui_out_table_header (uiout
, 3, ui_left
, "number", "Num"); /* 1 */
3821 if (nr_printable_breakpoints
> 0)
3823 ui_out_table_header (uiout
, 14, ui_left
, "type", "Type"); /* 2 */
3824 if (nr_printable_breakpoints
> 0)
3826 ui_out_table_header (uiout
, 4, ui_left
, "disp", "Disp"); /* 3 */
3827 if (nr_printable_breakpoints
> 0)
3829 ui_out_table_header (uiout
, 3, ui_left
, "enabled", "Enb"); /* 4 */
3832 if (nr_printable_breakpoints
> 0)
3834 if (TARGET_ADDR_BIT
<= 32)
3835 ui_out_table_header (uiout
, 10, ui_left
, "addr", "Address");/* 5 */
3837 ui_out_table_header (uiout
, 18, ui_left
, "addr", "Address");/* 5 */
3839 if (nr_printable_breakpoints
> 0)
3841 ui_out_table_header (uiout
, 40, ui_noalign
, "what", "What"); /* 6 */
3842 ui_out_table_body (uiout
);
3843 if (nr_printable_breakpoints
> 0)
3844 annotate_breakpoints_table ();
3848 || bnum
== b
->number
)
3850 /* We only print out user settable breakpoints unless the
3852 if (allflag
|| user_settable_breakpoint (b
))
3853 print_one_breakpoint (b
, &last_addr
);
3856 do_cleanups (bkpttbl_chain
);
3858 if (nr_printable_breakpoints
== 0)
3861 ui_out_message (uiout
, 0, "No breakpoints or watchpoints.\n");
3863 ui_out_message (uiout
, 0, "No breakpoint or watchpoint number %d.\n",
3868 /* Compare against (CORE_ADDR)-1 in case some compiler decides
3869 that a comparison of an unsigned with -1 is always false. */
3870 if (last_addr
!= (CORE_ADDR
) -1)
3871 set_next_address (last_addr
);
3874 /* FIXME? Should this be moved up so that it is only called when
3875 there have been breakpoints? */
3876 annotate_breakpoints_table_end ();
3880 breakpoints_info (char *bnum_exp
, int from_tty
)
3885 bnum
= parse_and_eval_long (bnum_exp
);
3887 breakpoint_1 (bnum
, 0);
3891 maintenance_info_breakpoints (char *bnum_exp
, int from_tty
)
3896 bnum
= parse_and_eval_long (bnum_exp
);
3898 breakpoint_1 (bnum
, 1);
3901 /* Print a message describing any breakpoints set at PC. */
3904 describe_other_breakpoints (CORE_ADDR pc
, asection
*section
, int thread
)
3907 struct breakpoint
*b
;
3910 if (b
->loc
->address
== pc
) /* address match / overlay match */
3911 if (!b
->pending
&& (!overlay_debugging
|| b
->loc
->section
== section
))
3916 printf_filtered (_("Note: breakpoint "));
3917 else /* if (others == ???) */
3918 printf_filtered (_("Note: breakpoints "));
3920 if (b
->loc
->address
== pc
) /* address match / overlay match */
3921 if (!b
->pending
&& (!overlay_debugging
|| b
->loc
->section
== section
))
3924 printf_filtered ("%d", b
->number
);
3925 if (b
->thread
== -1 && thread
!= -1)
3926 printf_filtered (" (all threads)");
3927 else if (b
->thread
!= -1)
3928 printf_filtered (" (thread %d)", b
->thread
);
3929 printf_filtered ("%s%s ",
3930 ((b
->enable_state
== bp_disabled
||
3931 b
->enable_state
== bp_shlib_disabled
||
3932 b
->enable_state
== bp_call_disabled
)
3934 : b
->enable_state
== bp_permanent
3938 : ((others
== 1) ? " and" : ""));
3940 printf_filtered (_("also set at pc "));
3941 deprecated_print_address_numeric (pc
, 1, gdb_stdout
);
3942 printf_filtered (".\n");
3946 /* Set the default place to put a breakpoint
3947 for the `break' command with no arguments. */
3950 set_default_breakpoint (int valid
, CORE_ADDR addr
, struct symtab
*symtab
,
3953 default_breakpoint_valid
= valid
;
3954 default_breakpoint_address
= addr
;
3955 default_breakpoint_symtab
= symtab
;
3956 default_breakpoint_line
= line
;
3959 /* Return true iff it is meaningful to use the address member of
3960 BPT. For some breakpoint types, the address member is irrelevant
3961 and it makes no sense to attempt to compare it to other addresses
3962 (or use it for any other purpose either).
3964 More specifically, each of the following breakpoint types will always
3965 have a zero valued address and we don't want check_duplicates() to mark
3966 breakpoints of any of these types to be a duplicate of an actual
3967 breakpoint at address zero:
3970 bp_hardware_watchpoint
3972 bp_access_watchpoint
3979 breakpoint_address_is_meaningful (struct breakpoint
*bpt
)
3981 enum bptype type
= bpt
->type
;
3983 return (type
!= bp_watchpoint
3984 && type
!= bp_hardware_watchpoint
3985 && type
!= bp_read_watchpoint
3986 && type
!= bp_access_watchpoint
3987 && type
!= bp_catch_exec
3988 && type
!= bp_longjmp_resume
3989 && type
!= bp_catch_fork
3990 && type
!= bp_catch_vfork
);
3993 /* Rescan breakpoints at the same address and section as BPT,
3994 marking the first one as "first" and any others as "duplicates".
3995 This is so that the bpt instruction is only inserted once.
3996 If we have a permanent breakpoint at the same place as BPT, make
3997 that one the official one, and the rest as duplicates. */
4000 check_duplicates (struct breakpoint
*bpt
)
4002 struct bp_location
*b
;
4004 struct bp_location
*perm_bp
= 0;
4005 CORE_ADDR address
= bpt
->loc
->address
;
4006 asection
*section
= bpt
->loc
->section
;
4008 if (! breakpoint_address_is_meaningful (bpt
))
4011 ALL_BP_LOCATIONS (b
)
4012 if (b
->owner
->enable_state
!= bp_disabled
4013 && b
->owner
->enable_state
!= bp_shlib_disabled
4014 && !b
->owner
->pending
4015 && b
->owner
->enable_state
!= bp_call_disabled
4016 && b
->address
== address
/* address / overlay match */
4017 && (!overlay_debugging
|| b
->section
== section
)
4018 && breakpoint_address_is_meaningful (b
->owner
))
4020 /* Have we found a permanent breakpoint? */
4021 if (b
->owner
->enable_state
== bp_permanent
)
4028 b
->duplicate
= count
> 1;
4031 /* If we found a permanent breakpoint at this address, go over the
4032 list again and declare all the other breakpoints there to be the
4036 perm_bp
->duplicate
= 0;
4038 /* Permanent breakpoint should always be inserted. */
4039 if (! perm_bp
->inserted
)
4040 internal_error (__FILE__
, __LINE__
,
4041 _("allegedly permanent breakpoint is not "
4042 "actually inserted"));
4044 ALL_BP_LOCATIONS (b
)
4047 if (b
->owner
->enable_state
!= bp_disabled
4048 && b
->owner
->enable_state
!= bp_shlib_disabled
4049 && !b
->owner
->pending
4050 && b
->owner
->enable_state
!= bp_call_disabled
4051 && b
->address
== address
/* address / overlay match */
4052 && (!overlay_debugging
|| b
->section
== section
)
4053 && breakpoint_address_is_meaningful (b
->owner
))
4056 internal_error (__FILE__
, __LINE__
,
4057 _("another breakpoint was inserted on top of "
4058 "a permanent breakpoint"));
4067 breakpoint_adjustment_warning (CORE_ADDR from_addr
, CORE_ADDR to_addr
,
4068 int bnum
, int have_bnum
)
4073 strcpy (astr1
, hex_string_custom ((unsigned long) from_addr
, 8));
4074 strcpy (astr2
, hex_string_custom ((unsigned long) to_addr
, 8));
4076 warning (_("Breakpoint %d address previously adjusted from %s to %s."),
4077 bnum
, astr1
, astr2
);
4079 warning (_("Breakpoint address adjusted from %s to %s."), astr1
, astr2
);
4082 /* Adjust a breakpoint's address to account for architectural constraints
4083 on breakpoint placement. Return the adjusted address. Note: Very
4084 few targets require this kind of adjustment. For most targets,
4085 this function is simply the identity function. */
4088 adjust_breakpoint_address (CORE_ADDR bpaddr
, enum bptype bptype
)
4090 if (!gdbarch_adjust_breakpoint_address_p (current_gdbarch
))
4092 /* Very few targets need any kind of breakpoint adjustment. */
4095 else if (bptype
== bp_watchpoint
4096 || bptype
== bp_hardware_watchpoint
4097 || bptype
== bp_read_watchpoint
4098 || bptype
== bp_access_watchpoint
4099 || bptype
== bp_catch_fork
4100 || bptype
== bp_catch_vfork
4101 || bptype
== bp_catch_exec
)
4103 /* Watchpoints and the various bp_catch_* eventpoints should not
4104 have their addresses modified. */
4109 CORE_ADDR adjusted_bpaddr
;
4111 /* Some targets have architectural constraints on the placement
4112 of breakpoint instructions. Obtain the adjusted address. */
4113 adjusted_bpaddr
= gdbarch_adjust_breakpoint_address (current_gdbarch
,
4116 /* An adjusted breakpoint address can significantly alter
4117 a user's expectations. Print a warning if an adjustment
4119 if (adjusted_bpaddr
!= bpaddr
)
4120 breakpoint_adjustment_warning (bpaddr
, adjusted_bpaddr
, 0, 0);
4122 return adjusted_bpaddr
;
4126 /* Allocate a struct bp_location. */
4128 static struct bp_location
*
4129 allocate_bp_location (struct breakpoint
*bpt
, enum bptype bp_type
)
4131 struct bp_location
*loc
, *loc_p
;
4133 loc
= xmalloc (sizeof (struct bp_location
));
4134 memset (loc
, 0, sizeof (*loc
));
4144 case bp_longjmp_resume
:
4145 case bp_step_resume
:
4146 case bp_through_sigtramp
:
4147 case bp_watchpoint_scope
:
4149 case bp_shlib_event
:
4150 case bp_thread_event
:
4151 case bp_overlay_event
:
4153 case bp_catch_unload
:
4154 loc
->loc_type
= bp_loc_software_breakpoint
;
4156 case bp_hardware_breakpoint
:
4157 loc
->loc_type
= bp_loc_hardware_breakpoint
;
4159 case bp_hardware_watchpoint
:
4160 case bp_read_watchpoint
:
4161 case bp_access_watchpoint
:
4162 loc
->loc_type
= bp_loc_hardware_watchpoint
;
4166 case bp_catch_vfork
:
4168 case bp_catch_catch
:
4169 case bp_catch_throw
:
4170 loc
->loc_type
= bp_loc_other
;
4173 internal_error (__FILE__
, __LINE__
, _("unknown breakpoint type"));
4176 /* Add this breakpoint to the end of the chain. */
4178 loc_p
= bp_location_chain
;
4180 bp_location_chain
= loc
;
4184 loc_p
= loc_p
->next
;
4191 /* set_raw_breakpoint() is a low level routine for allocating and
4192 partially initializing a breakpoint of type BPTYPE. The newly
4193 created breakpoint's address, section, source file name, and line
4194 number are provided by SAL. The newly created and partially
4195 initialized breakpoint is added to the breakpoint chain and
4196 is also returned as the value of this function.
4198 It is expected that the caller will complete the initialization of
4199 the newly created breakpoint struct as well as output any status
4200 information regarding the creation of a new breakpoint. In
4201 particular, set_raw_breakpoint() does NOT set the breakpoint
4202 number! Care should be taken to not allow an error() to occur
4203 prior to completing the initialization of the breakpoint. If this
4204 should happen, a bogus breakpoint will be left on the chain. */
4207 set_raw_breakpoint (struct symtab_and_line sal
, enum bptype bptype
)
4209 struct breakpoint
*b
, *b1
;
4211 b
= (struct breakpoint
*) xmalloc (sizeof (struct breakpoint
));
4212 memset (b
, 0, sizeof (*b
));
4213 b
->loc
= allocate_bp_location (b
, bptype
);
4214 b
->loc
->requested_address
= sal
.pc
;
4215 b
->loc
->address
= adjust_breakpoint_address (b
->loc
->requested_address
,
4217 if (sal
.symtab
== NULL
)
4218 b
->source_file
= NULL
;
4220 b
->source_file
= savestring (sal
.symtab
->filename
,
4221 strlen (sal
.symtab
->filename
));
4222 b
->loc
->section
= sal
.section
;
4224 b
->language
= current_language
->la_language
;
4225 b
->input_radix
= input_radix
;
4227 b
->line_number
= sal
.line
;
4228 b
->enable_state
= bp_enabled
;
4231 b
->ignore_count
= 0;
4233 b
->frame_id
= null_frame_id
;
4234 b
->dll_pathname
= NULL
;
4235 b
->triggered_dll_pathname
= NULL
;
4236 b
->forked_inferior_pid
= 0;
4237 b
->exec_pathname
= NULL
;
4241 /* Add this breakpoint to the end of the chain
4242 so that a list of breakpoints will come out in order
4243 of increasing numbers. */
4245 b1
= breakpoint_chain
;
4247 breakpoint_chain
= b
;
4255 check_duplicates (b
);
4256 breakpoints_changed ();
4262 /* Note that the breakpoint object B describes a permanent breakpoint
4263 instruction, hard-wired into the inferior's code. */
4265 make_breakpoint_permanent (struct breakpoint
*b
)
4267 b
->enable_state
= bp_permanent
;
4269 /* By definition, permanent breakpoints are already present in the code. */
4270 b
->loc
->inserted
= 1;
4273 static struct breakpoint
*
4274 create_internal_breakpoint (CORE_ADDR address
, enum bptype type
)
4276 static int internal_breakpoint_number
= -1;
4277 struct symtab_and_line sal
;
4278 struct breakpoint
*b
;
4280 init_sal (&sal
); /* initialize to zeroes */
4283 sal
.section
= find_pc_overlay (sal
.pc
);
4285 b
= set_raw_breakpoint (sal
, type
);
4286 b
->number
= internal_breakpoint_number
--;
4287 b
->disposition
= disp_donttouch
;
4294 create_longjmp_breakpoint (char *func_name
)
4296 struct breakpoint
*b
;
4297 struct minimal_symbol
*m
;
4299 if (func_name
== NULL
)
4300 b
= create_internal_breakpoint (0, bp_longjmp_resume
);
4303 if ((m
= lookup_minimal_symbol_text (func_name
, NULL
)) == NULL
)
4306 b
= create_internal_breakpoint (SYMBOL_VALUE_ADDRESS (m
), bp_longjmp
);
4309 b
->enable_state
= bp_disabled
;
4312 b
->addr_string
= xstrdup (func_name
);
4315 /* Call this routine when stepping and nexting to enable a breakpoint
4316 if we do a longjmp(). When we hit that breakpoint, call
4317 set_longjmp_resume_breakpoint() to figure out where we are going. */
4320 enable_longjmp_breakpoint (void)
4322 struct breakpoint
*b
;
4325 if (b
->type
== bp_longjmp
)
4327 b
->enable_state
= bp_enabled
;
4328 check_duplicates (b
);
4333 disable_longjmp_breakpoint (void)
4335 struct breakpoint
*b
;
4338 if (b
->type
== bp_longjmp
4339 || b
->type
== bp_longjmp_resume
)
4341 b
->enable_state
= bp_disabled
;
4342 check_duplicates (b
);
4347 create_overlay_event_breakpoint (char *func_name
)
4349 struct breakpoint
*b
;
4350 struct minimal_symbol
*m
;
4352 if ((m
= lookup_minimal_symbol_text (func_name
, NULL
)) == NULL
)
4355 b
= create_internal_breakpoint (SYMBOL_VALUE_ADDRESS (m
),
4357 b
->addr_string
= xstrdup (func_name
);
4359 if (overlay_debugging
== ovly_auto
)
4361 b
->enable_state
= bp_enabled
;
4362 overlay_events_enabled
= 1;
4366 b
->enable_state
= bp_disabled
;
4367 overlay_events_enabled
= 0;
4372 enable_overlay_breakpoints (void)
4374 struct breakpoint
*b
;
4377 if (b
->type
== bp_overlay_event
)
4379 b
->enable_state
= bp_enabled
;
4380 check_duplicates (b
);
4381 overlay_events_enabled
= 1;
4386 disable_overlay_breakpoints (void)
4388 struct breakpoint
*b
;
4391 if (b
->type
== bp_overlay_event
)
4393 b
->enable_state
= bp_disabled
;
4394 check_duplicates (b
);
4395 overlay_events_enabled
= 0;
4400 create_thread_event_breakpoint (CORE_ADDR address
)
4402 struct breakpoint
*b
;
4404 b
= create_internal_breakpoint (address
, bp_thread_event
);
4406 b
->enable_state
= bp_enabled
;
4407 /* addr_string has to be used or breakpoint_re_set will delete me. */
4408 b
->addr_string
= xstrprintf ("*0x%s", paddr (b
->loc
->address
));
4414 remove_thread_event_breakpoints (void)
4416 struct breakpoint
*b
, *temp
;
4418 ALL_BREAKPOINTS_SAFE (b
, temp
)
4419 if (b
->type
== bp_thread_event
)
4420 delete_breakpoint (b
);
4423 struct captured_parse_breakpoint_args
4426 struct symtabs_and_lines
*sals_p
;
4427 char ***addr_string_p
;
4431 struct lang_and_radix
4437 /* Cleanup helper routine to restore the current language and
4440 do_restore_lang_radix_cleanup (void *old
)
4442 struct lang_and_radix
*p
= old
;
4443 set_language (p
->lang
);
4444 input_radix
= p
->radix
;
4447 /* Try and resolve a pending breakpoint. */
4449 resolve_pending_breakpoint (struct breakpoint
*b
)
4451 /* Try and reparse the breakpoint in case the shared library
4453 struct symtabs_and_lines sals
;
4454 struct symtab_and_line pending_sal
;
4455 char **cond_string
= (char **) NULL
;
4456 char *copy_arg
= b
->addr_string
;
4461 struct ui_file
*old_gdb_stderr
;
4462 struct lang_and_radix old_lr
;
4463 struct cleanup
*old_chain
;
4465 /* Set language, input-radix, then reissue breakpoint command.
4466 Ensure the language and input-radix are restored afterwards. */
4467 old_lr
.lang
= current_language
->la_language
;
4468 old_lr
.radix
= input_radix
;
4469 old_chain
= make_cleanup (do_restore_lang_radix_cleanup
, &old_lr
);
4471 set_language (b
->language
);
4472 input_radix
= b
->input_radix
;
4473 rc
= break_command_1 (b
->addr_string
, b
->flag
, b
->from_tty
, b
);
4475 if (rc
== GDB_RC_OK
)
4476 /* Pending breakpoint has been resolved. */
4477 printf_filtered (_("Pending breakpoint \"%s\" resolved\n"), b
->addr_string
);
4479 do_cleanups (old_chain
);
4484 remove_solib_event_breakpoints (void)
4486 struct breakpoint
*b
, *temp
;
4488 ALL_BREAKPOINTS_SAFE (b
, temp
)
4489 if (b
->type
== bp_shlib_event
)
4490 delete_breakpoint (b
);
4494 create_solib_event_breakpoint (CORE_ADDR address
)
4496 struct breakpoint
*b
;
4498 b
= create_internal_breakpoint (address
, bp_shlib_event
);
4502 /* Disable any breakpoints that are on code in shared libraries. Only
4503 apply to enabled breakpoints, disabled ones can just stay disabled. */
4506 disable_breakpoints_in_shlibs (int silent
)
4508 struct breakpoint
*b
;
4509 int disabled_shlib_breaks
= 0;
4511 /* See also: insert_breakpoints, under DISABLE_UNSETTABLE_BREAK. */
4514 if (((b
->type
== bp_breakpoint
) || (b
->type
== bp_hardware_breakpoint
))
4515 && breakpoint_enabled (b
) && !b
->loc
->duplicate
4517 && PC_SOLIB (b
->loc
->address
)
4519 && solib_address (b
->loc
->address
)
4523 b
->enable_state
= bp_shlib_disabled
;
4526 if (!disabled_shlib_breaks
)
4528 target_terminal_ours_for_output ();
4529 warning (_("Temporarily disabling shared library breakpoints:"));
4531 disabled_shlib_breaks
= 1;
4532 warning (_("breakpoint #%d "), b
->number
);
4538 /* Disable any breakpoints that are in in an unloaded shared library. Only
4539 apply to enabled breakpoints, disabled ones can just stay disabled. */
4542 disable_breakpoints_in_unloaded_shlib (struct so_list
*solib
)
4544 struct breakpoint
*b
;
4545 int disabled_shlib_breaks
= 0;
4547 /* See also: insert_breakpoints, under DISABLE_UNSETTABLE_BREAK. */
4550 if ((b
->loc
->loc_type
== bp_loc_hardware_breakpoint
4551 || b
->loc
->loc_type
== bp_loc_software_breakpoint
)
4552 && breakpoint_enabled (b
) && !b
->loc
->duplicate
)
4555 char *so_name
= PC_SOLIB (b
->loc
->address
);
4557 char *so_name
= solib_address (b
->loc
->address
);
4559 if (so_name
&& !strcmp (so_name
, solib
->so_name
))
4561 b
->enable_state
= bp_shlib_disabled
;
4562 /* At this point, we cannot rely on remove_breakpoint
4563 succeeding so we must mark the breakpoint as not inserted
4564 to prevent future errors occurring in remove_breakpoints. */
4565 b
->loc
->inserted
= 0;
4566 if (!disabled_shlib_breaks
)
4568 target_terminal_ours_for_output ();
4569 warning (_("Temporarily disabling breakpoints for unloaded shared library \"%s\""),
4572 disabled_shlib_breaks
= 1;
4578 /* Try to reenable any breakpoints in shared libraries. */
4580 re_enable_breakpoints_in_shlibs (void)
4582 struct breakpoint
*b
, *tmp
;
4584 ALL_BREAKPOINTS_SAFE (b
, tmp
)
4586 if (b
->enable_state
== bp_shlib_disabled
)
4591 /* Do not reenable the breakpoint if the shared library is
4592 still not mapped in. */
4594 lib
= PC_SOLIB (b
->loc
->address
);
4596 lib
= solib_address (b
->loc
->address
);
4598 if (lib
!= NULL
&& target_read_memory (b
->loc
->address
, buf
, 1) == 0)
4599 b
->enable_state
= bp_enabled
;
4601 else if (b
->pending
&& (b
->enable_state
== bp_enabled
))
4603 if (resolve_pending_breakpoint (b
) == GDB_RC_OK
)
4604 delete_breakpoint (b
);
4610 solib_load_unload_1 (char *hookname
, int tempflag
, char *dll_pathname
,
4611 char *cond_string
, enum bptype bp_kind
)
4613 struct breakpoint
*b
;
4614 struct symtabs_and_lines sals
;
4615 struct cleanup
*old_chain
;
4616 struct cleanup
*canonical_strings_chain
= NULL
;
4617 char *addr_start
= hookname
;
4618 char *addr_end
= NULL
;
4619 char **canonical
= (char **) NULL
;
4620 int thread
= -1; /* All threads. */
4622 /* Set a breakpoint on the specified hook. */
4623 sals
= decode_line_1 (&hookname
, 1, (struct symtab
*) NULL
,
4624 0, &canonical
, NULL
);
4625 addr_end
= hookname
;
4627 if (sals
.nelts
== 0)
4629 warning (_("Unable to set a breakpoint on dynamic linker callback.\n"
4630 "Suggest linking with /opt/langtools/lib/end.o.\n"
4631 "GDB will be unable to track shl_load/shl_unload calls."));
4634 if (sals
.nelts
!= 1)
4636 warning (_("Unable to set unique breakpoint on dynamic linker callback.\n"
4637 "GDB will be unable to track shl_load/shl_unload calls."));
4641 /* Make sure that all storage allocated in decode_line_1 gets freed
4642 in case the following errors out. */
4643 old_chain
= make_cleanup (xfree
, sals
.sals
);
4644 if (canonical
!= (char **) NULL
)
4646 make_cleanup (xfree
, canonical
);
4647 canonical_strings_chain
= make_cleanup (null_cleanup
, 0);
4648 if (canonical
[0] != NULL
)
4649 make_cleanup (xfree
, canonical
[0]);
4652 resolve_sal_pc (&sals
.sals
[0]);
4654 /* Remove the canonical strings from the cleanup, they are needed below. */
4655 if (canonical
!= (char **) NULL
)
4656 discard_cleanups (canonical_strings_chain
);
4658 b
= set_raw_breakpoint (sals
.sals
[0], bp_kind
);
4659 set_breakpoint_count (breakpoint_count
+ 1);
4660 b
->number
= breakpoint_count
;
4662 b
->cond_string
= (cond_string
== NULL
) ?
4663 NULL
: savestring (cond_string
, strlen (cond_string
));
4666 if (canonical
!= (char **) NULL
&& canonical
[0] != NULL
)
4667 b
->addr_string
= canonical
[0];
4668 else if (addr_start
)
4669 b
->addr_string
= savestring (addr_start
, addr_end
- addr_start
);
4671 b
->enable_state
= bp_enabled
;
4672 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
4674 if (dll_pathname
== NULL
)
4675 b
->dll_pathname
= NULL
;
4678 b
->dll_pathname
= (char *) xmalloc (strlen (dll_pathname
) + 1);
4679 strcpy (b
->dll_pathname
, dll_pathname
);
4683 do_cleanups (old_chain
);
4687 create_solib_load_event_breakpoint (char *hookname
, int tempflag
,
4688 char *dll_pathname
, char *cond_string
)
4690 solib_load_unload_1 (hookname
, tempflag
, dll_pathname
,
4691 cond_string
, bp_catch_load
);
4695 create_solib_unload_event_breakpoint (char *hookname
, int tempflag
,
4696 char *dll_pathname
, char *cond_string
)
4698 solib_load_unload_1 (hookname
, tempflag
, dll_pathname
,
4699 cond_string
, bp_catch_unload
);
4703 create_fork_vfork_event_catchpoint (int tempflag
, char *cond_string
,
4704 enum bptype bp_kind
)
4706 struct symtab_and_line sal
;
4707 struct breakpoint
*b
;
4708 int thread
= -1; /* All threads. */
4715 b
= set_raw_breakpoint (sal
, bp_kind
);
4716 set_breakpoint_count (breakpoint_count
+ 1);
4717 b
->number
= breakpoint_count
;
4719 b
->cond_string
= (cond_string
== NULL
) ?
4720 NULL
: savestring (cond_string
, strlen (cond_string
));
4722 b
->addr_string
= NULL
;
4723 b
->enable_state
= bp_enabled
;
4724 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
4725 b
->forked_inferior_pid
= 0;
4731 create_fork_event_catchpoint (int tempflag
, char *cond_string
)
4733 create_fork_vfork_event_catchpoint (tempflag
, cond_string
, bp_catch_fork
);
4737 create_vfork_event_catchpoint (int tempflag
, char *cond_string
)
4739 create_fork_vfork_event_catchpoint (tempflag
, cond_string
, bp_catch_vfork
);
4743 create_exec_event_catchpoint (int tempflag
, char *cond_string
)
4745 struct symtab_and_line sal
;
4746 struct breakpoint
*b
;
4747 int thread
= -1; /* All threads. */
4754 b
= set_raw_breakpoint (sal
, bp_catch_exec
);
4755 set_breakpoint_count (breakpoint_count
+ 1);
4756 b
->number
= breakpoint_count
;
4758 b
->cond_string
= (cond_string
== NULL
) ?
4759 NULL
: savestring (cond_string
, strlen (cond_string
));
4761 b
->addr_string
= NULL
;
4762 b
->enable_state
= bp_enabled
;
4763 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
4769 hw_breakpoint_used_count (void)
4771 struct breakpoint
*b
;
4776 if (b
->type
== bp_hardware_breakpoint
&& b
->enable_state
== bp_enabled
)
4784 hw_watchpoint_used_count (enum bptype type
, int *other_type_used
)
4786 struct breakpoint
*b
;
4789 *other_type_used
= 0;
4792 if (breakpoint_enabled (b
))
4794 if (b
->type
== type
)
4796 else if ((b
->type
== bp_hardware_watchpoint
||
4797 b
->type
== bp_read_watchpoint
||
4798 b
->type
== bp_access_watchpoint
))
4799 *other_type_used
= 1;
4805 /* Call this after hitting the longjmp() breakpoint. Use this to set
4806 a new breakpoint at the target of the jmp_buf.
4808 FIXME - This ought to be done by setting a temporary breakpoint
4809 that gets deleted automatically... */
4812 set_longjmp_resume_breakpoint (CORE_ADDR pc
, struct frame_id frame_id
)
4814 struct breakpoint
*b
;
4817 if (b
->type
== bp_longjmp_resume
)
4819 b
->loc
->requested_address
= pc
;
4820 b
->loc
->address
= adjust_breakpoint_address (b
->loc
->requested_address
,
4822 b
->enable_state
= bp_enabled
;
4823 b
->frame_id
= frame_id
;
4824 check_duplicates (b
);
4830 disable_watchpoints_before_interactive_call_start (void)
4832 struct breakpoint
*b
;
4836 if (((b
->type
== bp_watchpoint
)
4837 || (b
->type
== bp_hardware_watchpoint
)
4838 || (b
->type
== bp_read_watchpoint
)
4839 || (b
->type
== bp_access_watchpoint
)
4840 || ep_is_exception_catchpoint (b
))
4841 && breakpoint_enabled (b
))
4843 b
->enable_state
= bp_call_disabled
;
4844 check_duplicates (b
);
4850 enable_watchpoints_after_interactive_call_stop (void)
4852 struct breakpoint
*b
;
4856 if (((b
->type
== bp_watchpoint
)
4857 || (b
->type
== bp_hardware_watchpoint
)
4858 || (b
->type
== bp_read_watchpoint
)
4859 || (b
->type
== bp_access_watchpoint
)
4860 || ep_is_exception_catchpoint (b
))
4861 && (b
->enable_state
== bp_call_disabled
))
4863 b
->enable_state
= bp_enabled
;
4864 check_duplicates (b
);
4870 /* Set a breakpoint that will evaporate an end of command
4871 at address specified by SAL.
4872 Restrict it to frame FRAME if FRAME is nonzero. */
4875 set_momentary_breakpoint (struct symtab_and_line sal
, struct frame_id frame_id
,
4878 struct breakpoint
*b
;
4879 b
= set_raw_breakpoint (sal
, type
);
4880 b
->enable_state
= bp_enabled
;
4881 b
->disposition
= disp_donttouch
;
4882 b
->frame_id
= frame_id
;
4884 /* If we're debugging a multi-threaded program, then we
4885 want momentary breakpoints to be active in only a
4886 single thread of control. */
4887 if (in_thread_list (inferior_ptid
))
4888 b
->thread
= pid_to_thread_id (inferior_ptid
);
4894 /* Tell the user we have just set a breakpoint B. */
4897 mention (struct breakpoint
*b
)
4900 struct cleanup
*old_chain
, *ui_out_chain
;
4901 struct ui_stream
*stb
;
4903 stb
= ui_out_stream_new (uiout
);
4904 old_chain
= make_cleanup_ui_out_stream_delete (stb
);
4906 /* FIXME: This is misplaced; mention() is called by things (like
4907 hitting a watchpoint) other than breakpoint creation. It should
4908 be possible to clean this up and at the same time replace the
4909 random calls to breakpoint_changed with this hook, as has already
4910 been done for deprecated_delete_breakpoint_hook and so on. */
4911 if (deprecated_create_breakpoint_hook
)
4912 deprecated_create_breakpoint_hook (b
);
4913 breakpoint_create_event (b
->number
);
4915 if (b
->ops
!= NULL
&& b
->ops
->print_mention
!= NULL
)
4916 b
->ops
->print_mention (b
);
4921 printf_filtered (_("(apparently deleted?) Eventpoint %d: "), b
->number
);
4924 ui_out_text (uiout
, "Watchpoint ");
4925 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "wpt");
4926 ui_out_field_int (uiout
, "number", b
->number
);
4927 ui_out_text (uiout
, ": ");
4928 print_expression (b
->exp
, stb
->stream
);
4929 ui_out_field_stream (uiout
, "exp", stb
);
4930 do_cleanups (ui_out_chain
);
4932 case bp_hardware_watchpoint
:
4933 ui_out_text (uiout
, "Hardware watchpoint ");
4934 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "wpt");
4935 ui_out_field_int (uiout
, "number", b
->number
);
4936 ui_out_text (uiout
, ": ");
4937 print_expression (b
->exp
, stb
->stream
);
4938 ui_out_field_stream (uiout
, "exp", stb
);
4939 do_cleanups (ui_out_chain
);
4941 case bp_read_watchpoint
:
4942 ui_out_text (uiout
, "Hardware read watchpoint ");
4943 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "hw-rwpt");
4944 ui_out_field_int (uiout
, "number", b
->number
);
4945 ui_out_text (uiout
, ": ");
4946 print_expression (b
->exp
, stb
->stream
);
4947 ui_out_field_stream (uiout
, "exp", stb
);
4948 do_cleanups (ui_out_chain
);
4950 case bp_access_watchpoint
:
4951 ui_out_text (uiout
, "Hardware access (read/write) watchpoint ");
4952 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "hw-awpt");
4953 ui_out_field_int (uiout
, "number", b
->number
);
4954 ui_out_text (uiout
, ": ");
4955 print_expression (b
->exp
, stb
->stream
);
4956 ui_out_field_stream (uiout
, "exp", stb
);
4957 do_cleanups (ui_out_chain
);
4960 if (ui_out_is_mi_like_p (uiout
))
4965 printf_filtered (_("Breakpoint %d"), b
->number
);
4968 case bp_hardware_breakpoint
:
4969 if (ui_out_is_mi_like_p (uiout
))
4974 printf_filtered (_("Hardware assisted breakpoint %d"), b
->number
);
4978 case bp_catch_unload
:
4979 printf_filtered (_("Catchpoint %d (%s %s)"),
4981 (b
->type
== bp_catch_load
) ? "load" : "unload",
4982 (b
->dll_pathname
!= NULL
) ?
4983 b
->dll_pathname
: "<any library>");
4986 case bp_catch_vfork
:
4987 printf_filtered (_("Catchpoint %d (%s)"),
4989 (b
->type
== bp_catch_fork
) ? "fork" : "vfork");
4992 printf_filtered (_("Catchpoint %d (exec)"),
4995 case bp_catch_catch
:
4996 case bp_catch_throw
:
4997 printf_filtered (_("Catchpoint %d (%s)"),
4999 (b
->type
== bp_catch_catch
) ? "catch" : "throw");
5005 case bp_longjmp_resume
:
5006 case bp_step_resume
:
5007 case bp_through_sigtramp
:
5009 case bp_watchpoint_scope
:
5010 case bp_shlib_event
:
5011 case bp_thread_event
:
5012 case bp_overlay_event
:
5018 /* i18n: cagney/2005-02-11: Below needs to be merged into a
5022 printf_filtered (_(" (%s) pending."), b
->addr_string
);
5026 if (addressprint
|| b
->source_file
== NULL
)
5028 printf_filtered (" at ");
5029 deprecated_print_address_numeric (b
->loc
->address
, 1, gdb_stdout
);
5032 printf_filtered (": file %s, line %d.",
5033 b
->source_file
, b
->line_number
);
5036 do_cleanups (old_chain
);
5037 if (ui_out_is_mi_like_p (uiout
))
5039 printf_filtered ("\n");
5043 /* Add SALS.nelts breakpoints to the breakpoint table. For each
5044 SALS.sal[i] breakpoint, include the corresponding ADDR_STRING[i],
5045 COND[i] and COND_STRING[i] values.
5047 The parameter PENDING_BP points to a pending breakpoint that is
5048 the basis of the breakpoints currently being created. The pending
5049 breakpoint may contain a separate condition string or commands
5050 that were added after the initial pending breakpoint was created.
5052 NOTE: If the function succeeds, the caller is expected to cleanup
5053 the arrays ADDR_STRING, COND_STRING, COND and SALS (but not the
5054 array contents). If the function fails (error() is called), the
5055 caller is expected to cleanups both the ADDR_STRING, COND_STRING,
5056 COND and SALS arrays and each of those arrays contents. */
5059 create_breakpoints (struct symtabs_and_lines sals
, char **addr_string
,
5060 struct expression
**cond
, char **cond_string
,
5061 enum bptype type
, enum bpdisp disposition
,
5062 int thread
, int ignore_count
, int from_tty
,
5063 struct breakpoint
*pending_bp
)
5065 if (type
== bp_hardware_breakpoint
)
5067 int i
= hw_breakpoint_used_count ();
5068 int target_resources_ok
=
5069 TARGET_CAN_USE_HARDWARE_WATCHPOINT (bp_hardware_breakpoint
,
5071 if (target_resources_ok
== 0)
5072 error (_("No hardware breakpoint support in the target."));
5073 else if (target_resources_ok
< 0)
5074 error (_("Hardware breakpoints used exceeds limit."));
5077 /* Now set all the breakpoints. */
5080 for (i
= 0; i
< sals
.nelts
; i
++)
5082 struct breakpoint
*b
;
5083 struct symtab_and_line sal
= sals
.sals
[i
];
5086 describe_other_breakpoints (sal
.pc
, sal
.section
, thread
);
5088 b
= set_raw_breakpoint (sal
, type
);
5089 set_breakpoint_count (breakpoint_count
+ 1);
5090 b
->number
= breakpoint_count
;
5094 b
->addr_string
= addr_string
[i
];
5096 /* addr_string has to be used or breakpoint_re_set will delete
5098 b
->addr_string
= xstrprintf ("*0x%s", paddr (b
->loc
->address
));
5099 b
->cond_string
= cond_string
[i
];
5100 b
->ignore_count
= ignore_count
;
5101 b
->enable_state
= bp_enabled
;
5102 b
->disposition
= disposition
;
5103 /* If resolving a pending breakpoint, a check must be made to see if
5104 the user has specified a new condition or commands for the
5105 breakpoint. A new condition will override any condition that was
5106 initially specified with the initial breakpoint command. */
5110 if (pending_bp
->cond_string
)
5112 arg
= pending_bp
->cond_string
;
5113 b
->cond_string
= savestring (arg
, strlen (arg
));
5114 b
->cond
= parse_exp_1 (&arg
, block_for_pc (b
->loc
->address
), 0);
5116 error (_("Junk at end of pending breakpoint condition expression"));
5118 /* If there are commands associated with the breakpoint, they should
5120 if (pending_bp
->commands
)
5121 b
->commands
= copy_command_lines (pending_bp
->commands
);
5123 /* We have to copy over the ignore_count and thread as well. */
5124 b
->ignore_count
= pending_bp
->ignore_count
;
5125 b
->thread
= pending_bp
->thread
;
5132 /* Parse ARG which is assumed to be a SAL specification possibly
5133 followed by conditionals. On return, SALS contains an array of SAL
5134 addresses found. ADDR_STRING contains a vector of (canonical)
5135 address strings. ARG points to the end of the SAL. */
5138 parse_breakpoint_sals (char **address
,
5139 struct symtabs_and_lines
*sals
,
5140 char ***addr_string
,
5143 char *addr_start
= *address
;
5144 *addr_string
= NULL
;
5145 /* If no arg given, or if first arg is 'if ', use the default
5147 if ((*address
) == NULL
5148 || (strncmp ((*address
), "if", 2) == 0 && isspace ((*address
)[2])))
5150 if (default_breakpoint_valid
)
5152 struct symtab_and_line sal
;
5153 init_sal (&sal
); /* initialize to zeroes */
5154 sals
->sals
= (struct symtab_and_line
*)
5155 xmalloc (sizeof (struct symtab_and_line
));
5156 sal
.pc
= default_breakpoint_address
;
5157 sal
.line
= default_breakpoint_line
;
5158 sal
.symtab
= default_breakpoint_symtab
;
5159 sal
.section
= find_pc_overlay (sal
.pc
);
5160 sals
->sals
[0] = sal
;
5164 error (_("No default breakpoint address now."));
5168 /* Force almost all breakpoints to be in terms of the
5169 current_source_symtab (which is decode_line_1's default). This
5170 should produce the results we want almost all of the time while
5171 leaving default_breakpoint_* alone.
5172 ObjC: However, don't match an Objective-C method name which
5173 may have a '+' or '-' succeeded by a '[' */
5175 struct symtab_and_line cursal
= get_current_source_symtab_and_line ();
5177 if (default_breakpoint_valid
5179 || ((strchr ("+-", (*address
)[0]) != NULL
)
5180 && ((*address
)[1] != '['))))
5181 *sals
= decode_line_1 (address
, 1, default_breakpoint_symtab
,
5182 default_breakpoint_line
, addr_string
,
5185 *sals
= decode_line_1 (address
, 1, (struct symtab
*) NULL
, 0,
5186 addr_string
, not_found_ptr
);
5188 /* For any SAL that didn't have a canonical string, fill one in. */
5189 if (sals
->nelts
> 0 && *addr_string
== NULL
)
5190 *addr_string
= xcalloc (sals
->nelts
, sizeof (char **));
5191 if (addr_start
!= (*address
))
5194 for (i
= 0; i
< sals
->nelts
; i
++)
5196 /* Add the string if not present. */
5197 if ((*addr_string
)[i
] == NULL
)
5198 (*addr_string
)[i
] = savestring (addr_start
, (*address
) - addr_start
);
5204 /* Convert each SAL into a real PC. Verify that the PC can be
5205 inserted as a breakpoint. If it can't throw an error. */
5208 breakpoint_sals_to_pc (struct symtabs_and_lines
*sals
,
5212 for (i
= 0; i
< sals
->nelts
; i
++)
5214 resolve_sal_pc (&sals
->sals
[i
]);
5216 /* It's possible for the PC to be nonzero, but still an illegal
5217 value on some targets.
5219 For example, on HP-UX if you start gdb, and before running the
5220 inferior you try to set a breakpoint on a shared library function
5221 "foo" where the inferior doesn't call "foo" directly but does
5222 pass its address to another function call, then we do find a
5223 minimal symbol for the "foo", but it's address is invalid.
5224 (Appears to be an index into a table that the loader sets up
5225 when the inferior is run.)
5227 Give the target a chance to bless sals.sals[i].pc before we
5228 try to make a breakpoint for it. */
5229 #ifdef DEPRECATED_PC_REQUIRES_RUN_BEFORE_USE
5230 if (DEPRECATED_PC_REQUIRES_RUN_BEFORE_USE (sals
->sals
[i
].pc
))
5232 if (address
== NULL
)
5233 error (_("Cannot break without a running program."));
5235 error (_("Cannot break on %s without a running program."),
5243 do_captured_parse_breakpoint (struct ui_out
*ui
, void *data
)
5245 struct captured_parse_breakpoint_args
*args
= data
;
5247 parse_breakpoint_sals (args
->arg_p
, args
->sals_p
, args
->addr_string_p
,
5248 args
->not_found_ptr
);
5251 /* Set a breakpoint according to ARG (function, linenum or *address)
5252 flag: first bit : 0 non-temporary, 1 temporary.
5253 second bit : 0 normal breakpoint, 1 hardware breakpoint.
5255 PENDING_BP is non-NULL when this function is being called to resolve
5256 a pending breakpoint. */
5259 break_command_1 (char *arg
, int flag
, int from_tty
, struct breakpoint
*pending_bp
)
5261 struct gdb_exception e
;
5262 int tempflag
, hardwareflag
;
5263 struct symtabs_and_lines sals
;
5264 struct expression
**cond
= 0;
5265 struct symtab_and_line pending_sal
;
5266 char **cond_string
= (char **) NULL
;
5269 char *addr_start
= arg
;
5271 struct cleanup
*old_chain
;
5272 struct cleanup
*breakpoint_chain
= NULL
;
5273 struct captured_parse_breakpoint_args parse_args
;
5277 int ignore_count
= 0;
5280 hardwareflag
= flag
& BP_HARDWAREFLAG
;
5281 tempflag
= flag
& BP_TEMPFLAG
;
5287 parse_args
.arg_p
= &arg
;
5288 parse_args
.sals_p
= &sals
;
5289 parse_args
.addr_string_p
= &addr_string
;
5290 parse_args
.not_found_ptr
= ¬_found
;
5292 e
= catch_exception (uiout
, do_captured_parse_breakpoint
,
5293 &parse_args
, RETURN_MASK_ALL
);
5295 /* If caller is interested in rc value from parse, set value. */
5299 exception_print (gdb_stderr
, e
);
5304 case NOT_FOUND_ERROR
:
5305 /* If called to resolve pending breakpoint, just return
5310 exception_print (gdb_stderr
, e
);
5312 /* If pending breakpoint support is turned off, throw
5315 if (pending_break_support
== AUTO_BOOLEAN_FALSE
)
5316 deprecated_throw_reason (RETURN_ERROR
);
5318 /* If pending breakpoint support is auto query and the user
5319 selects no, then simply return the error code. */
5320 if (pending_break_support
== AUTO_BOOLEAN_AUTO
&&
5321 !nquery ("Make breakpoint pending on future shared library load? "))
5324 /* At this point, either the user was queried about setting
5325 a pending breakpoint and selected yes, or pending
5326 breakpoint behavior is on and thus a pending breakpoint
5327 is defaulted on behalf of the user. */
5328 copy_arg
= xstrdup (addr_start
);
5329 addr_string
= ©_arg
;
5331 sals
.sals
= &pending_sal
;
5336 exception_print (gdb_stderr
, e
);
5344 /* Create a chain of things that always need to be cleaned up. */
5345 old_chain
= make_cleanup (null_cleanup
, 0);
5349 /* Make sure that all storage allocated to SALS gets freed. */
5350 make_cleanup (xfree
, sals
.sals
);
5352 /* Cleanup the addr_string array but not its contents. */
5353 make_cleanup (xfree
, addr_string
);
5356 /* Allocate space for all the cond expressions. */
5357 cond
= xcalloc (sals
.nelts
, sizeof (struct expression
*));
5358 make_cleanup (xfree
, cond
);
5360 /* Allocate space for all the cond strings. */
5361 cond_string
= xcalloc (sals
.nelts
, sizeof (char **));
5362 make_cleanup (xfree
, cond_string
);
5364 /* ----------------------------- SNIP -----------------------------
5365 Anything added to the cleanup chain beyond this point is assumed
5366 to be part of a breakpoint. If the breakpoint create succeeds
5367 then the memory is not reclaimed. */
5368 breakpoint_chain
= make_cleanup (null_cleanup
, 0);
5370 /* Mark the contents of the addr_string for cleanup. These go on
5371 the breakpoint_chain and only occure if the breakpoint create
5373 for (i
= 0; i
< sals
.nelts
; i
++)
5375 if (addr_string
[i
] != NULL
)
5376 make_cleanup (xfree
, addr_string
[i
]);
5379 /* Resolve all line numbers to PC's and verify that the addresses
5380 are ok for the target. */
5382 breakpoint_sals_to_pc (&sals
, addr_start
);
5384 /* Verify that condition can be parsed, before setting any
5385 breakpoints. Allocate a separate condition expression for each
5387 thread
= -1; /* No specific thread yet */
5390 for (i
= 0; i
< sals
.nelts
; i
++)
5397 char *cond_start
= NULL
;
5398 char *cond_end
= NULL
;
5399 while (*tok
== ' ' || *tok
== '\t')
5404 while (*end_tok
!= ' ' && *end_tok
!= '\t' && *end_tok
!= '\000')
5407 toklen
= end_tok
- tok
;
5409 if (toklen
>= 1 && strncmp (tok
, "if", toklen
) == 0)
5411 tok
= cond_start
= end_tok
+ 1;
5412 cond
[i
] = parse_exp_1 (&tok
, block_for_pc (sals
.sals
[i
].pc
),
5414 make_cleanup (xfree
, cond
[i
]);
5416 cond_string
[i
] = savestring (cond_start
,
5417 cond_end
- cond_start
);
5418 make_cleanup (xfree
, cond_string
[i
]);
5420 else if (toklen
>= 1 && strncmp (tok
, "thread", toklen
) == 0)
5426 thread
= strtol (tok
, &tok
, 0);
5428 error (_("Junk after thread keyword."));
5429 if (!valid_thread_id (thread
))
5430 error (_("Unknown thread %d."), thread
);
5433 error (_("Junk at end of arguments."));
5436 create_breakpoints (sals
, addr_string
, cond
, cond_string
,
5437 hardwareflag
? bp_hardware_breakpoint
5439 tempflag
? disp_del
: disp_donttouch
,
5440 thread
, ignore_count
, from_tty
,
5445 struct symtab_and_line sal
;
5446 struct breakpoint
*b
;
5451 make_cleanup (xfree
, copy_arg
);
5453 b
= set_raw_breakpoint (sal
, hardwareflag
? bp_hardware_breakpoint
5455 set_breakpoint_count (breakpoint_count
+ 1);
5456 b
->number
= breakpoint_count
;
5459 b
->addr_string
= *addr_string
;
5460 b
->cond_string
= *cond_string
;
5461 b
->ignore_count
= ignore_count
;
5463 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
5464 b
->from_tty
= from_tty
;
5470 warning (_("Multiple breakpoints were set.\n"
5471 "Use the \"delete\" command to delete unwanted breakpoints."));
5472 /* That's it. Discard the cleanups for data inserted into the
5474 discard_cleanups (breakpoint_chain
);
5475 /* But cleanup everything else. */
5476 do_cleanups (old_chain
);
5481 /* Set a breakpoint of TYPE/DISPOSITION according to ARG (function,
5482 linenum or *address) with COND and IGNORE_COUNT. */
5484 struct captured_breakpoint_args
5495 do_captured_breakpoint (struct ui_out
*uiout
, void *data
)
5497 struct captured_breakpoint_args
*args
= data
;
5498 struct symtabs_and_lines sals
;
5499 struct expression
**cond
;
5500 struct cleanup
*old_chain
;
5501 struct cleanup
*breakpoint_chain
= NULL
;
5508 /* Parse the source and lines spec. Delay check that the expression
5509 didn't contain trailing garbage until after cleanups are in
5513 address_end
= args
->address
;
5515 parse_breakpoint_sals (&address_end
, &sals
, &addr_string
, 0);
5520 /* Create a chain of things at always need to be cleaned up. */
5521 old_chain
= make_cleanup (null_cleanup
, 0);
5523 /* Always have a addr_string array, even if it is empty. */
5524 make_cleanup (xfree
, addr_string
);
5526 /* Make sure that all storage allocated to SALS gets freed. */
5527 make_cleanup (xfree
, sals
.sals
);
5529 /* Allocate space for all the cond expressions. */
5530 cond
= xcalloc (sals
.nelts
, sizeof (struct expression
*));
5531 make_cleanup (xfree
, cond
);
5533 /* Allocate space for all the cond strings. */
5534 cond_string
= xcalloc (sals
.nelts
, sizeof (char **));
5535 make_cleanup (xfree
, cond_string
);
5537 /* ----------------------------- SNIP -----------------------------
5538 Anything added to the cleanup chain beyond this point is assumed
5539 to be part of a breakpoint. If the breakpoint create goes
5540 through then that memory is not cleaned up. */
5541 breakpoint_chain
= make_cleanup (null_cleanup
, 0);
5543 /* Mark the contents of the addr_string for cleanup. These go on
5544 the breakpoint_chain and only occure if the breakpoint create
5546 for (i
= 0; i
< sals
.nelts
; i
++)
5548 if (addr_string
[i
] != NULL
)
5549 make_cleanup (xfree
, addr_string
[i
]);
5552 /* Wait until now before checking for garbage at the end of the
5553 address. That way cleanups can take care of freeing any
5555 if (*address_end
!= '\0')
5556 error (_("Garbage %s following breakpoint address"), address_end
);
5558 /* Resolve all line numbers to PC's. */
5559 breakpoint_sals_to_pc (&sals
, args
->address
);
5561 /* Verify that conditions can be parsed, before setting any
5563 for (i
= 0; i
< sals
.nelts
; i
++)
5565 if (args
->condition
!= NULL
)
5567 char *tok
= args
->condition
;
5568 cond
[i
] = parse_exp_1 (&tok
, block_for_pc (sals
.sals
[i
].pc
), 0);
5570 error (_("Garbage %s follows condition"), tok
);
5571 make_cleanup (xfree
, cond
[i
]);
5572 cond_string
[i
] = xstrdup (args
->condition
);
5576 create_breakpoints (sals
, addr_string
, cond
, cond_string
,
5577 args
->hardwareflag
? bp_hardware_breakpoint
: bp_breakpoint
,
5578 args
->tempflag
? disp_del
: disp_donttouch
,
5579 args
->thread
, args
->ignore_count
, 0/*from-tty*/,
5580 NULL
/*pending_bp*/);
5582 /* That's it. Discard the cleanups for data inserted into the
5584 discard_cleanups (breakpoint_chain
);
5585 /* But cleanup everything else. */
5586 do_cleanups (old_chain
);
5591 gdb_breakpoint (char *address
, char *condition
,
5592 int hardwareflag
, int tempflag
,
5593 int thread
, int ignore_count
,
5594 char **error_message
)
5596 struct captured_breakpoint_args args
;
5597 args
.address
= address
;
5598 args
.condition
= condition
;
5599 args
.hardwareflag
= hardwareflag
;
5600 args
.tempflag
= tempflag
;
5601 args
.thread
= thread
;
5602 args
.ignore_count
= ignore_count
;
5603 return catch_exceptions_with_msg (uiout
, do_captured_breakpoint
, &args
,
5604 error_message
, RETURN_MASK_ALL
);
5608 /* Helper function for break_command_1 and disassemble_command. */
5611 resolve_sal_pc (struct symtab_and_line
*sal
)
5615 if (sal
->pc
== 0 && sal
->symtab
!= NULL
)
5617 if (!find_line_pc (sal
->symtab
, sal
->line
, &pc
))
5618 error (_("No line %d in file \"%s\"."),
5619 sal
->line
, sal
->symtab
->filename
);
5623 if (sal
->section
== 0 && sal
->symtab
!= NULL
)
5625 struct blockvector
*bv
;
5630 bv
= blockvector_for_pc_sect (sal
->pc
, 0, &index
, sal
->symtab
);
5633 b
= BLOCKVECTOR_BLOCK (bv
, index
);
5634 sym
= block_function (b
);
5637 fixup_symbol_section (sym
, sal
->symtab
->objfile
);
5638 sal
->section
= SYMBOL_BFD_SECTION (sym
);
5642 /* It really is worthwhile to have the section, so we'll just
5643 have to look harder. This case can be executed if we have
5644 line numbers but no functions (as can happen in assembly
5647 struct minimal_symbol
*msym
;
5649 msym
= lookup_minimal_symbol_by_pc (sal
->pc
);
5651 sal
->section
= SYMBOL_BFD_SECTION (msym
);
5658 break_command (char *arg
, int from_tty
)
5660 break_command_1 (arg
, 0, from_tty
, NULL
);
5664 tbreak_command (char *arg
, int from_tty
)
5666 break_command_1 (arg
, BP_TEMPFLAG
, from_tty
, NULL
);
5670 hbreak_command (char *arg
, int from_tty
)
5672 break_command_1 (arg
, BP_HARDWAREFLAG
, from_tty
, NULL
);
5676 thbreak_command (char *arg
, int from_tty
)
5678 break_command_1 (arg
, (BP_TEMPFLAG
| BP_HARDWAREFLAG
), from_tty
, NULL
);
5682 stop_command (char *arg
, int from_tty
)
5684 printf_filtered (_("Specify the type of breakpoint to set.\n\
5685 Usage: stop in <function | address>\n\
5686 stop at <line>\n"));
5690 stopin_command (char *arg
, int from_tty
)
5694 if (arg
== (char *) NULL
)
5696 else if (*arg
!= '*')
5701 /* look for a ':'. If this is a line number specification, then
5702 say it is bad, otherwise, it should be an address or
5703 function/method name */
5704 while (*argptr
&& !hasColon
)
5706 hasColon
= (*argptr
== ':');
5711 badInput
= (*argptr
!= ':'); /* Not a class::method */
5713 badInput
= isdigit (*arg
); /* a simple line number */
5717 printf_filtered (_("Usage: stop in <function | address>\n"));
5719 break_command_1 (arg
, 0, from_tty
, NULL
);
5723 stopat_command (char *arg
, int from_tty
)
5727 if (arg
== (char *) NULL
|| *arg
== '*') /* no line number */
5734 /* look for a ':'. If there is a '::' then get out, otherwise
5735 it is probably a line number. */
5736 while (*argptr
&& !hasColon
)
5738 hasColon
= (*argptr
== ':');
5743 badInput
= (*argptr
== ':'); /* we have class::method */
5745 badInput
= !isdigit (*arg
); /* not a line number */
5749 printf_filtered (_("Usage: stop at <line>\n"));
5751 break_command_1 (arg
, 0, from_tty
, NULL
);
5754 /* accessflag: hw_write: watch write,
5755 hw_read: watch read,
5756 hw_access: watch access (read or write) */
5758 watch_command_1 (char *arg
, int accessflag
, int from_tty
)
5760 struct breakpoint
*b
;
5761 struct symtab_and_line sal
;
5762 struct expression
*exp
;
5763 struct block
*exp_valid_block
;
5764 struct value
*val
, *mark
;
5765 struct frame_info
*frame
;
5766 struct frame_info
*prev_frame
= NULL
;
5767 char *exp_start
= NULL
;
5768 char *exp_end
= NULL
;
5769 char *tok
, *end_tok
;
5771 char *cond_start
= NULL
;
5772 char *cond_end
= NULL
;
5773 struct expression
*cond
= NULL
;
5774 int i
, other_type_used
, target_resources_ok
= 0;
5775 enum bptype bp_type
;
5778 init_sal (&sal
); /* initialize to zeroes */
5780 /* Parse arguments. */
5781 innermost_block
= NULL
;
5783 exp
= parse_exp_1 (&arg
, 0, 0);
5785 exp_valid_block
= innermost_block
;
5786 mark
= value_mark ();
5787 val
= evaluate_expression (exp
);
5788 release_value (val
);
5789 if (value_lazy (val
))
5790 value_fetch_lazy (val
);
5793 while (*tok
== ' ' || *tok
== '\t')
5797 while (*end_tok
!= ' ' && *end_tok
!= '\t' && *end_tok
!= '\000')
5800 toklen
= end_tok
- tok
;
5801 if (toklen
>= 1 && strncmp (tok
, "if", toklen
) == 0)
5803 tok
= cond_start
= end_tok
+ 1;
5804 cond
= parse_exp_1 (&tok
, 0, 0);
5808 error (_("Junk at end of command."));
5810 if (accessflag
== hw_read
)
5811 bp_type
= bp_read_watchpoint
;
5812 else if (accessflag
== hw_access
)
5813 bp_type
= bp_access_watchpoint
;
5815 bp_type
= bp_hardware_watchpoint
;
5817 mem_cnt
= can_use_hardware_watchpoint (val
);
5818 if (mem_cnt
== 0 && bp_type
!= bp_hardware_watchpoint
)
5819 error (_("Expression cannot be implemented with read/access watchpoint."));
5822 i
= hw_watchpoint_used_count (bp_type
, &other_type_used
);
5823 target_resources_ok
=
5824 TARGET_CAN_USE_HARDWARE_WATCHPOINT (bp_type
, i
+ mem_cnt
,
5826 if (target_resources_ok
== 0 && bp_type
!= bp_hardware_watchpoint
)
5827 error (_("Target does not support this type of hardware watchpoint."));
5829 if (target_resources_ok
< 0 && bp_type
!= bp_hardware_watchpoint
)
5830 error (_("Target can only support one kind of HW watchpoint at a time."));
5833 #if defined(HPUXHPPA)
5834 /* On HP-UX if you set a h/w
5835 watchpoint before the "run" command, the inferior dies with a e.g.,
5836 SIGILL once you start it. I initially believed this was due to a
5837 bad interaction between page protection traps and the initial
5838 startup sequence by the dynamic linker.
5840 However, I tried avoiding that by having HP-UX's implementation of
5841 TARGET_CAN_USE_HW_WATCHPOINT return FALSE if there was no inferior_ptid
5842 yet, which forced slow watches before a "run" or "attach", and it
5843 still fails somewhere in the startup code.
5845 Until I figure out what's happening, I'm disallowing watches altogether
5846 before the "run" or "attach" command. We'll tell the user they must
5847 set watches after getting the program started. */
5848 if (!target_has_execution
)
5850 warning (_("can't do that without a running program; try \"break main\"), \"run\" first");
5853 #endif /* HPUXHPPA */
5855 /* Change the type of breakpoint to an ordinary watchpoint if a hardware
5856 watchpoint could not be set. */
5857 if (!mem_cnt
|| target_resources_ok
<= 0)
5858 bp_type
= bp_watchpoint
;
5860 /* Now set up the breakpoint. */
5861 b
= set_raw_breakpoint (sal
, bp_type
);
5862 set_breakpoint_count (breakpoint_count
+ 1);
5863 b
->number
= breakpoint_count
;
5864 b
->disposition
= disp_donttouch
;
5866 b
->exp_valid_block
= exp_valid_block
;
5867 b
->exp_string
= savestring (exp_start
, exp_end
- exp_start
);
5871 b
->cond_string
= savestring (cond_start
, cond_end
- cond_start
);
5875 frame
= block_innermost_frame (exp_valid_block
);
5878 prev_frame
= get_prev_frame (frame
);
5879 b
->watchpoint_frame
= get_frame_id (frame
);
5883 memset (&b
->watchpoint_frame
, 0, sizeof (b
->watchpoint_frame
));
5886 /* If the expression is "local", then set up a "watchpoint scope"
5887 breakpoint at the point where we've left the scope of the watchpoint
5889 if (innermost_block
)
5893 struct breakpoint
*scope_breakpoint
;
5894 scope_breakpoint
= create_internal_breakpoint (get_frame_pc (prev_frame
),
5895 bp_watchpoint_scope
);
5897 scope_breakpoint
->enable_state
= bp_enabled
;
5899 /* Automatically delete the breakpoint when it hits. */
5900 scope_breakpoint
->disposition
= disp_del
;
5902 /* Only break in the proper frame (help with recursion). */
5903 scope_breakpoint
->frame_id
= get_frame_id (prev_frame
);
5905 /* Set the address at which we will stop. */
5906 scope_breakpoint
->loc
->requested_address
5907 = get_frame_pc (prev_frame
);
5908 scope_breakpoint
->loc
->address
5909 = adjust_breakpoint_address (scope_breakpoint
->loc
->requested_address
,
5910 scope_breakpoint
->type
);
5912 /* The scope breakpoint is related to the watchpoint. We
5913 will need to act on them together. */
5914 b
->related_breakpoint
= scope_breakpoint
;
5917 value_free_to_mark (mark
);
5921 /* Return count of locations need to be watched and can be handled
5922 in hardware. If the watchpoint can not be handled
5923 in hardware return zero. */
5926 can_use_hardware_watchpoint (struct value
*v
)
5928 int found_memory_cnt
= 0;
5929 struct value
*head
= v
;
5931 /* Did the user specifically forbid us to use hardware watchpoints? */
5932 if (!can_use_hw_watchpoints
)
5935 /* Make sure that the value of the expression depends only upon
5936 memory contents, and values computed from them within GDB. If we
5937 find any register references or function calls, we can't use a
5938 hardware watchpoint.
5940 The idea here is that evaluating an expression generates a series
5941 of values, one holding the value of every subexpression. (The
5942 expression a*b+c has five subexpressions: a, b, a*b, c, and
5943 a*b+c.) GDB's values hold almost enough information to establish
5944 the criteria given above --- they identify memory lvalues,
5945 register lvalues, computed values, etcetera. So we can evaluate
5946 the expression, and then scan the chain of values that leaves
5947 behind to decide whether we can detect any possible change to the
5948 expression's final value using only hardware watchpoints.
5950 However, I don't think that the values returned by inferior
5951 function calls are special in any way. So this function may not
5952 notice that an expression involving an inferior function call
5953 can't be watched with hardware watchpoints. FIXME. */
5954 for (; v
; v
= value_next (v
))
5956 if (VALUE_LVAL (v
) == lval_memory
)
5959 /* A lazy memory lvalue is one that GDB never needed to fetch;
5960 we either just used its address (e.g., `a' in `a.b') or
5961 we never needed it at all (e.g., `a' in `a,b'). */
5965 /* Ahh, memory we actually used! Check if we can cover
5966 it with hardware watchpoints. */
5967 struct type
*vtype
= check_typedef (value_type (v
));
5969 /* We only watch structs and arrays if user asked for it
5970 explicitly, never if they just happen to appear in a
5971 middle of some value chain. */
5973 || (TYPE_CODE (vtype
) != TYPE_CODE_STRUCT
5974 && TYPE_CODE (vtype
) != TYPE_CODE_ARRAY
))
5976 CORE_ADDR vaddr
= VALUE_ADDRESS (v
) + value_offset (v
);
5977 int len
= TYPE_LENGTH (value_type (v
));
5979 if (!TARGET_REGION_OK_FOR_HW_WATCHPOINT (vaddr
, len
))
5986 else if (VALUE_LVAL (v
) != not_lval
5987 && deprecated_value_modifiable (v
) == 0)
5988 return 0; /* ??? What does this represent? */
5989 else if (VALUE_LVAL (v
) == lval_register
)
5990 return 0; /* cannot watch a register with a HW watchpoint */
5993 /* The expression itself looks suitable for using a hardware
5994 watchpoint, but give the target machine a chance to reject it. */
5995 return found_memory_cnt
;
5999 watch_command_wrapper (char *arg
, int from_tty
)
6001 watch_command (arg
, from_tty
);
6005 watch_command (char *arg
, int from_tty
)
6007 watch_command_1 (arg
, hw_write
, from_tty
);
6011 rwatch_command_wrapper (char *arg
, int from_tty
)
6013 rwatch_command (arg
, from_tty
);
6017 rwatch_command (char *arg
, int from_tty
)
6019 watch_command_1 (arg
, hw_read
, from_tty
);
6023 awatch_command_wrapper (char *arg
, int from_tty
)
6025 awatch_command (arg
, from_tty
);
6029 awatch_command (char *arg
, int from_tty
)
6031 watch_command_1 (arg
, hw_access
, from_tty
);
6035 /* Helper routines for the until_command routine in infcmd.c. Here
6036 because it uses the mechanisms of breakpoints. */
6038 /* This function is called by fetch_inferior_event via the
6039 cmd_continuation pointer, to complete the until command. It takes
6040 care of cleaning up the temporary breakpoints set up by the until
6043 until_break_command_continuation (struct continuation_arg
*arg
)
6045 struct cleanup
*cleanups
;
6047 cleanups
= (struct cleanup
*) arg
->data
.pointer
;
6048 do_exec_cleanups (cleanups
);
6052 until_break_command (char *arg
, int from_tty
, int anywhere
)
6054 struct symtabs_and_lines sals
;
6055 struct symtab_and_line sal
;
6056 struct frame_info
*frame
= get_selected_frame (NULL
);
6057 struct frame_info
*prev_frame
= get_prev_frame (frame
);
6058 struct breakpoint
*breakpoint
;
6059 struct cleanup
*old_chain
;
6060 struct continuation_arg
*arg1
;
6063 clear_proceed_status ();
6065 /* Set a breakpoint where the user wants it and at return from
6068 if (default_breakpoint_valid
)
6069 sals
= decode_line_1 (&arg
, 1, default_breakpoint_symtab
,
6070 default_breakpoint_line
, (char ***) NULL
, NULL
);
6072 sals
= decode_line_1 (&arg
, 1, (struct symtab
*) NULL
,
6073 0, (char ***) NULL
, NULL
);
6075 if (sals
.nelts
!= 1)
6076 error (_("Couldn't get information on specified line."));
6079 xfree (sals
.sals
); /* malloc'd, so freed */
6082 error (_("Junk at end of arguments."));
6084 resolve_sal_pc (&sal
);
6087 /* If the user told us to continue until a specified location,
6088 we don't specify a frame at which we need to stop. */
6089 breakpoint
= set_momentary_breakpoint (sal
, null_frame_id
, bp_until
);
6091 /* Otherwise, specify the current frame, because we want to stop only
6092 at the very same frame. */
6093 breakpoint
= set_momentary_breakpoint (sal
, get_frame_id (frame
),
6096 if (!target_can_async_p ())
6097 old_chain
= make_cleanup_delete_breakpoint (breakpoint
);
6099 old_chain
= make_exec_cleanup_delete_breakpoint (breakpoint
);
6101 /* If we are running asynchronously, and the target supports async
6102 execution, we are not waiting for the target to stop, in the call
6103 tp proceed, below. This means that we cannot delete the
6104 brekpoints until the target has actually stopped. The only place
6105 where we get a chance to do that is in fetch_inferior_event, so
6106 we must set things up for that. */
6108 if (target_can_async_p ())
6110 /* In this case the arg for the continuation is just the point
6111 in the exec_cleanups chain from where to start doing
6112 cleanups, because all the continuation does is the cleanups in
6113 the exec_cleanup_chain. */
6115 (struct continuation_arg
*) xmalloc (sizeof (struct continuation_arg
));
6117 arg1
->data
.pointer
= old_chain
;
6119 add_continuation (until_break_command_continuation
, arg1
);
6122 /* Keep within the current frame, or in frames called by the current
6126 sal
= find_pc_line (get_frame_pc (prev_frame
), 0);
6127 sal
.pc
= get_frame_pc (prev_frame
);
6128 breakpoint
= set_momentary_breakpoint (sal
, get_frame_id (prev_frame
),
6130 if (!target_can_async_p ())
6131 make_cleanup_delete_breakpoint (breakpoint
);
6133 make_exec_cleanup_delete_breakpoint (breakpoint
);
6136 proceed (-1, TARGET_SIGNAL_DEFAULT
, 0);
6137 /* Do the cleanups now, anly if we are not running asynchronously,
6138 of if we are, but the target is still synchronous. */
6139 if (!target_can_async_p ())
6140 do_cleanups (old_chain
);
6144 ep_skip_leading_whitespace (char **s
)
6146 if ((s
== NULL
) || (*s
== NULL
))
6148 while (isspace (**s
))
6152 /* This function examines a string, and attempts to find a token
6153 that might be an event name in the leading characters. If a
6154 possible match is found, a pointer to the last character of
6155 the token is returned. Else, NULL is returned. */
6158 ep_find_event_name_end (char *arg
)
6161 char *event_name_end
= NULL
;
6163 /* If we could depend upon the presense of strrpbrk, we'd use that... */
6167 /* We break out of the loop when we find a token delimiter.
6168 Basically, we're looking for alphanumerics and underscores;
6169 anything else delimites the token. */
6172 if (!isalnum (*s
) && (*s
!= '_'))
6178 return event_name_end
;
6182 /* This function attempts to parse an optional "if <cond>" clause
6183 from the arg string. If one is not found, it returns NULL.
6185 Else, it returns a pointer to the condition string. (It does not
6186 attempt to evaluate the string against a particular block.) And,
6187 it updates arg to point to the first character following the parsed
6188 if clause in the arg string. */
6191 ep_parse_optional_if_clause (char **arg
)
6195 if (((*arg
)[0] != 'i') || ((*arg
)[1] != 'f') || !isspace ((*arg
)[2]))
6198 /* Skip the "if" keyword. */
6201 /* Skip any extra leading whitespace, and record the start of the
6202 condition string. */
6203 ep_skip_leading_whitespace (arg
);
6206 /* Assume that the condition occupies the remainder of the arg string. */
6207 (*arg
) += strlen (cond_string
);
6212 /* This function attempts to parse an optional filename from the arg
6213 string. If one is not found, it returns NULL.
6215 Else, it returns a pointer to the parsed filename. (This function
6216 makes no attempt to verify that a file of that name exists, or is
6217 accessible.) And, it updates arg to point to the first character
6218 following the parsed filename in the arg string.
6220 Note that clients needing to preserve the returned filename for
6221 future access should copy it to their own buffers. */
6223 ep_parse_optional_filename (char **arg
)
6225 static char filename
[1024];
6230 if ((*arg_p
== '\0') || isspace (*arg_p
))
6248 /* Commands to deal with catching events, such as signals, exceptions,
6249 process start/exit, etc. */
6253 catch_fork
, catch_vfork
6258 catch_fork_command_1 (catch_fork_kind fork_kind
, char *arg
, int tempflag
,
6261 char *cond_string
= NULL
;
6263 ep_skip_leading_whitespace (&arg
);
6265 /* The allowed syntax is:
6267 catch [v]fork if <cond>
6269 First, check if there's an if clause. */
6270 cond_string
= ep_parse_optional_if_clause (&arg
);
6272 if ((*arg
!= '\0') && !isspace (*arg
))
6273 error (_("Junk at end of arguments."));
6275 /* If this target supports it, create a fork or vfork catchpoint
6276 and enable reporting of such events. */
6280 create_fork_event_catchpoint (tempflag
, cond_string
);
6283 create_vfork_event_catchpoint (tempflag
, cond_string
);
6286 error (_("unsupported or unknown fork kind; cannot catch it"));
6292 catch_exec_command_1 (char *arg
, int tempflag
, int from_tty
)
6294 char *cond_string
= NULL
;
6296 ep_skip_leading_whitespace (&arg
);
6298 /* The allowed syntax is:
6300 catch exec if <cond>
6302 First, check if there's an if clause. */
6303 cond_string
= ep_parse_optional_if_clause (&arg
);
6305 if ((*arg
!= '\0') && !isspace (*arg
))
6306 error (_("Junk at end of arguments."));
6308 /* If this target supports it, create an exec catchpoint
6309 and enable reporting of such events. */
6310 create_exec_event_catchpoint (tempflag
, cond_string
);
6314 catch_load_command_1 (char *arg
, int tempflag
, int from_tty
)
6316 char *dll_pathname
= NULL
;
6317 char *cond_string
= NULL
;
6319 ep_skip_leading_whitespace (&arg
);
6321 /* The allowed syntax is:
6323 catch load if <cond>
6324 catch load <filename>
6325 catch load <filename> if <cond>
6327 The user is not allowed to specify the <filename> after an
6330 We'll ignore the pathological case of a file named "if".
6332 First, check if there's an if clause. If so, then there
6333 cannot be a filename. */
6334 cond_string
= ep_parse_optional_if_clause (&arg
);
6336 /* If there was an if clause, then there cannot be a filename.
6337 Else, there might be a filename and an if clause. */
6338 if (cond_string
== NULL
)
6340 dll_pathname
= ep_parse_optional_filename (&arg
);
6341 ep_skip_leading_whitespace (&arg
);
6342 cond_string
= ep_parse_optional_if_clause (&arg
);
6345 if ((*arg
!= '\0') && !isspace (*arg
))
6346 error (_("Junk at end of arguments."));
6348 /* Create a load breakpoint that only triggers when a load of
6349 the specified dll (or any dll, if no pathname was specified)
6351 SOLIB_CREATE_CATCH_LOAD_HOOK (PIDGET (inferior_ptid
), tempflag
,
6352 dll_pathname
, cond_string
);
6356 catch_unload_command_1 (char *arg
, int tempflag
, int from_tty
)
6358 char *dll_pathname
= NULL
;
6359 char *cond_string
= NULL
;
6361 ep_skip_leading_whitespace (&arg
);
6363 /* The allowed syntax is:
6365 catch unload if <cond>
6366 catch unload <filename>
6367 catch unload <filename> if <cond>
6369 The user is not allowed to specify the <filename> after an
6372 We'll ignore the pathological case of a file named "if".
6374 First, check if there's an if clause. If so, then there
6375 cannot be a filename. */
6376 cond_string
= ep_parse_optional_if_clause (&arg
);
6378 /* If there was an if clause, then there cannot be a filename.
6379 Else, there might be a filename and an if clause. */
6380 if (cond_string
== NULL
)
6382 dll_pathname
= ep_parse_optional_filename (&arg
);
6383 ep_skip_leading_whitespace (&arg
);
6384 cond_string
= ep_parse_optional_if_clause (&arg
);
6387 if ((*arg
!= '\0') && !isspace (*arg
))
6388 error (_("Junk at end of arguments."));
6390 /* Create an unload breakpoint that only triggers when an unload of
6391 the specified dll (or any dll, if no pathname was specified)
6393 SOLIB_CREATE_CATCH_UNLOAD_HOOK (PIDGET (inferior_ptid
), tempflag
,
6394 dll_pathname
, cond_string
);
6397 /* Commands to deal with catching exceptions. */
6399 /* Set a breakpoint at the specified callback routine for an
6400 exception event callback */
6403 create_exception_catchpoint (int tempflag
, char *cond_string
,
6404 enum exception_event_kind ex_event
,
6405 struct symtab_and_line
*sal
)
6407 struct breakpoint
*b
;
6408 int thread
= -1; /* All threads. */
6411 if (!sal
) /* no exception support? */
6416 case EX_EVENT_THROW
:
6417 bptype
= bp_catch_throw
;
6419 case EX_EVENT_CATCH
:
6420 bptype
= bp_catch_catch
;
6422 default: /* error condition */
6423 error (_("Internal error -- invalid catchpoint kind"));
6426 b
= set_raw_breakpoint (*sal
, bptype
);
6427 set_breakpoint_count (breakpoint_count
+ 1);
6428 b
->number
= breakpoint_count
;
6430 b
->cond_string
= (cond_string
== NULL
) ?
6431 NULL
: savestring (cond_string
, strlen (cond_string
));
6433 b
->addr_string
= NULL
;
6434 b
->enable_state
= bp_enabled
;
6435 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
6439 static enum print_stop_action
6440 print_exception_catchpoint (struct breakpoint
*b
)
6442 annotate_catchpoint (b
->number
);
6444 if (strstr (b
->addr_string
, "throw") != NULL
)
6445 printf_filtered (_("\nCatchpoint %d (exception thrown)\n"),
6448 printf_filtered (_("\nCatchpoint %d (exception caught)\n"),
6451 return PRINT_SRC_AND_LOC
;
6455 print_one_exception_catchpoint (struct breakpoint
*b
, CORE_ADDR
*last_addr
)
6460 ui_out_field_core_addr (uiout
, "addr", b
->loc
->address
);
6463 *last_addr
= b
->loc
->address
;
6464 if (strstr (b
->addr_string
, "throw") != NULL
)
6465 ui_out_field_string (uiout
, "what", "exception throw");
6467 ui_out_field_string (uiout
, "what", "exception catch");
6471 print_mention_exception_catchpoint (struct breakpoint
*b
)
6473 if (strstr (b
->addr_string
, "throw") != NULL
)
6474 printf_filtered (_("Catchpoint %d (throw)"), b
->number
);
6476 printf_filtered (_("Catchpoint %d (catch)"), b
->number
);
6479 static struct breakpoint_ops gnu_v3_exception_catchpoint_ops
= {
6480 print_exception_catchpoint
,
6481 print_one_exception_catchpoint
,
6482 print_mention_exception_catchpoint
6486 handle_gnu_v3_exceptions (int tempflag
, char *cond_string
,
6487 enum exception_event_kind ex_event
, int from_tty
)
6489 char *trigger_func_name
, *nameptr
;
6490 struct symtabs_and_lines sals
;
6491 struct breakpoint
*b
;
6493 if (ex_event
== EX_EVENT_CATCH
)
6494 trigger_func_name
= xstrdup ("__cxa_begin_catch");
6496 trigger_func_name
= xstrdup ("__cxa_throw");
6498 nameptr
= trigger_func_name
;
6499 sals
= decode_line_1 (&nameptr
, 1, NULL
, 0, NULL
, NULL
);
6500 if (sals
.nelts
== 0)
6502 xfree (trigger_func_name
);
6506 b
= set_raw_breakpoint (sals
.sals
[0], bp_breakpoint
);
6507 set_breakpoint_count (breakpoint_count
+ 1);
6508 b
->number
= breakpoint_count
;
6510 b
->cond_string
= (cond_string
== NULL
) ?
6511 NULL
: savestring (cond_string
, strlen (cond_string
));
6513 b
->addr_string
= trigger_func_name
;
6514 b
->enable_state
= bp_enabled
;
6515 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
6516 b
->ops
= &gnu_v3_exception_catchpoint_ops
;
6523 /* Deal with "catch catch" and "catch throw" commands */
6526 catch_exception_command_1 (enum exception_event_kind ex_event
, char *arg
,
6527 int tempflag
, int from_tty
)
6529 char *cond_string
= NULL
;
6530 struct symtab_and_line
*sal
= NULL
;
6532 ep_skip_leading_whitespace (&arg
);
6534 cond_string
= ep_parse_optional_if_clause (&arg
);
6536 if ((*arg
!= '\0') && !isspace (*arg
))
6537 error (_("Junk at end of arguments."));
6539 if ((ex_event
!= EX_EVENT_THROW
) &&
6540 (ex_event
!= EX_EVENT_CATCH
))
6541 error (_("Unsupported or unknown exception event; cannot catch it"));
6543 if (handle_gnu_v3_exceptions (tempflag
, cond_string
, ex_event
, from_tty
))
6546 /* See if we can find a callback routine */
6547 sal
= target_enable_exception_callback (ex_event
, 1);
6551 /* We have callbacks from the runtime system for exceptions.
6552 Set a breakpoint on the sal found, if no errors */
6553 if (sal
!= (struct symtab_and_line
*) -1)
6554 create_exception_catchpoint (tempflag
, cond_string
, ex_event
, sal
);
6556 return; /* something went wrong with setting up callbacks */
6559 warning (_("Unsupported with this platform/compiler combination."));
6562 /* Create a breakpoint struct for Ada exception catchpoints. */
6565 create_ada_exception_breakpoint (struct symtab_and_line sal
,
6569 struct expression
*cond
,
6570 struct breakpoint_ops
*ops
,
6574 struct breakpoint
*b
;
6578 describe_other_breakpoints (sal
.pc
, sal
.section
, -1);
6579 /* FIXME: brobecker/2006-12-28: Actually, re-implement a special
6580 version for exception catchpoints, because two catchpoints
6581 used for different exception names will use the same address.
6582 In this case, a "breakpoint ... also set at..." warning is
6583 unproductive. Besides. the warning phrasing is also a bit
6584 inapropriate, we should use the word catchpoint, and tell
6585 the user what type of catchpoint it is. The above is good
6586 enough for now, though. */
6589 b
= set_raw_breakpoint (sal
, bp_breakpoint
);
6590 set_breakpoint_count (breakpoint_count
+ 1);
6592 b
->enable_state
= bp_enabled
;
6593 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
6594 b
->number
= breakpoint_count
;
6595 b
->ignore_count
= 0;
6597 b
->addr_string
= addr_string
;
6598 b
->language
= language_ada
;
6599 b
->cond_string
= cond_string
;
6600 b
->exp_string
= exp_string
;
6603 b
->from_tty
= from_tty
;
6608 /* Implement the "catch exception" command. */
6611 catch_ada_exception_command (char *arg
, int tempflag
, int from_tty
)
6613 struct symtab_and_line sal
;
6615 char *addr_string
= NULL
;
6616 char *exp_string
= NULL
;
6617 char *cond_string
= NULL
;
6618 struct expression
*cond
= NULL
;
6619 struct breakpoint_ops
*ops
= NULL
;
6621 sal
= ada_decode_exception_location (arg
, &addr_string
, &exp_string
,
6622 &cond_string
, &cond
, &ops
);
6623 create_ada_exception_breakpoint (sal
, addr_string
, exp_string
,
6624 cond_string
, cond
, ops
, tempflag
,
6628 /* Implement the "catch assert" command. */
6631 catch_assert_command (char *arg
, int tempflag
, int from_tty
)
6633 struct symtab_and_line sal
;
6634 char *addr_string
= NULL
;
6635 struct breakpoint_ops
*ops
= NULL
;
6637 sal
= ada_decode_assert_location (arg
, &addr_string
, &ops
);
6638 create_ada_exception_breakpoint (sal
, addr_string
, NULL
, NULL
, NULL
, ops
,
6639 tempflag
, from_tty
);
6642 /* Cover routine to allow wrapping target_enable_exception_catchpoints
6643 inside a catch_errors */
6646 cover_target_enable_exception_callback (void *arg
)
6648 args_for_catchpoint_enable
*args
= arg
;
6649 struct symtab_and_line
*sal
;
6650 sal
= target_enable_exception_callback (args
->kind
, args
->enable_p
);
6653 else if (sal
== (struct symtab_and_line
*) -1)
6656 return 1; /*is valid */
6660 catch_command_1 (char *arg
, int tempflag
, int from_tty
)
6663 /* The first argument may be an event name, such as "start" or "load".
6664 If so, then handle it as such. If it doesn't match an event name,
6665 then attempt to interpret it as an exception name. (This latter is
6666 the v4.16-and-earlier GDB meaning of the "catch" command.)
6668 First, try to find the bounds of what might be an event name. */
6669 char *arg1_start
= arg
;
6673 if (arg1_start
== NULL
)
6675 /* Old behaviour was to use pre-v-4.16 syntax */
6676 /* catch_throw_command_1 (arg1_start, tempflag, from_tty); */
6678 /* Now, this is not allowed */
6679 error (_("Catch requires an event name."));
6682 arg1_end
= ep_find_event_name_end (arg1_start
);
6683 if (arg1_end
== NULL
)
6684 error (_("catch requires an event"));
6685 arg1_length
= arg1_end
+ 1 - arg1_start
;
6687 /* Try to match what we found against known event names. */
6688 if (strncmp (arg1_start
, "signal", arg1_length
) == 0)
6690 error (_("Catch of signal not yet implemented"));
6692 else if (strncmp (arg1_start
, "catch", arg1_length
) == 0)
6694 catch_exception_command_1 (EX_EVENT_CATCH
, arg1_end
+ 1,
6695 tempflag
, from_tty
);
6697 else if (strncmp (arg1_start
, "throw", arg1_length
) == 0)
6699 catch_exception_command_1 (EX_EVENT_THROW
, arg1_end
+ 1,
6700 tempflag
, from_tty
);
6702 else if (strncmp (arg1_start
, "thread_start", arg1_length
) == 0)
6704 error (_("Catch of thread_start not yet implemented"));
6706 else if (strncmp (arg1_start
, "thread_exit", arg1_length
) == 0)
6708 error (_("Catch of thread_exit not yet implemented"));
6710 else if (strncmp (arg1_start
, "thread_join", arg1_length
) == 0)
6712 error (_("Catch of thread_join not yet implemented"));
6714 else if (strncmp (arg1_start
, "start", arg1_length
) == 0)
6716 error (_("Catch of start not yet implemented"));
6718 else if (strncmp (arg1_start
, "exit", arg1_length
) == 0)
6720 error (_("Catch of exit not yet implemented"));
6722 else if (strncmp (arg1_start
, "fork", arg1_length
) == 0)
6724 catch_fork_command_1 (catch_fork
, arg1_end
+ 1, tempflag
, from_tty
);
6726 else if (strncmp (arg1_start
, "vfork", arg1_length
) == 0)
6728 catch_fork_command_1 (catch_vfork
, arg1_end
+ 1, tempflag
, from_tty
);
6730 else if (strncmp (arg1_start
, "exec", arg1_length
) == 0)
6732 catch_exec_command_1 (arg1_end
+ 1, tempflag
, from_tty
);
6734 else if (strncmp (arg1_start
, "load", arg1_length
) == 0)
6736 catch_load_command_1 (arg1_end
+ 1, tempflag
, from_tty
);
6738 else if (strncmp (arg1_start
, "unload", arg1_length
) == 0)
6740 catch_unload_command_1 (arg1_end
+ 1, tempflag
, from_tty
);
6742 else if (strncmp (arg1_start
, "stop", arg1_length
) == 0)
6744 error (_("Catch of stop not yet implemented"));
6746 else if (strncmp (arg1_start
, "exception", arg1_length
) == 0)
6748 catch_ada_exception_command (arg1_end
+ 1, tempflag
, from_tty
);
6751 else if (strncmp (arg1_start
, "assert", arg1_length
) == 0)
6753 catch_assert_command (arg1_end
+ 1, tempflag
, from_tty
);
6756 /* This doesn't appear to be an event name */
6760 /* Pre-v.4.16 behaviour was to treat the argument
6761 as the name of an exception */
6762 /* catch_throw_command_1 (arg1_start, tempflag, from_tty); */
6763 /* Now this is not allowed */
6764 error (_("Unknown event kind specified for catch"));
6769 /* Used by the gui, could be made a worker for other things. */
6772 set_breakpoint_sal (struct symtab_and_line sal
)
6774 struct breakpoint
*b
;
6775 b
= set_raw_breakpoint (sal
, bp_breakpoint
);
6776 set_breakpoint_count (breakpoint_count
+ 1);
6777 b
->number
= breakpoint_count
;
6784 catch_command (char *arg
, int from_tty
)
6786 catch_command_1 (arg
, 0, from_tty
);
6791 tcatch_command (char *arg
, int from_tty
)
6793 catch_command_1 (arg
, 1, from_tty
);
6796 /* Delete breakpoints by address or line. */
6799 clear_command (char *arg
, int from_tty
)
6801 struct breakpoint
*b
, *tmp
, *prev
, *found
;
6803 struct symtabs_and_lines sals
;
6804 struct symtab_and_line sal
;
6809 sals
= decode_line_spec (arg
, 1);
6814 sals
.sals
= (struct symtab_and_line
*)
6815 xmalloc (sizeof (struct symtab_and_line
));
6816 make_cleanup (xfree
, sals
.sals
);
6817 init_sal (&sal
); /* initialize to zeroes */
6818 sal
.line
= default_breakpoint_line
;
6819 sal
.symtab
= default_breakpoint_symtab
;
6820 sal
.pc
= default_breakpoint_address
;
6821 if (sal
.symtab
== 0)
6822 error (_("No source file specified."));
6830 /* For each line spec given, delete bps which correspond
6831 to it. Do it in two passes, solely to preserve the current
6832 behavior that from_tty is forced true if we delete more than
6836 for (i
= 0; i
< sals
.nelts
; i
++)
6838 /* If exact pc given, clear bpts at that pc.
6839 If line given (pc == 0), clear all bpts on specified line.
6840 If defaulting, clear all bpts on default line
6843 defaulting sal.pc != 0 tests to do
6848 1 0 <can't happen> */
6853 /* Find all matching breakpoints, remove them from the
6854 breakpoint chain, and add them to the 'found' chain. */
6855 ALL_BREAKPOINTS_SAFE (b
, tmp
)
6857 /* Are we going to delete b? */
6858 if (b
->type
!= bp_none
6859 && b
->type
!= bp_watchpoint
6860 && b
->type
!= bp_hardware_watchpoint
6861 && b
->type
!= bp_read_watchpoint
6862 && b
->type
!= bp_access_watchpoint
6863 /* Not if b is a watchpoint of any sort... */
6864 && (((sal
.pc
&& (b
->loc
->address
== sal
.pc
))
6865 && (!section_is_overlay (b
->loc
->section
)
6866 || b
->loc
->section
== sal
.section
))
6867 /* Yes, if sal.pc matches b (modulo overlays). */
6868 || ((default_match
|| (0 == sal
.pc
))
6869 && b
->source_file
!= NULL
6870 && sal
.symtab
!= NULL
6871 && strcmp (b
->source_file
, sal
.symtab
->filename
) == 0
6872 && b
->line_number
== sal
.line
)))
6873 /* Yes, if sal source file and line matches b. */
6875 /* Remove it from breakpoint_chain... */
6876 if (b
== breakpoint_chain
)
6878 /* b is at the head of the list */
6879 breakpoint_chain
= b
->next
;
6883 prev
->next
= b
->next
;
6885 /* And add it to 'found' chain. */
6891 /* Keep b, and keep a pointer to it. */
6896 /* Now go thru the 'found' chain and delete them. */
6900 error (_("No breakpoint at %s."), arg
);
6902 error (_("No breakpoint at this line."));
6906 from_tty
= 1; /* Always report if deleted more than one */
6910 printf_unfiltered (_("Deleted breakpoint "));
6912 printf_unfiltered (_("Deleted breakpoints "));
6914 breakpoints_changed ();
6918 printf_unfiltered ("%d ", found
->number
);
6920 delete_breakpoint (found
);
6924 putchar_unfiltered ('\n');
6927 /* Delete breakpoint in BS if they are `delete' breakpoints and
6928 all breakpoints that are marked for deletion, whether hit or not.
6929 This is called after any breakpoint is hit, or after errors. */
6932 breakpoint_auto_delete (bpstat bs
)
6934 struct breakpoint
*b
, *temp
;
6936 for (; bs
; bs
= bs
->next
)
6937 if (bs
->breakpoint_at
&& bs
->breakpoint_at
->disposition
== disp_del
6939 delete_breakpoint (bs
->breakpoint_at
);
6941 ALL_BREAKPOINTS_SAFE (b
, temp
)
6943 if (b
->disposition
== disp_del_at_next_stop
)
6944 delete_breakpoint (b
);
6948 /* Delete a breakpoint and clean up all traces of it in the data
6952 delete_breakpoint (struct breakpoint
*bpt
)
6954 struct breakpoint
*b
;
6956 struct bp_location
*loc
;
6958 gdb_assert (bpt
!= NULL
);
6960 /* Has this bp already been deleted? This can happen because multiple
6961 lists can hold pointers to bp's. bpstat lists are especial culprits.
6963 One example of this happening is a watchpoint's scope bp. When the
6964 scope bp triggers, we notice that the watchpoint is out of scope, and
6965 delete it. We also delete its scope bp. But the scope bp is marked
6966 "auto-deleting", and is already on a bpstat. That bpstat is then
6967 checked for auto-deleting bp's, which are deleted.
6969 A real solution to this problem might involve reference counts in bp's,
6970 and/or giving them pointers back to their referencing bpstat's, and
6971 teaching delete_breakpoint to only free a bp's storage when no more
6972 references were extent. A cheaper bandaid was chosen. */
6973 if (bpt
->type
== bp_none
)
6976 if (deprecated_delete_breakpoint_hook
)
6977 deprecated_delete_breakpoint_hook (bpt
);
6978 breakpoint_delete_event (bpt
->number
);
6980 if (bpt
->loc
->inserted
)
6981 remove_breakpoint (bpt
->loc
, mark_inserted
);
6983 free_valchain (bpt
->loc
);
6985 if (breakpoint_chain
== bpt
)
6986 breakpoint_chain
= bpt
->next
;
6988 if (bp_location_chain
== bpt
->loc
)
6989 bp_location_chain
= bpt
->loc
->next
;
6991 /* If we have callback-style exception catchpoints, don't go through
6992 the adjustments to the C++ runtime library etc. if the inferior
6993 isn't actually running. target_enable_exception_callback for a
6994 null target ops vector gives an undesirable error message, so we
6995 check here and avoid it. Since currently (1997-09-17) only HP-UX aCC's
6996 exceptions are supported in this way, it's OK for now. FIXME */
6997 if (ep_is_exception_catchpoint (bpt
) && target_has_execution
)
6999 /* Format possible error msg */
7000 char *message
= xstrprintf ("Error in deleting catchpoint %d:\n",
7002 struct cleanup
*cleanups
= make_cleanup (xfree
, message
);
7003 args_for_catchpoint_enable args
;
7004 args
.kind
= bpt
->type
== bp_catch_catch
?
7005 EX_EVENT_CATCH
: EX_EVENT_THROW
;
7007 catch_errors (cover_target_enable_exception_callback
, &args
,
7008 message
, RETURN_MASK_ALL
);
7009 do_cleanups (cleanups
);
7016 b
->next
= bpt
->next
;
7020 ALL_BP_LOCATIONS (loc
)
7021 if (loc
->next
== bpt
->loc
)
7023 loc
->next
= bpt
->loc
->next
;
7027 check_duplicates (bpt
);
7028 /* If this breakpoint was inserted, and there is another breakpoint
7029 at the same address, we need to insert the other breakpoint. */
7030 if (bpt
->loc
->inserted
7031 && bpt
->type
!= bp_hardware_watchpoint
7032 && bpt
->type
!= bp_read_watchpoint
7033 && bpt
->type
!= bp_access_watchpoint
7034 && bpt
->type
!= bp_catch_fork
7035 && bpt
->type
!= bp_catch_vfork
7036 && bpt
->type
!= bp_catch_exec
)
7039 if (b
->loc
->address
== bpt
->loc
->address
7040 && b
->loc
->section
== bpt
->loc
->section
7041 && !b
->loc
->duplicate
7042 && b
->enable_state
!= bp_disabled
7043 && b
->enable_state
!= bp_shlib_disabled
7045 && b
->enable_state
!= bp_call_disabled
)
7049 /* We should never reach this point if there is a permanent
7050 breakpoint at the same address as the one being deleted.
7051 If there is a permanent breakpoint somewhere, it should
7052 always be the only one inserted. */
7053 if (b
->enable_state
== bp_permanent
)
7054 internal_error (__FILE__
, __LINE__
,
7055 _("another breakpoint was inserted on top of "
7056 "a permanent breakpoint"));
7058 memset (&b
->loc
->target_info
, 0, sizeof (b
->loc
->target_info
));
7059 b
->loc
->target_info
.placed_address
= b
->loc
->address
;
7060 if (b
->type
== bp_hardware_breakpoint
)
7061 val
= target_insert_hw_breakpoint (&b
->loc
->target_info
);
7063 val
= target_insert_breakpoint (&b
->loc
->target_info
);
7065 /* If there was an error in the insert, print a message, then stop execution. */
7068 struct ui_file
*tmp_error_stream
= mem_fileopen ();
7069 make_cleanup_ui_file_delete (tmp_error_stream
);
7072 if (b
->type
== bp_hardware_breakpoint
)
7074 fprintf_unfiltered (tmp_error_stream
,
7075 "Cannot insert hardware breakpoint %d.\n"
7076 "You may have requested too many hardware breakpoints.\n",
7081 fprintf_unfiltered (tmp_error_stream
, "Cannot insert breakpoint %d.\n", b
->number
);
7082 fprintf_filtered (tmp_error_stream
, "Error accessing memory address ");
7083 deprecated_print_address_numeric (b
->loc
->address
, 1, tmp_error_stream
);
7084 fprintf_filtered (tmp_error_stream
, ": %s.\n",
7085 safe_strerror (val
));
7088 fprintf_unfiltered (tmp_error_stream
,"The same program may be running in another process.");
7089 target_terminal_ours_for_output ();
7090 error_stream(tmp_error_stream
);
7093 b
->loc
->inserted
= 1;
7097 free_command_lines (&bpt
->commands
);
7100 if (bpt
->cond_string
!= NULL
)
7101 xfree (bpt
->cond_string
);
7102 if (bpt
->addr_string
!= NULL
)
7103 xfree (bpt
->addr_string
);
7104 if (bpt
->exp
!= NULL
)
7106 if (bpt
->exp_string
!= NULL
)
7107 xfree (bpt
->exp_string
);
7108 if (bpt
->val
!= NULL
)
7109 value_free (bpt
->val
);
7110 if (bpt
->source_file
!= NULL
)
7111 xfree (bpt
->source_file
);
7112 if (bpt
->dll_pathname
!= NULL
)
7113 xfree (bpt
->dll_pathname
);
7114 if (bpt
->triggered_dll_pathname
!= NULL
)
7115 xfree (bpt
->triggered_dll_pathname
);
7116 if (bpt
->exec_pathname
!= NULL
)
7117 xfree (bpt
->exec_pathname
);
7119 /* Be sure no bpstat's are pointing at it after it's been freed. */
7120 /* FIXME, how can we find all bpstat's?
7121 We just check stop_bpstat for now. */
7122 for (bs
= stop_bpstat
; bs
; bs
= bs
->next
)
7123 if (bs
->breakpoint_at
== bpt
)
7125 bs
->breakpoint_at
= NULL
;
7127 /* bs->commands will be freed later. */
7129 /* On the chance that someone will soon try again to delete this same
7130 bp, we mark it as deleted before freeing its storage. */
7131 bpt
->type
= bp_none
;
7138 do_delete_breakpoint_cleanup (void *b
)
7140 delete_breakpoint (b
);
7144 make_cleanup_delete_breakpoint (struct breakpoint
*b
)
7146 return make_cleanup (do_delete_breakpoint_cleanup
, b
);
7150 make_exec_cleanup_delete_breakpoint (struct breakpoint
*b
)
7152 return make_exec_cleanup (do_delete_breakpoint_cleanup
, b
);
7156 delete_command (char *arg
, int from_tty
)
7158 struct breakpoint
*b
, *temp
;
7164 int breaks_to_delete
= 0;
7166 /* Delete all breakpoints if no argument.
7167 Do not delete internal or call-dummy breakpoints, these
7168 have to be deleted with an explicit breakpoint number argument. */
7171 if (b
->type
!= bp_call_dummy
&&
7172 b
->type
!= bp_shlib_event
&&
7173 b
->type
!= bp_thread_event
&&
7174 b
->type
!= bp_overlay_event
&&
7177 breaks_to_delete
= 1;
7182 /* Ask user only if there are some breakpoints to delete. */
7184 || (breaks_to_delete
&& query (_("Delete all breakpoints? "))))
7186 ALL_BREAKPOINTS_SAFE (b
, temp
)
7188 if (b
->type
!= bp_call_dummy
&&
7189 b
->type
!= bp_shlib_event
&&
7190 b
->type
!= bp_thread_event
&&
7191 b
->type
!= bp_overlay_event
&&
7193 delete_breakpoint (b
);
7198 map_breakpoint_numbers (arg
, delete_breakpoint
);
7201 /* Reset a breakpoint given it's struct breakpoint * BINT.
7202 The value we return ends up being the return value from catch_errors.
7203 Unused in this case. */
7206 breakpoint_re_set_one (void *bint
)
7208 /* get past catch_errs */
7209 struct breakpoint
*b
= (struct breakpoint
*) bint
;
7213 int *not_found_ptr
= NULL
;
7214 struct symtabs_and_lines sals
;
7216 enum enable_state save_enable
;
7221 warning (_("attempted to reset apparently deleted breakpoint #%d?"),
7225 case bp_hardware_breakpoint
:
7227 case bp_catch_unload
:
7228 if (b
->addr_string
== NULL
)
7230 /* Anything without a string can't be re-set. */
7231 delete_breakpoint (b
);
7234 /* HACK: cagney/2001-11-11: kettenis/2001-11-11: MarkK wrote:
7236 ``And a hack it is, although Apple's Darwin version of GDB
7237 contains an almost identical hack to implement a "future
7238 break" command. It seems to work in many real world cases,
7239 but it is easy to come up with a test case where the patch
7240 doesn't help at all.''
7242 ``It seems that the way GDB implements breakpoints - in -
7243 shared - libraries was designed for a.out shared library
7244 systems (SunOS 4) where shared libraries were loaded at a
7245 fixed address in memory. Since ELF shared libraries can (and
7246 will) be loaded at any address in memory, things break.
7247 Fixing this is not trivial. Therefore, I'm not sure whether
7248 we should add this hack to the branch only. I cannot
7249 guarantee that things will be fixed on the trunk in the near
7252 In case we have a problem, disable this breakpoint. We'll
7253 restore its status if we succeed. Don't disable a
7254 shlib_disabled breakpoint though. There's a fair chance we
7255 can't re-set it if the shared library it's in hasn't been
7261 save_enable
= b
->enable_state
;
7262 if (b
->enable_state
!= bp_shlib_disabled
)
7263 b
->enable_state
= bp_disabled
;
7265 /* If resetting a shlib-disabled breakpoint, we don't want to
7266 see an error message if it is not found since we will expect
7267 this to occur until the shared library is finally reloaded.
7268 We accomplish this by giving decode_line_1 a pointer to use
7269 for silent notification that the symbol is not found. */
7270 not_found_ptr
= ¬_found
;
7272 set_language (b
->language
);
7273 input_radix
= b
->input_radix
;
7275 sals
= decode_line_1 (&s
, 1, (struct symtab
*) NULL
, 0, (char ***) NULL
,
7277 for (i
= 0; i
< sals
.nelts
; i
++)
7279 resolve_sal_pc (&sals
.sals
[i
]);
7281 /* Reparse conditions, they might contain references to the
7283 if (b
->cond_string
!= NULL
)
7289 /* Avoid re-freeing b->exp if an error during the call
7293 b
->cond
= parse_exp_1 (&s
, block_for_pc (sals
.sals
[i
].pc
), 0);
7296 /* We need to re-set the breakpoint if the address changes... */
7297 if (b
->loc
->address
!= sals
.sals
[i
].pc
7298 /* ...or new and old breakpoints both have source files, and
7299 the source file name or the line number changes... */
7300 || (b
->source_file
!= NULL
7301 && sals
.sals
[i
].symtab
!= NULL
7302 && (strcmp (b
->source_file
, sals
.sals
[i
].symtab
->filename
) != 0
7303 || b
->line_number
!= sals
.sals
[i
].line
)
7305 /* ...or we switch between having a source file and not having
7307 || ((b
->source_file
== NULL
) != (sals
.sals
[i
].symtab
== NULL
))
7310 if (b
->source_file
!= NULL
)
7311 xfree (b
->source_file
);
7312 if (sals
.sals
[i
].symtab
== NULL
)
7313 b
->source_file
= NULL
;
7316 savestring (sals
.sals
[i
].symtab
->filename
,
7317 strlen (sals
.sals
[i
].symtab
->filename
));
7318 b
->line_number
= sals
.sals
[i
].line
;
7319 b
->loc
->requested_address
= sals
.sals
[i
].pc
;
7321 = adjust_breakpoint_address (b
->loc
->requested_address
,
7324 /* Used to check for duplicates here, but that can
7325 cause trouble, as it doesn't check for disabled
7330 /* Might be better to do this just once per breakpoint_re_set,
7331 rather than once for every breakpoint. */
7332 breakpoints_changed ();
7334 b
->loc
->section
= sals
.sals
[i
].section
;
7335 b
->enable_state
= save_enable
; /* Restore it, this worked. */
7338 /* Now that this is re-enabled, check_duplicates
7340 check_duplicates (b
);
7347 case bp_hardware_watchpoint
:
7348 case bp_read_watchpoint
:
7349 case bp_access_watchpoint
:
7350 innermost_block
= NULL
;
7351 /* The issue arises of what context to evaluate this in. The
7352 same one as when it was set, but what does that mean when
7353 symbols have been re-read? We could save the filename and
7354 functionname, but if the context is more local than that, the
7355 best we could do would be something like how many levels deep
7356 and which index at that particular level, but that's going to
7357 be less stable than filenames or function names. */
7359 /* So for now, just use a global context. */
7363 /* Avoid re-freeing b->exp if an error during the call to
7364 parse_expression. */
7367 b
->exp
= parse_expression (b
->exp_string
);
7368 b
->exp_valid_block
= innermost_block
;
7369 mark
= value_mark ();
7372 value_free (b
->val
);
7373 /* Avoid re-freeing b->val if an error during the call to
7374 evaluate_expression. */
7377 b
->val
= evaluate_expression (b
->exp
);
7378 release_value (b
->val
);
7379 if (value_lazy (b
->val
) && breakpoint_enabled (b
))
7380 value_fetch_lazy (b
->val
);
7382 if (b
->cond_string
!= NULL
)
7388 /* Avoid re-freeing b->exp if an error during the call
7392 b
->cond
= parse_exp_1 (&s
, (struct block
*) 0, 0);
7394 if (breakpoint_enabled (b
))
7396 value_free_to_mark (mark
);
7398 case bp_catch_catch
:
7399 case bp_catch_throw
:
7401 /* We needn't really do anything to reset these, since the mask
7402 that requests them is unaffected by e.g., new libraries being
7405 case bp_catch_vfork
:
7410 printf_filtered (_("Deleting unknown breakpoint type %d\n"), b
->type
);
7412 /* Delete longjmp and overlay event breakpoints; they will be
7413 reset later by breakpoint_re_set. */
7415 case bp_longjmp_resume
:
7416 case bp_overlay_event
:
7417 delete_breakpoint (b
);
7420 /* This breakpoint is special, it's set up when the inferior
7421 starts and we really don't want to touch it. */
7422 case bp_shlib_event
:
7424 /* Like bp_shlib_event, this breakpoint type is special.
7425 Once it is set up, we do not want to touch it. */
7426 case bp_thread_event
:
7428 /* Keep temporary breakpoints, which can be encountered when we step
7429 over a dlopen call and SOLIB_ADD is resetting the breakpoints.
7430 Otherwise these should have been blown away via the cleanup chain
7431 or by breakpoint_init_inferior when we rerun the executable. */
7434 case bp_watchpoint_scope
:
7436 case bp_step_resume
:
7443 /* Re-set all breakpoints after symbols have been re-loaded. */
7445 breakpoint_re_set (void)
7447 struct breakpoint
*b
, *temp
;
7448 enum language save_language
;
7449 int save_input_radix
;
7451 save_language
= current_language
->la_language
;
7452 save_input_radix
= input_radix
;
7453 ALL_BREAKPOINTS_SAFE (b
, temp
)
7455 /* Format possible error msg */
7456 char *message
= xstrprintf ("Error in re-setting breakpoint %d:\n",
7458 struct cleanup
*cleanups
= make_cleanup (xfree
, message
);
7459 catch_errors (breakpoint_re_set_one
, b
, message
, RETURN_MASK_ALL
);
7460 do_cleanups (cleanups
);
7462 set_language (save_language
);
7463 input_radix
= save_input_radix
;
7465 if (GET_LONGJMP_TARGET_P ())
7467 create_longjmp_breakpoint ("longjmp");
7468 create_longjmp_breakpoint ("_longjmp");
7469 create_longjmp_breakpoint ("siglongjmp");
7470 create_longjmp_breakpoint ("_siglongjmp");
7471 create_longjmp_breakpoint (NULL
);
7474 create_overlay_event_breakpoint ("_ovly_debug_event");
7477 /* Reset the thread number of this breakpoint:
7479 - If the breakpoint is for all threads, leave it as-is.
7480 - Else, reset it to the current thread for inferior_ptid. */
7482 breakpoint_re_set_thread (struct breakpoint
*b
)
7484 if (b
->thread
!= -1)
7486 if (in_thread_list (inferior_ptid
))
7487 b
->thread
= pid_to_thread_id (inferior_ptid
);
7491 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
7492 If from_tty is nonzero, it prints a message to that effect,
7493 which ends with a period (no newline). */
7496 set_ignore_count (int bptnum
, int count
, int from_tty
)
7498 struct breakpoint
*b
;
7504 if (b
->number
== bptnum
)
7506 b
->ignore_count
= count
;
7510 printf_filtered (_("Will stop next time breakpoint %d is reached."),
7512 else if (count
== 1)
7513 printf_filtered (_("Will ignore next crossing of breakpoint %d."),
7516 printf_filtered (_("Will ignore next %d crossings of breakpoint %d."),
7519 breakpoints_changed ();
7520 breakpoint_modify_event (b
->number
);
7524 error (_("No breakpoint number %d."), bptnum
);
7527 /* Clear the ignore counts of all breakpoints. */
7529 breakpoint_clear_ignore_counts (void)
7531 struct breakpoint
*b
;
7534 b
->ignore_count
= 0;
7537 /* Command to set ignore-count of breakpoint N to COUNT. */
7540 ignore_command (char *args
, int from_tty
)
7546 error_no_arg (_("a breakpoint number"));
7548 num
= get_number (&p
);
7550 error (_("bad breakpoint number: '%s'"), args
);
7552 error (_("Second argument (specified ignore-count) is missing."));
7554 set_ignore_count (num
,
7555 longest_to_int (value_as_long (parse_and_eval (p
))),
7558 printf_filtered ("\n");
7561 /* Call FUNCTION on each of the breakpoints
7562 whose numbers are given in ARGS. */
7565 map_breakpoint_numbers (char *args
, void (*function
) (struct breakpoint
*))
7570 struct breakpoint
*b
, *tmp
;
7574 error_no_arg (_("one or more breakpoint numbers"));
7581 num
= get_number_or_range (&p1
);
7584 warning (_("bad breakpoint number at or near '%s'"), p
);
7588 ALL_BREAKPOINTS_SAFE (b
, tmp
)
7589 if (b
->number
== num
)
7591 struct breakpoint
*related_breakpoint
= b
->related_breakpoint
;
7594 if (related_breakpoint
)
7595 function (related_breakpoint
);
7599 printf_unfiltered (_("No breakpoint number %d.\n"), num
);
7605 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
7606 If from_tty is nonzero, it prints a message to that effect,
7607 which ends with a period (no newline). */
7610 disable_breakpoint (struct breakpoint
*bpt
)
7612 /* Never disable a watchpoint scope breakpoint; we want to
7613 hit them when we leave scope so we can delete both the
7614 watchpoint and its scope breakpoint at that time. */
7615 if (bpt
->type
== bp_watchpoint_scope
)
7618 /* You can't disable permanent breakpoints. */
7619 if (bpt
->enable_state
== bp_permanent
)
7622 bpt
->enable_state
= bp_disabled
;
7624 check_duplicates (bpt
);
7626 if (deprecated_modify_breakpoint_hook
)
7627 deprecated_modify_breakpoint_hook (bpt
);
7628 breakpoint_modify_event (bpt
->number
);
7632 disable_command (char *args
, int from_tty
)
7634 struct breakpoint
*bpt
;
7636 ALL_BREAKPOINTS (bpt
)
7640 warning (_("attempted to disable apparently deleted breakpoint #%d?"),
7645 case bp_catch_unload
:
7647 case bp_catch_vfork
:
7649 case bp_catch_catch
:
7650 case bp_catch_throw
:
7651 case bp_hardware_breakpoint
:
7653 case bp_hardware_watchpoint
:
7654 case bp_read_watchpoint
:
7655 case bp_access_watchpoint
:
7656 disable_breakpoint (bpt
);
7661 map_breakpoint_numbers (args
, disable_breakpoint
);
7665 do_enable_breakpoint (struct breakpoint
*bpt
, enum bpdisp disposition
)
7667 int target_resources_ok
, other_type_used
;
7670 if (bpt
->type
== bp_hardware_breakpoint
)
7673 i
= hw_breakpoint_used_count ();
7674 target_resources_ok
=
7675 TARGET_CAN_USE_HARDWARE_WATCHPOINT (bp_hardware_breakpoint
,
7677 if (target_resources_ok
== 0)
7678 error (_("No hardware breakpoint support in the target."));
7679 else if (target_resources_ok
< 0)
7680 error (_("Hardware breakpoints used exceeds limit."));
7685 if (bpt
->enable_state
!= bp_enabled
)
7687 /* When enabling a pending breakpoint, we need to check if the breakpoint
7688 is resolvable since shared libraries could have been loaded
7689 after the breakpoint was disabled. */
7690 breakpoints_changed ();
7691 if (resolve_pending_breakpoint (bpt
) == GDB_RC_OK
)
7693 delete_breakpoint (bpt
);
7696 bpt
->enable_state
= bp_enabled
;
7697 bpt
->disposition
= disposition
;
7700 else /* Not a pending breakpoint. */
7702 if (bpt
->enable_state
!= bp_permanent
)
7703 bpt
->enable_state
= bp_enabled
;
7704 bpt
->disposition
= disposition
;
7705 check_duplicates (bpt
);
7706 breakpoints_changed ();
7708 if (bpt
->type
== bp_watchpoint
||
7709 bpt
->type
== bp_hardware_watchpoint
||
7710 bpt
->type
== bp_read_watchpoint
||
7711 bpt
->type
== bp_access_watchpoint
)
7713 struct frame_id saved_frame_id
;
7715 saved_frame_id
= get_frame_id (get_selected_frame (NULL
));
7716 if (bpt
->exp_valid_block
!= NULL
)
7718 struct frame_info
*fr
=
7719 fr
= frame_find_by_id (bpt
->watchpoint_frame
);
7722 printf_filtered (_("\
7723 Cannot enable watchpoint %d because the block in which its expression\n\
7724 is valid is not currently in scope.\n"), bpt
->number
);
7725 bpt
->enable_state
= bp_disabled
;
7731 value_free (bpt
->val
);
7732 mark
= value_mark ();
7733 bpt
->val
= evaluate_expression (bpt
->exp
);
7734 release_value (bpt
->val
);
7735 if (value_lazy (bpt
->val
))
7736 value_fetch_lazy (bpt
->val
);
7738 if (bpt
->type
== bp_hardware_watchpoint
||
7739 bpt
->type
== bp_read_watchpoint
||
7740 bpt
->type
== bp_access_watchpoint
)
7742 int i
= hw_watchpoint_used_count (bpt
->type
, &other_type_used
);
7743 int mem_cnt
= can_use_hardware_watchpoint (bpt
->val
);
7745 /* Hack around 'unused var' error for some targets here */
7746 (void) mem_cnt
, (void) i
;
7747 target_resources_ok
= TARGET_CAN_USE_HARDWARE_WATCHPOINT (
7748 bpt
->type
, i
+ mem_cnt
, other_type_used
);
7749 /* we can consider of type is bp_hardware_watchpoint, convert to
7750 bp_watchpoint in the following condition */
7751 if (target_resources_ok
< 0)
7753 printf_filtered (_("\
7754 Cannot enable watchpoint %d because target watch resources\n\
7755 have been allocated for other watchpoints.\n"), bpt
->number
);
7756 bpt
->enable_state
= bp_disabled
;
7757 value_free_to_mark (mark
);
7762 select_frame (frame_find_by_id (saved_frame_id
));
7763 value_free_to_mark (mark
);
7767 if (deprecated_modify_breakpoint_hook
)
7768 deprecated_modify_breakpoint_hook (bpt
);
7769 breakpoint_modify_event (bpt
->number
);
7773 enable_breakpoint (struct breakpoint
*bpt
)
7775 do_enable_breakpoint (bpt
, bpt
->disposition
);
7778 /* The enable command enables the specified breakpoints (or all defined
7779 breakpoints) so they once again become (or continue to be) effective
7780 in stopping the inferior. */
7783 enable_command (char *args
, int from_tty
)
7785 struct breakpoint
*bpt
;
7787 ALL_BREAKPOINTS (bpt
)
7791 warning (_("attempted to enable apparently deleted breakpoint #%d?"),
7796 case bp_catch_unload
:
7798 case bp_catch_vfork
:
7800 case bp_catch_catch
:
7801 case bp_catch_throw
:
7802 case bp_hardware_breakpoint
:
7804 case bp_hardware_watchpoint
:
7805 case bp_read_watchpoint
:
7806 case bp_access_watchpoint
:
7807 enable_breakpoint (bpt
);
7812 map_breakpoint_numbers (args
, enable_breakpoint
);
7816 enable_once_breakpoint (struct breakpoint
*bpt
)
7818 do_enable_breakpoint (bpt
, disp_disable
);
7822 enable_once_command (char *args
, int from_tty
)
7824 map_breakpoint_numbers (args
, enable_once_breakpoint
);
7828 enable_delete_breakpoint (struct breakpoint
*bpt
)
7830 do_enable_breakpoint (bpt
, disp_del
);
7834 enable_delete_command (char *args
, int from_tty
)
7836 map_breakpoint_numbers (args
, enable_delete_breakpoint
);
7840 set_breakpoint_cmd (char *args
, int from_tty
)
7845 show_breakpoint_cmd (char *args
, int from_tty
)
7849 /* Use default_breakpoint_'s, or nothing if they aren't valid. */
7851 struct symtabs_and_lines
7852 decode_line_spec_1 (char *string
, int funfirstline
)
7854 struct symtabs_and_lines sals
;
7856 error (_("Empty line specification."));
7857 if (default_breakpoint_valid
)
7858 sals
= decode_line_1 (&string
, funfirstline
,
7859 default_breakpoint_symtab
,
7860 default_breakpoint_line
,
7861 (char ***) NULL
, NULL
);
7863 sals
= decode_line_1 (&string
, funfirstline
,
7864 (struct symtab
*) NULL
, 0, (char ***) NULL
, NULL
);
7866 error (_("Junk at end of line specification: %s"), string
);
7870 /* Create and insert a raw software breakpoint at PC. Return an
7871 identifier, which should be used to remove the breakpoint later.
7872 In general, places which call this should be using something on the
7873 breakpoint chain instead; this function should be eliminated
7877 deprecated_insert_raw_breakpoint (CORE_ADDR pc
)
7879 struct bp_target_info
*bp_tgt
;
7881 bp_tgt
= xmalloc (sizeof (struct bp_target_info
));
7882 memset (bp_tgt
, 0, sizeof (struct bp_target_info
));
7884 bp_tgt
->placed_address
= pc
;
7885 if (target_insert_breakpoint (bp_tgt
) != 0)
7887 /* Could not insert the breakpoint. */
7895 /* Remove a breakpoint BP inserted by deprecated_insert_raw_breakpoint. */
7898 deprecated_remove_raw_breakpoint (void *bp
)
7900 struct bp_target_info
*bp_tgt
= bp
;
7903 ret
= target_remove_breakpoint (bp_tgt
);
7909 /* One (or perhaps two) breakpoints used for software single stepping. */
7911 static void *single_step_breakpoints
[2];
7913 /* Create and insert a breakpoint for software single step. */
7916 insert_single_step_breakpoint (CORE_ADDR next_pc
)
7920 if (single_step_breakpoints
[0] == NULL
)
7921 bpt_p
= &single_step_breakpoints
[0];
7924 gdb_assert (single_step_breakpoints
[1] == NULL
);
7925 bpt_p
= &single_step_breakpoints
[1];
7928 /* NOTE drow/2006-04-11: A future improvement to this function would be
7929 to only create the breakpoints once, and actually put them on the
7930 breakpoint chain. That would let us use set_raw_breakpoint. We could
7931 adjust the addresses each time they were needed. Doing this requires
7932 corresponding changes elsewhere where single step breakpoints are
7933 handled, however. So, for now, we use this. */
7935 *bpt_p
= deprecated_insert_raw_breakpoint (next_pc
);
7937 error (_("Could not insert single-step breakpoint at 0x%s"),
7938 paddr_nz (next_pc
));
7941 /* Remove and delete any breakpoints used for software single step. */
7944 remove_single_step_breakpoints (void)
7946 gdb_assert (single_step_breakpoints
[0] != NULL
);
7948 /* See insert_single_step_breakpoint for more about this deprecated
7950 deprecated_remove_raw_breakpoint (single_step_breakpoints
[0]);
7951 single_step_breakpoints
[0] = NULL
;
7953 if (single_step_breakpoints
[1] != NULL
)
7955 deprecated_remove_raw_breakpoint (single_step_breakpoints
[1]);
7956 single_step_breakpoints
[1] = NULL
;
7961 /* This help string is used for the break, hbreak, tbreak and thbreak commands.
7962 It is defined as a macro to prevent duplication.
7963 COMMAND should be a string constant containing the name of the command. */
7964 #define BREAK_ARGS_HELP(command) \
7965 command" [LOCATION] [thread THREADNUM] [if CONDITION]\n\
7966 LOCATION may be a line number, function name, or \"*\" and an address.\n\
7967 If a line number is specified, break at start of code for that line.\n\
7968 If a function is specified, break at start of code for that function.\n\
7969 If an address is specified, break at that exact address.\n\
7970 With no LOCATION, uses current execution address of selected stack frame.\n\
7971 This is useful for breaking on return to a stack frame.\n\
7973 THREADNUM is the number from \"info threads\".\n\
7974 CONDITION is a boolean expression.\n\
7976 Multiple breakpoints at one place are permitted, and useful if conditional.\n\
7978 Do \"help breakpoints\" for info on other commands dealing with breakpoints."
7981 _initialize_breakpoint (void)
7983 static struct cmd_list_element
*breakpoint_set_cmdlist
;
7984 static struct cmd_list_element
*breakpoint_show_cmdlist
;
7985 struct cmd_list_element
*c
;
7987 observer_attach_solib_unloaded (disable_breakpoints_in_unloaded_shlib
);
7989 breakpoint_chain
= 0;
7990 /* Don't bother to call set_breakpoint_count. $bpnum isn't useful
7991 before a breakpoint is set. */
7992 breakpoint_count
= 0;
7994 add_com ("ignore", class_breakpoint
, ignore_command
, _("\
7995 Set ignore-count of breakpoint number N to COUNT.\n\
7996 Usage is `ignore N COUNT'."));
7998 add_com_alias ("bc", "ignore", class_breakpoint
, 1);
8000 add_com ("commands", class_breakpoint
, commands_command
, _("\
8001 Set commands to be executed when a breakpoint is hit.\n\
8002 Give breakpoint number as argument after \"commands\".\n\
8003 With no argument, the targeted breakpoint is the last one set.\n\
8004 The commands themselves follow starting on the next line.\n\
8005 Type a line containing \"end\" to indicate the end of them.\n\
8006 Give \"silent\" as the first line to make the breakpoint silent;\n\
8007 then no output is printed when it is hit, except what the commands print."));
8009 add_com ("condition", class_breakpoint
, condition_command
, _("\
8010 Specify breakpoint number N to break only if COND is true.\n\
8011 Usage is `condition N COND', where N is an integer and COND is an\n\
8012 expression to be evaluated whenever breakpoint N is reached."));
8014 c
= add_com ("tbreak", class_breakpoint
, tbreak_command
, _("\
8015 Set a temporary breakpoint.\n\
8016 Like \"break\" except the breakpoint is only temporary,\n\
8017 so it will be deleted when hit. Equivalent to \"break\" followed\n\
8018 by using \"enable delete\" on the breakpoint number.\n\
8020 BREAK_ARGS_HELP ("tbreak")));
8021 set_cmd_completer (c
, location_completer
);
8023 c
= add_com ("hbreak", class_breakpoint
, hbreak_command
, _("\
8024 Set a hardware assisted breakpoint.\n\
8025 Like \"break\" except the breakpoint requires hardware support,\n\
8026 some target hardware may not have this support.\n\
8028 BREAK_ARGS_HELP ("hbreak")));
8029 set_cmd_completer (c
, location_completer
);
8031 c
= add_com ("thbreak", class_breakpoint
, thbreak_command
, _("\
8032 Set a temporary hardware assisted breakpoint.\n\
8033 Like \"hbreak\" except the breakpoint is only temporary,\n\
8034 so it will be deleted when hit.\n\
8036 BREAK_ARGS_HELP ("thbreak")));
8037 set_cmd_completer (c
, location_completer
);
8039 add_prefix_cmd ("enable", class_breakpoint
, enable_command
, _("\
8040 Enable some breakpoints.\n\
8041 Give breakpoint numbers (separated by spaces) as arguments.\n\
8042 With no subcommand, breakpoints are enabled until you command otherwise.\n\
8043 This is used to cancel the effect of the \"disable\" command.\n\
8044 With a subcommand you can enable temporarily."),
8045 &enablelist
, "enable ", 1, &cmdlist
);
8047 add_com ("ab", class_breakpoint
, enable_command
, _("\
8048 Enable some breakpoints.\n\
8049 Give breakpoint numbers (separated by spaces) as arguments.\n\
8050 With no subcommand, breakpoints are enabled until you command otherwise.\n\
8051 This is used to cancel the effect of the \"disable\" command.\n\
8052 With a subcommand you can enable temporarily."));
8054 add_com_alias ("en", "enable", class_breakpoint
, 1);
8056 add_abbrev_prefix_cmd ("breakpoints", class_breakpoint
, enable_command
, _("\
8057 Enable some breakpoints.\n\
8058 Give breakpoint numbers (separated by spaces) as arguments.\n\
8059 This is used to cancel the effect of the \"disable\" command.\n\
8060 May be abbreviated to simply \"enable\".\n"),
8061 &enablebreaklist
, "enable breakpoints ", 1, &enablelist
);
8063 add_cmd ("once", no_class
, enable_once_command
, _("\
8064 Enable breakpoints for one hit. Give breakpoint numbers.\n\
8065 If a breakpoint is hit while enabled in this fashion, it becomes disabled."),
8068 add_cmd ("delete", no_class
, enable_delete_command
, _("\
8069 Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
8070 If a breakpoint is hit while enabled in this fashion, it is deleted."),
8073 add_cmd ("delete", no_class
, enable_delete_command
, _("\
8074 Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
8075 If a breakpoint is hit while enabled in this fashion, it is deleted."),
8078 add_cmd ("once", no_class
, enable_once_command
, _("\
8079 Enable breakpoints for one hit. Give breakpoint numbers.\n\
8080 If a breakpoint is hit while enabled in this fashion, it becomes disabled."),
8083 add_prefix_cmd ("disable", class_breakpoint
, disable_command
, _("\
8084 Disable some breakpoints.\n\
8085 Arguments are breakpoint numbers with spaces in between.\n\
8086 To disable all breakpoints, give no argument.\n\
8087 A disabled breakpoint is not forgotten, but has no effect until reenabled."),
8088 &disablelist
, "disable ", 1, &cmdlist
);
8089 add_com_alias ("dis", "disable", class_breakpoint
, 1);
8090 add_com_alias ("disa", "disable", class_breakpoint
, 1);
8092 add_com ("sb", class_breakpoint
, disable_command
, _("\
8093 Disable some breakpoints.\n\
8094 Arguments are breakpoint numbers with spaces in between.\n\
8095 To disable all breakpoints, give no argument.\n\
8096 A disabled breakpoint is not forgotten, but has no effect until reenabled."));
8098 add_cmd ("breakpoints", class_alias
, disable_command
, _("\
8099 Disable some breakpoints.\n\
8100 Arguments are breakpoint numbers with spaces in between.\n\
8101 To disable all breakpoints, give no argument.\n\
8102 A disabled breakpoint is not forgotten, but has no effect until reenabled.\n\
8103 This command may be abbreviated \"disable\"."),
8106 add_prefix_cmd ("delete", class_breakpoint
, delete_command
, _("\
8107 Delete some breakpoints or auto-display expressions.\n\
8108 Arguments are breakpoint numbers with spaces in between.\n\
8109 To delete all breakpoints, give no argument.\n\
8111 Also a prefix command for deletion of other GDB objects.\n\
8112 The \"unset\" command is also an alias for \"delete\"."),
8113 &deletelist
, "delete ", 1, &cmdlist
);
8114 add_com_alias ("d", "delete", class_breakpoint
, 1);
8115 add_com_alias ("del", "delete", class_breakpoint
, 1);
8117 add_com ("db", class_breakpoint
, delete_command
, _("\
8118 Delete some breakpoints.\n\
8119 Arguments are breakpoint numbers with spaces in between.\n\
8120 To delete all breakpoints, give no argument.\n"));
8122 add_cmd ("breakpoints", class_alias
, delete_command
, _("\
8123 Delete some breakpoints or auto-display expressions.\n\
8124 Arguments are breakpoint numbers with spaces in between.\n\
8125 To delete all breakpoints, give no argument.\n\
8126 This command may be abbreviated \"delete\"."),
8129 add_com ("clear", class_breakpoint
, clear_command
, _("\
8130 Clear breakpoint at specified line or function.\n\
8131 Argument may be line number, function name, or \"*\" and an address.\n\
8132 If line number is specified, all breakpoints in that line are cleared.\n\
8133 If function is specified, breakpoints at beginning of function are cleared.\n\
8134 If an address is specified, breakpoints at that address are cleared.\n\
8136 With no argument, clears all breakpoints in the line that the selected frame\n\
8139 See also the \"delete\" command which clears breakpoints by number."));
8141 c
= add_com ("break", class_breakpoint
, break_command
, _("\
8142 Set breakpoint at specified line or function.\n"
8143 BREAK_ARGS_HELP ("break")));
8144 set_cmd_completer (c
, location_completer
);
8146 add_com_alias ("b", "break", class_run
, 1);
8147 add_com_alias ("br", "break", class_run
, 1);
8148 add_com_alias ("bre", "break", class_run
, 1);
8149 add_com_alias ("brea", "break", class_run
, 1);
8153 add_com_alias ("ba", "break", class_breakpoint
, 1);
8154 add_com_alias ("bu", "ubreak", class_breakpoint
, 1);
8159 add_abbrev_prefix_cmd ("stop", class_breakpoint
, stop_command
, _("\
8160 Break in function/address or break at a line in the current file."),
8161 &stoplist
, "stop ", 1, &cmdlist
);
8162 add_cmd ("in", class_breakpoint
, stopin_command
,
8163 _("Break in function or address."), &stoplist
);
8164 add_cmd ("at", class_breakpoint
, stopat_command
,
8165 _("Break at a line in the current file."), &stoplist
);
8166 add_com ("status", class_info
, breakpoints_info
, _("\
8167 Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
8168 The \"Type\" column indicates one of:\n\
8169 \tbreakpoint - normal breakpoint\n\
8170 \twatchpoint - watchpoint\n\
8171 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
8172 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
8173 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
8174 address and file/line number respectively.\n\
8176 Convenience variable \"$_\" and default examine address for \"x\"\n\
8177 are set to the address of the last breakpoint listed.\n\n\
8178 Convenience variable \"$bpnum\" contains the number of the last\n\
8182 add_info ("breakpoints", breakpoints_info
, _("\
8183 Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
8184 The \"Type\" column indicates one of:\n\
8185 \tbreakpoint - normal breakpoint\n\
8186 \twatchpoint - watchpoint\n\
8187 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
8188 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
8189 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
8190 address and file/line number respectively.\n\
8192 Convenience variable \"$_\" and default examine address for \"x\"\n\
8193 are set to the address of the last breakpoint listed.\n\n\
8194 Convenience variable \"$bpnum\" contains the number of the last\n\
8198 add_com ("lb", class_breakpoint
, breakpoints_info
, _("\
8199 Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
8200 The \"Type\" column indicates one of:\n\
8201 \tbreakpoint - normal breakpoint\n\
8202 \twatchpoint - watchpoint\n\
8203 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
8204 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
8205 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
8206 address and file/line number respectively.\n\
8208 Convenience variable \"$_\" and default examine address for \"x\"\n\
8209 are set to the address of the last breakpoint listed.\n\n\
8210 Convenience variable \"$bpnum\" contains the number of the last\n\
8213 add_cmd ("breakpoints", class_maintenance
, maintenance_info_breakpoints
, _("\
8214 Status of all breakpoints, or breakpoint number NUMBER.\n\
8215 The \"Type\" column indicates one of:\n\
8216 \tbreakpoint - normal breakpoint\n\
8217 \twatchpoint - watchpoint\n\
8218 \tlongjmp - internal breakpoint used to step through longjmp()\n\
8219 \tlongjmp resume - internal breakpoint at the target of longjmp()\n\
8220 \tuntil - internal breakpoint used by the \"until\" command\n\
8221 \tfinish - internal breakpoint used by the \"finish\" command\n\
8222 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
8223 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
8224 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
8225 address and file/line number respectively.\n\
8227 Convenience variable \"$_\" and default examine address for \"x\"\n\
8228 are set to the address of the last breakpoint listed.\n\
8230 Convenience variable \"$bpnum\" contains the number of the last\n\
8232 &maintenanceinfolist
);
8234 add_com ("catch", class_breakpoint
, catch_command
, _("\
8235 Set catchpoints to catch events.\n\
8236 Raised signals may be caught:\n\
8237 \tcatch signal - all signals\n\
8238 \tcatch signal <signame> - a particular signal\n\
8239 Raised exceptions may be caught:\n\
8240 \tcatch throw - all exceptions, when thrown\n\
8241 \tcatch throw <exceptname> - a particular exception, when thrown\n\
8242 \tcatch catch - all exceptions, when caught\n\
8243 \tcatch catch <exceptname> - a particular exception, when caught\n\
8244 Thread or process events may be caught:\n\
8245 \tcatch thread_start - any threads, just after creation\n\
8246 \tcatch thread_exit - any threads, just before expiration\n\
8247 \tcatch thread_join - any threads, just after joins\n\
8248 Process events may be caught:\n\
8249 \tcatch start - any processes, just after creation\n\
8250 \tcatch exit - any processes, just before expiration\n\
8251 \tcatch fork - calls to fork()\n\
8252 \tcatch vfork - calls to vfork()\n\
8253 \tcatch exec - calls to exec()\n\
8254 Dynamically-linked library events may be caught:\n\
8255 \tcatch load - loads of any library\n\
8256 \tcatch load <libname> - loads of a particular library\n\
8257 \tcatch unload - unloads of any library\n\
8258 \tcatch unload <libname> - unloads of a particular library\n\
8259 The act of your program's execution stopping may also be caught:\n\
8261 C++ exceptions may be caught:\n\
8262 \tcatch throw - all exceptions, when thrown\n\
8263 \tcatch catch - all exceptions, when caught\n\
8264 Ada exceptions may be caught:\n\
8265 \tcatch exception - all exceptions, when raised\n\
8266 \tcatch exception <name> - a particular exception, when raised\n\
8267 \tcatch exception unhandled - all unhandled exceptions, when raised\n\
8268 \tcatch assert - all failed assertions, when raised\n\
8270 Do \"help set follow-fork-mode\" for info on debugging your program\n\
8271 after a fork or vfork is caught.\n\n\
8272 Do \"help breakpoints\" for info on other commands dealing with breakpoints."));
8274 add_com ("tcatch", class_breakpoint
, tcatch_command
, _("\
8275 Set temporary catchpoints to catch events.\n\
8276 Args like \"catch\" command.\n\
8277 Like \"catch\" except the catchpoint is only temporary,\n\
8278 so it will be deleted when hit. Equivalent to \"catch\" followed\n\
8279 by using \"enable delete\" on the catchpoint number."));
8281 c
= add_com ("watch", class_breakpoint
, watch_command
, _("\
8282 Set a watchpoint for an expression.\n\
8283 A watchpoint stops execution of your program whenever the value of\n\
8284 an expression changes."));
8285 set_cmd_completer (c
, location_completer
);
8287 c
= add_com ("rwatch", class_breakpoint
, rwatch_command
, _("\
8288 Set a read watchpoint for an expression.\n\
8289 A watchpoint stops execution of your program whenever the value of\n\
8290 an expression is read."));
8291 set_cmd_completer (c
, location_completer
);
8293 c
= add_com ("awatch", class_breakpoint
, awatch_command
, _("\
8294 Set a watchpoint for an expression.\n\
8295 A watchpoint stops execution of your program whenever the value of\n\
8296 an expression is either read or written."));
8297 set_cmd_completer (c
, location_completer
);
8299 add_info ("watchpoints", breakpoints_info
,
8300 _("Synonym for ``info breakpoints''."));
8303 /* XXX: cagney/2005-02-23: This should be a boolean, and should
8304 respond to changes - contrary to the description. */
8305 add_setshow_zinteger_cmd ("can-use-hw-watchpoints", class_support
,
8306 &can_use_hw_watchpoints
, _("\
8307 Set debugger's willingness to use watchpoint hardware."), _("\
8308 Show debugger's willingness to use watchpoint hardware."), _("\
8309 If zero, gdb will not use hardware for new watchpoints, even if\n\
8310 such is available. (However, any hardware watchpoints that were\n\
8311 created before setting this to nonzero, will continue to use watchpoint\n\
8314 show_can_use_hw_watchpoints
,
8315 &setlist
, &showlist
);
8317 can_use_hw_watchpoints
= 1;
8319 add_prefix_cmd ("breakpoint", class_maintenance
, set_breakpoint_cmd
, _("\
8320 Breakpoint specific settings\n\
8321 Configure various breakpoint-specific variables such as\n\
8322 pending breakpoint behavior"),
8323 &breakpoint_set_cmdlist
, "set breakpoint ",
8324 0/*allow-unknown*/, &setlist
);
8325 add_prefix_cmd ("breakpoint", class_maintenance
, show_breakpoint_cmd
, _("\
8326 Breakpoint specific settings\n\
8327 Configure various breakpoint-specific variables such as\n\
8328 pending breakpoint behavior"),
8329 &breakpoint_show_cmdlist
, "show breakpoint ",
8330 0/*allow-unknown*/, &showlist
);
8332 add_setshow_auto_boolean_cmd ("pending", no_class
,
8333 &pending_break_support
, _("\
8334 Set debugger's behavior regarding pending breakpoints."), _("\
8335 Show debugger's behavior regarding pending breakpoints."), _("\
8336 If on, an unrecognized breakpoint location will cause gdb to create a\n\
8337 pending breakpoint. If off, an unrecognized breakpoint location results in\n\
8338 an error. If auto, an unrecognized breakpoint location results in a\n\
8339 user-query to see if a pending breakpoint should be created."),
8341 show_pending_break_support
,
8342 &breakpoint_set_cmdlist
,
8343 &breakpoint_show_cmdlist
);
8345 pending_break_support
= AUTO_BOOLEAN_AUTO
;
8347 add_setshow_boolean_cmd ("auto-hw", no_class
,
8348 &automatic_hardware_breakpoints
, _("\
8349 Set automatic usage of hardware breakpoints."), _("\
8350 Show automatic usage of hardware breakpoints."), _("\
8351 If set, the debugger will automatically use hardware breakpoints for\n\
8352 breakpoints set with \"break\" but falling in read-only memory. If not set,\n\
8353 a warning will be emitted for such breakpoints."),
8355 show_automatic_hardware_breakpoints
,
8356 &breakpoint_set_cmdlist
,
8357 &breakpoint_show_cmdlist
);
8359 automatic_hardware_breakpoints
= 1;