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 exception-handling catchpoints. */
1411 if ((b
->type
== bp_catch_catch
) || (b
->type
== bp_catch_throw
))
1413 delete_breakpoint (b
);
1417 /* Don't delete an exec catchpoint, because else the inferior
1418 won't stop when it ought!
1420 Similarly, we probably ought to keep vfork catchpoints, 'cause
1421 on this target, we may not be able to stop when the vfork is
1422 seen, but only when the subsequent exec is seen. (And because
1423 deleting fork catchpoints here but not vfork catchpoints will
1424 seem mysterious to users, keep those too.)
1426 ??rehrauer: Let's hope that merely clearing out this catchpoint's
1427 target address field, if any, is sufficient to have it be reset
1428 automagically. Certainly on HP-UX that's true.
1430 Jim Blandy <jimb@redhat.com>: Actually, zero is a perfectly
1431 valid code address on some platforms (like the mn10300
1432 simulators). We shouldn't assign any special interpretation to
1433 a breakpoint with a zero address. And in fact, GDB doesn't ---
1434 I can't see what that comment above is talking about. As far
1435 as I can tell, setting the address of a
1436 bp_catch_exec/bp_catch_vfork/bp_catch_fork breakpoint to zero
1437 is meaningless, since those are implemented with HP-UX kernel
1438 hackery, not by storing breakpoint instructions somewhere. */
1439 if ((b
->type
== bp_catch_exec
) ||
1440 (b
->type
== bp_catch_vfork
) ||
1441 (b
->type
== bp_catch_fork
))
1443 b
->loc
->address
= (CORE_ADDR
) 0;
1447 /* bp_finish is a special case. The only way we ought to be able
1448 to see one of these when an exec() has happened, is if the user
1449 caught a vfork, and then said "finish". Ordinarily a finish just
1450 carries them to the call-site of the current callee, by setting
1451 a temporary bp there and resuming. But in this case, the finish
1452 will carry them entirely through the vfork & exec.
1454 We don't want to allow a bp_finish to remain inserted now. But
1455 we can't safely delete it, 'cause finish_command has a handle to
1456 the bp on a bpstat, and will later want to delete it. There's a
1457 chance (and I've seen it happen) that if we delete the bp_finish
1458 here, that its storage will get reused by the time finish_command
1459 gets 'round to deleting the "use to be a bp_finish" breakpoint.
1460 We really must allow finish_command to delete a bp_finish.
1462 In the absense of a general solution for the "how do we know
1463 it's safe to delete something others may have handles to?"
1464 problem, what we'll do here is just uninsert the bp_finish, and
1465 let finish_command delete it.
1467 (We know the bp_finish is "doomed" in the sense that it's
1468 momentary, and will be deleted as soon as finish_command sees
1469 the inferior stopped. So it doesn't matter that the bp's
1470 address is probably bogus in the new a.out, unlike e.g., the
1471 solib breakpoints.) */
1473 if (b
->type
== bp_finish
)
1478 /* Without a symbolic address, we have little hope of the
1479 pre-exec() address meaning the same thing in the post-exec()
1481 if (b
->addr_string
== NULL
)
1483 delete_breakpoint (b
);
1487 /* If this breakpoint has survived the above battery of checks, then
1488 it must have a symbolic address. Be sure that it gets reevaluated
1489 to a target address, rather than reusing the old evaluation.
1491 Jim Blandy <jimb@redhat.com>: As explained above in the comment
1492 for bp_catch_exec and friends, I'm pretty sure this is entirely
1493 unnecessary. A call to breakpoint_re_set_one always recomputes
1494 the breakpoint's address from scratch, or deletes it if it can't.
1495 So I think this assignment could be deleted without effect. */
1496 b
->loc
->address
= (CORE_ADDR
) 0;
1498 /* FIXME what about longjmp breakpoints? Re-create them here? */
1499 create_overlay_event_breakpoint ("_ovly_debug_event");
1503 detach_breakpoints (int pid
)
1505 struct bp_location
*b
;
1507 struct cleanup
*old_chain
= save_inferior_ptid ();
1509 if (pid
== PIDGET (inferior_ptid
))
1510 error (_("Cannot detach breakpoints of inferior_ptid"));
1512 /* Set inferior_ptid; remove_breakpoint uses this global. */
1513 inferior_ptid
= pid_to_ptid (pid
);
1514 ALL_BP_LOCATIONS (b
)
1518 val
= remove_breakpoint (b
, mark_inserted
);
1521 do_cleanups (old_chain
);
1526 do_cleanups (old_chain
);
1531 remove_breakpoint (struct bp_location
*b
, insertion_state_t is
)
1535 if (b
->owner
->enable_state
== bp_permanent
)
1536 /* Permanent breakpoints cannot be inserted or removed. */
1539 if (b
->owner
->type
== bp_none
)
1540 warning (_("attempted to remove apparently deleted breakpoint #%d?"),
1543 if (b
->loc_type
== bp_loc_software_breakpoint
1544 || b
->loc_type
== bp_loc_hardware_breakpoint
)
1546 /* "Normal" instruction breakpoint: either the standard
1547 trap-instruction bp (bp_breakpoint), or a
1548 bp_hardware_breakpoint. */
1550 /* First check to see if we have to handle an overlay. */
1551 if (overlay_debugging
== ovly_off
1552 || b
->section
== NULL
1553 || !(section_is_overlay (b
->section
)))
1555 /* No overlay handling: just remove the breakpoint. */
1557 if (b
->loc_type
== bp_loc_hardware_breakpoint
)
1558 val
= target_remove_hw_breakpoint (&b
->target_info
);
1560 val
= target_remove_breakpoint (&b
->target_info
);
1564 /* This breakpoint is in an overlay section.
1565 Did we set a breakpoint at the LMA? */
1566 if (!overlay_events_enabled
)
1568 /* Yes -- overlay event support is not active, so we
1569 should have set a breakpoint at the LMA. Remove it.
1571 /* Ignore any failures: if the LMA is in ROM, we will
1572 have already warned when we failed to insert it. */
1573 if (b
->loc_type
== bp_loc_hardware_breakpoint
)
1574 target_remove_hw_breakpoint (&b
->overlay_target_info
);
1576 target_remove_breakpoint (&b
->overlay_target_info
);
1578 /* Did we set a breakpoint at the VMA?
1579 If so, we will have marked the breakpoint 'inserted'. */
1582 /* Yes -- remove it. Previously we did not bother to
1583 remove the breakpoint if the section had been
1584 unmapped, but let's not rely on that being safe. We
1585 don't know what the overlay manager might do. */
1586 if (b
->loc_type
== bp_loc_hardware_breakpoint
)
1587 val
= target_remove_hw_breakpoint (&b
->target_info
);
1589 val
= target_remove_breakpoint (&b
->target_info
);
1593 /* No -- not inserted, so no need to remove. No error. */
1599 b
->inserted
= (is
== mark_inserted
);
1601 else if (b
->loc_type
== bp_loc_hardware_watchpoint
1602 && breakpoint_enabled (b
->owner
)
1608 b
->inserted
= (is
== mark_inserted
);
1609 /* Walk down the saved value chain. */
1610 for (v
= b
->owner
->val_chain
; v
; v
= value_next (v
))
1612 /* For each memory reference remove the watchpoint
1614 if (VALUE_LVAL (v
) == lval_memory
1615 && ! value_lazy (v
))
1617 struct type
*vtype
= check_typedef (value_type (v
));
1619 if (v
== b
->owner
->val_chain
1620 || (TYPE_CODE (vtype
) != TYPE_CODE_STRUCT
1621 && TYPE_CODE (vtype
) != TYPE_CODE_ARRAY
))
1626 addr
= VALUE_ADDRESS (v
) + value_offset (v
);
1627 len
= TYPE_LENGTH (value_type (v
));
1629 if (b
->owner
->type
== bp_read_watchpoint
)
1631 else if (b
->owner
->type
== bp_access_watchpoint
)
1634 val
= target_remove_watchpoint (addr
, len
, type
);
1641 /* Failure to remove any of the hardware watchpoints comes here. */
1642 if ((is
== mark_uninserted
) && (b
->inserted
))
1643 warning (_("Could not remove hardware watchpoint %d."),
1646 else if ((b
->owner
->type
== bp_catch_fork
||
1647 b
->owner
->type
== bp_catch_vfork
||
1648 b
->owner
->type
== bp_catch_exec
)
1649 && breakpoint_enabled (b
->owner
)
1653 switch (b
->owner
->type
)
1656 val
= target_remove_fork_catchpoint (PIDGET (inferior_ptid
));
1658 case bp_catch_vfork
:
1659 val
= target_remove_vfork_catchpoint (PIDGET (inferior_ptid
));
1662 val
= target_remove_exec_catchpoint (PIDGET (inferior_ptid
));
1665 warning (_("Internal error, %s line %d."), __FILE__
, __LINE__
);
1670 b
->inserted
= (is
== mark_inserted
);
1672 else if ((b
->owner
->type
== bp_catch_catch
||
1673 b
->owner
->type
== bp_catch_throw
)
1674 && breakpoint_enabled (b
->owner
)
1677 val
= target_remove_breakpoint (&b
->target_info
);
1680 b
->inserted
= (is
== mark_inserted
);
1686 /* Clear the "inserted" flag in all breakpoints. */
1689 mark_breakpoints_out (void)
1691 struct bp_location
*bpt
;
1693 ALL_BP_LOCATIONS (bpt
)
1697 /* Clear the "inserted" flag in all breakpoints and delete any
1698 breakpoints which should go away between runs of the program.
1700 Plus other such housekeeping that has to be done for breakpoints
1703 Note: this function gets called at the end of a run (by
1704 generic_mourn_inferior) and when a run begins (by
1705 init_wait_for_inferior). */
1710 breakpoint_init_inferior (enum inf_context context
)
1712 struct breakpoint
*b
, *temp
;
1713 struct bp_location
*bpt
;
1714 static int warning_needed
= 0;
1716 ALL_BP_LOCATIONS (bpt
)
1719 ALL_BREAKPOINTS_SAFE (b
, temp
)
1724 case bp_watchpoint_scope
:
1726 /* If the call dummy breakpoint is at the entry point it will
1727 cause problems when the inferior is rerun, so we better
1730 Also get rid of scope breakpoints. */
1731 delete_breakpoint (b
);
1735 case bp_hardware_watchpoint
:
1736 case bp_read_watchpoint
:
1737 case bp_access_watchpoint
:
1739 /* Likewise for watchpoints on local expressions. */
1740 if (b
->exp_valid_block
!= NULL
)
1741 delete_breakpoint (b
);
1742 if (context
== inf_starting
)
1744 /* Reset val field to force reread of starting value
1745 in insert_breakpoints. */
1747 value_free (b
->val
);
1752 /* Likewise for exception catchpoints in dynamic-linked
1753 executables where required */
1754 if (ep_is_exception_catchpoint (b
)
1755 && deprecated_exception_catchpoints_are_fragile
)
1758 delete_breakpoint (b
);
1764 if (deprecated_exception_catchpoints_are_fragile
)
1765 deprecated_exception_support_initialized
= 0;
1767 /* Don't issue the warning unless it's really needed... */
1768 if (warning_needed
&& (context
!= inf_exited
))
1770 warning (_("Exception catchpoints from last run were deleted.\n"
1771 "You must reinsert them explicitly."));
1776 /* breakpoint_here_p (PC) returns non-zero if an enabled breakpoint
1777 exists at PC. It returns ordinary_breakpoint_here if it's an
1778 ordinary breakpoint, or permanent_breakpoint_here if it's a
1779 permanent breakpoint.
1780 - When continuing from a location with an ordinary breakpoint, we
1781 actually single step once before calling insert_breakpoints.
1782 - When continuing from a localion with a permanent breakpoint, we
1783 need to use the `SKIP_PERMANENT_BREAKPOINT' macro, provided by
1784 the target, to advance the PC past the breakpoint. */
1786 enum breakpoint_here
1787 breakpoint_here_p (CORE_ADDR pc
)
1789 struct bp_location
*bpt
;
1790 int any_breakpoint_here
= 0;
1792 ALL_BP_LOCATIONS (bpt
)
1794 if (bpt
->loc_type
!= bp_loc_software_breakpoint
1795 && bpt
->loc_type
!= bp_loc_hardware_breakpoint
)
1798 if ((breakpoint_enabled (bpt
->owner
)
1799 || bpt
->owner
->enable_state
== bp_permanent
)
1800 && bpt
->address
== pc
) /* bp is enabled and matches pc */
1802 if (overlay_debugging
1803 && section_is_overlay (bpt
->section
)
1804 && !section_is_mapped (bpt
->section
))
1805 continue; /* unmapped overlay -- can't be a match */
1806 else if (bpt
->owner
->enable_state
== bp_permanent
)
1807 return permanent_breakpoint_here
;
1809 any_breakpoint_here
= 1;
1813 return any_breakpoint_here
? ordinary_breakpoint_here
: 0;
1817 /* breakpoint_inserted_here_p (PC) is just like breakpoint_here_p(),
1818 but it only returns true if there is actually a breakpoint inserted
1822 breakpoint_inserted_here_p (CORE_ADDR pc
)
1824 struct bp_location
*bpt
;
1826 ALL_BP_LOCATIONS (bpt
)
1828 if (bpt
->loc_type
!= bp_loc_software_breakpoint
1829 && bpt
->loc_type
!= bp_loc_hardware_breakpoint
)
1833 && bpt
->address
== pc
) /* bp is inserted and matches pc */
1835 if (overlay_debugging
1836 && section_is_overlay (bpt
->section
)
1837 && !section_is_mapped (bpt
->section
))
1838 continue; /* unmapped overlay -- can't be a match */
1847 /* This function returns non-zero iff there is a software breakpoint
1851 software_breakpoint_inserted_here_p (CORE_ADDR pc
)
1853 struct bp_location
*bpt
;
1854 int any_breakpoint_here
= 0;
1856 ALL_BP_LOCATIONS (bpt
)
1858 if (bpt
->loc_type
!= bp_loc_software_breakpoint
)
1861 if ((breakpoint_enabled (bpt
->owner
)
1862 || bpt
->owner
->enable_state
== bp_permanent
)
1864 && bpt
->address
== pc
) /* bp is enabled and matches pc */
1866 if (overlay_debugging
1867 && section_is_overlay (bpt
->section
)
1868 && !section_is_mapped (bpt
->section
))
1869 continue; /* unmapped overlay -- can't be a match */
1878 /* breakpoint_thread_match (PC, PTID) returns true if the breakpoint at
1879 PC is valid for process/thread PTID. */
1882 breakpoint_thread_match (CORE_ADDR pc
, ptid_t ptid
)
1884 struct bp_location
*bpt
;
1887 thread
= pid_to_thread_id (ptid
);
1889 ALL_BP_LOCATIONS (bpt
)
1891 if (bpt
->loc_type
!= bp_loc_software_breakpoint
1892 && bpt
->loc_type
!= bp_loc_hardware_breakpoint
)
1895 if ((breakpoint_enabled (bpt
->owner
)
1896 || bpt
->owner
->enable_state
== bp_permanent
)
1897 && bpt
->address
== pc
1898 && (bpt
->owner
->thread
== -1 || bpt
->owner
->thread
== thread
))
1900 if (overlay_debugging
1901 && section_is_overlay (bpt
->section
)
1902 && !section_is_mapped (bpt
->section
))
1903 continue; /* unmapped overlay -- can't be a match */
1913 /* bpstat stuff. External routines' interfaces are documented
1917 ep_is_catchpoint (struct breakpoint
*ep
)
1920 (ep
->type
== bp_catch_load
)
1921 || (ep
->type
== bp_catch_unload
)
1922 || (ep
->type
== bp_catch_fork
)
1923 || (ep
->type
== bp_catch_vfork
)
1924 || (ep
->type
== bp_catch_exec
)
1925 || (ep
->type
== bp_catch_catch
)
1926 || (ep
->type
== bp_catch_throw
);
1928 /* ??rehrauer: Add more kinds here, as are implemented... */
1932 ep_is_shlib_catchpoint (struct breakpoint
*ep
)
1935 (ep
->type
== bp_catch_load
)
1936 || (ep
->type
== bp_catch_unload
);
1940 ep_is_exception_catchpoint (struct breakpoint
*ep
)
1943 (ep
->type
== bp_catch_catch
)
1944 || (ep
->type
== bp_catch_throw
);
1947 /* Clear a bpstat so that it says we are not at any breakpoint.
1948 Also free any storage that is part of a bpstat. */
1951 bpstat_clear (bpstat
*bsp
)
1962 if (p
->old_val
!= NULL
)
1963 value_free (p
->old_val
);
1964 free_command_lines (&p
->commands
);
1971 /* Return a copy of a bpstat. Like "bs1 = bs2" but all storage that
1972 is part of the bpstat is copied as well. */
1975 bpstat_copy (bpstat bs
)
1979 bpstat retval
= NULL
;
1984 for (; bs
!= NULL
; bs
= bs
->next
)
1986 tmp
= (bpstat
) xmalloc (sizeof (*tmp
));
1987 memcpy (tmp
, bs
, sizeof (*tmp
));
1988 if (bs
->commands
!= NULL
)
1989 tmp
->commands
= copy_command_lines (bs
->commands
);
1990 if (bs
->old_val
!= NULL
)
1991 tmp
->old_val
= value_copy (bs
->old_val
);
1994 /* This is the first thing in the chain. */
2004 /* Find the bpstat associated with this breakpoint */
2007 bpstat_find_breakpoint (bpstat bsp
, struct breakpoint
*breakpoint
)
2012 for (; bsp
!= NULL
; bsp
= bsp
->next
)
2014 if (bsp
->breakpoint_at
== breakpoint
)
2020 /* Find a step_resume breakpoint associated with this bpstat.
2021 (If there are multiple step_resume bp's on the list, this function
2022 will arbitrarily pick one.)
2024 It is an error to use this function if BPSTAT doesn't contain a
2025 step_resume breakpoint.
2027 See wait_for_inferior's use of this function. */
2029 bpstat_find_step_resume_breakpoint (bpstat bsp
)
2033 gdb_assert (bsp
!= NULL
);
2035 current_thread
= pid_to_thread_id (inferior_ptid
);
2037 for (; bsp
!= NULL
; bsp
= bsp
->next
)
2039 if ((bsp
->breakpoint_at
!= NULL
) &&
2040 (bsp
->breakpoint_at
->type
== bp_step_resume
) &&
2041 (bsp
->breakpoint_at
->thread
== current_thread
||
2042 bsp
->breakpoint_at
->thread
== -1))
2043 return bsp
->breakpoint_at
;
2046 internal_error (__FILE__
, __LINE__
, _("No step_resume breakpoint found."));
2050 /* Put in *NUM the breakpoint number of the first breakpoint we are stopped
2051 at. *BSP upon return is a bpstat which points to the remaining
2052 breakpoints stopped at (but which is not guaranteed to be good for
2053 anything but further calls to bpstat_num).
2054 Return 0 if passed a bpstat which does not indicate any breakpoints.
2055 Return -1 if stopped at a breakpoint that has been deleted since
2057 Return 1 otherwise. */
2060 bpstat_num (bpstat
*bsp
, int *num
)
2062 struct breakpoint
*b
;
2065 return 0; /* No more breakpoint values */
2067 b
= (*bsp
)->breakpoint_at
;
2068 *bsp
= (*bsp
)->next
;
2070 return -1; /* breakpoint that's been deleted since */
2072 *num
= b
->number
; /* We have its number */
2076 /* Modify BS so that the actions will not be performed. */
2079 bpstat_clear_actions (bpstat bs
)
2081 for (; bs
!= NULL
; bs
= bs
->next
)
2083 free_command_lines (&bs
->commands
);
2084 if (bs
->old_val
!= NULL
)
2086 value_free (bs
->old_val
);
2092 /* Stub for cleaning up our state if we error-out of a breakpoint command */
2094 cleanup_executing_breakpoints (void *ignore
)
2096 executing_breakpoint_commands
= 0;
2099 /* Execute all the commands associated with all the breakpoints at this
2100 location. Any of these commands could cause the process to proceed
2101 beyond this point, etc. We look out for such changes by checking
2102 the global "breakpoint_proceeded" after each command. */
2105 bpstat_do_actions (bpstat
*bsp
)
2108 struct cleanup
*old_chain
;
2110 /* Avoid endless recursion if a `source' command is contained
2112 if (executing_breakpoint_commands
)
2115 executing_breakpoint_commands
= 1;
2116 old_chain
= make_cleanup (cleanup_executing_breakpoints
, 0);
2119 /* Note that (as of this writing), our callers all appear to
2120 be passing us the address of global stop_bpstat. And, if
2121 our calls to execute_control_command cause the inferior to
2122 proceed, that global (and hence, *bsp) will change.
2124 We must be careful to not touch *bsp unless the inferior
2125 has not proceeded. */
2127 /* This pointer will iterate over the list of bpstat's. */
2130 breakpoint_proceeded
= 0;
2131 for (; bs
!= NULL
; bs
= bs
->next
)
2133 struct command_line
*cmd
;
2134 struct cleanup
*this_cmd_tree_chain
;
2136 /* Take ownership of the BSP's command tree, if it has one.
2138 The command tree could legitimately contain commands like
2139 'step' and 'next', which call clear_proceed_status, which
2140 frees stop_bpstat's command tree. To make sure this doesn't
2141 free the tree we're executing out from under us, we need to
2142 take ownership of the tree ourselves. Since a given bpstat's
2143 commands are only executed once, we don't need to copy it; we
2144 can clear the pointer in the bpstat, and make sure we free
2145 the tree when we're done. */
2148 this_cmd_tree_chain
= make_cleanup_free_command_lines (&cmd
);
2152 execute_control_command (cmd
);
2154 if (breakpoint_proceeded
)
2160 /* We can free this command tree now. */
2161 do_cleanups (this_cmd_tree_chain
);
2163 if (breakpoint_proceeded
)
2164 /* The inferior is proceeded by the command; bomb out now.
2165 The bpstat chain has been blown away by wait_for_inferior.
2166 But since execution has stopped again, there is a new bpstat
2167 to look at, so start over. */
2170 do_cleanups (old_chain
);
2173 /* This is the normal print function for a bpstat. In the future,
2174 much of this logic could (should?) be moved to bpstat_stop_status,
2175 by having it set different print_it values.
2177 Current scheme: When we stop, bpstat_print() is called. It loops
2178 through the bpstat list of things causing this stop, calling the
2179 print_bp_stop_message function on each one. The behavior of the
2180 print_bp_stop_message function depends on the print_it field of
2181 bpstat. If such field so indicates, call this function here.
2183 Return values from this routine (ultimately used by bpstat_print()
2184 and normal_stop() to decide what to do):
2185 PRINT_NOTHING: Means we already printed all we needed to print,
2186 don't print anything else.
2187 PRINT_SRC_ONLY: Means we printed something, and we do *not* desire
2188 that something to be followed by a location.
2189 PRINT_SCR_AND_LOC: Means we printed something, and we *do* desire
2190 that something to be followed by a location.
2191 PRINT_UNKNOWN: Means we printed nothing or we need to do some more
2194 static enum print_stop_action
2195 print_it_typical (bpstat bs
)
2197 struct cleanup
*old_chain
, *ui_out_chain
;
2198 struct ui_stream
*stb
;
2199 stb
= ui_out_stream_new (uiout
);
2200 old_chain
= make_cleanup_ui_out_stream_delete (stb
);
2201 /* bs->breakpoint_at can be NULL if it was a momentary breakpoint
2202 which has since been deleted. */
2203 if (bs
->breakpoint_at
== NULL
)
2204 return PRINT_UNKNOWN
;
2206 switch (bs
->breakpoint_at
->type
)
2209 case bp_hardware_breakpoint
:
2210 if (bs
->breakpoint_at
->loc
->address
!= bs
->breakpoint_at
->loc
->requested_address
)
2211 breakpoint_adjustment_warning (bs
->breakpoint_at
->loc
->requested_address
,
2212 bs
->breakpoint_at
->loc
->address
,
2213 bs
->breakpoint_at
->number
, 1);
2214 annotate_breakpoint (bs
->breakpoint_at
->number
);
2215 ui_out_text (uiout
, "\nBreakpoint ");
2216 if (ui_out_is_mi_like_p (uiout
))
2217 ui_out_field_string (uiout
, "reason",
2218 async_reason_lookup (EXEC_ASYNC_BREAKPOINT_HIT
));
2219 ui_out_field_int (uiout
, "bkptno", bs
->breakpoint_at
->number
);
2220 ui_out_text (uiout
, ", ");
2221 return PRINT_SRC_AND_LOC
;
2224 case bp_shlib_event
:
2225 /* Did we stop because the user set the stop_on_solib_events
2226 variable? (If so, we report this as a generic, "Stopped due
2227 to shlib event" message.) */
2228 printf_filtered (_("Stopped due to shared library event\n"));
2229 return PRINT_NOTHING
;
2232 case bp_thread_event
:
2233 /* Not sure how we will get here.
2234 GDB should not stop for these breakpoints. */
2235 printf_filtered (_("Thread Event Breakpoint: gdb should not stop!\n"));
2236 return PRINT_NOTHING
;
2239 case bp_overlay_event
:
2240 /* By analogy with the thread event, GDB should not stop for these. */
2241 printf_filtered (_("Overlay Event Breakpoint: gdb should not stop!\n"));
2242 return PRINT_NOTHING
;
2246 annotate_catchpoint (bs
->breakpoint_at
->number
);
2247 printf_filtered (_("\nCatchpoint %d (loaded %s), "),
2248 bs
->breakpoint_at
->number
,
2249 bs
->breakpoint_at
->triggered_dll_pathname
);
2250 return PRINT_SRC_AND_LOC
;
2253 case bp_catch_unload
:
2254 annotate_catchpoint (bs
->breakpoint_at
->number
);
2255 printf_filtered (_("\nCatchpoint %d (unloaded %s), "),
2256 bs
->breakpoint_at
->number
,
2257 bs
->breakpoint_at
->triggered_dll_pathname
);
2258 return PRINT_SRC_AND_LOC
;
2262 annotate_catchpoint (bs
->breakpoint_at
->number
);
2263 printf_filtered (_("\nCatchpoint %d (forked process %d), "),
2264 bs
->breakpoint_at
->number
,
2265 bs
->breakpoint_at
->forked_inferior_pid
);
2266 return PRINT_SRC_AND_LOC
;
2269 case bp_catch_vfork
:
2270 annotate_catchpoint (bs
->breakpoint_at
->number
);
2271 printf_filtered (_("\nCatchpoint %d (vforked process %d), "),
2272 bs
->breakpoint_at
->number
,
2273 bs
->breakpoint_at
->forked_inferior_pid
);
2274 return PRINT_SRC_AND_LOC
;
2278 annotate_catchpoint (bs
->breakpoint_at
->number
);
2279 printf_filtered (_("\nCatchpoint %d (exec'd %s), "),
2280 bs
->breakpoint_at
->number
,
2281 bs
->breakpoint_at
->exec_pathname
);
2282 return PRINT_SRC_AND_LOC
;
2285 case bp_catch_catch
:
2286 if (current_exception_event
&&
2287 (CURRENT_EXCEPTION_KIND
== EX_EVENT_CATCH
))
2289 annotate_catchpoint (bs
->breakpoint_at
->number
);
2290 printf_filtered (_("\nCatchpoint %d (exception caught), "),
2291 bs
->breakpoint_at
->number
);
2292 if (CURRENT_EXCEPTION_THROW_PC
&& CURRENT_EXCEPTION_THROW_LINE
)
2293 printf_filtered (_("throw location %s:%d, "),
2294 CURRENT_EXCEPTION_THROW_FILE
,
2295 CURRENT_EXCEPTION_THROW_LINE
);
2297 printf_filtered (_("throw location unknown, "));
2299 if (CURRENT_EXCEPTION_CATCH_PC
&& CURRENT_EXCEPTION_CATCH_LINE
)
2300 printf_filtered (_("catch location %s:%d\n"),
2301 CURRENT_EXCEPTION_CATCH_FILE
,
2302 CURRENT_EXCEPTION_CATCH_LINE
);
2304 printf_filtered (_("catch location unknown\n"));
2306 /* don't bother to print location frame info */
2307 return PRINT_SRC_ONLY
;
2311 /* really throw, some other bpstat will handle it */
2312 return PRINT_UNKNOWN
;
2316 case bp_catch_throw
:
2317 if (current_exception_event
&&
2318 (CURRENT_EXCEPTION_KIND
== EX_EVENT_THROW
))
2320 annotate_catchpoint (bs
->breakpoint_at
->number
);
2321 printf_filtered (_("\nCatchpoint %d (exception thrown), "),
2322 bs
->breakpoint_at
->number
);
2323 if (CURRENT_EXCEPTION_THROW_PC
&& CURRENT_EXCEPTION_THROW_LINE
)
2324 printf_filtered (_("throw location %s:%d, "),
2325 CURRENT_EXCEPTION_THROW_FILE
,
2326 CURRENT_EXCEPTION_THROW_LINE
);
2328 printf_filtered (_("throw location unknown, "));
2330 if (CURRENT_EXCEPTION_CATCH_PC
&& CURRENT_EXCEPTION_CATCH_LINE
)
2331 printf_filtered (_("catch location %s:%d\n"),
2332 CURRENT_EXCEPTION_CATCH_FILE
,
2333 CURRENT_EXCEPTION_CATCH_LINE
);
2335 printf_filtered (_("catch location unknown\n"));
2337 /* don't bother to print location frame info */
2338 return PRINT_SRC_ONLY
;
2342 /* really catch, some other bpstat will handle it */
2343 return PRINT_UNKNOWN
;
2348 case bp_hardware_watchpoint
:
2349 if (bs
->old_val
!= NULL
)
2351 annotate_watchpoint (bs
->breakpoint_at
->number
);
2352 if (ui_out_is_mi_like_p (uiout
))
2355 async_reason_lookup (EXEC_ASYNC_WATCHPOINT_TRIGGER
));
2356 mention (bs
->breakpoint_at
);
2357 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "value");
2358 ui_out_text (uiout
, "\nOld value = ");
2359 value_print (bs
->old_val
, stb
->stream
, 0, Val_pretty_default
);
2360 ui_out_field_stream (uiout
, "old", stb
);
2361 ui_out_text (uiout
, "\nNew value = ");
2362 value_print (bs
->breakpoint_at
->val
, stb
->stream
, 0, Val_pretty_default
);
2363 ui_out_field_stream (uiout
, "new", stb
);
2364 do_cleanups (ui_out_chain
);
2365 ui_out_text (uiout
, "\n");
2366 value_free (bs
->old_val
);
2369 /* More than one watchpoint may have been triggered. */
2370 return PRINT_UNKNOWN
;
2373 case bp_read_watchpoint
:
2374 if (ui_out_is_mi_like_p (uiout
))
2377 async_reason_lookup (EXEC_ASYNC_READ_WATCHPOINT_TRIGGER
));
2378 mention (bs
->breakpoint_at
);
2379 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "value");
2380 ui_out_text (uiout
, "\nValue = ");
2381 value_print (bs
->breakpoint_at
->val
, stb
->stream
, 0, Val_pretty_default
);
2382 ui_out_field_stream (uiout
, "value", stb
);
2383 do_cleanups (ui_out_chain
);
2384 ui_out_text (uiout
, "\n");
2385 return PRINT_UNKNOWN
;
2388 case bp_access_watchpoint
:
2389 if (bs
->old_val
!= NULL
)
2391 annotate_watchpoint (bs
->breakpoint_at
->number
);
2392 if (ui_out_is_mi_like_p (uiout
))
2395 async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER
));
2396 mention (bs
->breakpoint_at
);
2397 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "value");
2398 ui_out_text (uiout
, "\nOld value = ");
2399 value_print (bs
->old_val
, stb
->stream
, 0, Val_pretty_default
);
2400 ui_out_field_stream (uiout
, "old", stb
);
2401 value_free (bs
->old_val
);
2403 ui_out_text (uiout
, "\nNew value = ");
2407 mention (bs
->breakpoint_at
);
2408 if (ui_out_is_mi_like_p (uiout
))
2411 async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER
));
2412 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "value");
2413 ui_out_text (uiout
, "\nValue = ");
2415 value_print (bs
->breakpoint_at
->val
, stb
->stream
, 0,Val_pretty_default
);
2416 ui_out_field_stream (uiout
, "new", stb
);
2417 do_cleanups (ui_out_chain
);
2418 ui_out_text (uiout
, "\n");
2419 return PRINT_UNKNOWN
;
2422 /* Fall through, we don't deal with these types of breakpoints
2426 if (ui_out_is_mi_like_p (uiout
))
2429 async_reason_lookup (EXEC_ASYNC_FUNCTION_FINISHED
));
2430 return PRINT_UNKNOWN
;
2434 if (ui_out_is_mi_like_p (uiout
))
2437 async_reason_lookup (EXEC_ASYNC_LOCATION_REACHED
));
2438 return PRINT_UNKNOWN
;
2443 case bp_longjmp_resume
:
2444 case bp_step_resume
:
2445 case bp_watchpoint_scope
:
2448 return PRINT_UNKNOWN
;
2452 /* Generic routine for printing messages indicating why we
2453 stopped. The behavior of this function depends on the value
2454 'print_it' in the bpstat structure. Under some circumstances we
2455 may decide not to print anything here and delegate the task to
2458 static enum print_stop_action
2459 print_bp_stop_message (bpstat bs
)
2461 switch (bs
->print_it
)
2464 /* Nothing should be printed for this bpstat entry. */
2465 return PRINT_UNKNOWN
;
2469 /* We still want to print the frame, but we already printed the
2470 relevant messages. */
2471 return PRINT_SRC_AND_LOC
;
2474 case print_it_normal
:
2475 /* Normal case. Call the breakpoint's print_it method, or
2476 print_it_typical. */
2477 if (bs
->breakpoint_at
!= NULL
&& bs
->breakpoint_at
->ops
!= NULL
2478 && bs
->breakpoint_at
->ops
->print_it
!= NULL
)
2479 return bs
->breakpoint_at
->ops
->print_it (bs
->breakpoint_at
);
2481 return print_it_typical (bs
);
2485 internal_error (__FILE__
, __LINE__
,
2486 _("print_bp_stop_message: unrecognized enum value"));
2491 /* Print a message indicating what happened. This is called from
2492 normal_stop(). The input to this routine is the head of the bpstat
2493 list - a list of the eventpoints that caused this stop. This
2494 routine calls the generic print routine for printing a message
2495 about reasons for stopping. This will print (for example) the
2496 "Breakpoint n," part of the output. The return value of this
2499 PRINT_UNKNOWN: Means we printed nothing
2500 PRINT_SRC_AND_LOC: Means we printed something, and expect subsequent
2501 code to print the location. An example is
2502 "Breakpoint 1, " which should be followed by
2504 PRINT_SRC_ONLY: Means we printed something, but there is no need
2505 to also print the location part of the message.
2506 An example is the catch/throw messages, which
2507 don't require a location appended to the end.
2508 PRINT_NOTHING: We have done some printing and we don't need any
2509 further info to be printed.*/
2511 enum print_stop_action
2512 bpstat_print (bpstat bs
)
2516 /* Maybe another breakpoint in the chain caused us to stop.
2517 (Currently all watchpoints go on the bpstat whether hit or not.
2518 That probably could (should) be changed, provided care is taken
2519 with respect to bpstat_explains_signal). */
2520 for (; bs
; bs
= bs
->next
)
2522 val
= print_bp_stop_message (bs
);
2523 if (val
== PRINT_SRC_ONLY
2524 || val
== PRINT_SRC_AND_LOC
2525 || val
== PRINT_NOTHING
)
2529 /* We reached the end of the chain, or we got a null BS to start
2530 with and nothing was printed. */
2531 return PRINT_UNKNOWN
;
2534 /* Evaluate the expression EXP and return 1 if value is zero.
2535 This is used inside a catch_errors to evaluate the breakpoint condition.
2536 The argument is a "struct expression *" that has been cast to char * to
2537 make it pass through catch_errors. */
2540 breakpoint_cond_eval (void *exp
)
2542 struct value
*mark
= value_mark ();
2543 int i
= !value_true (evaluate_expression ((struct expression
*) exp
));
2544 value_free_to_mark (mark
);
2548 /* Allocate a new bpstat and chain it to the current one. */
2551 bpstat_alloc (struct breakpoint
*b
, bpstat cbs
/* Current "bs" value */ )
2555 bs
= (bpstat
) xmalloc (sizeof (*bs
));
2557 bs
->breakpoint_at
= b
;
2558 /* If the condition is false, etc., don't do the commands. */
2559 bs
->commands
= NULL
;
2561 bs
->print_it
= print_it_normal
;
2565 /* Possible return values for watchpoint_check (this can't be an enum
2566 because of check_errors). */
2567 /* The watchpoint has been deleted. */
2568 #define WP_DELETED 1
2569 /* The value has changed. */
2570 #define WP_VALUE_CHANGED 2
2571 /* The value has not changed. */
2572 #define WP_VALUE_NOT_CHANGED 3
2574 #define BP_TEMPFLAG 1
2575 #define BP_HARDWAREFLAG 2
2577 /* Check watchpoint condition. */
2580 watchpoint_check (void *p
)
2582 bpstat bs
= (bpstat
) p
;
2583 struct breakpoint
*b
;
2584 struct frame_info
*fr
;
2585 int within_current_scope
;
2587 b
= bs
->breakpoint_at
;
2589 if (b
->exp_valid_block
== NULL
)
2590 within_current_scope
= 1;
2593 /* There is no current frame at this moment. If we're going to have
2594 any chance of handling watchpoints on local variables, we'll need
2595 the frame chain (so we can determine if we're in scope). */
2596 reinit_frame_cache ();
2597 fr
= frame_find_by_id (b
->watchpoint_frame
);
2598 within_current_scope
= (fr
!= NULL
);
2600 /* If we've gotten confused in the unwinder, we might have
2601 returned a frame that can't describe this variable. */
2602 if (within_current_scope
2603 && block_function (b
->exp_valid_block
) != get_frame_function (fr
))
2604 within_current_scope
= 0;
2606 /* in_function_epilogue_p() returns a non-zero value if we're still
2607 in the function but the stack frame has already been invalidated.
2608 Since we can't rely on the values of local variables after the
2609 stack has been destroyed, we are treating the watchpoint in that
2610 state as `not changed' without further checking.
2612 vinschen/2003-09-04: The former implementation left out the case
2613 that the watchpoint frame couldn't be found by frame_find_by_id()
2614 because the current PC is currently in an epilogue. Calling
2615 gdbarch_in_function_epilogue_p() also when fr == NULL fixes that. */
2616 if ((!within_current_scope
|| fr
== get_current_frame ())
2617 && gdbarch_in_function_epilogue_p (current_gdbarch
, read_pc ()))
2618 return WP_VALUE_NOT_CHANGED
;
2619 if (fr
&& within_current_scope
)
2620 /* If we end up stopping, the current frame will get selected
2621 in normal_stop. So this call to select_frame won't affect
2626 if (within_current_scope
)
2628 /* We use value_{,free_to_}mark because it could be a
2629 *long* time before we return to the command level and
2630 call free_all_values. We can't call free_all_values because
2631 we might be in the middle of evaluating a function call. */
2633 struct value
*mark
= value_mark ();
2634 struct value
*new_val
= evaluate_expression (bs
->breakpoint_at
->exp
);
2635 if (!value_equal (b
->val
, new_val
))
2637 release_value (new_val
);
2638 value_free_to_mark (mark
);
2639 bs
->old_val
= b
->val
;
2641 /* We will stop here */
2642 return WP_VALUE_CHANGED
;
2646 /* Nothing changed, don't do anything. */
2647 value_free_to_mark (mark
);
2648 /* We won't stop here */
2649 return WP_VALUE_NOT_CHANGED
;
2654 /* This seems like the only logical thing to do because
2655 if we temporarily ignored the watchpoint, then when
2656 we reenter the block in which it is valid it contains
2657 garbage (in the case of a function, it may have two
2658 garbage values, one before and one after the prologue).
2659 So we can't even detect the first assignment to it and
2660 watch after that (since the garbage may or may not equal
2661 the first value assigned). */
2662 /* We print all the stop information in print_it_typical(), but
2663 in this case, by the time we call print_it_typical() this bp
2664 will be deleted already. So we have no choice but print the
2665 information here. */
2666 if (ui_out_is_mi_like_p (uiout
))
2668 (uiout
, "reason", async_reason_lookup (EXEC_ASYNC_WATCHPOINT_SCOPE
));
2669 ui_out_text (uiout
, "\nWatchpoint ");
2670 ui_out_field_int (uiout
, "wpnum", bs
->breakpoint_at
->number
);
2671 ui_out_text (uiout
, " deleted because the program has left the block in\n\
2672 which its expression is valid.\n");
2674 if (b
->related_breakpoint
)
2675 b
->related_breakpoint
->disposition
= disp_del_at_next_stop
;
2676 b
->disposition
= disp_del_at_next_stop
;
2682 /* Get a bpstat associated with having just stopped at address
2683 BP_ADDR in thread PTID. STOPPED_BY_WATCHPOINT is 1 if the
2684 target thinks we stopped due to a hardware watchpoint, 0 if we
2685 know we did not trigger a hardware watchpoint, and -1 if we do not know. */
2687 /* Determine whether we stopped at a breakpoint, etc, or whether we
2688 don't understand this stop. Result is a chain of bpstat's such that:
2690 if we don't understand the stop, the result is a null pointer.
2692 if we understand why we stopped, the result is not null.
2694 Each element of the chain refers to a particular breakpoint or
2695 watchpoint at which we have stopped. (We may have stopped for
2696 several reasons concurrently.)
2698 Each element of the chain has valid next, breakpoint_at,
2699 commands, FIXME??? fields. */
2702 bpstat_stop_status (CORE_ADDR bp_addr
, ptid_t ptid
, int stopped_by_watchpoint
)
2704 struct breakpoint
*b
, *temp
;
2705 /* True if we've hit a breakpoint (as opposed to a watchpoint). */
2706 int real_breakpoint
= 0;
2707 /* Root of the chain of bpstat's */
2708 struct bpstats root_bs
[1];
2709 /* Pointer to the last thing in the chain currently. */
2710 bpstat bs
= root_bs
;
2711 int thread_id
= pid_to_thread_id (ptid
);
2713 ALL_BREAKPOINTS_SAFE (b
, temp
)
2715 if (!breakpoint_enabled (b
) && b
->enable_state
!= bp_permanent
)
2718 if (b
->type
!= bp_watchpoint
2719 && b
->type
!= bp_hardware_watchpoint
2720 && b
->type
!= bp_read_watchpoint
2721 && b
->type
!= bp_access_watchpoint
2722 && b
->type
!= bp_hardware_breakpoint
2723 && b
->type
!= bp_catch_fork
2724 && b
->type
!= bp_catch_vfork
2725 && b
->type
!= bp_catch_exec
2726 && b
->type
!= bp_catch_catch
2727 && b
->type
!= bp_catch_throw
) /* a non-watchpoint bp */
2729 if (b
->loc
->address
!= bp_addr
) /* address doesn't match */
2731 if (overlay_debugging
/* unmapped overlay section */
2732 && section_is_overlay (b
->loc
->section
)
2733 && !section_is_mapped (b
->loc
->section
))
2737 /* Continuable hardware watchpoints are treated as non-existent if the
2738 reason we stopped wasn't a hardware watchpoint (we didn't stop on
2739 some data address). Otherwise gdb won't stop on a break instruction
2740 in the code (not from a breakpoint) when a hardware watchpoint has
2743 if ((b
->type
== bp_hardware_watchpoint
2744 || b
->type
== bp_read_watchpoint
2745 || b
->type
== bp_access_watchpoint
)
2746 && !stopped_by_watchpoint
)
2749 if (b
->type
== bp_hardware_breakpoint
)
2751 if (b
->loc
->address
!= bp_addr
)
2753 if (overlay_debugging
/* unmapped overlay section */
2754 && section_is_overlay (b
->loc
->section
)
2755 && !section_is_mapped (b
->loc
->section
))
2759 /* Is this a catchpoint of a load or unload? If so, did we
2760 get a load or unload of the specified library? If not,
2762 if ((b
->type
== bp_catch_load
)
2763 #if defined(SOLIB_HAVE_LOAD_EVENT)
2764 && (!SOLIB_HAVE_LOAD_EVENT (PIDGET (inferior_ptid
))
2765 || ((b
->dll_pathname
!= NULL
)
2766 && (strcmp (b
->dll_pathname
,
2767 SOLIB_LOADED_LIBRARY_PATHNAME (
2768 PIDGET (inferior_ptid
)))
2774 if ((b
->type
== bp_catch_unload
)
2775 #if defined(SOLIB_HAVE_UNLOAD_EVENT)
2776 && (!SOLIB_HAVE_UNLOAD_EVENT (PIDGET (inferior_ptid
))
2777 || ((b
->dll_pathname
!= NULL
)
2778 && (strcmp (b
->dll_pathname
,
2779 SOLIB_UNLOADED_LIBRARY_PATHNAME (
2780 PIDGET (inferior_ptid
)))
2786 if ((b
->type
== bp_catch_fork
)
2787 && !inferior_has_forked (PIDGET (inferior_ptid
),
2788 &b
->forked_inferior_pid
))
2791 if ((b
->type
== bp_catch_vfork
)
2792 && !inferior_has_vforked (PIDGET (inferior_ptid
),
2793 &b
->forked_inferior_pid
))
2796 if ((b
->type
== bp_catch_exec
)
2797 && !inferior_has_execd (PIDGET (inferior_ptid
), &b
->exec_pathname
))
2800 if (ep_is_exception_catchpoint (b
) &&
2801 !(current_exception_event
= target_get_current_exception_event ()))
2804 /* Come here if it's a watchpoint, or if the break address matches */
2806 bs
= bpstat_alloc (b
, bs
); /* Alloc a bpstat to explain stop */
2808 /* Watchpoints may change this, if not found to have triggered. */
2812 if (b
->type
== bp_watchpoint
||
2813 b
->type
== bp_hardware_watchpoint
)
2815 char *message
= xstrprintf ("Error evaluating expression for watchpoint %d\n",
2817 struct cleanup
*cleanups
= make_cleanup (xfree
, message
);
2818 int e
= catch_errors (watchpoint_check
, bs
, message
,
2820 do_cleanups (cleanups
);
2824 /* We've already printed what needs to be printed. */
2825 /* Actually this is superfluous, because by the time we
2826 call print_it_typical() the wp will be already deleted,
2827 and the function will return immediately. */
2828 bs
->print_it
= print_it_done
;
2831 case WP_VALUE_CHANGED
:
2835 case WP_VALUE_NOT_CHANGED
:
2837 bs
->print_it
= print_it_noop
;
2844 /* Error from catch_errors. */
2845 printf_filtered (_("Watchpoint %d deleted.\n"), b
->number
);
2846 if (b
->related_breakpoint
)
2847 b
->related_breakpoint
->disposition
= disp_del_at_next_stop
;
2848 b
->disposition
= disp_del_at_next_stop
;
2849 /* We've already printed what needs to be printed. */
2850 bs
->print_it
= print_it_done
;
2856 else if (b
->type
== bp_read_watchpoint
||
2857 b
->type
== bp_access_watchpoint
)
2863 if (!target_stopped_data_address (¤t_target
, &addr
))
2865 for (v
= b
->val_chain
; v
; v
= value_next (v
))
2867 if (VALUE_LVAL (v
) == lval_memory
2868 && ! value_lazy (v
))
2870 struct type
*vtype
= check_typedef (value_type (v
));
2872 if (v
== b
->val_chain
2873 || (TYPE_CODE (vtype
) != TYPE_CODE_STRUCT
2874 && TYPE_CODE (vtype
) != TYPE_CODE_ARRAY
))
2878 vaddr
= VALUE_ADDRESS (v
) + value_offset (v
);
2879 /* Exact match not required. Within range is
2881 if (addr
>= vaddr
&&
2882 addr
< vaddr
+ TYPE_LENGTH (value_type (v
)))
2889 char *message
= xstrprintf ("Error evaluating expression for watchpoint %d\n",
2891 struct cleanup
*cleanups
= make_cleanup (xfree
, message
);
2892 int e
= catch_errors (watchpoint_check
, bs
, message
,
2894 do_cleanups (cleanups
);
2898 /* We've already printed what needs to be printed. */
2899 bs
->print_it
= print_it_done
;
2902 case WP_VALUE_CHANGED
:
2903 if (b
->type
== bp_read_watchpoint
)
2905 /* Don't stop: read watchpoints shouldn't fire if
2906 the value has changed. This is for targets
2907 which cannot set read-only watchpoints. */
2908 bs
->print_it
= print_it_noop
;
2914 case WP_VALUE_NOT_CHANGED
:
2921 /* Error from catch_errors. */
2922 printf_filtered (_("Watchpoint %d deleted.\n"), b
->number
);
2923 if (b
->related_breakpoint
)
2924 b
->related_breakpoint
->disposition
= disp_del_at_next_stop
;
2925 b
->disposition
= disp_del_at_next_stop
;
2926 /* We've already printed what needs to be printed. */
2927 bs
->print_it
= print_it_done
;
2931 else /* found == 0 */
2933 /* This is a case where some watchpoint(s) triggered,
2934 but not at the address of this watchpoint (FOUND
2935 was left zero). So don't print anything for this
2937 bs
->print_it
= print_it_noop
;
2944 /* By definition, an encountered breakpoint is a triggered
2948 real_breakpoint
= 1;
2951 if (frame_id_p (b
->frame_id
)
2952 && !frame_id_eq (b
->frame_id
, get_frame_id (get_current_frame ())))
2956 int value_is_zero
= 0;
2960 /* Need to select the frame, with all that implies
2961 so that the conditions will have the right context. */
2962 select_frame (get_current_frame ());
2964 = catch_errors (breakpoint_cond_eval
, (b
->cond
),
2965 "Error in testing breakpoint condition:\n",
2967 /* FIXME-someday, should give breakpoint # */
2970 if (b
->cond
&& value_is_zero
)
2973 /* Don't consider this a hit. */
2976 else if (b
->thread
!= -1 && b
->thread
!= thread_id
)
2979 /* Don't consider this a hit. */
2982 else if (b
->ignore_count
> 0)
2985 annotate_ignore_count_change ();
2990 /* We will stop here */
2991 if (b
->disposition
== disp_disable
)
2992 b
->enable_state
= bp_disabled
;
2995 bs
->commands
= b
->commands
;
2997 (strcmp ("silent", bs
->commands
->line
) == 0
2998 || (xdb_commands
&& strcmp ("Q", bs
->commands
->line
) == 0)))
3000 bs
->commands
= bs
->commands
->next
;
3003 bs
->commands
= copy_command_lines (bs
->commands
);
3006 /* Print nothing for this entry if we dont stop or if we dont print. */
3007 if (bs
->stop
== 0 || bs
->print
== 0)
3008 bs
->print_it
= print_it_noop
;
3011 bs
->next
= NULL
; /* Terminate the chain */
3012 bs
= root_bs
->next
; /* Re-grab the head of the chain */
3014 /* The value of a hardware watchpoint hasn't changed, but the
3015 intermediate memory locations we are watching may have. */
3016 if (bs
&& !bs
->stop
&&
3017 (bs
->breakpoint_at
->type
== bp_hardware_watchpoint
||
3018 bs
->breakpoint_at
->type
== bp_read_watchpoint
||
3019 bs
->breakpoint_at
->type
== bp_access_watchpoint
))
3021 remove_breakpoints ();
3022 insert_breakpoints ();
3027 /* Tell what to do about this bpstat. */
3029 bpstat_what (bpstat bs
)
3031 /* Classify each bpstat as one of the following. */
3034 /* This bpstat element has no effect on the main_action. */
3037 /* There was a watchpoint, stop but don't print. */
3040 /* There was a watchpoint, stop and print. */
3043 /* There was a breakpoint but we're not stopping. */
3046 /* There was a breakpoint, stop but don't print. */
3049 /* There was a breakpoint, stop and print. */
3052 /* We hit the longjmp breakpoint. */
3055 /* We hit the longjmp_resume breakpoint. */
3058 /* We hit the step_resume breakpoint. */
3061 /* We hit the shared library event breakpoint. */
3064 /* We caught a shared library event. */
3067 /* This is just used to count how many enums there are. */
3071 /* Here is the table which drives this routine. So that we can
3072 format it pretty, we define some abbreviations for the
3073 enum bpstat_what codes. */
3074 #define kc BPSTAT_WHAT_KEEP_CHECKING
3075 #define ss BPSTAT_WHAT_STOP_SILENT
3076 #define sn BPSTAT_WHAT_STOP_NOISY
3077 #define sgl BPSTAT_WHAT_SINGLE
3078 #define slr BPSTAT_WHAT_SET_LONGJMP_RESUME
3079 #define clr BPSTAT_WHAT_CLEAR_LONGJMP_RESUME
3080 #define clrs BPSTAT_WHAT_CLEAR_LONGJMP_RESUME_SINGLE
3081 #define sr BPSTAT_WHAT_STEP_RESUME
3082 #define shl BPSTAT_WHAT_CHECK_SHLIBS
3083 #define shlr BPSTAT_WHAT_CHECK_SHLIBS_RESUME_FROM_HOOK
3085 /* "Can't happen." Might want to print an error message.
3086 abort() is not out of the question, but chances are GDB is just
3087 a bit confused, not unusable. */
3088 #define err BPSTAT_WHAT_STOP_NOISY
3090 /* Given an old action and a class, come up with a new action. */
3091 /* One interesting property of this table is that wp_silent is the same
3092 as bp_silent and wp_noisy is the same as bp_noisy. That is because
3093 after stopping, the check for whether to step over a breakpoint
3094 (BPSTAT_WHAT_SINGLE type stuff) is handled in proceed() without
3095 reference to how we stopped. We retain separate wp_silent and
3096 bp_silent codes in case we want to change that someday.
3098 Another possibly interesting property of this table is that
3099 there's a partial ordering, priority-like, of the actions. Once
3100 you've decided that some action is appropriate, you'll never go
3101 back and decide something of a lower priority is better. The
3104 kc < clr sgl shl shlr slr sn sr ss
3105 sgl < clrs shl shlr slr sn sr ss
3106 slr < err shl shlr sn sr ss
3107 clr < clrs err shl shlr sn sr ss
3108 clrs < err shl shlr sn sr ss
3115 What I think this means is that we don't need a damned table
3116 here. If you just put the rows and columns in the right order,
3117 it'd look awfully regular. We could simply walk the bpstat list
3118 and choose the highest priority action we find, with a little
3119 logic to handle the 'err' cases, and the CLEAR_LONGJMP_RESUME/
3120 CLEAR_LONGJMP_RESUME_SINGLE distinction (which breakpoint.h says
3121 is messy anyway). */
3123 /* step_resume entries: a step resume breakpoint overrides another
3124 breakpoint of signal handling (see comment in wait_for_inferior
3125 at where we set the step_resume breakpoint). */
3127 static const enum bpstat_what_main_action
3128 table
[(int) class_last
][(int) BPSTAT_WHAT_LAST
] =
3131 /* kc ss sn sgl slr clr clrs sr shl shlr
3134 {kc
, ss
, sn
, sgl
, slr
, clr
, clrs
, sr
, shl
, shlr
},
3136 {ss
, ss
, sn
, ss
, ss
, ss
, ss
, sr
, shl
, shlr
},
3138 {sn
, sn
, sn
, sn
, sn
, sn
, sn
, sr
, shl
, shlr
},
3140 {sgl
, ss
, sn
, sgl
, slr
, clrs
, clrs
, sr
, shl
, shlr
},
3142 {ss
, ss
, sn
, ss
, ss
, ss
, ss
, sr
, shl
, shlr
},
3144 {sn
, sn
, sn
, sn
, sn
, sn
, sn
, sr
, shl
, shlr
},
3146 {slr
, ss
, sn
, slr
, slr
, err
, err
, sr
, shl
, shlr
},
3148 {clr
, ss
, sn
, clrs
, err
, err
, err
, sr
, shl
, shlr
},
3150 {sr
, sr
, sr
, sr
, sr
, sr
, sr
, sr
, sr
, sr
},
3152 {shl
, shl
, shl
, shl
, shl
, shl
, shl
, sr
, shl
, shlr
},
3154 {shlr
, shlr
, shlr
, shlr
, shlr
, shlr
, shlr
, sr
, shlr
, shlr
}
3169 enum bpstat_what_main_action current_action
= BPSTAT_WHAT_KEEP_CHECKING
;
3170 struct bpstat_what retval
;
3172 retval
.call_dummy
= 0;
3173 for (; bs
!= NULL
; bs
= bs
->next
)
3175 enum class bs_class
= no_effect
;
3176 if (bs
->breakpoint_at
== NULL
)
3177 /* I suspect this can happen if it was a momentary breakpoint
3178 which has since been deleted. */
3180 switch (bs
->breakpoint_at
->type
)
3186 case bp_hardware_breakpoint
:
3192 bs_class
= bp_noisy
;
3194 bs_class
= bp_silent
;
3197 bs_class
= bp_nostop
;
3200 case bp_hardware_watchpoint
:
3201 case bp_read_watchpoint
:
3202 case bp_access_watchpoint
:
3206 bs_class
= wp_noisy
;
3208 bs_class
= wp_silent
;
3211 /* There was a watchpoint, but we're not stopping.
3212 This requires no further action. */
3213 bs_class
= no_effect
;
3216 bs_class
= long_jump
;
3218 case bp_longjmp_resume
:
3219 bs_class
= long_resume
;
3221 case bp_step_resume
:
3224 bs_class
= step_resume
;
3227 /* It is for the wrong frame. */
3228 bs_class
= bp_nostop
;
3230 case bp_watchpoint_scope
:
3231 bs_class
= bp_nostop
;
3233 case bp_shlib_event
:
3234 bs_class
= shlib_event
;
3236 case bp_thread_event
:
3237 case bp_overlay_event
:
3238 bs_class
= bp_nostop
;
3241 case bp_catch_unload
:
3242 /* Only if this catchpoint triggered should we cause the
3243 step-out-of-dld behaviour. Otherwise, we ignore this
3246 bs_class
= catch_shlib_event
;
3248 bs_class
= no_effect
;
3251 case bp_catch_vfork
:
3256 bs_class
= bp_noisy
;
3258 bs_class
= bp_silent
;
3261 /* There was a catchpoint, but we're not stopping.
3262 This requires no further action. */
3263 bs_class
= no_effect
;
3265 case bp_catch_catch
:
3266 if (!bs
->stop
|| CURRENT_EXCEPTION_KIND
!= EX_EVENT_CATCH
)
3267 bs_class
= bp_nostop
;
3269 bs_class
= bs
->print
? bp_noisy
: bp_silent
;
3271 case bp_catch_throw
:
3272 if (!bs
->stop
|| CURRENT_EXCEPTION_KIND
!= EX_EVENT_THROW
)
3273 bs_class
= bp_nostop
;
3275 bs_class
= bs
->print
? bp_noisy
: bp_silent
;
3278 /* Make sure the action is stop (silent or noisy),
3279 so infrun.c pops the dummy frame. */
3280 bs_class
= bp_silent
;
3281 retval
.call_dummy
= 1;
3284 current_action
= table
[(int) bs_class
][(int) current_action
];
3286 retval
.main_action
= current_action
;
3290 /* Nonzero if we should step constantly (e.g. watchpoints on machines
3291 without hardware support). This isn't related to a specific bpstat,
3292 just to things like whether watchpoints are set. */
3295 bpstat_should_step (void)
3297 struct breakpoint
*b
;
3299 if (breakpoint_enabled (b
) && b
->type
== bp_watchpoint
)
3304 /* Nonzero if there are enabled hardware watchpoints. */
3306 bpstat_have_active_hw_watchpoints (void)
3308 struct bp_location
*bpt
;
3309 ALL_BP_LOCATIONS (bpt
)
3310 if (breakpoint_enabled (bpt
->owner
)
3312 && bpt
->loc_type
== bp_loc_hardware_watchpoint
)
3318 /* Given a bpstat that records zero or more triggered eventpoints, this
3319 function returns another bpstat which contains only the catchpoints
3320 on that first list, if any. */
3322 bpstat_get_triggered_catchpoints (bpstat ep_list
, bpstat
*cp_list
)
3324 struct bpstats root_bs
[1];
3325 bpstat bs
= root_bs
;
3326 struct breakpoint
*ep
;
3329 bpstat_clear (cp_list
);
3330 root_bs
->next
= NULL
;
3332 for (; ep_list
!= NULL
; ep_list
= ep_list
->next
)
3334 /* Is this eventpoint a catchpoint? If not, ignore it. */
3335 ep
= ep_list
->breakpoint_at
;
3338 if ((ep
->type
!= bp_catch_load
) &&
3339 (ep
->type
!= bp_catch_unload
) &&
3340 (ep
->type
!= bp_catch_catch
) &&
3341 (ep
->type
!= bp_catch_throw
))
3342 /* pai: (temp) ADD fork/vfork here!! */
3345 /* Yes; add it to the list. */
3346 bs
= bpstat_alloc (ep
, bs
);
3351 #if defined(SOLIB_ADD)
3352 /* Also, for each triggered catchpoint, tag it with the name of
3353 the library that caused this trigger. (We copy the name now,
3354 because it's only guaranteed to be available NOW, when the
3355 catchpoint triggers. Clients who may wish to know the name
3356 later must get it from the catchpoint itself.) */
3357 if (ep
->triggered_dll_pathname
!= NULL
)
3358 xfree (ep
->triggered_dll_pathname
);
3359 if (ep
->type
== bp_catch_load
)
3360 dll_pathname
= SOLIB_LOADED_LIBRARY_PATHNAME (
3361 PIDGET (inferior_ptid
));
3363 dll_pathname
= SOLIB_UNLOADED_LIBRARY_PATHNAME (
3364 PIDGET (inferior_ptid
));
3366 dll_pathname
= NULL
;
3370 ep
->triggered_dll_pathname
= (char *)
3371 xmalloc (strlen (dll_pathname
) + 1);
3372 strcpy (ep
->triggered_dll_pathname
, dll_pathname
);
3375 ep
->triggered_dll_pathname
= NULL
;
3381 /* Print B to gdb_stdout. */
3383 print_one_breakpoint (struct breakpoint
*b
,
3384 CORE_ADDR
*last_addr
)
3386 struct command_line
*l
;
3388 struct ep_type_description
3393 static struct ep_type_description bptypes
[] =
3395 {bp_none
, "?deleted?"},
3396 {bp_breakpoint
, "breakpoint"},
3397 {bp_hardware_breakpoint
, "hw breakpoint"},
3398 {bp_until
, "until"},
3399 {bp_finish
, "finish"},
3400 {bp_watchpoint
, "watchpoint"},
3401 {bp_hardware_watchpoint
, "hw watchpoint"},
3402 {bp_read_watchpoint
, "read watchpoint"},
3403 {bp_access_watchpoint
, "acc watchpoint"},
3404 {bp_longjmp
, "longjmp"},
3405 {bp_longjmp_resume
, "longjmp resume"},
3406 {bp_step_resume
, "step resume"},
3407 {bp_watchpoint_scope
, "watchpoint scope"},
3408 {bp_call_dummy
, "call dummy"},
3409 {bp_shlib_event
, "shlib events"},
3410 {bp_thread_event
, "thread events"},
3411 {bp_overlay_event
, "overlay events"},
3412 {bp_catch_load
, "catch load"},
3413 {bp_catch_unload
, "catch unload"},
3414 {bp_catch_fork
, "catch fork"},
3415 {bp_catch_vfork
, "catch vfork"},
3416 {bp_catch_exec
, "catch exec"},
3417 {bp_catch_catch
, "catch catch"},
3418 {bp_catch_throw
, "catch throw"}
3421 static char *bpdisps
[] =
3422 {"del", "dstp", "dis", "keep"};
3423 static char bpenables
[] = "nynny";
3424 char wrap_indent
[80];
3425 struct ui_stream
*stb
= ui_out_stream_new (uiout
);
3426 struct cleanup
*old_chain
= make_cleanup_ui_out_stream_delete (stb
);
3427 struct cleanup
*bkpt_chain
;
3430 bkpt_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "bkpt");
3434 ui_out_field_int (uiout
, "number", b
->number
);
3438 if (((int) b
->type
> (sizeof (bptypes
) / sizeof (bptypes
[0])))
3439 || ((int) b
->type
!= bptypes
[(int) b
->type
].type
))
3440 internal_error (__FILE__
, __LINE__
,
3441 _("bptypes table does not describe type #%d."),
3443 ui_out_field_string (uiout
, "type", bptypes
[(int) b
->type
].description
);
3447 ui_out_field_string (uiout
, "disp", bpdisps
[(int) b
->disposition
]);
3451 ui_out_field_fmt (uiout
, "enabled", "%c", bpenables
[(int) b
->enable_state
]);
3452 ui_out_spaces (uiout
, 2);
3455 strcpy (wrap_indent
, " ");
3458 if (TARGET_ADDR_BIT
<= 32)
3459 strcat (wrap_indent
, " ");
3461 strcat (wrap_indent
, " ");
3464 if (b
->ops
!= NULL
&& b
->ops
->print_one
!= NULL
)
3465 b
->ops
->print_one (b
, last_addr
);
3470 internal_error (__FILE__
, __LINE__
,
3471 _("print_one_breakpoint: bp_none encountered\n"));
3475 case bp_hardware_watchpoint
:
3476 case bp_read_watchpoint
:
3477 case bp_access_watchpoint
:
3478 /* Field 4, the address, is omitted (which makes the columns
3479 not line up too nicely with the headers, but the effect
3480 is relatively readable). */
3482 ui_out_field_skip (uiout
, "addr");
3484 print_expression (b
->exp
, stb
->stream
);
3485 ui_out_field_stream (uiout
, "what", stb
);
3489 case bp_catch_unload
:
3490 /* Field 4, the address, is omitted (which makes the columns
3491 not line up too nicely with the headers, but the effect
3492 is relatively readable). */
3494 ui_out_field_skip (uiout
, "addr");
3496 if (b
->dll_pathname
== NULL
)
3498 ui_out_field_string (uiout
, "what", "<any library>");
3499 ui_out_spaces (uiout
, 1);
3503 ui_out_text (uiout
, "library \"");
3504 ui_out_field_string (uiout
, "what", b
->dll_pathname
);
3505 ui_out_text (uiout
, "\" ");
3510 case bp_catch_vfork
:
3511 /* Field 4, the address, is omitted (which makes the columns
3512 not line up too nicely with the headers, but the effect
3513 is relatively readable). */
3515 ui_out_field_skip (uiout
, "addr");
3517 if (b
->forked_inferior_pid
!= 0)
3519 ui_out_text (uiout
, "process ");
3520 ui_out_field_int (uiout
, "what", b
->forked_inferior_pid
);
3521 ui_out_spaces (uiout
, 1);
3526 /* Field 4, the address, is omitted (which makes the columns
3527 not line up too nicely with the headers, but the effect
3528 is relatively readable). */
3530 ui_out_field_skip (uiout
, "addr");
3532 if (b
->exec_pathname
!= NULL
)
3534 ui_out_text (uiout
, "program \"");
3535 ui_out_field_string (uiout
, "what", b
->exec_pathname
);
3536 ui_out_text (uiout
, "\" ");
3540 case bp_catch_catch
:
3541 /* Field 4, the address, is omitted (which makes the columns
3542 not line up too nicely with the headers, but the effect
3543 is relatively readable). */
3545 ui_out_field_skip (uiout
, "addr");
3547 ui_out_field_string (uiout
, "what", "exception catch");
3548 ui_out_spaces (uiout
, 1);
3551 case bp_catch_throw
:
3552 /* Field 4, the address, is omitted (which makes the columns
3553 not line up too nicely with the headers, but the effect
3554 is relatively readable). */
3556 ui_out_field_skip (uiout
, "addr");
3558 ui_out_field_string (uiout
, "what", "exception throw");
3559 ui_out_spaces (uiout
, 1);
3563 case bp_hardware_breakpoint
:
3567 case bp_longjmp_resume
:
3568 case bp_step_resume
:
3569 case bp_watchpoint_scope
:
3571 case bp_shlib_event
:
3572 case bp_thread_event
:
3573 case bp_overlay_event
:
3578 ui_out_field_string (uiout
, "addr", "<PENDING>");
3580 ui_out_field_core_addr (uiout
, "addr", b
->loc
->address
);
3583 *last_addr
= b
->loc
->address
;
3586 sym
= find_pc_sect_function (b
->loc
->address
, b
->loc
->section
);
3589 ui_out_text (uiout
, "in ");
3590 ui_out_field_string (uiout
, "func",
3591 SYMBOL_PRINT_NAME (sym
));
3592 ui_out_wrap_hint (uiout
, wrap_indent
);
3593 ui_out_text (uiout
, " at ");
3595 ui_out_field_string (uiout
, "file", b
->source_file
);
3596 ui_out_text (uiout
, ":");
3598 if (ui_out_is_mi_like_p (uiout
))
3600 struct symtab_and_line sal
= find_pc_line (b
->loc
->address
, 0);
3601 char *fullname
= symtab_to_fullname (sal
.symtab
);
3604 ui_out_field_string (uiout
, "fullname", fullname
);
3607 ui_out_field_int (uiout
, "line", b
->line_number
);
3609 else if (b
->pending
)
3611 ui_out_field_string (uiout
, "pending", b
->addr_string
);
3615 print_address_symbolic (b
->loc
->address
, stb
->stream
, demangle
, "");
3616 ui_out_field_stream (uiout
, "at", stb
);
3621 if (b
->thread
!= -1)
3623 /* FIXME: This seems to be redundant and lost here; see the
3624 "stop only in" line a little further down. */
3625 ui_out_text (uiout
, " thread ");
3626 ui_out_field_int (uiout
, "thread", b
->thread
);
3629 ui_out_text (uiout
, "\n");
3631 if (frame_id_p (b
->frame_id
))
3634 ui_out_text (uiout
, "\tstop only in stack frame at ");
3635 /* FIXME: cagney/2002-12-01: Shouldn't be poeking around inside
3637 ui_out_field_core_addr (uiout
, "frame", b
->frame_id
.stack_addr
);
3638 ui_out_text (uiout
, "\n");
3641 if (b
->cond
&& !ada_exception_catchpoint_p (b
))
3643 /* We do not print the condition for Ada exception catchpoints
3644 because the condition is an internal implementation detail
3645 that we do not want to expose to the user. */
3647 ui_out_text (uiout
, "\tstop only if ");
3648 print_expression (b
->cond
, stb
->stream
);
3649 ui_out_field_stream (uiout
, "cond", stb
);
3650 ui_out_text (uiout
, "\n");
3653 if (b
->pending
&& b
->cond_string
)
3656 ui_out_text (uiout
, "\tstop only if ");
3657 ui_out_field_string (uiout
, "cond", b
->cond_string
);
3658 ui_out_text (uiout
, "\n");
3661 if (b
->thread
!= -1)
3663 /* FIXME should make an annotation for this */
3664 ui_out_text (uiout
, "\tstop only in thread ");
3665 ui_out_field_int (uiout
, "thread", b
->thread
);
3666 ui_out_text (uiout
, "\n");
3669 if (show_breakpoint_hit_counts
&& b
->hit_count
)
3671 /* FIXME should make an annotation for this */
3672 if (ep_is_catchpoint (b
))
3673 ui_out_text (uiout
, "\tcatchpoint");
3675 ui_out_text (uiout
, "\tbreakpoint");
3676 ui_out_text (uiout
, " already hit ");
3677 ui_out_field_int (uiout
, "times", b
->hit_count
);
3678 if (b
->hit_count
== 1)
3679 ui_out_text (uiout
, " time\n");
3681 ui_out_text (uiout
, " times\n");
3684 /* Output the count also if it is zero, but only if this is
3685 mi. FIXME: Should have a better test for this. */
3686 if (ui_out_is_mi_like_p (uiout
))
3687 if (show_breakpoint_hit_counts
&& b
->hit_count
== 0)
3688 ui_out_field_int (uiout
, "times", b
->hit_count
);
3690 if (b
->ignore_count
)
3693 ui_out_text (uiout
, "\tignore next ");
3694 ui_out_field_int (uiout
, "ignore", b
->ignore_count
);
3695 ui_out_text (uiout
, " hits\n");
3698 if ((l
= b
->commands
))
3700 struct cleanup
*script_chain
;
3703 script_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "script");
3704 print_command_lines (uiout
, l
, 4);
3705 do_cleanups (script_chain
);
3707 do_cleanups (bkpt_chain
);
3708 do_cleanups (old_chain
);
3711 struct captured_breakpoint_query_args
3717 do_captured_breakpoint_query (struct ui_out
*uiout
, void *data
)
3719 struct captured_breakpoint_query_args
*args
= data
;
3720 struct breakpoint
*b
;
3721 CORE_ADDR dummy_addr
= 0;
3724 if (args
->bnum
== b
->number
)
3726 print_one_breakpoint (b
, &dummy_addr
);
3734 gdb_breakpoint_query (struct ui_out
*uiout
, int bnum
, char **error_message
)
3736 struct captured_breakpoint_query_args args
;
3738 /* For the moment we don't trust print_one_breakpoint() to not throw
3740 if (catch_exceptions_with_msg (uiout
, do_captured_breakpoint_query
, &args
,
3741 error_message
, RETURN_MASK_ALL
) < 0)
3747 /* Return non-zero if B is user settable (breakpoints, watchpoints,
3748 catchpoints, et.al.). */
3751 user_settable_breakpoint (const struct breakpoint
*b
)
3753 return (b
->type
== bp_breakpoint
3754 || b
->type
== bp_catch_load
3755 || b
->type
== bp_catch_unload
3756 || b
->type
== bp_catch_fork
3757 || b
->type
== bp_catch_vfork
3758 || b
->type
== bp_catch_exec
3759 || b
->type
== bp_catch_catch
3760 || b
->type
== bp_catch_throw
3761 || b
->type
== bp_hardware_breakpoint
3762 || b
->type
== bp_watchpoint
3763 || b
->type
== bp_read_watchpoint
3764 || b
->type
== bp_access_watchpoint
3765 || b
->type
== bp_hardware_watchpoint
);
3768 /* Print information on user settable breakpoint (watchpoint, etc)
3769 number BNUM. If BNUM is -1 print all user settable breakpoints.
3770 If ALLFLAG is non-zero, include non- user settable breakpoints. */
3773 breakpoint_1 (int bnum
, int allflag
)
3775 struct breakpoint
*b
;
3776 CORE_ADDR last_addr
= (CORE_ADDR
) -1;
3777 int nr_printable_breakpoints
;
3778 struct cleanup
*bkpttbl_chain
;
3780 /* Compute the number of rows in the table. */
3781 nr_printable_breakpoints
= 0;
3784 || bnum
== b
->number
)
3786 if (allflag
|| user_settable_breakpoint (b
))
3787 nr_printable_breakpoints
++;
3792 = make_cleanup_ui_out_table_begin_end (uiout
, 6, nr_printable_breakpoints
,
3796 = make_cleanup_ui_out_table_begin_end (uiout
, 5, nr_printable_breakpoints
,
3799 if (nr_printable_breakpoints
> 0)
3800 annotate_breakpoints_headers ();
3801 if (nr_printable_breakpoints
> 0)
3803 ui_out_table_header (uiout
, 3, ui_left
, "number", "Num"); /* 1 */
3804 if (nr_printable_breakpoints
> 0)
3806 ui_out_table_header (uiout
, 14, ui_left
, "type", "Type"); /* 2 */
3807 if (nr_printable_breakpoints
> 0)
3809 ui_out_table_header (uiout
, 4, ui_left
, "disp", "Disp"); /* 3 */
3810 if (nr_printable_breakpoints
> 0)
3812 ui_out_table_header (uiout
, 3, ui_left
, "enabled", "Enb"); /* 4 */
3815 if (nr_printable_breakpoints
> 0)
3817 if (TARGET_ADDR_BIT
<= 32)
3818 ui_out_table_header (uiout
, 10, ui_left
, "addr", "Address");/* 5 */
3820 ui_out_table_header (uiout
, 18, ui_left
, "addr", "Address");/* 5 */
3822 if (nr_printable_breakpoints
> 0)
3824 ui_out_table_header (uiout
, 40, ui_noalign
, "what", "What"); /* 6 */
3825 ui_out_table_body (uiout
);
3826 if (nr_printable_breakpoints
> 0)
3827 annotate_breakpoints_table ();
3831 || bnum
== b
->number
)
3833 /* We only print out user settable breakpoints unless the
3835 if (allflag
|| user_settable_breakpoint (b
))
3836 print_one_breakpoint (b
, &last_addr
);
3839 do_cleanups (bkpttbl_chain
);
3841 if (nr_printable_breakpoints
== 0)
3844 ui_out_message (uiout
, 0, "No breakpoints or watchpoints.\n");
3846 ui_out_message (uiout
, 0, "No breakpoint or watchpoint number %d.\n",
3851 /* Compare against (CORE_ADDR)-1 in case some compiler decides
3852 that a comparison of an unsigned with -1 is always false. */
3853 if (last_addr
!= (CORE_ADDR
) -1)
3854 set_next_address (last_addr
);
3857 /* FIXME? Should this be moved up so that it is only called when
3858 there have been breakpoints? */
3859 annotate_breakpoints_table_end ();
3863 breakpoints_info (char *bnum_exp
, int from_tty
)
3868 bnum
= parse_and_eval_long (bnum_exp
);
3870 breakpoint_1 (bnum
, 0);
3874 maintenance_info_breakpoints (char *bnum_exp
, int from_tty
)
3879 bnum
= parse_and_eval_long (bnum_exp
);
3881 breakpoint_1 (bnum
, 1);
3884 /* Print a message describing any breakpoints set at PC. */
3887 describe_other_breakpoints (CORE_ADDR pc
, asection
*section
, int thread
)
3890 struct breakpoint
*b
;
3893 if (b
->loc
->address
== pc
) /* address match / overlay match */
3894 if (!b
->pending
&& (!overlay_debugging
|| b
->loc
->section
== section
))
3899 printf_filtered (_("Note: breakpoint "));
3900 else /* if (others == ???) */
3901 printf_filtered (_("Note: breakpoints "));
3903 if (b
->loc
->address
== pc
) /* address match / overlay match */
3904 if (!b
->pending
&& (!overlay_debugging
|| b
->loc
->section
== section
))
3907 printf_filtered ("%d", b
->number
);
3908 if (b
->thread
== -1 && thread
!= -1)
3909 printf_filtered (" (all threads)");
3910 else if (b
->thread
!= -1)
3911 printf_filtered (" (thread %d)", b
->thread
);
3912 printf_filtered ("%s%s ",
3913 ((b
->enable_state
== bp_disabled
||
3914 b
->enable_state
== bp_shlib_disabled
||
3915 b
->enable_state
== bp_call_disabled
)
3917 : b
->enable_state
== bp_permanent
3921 : ((others
== 1) ? " and" : ""));
3923 printf_filtered (_("also set at pc "));
3924 deprecated_print_address_numeric (pc
, 1, gdb_stdout
);
3925 printf_filtered (".\n");
3929 /* Set the default place to put a breakpoint
3930 for the `break' command with no arguments. */
3933 set_default_breakpoint (int valid
, CORE_ADDR addr
, struct symtab
*symtab
,
3936 default_breakpoint_valid
= valid
;
3937 default_breakpoint_address
= addr
;
3938 default_breakpoint_symtab
= symtab
;
3939 default_breakpoint_line
= line
;
3942 /* Return true iff it is meaningful to use the address member of
3943 BPT. For some breakpoint types, the address member is irrelevant
3944 and it makes no sense to attempt to compare it to other addresses
3945 (or use it for any other purpose either).
3947 More specifically, each of the following breakpoint types will always
3948 have a zero valued address and we don't want check_duplicates() to mark
3949 breakpoints of any of these types to be a duplicate of an actual
3950 breakpoint at address zero:
3953 bp_hardware_watchpoint
3955 bp_access_watchpoint
3962 breakpoint_address_is_meaningful (struct breakpoint
*bpt
)
3964 enum bptype type
= bpt
->type
;
3966 return (type
!= bp_watchpoint
3967 && type
!= bp_hardware_watchpoint
3968 && type
!= bp_read_watchpoint
3969 && type
!= bp_access_watchpoint
3970 && type
!= bp_catch_exec
3971 && type
!= bp_longjmp_resume
3972 && type
!= bp_catch_fork
3973 && type
!= bp_catch_vfork
);
3976 /* Rescan breakpoints at the same address and section as BPT,
3977 marking the first one as "first" and any others as "duplicates".
3978 This is so that the bpt instruction is only inserted once.
3979 If we have a permanent breakpoint at the same place as BPT, make
3980 that one the official one, and the rest as duplicates. */
3983 check_duplicates (struct breakpoint
*bpt
)
3985 struct bp_location
*b
;
3987 struct bp_location
*perm_bp
= 0;
3988 CORE_ADDR address
= bpt
->loc
->address
;
3989 asection
*section
= bpt
->loc
->section
;
3991 if (! breakpoint_address_is_meaningful (bpt
))
3994 ALL_BP_LOCATIONS (b
)
3995 if (b
->owner
->enable_state
!= bp_disabled
3996 && b
->owner
->enable_state
!= bp_shlib_disabled
3997 && !b
->owner
->pending
3998 && b
->owner
->enable_state
!= bp_call_disabled
3999 && b
->address
== address
/* address / overlay match */
4000 && (!overlay_debugging
|| b
->section
== section
)
4001 && breakpoint_address_is_meaningful (b
->owner
))
4003 /* Have we found a permanent breakpoint? */
4004 if (b
->owner
->enable_state
== bp_permanent
)
4011 b
->duplicate
= count
> 1;
4014 /* If we found a permanent breakpoint at this address, go over the
4015 list again and declare all the other breakpoints there to be the
4019 perm_bp
->duplicate
= 0;
4021 /* Permanent breakpoint should always be inserted. */
4022 if (! perm_bp
->inserted
)
4023 internal_error (__FILE__
, __LINE__
,
4024 _("allegedly permanent breakpoint is not "
4025 "actually inserted"));
4027 ALL_BP_LOCATIONS (b
)
4030 if (b
->owner
->enable_state
!= bp_disabled
4031 && b
->owner
->enable_state
!= bp_shlib_disabled
4032 && !b
->owner
->pending
4033 && b
->owner
->enable_state
!= bp_call_disabled
4034 && b
->address
== address
/* address / overlay match */
4035 && (!overlay_debugging
|| b
->section
== section
)
4036 && breakpoint_address_is_meaningful (b
->owner
))
4039 internal_error (__FILE__
, __LINE__
,
4040 _("another breakpoint was inserted on top of "
4041 "a permanent breakpoint"));
4050 breakpoint_adjustment_warning (CORE_ADDR from_addr
, CORE_ADDR to_addr
,
4051 int bnum
, int have_bnum
)
4056 strcpy (astr1
, hex_string_custom ((unsigned long) from_addr
, 8));
4057 strcpy (astr2
, hex_string_custom ((unsigned long) to_addr
, 8));
4059 warning (_("Breakpoint %d address previously adjusted from %s to %s."),
4060 bnum
, astr1
, astr2
);
4062 warning (_("Breakpoint address adjusted from %s to %s."), astr1
, astr2
);
4065 /* Adjust a breakpoint's address to account for architectural constraints
4066 on breakpoint placement. Return the adjusted address. Note: Very
4067 few targets require this kind of adjustment. For most targets,
4068 this function is simply the identity function. */
4071 adjust_breakpoint_address (CORE_ADDR bpaddr
, enum bptype bptype
)
4073 if (!gdbarch_adjust_breakpoint_address_p (current_gdbarch
))
4075 /* Very few targets need any kind of breakpoint adjustment. */
4078 else if (bptype
== bp_watchpoint
4079 || bptype
== bp_hardware_watchpoint
4080 || bptype
== bp_read_watchpoint
4081 || bptype
== bp_access_watchpoint
4082 || bptype
== bp_catch_fork
4083 || bptype
== bp_catch_vfork
4084 || bptype
== bp_catch_exec
)
4086 /* Watchpoints and the various bp_catch_* eventpoints should not
4087 have their addresses modified. */
4092 CORE_ADDR adjusted_bpaddr
;
4094 /* Some targets have architectural constraints on the placement
4095 of breakpoint instructions. Obtain the adjusted address. */
4096 adjusted_bpaddr
= gdbarch_adjust_breakpoint_address (current_gdbarch
,
4099 /* An adjusted breakpoint address can significantly alter
4100 a user's expectations. Print a warning if an adjustment
4102 if (adjusted_bpaddr
!= bpaddr
)
4103 breakpoint_adjustment_warning (bpaddr
, adjusted_bpaddr
, 0, 0);
4105 return adjusted_bpaddr
;
4109 /* Allocate a struct bp_location. */
4111 static struct bp_location
*
4112 allocate_bp_location (struct breakpoint
*bpt
, enum bptype bp_type
)
4114 struct bp_location
*loc
, *loc_p
;
4116 loc
= xmalloc (sizeof (struct bp_location
));
4117 memset (loc
, 0, sizeof (*loc
));
4127 case bp_longjmp_resume
:
4128 case bp_step_resume
:
4129 case bp_watchpoint_scope
:
4131 case bp_shlib_event
:
4132 case bp_thread_event
:
4133 case bp_overlay_event
:
4135 case bp_catch_unload
:
4136 loc
->loc_type
= bp_loc_software_breakpoint
;
4138 case bp_hardware_breakpoint
:
4139 loc
->loc_type
= bp_loc_hardware_breakpoint
;
4141 case bp_hardware_watchpoint
:
4142 case bp_read_watchpoint
:
4143 case bp_access_watchpoint
:
4144 loc
->loc_type
= bp_loc_hardware_watchpoint
;
4148 case bp_catch_vfork
:
4150 case bp_catch_catch
:
4151 case bp_catch_throw
:
4152 loc
->loc_type
= bp_loc_other
;
4155 internal_error (__FILE__
, __LINE__
, _("unknown breakpoint type"));
4158 /* Add this breakpoint to the end of the chain. */
4160 loc_p
= bp_location_chain
;
4162 bp_location_chain
= loc
;
4166 loc_p
= loc_p
->next
;
4173 /* set_raw_breakpoint() is a low level routine for allocating and
4174 partially initializing a breakpoint of type BPTYPE. The newly
4175 created breakpoint's address, section, source file name, and line
4176 number are provided by SAL. The newly created and partially
4177 initialized breakpoint is added to the breakpoint chain and
4178 is also returned as the value of this function.
4180 It is expected that the caller will complete the initialization of
4181 the newly created breakpoint struct as well as output any status
4182 information regarding the creation of a new breakpoint. In
4183 particular, set_raw_breakpoint() does NOT set the breakpoint
4184 number! Care should be taken to not allow an error() to occur
4185 prior to completing the initialization of the breakpoint. If this
4186 should happen, a bogus breakpoint will be left on the chain. */
4189 set_raw_breakpoint (struct symtab_and_line sal
, enum bptype bptype
)
4191 struct breakpoint
*b
, *b1
;
4192 CORE_ADDR adjusted_address
;
4194 b
= (struct breakpoint
*) xmalloc (sizeof (struct breakpoint
));
4195 memset (b
, 0, sizeof (*b
));
4197 /* Adjust the breakpoint's address prior to allocating a location.
4198 Once we call allocate_bp_location(), that mostly uninitialized
4199 location will be placed on the location chain. Adjustment of the
4200 breakpoint may cause read_memory_nobpt() to be called and we do
4201 not want its scan of the location chain to find a breakpoint and
4202 location that's only been partially initialized. */
4203 adjusted_address
= adjust_breakpoint_address (sal
.pc
, bptype
);
4205 b
->loc
= allocate_bp_location (b
, bptype
);
4206 b
->loc
->requested_address
= sal
.pc
;
4207 b
->loc
->address
= adjusted_address
;
4209 if (sal
.symtab
== NULL
)
4210 b
->source_file
= NULL
;
4212 b
->source_file
= savestring (sal
.symtab
->filename
,
4213 strlen (sal
.symtab
->filename
));
4214 b
->loc
->section
= sal
.section
;
4216 b
->language
= current_language
->la_language
;
4217 b
->input_radix
= input_radix
;
4219 b
->line_number
= sal
.line
;
4220 b
->enable_state
= bp_enabled
;
4223 b
->ignore_count
= 0;
4225 b
->frame_id
= null_frame_id
;
4226 b
->dll_pathname
= NULL
;
4227 b
->triggered_dll_pathname
= NULL
;
4228 b
->forked_inferior_pid
= 0;
4229 b
->exec_pathname
= NULL
;
4233 /* Add this breakpoint to the end of the chain
4234 so that a list of breakpoints will come out in order
4235 of increasing numbers. */
4237 b1
= breakpoint_chain
;
4239 breakpoint_chain
= b
;
4247 check_duplicates (b
);
4248 breakpoints_changed ();
4254 /* Note that the breakpoint object B describes a permanent breakpoint
4255 instruction, hard-wired into the inferior's code. */
4257 make_breakpoint_permanent (struct breakpoint
*b
)
4259 b
->enable_state
= bp_permanent
;
4261 /* By definition, permanent breakpoints are already present in the code. */
4262 b
->loc
->inserted
= 1;
4265 static struct breakpoint
*
4266 create_internal_breakpoint (CORE_ADDR address
, enum bptype type
)
4268 static int internal_breakpoint_number
= -1;
4269 struct symtab_and_line sal
;
4270 struct breakpoint
*b
;
4272 init_sal (&sal
); /* initialize to zeroes */
4275 sal
.section
= find_pc_overlay (sal
.pc
);
4277 b
= set_raw_breakpoint (sal
, type
);
4278 b
->number
= internal_breakpoint_number
--;
4279 b
->disposition
= disp_donttouch
;
4286 create_longjmp_breakpoint (char *func_name
)
4288 struct breakpoint
*b
;
4289 struct minimal_symbol
*m
;
4291 if (func_name
== NULL
)
4292 b
= create_internal_breakpoint (0, bp_longjmp_resume
);
4295 if ((m
= lookup_minimal_symbol_text (func_name
, NULL
)) == NULL
)
4298 b
= create_internal_breakpoint (SYMBOL_VALUE_ADDRESS (m
), bp_longjmp
);
4301 b
->enable_state
= bp_disabled
;
4304 b
->addr_string
= xstrdup (func_name
);
4307 /* Call this routine when stepping and nexting to enable a breakpoint
4308 if we do a longjmp(). When we hit that breakpoint, call
4309 set_longjmp_resume_breakpoint() to figure out where we are going. */
4312 enable_longjmp_breakpoint (void)
4314 struct breakpoint
*b
;
4317 if (b
->type
== bp_longjmp
)
4319 b
->enable_state
= bp_enabled
;
4320 check_duplicates (b
);
4325 disable_longjmp_breakpoint (void)
4327 struct breakpoint
*b
;
4330 if (b
->type
== bp_longjmp
4331 || b
->type
== bp_longjmp_resume
)
4333 b
->enable_state
= bp_disabled
;
4334 check_duplicates (b
);
4339 create_overlay_event_breakpoint (char *func_name
)
4341 struct breakpoint
*b
;
4342 struct minimal_symbol
*m
;
4344 if ((m
= lookup_minimal_symbol_text (func_name
, NULL
)) == NULL
)
4347 b
= create_internal_breakpoint (SYMBOL_VALUE_ADDRESS (m
),
4349 b
->addr_string
= xstrdup (func_name
);
4351 if (overlay_debugging
== ovly_auto
)
4353 b
->enable_state
= bp_enabled
;
4354 overlay_events_enabled
= 1;
4358 b
->enable_state
= bp_disabled
;
4359 overlay_events_enabled
= 0;
4364 enable_overlay_breakpoints (void)
4366 struct breakpoint
*b
;
4369 if (b
->type
== bp_overlay_event
)
4371 b
->enable_state
= bp_enabled
;
4372 check_duplicates (b
);
4373 overlay_events_enabled
= 1;
4378 disable_overlay_breakpoints (void)
4380 struct breakpoint
*b
;
4383 if (b
->type
== bp_overlay_event
)
4385 b
->enable_state
= bp_disabled
;
4386 check_duplicates (b
);
4387 overlay_events_enabled
= 0;
4392 create_thread_event_breakpoint (CORE_ADDR address
)
4394 struct breakpoint
*b
;
4396 b
= create_internal_breakpoint (address
, bp_thread_event
);
4398 b
->enable_state
= bp_enabled
;
4399 /* addr_string has to be used or breakpoint_re_set will delete me. */
4400 b
->addr_string
= xstrprintf ("*0x%s", paddr (b
->loc
->address
));
4406 remove_thread_event_breakpoints (void)
4408 struct breakpoint
*b
, *temp
;
4410 ALL_BREAKPOINTS_SAFE (b
, temp
)
4411 if (b
->type
== bp_thread_event
)
4412 delete_breakpoint (b
);
4415 struct captured_parse_breakpoint_args
4418 struct symtabs_and_lines
*sals_p
;
4419 char ***addr_string_p
;
4423 struct lang_and_radix
4429 /* Cleanup helper routine to restore the current language and
4432 do_restore_lang_radix_cleanup (void *old
)
4434 struct lang_and_radix
*p
= old
;
4435 set_language (p
->lang
);
4436 input_radix
= p
->radix
;
4439 /* Try and resolve a pending breakpoint. */
4441 resolve_pending_breakpoint (struct breakpoint
*b
)
4443 /* Try and reparse the breakpoint in case the shared library
4445 struct symtabs_and_lines sals
;
4446 struct symtab_and_line pending_sal
;
4447 char **cond_string
= (char **) NULL
;
4448 char *copy_arg
= b
->addr_string
;
4453 struct ui_file
*old_gdb_stderr
;
4454 struct lang_and_radix old_lr
;
4455 struct cleanup
*old_chain
;
4457 /* Set language, input-radix, then reissue breakpoint command.
4458 Ensure the language and input-radix are restored afterwards. */
4459 old_lr
.lang
= current_language
->la_language
;
4460 old_lr
.radix
= input_radix
;
4461 old_chain
= make_cleanup (do_restore_lang_radix_cleanup
, &old_lr
);
4463 set_language (b
->language
);
4464 input_radix
= b
->input_radix
;
4465 rc
= break_command_1 (b
->addr_string
, b
->flag
, b
->from_tty
, b
);
4467 if (rc
== GDB_RC_OK
)
4468 /* Pending breakpoint has been resolved. */
4469 printf_filtered (_("Pending breakpoint \"%s\" resolved\n"), b
->addr_string
);
4471 do_cleanups (old_chain
);
4476 remove_solib_event_breakpoints (void)
4478 struct breakpoint
*b
, *temp
;
4480 ALL_BREAKPOINTS_SAFE (b
, temp
)
4481 if (b
->type
== bp_shlib_event
)
4482 delete_breakpoint (b
);
4486 create_solib_event_breakpoint (CORE_ADDR address
)
4488 struct breakpoint
*b
;
4490 b
= create_internal_breakpoint (address
, bp_shlib_event
);
4494 /* Disable any breakpoints that are on code in shared libraries. Only
4495 apply to enabled breakpoints, disabled ones can just stay disabled. */
4498 disable_breakpoints_in_shlibs (int silent
)
4500 struct breakpoint
*b
;
4501 int disabled_shlib_breaks
= 0;
4503 /* See also: insert_breakpoints, under DISABLE_UNSETTABLE_BREAK. */
4506 if (((b
->type
== bp_breakpoint
) || (b
->type
== bp_hardware_breakpoint
))
4507 && breakpoint_enabled (b
) && !b
->loc
->duplicate
4509 && PC_SOLIB (b
->loc
->address
)
4511 && solib_address (b
->loc
->address
)
4515 b
->enable_state
= bp_shlib_disabled
;
4518 if (!disabled_shlib_breaks
)
4520 target_terminal_ours_for_output ();
4521 warning (_("Temporarily disabling shared library breakpoints:"));
4523 disabled_shlib_breaks
= 1;
4524 warning (_("breakpoint #%d "), b
->number
);
4530 /* Disable any breakpoints that are in in an unloaded shared library. Only
4531 apply to enabled breakpoints, disabled ones can just stay disabled. */
4534 disable_breakpoints_in_unloaded_shlib (struct so_list
*solib
)
4536 struct breakpoint
*b
;
4537 int disabled_shlib_breaks
= 0;
4539 /* See also: insert_breakpoints, under DISABLE_UNSETTABLE_BREAK. */
4542 if ((b
->loc
->loc_type
== bp_loc_hardware_breakpoint
4543 || b
->loc
->loc_type
== bp_loc_software_breakpoint
)
4544 && breakpoint_enabled (b
) && !b
->loc
->duplicate
)
4547 char *so_name
= PC_SOLIB (b
->loc
->address
);
4549 char *so_name
= solib_address (b
->loc
->address
);
4551 if (so_name
&& !strcmp (so_name
, solib
->so_name
))
4553 b
->enable_state
= bp_shlib_disabled
;
4554 /* At this point, we cannot rely on remove_breakpoint
4555 succeeding so we must mark the breakpoint as not inserted
4556 to prevent future errors occurring in remove_breakpoints. */
4557 b
->loc
->inserted
= 0;
4558 if (!disabled_shlib_breaks
)
4560 target_terminal_ours_for_output ();
4561 warning (_("Temporarily disabling breakpoints for unloaded shared library \"%s\""),
4564 disabled_shlib_breaks
= 1;
4570 /* Try to reenable any breakpoints in shared libraries. */
4572 re_enable_breakpoints_in_shlibs (void)
4574 struct breakpoint
*b
, *tmp
;
4576 ALL_BREAKPOINTS_SAFE (b
, tmp
)
4578 if (b
->enable_state
== bp_shlib_disabled
)
4583 /* Do not reenable the breakpoint if the shared library is
4584 still not mapped in. */
4586 lib
= PC_SOLIB (b
->loc
->address
);
4588 lib
= solib_address (b
->loc
->address
);
4590 if (lib
!= NULL
&& target_read_memory (b
->loc
->address
, buf
, 1) == 0)
4591 b
->enable_state
= bp_enabled
;
4593 else if (b
->pending
&& (b
->enable_state
== bp_enabled
))
4595 if (resolve_pending_breakpoint (b
) == GDB_RC_OK
)
4596 delete_breakpoint (b
);
4602 solib_load_unload_1 (char *hookname
, int tempflag
, char *dll_pathname
,
4603 char *cond_string
, enum bptype bp_kind
)
4605 struct breakpoint
*b
;
4606 struct symtabs_and_lines sals
;
4607 struct cleanup
*old_chain
;
4608 struct cleanup
*canonical_strings_chain
= NULL
;
4609 char *addr_start
= hookname
;
4610 char *addr_end
= NULL
;
4611 char **canonical
= (char **) NULL
;
4612 int thread
= -1; /* All threads. */
4614 /* Set a breakpoint on the specified hook. */
4615 sals
= decode_line_1 (&hookname
, 1, (struct symtab
*) NULL
,
4616 0, &canonical
, NULL
);
4617 addr_end
= hookname
;
4619 if (sals
.nelts
== 0)
4621 warning (_("Unable to set a breakpoint on dynamic linker callback.\n"
4622 "Suggest linking with /opt/langtools/lib/end.o.\n"
4623 "GDB will be unable to track shl_load/shl_unload calls."));
4626 if (sals
.nelts
!= 1)
4628 warning (_("Unable to set unique breakpoint on dynamic linker callback.\n"
4629 "GDB will be unable to track shl_load/shl_unload calls."));
4633 /* Make sure that all storage allocated in decode_line_1 gets freed
4634 in case the following errors out. */
4635 old_chain
= make_cleanup (xfree
, sals
.sals
);
4636 if (canonical
!= (char **) NULL
)
4638 make_cleanup (xfree
, canonical
);
4639 canonical_strings_chain
= make_cleanup (null_cleanup
, 0);
4640 if (canonical
[0] != NULL
)
4641 make_cleanup (xfree
, canonical
[0]);
4644 resolve_sal_pc (&sals
.sals
[0]);
4646 /* Remove the canonical strings from the cleanup, they are needed below. */
4647 if (canonical
!= (char **) NULL
)
4648 discard_cleanups (canonical_strings_chain
);
4650 b
= set_raw_breakpoint (sals
.sals
[0], bp_kind
);
4651 set_breakpoint_count (breakpoint_count
+ 1);
4652 b
->number
= breakpoint_count
;
4654 b
->cond_string
= (cond_string
== NULL
) ?
4655 NULL
: savestring (cond_string
, strlen (cond_string
));
4658 if (canonical
!= (char **) NULL
&& canonical
[0] != NULL
)
4659 b
->addr_string
= canonical
[0];
4660 else if (addr_start
)
4661 b
->addr_string
= savestring (addr_start
, addr_end
- addr_start
);
4663 b
->enable_state
= bp_enabled
;
4664 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
4666 if (dll_pathname
== NULL
)
4667 b
->dll_pathname
= NULL
;
4670 b
->dll_pathname
= (char *) xmalloc (strlen (dll_pathname
) + 1);
4671 strcpy (b
->dll_pathname
, dll_pathname
);
4675 do_cleanups (old_chain
);
4679 create_solib_load_event_breakpoint (char *hookname
, int tempflag
,
4680 char *dll_pathname
, char *cond_string
)
4682 solib_load_unload_1 (hookname
, tempflag
, dll_pathname
,
4683 cond_string
, bp_catch_load
);
4687 create_solib_unload_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_unload
);
4695 create_fork_vfork_event_catchpoint (int tempflag
, char *cond_string
,
4696 enum bptype bp_kind
)
4698 struct symtab_and_line sal
;
4699 struct breakpoint
*b
;
4700 int thread
= -1; /* All threads. */
4707 b
= set_raw_breakpoint (sal
, bp_kind
);
4708 set_breakpoint_count (breakpoint_count
+ 1);
4709 b
->number
= breakpoint_count
;
4711 b
->cond_string
= (cond_string
== NULL
) ?
4712 NULL
: savestring (cond_string
, strlen (cond_string
));
4714 b
->addr_string
= NULL
;
4715 b
->enable_state
= bp_enabled
;
4716 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
4717 b
->forked_inferior_pid
= 0;
4723 create_fork_event_catchpoint (int tempflag
, char *cond_string
)
4725 create_fork_vfork_event_catchpoint (tempflag
, cond_string
, bp_catch_fork
);
4729 create_vfork_event_catchpoint (int tempflag
, char *cond_string
)
4731 create_fork_vfork_event_catchpoint (tempflag
, cond_string
, bp_catch_vfork
);
4735 create_exec_event_catchpoint (int tempflag
, char *cond_string
)
4737 struct symtab_and_line sal
;
4738 struct breakpoint
*b
;
4739 int thread
= -1; /* All threads. */
4746 b
= set_raw_breakpoint (sal
, bp_catch_exec
);
4747 set_breakpoint_count (breakpoint_count
+ 1);
4748 b
->number
= breakpoint_count
;
4750 b
->cond_string
= (cond_string
== NULL
) ?
4751 NULL
: savestring (cond_string
, strlen (cond_string
));
4753 b
->addr_string
= NULL
;
4754 b
->enable_state
= bp_enabled
;
4755 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
4761 hw_breakpoint_used_count (void)
4763 struct breakpoint
*b
;
4768 if (b
->type
== bp_hardware_breakpoint
&& b
->enable_state
== bp_enabled
)
4776 hw_watchpoint_used_count (enum bptype type
, int *other_type_used
)
4778 struct breakpoint
*b
;
4781 *other_type_used
= 0;
4784 if (breakpoint_enabled (b
))
4786 if (b
->type
== type
)
4788 else if ((b
->type
== bp_hardware_watchpoint
||
4789 b
->type
== bp_read_watchpoint
||
4790 b
->type
== bp_access_watchpoint
))
4791 *other_type_used
= 1;
4797 /* Call this after hitting the longjmp() breakpoint. Use this to set
4798 a new breakpoint at the target of the jmp_buf.
4800 FIXME - This ought to be done by setting a temporary breakpoint
4801 that gets deleted automatically... */
4804 set_longjmp_resume_breakpoint (CORE_ADDR pc
, struct frame_id frame_id
)
4806 struct breakpoint
*b
;
4809 if (b
->type
== bp_longjmp_resume
)
4811 b
->loc
->requested_address
= pc
;
4812 b
->loc
->address
= adjust_breakpoint_address (b
->loc
->requested_address
,
4814 b
->enable_state
= bp_enabled
;
4815 b
->frame_id
= frame_id
;
4816 check_duplicates (b
);
4822 disable_watchpoints_before_interactive_call_start (void)
4824 struct breakpoint
*b
;
4828 if (((b
->type
== bp_watchpoint
)
4829 || (b
->type
== bp_hardware_watchpoint
)
4830 || (b
->type
== bp_read_watchpoint
)
4831 || (b
->type
== bp_access_watchpoint
)
4832 || ep_is_exception_catchpoint (b
))
4833 && breakpoint_enabled (b
))
4835 b
->enable_state
= bp_call_disabled
;
4836 check_duplicates (b
);
4842 enable_watchpoints_after_interactive_call_stop (void)
4844 struct breakpoint
*b
;
4848 if (((b
->type
== bp_watchpoint
)
4849 || (b
->type
== bp_hardware_watchpoint
)
4850 || (b
->type
== bp_read_watchpoint
)
4851 || (b
->type
== bp_access_watchpoint
)
4852 || ep_is_exception_catchpoint (b
))
4853 && (b
->enable_state
== bp_call_disabled
))
4855 b
->enable_state
= bp_enabled
;
4856 check_duplicates (b
);
4862 /* Set a breakpoint that will evaporate an end of command
4863 at address specified by SAL.
4864 Restrict it to frame FRAME if FRAME is nonzero. */
4867 set_momentary_breakpoint (struct symtab_and_line sal
, struct frame_id frame_id
,
4870 struct breakpoint
*b
;
4871 b
= set_raw_breakpoint (sal
, type
);
4872 b
->enable_state
= bp_enabled
;
4873 b
->disposition
= disp_donttouch
;
4874 b
->frame_id
= frame_id
;
4876 /* If we're debugging a multi-threaded program, then we
4877 want momentary breakpoints to be active in only a
4878 single thread of control. */
4879 if (in_thread_list (inferior_ptid
))
4880 b
->thread
= pid_to_thread_id (inferior_ptid
);
4886 /* Tell the user we have just set a breakpoint B. */
4889 mention (struct breakpoint
*b
)
4892 struct cleanup
*old_chain
, *ui_out_chain
;
4893 struct ui_stream
*stb
;
4895 stb
= ui_out_stream_new (uiout
);
4896 old_chain
= make_cleanup_ui_out_stream_delete (stb
);
4898 /* FIXME: This is misplaced; mention() is called by things (like
4899 hitting a watchpoint) other than breakpoint creation. It should
4900 be possible to clean this up and at the same time replace the
4901 random calls to breakpoint_changed with this hook, as has already
4902 been done for deprecated_delete_breakpoint_hook and so on. */
4903 if (deprecated_create_breakpoint_hook
)
4904 deprecated_create_breakpoint_hook (b
);
4905 breakpoint_create_event (b
->number
);
4907 if (b
->ops
!= NULL
&& b
->ops
->print_mention
!= NULL
)
4908 b
->ops
->print_mention (b
);
4913 printf_filtered (_("(apparently deleted?) Eventpoint %d: "), b
->number
);
4916 ui_out_text (uiout
, "Watchpoint ");
4917 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "wpt");
4918 ui_out_field_int (uiout
, "number", b
->number
);
4919 ui_out_text (uiout
, ": ");
4920 print_expression (b
->exp
, stb
->stream
);
4921 ui_out_field_stream (uiout
, "exp", stb
);
4922 do_cleanups (ui_out_chain
);
4924 case bp_hardware_watchpoint
:
4925 ui_out_text (uiout
, "Hardware watchpoint ");
4926 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "wpt");
4927 ui_out_field_int (uiout
, "number", b
->number
);
4928 ui_out_text (uiout
, ": ");
4929 print_expression (b
->exp
, stb
->stream
);
4930 ui_out_field_stream (uiout
, "exp", stb
);
4931 do_cleanups (ui_out_chain
);
4933 case bp_read_watchpoint
:
4934 ui_out_text (uiout
, "Hardware read watchpoint ");
4935 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "hw-rwpt");
4936 ui_out_field_int (uiout
, "number", b
->number
);
4937 ui_out_text (uiout
, ": ");
4938 print_expression (b
->exp
, stb
->stream
);
4939 ui_out_field_stream (uiout
, "exp", stb
);
4940 do_cleanups (ui_out_chain
);
4942 case bp_access_watchpoint
:
4943 ui_out_text (uiout
, "Hardware access (read/write) watchpoint ");
4944 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "hw-awpt");
4945 ui_out_field_int (uiout
, "number", b
->number
);
4946 ui_out_text (uiout
, ": ");
4947 print_expression (b
->exp
, stb
->stream
);
4948 ui_out_field_stream (uiout
, "exp", stb
);
4949 do_cleanups (ui_out_chain
);
4952 if (ui_out_is_mi_like_p (uiout
))
4957 printf_filtered (_("Breakpoint %d"), b
->number
);
4960 case bp_hardware_breakpoint
:
4961 if (ui_out_is_mi_like_p (uiout
))
4966 printf_filtered (_("Hardware assisted breakpoint %d"), b
->number
);
4970 case bp_catch_unload
:
4971 printf_filtered (_("Catchpoint %d (%s %s)"),
4973 (b
->type
== bp_catch_load
) ? "load" : "unload",
4974 (b
->dll_pathname
!= NULL
) ?
4975 b
->dll_pathname
: "<any library>");
4978 case bp_catch_vfork
:
4979 printf_filtered (_("Catchpoint %d (%s)"),
4981 (b
->type
== bp_catch_fork
) ? "fork" : "vfork");
4984 printf_filtered (_("Catchpoint %d (exec)"),
4987 case bp_catch_catch
:
4988 case bp_catch_throw
:
4989 printf_filtered (_("Catchpoint %d (%s)"),
4991 (b
->type
== bp_catch_catch
) ? "catch" : "throw");
4997 case bp_longjmp_resume
:
4998 case bp_step_resume
:
5000 case bp_watchpoint_scope
:
5001 case bp_shlib_event
:
5002 case bp_thread_event
:
5003 case bp_overlay_event
:
5009 /* i18n: cagney/2005-02-11: Below needs to be merged into a
5013 printf_filtered (_(" (%s) pending."), b
->addr_string
);
5017 if (addressprint
|| b
->source_file
== NULL
)
5019 printf_filtered (" at ");
5020 deprecated_print_address_numeric (b
->loc
->address
, 1, gdb_stdout
);
5023 printf_filtered (": file %s, line %d.",
5024 b
->source_file
, b
->line_number
);
5027 do_cleanups (old_chain
);
5028 if (ui_out_is_mi_like_p (uiout
))
5030 printf_filtered ("\n");
5034 /* Add SALS.nelts breakpoints to the breakpoint table. For each
5035 SALS.sal[i] breakpoint, include the corresponding ADDR_STRING[i],
5036 COND[i] and COND_STRING[i] values.
5038 The parameter PENDING_BP points to a pending breakpoint that is
5039 the basis of the breakpoints currently being created. The pending
5040 breakpoint may contain a separate condition string or commands
5041 that were added after the initial pending breakpoint was created.
5043 NOTE: If the function succeeds, the caller is expected to cleanup
5044 the arrays ADDR_STRING, COND_STRING, COND and SALS (but not the
5045 array contents). If the function fails (error() is called), the
5046 caller is expected to cleanups both the ADDR_STRING, COND_STRING,
5047 COND and SALS arrays and each of those arrays contents. */
5050 create_breakpoints (struct symtabs_and_lines sals
, char **addr_string
,
5051 struct expression
**cond
, char **cond_string
,
5052 enum bptype type
, enum bpdisp disposition
,
5053 int thread
, int ignore_count
, int from_tty
,
5054 struct breakpoint
*pending_bp
)
5056 if (type
== bp_hardware_breakpoint
)
5058 int i
= hw_breakpoint_used_count ();
5059 int target_resources_ok
=
5060 TARGET_CAN_USE_HARDWARE_WATCHPOINT (bp_hardware_breakpoint
,
5062 if (target_resources_ok
== 0)
5063 error (_("No hardware breakpoint support in the target."));
5064 else if (target_resources_ok
< 0)
5065 error (_("Hardware breakpoints used exceeds limit."));
5068 /* Now set all the breakpoints. */
5071 for (i
= 0; i
< sals
.nelts
; i
++)
5073 struct breakpoint
*b
;
5074 struct symtab_and_line sal
= sals
.sals
[i
];
5077 describe_other_breakpoints (sal
.pc
, sal
.section
, thread
);
5079 b
= set_raw_breakpoint (sal
, type
);
5080 set_breakpoint_count (breakpoint_count
+ 1);
5081 b
->number
= breakpoint_count
;
5085 b
->addr_string
= addr_string
[i
];
5087 /* addr_string has to be used or breakpoint_re_set will delete
5089 b
->addr_string
= xstrprintf ("*0x%s", paddr (b
->loc
->address
));
5090 b
->cond_string
= cond_string
[i
];
5091 b
->ignore_count
= ignore_count
;
5092 b
->enable_state
= bp_enabled
;
5093 b
->disposition
= disposition
;
5094 /* If resolving a pending breakpoint, a check must be made to see if
5095 the user has specified a new condition or commands for the
5096 breakpoint. A new condition will override any condition that was
5097 initially specified with the initial breakpoint command. */
5101 if (pending_bp
->cond_string
)
5103 arg
= pending_bp
->cond_string
;
5104 b
->cond_string
= savestring (arg
, strlen (arg
));
5105 b
->cond
= parse_exp_1 (&arg
, block_for_pc (b
->loc
->address
), 0);
5107 error (_("Junk at end of pending breakpoint condition expression"));
5109 /* If there are commands associated with the breakpoint, they should
5111 if (pending_bp
->commands
)
5112 b
->commands
= copy_command_lines (pending_bp
->commands
);
5114 /* We have to copy over the ignore_count and thread as well. */
5115 b
->ignore_count
= pending_bp
->ignore_count
;
5116 b
->thread
= pending_bp
->thread
;
5123 /* Parse ARG which is assumed to be a SAL specification possibly
5124 followed by conditionals. On return, SALS contains an array of SAL
5125 addresses found. ADDR_STRING contains a vector of (canonical)
5126 address strings. ARG points to the end of the SAL. */
5129 parse_breakpoint_sals (char **address
,
5130 struct symtabs_and_lines
*sals
,
5131 char ***addr_string
,
5134 char *addr_start
= *address
;
5135 *addr_string
= NULL
;
5136 /* If no arg given, or if first arg is 'if ', use the default
5138 if ((*address
) == NULL
5139 || (strncmp ((*address
), "if", 2) == 0 && isspace ((*address
)[2])))
5141 if (default_breakpoint_valid
)
5143 struct symtab_and_line sal
;
5144 init_sal (&sal
); /* initialize to zeroes */
5145 sals
->sals
= (struct symtab_and_line
*)
5146 xmalloc (sizeof (struct symtab_and_line
));
5147 sal
.pc
= default_breakpoint_address
;
5148 sal
.line
= default_breakpoint_line
;
5149 sal
.symtab
= default_breakpoint_symtab
;
5150 sal
.section
= find_pc_overlay (sal
.pc
);
5151 sals
->sals
[0] = sal
;
5155 error (_("No default breakpoint address now."));
5159 /* Force almost all breakpoints to be in terms of the
5160 current_source_symtab (which is decode_line_1's default). This
5161 should produce the results we want almost all of the time while
5162 leaving default_breakpoint_* alone.
5163 ObjC: However, don't match an Objective-C method name which
5164 may have a '+' or '-' succeeded by a '[' */
5166 struct symtab_and_line cursal
= get_current_source_symtab_and_line ();
5168 if (default_breakpoint_valid
5170 || ((strchr ("+-", (*address
)[0]) != NULL
)
5171 && ((*address
)[1] != '['))))
5172 *sals
= decode_line_1 (address
, 1, default_breakpoint_symtab
,
5173 default_breakpoint_line
, addr_string
,
5176 *sals
= decode_line_1 (address
, 1, (struct symtab
*) NULL
, 0,
5177 addr_string
, not_found_ptr
);
5179 /* For any SAL that didn't have a canonical string, fill one in. */
5180 if (sals
->nelts
> 0 && *addr_string
== NULL
)
5181 *addr_string
= xcalloc (sals
->nelts
, sizeof (char **));
5182 if (addr_start
!= (*address
))
5185 for (i
= 0; i
< sals
->nelts
; i
++)
5187 /* Add the string if not present. */
5188 if ((*addr_string
)[i
] == NULL
)
5189 (*addr_string
)[i
] = savestring (addr_start
, (*address
) - addr_start
);
5195 /* Convert each SAL into a real PC. Verify that the PC can be
5196 inserted as a breakpoint. If it can't throw an error. */
5199 breakpoint_sals_to_pc (struct symtabs_and_lines
*sals
,
5203 for (i
= 0; i
< sals
->nelts
; i
++)
5205 resolve_sal_pc (&sals
->sals
[i
]);
5207 /* It's possible for the PC to be nonzero, but still an illegal
5208 value on some targets.
5210 For example, on HP-UX if you start gdb, and before running the
5211 inferior you try to set a breakpoint on a shared library function
5212 "foo" where the inferior doesn't call "foo" directly but does
5213 pass its address to another function call, then we do find a
5214 minimal symbol for the "foo", but it's address is invalid.
5215 (Appears to be an index into a table that the loader sets up
5216 when the inferior is run.)
5218 Give the target a chance to bless sals.sals[i].pc before we
5219 try to make a breakpoint for it. */
5220 #ifdef DEPRECATED_PC_REQUIRES_RUN_BEFORE_USE
5221 if (DEPRECATED_PC_REQUIRES_RUN_BEFORE_USE (sals
->sals
[i
].pc
))
5223 if (address
== NULL
)
5224 error (_("Cannot break without a running program."));
5226 error (_("Cannot break on %s without a running program."),
5234 do_captured_parse_breakpoint (struct ui_out
*ui
, void *data
)
5236 struct captured_parse_breakpoint_args
*args
= data
;
5238 parse_breakpoint_sals (args
->arg_p
, args
->sals_p
, args
->addr_string_p
,
5239 args
->not_found_ptr
);
5242 /* Set a breakpoint according to ARG (function, linenum or *address)
5243 flag: first bit : 0 non-temporary, 1 temporary.
5244 second bit : 0 normal breakpoint, 1 hardware breakpoint.
5246 PENDING_BP is non-NULL when this function is being called to resolve
5247 a pending breakpoint. */
5250 break_command_1 (char *arg
, int flag
, int from_tty
, struct breakpoint
*pending_bp
)
5252 struct gdb_exception e
;
5253 int tempflag
, hardwareflag
;
5254 struct symtabs_and_lines sals
;
5255 struct expression
**cond
= 0;
5256 struct symtab_and_line pending_sal
;
5257 char **cond_string
= (char **) NULL
;
5260 char *addr_start
= arg
;
5262 struct cleanup
*old_chain
;
5263 struct cleanup
*breakpoint_chain
= NULL
;
5264 struct captured_parse_breakpoint_args parse_args
;
5268 int ignore_count
= 0;
5271 hardwareflag
= flag
& BP_HARDWAREFLAG
;
5272 tempflag
= flag
& BP_TEMPFLAG
;
5278 parse_args
.arg_p
= &arg
;
5279 parse_args
.sals_p
= &sals
;
5280 parse_args
.addr_string_p
= &addr_string
;
5281 parse_args
.not_found_ptr
= ¬_found
;
5283 e
= catch_exception (uiout
, do_captured_parse_breakpoint
,
5284 &parse_args
, RETURN_MASK_ALL
);
5286 /* If caller is interested in rc value from parse, set value. */
5290 exception_print (gdb_stderr
, e
);
5295 case NOT_FOUND_ERROR
:
5296 /* If called to resolve pending breakpoint, just return
5301 exception_print (gdb_stderr
, e
);
5303 /* If pending breakpoint support is turned off, throw
5306 if (pending_break_support
== AUTO_BOOLEAN_FALSE
)
5307 deprecated_throw_reason (RETURN_ERROR
);
5309 /* If pending breakpoint support is auto query and the user
5310 selects no, then simply return the error code. */
5311 if (pending_break_support
== AUTO_BOOLEAN_AUTO
&&
5312 !nquery ("Make breakpoint pending on future shared library load? "))
5315 /* At this point, either the user was queried about setting
5316 a pending breakpoint and selected yes, or pending
5317 breakpoint behavior is on and thus a pending breakpoint
5318 is defaulted on behalf of the user. */
5319 copy_arg
= xstrdup (addr_start
);
5320 addr_string
= ©_arg
;
5322 sals
.sals
= &pending_sal
;
5327 exception_print (gdb_stderr
, e
);
5335 /* Create a chain of things that always need to be cleaned up. */
5336 old_chain
= make_cleanup (null_cleanup
, 0);
5340 /* Make sure that all storage allocated to SALS gets freed. */
5341 make_cleanup (xfree
, sals
.sals
);
5343 /* Cleanup the addr_string array but not its contents. */
5344 make_cleanup (xfree
, addr_string
);
5347 /* Allocate space for all the cond expressions. */
5348 cond
= xcalloc (sals
.nelts
, sizeof (struct expression
*));
5349 make_cleanup (xfree
, cond
);
5351 /* Allocate space for all the cond strings. */
5352 cond_string
= xcalloc (sals
.nelts
, sizeof (char **));
5353 make_cleanup (xfree
, cond_string
);
5355 /* ----------------------------- SNIP -----------------------------
5356 Anything added to the cleanup chain beyond this point is assumed
5357 to be part of a breakpoint. If the breakpoint create succeeds
5358 then the memory is not reclaimed. */
5359 breakpoint_chain
= make_cleanup (null_cleanup
, 0);
5361 /* Mark the contents of the addr_string for cleanup. These go on
5362 the breakpoint_chain and only occure if the breakpoint create
5364 for (i
= 0; i
< sals
.nelts
; i
++)
5366 if (addr_string
[i
] != NULL
)
5367 make_cleanup (xfree
, addr_string
[i
]);
5370 /* Resolve all line numbers to PC's and verify that the addresses
5371 are ok for the target. */
5373 breakpoint_sals_to_pc (&sals
, addr_start
);
5375 /* Verify that condition can be parsed, before setting any
5376 breakpoints. Allocate a separate condition expression for each
5378 thread
= -1; /* No specific thread yet */
5381 for (i
= 0; i
< sals
.nelts
; i
++)
5388 char *cond_start
= NULL
;
5389 char *cond_end
= NULL
;
5390 while (*tok
== ' ' || *tok
== '\t')
5395 while (*end_tok
!= ' ' && *end_tok
!= '\t' && *end_tok
!= '\000')
5398 toklen
= end_tok
- tok
;
5400 if (toklen
>= 1 && strncmp (tok
, "if", toklen
) == 0)
5402 tok
= cond_start
= end_tok
+ 1;
5403 cond
[i
] = parse_exp_1 (&tok
, block_for_pc (sals
.sals
[i
].pc
),
5405 make_cleanup (xfree
, cond
[i
]);
5407 cond_string
[i
] = savestring (cond_start
,
5408 cond_end
- cond_start
);
5409 make_cleanup (xfree
, cond_string
[i
]);
5411 else if (toklen
>= 1 && strncmp (tok
, "thread", toklen
) == 0)
5417 thread
= strtol (tok
, &tok
, 0);
5419 error (_("Junk after thread keyword."));
5420 if (!valid_thread_id (thread
))
5421 error (_("Unknown thread %d."), thread
);
5424 error (_("Junk at end of arguments."));
5427 create_breakpoints (sals
, addr_string
, cond
, cond_string
,
5428 hardwareflag
? bp_hardware_breakpoint
5430 tempflag
? disp_del
: disp_donttouch
,
5431 thread
, ignore_count
, from_tty
,
5436 struct symtab_and_line sal
;
5437 struct breakpoint
*b
;
5442 make_cleanup (xfree
, copy_arg
);
5444 b
= set_raw_breakpoint (sal
, hardwareflag
? bp_hardware_breakpoint
5446 set_breakpoint_count (breakpoint_count
+ 1);
5447 b
->number
= breakpoint_count
;
5450 b
->addr_string
= *addr_string
;
5451 b
->cond_string
= *cond_string
;
5452 b
->ignore_count
= ignore_count
;
5454 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
5455 b
->from_tty
= from_tty
;
5461 warning (_("Multiple breakpoints were set.\n"
5462 "Use the \"delete\" command to delete unwanted breakpoints."));
5463 /* That's it. Discard the cleanups for data inserted into the
5465 discard_cleanups (breakpoint_chain
);
5466 /* But cleanup everything else. */
5467 do_cleanups (old_chain
);
5472 /* Set a breakpoint of TYPE/DISPOSITION according to ARG (function,
5473 linenum or *address) with COND and IGNORE_COUNT. */
5475 struct captured_breakpoint_args
5486 do_captured_breakpoint (struct ui_out
*uiout
, void *data
)
5488 struct captured_breakpoint_args
*args
= data
;
5489 struct symtabs_and_lines sals
;
5490 struct expression
**cond
;
5491 struct cleanup
*old_chain
;
5492 struct cleanup
*breakpoint_chain
= NULL
;
5499 /* Parse the source and lines spec. Delay check that the expression
5500 didn't contain trailing garbage until after cleanups are in
5504 address_end
= args
->address
;
5506 parse_breakpoint_sals (&address_end
, &sals
, &addr_string
, 0);
5511 /* Create a chain of things at always need to be cleaned up. */
5512 old_chain
= make_cleanup (null_cleanup
, 0);
5514 /* Always have a addr_string array, even if it is empty. */
5515 make_cleanup (xfree
, addr_string
);
5517 /* Make sure that all storage allocated to SALS gets freed. */
5518 make_cleanup (xfree
, sals
.sals
);
5520 /* Allocate space for all the cond expressions. */
5521 cond
= xcalloc (sals
.nelts
, sizeof (struct expression
*));
5522 make_cleanup (xfree
, cond
);
5524 /* Allocate space for all the cond strings. */
5525 cond_string
= xcalloc (sals
.nelts
, sizeof (char **));
5526 make_cleanup (xfree
, cond_string
);
5528 /* ----------------------------- SNIP -----------------------------
5529 Anything added to the cleanup chain beyond this point is assumed
5530 to be part of a breakpoint. If the breakpoint create goes
5531 through then that memory is not cleaned up. */
5532 breakpoint_chain
= make_cleanup (null_cleanup
, 0);
5534 /* Mark the contents of the addr_string for cleanup. These go on
5535 the breakpoint_chain and only occure if the breakpoint create
5537 for (i
= 0; i
< sals
.nelts
; i
++)
5539 if (addr_string
[i
] != NULL
)
5540 make_cleanup (xfree
, addr_string
[i
]);
5543 /* Wait until now before checking for garbage at the end of the
5544 address. That way cleanups can take care of freeing any
5546 if (*address_end
!= '\0')
5547 error (_("Garbage %s following breakpoint address"), address_end
);
5549 /* Resolve all line numbers to PC's. */
5550 breakpoint_sals_to_pc (&sals
, args
->address
);
5552 /* Verify that conditions can be parsed, before setting any
5554 for (i
= 0; i
< sals
.nelts
; i
++)
5556 if (args
->condition
!= NULL
)
5558 char *tok
= args
->condition
;
5559 cond
[i
] = parse_exp_1 (&tok
, block_for_pc (sals
.sals
[i
].pc
), 0);
5561 error (_("Garbage %s follows condition"), tok
);
5562 make_cleanup (xfree
, cond
[i
]);
5563 cond_string
[i
] = xstrdup (args
->condition
);
5567 create_breakpoints (sals
, addr_string
, cond
, cond_string
,
5568 args
->hardwareflag
? bp_hardware_breakpoint
: bp_breakpoint
,
5569 args
->tempflag
? disp_del
: disp_donttouch
,
5570 args
->thread
, args
->ignore_count
, 0/*from-tty*/,
5571 NULL
/*pending_bp*/);
5573 /* That's it. Discard the cleanups for data inserted into the
5575 discard_cleanups (breakpoint_chain
);
5576 /* But cleanup everything else. */
5577 do_cleanups (old_chain
);
5582 gdb_breakpoint (char *address
, char *condition
,
5583 int hardwareflag
, int tempflag
,
5584 int thread
, int ignore_count
,
5585 char **error_message
)
5587 struct captured_breakpoint_args args
;
5588 args
.address
= address
;
5589 args
.condition
= condition
;
5590 args
.hardwareflag
= hardwareflag
;
5591 args
.tempflag
= tempflag
;
5592 args
.thread
= thread
;
5593 args
.ignore_count
= ignore_count
;
5594 if (catch_exceptions_with_msg (uiout
, do_captured_breakpoint
, &args
,
5595 error_message
, RETURN_MASK_ALL
) < 0)
5602 /* Helper function for break_command_1 and disassemble_command. */
5605 resolve_sal_pc (struct symtab_and_line
*sal
)
5609 if (sal
->pc
== 0 && sal
->symtab
!= NULL
)
5611 if (!find_line_pc (sal
->symtab
, sal
->line
, &pc
))
5612 error (_("No line %d in file \"%s\"."),
5613 sal
->line
, sal
->symtab
->filename
);
5617 if (sal
->section
== 0 && sal
->symtab
!= NULL
)
5619 struct blockvector
*bv
;
5624 bv
= blockvector_for_pc_sect (sal
->pc
, 0, &index
, sal
->symtab
);
5627 b
= BLOCKVECTOR_BLOCK (bv
, index
);
5628 sym
= block_function (b
);
5631 fixup_symbol_section (sym
, sal
->symtab
->objfile
);
5632 sal
->section
= SYMBOL_BFD_SECTION (sym
);
5636 /* It really is worthwhile to have the section, so we'll just
5637 have to look harder. This case can be executed if we have
5638 line numbers but no functions (as can happen in assembly
5641 struct minimal_symbol
*msym
;
5643 msym
= lookup_minimal_symbol_by_pc (sal
->pc
);
5645 sal
->section
= SYMBOL_BFD_SECTION (msym
);
5652 break_command (char *arg
, int from_tty
)
5654 break_command_1 (arg
, 0, from_tty
, NULL
);
5658 tbreak_command (char *arg
, int from_tty
)
5660 break_command_1 (arg
, BP_TEMPFLAG
, from_tty
, NULL
);
5664 hbreak_command (char *arg
, int from_tty
)
5666 break_command_1 (arg
, BP_HARDWAREFLAG
, from_tty
, NULL
);
5670 thbreak_command (char *arg
, int from_tty
)
5672 break_command_1 (arg
, (BP_TEMPFLAG
| BP_HARDWAREFLAG
), from_tty
, NULL
);
5676 stop_command (char *arg
, int from_tty
)
5678 printf_filtered (_("Specify the type of breakpoint to set.\n\
5679 Usage: stop in <function | address>\n\
5680 stop at <line>\n"));
5684 stopin_command (char *arg
, int from_tty
)
5688 if (arg
== (char *) NULL
)
5690 else if (*arg
!= '*')
5695 /* look for a ':'. If this is a line number specification, then
5696 say it is bad, otherwise, it should be an address or
5697 function/method name */
5698 while (*argptr
&& !hasColon
)
5700 hasColon
= (*argptr
== ':');
5705 badInput
= (*argptr
!= ':'); /* Not a class::method */
5707 badInput
= isdigit (*arg
); /* a simple line number */
5711 printf_filtered (_("Usage: stop in <function | address>\n"));
5713 break_command_1 (arg
, 0, from_tty
, NULL
);
5717 stopat_command (char *arg
, int from_tty
)
5721 if (arg
== (char *) NULL
|| *arg
== '*') /* no line number */
5728 /* look for a ':'. If there is a '::' then get out, otherwise
5729 it is probably a line number. */
5730 while (*argptr
&& !hasColon
)
5732 hasColon
= (*argptr
== ':');
5737 badInput
= (*argptr
== ':'); /* we have class::method */
5739 badInput
= !isdigit (*arg
); /* not a line number */
5743 printf_filtered (_("Usage: stop at <line>\n"));
5745 break_command_1 (arg
, 0, from_tty
, NULL
);
5748 /* accessflag: hw_write: watch write,
5749 hw_read: watch read,
5750 hw_access: watch access (read or write) */
5752 watch_command_1 (char *arg
, int accessflag
, int from_tty
)
5754 struct breakpoint
*b
;
5755 struct symtab_and_line sal
;
5756 struct expression
*exp
;
5757 struct block
*exp_valid_block
;
5758 struct value
*val
, *mark
;
5759 struct frame_info
*frame
;
5760 struct frame_info
*prev_frame
= NULL
;
5761 char *exp_start
= NULL
;
5762 char *exp_end
= NULL
;
5763 char *tok
, *end_tok
;
5765 char *cond_start
= NULL
;
5766 char *cond_end
= NULL
;
5767 struct expression
*cond
= NULL
;
5768 int i
, other_type_used
, target_resources_ok
= 0;
5769 enum bptype bp_type
;
5772 init_sal (&sal
); /* initialize to zeroes */
5774 /* Parse arguments. */
5775 innermost_block
= NULL
;
5777 exp
= parse_exp_1 (&arg
, 0, 0);
5779 exp_valid_block
= innermost_block
;
5780 mark
= value_mark ();
5781 val
= evaluate_expression (exp
);
5782 release_value (val
);
5783 if (value_lazy (val
))
5784 value_fetch_lazy (val
);
5787 while (*tok
== ' ' || *tok
== '\t')
5791 while (*end_tok
!= ' ' && *end_tok
!= '\t' && *end_tok
!= '\000')
5794 toklen
= end_tok
- tok
;
5795 if (toklen
>= 1 && strncmp (tok
, "if", toklen
) == 0)
5797 tok
= cond_start
= end_tok
+ 1;
5798 cond
= parse_exp_1 (&tok
, 0, 0);
5802 error (_("Junk at end of command."));
5804 if (accessflag
== hw_read
)
5805 bp_type
= bp_read_watchpoint
;
5806 else if (accessflag
== hw_access
)
5807 bp_type
= bp_access_watchpoint
;
5809 bp_type
= bp_hardware_watchpoint
;
5811 mem_cnt
= can_use_hardware_watchpoint (val
);
5812 if (mem_cnt
== 0 && bp_type
!= bp_hardware_watchpoint
)
5813 error (_("Expression cannot be implemented with read/access watchpoint."));
5816 i
= hw_watchpoint_used_count (bp_type
, &other_type_used
);
5817 target_resources_ok
=
5818 TARGET_CAN_USE_HARDWARE_WATCHPOINT (bp_type
, i
+ mem_cnt
,
5820 if (target_resources_ok
== 0 && bp_type
!= bp_hardware_watchpoint
)
5821 error (_("Target does not support this type of hardware watchpoint."));
5823 if (target_resources_ok
< 0 && bp_type
!= bp_hardware_watchpoint
)
5824 error (_("Target can only support one kind of HW watchpoint at a time."));
5827 #if defined(HPUXHPPA)
5828 /* On HP-UX if you set a h/w
5829 watchpoint before the "run" command, the inferior dies with a e.g.,
5830 SIGILL once you start it. I initially believed this was due to a
5831 bad interaction between page protection traps and the initial
5832 startup sequence by the dynamic linker.
5834 However, I tried avoiding that by having HP-UX's implementation of
5835 TARGET_CAN_USE_HW_WATCHPOINT return FALSE if there was no inferior_ptid
5836 yet, which forced slow watches before a "run" or "attach", and it
5837 still fails somewhere in the startup code.
5839 Until I figure out what's happening, I'm disallowing watches altogether
5840 before the "run" or "attach" command. We'll tell the user they must
5841 set watches after getting the program started. */
5842 if (!target_has_execution
)
5844 warning (_("can't do that without a running program; try \"break main\"), \"run\" first");
5847 #endif /* HPUXHPPA */
5849 /* Change the type of breakpoint to an ordinary watchpoint if a hardware
5850 watchpoint could not be set. */
5851 if (!mem_cnt
|| target_resources_ok
<= 0)
5852 bp_type
= bp_watchpoint
;
5854 /* Now set up the breakpoint. */
5855 b
= set_raw_breakpoint (sal
, bp_type
);
5856 set_breakpoint_count (breakpoint_count
+ 1);
5857 b
->number
= breakpoint_count
;
5858 b
->disposition
= disp_donttouch
;
5860 b
->exp_valid_block
= exp_valid_block
;
5861 b
->exp_string
= savestring (exp_start
, exp_end
- exp_start
);
5865 b
->cond_string
= savestring (cond_start
, cond_end
- cond_start
);
5869 frame
= block_innermost_frame (exp_valid_block
);
5872 prev_frame
= get_prev_frame (frame
);
5873 b
->watchpoint_frame
= get_frame_id (frame
);
5877 memset (&b
->watchpoint_frame
, 0, sizeof (b
->watchpoint_frame
));
5880 /* If the expression is "local", then set up a "watchpoint scope"
5881 breakpoint at the point where we've left the scope of the watchpoint
5883 if (innermost_block
)
5887 struct breakpoint
*scope_breakpoint
;
5888 scope_breakpoint
= create_internal_breakpoint (get_frame_pc (prev_frame
),
5889 bp_watchpoint_scope
);
5891 scope_breakpoint
->enable_state
= bp_enabled
;
5893 /* Automatically delete the breakpoint when it hits. */
5894 scope_breakpoint
->disposition
= disp_del
;
5896 /* Only break in the proper frame (help with recursion). */
5897 scope_breakpoint
->frame_id
= get_frame_id (prev_frame
);
5899 /* Set the address at which we will stop. */
5900 scope_breakpoint
->loc
->requested_address
5901 = get_frame_pc (prev_frame
);
5902 scope_breakpoint
->loc
->address
5903 = adjust_breakpoint_address (scope_breakpoint
->loc
->requested_address
,
5904 scope_breakpoint
->type
);
5906 /* The scope breakpoint is related to the watchpoint. We
5907 will need to act on them together. */
5908 b
->related_breakpoint
= scope_breakpoint
;
5911 value_free_to_mark (mark
);
5915 /* Return count of locations need to be watched and can be handled
5916 in hardware. If the watchpoint can not be handled
5917 in hardware return zero. */
5920 can_use_hardware_watchpoint (struct value
*v
)
5922 int found_memory_cnt
= 0;
5923 struct value
*head
= v
;
5925 /* Did the user specifically forbid us to use hardware watchpoints? */
5926 if (!can_use_hw_watchpoints
)
5929 /* Make sure that the value of the expression depends only upon
5930 memory contents, and values computed from them within GDB. If we
5931 find any register references or function calls, we can't use a
5932 hardware watchpoint.
5934 The idea here is that evaluating an expression generates a series
5935 of values, one holding the value of every subexpression. (The
5936 expression a*b+c has five subexpressions: a, b, a*b, c, and
5937 a*b+c.) GDB's values hold almost enough information to establish
5938 the criteria given above --- they identify memory lvalues,
5939 register lvalues, computed values, etcetera. So we can evaluate
5940 the expression, and then scan the chain of values that leaves
5941 behind to decide whether we can detect any possible change to the
5942 expression's final value using only hardware watchpoints.
5944 However, I don't think that the values returned by inferior
5945 function calls are special in any way. So this function may not
5946 notice that an expression involving an inferior function call
5947 can't be watched with hardware watchpoints. FIXME. */
5948 for (; v
; v
= value_next (v
))
5950 if (VALUE_LVAL (v
) == lval_memory
)
5953 /* A lazy memory lvalue is one that GDB never needed to fetch;
5954 we either just used its address (e.g., `a' in `a.b') or
5955 we never needed it at all (e.g., `a' in `a,b'). */
5959 /* Ahh, memory we actually used! Check if we can cover
5960 it with hardware watchpoints. */
5961 struct type
*vtype
= check_typedef (value_type (v
));
5963 /* We only watch structs and arrays if user asked for it
5964 explicitly, never if they just happen to appear in a
5965 middle of some value chain. */
5967 || (TYPE_CODE (vtype
) != TYPE_CODE_STRUCT
5968 && TYPE_CODE (vtype
) != TYPE_CODE_ARRAY
))
5970 CORE_ADDR vaddr
= VALUE_ADDRESS (v
) + value_offset (v
);
5971 int len
= TYPE_LENGTH (value_type (v
));
5973 if (!TARGET_REGION_OK_FOR_HW_WATCHPOINT (vaddr
, len
))
5980 else if (VALUE_LVAL (v
) != not_lval
5981 && deprecated_value_modifiable (v
) == 0)
5982 return 0; /* ??? What does this represent? */
5983 else if (VALUE_LVAL (v
) == lval_register
)
5984 return 0; /* cannot watch a register with a HW watchpoint */
5987 /* The expression itself looks suitable for using a hardware
5988 watchpoint, but give the target machine a chance to reject it. */
5989 return found_memory_cnt
;
5993 watch_command_wrapper (char *arg
, int from_tty
)
5995 watch_command (arg
, from_tty
);
5999 watch_command (char *arg
, int from_tty
)
6001 watch_command_1 (arg
, hw_write
, from_tty
);
6005 rwatch_command_wrapper (char *arg
, int from_tty
)
6007 rwatch_command (arg
, from_tty
);
6011 rwatch_command (char *arg
, int from_tty
)
6013 watch_command_1 (arg
, hw_read
, from_tty
);
6017 awatch_command_wrapper (char *arg
, int from_tty
)
6019 awatch_command (arg
, from_tty
);
6023 awatch_command (char *arg
, int from_tty
)
6025 watch_command_1 (arg
, hw_access
, from_tty
);
6029 /* Helper routines for the until_command routine in infcmd.c. Here
6030 because it uses the mechanisms of breakpoints. */
6032 /* This function is called by fetch_inferior_event via the
6033 cmd_continuation pointer, to complete the until command. It takes
6034 care of cleaning up the temporary breakpoints set up by the until
6037 until_break_command_continuation (struct continuation_arg
*arg
)
6039 struct cleanup
*cleanups
;
6041 cleanups
= (struct cleanup
*) arg
->data
.pointer
;
6042 do_exec_cleanups (cleanups
);
6046 until_break_command (char *arg
, int from_tty
, int anywhere
)
6048 struct symtabs_and_lines sals
;
6049 struct symtab_and_line sal
;
6050 struct frame_info
*frame
= get_selected_frame (NULL
);
6051 struct frame_info
*prev_frame
= get_prev_frame (frame
);
6052 struct breakpoint
*breakpoint
;
6053 struct cleanup
*old_chain
;
6054 struct continuation_arg
*arg1
;
6057 clear_proceed_status ();
6059 /* Set a breakpoint where the user wants it and at return from
6062 if (default_breakpoint_valid
)
6063 sals
= decode_line_1 (&arg
, 1, default_breakpoint_symtab
,
6064 default_breakpoint_line
, (char ***) NULL
, NULL
);
6066 sals
= decode_line_1 (&arg
, 1, (struct symtab
*) NULL
,
6067 0, (char ***) NULL
, NULL
);
6069 if (sals
.nelts
!= 1)
6070 error (_("Couldn't get information on specified line."));
6073 xfree (sals
.sals
); /* malloc'd, so freed */
6076 error (_("Junk at end of arguments."));
6078 resolve_sal_pc (&sal
);
6081 /* If the user told us to continue until a specified location,
6082 we don't specify a frame at which we need to stop. */
6083 breakpoint
= set_momentary_breakpoint (sal
, null_frame_id
, bp_until
);
6085 /* Otherwise, specify the current frame, because we want to stop only
6086 at the very same frame. */
6087 breakpoint
= set_momentary_breakpoint (sal
, get_frame_id (frame
),
6090 if (!target_can_async_p ())
6091 old_chain
= make_cleanup_delete_breakpoint (breakpoint
);
6093 old_chain
= make_exec_cleanup_delete_breakpoint (breakpoint
);
6095 /* If we are running asynchronously, and the target supports async
6096 execution, we are not waiting for the target to stop, in the call
6097 tp proceed, below. This means that we cannot delete the
6098 brekpoints until the target has actually stopped. The only place
6099 where we get a chance to do that is in fetch_inferior_event, so
6100 we must set things up for that. */
6102 if (target_can_async_p ())
6104 /* In this case the arg for the continuation is just the point
6105 in the exec_cleanups chain from where to start doing
6106 cleanups, because all the continuation does is the cleanups in
6107 the exec_cleanup_chain. */
6109 (struct continuation_arg
*) xmalloc (sizeof (struct continuation_arg
));
6111 arg1
->data
.pointer
= old_chain
;
6113 add_continuation (until_break_command_continuation
, arg1
);
6116 /* Keep within the current frame, or in frames called by the current
6120 sal
= find_pc_line (get_frame_pc (prev_frame
), 0);
6121 sal
.pc
= get_frame_pc (prev_frame
);
6122 breakpoint
= set_momentary_breakpoint (sal
, get_frame_id (prev_frame
),
6124 if (!target_can_async_p ())
6125 make_cleanup_delete_breakpoint (breakpoint
);
6127 make_exec_cleanup_delete_breakpoint (breakpoint
);
6130 proceed (-1, TARGET_SIGNAL_DEFAULT
, 0);
6131 /* Do the cleanups now, anly if we are not running asynchronously,
6132 of if we are, but the target is still synchronous. */
6133 if (!target_can_async_p ())
6134 do_cleanups (old_chain
);
6138 ep_skip_leading_whitespace (char **s
)
6140 if ((s
== NULL
) || (*s
== NULL
))
6142 while (isspace (**s
))
6146 /* This function examines a string, and attempts to find a token
6147 that might be an event name in the leading characters. If a
6148 possible match is found, a pointer to the last character of
6149 the token is returned. Else, NULL is returned. */
6152 ep_find_event_name_end (char *arg
)
6155 char *event_name_end
= NULL
;
6157 /* If we could depend upon the presense of strrpbrk, we'd use that... */
6161 /* We break out of the loop when we find a token delimiter.
6162 Basically, we're looking for alphanumerics and underscores;
6163 anything else delimites the token. */
6166 if (!isalnum (*s
) && (*s
!= '_'))
6172 return event_name_end
;
6176 /* This function attempts to parse an optional "if <cond>" clause
6177 from the arg string. If one is not found, it returns NULL.
6179 Else, it returns a pointer to the condition string. (It does not
6180 attempt to evaluate the string against a particular block.) And,
6181 it updates arg to point to the first character following the parsed
6182 if clause in the arg string. */
6185 ep_parse_optional_if_clause (char **arg
)
6189 if (((*arg
)[0] != 'i') || ((*arg
)[1] != 'f') || !isspace ((*arg
)[2]))
6192 /* Skip the "if" keyword. */
6195 /* Skip any extra leading whitespace, and record the start of the
6196 condition string. */
6197 ep_skip_leading_whitespace (arg
);
6200 /* Assume that the condition occupies the remainder of the arg string. */
6201 (*arg
) += strlen (cond_string
);
6206 /* This function attempts to parse an optional filename from the arg
6207 string. If one is not found, it returns NULL.
6209 Else, it returns a pointer to the parsed filename. (This function
6210 makes no attempt to verify that a file of that name exists, or is
6211 accessible.) And, it updates arg to point to the first character
6212 following the parsed filename in the arg string.
6214 Note that clients needing to preserve the returned filename for
6215 future access should copy it to their own buffers. */
6217 ep_parse_optional_filename (char **arg
)
6219 static char filename
[1024];
6224 if ((*arg_p
== '\0') || isspace (*arg_p
))
6242 /* Commands to deal with catching events, such as signals, exceptions,
6243 process start/exit, etc. */
6247 catch_fork
, catch_vfork
6252 catch_fork_command_1 (catch_fork_kind fork_kind
, char *arg
, int tempflag
,
6255 char *cond_string
= NULL
;
6257 ep_skip_leading_whitespace (&arg
);
6259 /* The allowed syntax is:
6261 catch [v]fork if <cond>
6263 First, check if there's an if clause. */
6264 cond_string
= ep_parse_optional_if_clause (&arg
);
6266 if ((*arg
!= '\0') && !isspace (*arg
))
6267 error (_("Junk at end of arguments."));
6269 /* If this target supports it, create a fork or vfork catchpoint
6270 and enable reporting of such events. */
6274 create_fork_event_catchpoint (tempflag
, cond_string
);
6277 create_vfork_event_catchpoint (tempflag
, cond_string
);
6280 error (_("unsupported or unknown fork kind; cannot catch it"));
6286 catch_exec_command_1 (char *arg
, int tempflag
, int from_tty
)
6288 char *cond_string
= NULL
;
6290 ep_skip_leading_whitespace (&arg
);
6292 /* The allowed syntax is:
6294 catch exec if <cond>
6296 First, check if there's an if clause. */
6297 cond_string
= ep_parse_optional_if_clause (&arg
);
6299 if ((*arg
!= '\0') && !isspace (*arg
))
6300 error (_("Junk at end of arguments."));
6302 /* If this target supports it, create an exec catchpoint
6303 and enable reporting of such events. */
6304 create_exec_event_catchpoint (tempflag
, cond_string
);
6308 catch_load_command_1 (char *arg
, int tempflag
, int from_tty
)
6310 char *dll_pathname
= NULL
;
6311 char *cond_string
= NULL
;
6313 ep_skip_leading_whitespace (&arg
);
6315 /* The allowed syntax is:
6317 catch load if <cond>
6318 catch load <filename>
6319 catch load <filename> if <cond>
6321 The user is not allowed to specify the <filename> after an
6324 We'll ignore the pathological case of a file named "if".
6326 First, check if there's an if clause. If so, then there
6327 cannot be a filename. */
6328 cond_string
= ep_parse_optional_if_clause (&arg
);
6330 /* If there was an if clause, then there cannot be a filename.
6331 Else, there might be a filename and an if clause. */
6332 if (cond_string
== NULL
)
6334 dll_pathname
= ep_parse_optional_filename (&arg
);
6335 ep_skip_leading_whitespace (&arg
);
6336 cond_string
= ep_parse_optional_if_clause (&arg
);
6339 if ((*arg
!= '\0') && !isspace (*arg
))
6340 error (_("Junk at end of arguments."));
6342 /* Create a load breakpoint that only triggers when a load of
6343 the specified dll (or any dll, if no pathname was specified)
6345 SOLIB_CREATE_CATCH_LOAD_HOOK (PIDGET (inferior_ptid
), tempflag
,
6346 dll_pathname
, cond_string
);
6350 catch_unload_command_1 (char *arg
, int tempflag
, int from_tty
)
6352 char *dll_pathname
= NULL
;
6353 char *cond_string
= NULL
;
6355 ep_skip_leading_whitespace (&arg
);
6357 /* The allowed syntax is:
6359 catch unload if <cond>
6360 catch unload <filename>
6361 catch unload <filename> if <cond>
6363 The user is not allowed to specify the <filename> after an
6366 We'll ignore the pathological case of a file named "if".
6368 First, check if there's an if clause. If so, then there
6369 cannot be a filename. */
6370 cond_string
= ep_parse_optional_if_clause (&arg
);
6372 /* If there was an if clause, then there cannot be a filename.
6373 Else, there might be a filename and an if clause. */
6374 if (cond_string
== NULL
)
6376 dll_pathname
= ep_parse_optional_filename (&arg
);
6377 ep_skip_leading_whitespace (&arg
);
6378 cond_string
= ep_parse_optional_if_clause (&arg
);
6381 if ((*arg
!= '\0') && !isspace (*arg
))
6382 error (_("Junk at end of arguments."));
6384 /* Create an unload breakpoint that only triggers when an unload of
6385 the specified dll (or any dll, if no pathname was specified)
6387 SOLIB_CREATE_CATCH_UNLOAD_HOOK (PIDGET (inferior_ptid
), tempflag
,
6388 dll_pathname
, cond_string
);
6391 /* Commands to deal with catching exceptions. */
6393 /* Set a breakpoint at the specified callback routine for an
6394 exception event callback */
6397 create_exception_catchpoint (int tempflag
, char *cond_string
,
6398 enum exception_event_kind ex_event
,
6399 struct symtab_and_line
*sal
)
6401 struct breakpoint
*b
;
6402 int thread
= -1; /* All threads. */
6405 if (!sal
) /* no exception support? */
6410 case EX_EVENT_THROW
:
6411 bptype
= bp_catch_throw
;
6413 case EX_EVENT_CATCH
:
6414 bptype
= bp_catch_catch
;
6416 default: /* error condition */
6417 error (_("Internal error -- invalid catchpoint kind"));
6420 b
= set_raw_breakpoint (*sal
, bptype
);
6421 set_breakpoint_count (breakpoint_count
+ 1);
6422 b
->number
= breakpoint_count
;
6424 b
->cond_string
= (cond_string
== NULL
) ?
6425 NULL
: savestring (cond_string
, strlen (cond_string
));
6427 b
->addr_string
= NULL
;
6428 b
->enable_state
= bp_enabled
;
6429 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
6433 static enum print_stop_action
6434 print_exception_catchpoint (struct breakpoint
*b
)
6436 annotate_catchpoint (b
->number
);
6438 if (strstr (b
->addr_string
, "throw") != NULL
)
6439 printf_filtered (_("\nCatchpoint %d (exception thrown)\n"),
6442 printf_filtered (_("\nCatchpoint %d (exception caught)\n"),
6445 return PRINT_SRC_AND_LOC
;
6449 print_one_exception_catchpoint (struct breakpoint
*b
, CORE_ADDR
*last_addr
)
6454 ui_out_field_core_addr (uiout
, "addr", b
->loc
->address
);
6457 *last_addr
= b
->loc
->address
;
6458 if (strstr (b
->addr_string
, "throw") != NULL
)
6459 ui_out_field_string (uiout
, "what", "exception throw");
6461 ui_out_field_string (uiout
, "what", "exception catch");
6465 print_mention_exception_catchpoint (struct breakpoint
*b
)
6467 if (strstr (b
->addr_string
, "throw") != NULL
)
6468 printf_filtered (_("Catchpoint %d (throw)"), b
->number
);
6470 printf_filtered (_("Catchpoint %d (catch)"), b
->number
);
6473 static struct breakpoint_ops gnu_v3_exception_catchpoint_ops
= {
6474 print_exception_catchpoint
,
6475 print_one_exception_catchpoint
,
6476 print_mention_exception_catchpoint
6480 handle_gnu_v3_exceptions (int tempflag
, char *cond_string
,
6481 enum exception_event_kind ex_event
, int from_tty
)
6483 char *trigger_func_name
, *nameptr
;
6484 struct symtabs_and_lines sals
;
6485 struct breakpoint
*b
;
6487 if (ex_event
== EX_EVENT_CATCH
)
6488 trigger_func_name
= xstrdup ("__cxa_begin_catch");
6490 trigger_func_name
= xstrdup ("__cxa_throw");
6492 nameptr
= trigger_func_name
;
6493 sals
= decode_line_1 (&nameptr
, 1, NULL
, 0, NULL
, NULL
);
6494 if (sals
.nelts
== 0)
6496 xfree (trigger_func_name
);
6500 b
= set_raw_breakpoint (sals
.sals
[0], bp_breakpoint
);
6501 set_breakpoint_count (breakpoint_count
+ 1);
6502 b
->number
= breakpoint_count
;
6504 b
->cond_string
= (cond_string
== NULL
) ?
6505 NULL
: savestring (cond_string
, strlen (cond_string
));
6507 b
->addr_string
= trigger_func_name
;
6508 b
->enable_state
= bp_enabled
;
6509 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
6510 b
->ops
= &gnu_v3_exception_catchpoint_ops
;
6517 /* Deal with "catch catch" and "catch throw" commands */
6520 catch_exception_command_1 (enum exception_event_kind ex_event
, char *arg
,
6521 int tempflag
, int from_tty
)
6523 char *cond_string
= NULL
;
6524 struct symtab_and_line
*sal
= NULL
;
6526 ep_skip_leading_whitespace (&arg
);
6528 cond_string
= ep_parse_optional_if_clause (&arg
);
6530 if ((*arg
!= '\0') && !isspace (*arg
))
6531 error (_("Junk at end of arguments."));
6533 if ((ex_event
!= EX_EVENT_THROW
) &&
6534 (ex_event
!= EX_EVENT_CATCH
))
6535 error (_("Unsupported or unknown exception event; cannot catch it"));
6537 if (handle_gnu_v3_exceptions (tempflag
, cond_string
, ex_event
, from_tty
))
6540 /* See if we can find a callback routine */
6541 sal
= target_enable_exception_callback (ex_event
, 1);
6545 /* We have callbacks from the runtime system for exceptions.
6546 Set a breakpoint on the sal found, if no errors */
6547 if (sal
!= (struct symtab_and_line
*) -1)
6548 create_exception_catchpoint (tempflag
, cond_string
, ex_event
, sal
);
6550 return; /* something went wrong with setting up callbacks */
6553 warning (_("Unsupported with this platform/compiler combination."));
6556 /* Create a breakpoint struct for Ada exception catchpoints. */
6559 create_ada_exception_breakpoint (struct symtab_and_line sal
,
6563 struct expression
*cond
,
6564 struct breakpoint_ops
*ops
,
6568 struct breakpoint
*b
;
6572 describe_other_breakpoints (sal
.pc
, sal
.section
, -1);
6573 /* FIXME: brobecker/2006-12-28: Actually, re-implement a special
6574 version for exception catchpoints, because two catchpoints
6575 used for different exception names will use the same address.
6576 In this case, a "breakpoint ... also set at..." warning is
6577 unproductive. Besides. the warning phrasing is also a bit
6578 inapropriate, we should use the word catchpoint, and tell
6579 the user what type of catchpoint it is. The above is good
6580 enough for now, though. */
6583 b
= set_raw_breakpoint (sal
, bp_breakpoint
);
6584 set_breakpoint_count (breakpoint_count
+ 1);
6586 b
->enable_state
= bp_enabled
;
6587 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
6588 b
->number
= breakpoint_count
;
6589 b
->ignore_count
= 0;
6591 b
->addr_string
= addr_string
;
6592 b
->language
= language_ada
;
6593 b
->cond_string
= cond_string
;
6594 b
->exp_string
= exp_string
;
6597 b
->from_tty
= from_tty
;
6602 /* Implement the "catch exception" command. */
6605 catch_ada_exception_command (char *arg
, int tempflag
, int from_tty
)
6607 struct symtab_and_line sal
;
6609 char *addr_string
= NULL
;
6610 char *exp_string
= NULL
;
6611 char *cond_string
= NULL
;
6612 struct expression
*cond
= NULL
;
6613 struct breakpoint_ops
*ops
= NULL
;
6615 sal
= ada_decode_exception_location (arg
, &addr_string
, &exp_string
,
6616 &cond_string
, &cond
, &ops
);
6617 create_ada_exception_breakpoint (sal
, addr_string
, exp_string
,
6618 cond_string
, cond
, ops
, tempflag
,
6622 /* Implement the "catch assert" command. */
6625 catch_assert_command (char *arg
, int tempflag
, int from_tty
)
6627 struct symtab_and_line sal
;
6628 char *addr_string
= NULL
;
6629 struct breakpoint_ops
*ops
= NULL
;
6631 sal
= ada_decode_assert_location (arg
, &addr_string
, &ops
);
6632 create_ada_exception_breakpoint (sal
, addr_string
, NULL
, NULL
, NULL
, ops
,
6633 tempflag
, from_tty
);
6636 /* Cover routine to allow wrapping target_enable_exception_catchpoints
6637 inside a catch_errors */
6640 cover_target_enable_exception_callback (void *arg
)
6642 args_for_catchpoint_enable
*args
= arg
;
6643 struct symtab_and_line
*sal
;
6644 sal
= target_enable_exception_callback (args
->kind
, args
->enable_p
);
6647 else if (sal
== (struct symtab_and_line
*) -1)
6650 return 1; /*is valid */
6654 catch_command_1 (char *arg
, int tempflag
, int from_tty
)
6657 /* The first argument may be an event name, such as "start" or "load".
6658 If so, then handle it as such. If it doesn't match an event name,
6659 then attempt to interpret it as an exception name. (This latter is
6660 the v4.16-and-earlier GDB meaning of the "catch" command.)
6662 First, try to find the bounds of what might be an event name. */
6663 char *arg1_start
= arg
;
6667 if (arg1_start
== NULL
)
6669 /* Old behaviour was to use pre-v-4.16 syntax */
6670 /* catch_throw_command_1 (arg1_start, tempflag, from_tty); */
6672 /* Now, this is not allowed */
6673 error (_("Catch requires an event name."));
6676 arg1_end
= ep_find_event_name_end (arg1_start
);
6677 if (arg1_end
== NULL
)
6678 error (_("catch requires an event"));
6679 arg1_length
= arg1_end
+ 1 - arg1_start
;
6681 /* Try to match what we found against known event names. */
6682 if (strncmp (arg1_start
, "signal", arg1_length
) == 0)
6684 error (_("Catch of signal not yet implemented"));
6686 else if (strncmp (arg1_start
, "catch", arg1_length
) == 0)
6688 catch_exception_command_1 (EX_EVENT_CATCH
, arg1_end
+ 1,
6689 tempflag
, from_tty
);
6691 else if (strncmp (arg1_start
, "throw", arg1_length
) == 0)
6693 catch_exception_command_1 (EX_EVENT_THROW
, arg1_end
+ 1,
6694 tempflag
, from_tty
);
6696 else if (strncmp (arg1_start
, "thread_start", arg1_length
) == 0)
6698 error (_("Catch of thread_start not yet implemented"));
6700 else if (strncmp (arg1_start
, "thread_exit", arg1_length
) == 0)
6702 error (_("Catch of thread_exit not yet implemented"));
6704 else if (strncmp (arg1_start
, "thread_join", arg1_length
) == 0)
6706 error (_("Catch of thread_join not yet implemented"));
6708 else if (strncmp (arg1_start
, "start", arg1_length
) == 0)
6710 error (_("Catch of start not yet implemented"));
6712 else if (strncmp (arg1_start
, "exit", arg1_length
) == 0)
6714 error (_("Catch of exit not yet implemented"));
6716 else if (strncmp (arg1_start
, "fork", arg1_length
) == 0)
6718 catch_fork_command_1 (catch_fork
, arg1_end
+ 1, tempflag
, from_tty
);
6720 else if (strncmp (arg1_start
, "vfork", arg1_length
) == 0)
6722 catch_fork_command_1 (catch_vfork
, arg1_end
+ 1, tempflag
, from_tty
);
6724 else if (strncmp (arg1_start
, "exec", arg1_length
) == 0)
6726 catch_exec_command_1 (arg1_end
+ 1, tempflag
, from_tty
);
6728 else if (strncmp (arg1_start
, "load", arg1_length
) == 0)
6730 catch_load_command_1 (arg1_end
+ 1, tempflag
, from_tty
);
6732 else if (strncmp (arg1_start
, "unload", arg1_length
) == 0)
6734 catch_unload_command_1 (arg1_end
+ 1, tempflag
, from_tty
);
6736 else if (strncmp (arg1_start
, "stop", arg1_length
) == 0)
6738 error (_("Catch of stop not yet implemented"));
6740 else if (strncmp (arg1_start
, "exception", arg1_length
) == 0)
6742 catch_ada_exception_command (arg1_end
+ 1, tempflag
, from_tty
);
6745 else if (strncmp (arg1_start
, "assert", arg1_length
) == 0)
6747 catch_assert_command (arg1_end
+ 1, tempflag
, from_tty
);
6750 /* This doesn't appear to be an event name */
6754 /* Pre-v.4.16 behaviour was to treat the argument
6755 as the name of an exception */
6756 /* catch_throw_command_1 (arg1_start, tempflag, from_tty); */
6757 /* Now this is not allowed */
6758 error (_("Unknown event kind specified for catch"));
6763 /* Used by the gui, could be made a worker for other things. */
6766 set_breakpoint_sal (struct symtab_and_line sal
)
6768 struct breakpoint
*b
;
6769 b
= set_raw_breakpoint (sal
, bp_breakpoint
);
6770 set_breakpoint_count (breakpoint_count
+ 1);
6771 b
->number
= breakpoint_count
;
6778 catch_command (char *arg
, int from_tty
)
6780 catch_command_1 (arg
, 0, from_tty
);
6785 tcatch_command (char *arg
, int from_tty
)
6787 catch_command_1 (arg
, 1, from_tty
);
6790 /* Delete breakpoints by address or line. */
6793 clear_command (char *arg
, int from_tty
)
6795 struct breakpoint
*b
, *tmp
, *prev
, *found
;
6797 struct symtabs_and_lines sals
;
6798 struct symtab_and_line sal
;
6803 sals
= decode_line_spec (arg
, 1);
6808 sals
.sals
= (struct symtab_and_line
*)
6809 xmalloc (sizeof (struct symtab_and_line
));
6810 make_cleanup (xfree
, sals
.sals
);
6811 init_sal (&sal
); /* initialize to zeroes */
6812 sal
.line
= default_breakpoint_line
;
6813 sal
.symtab
= default_breakpoint_symtab
;
6814 sal
.pc
= default_breakpoint_address
;
6815 if (sal
.symtab
== 0)
6816 error (_("No source file specified."));
6824 /* For each line spec given, delete bps which correspond
6825 to it. Do it in two passes, solely to preserve the current
6826 behavior that from_tty is forced true if we delete more than
6830 for (i
= 0; i
< sals
.nelts
; i
++)
6832 /* If exact pc given, clear bpts at that pc.
6833 If line given (pc == 0), clear all bpts on specified line.
6834 If defaulting, clear all bpts on default line
6837 defaulting sal.pc != 0 tests to do
6842 1 0 <can't happen> */
6847 /* Find all matching breakpoints, remove them from the
6848 breakpoint chain, and add them to the 'found' chain. */
6849 ALL_BREAKPOINTS_SAFE (b
, tmp
)
6851 /* Are we going to delete b? */
6852 if (b
->type
!= bp_none
6853 && b
->type
!= bp_watchpoint
6854 && b
->type
!= bp_hardware_watchpoint
6855 && b
->type
!= bp_read_watchpoint
6856 && b
->type
!= bp_access_watchpoint
6857 /* Not if b is a watchpoint of any sort... */
6858 && (((sal
.pc
&& (b
->loc
->address
== sal
.pc
))
6859 && (!section_is_overlay (b
->loc
->section
)
6860 || b
->loc
->section
== sal
.section
))
6861 /* Yes, if sal.pc matches b (modulo overlays). */
6862 || ((default_match
|| (0 == sal
.pc
))
6863 && b
->source_file
!= NULL
6864 && sal
.symtab
!= NULL
6865 && strcmp (b
->source_file
, sal
.symtab
->filename
) == 0
6866 && b
->line_number
== sal
.line
)))
6867 /* Yes, if sal source file and line matches b. */
6869 /* Remove it from breakpoint_chain... */
6870 if (b
== breakpoint_chain
)
6872 /* b is at the head of the list */
6873 breakpoint_chain
= b
->next
;
6877 prev
->next
= b
->next
;
6879 /* And add it to 'found' chain. */
6885 /* Keep b, and keep a pointer to it. */
6890 /* Now go thru the 'found' chain and delete them. */
6894 error (_("No breakpoint at %s."), arg
);
6896 error (_("No breakpoint at this line."));
6900 from_tty
= 1; /* Always report if deleted more than one */
6904 printf_unfiltered (_("Deleted breakpoint "));
6906 printf_unfiltered (_("Deleted breakpoints "));
6908 breakpoints_changed ();
6912 printf_unfiltered ("%d ", found
->number
);
6914 delete_breakpoint (found
);
6918 putchar_unfiltered ('\n');
6921 /* Delete breakpoint in BS if they are `delete' breakpoints and
6922 all breakpoints that are marked for deletion, whether hit or not.
6923 This is called after any breakpoint is hit, or after errors. */
6926 breakpoint_auto_delete (bpstat bs
)
6928 struct breakpoint
*b
, *temp
;
6930 for (; bs
; bs
= bs
->next
)
6931 if (bs
->breakpoint_at
&& bs
->breakpoint_at
->disposition
== disp_del
6933 delete_breakpoint (bs
->breakpoint_at
);
6935 ALL_BREAKPOINTS_SAFE (b
, temp
)
6937 if (b
->disposition
== disp_del_at_next_stop
)
6938 delete_breakpoint (b
);
6942 /* Delete a breakpoint and clean up all traces of it in the data
6946 delete_breakpoint (struct breakpoint
*bpt
)
6948 struct breakpoint
*b
;
6950 struct bp_location
*loc
;
6952 gdb_assert (bpt
!= NULL
);
6954 /* Has this bp already been deleted? This can happen because multiple
6955 lists can hold pointers to bp's. bpstat lists are especial culprits.
6957 One example of this happening is a watchpoint's scope bp. When the
6958 scope bp triggers, we notice that the watchpoint is out of scope, and
6959 delete it. We also delete its scope bp. But the scope bp is marked
6960 "auto-deleting", and is already on a bpstat. That bpstat is then
6961 checked for auto-deleting bp's, which are deleted.
6963 A real solution to this problem might involve reference counts in bp's,
6964 and/or giving them pointers back to their referencing bpstat's, and
6965 teaching delete_breakpoint to only free a bp's storage when no more
6966 references were extent. A cheaper bandaid was chosen. */
6967 if (bpt
->type
== bp_none
)
6970 if (deprecated_delete_breakpoint_hook
)
6971 deprecated_delete_breakpoint_hook (bpt
);
6972 breakpoint_delete_event (bpt
->number
);
6974 if (bpt
->loc
->inserted
)
6975 remove_breakpoint (bpt
->loc
, mark_inserted
);
6977 free_valchain (bpt
->loc
);
6979 if (breakpoint_chain
== bpt
)
6980 breakpoint_chain
= bpt
->next
;
6982 if (bp_location_chain
== bpt
->loc
)
6983 bp_location_chain
= bpt
->loc
->next
;
6985 /* If we have callback-style exception catchpoints, don't go through
6986 the adjustments to the C++ runtime library etc. if the inferior
6987 isn't actually running. target_enable_exception_callback for a
6988 null target ops vector gives an undesirable error message, so we
6989 check here and avoid it. Since currently (1997-09-17) only HP-UX aCC's
6990 exceptions are supported in this way, it's OK for now. FIXME */
6991 if (ep_is_exception_catchpoint (bpt
) && target_has_execution
)
6993 /* Format possible error msg */
6994 char *message
= xstrprintf ("Error in deleting catchpoint %d:\n",
6996 struct cleanup
*cleanups
= make_cleanup (xfree
, message
);
6997 args_for_catchpoint_enable args
;
6998 args
.kind
= bpt
->type
== bp_catch_catch
?
6999 EX_EVENT_CATCH
: EX_EVENT_THROW
;
7001 catch_errors (cover_target_enable_exception_callback
, &args
,
7002 message
, RETURN_MASK_ALL
);
7003 do_cleanups (cleanups
);
7010 b
->next
= bpt
->next
;
7014 ALL_BP_LOCATIONS (loc
)
7015 if (loc
->next
== bpt
->loc
)
7017 loc
->next
= bpt
->loc
->next
;
7021 check_duplicates (bpt
);
7022 /* If this breakpoint was inserted, and there is another breakpoint
7023 at the same address, we need to insert the other breakpoint. */
7024 if (bpt
->loc
->inserted
7025 && bpt
->type
!= bp_hardware_watchpoint
7026 && bpt
->type
!= bp_read_watchpoint
7027 && bpt
->type
!= bp_access_watchpoint
7028 && bpt
->type
!= bp_catch_fork
7029 && bpt
->type
!= bp_catch_vfork
7030 && bpt
->type
!= bp_catch_exec
)
7033 if (b
->loc
->address
== bpt
->loc
->address
7034 && b
->loc
->section
== bpt
->loc
->section
7035 && !b
->loc
->duplicate
7036 && b
->enable_state
!= bp_disabled
7037 && b
->enable_state
!= bp_shlib_disabled
7039 && b
->enable_state
!= bp_call_disabled
)
7043 /* We should never reach this point if there is a permanent
7044 breakpoint at the same address as the one being deleted.
7045 If there is a permanent breakpoint somewhere, it should
7046 always be the only one inserted. */
7047 if (b
->enable_state
== bp_permanent
)
7048 internal_error (__FILE__
, __LINE__
,
7049 _("another breakpoint was inserted on top of "
7050 "a permanent breakpoint"));
7052 memset (&b
->loc
->target_info
, 0, sizeof (b
->loc
->target_info
));
7053 b
->loc
->target_info
.placed_address
= b
->loc
->address
;
7054 if (b
->type
== bp_hardware_breakpoint
)
7055 val
= target_insert_hw_breakpoint (&b
->loc
->target_info
);
7057 val
= target_insert_breakpoint (&b
->loc
->target_info
);
7059 /* If there was an error in the insert, print a message, then stop execution. */
7062 struct ui_file
*tmp_error_stream
= mem_fileopen ();
7063 make_cleanup_ui_file_delete (tmp_error_stream
);
7066 if (b
->type
== bp_hardware_breakpoint
)
7068 fprintf_unfiltered (tmp_error_stream
,
7069 "Cannot insert hardware breakpoint %d.\n"
7070 "You may have requested too many hardware breakpoints.\n",
7075 fprintf_unfiltered (tmp_error_stream
, "Cannot insert breakpoint %d.\n", b
->number
);
7076 fprintf_filtered (tmp_error_stream
, "Error accessing memory address ");
7077 deprecated_print_address_numeric (b
->loc
->address
, 1, tmp_error_stream
);
7078 fprintf_filtered (tmp_error_stream
, ": %s.\n",
7079 safe_strerror (val
));
7082 fprintf_unfiltered (tmp_error_stream
,"The same program may be running in another process.");
7083 target_terminal_ours_for_output ();
7084 error_stream(tmp_error_stream
);
7087 b
->loc
->inserted
= 1;
7091 free_command_lines (&bpt
->commands
);
7094 if (bpt
->cond_string
!= NULL
)
7095 xfree (bpt
->cond_string
);
7096 if (bpt
->addr_string
!= NULL
)
7097 xfree (bpt
->addr_string
);
7098 if (bpt
->exp
!= NULL
)
7100 if (bpt
->exp_string
!= NULL
)
7101 xfree (bpt
->exp_string
);
7102 if (bpt
->val
!= NULL
)
7103 value_free (bpt
->val
);
7104 if (bpt
->source_file
!= NULL
)
7105 xfree (bpt
->source_file
);
7106 if (bpt
->dll_pathname
!= NULL
)
7107 xfree (bpt
->dll_pathname
);
7108 if (bpt
->triggered_dll_pathname
!= NULL
)
7109 xfree (bpt
->triggered_dll_pathname
);
7110 if (bpt
->exec_pathname
!= NULL
)
7111 xfree (bpt
->exec_pathname
);
7113 /* Be sure no bpstat's are pointing at it after it's been freed. */
7114 /* FIXME, how can we find all bpstat's?
7115 We just check stop_bpstat for now. */
7116 for (bs
= stop_bpstat
; bs
; bs
= bs
->next
)
7117 if (bs
->breakpoint_at
== bpt
)
7119 bs
->breakpoint_at
= NULL
;
7121 /* bs->commands will be freed later. */
7123 /* On the chance that someone will soon try again to delete this same
7124 bp, we mark it as deleted before freeing its storage. */
7125 bpt
->type
= bp_none
;
7132 do_delete_breakpoint_cleanup (void *b
)
7134 delete_breakpoint (b
);
7138 make_cleanup_delete_breakpoint (struct breakpoint
*b
)
7140 return make_cleanup (do_delete_breakpoint_cleanup
, b
);
7144 make_exec_cleanup_delete_breakpoint (struct breakpoint
*b
)
7146 return make_exec_cleanup (do_delete_breakpoint_cleanup
, b
);
7150 delete_command (char *arg
, int from_tty
)
7152 struct breakpoint
*b
, *temp
;
7158 int breaks_to_delete
= 0;
7160 /* Delete all breakpoints if no argument.
7161 Do not delete internal or call-dummy breakpoints, these
7162 have to be deleted with an explicit breakpoint number argument. */
7165 if (b
->type
!= bp_call_dummy
&&
7166 b
->type
!= bp_shlib_event
&&
7167 b
->type
!= bp_thread_event
&&
7168 b
->type
!= bp_overlay_event
&&
7171 breaks_to_delete
= 1;
7176 /* Ask user only if there are some breakpoints to delete. */
7178 || (breaks_to_delete
&& query (_("Delete all breakpoints? "))))
7180 ALL_BREAKPOINTS_SAFE (b
, temp
)
7182 if (b
->type
!= bp_call_dummy
&&
7183 b
->type
!= bp_shlib_event
&&
7184 b
->type
!= bp_thread_event
&&
7185 b
->type
!= bp_overlay_event
&&
7187 delete_breakpoint (b
);
7192 map_breakpoint_numbers (arg
, delete_breakpoint
);
7195 /* Reset a breakpoint given it's struct breakpoint * BINT.
7196 The value we return ends up being the return value from catch_errors.
7197 Unused in this case. */
7200 breakpoint_re_set_one (void *bint
)
7202 /* get past catch_errs */
7203 struct breakpoint
*b
= (struct breakpoint
*) bint
;
7207 int *not_found_ptr
= NULL
;
7208 struct symtabs_and_lines sals
;
7210 enum enable_state save_enable
;
7215 warning (_("attempted to reset apparently deleted breakpoint #%d?"),
7219 case bp_hardware_breakpoint
:
7221 case bp_catch_unload
:
7222 if (b
->addr_string
== NULL
)
7224 /* Anything without a string can't be re-set. */
7225 delete_breakpoint (b
);
7228 /* HACK: cagney/2001-11-11: kettenis/2001-11-11: MarkK wrote:
7230 ``And a hack it is, although Apple's Darwin version of GDB
7231 contains an almost identical hack to implement a "future
7232 break" command. It seems to work in many real world cases,
7233 but it is easy to come up with a test case where the patch
7234 doesn't help at all.''
7236 ``It seems that the way GDB implements breakpoints - in -
7237 shared - libraries was designed for a.out shared library
7238 systems (SunOS 4) where shared libraries were loaded at a
7239 fixed address in memory. Since ELF shared libraries can (and
7240 will) be loaded at any address in memory, things break.
7241 Fixing this is not trivial. Therefore, I'm not sure whether
7242 we should add this hack to the branch only. I cannot
7243 guarantee that things will be fixed on the trunk in the near
7246 In case we have a problem, disable this breakpoint. We'll
7247 restore its status if we succeed. Don't disable a
7248 shlib_disabled breakpoint though. There's a fair chance we
7249 can't re-set it if the shared library it's in hasn't been
7255 save_enable
= b
->enable_state
;
7256 if (b
->enable_state
!= bp_shlib_disabled
)
7257 b
->enable_state
= bp_disabled
;
7259 /* If resetting a shlib-disabled breakpoint, we don't want to
7260 see an error message if it is not found since we will expect
7261 this to occur until the shared library is finally reloaded.
7262 We accomplish this by giving decode_line_1 a pointer to use
7263 for silent notification that the symbol is not found. */
7264 not_found_ptr
= ¬_found
;
7266 set_language (b
->language
);
7267 input_radix
= b
->input_radix
;
7269 sals
= decode_line_1 (&s
, 1, (struct symtab
*) NULL
, 0, (char ***) NULL
,
7271 for (i
= 0; i
< sals
.nelts
; i
++)
7273 resolve_sal_pc (&sals
.sals
[i
]);
7275 /* Reparse conditions, they might contain references to the
7277 if (b
->cond_string
!= NULL
)
7283 /* Avoid re-freeing b->exp if an error during the call
7287 b
->cond
= parse_exp_1 (&s
, block_for_pc (sals
.sals
[i
].pc
), 0);
7290 /* We need to re-set the breakpoint if the address changes... */
7291 if (b
->loc
->address
!= sals
.sals
[i
].pc
7292 /* ...or new and old breakpoints both have source files, and
7293 the source file name or the line number changes... */
7294 || (b
->source_file
!= NULL
7295 && sals
.sals
[i
].symtab
!= NULL
7296 && (strcmp (b
->source_file
, sals
.sals
[i
].symtab
->filename
) != 0
7297 || b
->line_number
!= sals
.sals
[i
].line
)
7299 /* ...or we switch between having a source file and not having
7301 || ((b
->source_file
== NULL
) != (sals
.sals
[i
].symtab
== NULL
))
7304 if (b
->source_file
!= NULL
)
7305 xfree (b
->source_file
);
7306 if (sals
.sals
[i
].symtab
== NULL
)
7307 b
->source_file
= NULL
;
7310 savestring (sals
.sals
[i
].symtab
->filename
,
7311 strlen (sals
.sals
[i
].symtab
->filename
));
7312 b
->line_number
= sals
.sals
[i
].line
;
7313 b
->loc
->requested_address
= sals
.sals
[i
].pc
;
7315 = adjust_breakpoint_address (b
->loc
->requested_address
,
7318 /* Used to check for duplicates here, but that can
7319 cause trouble, as it doesn't check for disabled
7324 /* Might be better to do this just once per breakpoint_re_set,
7325 rather than once for every breakpoint. */
7326 breakpoints_changed ();
7328 b
->loc
->section
= sals
.sals
[i
].section
;
7329 b
->enable_state
= save_enable
; /* Restore it, this worked. */
7332 /* Now that this is re-enabled, check_duplicates
7334 check_duplicates (b
);
7341 case bp_hardware_watchpoint
:
7342 case bp_read_watchpoint
:
7343 case bp_access_watchpoint
:
7344 innermost_block
= NULL
;
7345 /* The issue arises of what context to evaluate this in. The
7346 same one as when it was set, but what does that mean when
7347 symbols have been re-read? We could save the filename and
7348 functionname, but if the context is more local than that, the
7349 best we could do would be something like how many levels deep
7350 and which index at that particular level, but that's going to
7351 be less stable than filenames or function names. */
7353 /* So for now, just use a global context. */
7357 /* Avoid re-freeing b->exp if an error during the call to
7358 parse_expression. */
7361 b
->exp
= parse_expression (b
->exp_string
);
7362 b
->exp_valid_block
= innermost_block
;
7363 mark
= value_mark ();
7366 value_free (b
->val
);
7367 /* Avoid re-freeing b->val if an error during the call to
7368 evaluate_expression. */
7371 b
->val
= evaluate_expression (b
->exp
);
7372 release_value (b
->val
);
7373 if (value_lazy (b
->val
) && breakpoint_enabled (b
))
7374 value_fetch_lazy (b
->val
);
7376 if (b
->cond_string
!= NULL
)
7382 /* Avoid re-freeing b->exp if an error during the call
7386 b
->cond
= parse_exp_1 (&s
, (struct block
*) 0, 0);
7388 if (breakpoint_enabled (b
))
7390 value_free_to_mark (mark
);
7392 case bp_catch_catch
:
7393 case bp_catch_throw
:
7395 /* We needn't really do anything to reset these, since the mask
7396 that requests them is unaffected by e.g., new libraries being
7399 case bp_catch_vfork
:
7404 printf_filtered (_("Deleting unknown breakpoint type %d\n"), b
->type
);
7406 /* Delete longjmp and overlay event breakpoints; they will be
7407 reset later by breakpoint_re_set. */
7409 case bp_longjmp_resume
:
7410 case bp_overlay_event
:
7411 delete_breakpoint (b
);
7414 /* This breakpoint is special, it's set up when the inferior
7415 starts and we really don't want to touch it. */
7416 case bp_shlib_event
:
7418 /* Like bp_shlib_event, this breakpoint type is special.
7419 Once it is set up, we do not want to touch it. */
7420 case bp_thread_event
:
7422 /* Keep temporary breakpoints, which can be encountered when we step
7423 over a dlopen call and SOLIB_ADD is resetting the breakpoints.
7424 Otherwise these should have been blown away via the cleanup chain
7425 or by breakpoint_init_inferior when we rerun the executable. */
7428 case bp_watchpoint_scope
:
7430 case bp_step_resume
:
7437 /* Re-set all breakpoints after symbols have been re-loaded. */
7439 breakpoint_re_set (void)
7441 struct breakpoint
*b
, *temp
;
7442 enum language save_language
;
7443 int save_input_radix
;
7445 save_language
= current_language
->la_language
;
7446 save_input_radix
= input_radix
;
7447 ALL_BREAKPOINTS_SAFE (b
, temp
)
7449 /* Format possible error msg */
7450 char *message
= xstrprintf ("Error in re-setting breakpoint %d:\n",
7452 struct cleanup
*cleanups
= make_cleanup (xfree
, message
);
7453 catch_errors (breakpoint_re_set_one
, b
, message
, RETURN_MASK_ALL
);
7454 do_cleanups (cleanups
);
7456 set_language (save_language
);
7457 input_radix
= save_input_radix
;
7459 if (GET_LONGJMP_TARGET_P ())
7461 create_longjmp_breakpoint ("longjmp");
7462 create_longjmp_breakpoint ("_longjmp");
7463 create_longjmp_breakpoint ("siglongjmp");
7464 create_longjmp_breakpoint ("_siglongjmp");
7465 create_longjmp_breakpoint (NULL
);
7468 create_overlay_event_breakpoint ("_ovly_debug_event");
7471 /* Reset the thread number of this breakpoint:
7473 - If the breakpoint is for all threads, leave it as-is.
7474 - Else, reset it to the current thread for inferior_ptid. */
7476 breakpoint_re_set_thread (struct breakpoint
*b
)
7478 if (b
->thread
!= -1)
7480 if (in_thread_list (inferior_ptid
))
7481 b
->thread
= pid_to_thread_id (inferior_ptid
);
7485 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
7486 If from_tty is nonzero, it prints a message to that effect,
7487 which ends with a period (no newline). */
7490 set_ignore_count (int bptnum
, int count
, int from_tty
)
7492 struct breakpoint
*b
;
7498 if (b
->number
== bptnum
)
7500 b
->ignore_count
= count
;
7504 printf_filtered (_("Will stop next time breakpoint %d is reached."),
7506 else if (count
== 1)
7507 printf_filtered (_("Will ignore next crossing of breakpoint %d."),
7510 printf_filtered (_("Will ignore next %d crossings of breakpoint %d."),
7513 breakpoints_changed ();
7514 breakpoint_modify_event (b
->number
);
7518 error (_("No breakpoint number %d."), bptnum
);
7521 /* Clear the ignore counts of all breakpoints. */
7523 breakpoint_clear_ignore_counts (void)
7525 struct breakpoint
*b
;
7528 b
->ignore_count
= 0;
7531 /* Command to set ignore-count of breakpoint N to COUNT. */
7534 ignore_command (char *args
, int from_tty
)
7540 error_no_arg (_("a breakpoint number"));
7542 num
= get_number (&p
);
7544 error (_("bad breakpoint number: '%s'"), args
);
7546 error (_("Second argument (specified ignore-count) is missing."));
7548 set_ignore_count (num
,
7549 longest_to_int (value_as_long (parse_and_eval (p
))),
7552 printf_filtered ("\n");
7555 /* Call FUNCTION on each of the breakpoints
7556 whose numbers are given in ARGS. */
7559 map_breakpoint_numbers (char *args
, void (*function
) (struct breakpoint
*))
7564 struct breakpoint
*b
, *tmp
;
7568 error_no_arg (_("one or more breakpoint numbers"));
7575 num
= get_number_or_range (&p1
);
7578 warning (_("bad breakpoint number at or near '%s'"), p
);
7582 ALL_BREAKPOINTS_SAFE (b
, tmp
)
7583 if (b
->number
== num
)
7585 struct breakpoint
*related_breakpoint
= b
->related_breakpoint
;
7588 if (related_breakpoint
)
7589 function (related_breakpoint
);
7593 printf_unfiltered (_("No breakpoint number %d.\n"), num
);
7599 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
7600 If from_tty is nonzero, it prints a message to that effect,
7601 which ends with a period (no newline). */
7604 disable_breakpoint (struct breakpoint
*bpt
)
7606 /* Never disable a watchpoint scope breakpoint; we want to
7607 hit them when we leave scope so we can delete both the
7608 watchpoint and its scope breakpoint at that time. */
7609 if (bpt
->type
== bp_watchpoint_scope
)
7612 /* You can't disable permanent breakpoints. */
7613 if (bpt
->enable_state
== bp_permanent
)
7616 bpt
->enable_state
= bp_disabled
;
7618 check_duplicates (bpt
);
7620 if (deprecated_modify_breakpoint_hook
)
7621 deprecated_modify_breakpoint_hook (bpt
);
7622 breakpoint_modify_event (bpt
->number
);
7626 disable_command (char *args
, int from_tty
)
7628 struct breakpoint
*bpt
;
7630 ALL_BREAKPOINTS (bpt
)
7634 warning (_("attempted to disable apparently deleted breakpoint #%d?"),
7639 case bp_catch_unload
:
7641 case bp_catch_vfork
:
7643 case bp_catch_catch
:
7644 case bp_catch_throw
:
7645 case bp_hardware_breakpoint
:
7647 case bp_hardware_watchpoint
:
7648 case bp_read_watchpoint
:
7649 case bp_access_watchpoint
:
7650 disable_breakpoint (bpt
);
7655 map_breakpoint_numbers (args
, disable_breakpoint
);
7659 do_enable_breakpoint (struct breakpoint
*bpt
, enum bpdisp disposition
)
7661 int target_resources_ok
, other_type_used
;
7664 if (bpt
->type
== bp_hardware_breakpoint
)
7667 i
= hw_breakpoint_used_count ();
7668 target_resources_ok
=
7669 TARGET_CAN_USE_HARDWARE_WATCHPOINT (bp_hardware_breakpoint
,
7671 if (target_resources_ok
== 0)
7672 error (_("No hardware breakpoint support in the target."));
7673 else if (target_resources_ok
< 0)
7674 error (_("Hardware breakpoints used exceeds limit."));
7679 if (bpt
->enable_state
!= bp_enabled
)
7681 /* When enabling a pending breakpoint, we need to check if the breakpoint
7682 is resolvable since shared libraries could have been loaded
7683 after the breakpoint was disabled. */
7684 breakpoints_changed ();
7685 if (resolve_pending_breakpoint (bpt
) == GDB_RC_OK
)
7687 delete_breakpoint (bpt
);
7690 bpt
->enable_state
= bp_enabled
;
7691 bpt
->disposition
= disposition
;
7694 else /* Not a pending breakpoint. */
7696 if (bpt
->enable_state
!= bp_permanent
)
7697 bpt
->enable_state
= bp_enabled
;
7698 bpt
->disposition
= disposition
;
7699 check_duplicates (bpt
);
7700 breakpoints_changed ();
7702 if (bpt
->type
== bp_watchpoint
||
7703 bpt
->type
== bp_hardware_watchpoint
||
7704 bpt
->type
== bp_read_watchpoint
||
7705 bpt
->type
== bp_access_watchpoint
)
7707 struct frame_id saved_frame_id
;
7709 saved_frame_id
= get_frame_id (get_selected_frame (NULL
));
7710 if (bpt
->exp_valid_block
!= NULL
)
7712 struct frame_info
*fr
=
7713 fr
= frame_find_by_id (bpt
->watchpoint_frame
);
7716 printf_filtered (_("\
7717 Cannot enable watchpoint %d because the block in which its expression\n\
7718 is valid is not currently in scope.\n"), bpt
->number
);
7719 bpt
->enable_state
= bp_disabled
;
7725 value_free (bpt
->val
);
7726 mark
= value_mark ();
7727 bpt
->val
= evaluate_expression (bpt
->exp
);
7728 release_value (bpt
->val
);
7729 if (value_lazy (bpt
->val
))
7730 value_fetch_lazy (bpt
->val
);
7732 if (bpt
->type
== bp_hardware_watchpoint
||
7733 bpt
->type
== bp_read_watchpoint
||
7734 bpt
->type
== bp_access_watchpoint
)
7736 int i
= hw_watchpoint_used_count (bpt
->type
, &other_type_used
);
7737 int mem_cnt
= can_use_hardware_watchpoint (bpt
->val
);
7739 /* Hack around 'unused var' error for some targets here */
7740 (void) mem_cnt
, (void) i
;
7741 target_resources_ok
= TARGET_CAN_USE_HARDWARE_WATCHPOINT (
7742 bpt
->type
, i
+ mem_cnt
, other_type_used
);
7743 /* we can consider of type is bp_hardware_watchpoint, convert to
7744 bp_watchpoint in the following condition */
7745 if (target_resources_ok
< 0)
7747 printf_filtered (_("\
7748 Cannot enable watchpoint %d because target watch resources\n\
7749 have been allocated for other watchpoints.\n"), bpt
->number
);
7750 bpt
->enable_state
= bp_disabled
;
7751 value_free_to_mark (mark
);
7756 select_frame (frame_find_by_id (saved_frame_id
));
7757 value_free_to_mark (mark
);
7761 if (deprecated_modify_breakpoint_hook
)
7762 deprecated_modify_breakpoint_hook (bpt
);
7763 breakpoint_modify_event (bpt
->number
);
7767 enable_breakpoint (struct breakpoint
*bpt
)
7769 do_enable_breakpoint (bpt
, bpt
->disposition
);
7772 /* The enable command enables the specified breakpoints (or all defined
7773 breakpoints) so they once again become (or continue to be) effective
7774 in stopping the inferior. */
7777 enable_command (char *args
, int from_tty
)
7779 struct breakpoint
*bpt
;
7781 ALL_BREAKPOINTS (bpt
)
7785 warning (_("attempted to enable apparently deleted breakpoint #%d?"),
7790 case bp_catch_unload
:
7792 case bp_catch_vfork
:
7794 case bp_catch_catch
:
7795 case bp_catch_throw
:
7796 case bp_hardware_breakpoint
:
7798 case bp_hardware_watchpoint
:
7799 case bp_read_watchpoint
:
7800 case bp_access_watchpoint
:
7801 enable_breakpoint (bpt
);
7806 map_breakpoint_numbers (args
, enable_breakpoint
);
7810 enable_once_breakpoint (struct breakpoint
*bpt
)
7812 do_enable_breakpoint (bpt
, disp_disable
);
7816 enable_once_command (char *args
, int from_tty
)
7818 map_breakpoint_numbers (args
, enable_once_breakpoint
);
7822 enable_delete_breakpoint (struct breakpoint
*bpt
)
7824 do_enable_breakpoint (bpt
, disp_del
);
7828 enable_delete_command (char *args
, int from_tty
)
7830 map_breakpoint_numbers (args
, enable_delete_breakpoint
);
7834 set_breakpoint_cmd (char *args
, int from_tty
)
7839 show_breakpoint_cmd (char *args
, int from_tty
)
7843 /* Use default_breakpoint_'s, or nothing if they aren't valid. */
7845 struct symtabs_and_lines
7846 decode_line_spec_1 (char *string
, int funfirstline
)
7848 struct symtabs_and_lines sals
;
7850 error (_("Empty line specification."));
7851 if (default_breakpoint_valid
)
7852 sals
= decode_line_1 (&string
, funfirstline
,
7853 default_breakpoint_symtab
,
7854 default_breakpoint_line
,
7855 (char ***) NULL
, NULL
);
7857 sals
= decode_line_1 (&string
, funfirstline
,
7858 (struct symtab
*) NULL
, 0, (char ***) NULL
, NULL
);
7860 error (_("Junk at end of line specification: %s"), string
);
7864 /* Create and insert a raw software breakpoint at PC. Return an
7865 identifier, which should be used to remove the breakpoint later.
7866 In general, places which call this should be using something on the
7867 breakpoint chain instead; this function should be eliminated
7871 deprecated_insert_raw_breakpoint (CORE_ADDR pc
)
7873 struct bp_target_info
*bp_tgt
;
7875 bp_tgt
= xmalloc (sizeof (struct bp_target_info
));
7876 memset (bp_tgt
, 0, sizeof (struct bp_target_info
));
7878 bp_tgt
->placed_address
= pc
;
7879 if (target_insert_breakpoint (bp_tgt
) != 0)
7881 /* Could not insert the breakpoint. */
7889 /* Remove a breakpoint BP inserted by deprecated_insert_raw_breakpoint. */
7892 deprecated_remove_raw_breakpoint (void *bp
)
7894 struct bp_target_info
*bp_tgt
= bp
;
7897 ret
= target_remove_breakpoint (bp_tgt
);
7903 /* One (or perhaps two) breakpoints used for software single stepping. */
7905 static void *single_step_breakpoints
[2];
7907 /* Create and insert a breakpoint for software single step. */
7910 insert_single_step_breakpoint (CORE_ADDR next_pc
)
7914 if (single_step_breakpoints
[0] == NULL
)
7915 bpt_p
= &single_step_breakpoints
[0];
7918 gdb_assert (single_step_breakpoints
[1] == NULL
);
7919 bpt_p
= &single_step_breakpoints
[1];
7922 /* NOTE drow/2006-04-11: A future improvement to this function would be
7923 to only create the breakpoints once, and actually put them on the
7924 breakpoint chain. That would let us use set_raw_breakpoint. We could
7925 adjust the addresses each time they were needed. Doing this requires
7926 corresponding changes elsewhere where single step breakpoints are
7927 handled, however. So, for now, we use this. */
7929 *bpt_p
= deprecated_insert_raw_breakpoint (next_pc
);
7931 error (_("Could not insert single-step breakpoint at 0x%s"),
7932 paddr_nz (next_pc
));
7935 /* Remove and delete any breakpoints used for software single step. */
7938 remove_single_step_breakpoints (void)
7940 gdb_assert (single_step_breakpoints
[0] != NULL
);
7942 /* See insert_single_step_breakpoint for more about this deprecated
7944 deprecated_remove_raw_breakpoint (single_step_breakpoints
[0]);
7945 single_step_breakpoints
[0] = NULL
;
7947 if (single_step_breakpoints
[1] != NULL
)
7949 deprecated_remove_raw_breakpoint (single_step_breakpoints
[1]);
7950 single_step_breakpoints
[1] = NULL
;
7955 /* This help string is used for the break, hbreak, tbreak and thbreak commands.
7956 It is defined as a macro to prevent duplication.
7957 COMMAND should be a string constant containing the name of the command. */
7958 #define BREAK_ARGS_HELP(command) \
7959 command" [LOCATION] [thread THREADNUM] [if CONDITION]\n\
7960 LOCATION may be a line number, function name, or \"*\" and an address.\n\
7961 If a line number is specified, break at start of code for that line.\n\
7962 If a function is specified, break at start of code for that function.\n\
7963 If an address is specified, break at that exact address.\n\
7964 With no LOCATION, uses current execution address of selected stack frame.\n\
7965 This is useful for breaking on return to a stack frame.\n\
7967 THREADNUM is the number from \"info threads\".\n\
7968 CONDITION is a boolean expression.\n\
7970 Multiple breakpoints at one place are permitted, and useful if conditional.\n\
7972 Do \"help breakpoints\" for info on other commands dealing with breakpoints."
7975 _initialize_breakpoint (void)
7977 static struct cmd_list_element
*breakpoint_set_cmdlist
;
7978 static struct cmd_list_element
*breakpoint_show_cmdlist
;
7979 struct cmd_list_element
*c
;
7981 observer_attach_solib_unloaded (disable_breakpoints_in_unloaded_shlib
);
7983 breakpoint_chain
= 0;
7984 /* Don't bother to call set_breakpoint_count. $bpnum isn't useful
7985 before a breakpoint is set. */
7986 breakpoint_count
= 0;
7988 add_com ("ignore", class_breakpoint
, ignore_command
, _("\
7989 Set ignore-count of breakpoint number N to COUNT.\n\
7990 Usage is `ignore N COUNT'."));
7992 add_com_alias ("bc", "ignore", class_breakpoint
, 1);
7994 add_com ("commands", class_breakpoint
, commands_command
, _("\
7995 Set commands to be executed when a breakpoint is hit.\n\
7996 Give breakpoint number as argument after \"commands\".\n\
7997 With no argument, the targeted breakpoint is the last one set.\n\
7998 The commands themselves follow starting on the next line.\n\
7999 Type a line containing \"end\" to indicate the end of them.\n\
8000 Give \"silent\" as the first line to make the breakpoint silent;\n\
8001 then no output is printed when it is hit, except what the commands print."));
8003 add_com ("condition", class_breakpoint
, condition_command
, _("\
8004 Specify breakpoint number N to break only if COND is true.\n\
8005 Usage is `condition N COND', where N is an integer and COND is an\n\
8006 expression to be evaluated whenever breakpoint N is reached."));
8008 c
= add_com ("tbreak", class_breakpoint
, tbreak_command
, _("\
8009 Set a temporary breakpoint.\n\
8010 Like \"break\" except the breakpoint is only temporary,\n\
8011 so it will be deleted when hit. Equivalent to \"break\" followed\n\
8012 by using \"enable delete\" on the breakpoint number.\n\
8014 BREAK_ARGS_HELP ("tbreak")));
8015 set_cmd_completer (c
, location_completer
);
8017 c
= add_com ("hbreak", class_breakpoint
, hbreak_command
, _("\
8018 Set a hardware assisted breakpoint.\n\
8019 Like \"break\" except the breakpoint requires hardware support,\n\
8020 some target hardware may not have this support.\n\
8022 BREAK_ARGS_HELP ("hbreak")));
8023 set_cmd_completer (c
, location_completer
);
8025 c
= add_com ("thbreak", class_breakpoint
, thbreak_command
, _("\
8026 Set a temporary hardware assisted breakpoint.\n\
8027 Like \"hbreak\" except the breakpoint is only temporary,\n\
8028 so it will be deleted when hit.\n\
8030 BREAK_ARGS_HELP ("thbreak")));
8031 set_cmd_completer (c
, location_completer
);
8033 add_prefix_cmd ("enable", class_breakpoint
, enable_command
, _("\
8034 Enable some breakpoints.\n\
8035 Give breakpoint numbers (separated by spaces) as arguments.\n\
8036 With no subcommand, breakpoints are enabled until you command otherwise.\n\
8037 This is used to cancel the effect of the \"disable\" command.\n\
8038 With a subcommand you can enable temporarily."),
8039 &enablelist
, "enable ", 1, &cmdlist
);
8041 add_com ("ab", class_breakpoint
, enable_command
, _("\
8042 Enable some breakpoints.\n\
8043 Give breakpoint numbers (separated by spaces) as arguments.\n\
8044 With no subcommand, breakpoints are enabled until you command otherwise.\n\
8045 This is used to cancel the effect of the \"disable\" command.\n\
8046 With a subcommand you can enable temporarily."));
8048 add_com_alias ("en", "enable", class_breakpoint
, 1);
8050 add_abbrev_prefix_cmd ("breakpoints", class_breakpoint
, enable_command
, _("\
8051 Enable some breakpoints.\n\
8052 Give breakpoint numbers (separated by spaces) as arguments.\n\
8053 This is used to cancel the effect of the \"disable\" command.\n\
8054 May be abbreviated to simply \"enable\".\n"),
8055 &enablebreaklist
, "enable breakpoints ", 1, &enablelist
);
8057 add_cmd ("once", no_class
, enable_once_command
, _("\
8058 Enable breakpoints for one hit. Give breakpoint numbers.\n\
8059 If a breakpoint is hit while enabled in this fashion, it becomes disabled."),
8062 add_cmd ("delete", no_class
, enable_delete_command
, _("\
8063 Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
8064 If a breakpoint is hit while enabled in this fashion, it is deleted."),
8067 add_cmd ("delete", no_class
, enable_delete_command
, _("\
8068 Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
8069 If a breakpoint is hit while enabled in this fashion, it is deleted."),
8072 add_cmd ("once", no_class
, enable_once_command
, _("\
8073 Enable breakpoints for one hit. Give breakpoint numbers.\n\
8074 If a breakpoint is hit while enabled in this fashion, it becomes disabled."),
8077 add_prefix_cmd ("disable", class_breakpoint
, disable_command
, _("\
8078 Disable some breakpoints.\n\
8079 Arguments are breakpoint numbers with spaces in between.\n\
8080 To disable all breakpoints, give no argument.\n\
8081 A disabled breakpoint is not forgotten, but has no effect until reenabled."),
8082 &disablelist
, "disable ", 1, &cmdlist
);
8083 add_com_alias ("dis", "disable", class_breakpoint
, 1);
8084 add_com_alias ("disa", "disable", class_breakpoint
, 1);
8086 add_com ("sb", class_breakpoint
, disable_command
, _("\
8087 Disable some breakpoints.\n\
8088 Arguments are breakpoint numbers with spaces in between.\n\
8089 To disable all breakpoints, give no argument.\n\
8090 A disabled breakpoint is not forgotten, but has no effect until reenabled."));
8092 add_cmd ("breakpoints", class_alias
, 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.\n\
8097 This command may be abbreviated \"disable\"."),
8100 add_prefix_cmd ("delete", class_breakpoint
, delete_command
, _("\
8101 Delete some breakpoints or auto-display expressions.\n\
8102 Arguments are breakpoint numbers with spaces in between.\n\
8103 To delete all breakpoints, give no argument.\n\
8105 Also a prefix command for deletion of other GDB objects.\n\
8106 The \"unset\" command is also an alias for \"delete\"."),
8107 &deletelist
, "delete ", 1, &cmdlist
);
8108 add_com_alias ("d", "delete", class_breakpoint
, 1);
8109 add_com_alias ("del", "delete", class_breakpoint
, 1);
8111 add_com ("db", class_breakpoint
, delete_command
, _("\
8112 Delete some breakpoints.\n\
8113 Arguments are breakpoint numbers with spaces in between.\n\
8114 To delete all breakpoints, give no argument.\n"));
8116 add_cmd ("breakpoints", class_alias
, delete_command
, _("\
8117 Delete some breakpoints or auto-display expressions.\n\
8118 Arguments are breakpoint numbers with spaces in between.\n\
8119 To delete all breakpoints, give no argument.\n\
8120 This command may be abbreviated \"delete\"."),
8123 add_com ("clear", class_breakpoint
, clear_command
, _("\
8124 Clear breakpoint at specified line or function.\n\
8125 Argument may be line number, function name, or \"*\" and an address.\n\
8126 If line number is specified, all breakpoints in that line are cleared.\n\
8127 If function is specified, breakpoints at beginning of function are cleared.\n\
8128 If an address is specified, breakpoints at that address are cleared.\n\
8130 With no argument, clears all breakpoints in the line that the selected frame\n\
8133 See also the \"delete\" command which clears breakpoints by number."));
8135 c
= add_com ("break", class_breakpoint
, break_command
, _("\
8136 Set breakpoint at specified line or function.\n"
8137 BREAK_ARGS_HELP ("break")));
8138 set_cmd_completer (c
, location_completer
);
8140 add_com_alias ("b", "break", class_run
, 1);
8141 add_com_alias ("br", "break", class_run
, 1);
8142 add_com_alias ("bre", "break", class_run
, 1);
8143 add_com_alias ("brea", "break", class_run
, 1);
8147 add_com_alias ("ba", "break", class_breakpoint
, 1);
8148 add_com_alias ("bu", "ubreak", class_breakpoint
, 1);
8153 add_abbrev_prefix_cmd ("stop", class_breakpoint
, stop_command
, _("\
8154 Break in function/address or break at a line in the current file."),
8155 &stoplist
, "stop ", 1, &cmdlist
);
8156 add_cmd ("in", class_breakpoint
, stopin_command
,
8157 _("Break in function or address."), &stoplist
);
8158 add_cmd ("at", class_breakpoint
, stopat_command
,
8159 _("Break at a line in the current file."), &stoplist
);
8160 add_com ("status", class_info
, breakpoints_info
, _("\
8161 Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
8162 The \"Type\" column indicates one of:\n\
8163 \tbreakpoint - normal breakpoint\n\
8164 \twatchpoint - watchpoint\n\
8165 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
8166 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
8167 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
8168 address and file/line number respectively.\n\
8170 Convenience variable \"$_\" and default examine address for \"x\"\n\
8171 are set to the address of the last breakpoint listed.\n\n\
8172 Convenience variable \"$bpnum\" contains the number of the last\n\
8176 add_info ("breakpoints", breakpoints_info
, _("\
8177 Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
8178 The \"Type\" column indicates one of:\n\
8179 \tbreakpoint - normal breakpoint\n\
8180 \twatchpoint - watchpoint\n\
8181 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
8182 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
8183 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
8184 address and file/line number respectively.\n\
8186 Convenience variable \"$_\" and default examine address for \"x\"\n\
8187 are set to the address of the last breakpoint listed.\n\n\
8188 Convenience variable \"$bpnum\" contains the number of the last\n\
8192 add_com ("lb", class_breakpoint
, breakpoints_info
, _("\
8193 Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
8194 The \"Type\" column indicates one of:\n\
8195 \tbreakpoint - normal breakpoint\n\
8196 \twatchpoint - watchpoint\n\
8197 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
8198 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
8199 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
8200 address and file/line number respectively.\n\
8202 Convenience variable \"$_\" and default examine address for \"x\"\n\
8203 are set to the address of the last breakpoint listed.\n\n\
8204 Convenience variable \"$bpnum\" contains the number of the last\n\
8207 add_cmd ("breakpoints", class_maintenance
, maintenance_info_breakpoints
, _("\
8208 Status of all breakpoints, or breakpoint number NUMBER.\n\
8209 The \"Type\" column indicates one of:\n\
8210 \tbreakpoint - normal breakpoint\n\
8211 \twatchpoint - watchpoint\n\
8212 \tlongjmp - internal breakpoint used to step through longjmp()\n\
8213 \tlongjmp resume - internal breakpoint at the target of longjmp()\n\
8214 \tuntil - internal breakpoint used by the \"until\" command\n\
8215 \tfinish - internal breakpoint used by the \"finish\" command\n\
8216 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
8217 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
8218 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
8219 address and file/line number respectively.\n\
8221 Convenience variable \"$_\" and default examine address for \"x\"\n\
8222 are set to the address of the last breakpoint listed.\n\
8224 Convenience variable \"$bpnum\" contains the number of the last\n\
8226 &maintenanceinfolist
);
8228 add_com ("catch", class_breakpoint
, catch_command
, _("\
8229 Set catchpoints to catch events.\n\
8230 Raised signals may be caught:\n\
8231 \tcatch signal - all signals\n\
8232 \tcatch signal <signame> - a particular signal\n\
8233 Raised exceptions may be caught:\n\
8234 \tcatch throw - all exceptions, when thrown\n\
8235 \tcatch throw <exceptname> - a particular exception, when thrown\n\
8236 \tcatch catch - all exceptions, when caught\n\
8237 \tcatch catch <exceptname> - a particular exception, when caught\n\
8238 Thread or process events may be caught:\n\
8239 \tcatch thread_start - any threads, just after creation\n\
8240 \tcatch thread_exit - any threads, just before expiration\n\
8241 \tcatch thread_join - any threads, just after joins\n\
8242 Process events may be caught:\n\
8243 \tcatch start - any processes, just after creation\n\
8244 \tcatch exit - any processes, just before expiration\n\
8245 \tcatch fork - calls to fork()\n\
8246 \tcatch vfork - calls to vfork()\n\
8247 \tcatch exec - calls to exec()\n\
8248 Dynamically-linked library events may be caught:\n\
8249 \tcatch load - loads of any library\n\
8250 \tcatch load <libname> - loads of a particular library\n\
8251 \tcatch unload - unloads of any library\n\
8252 \tcatch unload <libname> - unloads of a particular library\n\
8253 The act of your program's execution stopping may also be caught:\n\
8255 C++ exceptions may be caught:\n\
8256 \tcatch throw - all exceptions, when thrown\n\
8257 \tcatch catch - all exceptions, when caught\n\
8258 Ada exceptions may be caught:\n\
8259 \tcatch exception - all exceptions, when raised\n\
8260 \tcatch exception <name> - a particular exception, when raised\n\
8261 \tcatch exception unhandled - all unhandled exceptions, when raised\n\
8262 \tcatch assert - all failed assertions, when raised\n\
8264 Do \"help set follow-fork-mode\" for info on debugging your program\n\
8265 after a fork or vfork is caught.\n\n\
8266 Do \"help breakpoints\" for info on other commands dealing with breakpoints."));
8268 add_com ("tcatch", class_breakpoint
, tcatch_command
, _("\
8269 Set temporary catchpoints to catch events.\n\
8270 Args like \"catch\" command.\n\
8271 Like \"catch\" except the catchpoint is only temporary,\n\
8272 so it will be deleted when hit. Equivalent to \"catch\" followed\n\
8273 by using \"enable delete\" on the catchpoint number."));
8275 c
= add_com ("watch", class_breakpoint
, watch_command
, _("\
8276 Set a watchpoint for an expression.\n\
8277 A watchpoint stops execution of your program whenever the value of\n\
8278 an expression changes."));
8279 set_cmd_completer (c
, location_completer
);
8281 c
= add_com ("rwatch", class_breakpoint
, rwatch_command
, _("\
8282 Set a read watchpoint for an expression.\n\
8283 A watchpoint stops execution of your program whenever the value of\n\
8284 an expression is read."));
8285 set_cmd_completer (c
, location_completer
);
8287 c
= add_com ("awatch", class_breakpoint
, awatch_command
, _("\
8288 Set a watchpoint for an expression.\n\
8289 A watchpoint stops execution of your program whenever the value of\n\
8290 an expression is either read or written."));
8291 set_cmd_completer (c
, location_completer
);
8293 add_info ("watchpoints", breakpoints_info
,
8294 _("Synonym for ``info breakpoints''."));
8297 /* XXX: cagney/2005-02-23: This should be a boolean, and should
8298 respond to changes - contrary to the description. */
8299 add_setshow_zinteger_cmd ("can-use-hw-watchpoints", class_support
,
8300 &can_use_hw_watchpoints
, _("\
8301 Set debugger's willingness to use watchpoint hardware."), _("\
8302 Show debugger's willingness to use watchpoint hardware."), _("\
8303 If zero, gdb will not use hardware for new watchpoints, even if\n\
8304 such is available. (However, any hardware watchpoints that were\n\
8305 created before setting this to nonzero, will continue to use watchpoint\n\
8308 show_can_use_hw_watchpoints
,
8309 &setlist
, &showlist
);
8311 can_use_hw_watchpoints
= 1;
8313 add_prefix_cmd ("breakpoint", class_maintenance
, set_breakpoint_cmd
, _("\
8314 Breakpoint specific settings\n\
8315 Configure various breakpoint-specific variables such as\n\
8316 pending breakpoint behavior"),
8317 &breakpoint_set_cmdlist
, "set breakpoint ",
8318 0/*allow-unknown*/, &setlist
);
8319 add_prefix_cmd ("breakpoint", class_maintenance
, show_breakpoint_cmd
, _("\
8320 Breakpoint specific settings\n\
8321 Configure various breakpoint-specific variables such as\n\
8322 pending breakpoint behavior"),
8323 &breakpoint_show_cmdlist
, "show breakpoint ",
8324 0/*allow-unknown*/, &showlist
);
8326 add_setshow_auto_boolean_cmd ("pending", no_class
,
8327 &pending_break_support
, _("\
8328 Set debugger's behavior regarding pending breakpoints."), _("\
8329 Show debugger's behavior regarding pending breakpoints."), _("\
8330 If on, an unrecognized breakpoint location will cause gdb to create a\n\
8331 pending breakpoint. If off, an unrecognized breakpoint location results in\n\
8332 an error. If auto, an unrecognized breakpoint location results in a\n\
8333 user-query to see if a pending breakpoint should be created."),
8335 show_pending_break_support
,
8336 &breakpoint_set_cmdlist
,
8337 &breakpoint_show_cmdlist
);
8339 pending_break_support
= AUTO_BOOLEAN_AUTO
;
8341 add_setshow_boolean_cmd ("auto-hw", no_class
,
8342 &automatic_hardware_breakpoints
, _("\
8343 Set automatic usage of hardware breakpoints."), _("\
8344 Show automatic usage of hardware breakpoints."), _("\
8345 If set, the debugger will automatically use hardware breakpoints for\n\
8346 breakpoints set with \"break\" but falling in read-only memory. If not set,\n\
8347 a warning will be emitted for such breakpoints."),
8349 show_automatic_hardware_breakpoints
,
8350 &breakpoint_set_cmdlist
,
8351 &breakpoint_show_cmdlist
);
8353 automatic_hardware_breakpoints
= 1;