1 /* Everything about breakpoints, for GDB.
3 Copyright (C) 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
4 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007
5 Free Software Foundation, Inc.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 51 Franklin Street, Fifth Floor,
22 Boston, MA 02110-1301, USA. */
28 #include "breakpoint.h"
30 #include "expression.h"
36 #include "gdbthread.h"
39 #include "gdb_string.h"
46 #include "completer.h"
49 #include "cli/cli-script.h"
50 #include "gdb_assert.h"
55 #include "exceptions.h"
59 #include "gdb-events.h"
60 #include "mi/mi-common.h"
62 /* Prototypes for local functions. */
64 static void until_break_command_continuation (struct continuation_arg
*arg
);
66 static void catch_command_1 (char *, int, int);
68 static void enable_delete_command (char *, int);
70 static void enable_delete_breakpoint (struct breakpoint
*);
72 static void enable_once_command (char *, int);
74 static void enable_once_breakpoint (struct breakpoint
*);
76 static void disable_command (char *, int);
78 static void enable_command (char *, int);
80 static void map_breakpoint_numbers (char *, void (*)(struct breakpoint
*));
82 static void ignore_command (char *, int);
84 static int breakpoint_re_set_one (void *);
86 static void clear_command (char *, int);
88 static void catch_command (char *, int);
90 static void watch_command (char *, int);
92 static int can_use_hardware_watchpoint (struct value
*);
94 static int break_command_1 (char *, int, int, struct breakpoint
*);
96 static void mention (struct breakpoint
*);
98 struct breakpoint
*set_raw_breakpoint (struct symtab_and_line
, enum bptype
);
100 static void check_duplicates (struct breakpoint
*);
102 static void breakpoint_adjustment_warning (CORE_ADDR
, CORE_ADDR
, int, int);
104 static CORE_ADDR
adjust_breakpoint_address (CORE_ADDR bpaddr
,
107 static void describe_other_breakpoints (CORE_ADDR
, asection
*, int);
109 static void breakpoints_info (char *, int);
111 static void breakpoint_1 (int, int);
113 static bpstat
bpstat_alloc (struct breakpoint
*, bpstat
);
115 static int breakpoint_cond_eval (void *);
117 static void cleanup_executing_breakpoints (void *);
119 static void commands_command (char *, int);
121 static void condition_command (char *, int);
123 static int get_number_trailer (char **, int);
125 void set_breakpoint_count (int);
134 static int remove_breakpoint (struct bp_location
*, insertion_state_t
);
136 static enum print_stop_action
print_it_typical (bpstat
);
138 static enum print_stop_action
print_bp_stop_message (bpstat bs
);
142 enum exception_event_kind kind
;
145 args_for_catchpoint_enable
;
147 static int watchpoint_check (void *);
149 static int cover_target_enable_exception_callback (void *);
151 static void maintenance_info_breakpoints (char *, int);
153 static void create_longjmp_breakpoint (char *);
155 static void create_overlay_event_breakpoint (char *);
157 static int hw_breakpoint_used_count (void);
159 static int hw_watchpoint_used_count (enum bptype
, int *);
161 static void hbreak_command (char *, int);
163 static void thbreak_command (char *, int);
165 static void watch_command_1 (char *, int, int);
167 static void rwatch_command (char *, int);
169 static void awatch_command (char *, int);
171 static void do_enable_breakpoint (struct breakpoint
*, enum bpdisp
);
173 static void solib_load_unload_1 (char *hookname
,
176 char *cond_string
, enum bptype bp_kind
);
178 static void create_fork_vfork_event_catchpoint (int tempflag
,
180 enum bptype bp_kind
);
182 static void stop_command (char *arg
, int from_tty
);
184 static void stopin_command (char *arg
, int from_tty
);
186 static void stopat_command (char *arg
, int from_tty
);
188 static char *ep_find_event_name_end (char *arg
);
190 static char *ep_parse_optional_if_clause (char **arg
);
192 static char *ep_parse_optional_filename (char **arg
);
194 static void create_exception_catchpoint (int tempflag
, char *cond_string
,
195 enum exception_event_kind ex_event
,
196 struct symtab_and_line
*sal
);
198 static void catch_exception_command_1 (enum exception_event_kind ex_event
,
199 char *arg
, int tempflag
, int from_tty
);
201 static void tcatch_command (char *arg
, int from_tty
);
203 static void ep_skip_leading_whitespace (char **s
);
205 /* Prototypes for exported functions. */
207 /* If FALSE, gdb will not use hardware support for watchpoints, even
208 if such is available. */
209 static int can_use_hw_watchpoints
;
212 show_can_use_hw_watchpoints (struct ui_file
*file
, int from_tty
,
213 struct cmd_list_element
*c
,
216 fprintf_filtered (file
, _("\
217 Debugger's willingness to use watchpoint hardware is %s.\n"),
221 /* If AUTO_BOOLEAN_FALSE, gdb will not attempt to create pending breakpoints.
222 If AUTO_BOOLEAN_TRUE, gdb will automatically create pending breakpoints
223 for unrecognized breakpoint locations.
224 If AUTO_BOOLEAN_AUTO, gdb will query when breakpoints are unrecognized. */
225 static enum auto_boolean pending_break_support
;
227 show_pending_break_support (struct ui_file
*file
, int from_tty
,
228 struct cmd_list_element
*c
,
231 fprintf_filtered (file
, _("\
232 Debugger's behavior regarding pending breakpoints is %s.\n"),
236 /* If 1, gdb will automatically use hardware breakpoints for breakpoints
237 set with "break" but falling in read-only memory.
238 If 0, gdb will warn about such breakpoints, but won't automatically
239 use hardware breakpoints. */
240 static int automatic_hardware_breakpoints
;
242 show_automatic_hardware_breakpoints (struct ui_file
*file
, int from_tty
,
243 struct cmd_list_element
*c
,
246 fprintf_filtered (file
, _("\
247 Automatic usage of hardware breakpoints is %s.\n"),
252 void _initialize_breakpoint (void);
254 extern int addressprint
; /* Print machine addresses? */
256 /* Are we executing breakpoint commands? */
257 static int executing_breakpoint_commands
;
259 /* Are overlay event breakpoints enabled? */
260 static int overlay_events_enabled
;
262 /* Walk the following statement or block through all breakpoints.
263 ALL_BREAKPOINTS_SAFE does so even if the statment deletes the current
266 #define ALL_BREAKPOINTS(B) for (B = breakpoint_chain; B; B = B->next)
268 #define ALL_BREAKPOINTS_SAFE(B,TMP) \
269 for (B = breakpoint_chain; \
270 B ? (TMP=B->next, 1): 0; \
273 /* Similar iterators for the low-level breakpoints. */
275 #define ALL_BP_LOCATIONS(B) for (B = bp_location_chain; B; B = B->next)
277 #define ALL_BP_LOCATIONS_SAFE(B,TMP) \
278 for (B = bp_location_chain; \
279 B ? (TMP=B->next, 1): 0; \
282 /* True if breakpoint hit counts should be displayed in breakpoint info. */
284 int show_breakpoint_hit_counts
= 1;
286 /* Chains of all breakpoints defined. */
288 struct breakpoint
*breakpoint_chain
;
290 struct bp_location
*bp_location_chain
;
292 /* Number of last breakpoint made. */
294 int breakpoint_count
;
296 /* Pointer to current exception event record */
297 static struct exception_event_record
*current_exception_event
;
299 /* Indicator of whether exception catchpoints should be nuked between
300 runs of a program. */
301 int deprecated_exception_catchpoints_are_fragile
= 0;
303 /* Indicator of when exception catchpoints set-up should be
304 reinitialized -- e.g. when program is re-run. */
305 int deprecated_exception_support_initialized
= 0;
307 /* This function returns a pointer to the string representation of the
308 pathname of the dynamically-linked library that has just been
311 This function must be used only when SOLIB_HAVE_LOAD_EVENT is TRUE,
312 or undefined results are guaranteed.
314 This string's contents are only valid immediately after the
315 inferior has stopped in the dynamic linker hook, and becomes
316 invalid as soon as the inferior is continued. Clients should make
317 a copy of this string if they wish to continue the inferior and
318 then access the string. */
320 #ifndef SOLIB_LOADED_LIBRARY_PATHNAME
321 #define SOLIB_LOADED_LIBRARY_PATHNAME(pid) ""
324 /* This function returns a pointer to the string representation of the
325 pathname of the dynamically-linked library that has just been
328 This function must be used only when SOLIB_HAVE_UNLOAD_EVENT is
329 TRUE, or undefined results are guaranteed.
331 This string's contents are only valid immediately after the
332 inferior has stopped in the dynamic linker hook, and becomes
333 invalid as soon as the inferior is continued. Clients should make
334 a copy of this string if they wish to continue the inferior and
335 then access the string. */
337 #ifndef SOLIB_UNLOADED_LIBRARY_PATHNAME
338 #define SOLIB_UNLOADED_LIBRARY_PATHNAME(pid) ""
341 /* This function is called by the "catch load" command. It allows the
342 debugger to be notified by the dynamic linker when a specified
343 library file (or any library file, if filename is NULL) is loaded. */
345 #ifndef SOLIB_CREATE_CATCH_LOAD_HOOK
346 #define SOLIB_CREATE_CATCH_LOAD_HOOK(pid,tempflag,filename,cond_string) \
347 error (_("catch of library loads not yet implemented on this platform"))
350 /* This function is called by the "catch unload" command. It allows
351 the debugger to be notified by the dynamic linker when a specified
352 library file (or any library file, if filename is NULL) is
355 #ifndef SOLIB_CREATE_CATCH_UNLOAD_HOOK
356 #define SOLIB_CREATE_CATCH_UNLOAD_HOOK(pid, tempflag, filename, cond_string) \
357 error (_("catch of library unloads not yet implemented on this platform"))
360 /* Return whether a breakpoint is an active enabled breakpoint. */
362 breakpoint_enabled (struct breakpoint
*b
)
364 return (b
->enable_state
== bp_enabled
&& !b
->pending
);
367 /* Set breakpoint count to NUM. */
370 set_breakpoint_count (int num
)
372 breakpoint_count
= num
;
373 set_internalvar (lookup_internalvar ("bpnum"),
374 value_from_longest (builtin_type_int
, (LONGEST
) num
));
377 /* Used in run_command to zero the hit count when a new run starts. */
380 clear_breakpoint_hit_counts (void)
382 struct breakpoint
*b
;
388 /* Default address, symtab and line to put a breakpoint at
389 for "break" command with no arg.
390 if default_breakpoint_valid is zero, the other three are
391 not valid, and "break" with no arg is an error.
393 This set by print_stack_frame, which calls set_default_breakpoint. */
395 int default_breakpoint_valid
;
396 CORE_ADDR default_breakpoint_address
;
397 struct symtab
*default_breakpoint_symtab
;
398 int default_breakpoint_line
;
400 /* *PP is a string denoting a breakpoint. Get the number of the breakpoint.
401 Advance *PP after the string and any trailing whitespace.
403 Currently the string can either be a number or "$" followed by the name
404 of a convenience variable. Making it an expression wouldn't work well
405 for map_breakpoint_numbers (e.g. "4 + 5 + 6").
407 If the string is a NULL pointer, that denotes the last breakpoint.
409 TRAILER is a character which can be found after the number; most
410 commonly this is `-'. If you don't want a trailer, use \0. */
412 get_number_trailer (char **pp
, int trailer
)
414 int retval
= 0; /* default */
418 /* Empty line means refer to the last breakpoint. */
419 return breakpoint_count
;
422 /* Make a copy of the name, so we can null-terminate it
423 to pass to lookup_internalvar(). */
428 while (isalnum (*p
) || *p
== '_')
430 varname
= (char *) alloca (p
- start
+ 1);
431 strncpy (varname
, start
, p
- start
);
432 varname
[p
- start
] = '\0';
433 val
= value_of_internalvar (lookup_internalvar (varname
));
434 if (TYPE_CODE (value_type (val
)) == TYPE_CODE_INT
)
435 retval
= (int) value_as_long (val
);
438 printf_filtered (_("Convenience variable must have integer value.\n"));
446 while (*p
>= '0' && *p
<= '9')
449 /* There is no number here. (e.g. "cond a == b"). */
451 /* Skip non-numeric token */
452 while (*p
&& !isspace((int) *p
))
454 /* Return zero, which caller must interpret as error. */
460 if (!(isspace (*p
) || *p
== '\0' || *p
== trailer
))
462 /* Trailing junk: return 0 and let caller print error msg. */
463 while (!(isspace (*p
) || *p
== '\0' || *p
== trailer
))
474 /* Like get_number_trailer, but don't allow a trailer. */
476 get_number (char **pp
)
478 return get_number_trailer (pp
, '\0');
481 /* Parse a number or a range.
482 * A number will be of the form handled by get_number.
483 * A range will be of the form <number1> - <number2>, and
484 * will represent all the integers between number1 and number2,
487 * While processing a range, this fuction is called iteratively;
488 * At each call it will return the next value in the range.
490 * At the beginning of parsing a range, the char pointer PP will
491 * be advanced past <number1> and left pointing at the '-' token.
492 * Subsequent calls will not advance the pointer until the range
493 * is completed. The call that completes the range will advance
494 * pointer PP past <number2>.
498 get_number_or_range (char **pp
)
500 static int last_retval
, end_value
;
501 static char *end_ptr
;
502 static int in_range
= 0;
506 /* Default case: pp is pointing either to a solo number,
507 or to the first number of a range. */
508 last_retval
= get_number_trailer (pp
, '-');
513 /* This is the start of a range (<number1> - <number2>).
514 Skip the '-', parse and remember the second number,
515 and also remember the end of the final token. */
519 while (isspace ((int) *end_ptr
))
520 end_ptr
++; /* skip white space */
521 end_value
= get_number (temp
);
522 if (end_value
< last_retval
)
524 error (_("inverted range"));
526 else if (end_value
== last_retval
)
528 /* degenerate range (number1 == number2). Advance the
529 token pointer so that the range will be treated as a
538 error (_("negative value"));
541 /* pp points to the '-' that betokens a range. All
542 number-parsing has already been done. Return the next
543 integer value (one greater than the saved previous value).
544 Do not advance the token pointer 'pp' until the end of range
547 if (++last_retval
== end_value
)
549 /* End of range reached; advance token pointer. */
559 /* condition N EXP -- set break condition of breakpoint N to EXP. */
562 condition_command (char *arg
, int from_tty
)
564 struct breakpoint
*b
;
569 error_no_arg (_("breakpoint number"));
572 bnum
= get_number (&p
);
574 error (_("Bad breakpoint argument: '%s'"), arg
);
577 if (b
->number
== bnum
)
584 if (b
->cond_string
!= NULL
)
585 xfree (b
->cond_string
);
590 b
->cond_string
= NULL
;
592 printf_filtered (_("Breakpoint %d now unconditional.\n"), bnum
);
597 /* I don't know if it matters whether this is the string the user
598 typed in or the decompiled expression. */
599 b
->cond_string
= savestring (arg
, strlen (arg
));
602 b
->cond
= parse_exp_1 (&arg
, block_for_pc (b
->loc
->address
), 0);
604 error (_("Junk at end of expression"));
607 breakpoints_changed ();
608 breakpoint_modify_event (b
->number
);
612 error (_("No breakpoint number %d."), bnum
);
616 commands_command (char *arg
, int from_tty
)
618 struct breakpoint
*b
;
621 struct command_line
*l
;
623 /* If we allowed this, we would have problems with when to
624 free the storage, if we change the commands currently
627 if (executing_breakpoint_commands
)
628 error (_("Can't use the \"commands\" command among a breakpoint's commands."));
631 bnum
= get_number (&p
);
634 error (_("Unexpected extra arguments following breakpoint number."));
637 if (b
->number
== bnum
)
639 char *tmpbuf
= xstrprintf ("Type commands for when breakpoint %d is hit, one per line.",
641 struct cleanup
*cleanups
= make_cleanup (xfree
, tmpbuf
);
642 l
= read_command_lines (tmpbuf
, from_tty
);
643 do_cleanups (cleanups
);
644 free_command_lines (&b
->commands
);
646 breakpoints_changed ();
647 breakpoint_modify_event (b
->number
);
650 error (_("No breakpoint number %d."), bnum
);
653 /* Like commands_command, but instead of reading the commands from
654 input stream, takes them from an already parsed command structure.
656 This is used by cli-script.c to DTRT with breakpoint commands
657 that are part of if and while bodies. */
658 enum command_control_type
659 commands_from_control_command (char *arg
, struct command_line
*cmd
)
661 struct breakpoint
*b
;
665 /* If we allowed this, we would have problems with when to
666 free the storage, if we change the commands currently
669 if (executing_breakpoint_commands
)
670 error (_("Can't use the \"commands\" command among a breakpoint's commands."));
672 /* An empty string for the breakpoint number means the last
673 breakpoint, but get_number expects a NULL pointer. */
678 bnum
= get_number (&p
);
681 error (_("Unexpected extra arguments following breakpoint number."));
684 if (b
->number
== bnum
)
686 free_command_lines (&b
->commands
);
687 if (cmd
->body_count
!= 1)
688 error (_("Invalid \"commands\" block structure."));
689 /* We need to copy the commands because if/while will free the
690 list after it finishes execution. */
691 b
->commands
= copy_command_lines (cmd
->body_list
[0]);
692 breakpoints_changed ();
693 breakpoint_modify_event (b
->number
);
694 return simple_control
;
696 error (_("No breakpoint number %d."), bnum
);
699 /* Like target_read_memory() but if breakpoints are inserted, return
700 the shadow contents instead of the breakpoints themselves.
702 Read "memory data" from whatever target or inferior we have.
703 Returns zero if successful, errno value if not. EIO is used
704 for address out of bounds. If breakpoints are inserted, returns
705 shadow contents, not the breakpoints themselves. From breakpoint.c. */
708 read_memory_nobpt (CORE_ADDR memaddr
, gdb_byte
*myaddr
, unsigned len
)
711 struct bp_location
*b
;
712 CORE_ADDR bp_addr
= 0;
715 if (BREAKPOINT_FROM_PC (&bp_addr
, &bp_size
) == NULL
)
716 /* No breakpoints on this machine. */
717 return target_read_memory (memaddr
, myaddr
, len
);
721 if (b
->owner
->type
== bp_none
)
722 warning (_("reading through apparently deleted breakpoint #%d?"),
725 if (b
->loc_type
!= bp_loc_software_breakpoint
)
729 /* Addresses and length of the part of the breakpoint that
731 bp_addr
= b
->target_info
.placed_address
;
732 bp_size
= b
->target_info
.shadow_len
;
734 /* bp isn't valid, or doesn't shadow memory. */
736 if (bp_addr
+ bp_size
<= memaddr
)
737 /* The breakpoint is entirely before the chunk of memory we
740 if (bp_addr
>= memaddr
+ len
)
741 /* The breakpoint is entirely after the chunk of memory we are
744 /* Copy the breakpoint from the shadow contents, and recurse for
745 the things before and after. */
747 /* Offset within shadow_contents. */
750 if (bp_addr
< memaddr
)
752 /* Only copy the second part of the breakpoint. */
753 bp_size
-= memaddr
- bp_addr
;
754 bptoffset
= memaddr
- bp_addr
;
758 if (bp_addr
+ bp_size
> memaddr
+ len
)
760 /* Only copy the first part of the breakpoint. */
761 bp_size
-= (bp_addr
+ bp_size
) - (memaddr
+ len
);
764 memcpy (myaddr
+ bp_addr
- memaddr
,
765 b
->target_info
.shadow_contents
+ bptoffset
, bp_size
);
767 if (bp_addr
> memaddr
)
769 /* Copy the section of memory before the breakpoint. */
770 status
= read_memory_nobpt (memaddr
, myaddr
, bp_addr
- memaddr
);
775 if (bp_addr
+ bp_size
< memaddr
+ len
)
777 /* Copy the section of memory after the breakpoint. */
778 status
= read_memory_nobpt (bp_addr
+ bp_size
,
779 myaddr
+ bp_addr
+ bp_size
- memaddr
,
780 memaddr
+ len
- (bp_addr
+ bp_size
));
787 /* Nothing overlaps. Just call read_memory_noerr. */
788 return target_read_memory (memaddr
, myaddr
, len
);
792 /* A wrapper function for inserting catchpoints. */
794 insert_catchpoint (struct ui_out
*uo
, void *args
)
796 struct breakpoint
*b
= (struct breakpoint
*) args
;
802 target_insert_fork_catchpoint (PIDGET (inferior_ptid
));
805 target_insert_vfork_catchpoint (PIDGET (inferior_ptid
));
808 target_insert_exec_catchpoint (PIDGET (inferior_ptid
));
811 internal_error (__FILE__
, __LINE__
, _("unknown breakpoint type"));
816 /* Helper routine: free the value chain for a breakpoint (watchpoint). */
819 free_valchain (struct bp_location
*b
)
824 /* Free the saved value chain. We will construct a new one
825 the next time the watchpoint is inserted. */
826 for (v
= b
->owner
->val_chain
; v
; v
= n
)
831 b
->owner
->val_chain
= NULL
;
834 /* Insert a low-level "breakpoint" of some type. BPT is the breakpoint.
835 Any error messages are printed to TMP_ERROR_STREAM; and DISABLED_BREAKS,
836 PROCESS_WARNING, and HW_BREAKPOINT_ERROR are used to report problems.
838 NOTE drow/2003-09-09: This routine could be broken down to an object-style
839 method for each breakpoint or catchpoint type. */
841 insert_bp_location (struct bp_location
*bpt
,
842 struct ui_file
*tmp_error_stream
,
843 int *disabled_breaks
, int *process_warning
,
844 int *hw_breakpoint_error
)
848 /* Permanent breakpoints cannot be inserted or removed. Disabled
849 breakpoints should not be inserted. */
850 if (!breakpoint_enabled (bpt
->owner
))
853 if (bpt
->inserted
|| bpt
->duplicate
)
856 /* Initialize the target-specific information. */
857 memset (&bpt
->target_info
, 0, sizeof (bpt
->target_info
));
858 bpt
->target_info
.placed_address
= bpt
->address
;
860 if (bpt
->loc_type
== bp_loc_software_breakpoint
861 || bpt
->loc_type
== bp_loc_hardware_breakpoint
)
863 if (bpt
->owner
->type
!= bp_hardware_breakpoint
)
865 /* If the explicitly specified breakpoint type
866 is not hardware breakpoint, check the memory map to see
867 if the breakpoint address is in read only memory or not.
868 Two important cases are:
869 - location type is not hardware breakpoint, memory
870 is readonly. We change the type of the location to
872 - location type is hardware breakpoint, memory is read-write.
873 This means we've previously made the location hardware one, but
874 then the memory map changed, so we undo.
876 When breakpoints are removed, remove_breakpoints will
877 use location types we've just set here, the only possible
878 problem is that memory map has changed during running program,
879 but it's not going to work anyway with current gdb. */
880 struct mem_region
*mr
881 = lookup_mem_region (bpt
->target_info
.placed_address
);
885 if (automatic_hardware_breakpoints
)
888 enum bp_loc_type new_type
;
890 if (mr
->attrib
.mode
!= MEM_RW
)
891 new_type
= bp_loc_hardware_breakpoint
;
893 new_type
= bp_loc_software_breakpoint
;
895 if (new_type
!= bpt
->loc_type
)
898 bpt
->loc_type
= new_type
;
901 fprintf_filtered (gdb_stdout
, _("\
902 Note: automatically using hardware breakpoints for read-only addresses.\n"));
907 else if (bpt
->loc_type
== bp_loc_software_breakpoint
908 && mr
->attrib
.mode
!= MEM_RW
)
909 warning (_("cannot set software breakpoint at readonly address %s"),
910 paddr (bpt
->address
));
914 /* First check to see if we have to handle an overlay. */
915 if (overlay_debugging
== ovly_off
916 || bpt
->section
== NULL
917 || !(section_is_overlay (bpt
->section
)))
919 /* No overlay handling: just set the breakpoint. */
921 if (bpt
->loc_type
== bp_loc_hardware_breakpoint
)
922 val
= target_insert_hw_breakpoint (&bpt
->target_info
);
924 val
= target_insert_breakpoint (&bpt
->target_info
);
928 /* This breakpoint is in an overlay section.
929 Shall we set a breakpoint at the LMA? */
930 if (!overlay_events_enabled
)
932 /* Yes -- overlay event support is not active,
933 so we must try to set a breakpoint at the LMA.
934 This will not work for a hardware breakpoint. */
935 if (bpt
->loc_type
== bp_loc_hardware_breakpoint
)
936 warning (_("hardware breakpoint %d not supported in overlay!"),
940 CORE_ADDR addr
= overlay_unmapped_address (bpt
->address
,
942 /* Set a software (trap) breakpoint at the LMA. */
943 bpt
->overlay_target_info
= bpt
->target_info
;
944 bpt
->overlay_target_info
.placed_address
= addr
;
945 val
= target_insert_breakpoint (&bpt
->overlay_target_info
);
947 fprintf_unfiltered (tmp_error_stream
,
948 "Overlay breakpoint %d failed: in ROM?",
952 /* Shall we set a breakpoint at the VMA? */
953 if (section_is_mapped (bpt
->section
))
955 /* Yes. This overlay section is mapped into memory. */
956 if (bpt
->loc_type
== bp_loc_hardware_breakpoint
)
957 val
= target_insert_hw_breakpoint (&bpt
->target_info
);
959 val
= target_insert_breakpoint (&bpt
->target_info
);
963 /* No. This breakpoint will not be inserted.
964 No error, but do not mark the bp as 'inserted'. */
971 /* Can't set the breakpoint. */
973 #if defined (DISABLE_UNSETTABLE_BREAK)
974 DISABLE_UNSETTABLE_BREAK (bpt
->address
)
976 solib_address (bpt
->address
)
980 /* See also: disable_breakpoints_in_shlibs. */
982 bpt
->owner
->enable_state
= bp_shlib_disabled
;
983 if (!*disabled_breaks
)
985 fprintf_unfiltered (tmp_error_stream
,
986 "Cannot insert breakpoint %d.\n",
988 fprintf_unfiltered (tmp_error_stream
,
989 "Temporarily disabling shared library breakpoints:\n");
991 *disabled_breaks
= 1;
992 fprintf_unfiltered (tmp_error_stream
,
993 "breakpoint #%d\n", bpt
->owner
->number
);
997 #ifdef ONE_PROCESS_WRITETEXT
998 *process_warning
= 1;
1000 if (bpt
->loc_type
== bp_loc_hardware_breakpoint
)
1002 *hw_breakpoint_error
= 1;
1003 fprintf_unfiltered (tmp_error_stream
,
1004 "Cannot insert hardware breakpoint %d.\n",
1005 bpt
->owner
->number
);
1009 fprintf_unfiltered (tmp_error_stream
,
1010 "Cannot insert breakpoint %d.\n",
1011 bpt
->owner
->number
);
1012 fprintf_filtered (tmp_error_stream
,
1013 "Error accessing memory address ");
1014 deprecated_print_address_numeric (bpt
->address
, 1, tmp_error_stream
);
1015 fprintf_filtered (tmp_error_stream
, ": %s.\n",
1016 safe_strerror (val
));
1027 else if (bpt
->loc_type
== bp_loc_hardware_watchpoint
1028 /* NOTE drow/2003-09-08: This state only exists for removing
1029 watchpoints. It's not clear that it's necessary... */
1030 && bpt
->owner
->disposition
!= disp_del_at_next_stop
)
1032 /* FIXME drow/2003-09-08: This code sets multiple hardware watchpoints
1033 based on the expression. Ideally this should happen at a higher level,
1034 and there should be one bp_location for each computed address we
1035 must watch. As soon as a many-to-one mapping is available I'll
1038 int within_current_scope
;
1039 struct value
*mark
= value_mark ();
1041 struct frame_id saved_frame_id
;
1043 /* Save the current frame's ID so we can restore it after
1044 evaluating the watchpoint expression on its own frame. */
1045 /* FIXME drow/2003-09-09: It would be nice if evaluate_expression
1046 took a frame parameter, so that we didn't have to change the
1048 saved_frame_id
= get_frame_id (get_selected_frame (NULL
));
1050 /* Determine if the watchpoint is within scope. */
1051 if (bpt
->owner
->exp_valid_block
== NULL
)
1052 within_current_scope
= 1;
1055 struct frame_info
*fi
;
1056 fi
= frame_find_by_id (bpt
->owner
->watchpoint_frame
);
1057 within_current_scope
= (fi
!= NULL
);
1058 if (within_current_scope
)
1062 if (within_current_scope
)
1064 free_valchain (bpt
);
1066 /* Evaluate the expression and cut the chain of values
1067 produced off from the value chain.
1069 Make sure the value returned isn't lazy; we use
1070 laziness to determine what memory GDB actually needed
1071 in order to compute the value of the expression. */
1072 v
= evaluate_expression (bpt
->owner
->exp
);
1074 value_release_to_mark (mark
);
1076 bpt
->owner
->val_chain
= v
;
1079 /* Look at each value on the value chain. */
1080 for (; v
; v
= value_next (v
))
1082 /* If it's a memory location, and GDB actually needed
1083 its contents to evaluate the expression, then we
1085 if (VALUE_LVAL (v
) == lval_memory
1086 && ! value_lazy (v
))
1088 struct type
*vtype
= check_typedef (value_type (v
));
1090 /* We only watch structs and arrays if user asked
1091 for it explicitly, never if they just happen to
1092 appear in the middle of some value chain. */
1093 if (v
== bpt
->owner
->val_chain
1094 || (TYPE_CODE (vtype
) != TYPE_CODE_STRUCT
1095 && TYPE_CODE (vtype
) != TYPE_CODE_ARRAY
))
1100 addr
= VALUE_ADDRESS (v
) + value_offset (v
);
1101 len
= TYPE_LENGTH (value_type (v
));
1103 if (bpt
->owner
->type
== bp_read_watchpoint
)
1105 else if (bpt
->owner
->type
== bp_access_watchpoint
)
1108 val
= target_insert_watchpoint (addr
, len
, type
);
1111 /* Don't exit the loop, try to insert
1112 every value on the value chain. That's
1113 because we will be removing all the
1114 watches below, and removing a
1115 watchpoint we didn't insert could have
1123 /* Failure to insert a watchpoint on any memory value in the
1124 value chain brings us here. */
1127 remove_breakpoint (bpt
, mark_uninserted
);
1128 *hw_breakpoint_error
= 1;
1129 fprintf_unfiltered (tmp_error_stream
,
1130 "Could not insert hardware watchpoint %d.\n",
1131 bpt
->owner
->number
);
1137 printf_filtered (_("\
1138 Hardware watchpoint %d deleted because the program has left the block \n\
1139 in which its expression is valid.\n"),
1140 bpt
->owner
->number
);
1141 if (bpt
->owner
->related_breakpoint
)
1142 bpt
->owner
->related_breakpoint
->disposition
= disp_del_at_next_stop
;
1143 bpt
->owner
->disposition
= disp_del_at_next_stop
;
1146 /* Restore the selected frame. */
1147 select_frame (frame_find_by_id (saved_frame_id
));
1152 else if (ep_is_exception_catchpoint (bpt
->owner
))
1154 /* FIXME drow/2003-09-09: This code sets both a catchpoint and a
1155 breakpoint. Once again, it would be better if this was represented
1156 as two bp_locations. */
1158 /* If we get here, we must have a callback mechanism for exception
1159 events -- with g++ style embedded label support, we insert
1160 ordinary breakpoints and not catchpoints. */
1161 val
= target_insert_breakpoint (&bpt
->target_info
);
1164 /* Couldn't set breakpoint for some reason */
1165 fprintf_unfiltered (tmp_error_stream
,
1166 "Cannot insert catchpoint %d; disabling it.\n",
1167 bpt
->owner
->number
);
1168 fprintf_filtered (tmp_error_stream
,
1169 "Error accessing memory address ");
1170 deprecated_print_address_numeric (bpt
->address
, 1, tmp_error_stream
);
1171 fprintf_filtered (tmp_error_stream
, ": %s.\n",
1172 safe_strerror (val
));
1173 bpt
->owner
->enable_state
= bp_disabled
;
1177 /* Bp set, now make sure callbacks are enabled */
1178 /* Format possible error msg */
1179 char *message
= xstrprintf ("Error inserting catchpoint %d:\n",
1180 bpt
->owner
->number
);
1181 struct cleanup
*cleanups
= make_cleanup (xfree
, message
);
1183 args_for_catchpoint_enable args
;
1184 args
.kind
= bpt
->owner
->type
== bp_catch_catch
?
1185 EX_EVENT_CATCH
: EX_EVENT_THROW
;
1187 val
= catch_errors (cover_target_enable_exception_callback
,
1188 &args
, message
, RETURN_MASK_ALL
);
1189 do_cleanups (cleanups
);
1190 if (val
!= 0 && val
!= -1)
1193 /* Check if something went wrong; val == 0 can be ignored */
1196 /* something went wrong */
1197 fprintf_unfiltered (tmp_error_stream
,
1198 "Cannot insert catchpoint %d; disabling it.\n",
1199 bpt
->owner
->number
);
1200 bpt
->owner
->enable_state
= bp_disabled
;
1207 else if (bpt
->owner
->type
== bp_catch_fork
1208 || bpt
->owner
->type
== bp_catch_vfork
1209 || bpt
->owner
->type
== bp_catch_exec
)
1211 struct gdb_exception e
= catch_exception (uiout
, insert_catchpoint
,
1212 bpt
->owner
, RETURN_MASK_ERROR
);
1213 exception_fprintf (gdb_stderr
, e
, "warning: inserting catchpoint %d: ",
1214 bpt
->owner
->number
);
1216 bpt
->owner
->enable_state
= bp_disabled
;
1220 /* We've already printed an error message if there was a problem
1221 inserting this catchpoint, and we've disabled the catchpoint,
1222 so just return success. */
1229 /* insert_breakpoints is used when starting or continuing the program.
1230 remove_breakpoints is used when the program stops.
1231 Both return zero if successful,
1232 or an `errno' value if could not write the inferior. */
1235 insert_breakpoints (void)
1237 struct bp_location
*b
, *temp
;
1238 int return_val
= 0; /* return success code. */
1240 int disabled_breaks
= 0;
1241 int hw_breakpoint_error
= 0;
1242 int process_warning
= 0;
1244 struct ui_file
*tmp_error_stream
= mem_fileopen ();
1245 make_cleanup_ui_file_delete (tmp_error_stream
);
1247 /* Explicitly mark the warning -- this will only be printed if
1248 there was an error. */
1249 fprintf_unfiltered (tmp_error_stream
, "Warning:\n");
1251 ALL_BP_LOCATIONS_SAFE (b
, temp
)
1253 /* Permanent breakpoints cannot be inserted or removed. Disabled
1254 breakpoints should not be inserted. */
1255 if (!breakpoint_enabled (b
->owner
))
1258 /* There is no point inserting thread-specific breakpoints if the
1259 thread no longer exists. */
1260 if (b
->owner
->thread
!= -1
1261 && !valid_thread_id (b
->owner
->thread
))
1264 /* FIXME drow/2003-10-07: This code should be pushed elsewhere when
1265 hardware watchpoints are split into multiple loc breakpoints. */
1266 if ((b
->loc_type
== bp_loc_hardware_watchpoint
1267 || b
->owner
->type
== bp_watchpoint
) && !b
->owner
->val
)
1270 val
= evaluate_expression (b
->owner
->exp
);
1271 release_value (val
);
1272 if (value_lazy (val
))
1273 value_fetch_lazy (val
);
1274 b
->owner
->val
= val
;
1277 val
= insert_bp_location (b
, tmp_error_stream
,
1278 &disabled_breaks
, &process_warning
,
1279 &hw_breakpoint_error
);
1286 /* If a hardware breakpoint or watchpoint was inserted, add a
1287 message about possibly exhausted resources. */
1288 if (hw_breakpoint_error
)
1290 fprintf_unfiltered (tmp_error_stream
,
1291 "Could not insert hardware breakpoints:\n\
1292 You may have requested too many hardware breakpoints/watchpoints.\n");
1294 #ifdef ONE_PROCESS_WRITETEXT
1295 if (process_warning
)
1296 fprintf_unfiltered (tmp_error_stream
,
1297 "The same program may be running in another process.");
1299 target_terminal_ours_for_output ();
1300 error_stream (tmp_error_stream
);
1306 remove_breakpoints (void)
1308 struct bp_location
*b
;
1311 ALL_BP_LOCATIONS (b
)
1315 val
= remove_breakpoint (b
, mark_uninserted
);
1324 remove_hw_watchpoints (void)
1326 struct bp_location
*b
;
1329 ALL_BP_LOCATIONS (b
)
1331 if (b
->inserted
&& b
->loc_type
== bp_loc_hardware_watchpoint
)
1333 val
= remove_breakpoint (b
, mark_uninserted
);
1342 reattach_breakpoints (int pid
)
1344 struct bp_location
*b
;
1346 struct cleanup
*old_chain
= save_inferior_ptid ();
1348 /* Set inferior_ptid; remove_breakpoint uses this global. */
1349 inferior_ptid
= pid_to_ptid (pid
);
1350 ALL_BP_LOCATIONS (b
)
1354 remove_breakpoint (b
, mark_inserted
);
1355 /* Note: since we insert a breakpoint right after removing,
1356 any decisions about automatically using hardware breakpoints
1357 made in insert_bp_location are preserved. */
1358 if (b
->loc_type
== bp_loc_hardware_breakpoint
)
1359 val
= target_insert_hw_breakpoint (&b
->target_info
);
1361 val
= target_insert_breakpoint (&b
->target_info
);
1362 /* FIXME drow/2003-10-07: This doesn't handle any other kinds of
1363 breakpoints. It's wrong for watchpoints, for example. */
1366 do_cleanups (old_chain
);
1371 do_cleanups (old_chain
);
1376 update_breakpoints_after_exec (void)
1378 struct breakpoint
*b
;
1379 struct breakpoint
*temp
;
1381 /* Doing this first prevents the badness of having delete_breakpoint()
1382 write a breakpoint's current "shadow contents" to lift the bp. That
1383 shadow is NOT valid after an exec()! */
1384 mark_breakpoints_out ();
1386 ALL_BREAKPOINTS_SAFE (b
, temp
)
1388 /* Solib breakpoints must be explicitly reset after an exec(). */
1389 if (b
->type
== bp_shlib_event
)
1391 delete_breakpoint (b
);
1395 /* Thread event breakpoints must be set anew after an exec(),
1396 as must overlay event breakpoints. */
1397 if (b
->type
== bp_thread_event
|| b
->type
== bp_overlay_event
)
1399 delete_breakpoint (b
);
1403 /* Step-resume breakpoints are meaningless after an exec(). */
1404 if (b
->type
== bp_step_resume
)
1406 delete_breakpoint (b
);
1410 /* Ditto the sigtramp handler breakpoints. */
1411 if (b
->type
== bp_through_sigtramp
)
1413 delete_breakpoint (b
);
1417 /* Ditto the exception-handling catchpoints. */
1418 if ((b
->type
== bp_catch_catch
) || (b
->type
== bp_catch_throw
))
1420 delete_breakpoint (b
);
1424 /* Don't delete an exec catchpoint, because else the inferior
1425 won't stop when it ought!
1427 Similarly, we probably ought to keep vfork catchpoints, 'cause
1428 on this target, we may not be able to stop when the vfork is
1429 seen, but only when the subsequent exec is seen. (And because
1430 deleting fork catchpoints here but not vfork catchpoints will
1431 seem mysterious to users, keep those too.)
1433 ??rehrauer: Let's hope that merely clearing out this catchpoint's
1434 target address field, if any, is sufficient to have it be reset
1435 automagically. Certainly on HP-UX that's true.
1437 Jim Blandy <jimb@redhat.com>: Actually, zero is a perfectly
1438 valid code address on some platforms (like the mn10300
1439 simulators). We shouldn't assign any special interpretation to
1440 a breakpoint with a zero address. And in fact, GDB doesn't ---
1441 I can't see what that comment above is talking about. As far
1442 as I can tell, setting the address of a
1443 bp_catch_exec/bp_catch_vfork/bp_catch_fork breakpoint to zero
1444 is meaningless, since those are implemented with HP-UX kernel
1445 hackery, not by storing breakpoint instructions somewhere. */
1446 if ((b
->type
== bp_catch_exec
) ||
1447 (b
->type
== bp_catch_vfork
) ||
1448 (b
->type
== bp_catch_fork
))
1450 b
->loc
->address
= (CORE_ADDR
) 0;
1454 /* bp_finish is a special case. The only way we ought to be able
1455 to see one of these when an exec() has happened, is if the user
1456 caught a vfork, and then said "finish". Ordinarily a finish just
1457 carries them to the call-site of the current callee, by setting
1458 a temporary bp there and resuming. But in this case, the finish
1459 will carry them entirely through the vfork & exec.
1461 We don't want to allow a bp_finish to remain inserted now. But
1462 we can't safely delete it, 'cause finish_command has a handle to
1463 the bp on a bpstat, and will later want to delete it. There's a
1464 chance (and I've seen it happen) that if we delete the bp_finish
1465 here, that its storage will get reused by the time finish_command
1466 gets 'round to deleting the "use to be a bp_finish" breakpoint.
1467 We really must allow finish_command to delete a bp_finish.
1469 In the absense of a general solution for the "how do we know
1470 it's safe to delete something others may have handles to?"
1471 problem, what we'll do here is just uninsert the bp_finish, and
1472 let finish_command delete it.
1474 (We know the bp_finish is "doomed" in the sense that it's
1475 momentary, and will be deleted as soon as finish_command sees
1476 the inferior stopped. So it doesn't matter that the bp's
1477 address is probably bogus in the new a.out, unlike e.g., the
1478 solib breakpoints.) */
1480 if (b
->type
== bp_finish
)
1485 /* Without a symbolic address, we have little hope of the
1486 pre-exec() address meaning the same thing in the post-exec()
1488 if (b
->addr_string
== NULL
)
1490 delete_breakpoint (b
);
1494 /* If this breakpoint has survived the above battery of checks, then
1495 it must have a symbolic address. Be sure that it gets reevaluated
1496 to a target address, rather than reusing the old evaluation.
1498 Jim Blandy <jimb@redhat.com>: As explained above in the comment
1499 for bp_catch_exec and friends, I'm pretty sure this is entirely
1500 unnecessary. A call to breakpoint_re_set_one always recomputes
1501 the breakpoint's address from scratch, or deletes it if it can't.
1502 So I think this assignment could be deleted without effect. */
1503 b
->loc
->address
= (CORE_ADDR
) 0;
1505 /* FIXME what about longjmp breakpoints? Re-create them here? */
1506 create_overlay_event_breakpoint ("_ovly_debug_event");
1510 detach_breakpoints (int pid
)
1512 struct bp_location
*b
;
1514 struct cleanup
*old_chain
= save_inferior_ptid ();
1516 if (pid
== PIDGET (inferior_ptid
))
1517 error (_("Cannot detach breakpoints of inferior_ptid"));
1519 /* Set inferior_ptid; remove_breakpoint uses this global. */
1520 inferior_ptid
= pid_to_ptid (pid
);
1521 ALL_BP_LOCATIONS (b
)
1525 val
= remove_breakpoint (b
, mark_inserted
);
1528 do_cleanups (old_chain
);
1533 do_cleanups (old_chain
);
1538 remove_breakpoint (struct bp_location
*b
, insertion_state_t is
)
1542 if (b
->owner
->enable_state
== bp_permanent
)
1543 /* Permanent breakpoints cannot be inserted or removed. */
1546 if (b
->owner
->type
== bp_none
)
1547 warning (_("attempted to remove apparently deleted breakpoint #%d?"),
1550 if (b
->loc_type
== bp_loc_software_breakpoint
1551 || b
->loc_type
== bp_loc_hardware_breakpoint
)
1553 /* "Normal" instruction breakpoint: either the standard
1554 trap-instruction bp (bp_breakpoint), or a
1555 bp_hardware_breakpoint. */
1557 /* First check to see if we have to handle an overlay. */
1558 if (overlay_debugging
== ovly_off
1559 || b
->section
== NULL
1560 || !(section_is_overlay (b
->section
)))
1562 /* No overlay handling: just remove the breakpoint. */
1564 if (b
->loc_type
== bp_loc_hardware_breakpoint
)
1565 val
= target_remove_hw_breakpoint (&b
->target_info
);
1567 val
= target_remove_breakpoint (&b
->target_info
);
1571 /* This breakpoint is in an overlay section.
1572 Did we set a breakpoint at the LMA? */
1573 if (!overlay_events_enabled
)
1575 /* Yes -- overlay event support is not active, so we
1576 should have set a breakpoint at the LMA. Remove it.
1578 /* Ignore any failures: if the LMA is in ROM, we will
1579 have already warned when we failed to insert it. */
1580 if (b
->loc_type
== bp_loc_hardware_breakpoint
)
1581 target_remove_hw_breakpoint (&b
->overlay_target_info
);
1583 target_remove_breakpoint (&b
->overlay_target_info
);
1585 /* Did we set a breakpoint at the VMA?
1586 If so, we will have marked the breakpoint 'inserted'. */
1589 /* Yes -- remove it. Previously we did not bother to
1590 remove the breakpoint if the section had been
1591 unmapped, but let's not rely on that being safe. We
1592 don't know what the overlay manager might do. */
1593 if (b
->loc_type
== bp_loc_hardware_breakpoint
)
1594 val
= target_remove_hw_breakpoint (&b
->target_info
);
1596 val
= target_remove_breakpoint (&b
->target_info
);
1600 /* No -- not inserted, so no need to remove. No error. */
1606 b
->inserted
= (is
== mark_inserted
);
1608 else if (b
->loc_type
== bp_loc_hardware_watchpoint
1609 && breakpoint_enabled (b
->owner
)
1615 b
->inserted
= (is
== mark_inserted
);
1616 /* Walk down the saved value chain. */
1617 for (v
= b
->owner
->val_chain
; v
; v
= value_next (v
))
1619 /* For each memory reference remove the watchpoint
1621 if (VALUE_LVAL (v
) == lval_memory
1622 && ! value_lazy (v
))
1624 struct type
*vtype
= check_typedef (value_type (v
));
1626 if (v
== b
->owner
->val_chain
1627 || (TYPE_CODE (vtype
) != TYPE_CODE_STRUCT
1628 && TYPE_CODE (vtype
) != TYPE_CODE_ARRAY
))
1633 addr
= VALUE_ADDRESS (v
) + value_offset (v
);
1634 len
= TYPE_LENGTH (value_type (v
));
1636 if (b
->owner
->type
== bp_read_watchpoint
)
1638 else if (b
->owner
->type
== bp_access_watchpoint
)
1641 val
= target_remove_watchpoint (addr
, len
, type
);
1648 /* Failure to remove any of the hardware watchpoints comes here. */
1649 if ((is
== mark_uninserted
) && (b
->inserted
))
1650 warning (_("Could not remove hardware watchpoint %d."),
1653 else if ((b
->owner
->type
== bp_catch_fork
||
1654 b
->owner
->type
== bp_catch_vfork
||
1655 b
->owner
->type
== bp_catch_exec
)
1656 && breakpoint_enabled (b
->owner
)
1660 switch (b
->owner
->type
)
1663 val
= target_remove_fork_catchpoint (PIDGET (inferior_ptid
));
1665 case bp_catch_vfork
:
1666 val
= target_remove_vfork_catchpoint (PIDGET (inferior_ptid
));
1669 val
= target_remove_exec_catchpoint (PIDGET (inferior_ptid
));
1672 warning (_("Internal error, %s line %d."), __FILE__
, __LINE__
);
1677 b
->inserted
= (is
== mark_inserted
);
1679 else if ((b
->owner
->type
== bp_catch_catch
||
1680 b
->owner
->type
== bp_catch_throw
)
1681 && breakpoint_enabled (b
->owner
)
1684 val
= target_remove_breakpoint (&b
->target_info
);
1687 b
->inserted
= (is
== mark_inserted
);
1693 /* Clear the "inserted" flag in all breakpoints. */
1696 mark_breakpoints_out (void)
1698 struct bp_location
*bpt
;
1700 ALL_BP_LOCATIONS (bpt
)
1704 /* Clear the "inserted" flag in all breakpoints and delete any
1705 breakpoints which should go away between runs of the program.
1707 Plus other such housekeeping that has to be done for breakpoints
1710 Note: this function gets called at the end of a run (by
1711 generic_mourn_inferior) and when a run begins (by
1712 init_wait_for_inferior). */
1717 breakpoint_init_inferior (enum inf_context context
)
1719 struct breakpoint
*b
, *temp
;
1720 struct bp_location
*bpt
;
1721 static int warning_needed
= 0;
1723 ALL_BP_LOCATIONS (bpt
)
1726 ALL_BREAKPOINTS_SAFE (b
, temp
)
1731 case bp_watchpoint_scope
:
1733 /* If the call dummy breakpoint is at the entry point it will
1734 cause problems when the inferior is rerun, so we better
1737 Also get rid of scope breakpoints. */
1738 delete_breakpoint (b
);
1742 case bp_hardware_watchpoint
:
1743 case bp_read_watchpoint
:
1744 case bp_access_watchpoint
:
1746 /* Likewise for watchpoints on local expressions. */
1747 if (b
->exp_valid_block
!= NULL
)
1748 delete_breakpoint (b
);
1749 if (context
== inf_starting
)
1751 /* Reset val field to force reread of starting value
1752 in insert_breakpoints. */
1754 value_free (b
->val
);
1759 /* Likewise for exception catchpoints in dynamic-linked
1760 executables where required */
1761 if (ep_is_exception_catchpoint (b
)
1762 && deprecated_exception_catchpoints_are_fragile
)
1765 delete_breakpoint (b
);
1771 if (deprecated_exception_catchpoints_are_fragile
)
1772 deprecated_exception_support_initialized
= 0;
1774 /* Don't issue the warning unless it's really needed... */
1775 if (warning_needed
&& (context
!= inf_exited
))
1777 warning (_("Exception catchpoints from last run were deleted.\n"
1778 "You must reinsert them explicitly."));
1783 /* breakpoint_here_p (PC) returns non-zero if an enabled breakpoint
1784 exists at PC. It returns ordinary_breakpoint_here if it's an
1785 ordinary breakpoint, or permanent_breakpoint_here if it's a
1786 permanent breakpoint.
1787 - When continuing from a location with an ordinary breakpoint, we
1788 actually single step once before calling insert_breakpoints.
1789 - When continuing from a localion with a permanent breakpoint, we
1790 need to use the `SKIP_PERMANENT_BREAKPOINT' macro, provided by
1791 the target, to advance the PC past the breakpoint. */
1793 enum breakpoint_here
1794 breakpoint_here_p (CORE_ADDR pc
)
1796 struct bp_location
*bpt
;
1797 int any_breakpoint_here
= 0;
1799 ALL_BP_LOCATIONS (bpt
)
1801 if (bpt
->loc_type
!= bp_loc_software_breakpoint
1802 && bpt
->loc_type
!= bp_loc_hardware_breakpoint
)
1805 if ((breakpoint_enabled (bpt
->owner
)
1806 || bpt
->owner
->enable_state
== bp_permanent
)
1807 && bpt
->address
== pc
) /* bp is enabled and matches pc */
1809 if (overlay_debugging
1810 && section_is_overlay (bpt
->section
)
1811 && !section_is_mapped (bpt
->section
))
1812 continue; /* unmapped overlay -- can't be a match */
1813 else if (bpt
->owner
->enable_state
== bp_permanent
)
1814 return permanent_breakpoint_here
;
1816 any_breakpoint_here
= 1;
1820 return any_breakpoint_here
? ordinary_breakpoint_here
: 0;
1824 /* breakpoint_inserted_here_p (PC) is just like breakpoint_here_p(),
1825 but it only returns true if there is actually a breakpoint inserted
1829 breakpoint_inserted_here_p (CORE_ADDR pc
)
1831 struct bp_location
*bpt
;
1833 ALL_BP_LOCATIONS (bpt
)
1835 if (bpt
->loc_type
!= bp_loc_software_breakpoint
1836 && bpt
->loc_type
!= bp_loc_hardware_breakpoint
)
1840 && bpt
->address
== pc
) /* bp is inserted and matches pc */
1842 if (overlay_debugging
1843 && section_is_overlay (bpt
->section
)
1844 && !section_is_mapped (bpt
->section
))
1845 continue; /* unmapped overlay -- can't be a match */
1854 /* This function returns non-zero iff there is a software breakpoint
1858 software_breakpoint_inserted_here_p (CORE_ADDR pc
)
1860 struct bp_location
*bpt
;
1861 int any_breakpoint_here
= 0;
1863 ALL_BP_LOCATIONS (bpt
)
1865 if (bpt
->loc_type
!= bp_loc_software_breakpoint
)
1868 if ((breakpoint_enabled (bpt
->owner
)
1869 || bpt
->owner
->enable_state
== bp_permanent
)
1871 && bpt
->address
== pc
) /* bp is enabled and matches pc */
1873 if (overlay_debugging
1874 && section_is_overlay (bpt
->section
)
1875 && !section_is_mapped (bpt
->section
))
1876 continue; /* unmapped overlay -- can't be a match */
1885 /* breakpoint_thread_match (PC, PTID) returns true if the breakpoint at
1886 PC is valid for process/thread PTID. */
1889 breakpoint_thread_match (CORE_ADDR pc
, ptid_t ptid
)
1891 struct bp_location
*bpt
;
1894 thread
= pid_to_thread_id (ptid
);
1896 ALL_BP_LOCATIONS (bpt
)
1898 if (bpt
->loc_type
!= bp_loc_software_breakpoint
1899 && bpt
->loc_type
!= bp_loc_hardware_breakpoint
)
1902 if ((breakpoint_enabled (bpt
->owner
)
1903 || bpt
->owner
->enable_state
== bp_permanent
)
1904 && bpt
->address
== pc
1905 && (bpt
->owner
->thread
== -1 || bpt
->owner
->thread
== thread
))
1907 if (overlay_debugging
1908 && section_is_overlay (bpt
->section
)
1909 && !section_is_mapped (bpt
->section
))
1910 continue; /* unmapped overlay -- can't be a match */
1920 /* bpstat stuff. External routines' interfaces are documented
1924 ep_is_catchpoint (struct breakpoint
*ep
)
1927 (ep
->type
== bp_catch_load
)
1928 || (ep
->type
== bp_catch_unload
)
1929 || (ep
->type
== bp_catch_fork
)
1930 || (ep
->type
== bp_catch_vfork
)
1931 || (ep
->type
== bp_catch_exec
)
1932 || (ep
->type
== bp_catch_catch
)
1933 || (ep
->type
== bp_catch_throw
);
1935 /* ??rehrauer: Add more kinds here, as are implemented... */
1939 ep_is_shlib_catchpoint (struct breakpoint
*ep
)
1942 (ep
->type
== bp_catch_load
)
1943 || (ep
->type
== bp_catch_unload
);
1947 ep_is_exception_catchpoint (struct breakpoint
*ep
)
1950 (ep
->type
== bp_catch_catch
)
1951 || (ep
->type
== bp_catch_throw
);
1954 /* Clear a bpstat so that it says we are not at any breakpoint.
1955 Also free any storage that is part of a bpstat. */
1958 bpstat_clear (bpstat
*bsp
)
1969 if (p
->old_val
!= NULL
)
1970 value_free (p
->old_val
);
1971 free_command_lines (&p
->commands
);
1978 /* Return a copy of a bpstat. Like "bs1 = bs2" but all storage that
1979 is part of the bpstat is copied as well. */
1982 bpstat_copy (bpstat bs
)
1986 bpstat retval
= NULL
;
1991 for (; bs
!= NULL
; bs
= bs
->next
)
1993 tmp
= (bpstat
) xmalloc (sizeof (*tmp
));
1994 memcpy (tmp
, bs
, sizeof (*tmp
));
1995 if (bs
->commands
!= NULL
)
1996 tmp
->commands
= copy_command_lines (bs
->commands
);
1997 if (bs
->old_val
!= NULL
)
1998 tmp
->old_val
= value_copy (bs
->old_val
);
2001 /* This is the first thing in the chain. */
2011 /* Find the bpstat associated with this breakpoint */
2014 bpstat_find_breakpoint (bpstat bsp
, struct breakpoint
*breakpoint
)
2019 for (; bsp
!= NULL
; bsp
= bsp
->next
)
2021 if (bsp
->breakpoint_at
== breakpoint
)
2027 /* Find a step_resume breakpoint associated with this bpstat.
2028 (If there are multiple step_resume bp's on the list, this function
2029 will arbitrarily pick one.)
2031 It is an error to use this function if BPSTAT doesn't contain a
2032 step_resume breakpoint.
2034 See wait_for_inferior's use of this function. */
2036 bpstat_find_step_resume_breakpoint (bpstat bsp
)
2040 gdb_assert (bsp
!= NULL
);
2042 current_thread
= pid_to_thread_id (inferior_ptid
);
2044 for (; bsp
!= NULL
; bsp
= bsp
->next
)
2046 if ((bsp
->breakpoint_at
!= NULL
) &&
2047 (bsp
->breakpoint_at
->type
== bp_step_resume
) &&
2048 (bsp
->breakpoint_at
->thread
== current_thread
||
2049 bsp
->breakpoint_at
->thread
== -1))
2050 return bsp
->breakpoint_at
;
2053 internal_error (__FILE__
, __LINE__
, _("No step_resume breakpoint found."));
2057 /* Put in *NUM the breakpoint number of the first breakpoint we are stopped
2058 at. *BSP upon return is a bpstat which points to the remaining
2059 breakpoints stopped at (but which is not guaranteed to be good for
2060 anything but further calls to bpstat_num).
2061 Return 0 if passed a bpstat which does not indicate any breakpoints.
2062 Return -1 if stopped at a breakpoint that has been deleted since
2064 Return 1 otherwise. */
2067 bpstat_num (bpstat
*bsp
, int *num
)
2069 struct breakpoint
*b
;
2072 return 0; /* No more breakpoint values */
2074 b
= (*bsp
)->breakpoint_at
;
2075 *bsp
= (*bsp
)->next
;
2077 return -1; /* breakpoint that's been deleted since */
2079 *num
= b
->number
; /* We have its number */
2083 /* Modify BS so that the actions will not be performed. */
2086 bpstat_clear_actions (bpstat bs
)
2088 for (; bs
!= NULL
; bs
= bs
->next
)
2090 free_command_lines (&bs
->commands
);
2091 if (bs
->old_val
!= NULL
)
2093 value_free (bs
->old_val
);
2099 /* Stub for cleaning up our state if we error-out of a breakpoint command */
2101 cleanup_executing_breakpoints (void *ignore
)
2103 executing_breakpoint_commands
= 0;
2106 /* Execute all the commands associated with all the breakpoints at this
2107 location. Any of these commands could cause the process to proceed
2108 beyond this point, etc. We look out for such changes by checking
2109 the global "breakpoint_proceeded" after each command. */
2112 bpstat_do_actions (bpstat
*bsp
)
2115 struct cleanup
*old_chain
;
2117 /* Avoid endless recursion if a `source' command is contained
2119 if (executing_breakpoint_commands
)
2122 executing_breakpoint_commands
= 1;
2123 old_chain
= make_cleanup (cleanup_executing_breakpoints
, 0);
2126 /* Note that (as of this writing), our callers all appear to
2127 be passing us the address of global stop_bpstat. And, if
2128 our calls to execute_control_command cause the inferior to
2129 proceed, that global (and hence, *bsp) will change.
2131 We must be careful to not touch *bsp unless the inferior
2132 has not proceeded. */
2134 /* This pointer will iterate over the list of bpstat's. */
2137 breakpoint_proceeded
= 0;
2138 for (; bs
!= NULL
; bs
= bs
->next
)
2140 struct command_line
*cmd
;
2141 struct cleanup
*this_cmd_tree_chain
;
2143 /* Take ownership of the BSP's command tree, if it has one.
2145 The command tree could legitimately contain commands like
2146 'step' and 'next', which call clear_proceed_status, which
2147 frees stop_bpstat's command tree. To make sure this doesn't
2148 free the tree we're executing out from under us, we need to
2149 take ownership of the tree ourselves. Since a given bpstat's
2150 commands are only executed once, we don't need to copy it; we
2151 can clear the pointer in the bpstat, and make sure we free
2152 the tree when we're done. */
2155 this_cmd_tree_chain
= make_cleanup_free_command_lines (&cmd
);
2159 execute_control_command (cmd
);
2161 if (breakpoint_proceeded
)
2167 /* We can free this command tree now. */
2168 do_cleanups (this_cmd_tree_chain
);
2170 if (breakpoint_proceeded
)
2171 /* The inferior is proceeded by the command; bomb out now.
2172 The bpstat chain has been blown away by wait_for_inferior.
2173 But since execution has stopped again, there is a new bpstat
2174 to look at, so start over. */
2177 do_cleanups (old_chain
);
2180 /* This is the normal print function for a bpstat. In the future,
2181 much of this logic could (should?) be moved to bpstat_stop_status,
2182 by having it set different print_it values.
2184 Current scheme: When we stop, bpstat_print() is called. It loops
2185 through the bpstat list of things causing this stop, calling the
2186 print_bp_stop_message function on each one. The behavior of the
2187 print_bp_stop_message function depends on the print_it field of
2188 bpstat. If such field so indicates, call this function here.
2190 Return values from this routine (ultimately used by bpstat_print()
2191 and normal_stop() to decide what to do):
2192 PRINT_NOTHING: Means we already printed all we needed to print,
2193 don't print anything else.
2194 PRINT_SRC_ONLY: Means we printed something, and we do *not* desire
2195 that something to be followed by a location.
2196 PRINT_SCR_AND_LOC: Means we printed something, and we *do* desire
2197 that something to be followed by a location.
2198 PRINT_UNKNOWN: Means we printed nothing or we need to do some more
2201 static enum print_stop_action
2202 print_it_typical (bpstat bs
)
2204 struct cleanup
*old_chain
, *ui_out_chain
;
2205 struct ui_stream
*stb
;
2206 stb
= ui_out_stream_new (uiout
);
2207 old_chain
= make_cleanup_ui_out_stream_delete (stb
);
2208 /* bs->breakpoint_at can be NULL if it was a momentary breakpoint
2209 which has since been deleted. */
2210 if (bs
->breakpoint_at
== NULL
)
2211 return PRINT_UNKNOWN
;
2213 switch (bs
->breakpoint_at
->type
)
2216 case bp_hardware_breakpoint
:
2217 if (bs
->breakpoint_at
->loc
->address
!= bs
->breakpoint_at
->loc
->requested_address
)
2218 breakpoint_adjustment_warning (bs
->breakpoint_at
->loc
->requested_address
,
2219 bs
->breakpoint_at
->loc
->address
,
2220 bs
->breakpoint_at
->number
, 1);
2221 annotate_breakpoint (bs
->breakpoint_at
->number
);
2222 ui_out_text (uiout
, "\nBreakpoint ");
2223 if (ui_out_is_mi_like_p (uiout
))
2224 ui_out_field_string (uiout
, "reason",
2225 async_reason_lookup (EXEC_ASYNC_BREAKPOINT_HIT
));
2226 ui_out_field_int (uiout
, "bkptno", bs
->breakpoint_at
->number
);
2227 ui_out_text (uiout
, ", ");
2228 return PRINT_SRC_AND_LOC
;
2231 case bp_shlib_event
:
2232 /* Did we stop because the user set the stop_on_solib_events
2233 variable? (If so, we report this as a generic, "Stopped due
2234 to shlib event" message.) */
2235 printf_filtered (_("Stopped due to shared library event\n"));
2236 return PRINT_NOTHING
;
2239 case bp_thread_event
:
2240 /* Not sure how we will get here.
2241 GDB should not stop for these breakpoints. */
2242 printf_filtered (_("Thread Event Breakpoint: gdb should not stop!\n"));
2243 return PRINT_NOTHING
;
2246 case bp_overlay_event
:
2247 /* By analogy with the thread event, GDB should not stop for these. */
2248 printf_filtered (_("Overlay Event Breakpoint: gdb should not stop!\n"));
2249 return PRINT_NOTHING
;
2253 annotate_catchpoint (bs
->breakpoint_at
->number
);
2254 printf_filtered (_("\nCatchpoint %d (loaded %s), "),
2255 bs
->breakpoint_at
->number
,
2256 bs
->breakpoint_at
->triggered_dll_pathname
);
2257 return PRINT_SRC_AND_LOC
;
2260 case bp_catch_unload
:
2261 annotate_catchpoint (bs
->breakpoint_at
->number
);
2262 printf_filtered (_("\nCatchpoint %d (unloaded %s), "),
2263 bs
->breakpoint_at
->number
,
2264 bs
->breakpoint_at
->triggered_dll_pathname
);
2265 return PRINT_SRC_AND_LOC
;
2269 annotate_catchpoint (bs
->breakpoint_at
->number
);
2270 printf_filtered (_("\nCatchpoint %d (forked process %d), "),
2271 bs
->breakpoint_at
->number
,
2272 bs
->breakpoint_at
->forked_inferior_pid
);
2273 return PRINT_SRC_AND_LOC
;
2276 case bp_catch_vfork
:
2277 annotate_catchpoint (bs
->breakpoint_at
->number
);
2278 printf_filtered (_("\nCatchpoint %d (vforked process %d), "),
2279 bs
->breakpoint_at
->number
,
2280 bs
->breakpoint_at
->forked_inferior_pid
);
2281 return PRINT_SRC_AND_LOC
;
2285 annotate_catchpoint (bs
->breakpoint_at
->number
);
2286 printf_filtered (_("\nCatchpoint %d (exec'd %s), "),
2287 bs
->breakpoint_at
->number
,
2288 bs
->breakpoint_at
->exec_pathname
);
2289 return PRINT_SRC_AND_LOC
;
2292 case bp_catch_catch
:
2293 if (current_exception_event
&&
2294 (CURRENT_EXCEPTION_KIND
== EX_EVENT_CATCH
))
2296 annotate_catchpoint (bs
->breakpoint_at
->number
);
2297 printf_filtered (_("\nCatchpoint %d (exception caught), "),
2298 bs
->breakpoint_at
->number
);
2299 if (CURRENT_EXCEPTION_THROW_PC
&& CURRENT_EXCEPTION_THROW_LINE
)
2300 printf_filtered (_("throw location %s:%d, "),
2301 CURRENT_EXCEPTION_THROW_FILE
,
2302 CURRENT_EXCEPTION_THROW_LINE
);
2304 printf_filtered (_("throw location unknown, "));
2306 if (CURRENT_EXCEPTION_CATCH_PC
&& CURRENT_EXCEPTION_CATCH_LINE
)
2307 printf_filtered (_("catch location %s:%d\n"),
2308 CURRENT_EXCEPTION_CATCH_FILE
,
2309 CURRENT_EXCEPTION_CATCH_LINE
);
2311 printf_filtered (_("catch location unknown\n"));
2313 /* don't bother to print location frame info */
2314 return PRINT_SRC_ONLY
;
2318 /* really throw, some other bpstat will handle it */
2319 return PRINT_UNKNOWN
;
2323 case bp_catch_throw
:
2324 if (current_exception_event
&&
2325 (CURRENT_EXCEPTION_KIND
== EX_EVENT_THROW
))
2327 annotate_catchpoint (bs
->breakpoint_at
->number
);
2328 printf_filtered (_("\nCatchpoint %d (exception thrown), "),
2329 bs
->breakpoint_at
->number
);
2330 if (CURRENT_EXCEPTION_THROW_PC
&& CURRENT_EXCEPTION_THROW_LINE
)
2331 printf_filtered (_("throw location %s:%d, "),
2332 CURRENT_EXCEPTION_THROW_FILE
,
2333 CURRENT_EXCEPTION_THROW_LINE
);
2335 printf_filtered (_("throw location unknown, "));
2337 if (CURRENT_EXCEPTION_CATCH_PC
&& CURRENT_EXCEPTION_CATCH_LINE
)
2338 printf_filtered (_("catch location %s:%d\n"),
2339 CURRENT_EXCEPTION_CATCH_FILE
,
2340 CURRENT_EXCEPTION_CATCH_LINE
);
2342 printf_filtered (_("catch location unknown\n"));
2344 /* don't bother to print location frame info */
2345 return PRINT_SRC_ONLY
;
2349 /* really catch, some other bpstat will handle it */
2350 return PRINT_UNKNOWN
;
2355 case bp_hardware_watchpoint
:
2356 if (bs
->old_val
!= NULL
)
2358 annotate_watchpoint (bs
->breakpoint_at
->number
);
2359 if (ui_out_is_mi_like_p (uiout
))
2362 async_reason_lookup (EXEC_ASYNC_WATCHPOINT_TRIGGER
));
2363 mention (bs
->breakpoint_at
);
2364 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "value");
2365 ui_out_text (uiout
, "\nOld value = ");
2366 value_print (bs
->old_val
, stb
->stream
, 0, Val_pretty_default
);
2367 ui_out_field_stream (uiout
, "old", stb
);
2368 ui_out_text (uiout
, "\nNew value = ");
2369 value_print (bs
->breakpoint_at
->val
, stb
->stream
, 0, Val_pretty_default
);
2370 ui_out_field_stream (uiout
, "new", stb
);
2371 do_cleanups (ui_out_chain
);
2372 ui_out_text (uiout
, "\n");
2373 value_free (bs
->old_val
);
2376 /* More than one watchpoint may have been triggered. */
2377 return PRINT_UNKNOWN
;
2380 case bp_read_watchpoint
:
2381 if (ui_out_is_mi_like_p (uiout
))
2384 async_reason_lookup (EXEC_ASYNC_READ_WATCHPOINT_TRIGGER
));
2385 mention (bs
->breakpoint_at
);
2386 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "value");
2387 ui_out_text (uiout
, "\nValue = ");
2388 value_print (bs
->breakpoint_at
->val
, stb
->stream
, 0, Val_pretty_default
);
2389 ui_out_field_stream (uiout
, "value", stb
);
2390 do_cleanups (ui_out_chain
);
2391 ui_out_text (uiout
, "\n");
2392 return PRINT_UNKNOWN
;
2395 case bp_access_watchpoint
:
2396 if (bs
->old_val
!= NULL
)
2398 annotate_watchpoint (bs
->breakpoint_at
->number
);
2399 if (ui_out_is_mi_like_p (uiout
))
2402 async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER
));
2403 mention (bs
->breakpoint_at
);
2404 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "value");
2405 ui_out_text (uiout
, "\nOld value = ");
2406 value_print (bs
->old_val
, stb
->stream
, 0, Val_pretty_default
);
2407 ui_out_field_stream (uiout
, "old", stb
);
2408 value_free (bs
->old_val
);
2410 ui_out_text (uiout
, "\nNew value = ");
2414 mention (bs
->breakpoint_at
);
2415 if (ui_out_is_mi_like_p (uiout
))
2418 async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER
));
2419 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "value");
2420 ui_out_text (uiout
, "\nValue = ");
2422 value_print (bs
->breakpoint_at
->val
, stb
->stream
, 0,Val_pretty_default
);
2423 ui_out_field_stream (uiout
, "new", stb
);
2424 do_cleanups (ui_out_chain
);
2425 ui_out_text (uiout
, "\n");
2426 return PRINT_UNKNOWN
;
2429 /* Fall through, we don't deal with these types of breakpoints
2433 if (ui_out_is_mi_like_p (uiout
))
2436 async_reason_lookup (EXEC_ASYNC_FUNCTION_FINISHED
));
2437 return PRINT_UNKNOWN
;
2441 if (ui_out_is_mi_like_p (uiout
))
2444 async_reason_lookup (EXEC_ASYNC_LOCATION_REACHED
));
2445 return PRINT_UNKNOWN
;
2450 case bp_longjmp_resume
:
2451 case bp_step_resume
:
2452 case bp_through_sigtramp
:
2453 case bp_watchpoint_scope
:
2456 return PRINT_UNKNOWN
;
2460 /* Generic routine for printing messages indicating why we
2461 stopped. The behavior of this function depends on the value
2462 'print_it' in the bpstat structure. Under some circumstances we
2463 may decide not to print anything here and delegate the task to
2466 static enum print_stop_action
2467 print_bp_stop_message (bpstat bs
)
2469 switch (bs
->print_it
)
2472 /* Nothing should be printed for this bpstat entry. */
2473 return PRINT_UNKNOWN
;
2477 /* We still want to print the frame, but we already printed the
2478 relevant messages. */
2479 return PRINT_SRC_AND_LOC
;
2482 case print_it_normal
:
2483 /* Normal case. Call the breakpoint's print_it method, or
2484 print_it_typical. */
2485 if (bs
->breakpoint_at
!= NULL
&& bs
->breakpoint_at
->ops
!= NULL
2486 && bs
->breakpoint_at
->ops
->print_it
!= NULL
)
2487 return bs
->breakpoint_at
->ops
->print_it (bs
->breakpoint_at
);
2489 return print_it_typical (bs
);
2493 internal_error (__FILE__
, __LINE__
,
2494 _("print_bp_stop_message: unrecognized enum value"));
2499 /* Print a message indicating what happened. This is called from
2500 normal_stop(). The input to this routine is the head of the bpstat
2501 list - a list of the eventpoints that caused this stop. This
2502 routine calls the generic print routine for printing a message
2503 about reasons for stopping. This will print (for example) the
2504 "Breakpoint n," part of the output. The return value of this
2507 PRINT_UNKNOWN: Means we printed nothing
2508 PRINT_SRC_AND_LOC: Means we printed something, and expect subsequent
2509 code to print the location. An example is
2510 "Breakpoint 1, " which should be followed by
2512 PRINT_SRC_ONLY: Means we printed something, but there is no need
2513 to also print the location part of the message.
2514 An example is the catch/throw messages, which
2515 don't require a location appended to the end.
2516 PRINT_NOTHING: We have done some printing and we don't need any
2517 further info to be printed.*/
2519 enum print_stop_action
2520 bpstat_print (bpstat bs
)
2524 /* Maybe another breakpoint in the chain caused us to stop.
2525 (Currently all watchpoints go on the bpstat whether hit or not.
2526 That probably could (should) be changed, provided care is taken
2527 with respect to bpstat_explains_signal). */
2528 for (; bs
; bs
= bs
->next
)
2530 val
= print_bp_stop_message (bs
);
2531 if (val
== PRINT_SRC_ONLY
2532 || val
== PRINT_SRC_AND_LOC
2533 || val
== PRINT_NOTHING
)
2537 /* We reached the end of the chain, or we got a null BS to start
2538 with and nothing was printed. */
2539 return PRINT_UNKNOWN
;
2542 /* Evaluate the expression EXP and return 1 if value is zero.
2543 This is used inside a catch_errors to evaluate the breakpoint condition.
2544 The argument is a "struct expression *" that has been cast to char * to
2545 make it pass through catch_errors. */
2548 breakpoint_cond_eval (void *exp
)
2550 struct value
*mark
= value_mark ();
2551 int i
= !value_true (evaluate_expression ((struct expression
*) exp
));
2552 value_free_to_mark (mark
);
2556 /* Allocate a new bpstat and chain it to the current one. */
2559 bpstat_alloc (struct breakpoint
*b
, bpstat cbs
/* Current "bs" value */ )
2563 bs
= (bpstat
) xmalloc (sizeof (*bs
));
2565 bs
->breakpoint_at
= b
;
2566 /* If the condition is false, etc., don't do the commands. */
2567 bs
->commands
= NULL
;
2569 bs
->print_it
= print_it_normal
;
2573 /* Possible return values for watchpoint_check (this can't be an enum
2574 because of check_errors). */
2575 /* The watchpoint has been deleted. */
2576 #define WP_DELETED 1
2577 /* The value has changed. */
2578 #define WP_VALUE_CHANGED 2
2579 /* The value has not changed. */
2580 #define WP_VALUE_NOT_CHANGED 3
2582 #define BP_TEMPFLAG 1
2583 #define BP_HARDWAREFLAG 2
2585 /* Check watchpoint condition. */
2588 watchpoint_check (void *p
)
2590 bpstat bs
= (bpstat
) p
;
2591 struct breakpoint
*b
;
2592 struct frame_info
*fr
;
2593 int within_current_scope
;
2595 b
= bs
->breakpoint_at
;
2597 if (b
->exp_valid_block
== NULL
)
2598 within_current_scope
= 1;
2601 /* There is no current frame at this moment. If we're going to have
2602 any chance of handling watchpoints on local variables, we'll need
2603 the frame chain (so we can determine if we're in scope). */
2604 reinit_frame_cache ();
2605 fr
= frame_find_by_id (b
->watchpoint_frame
);
2606 within_current_scope
= (fr
!= NULL
);
2608 /* If we've gotten confused in the unwinder, we might have
2609 returned a frame that can't describe this variable. */
2610 if (within_current_scope
2611 && block_function (b
->exp_valid_block
) != get_frame_function (fr
))
2612 within_current_scope
= 0;
2614 /* in_function_epilogue_p() returns a non-zero value if we're still
2615 in the function but the stack frame has already been invalidated.
2616 Since we can't rely on the values of local variables after the
2617 stack has been destroyed, we are treating the watchpoint in that
2618 state as `not changed' without further checking.
2620 vinschen/2003-09-04: The former implementation left out the case
2621 that the watchpoint frame couldn't be found by frame_find_by_id()
2622 because the current PC is currently in an epilogue. Calling
2623 gdbarch_in_function_epilogue_p() also when fr == NULL fixes that. */
2624 if ((!within_current_scope
|| fr
== get_current_frame ())
2625 && gdbarch_in_function_epilogue_p (current_gdbarch
, read_pc ()))
2626 return WP_VALUE_NOT_CHANGED
;
2627 if (fr
&& within_current_scope
)
2628 /* If we end up stopping, the current frame will get selected
2629 in normal_stop. So this call to select_frame won't affect
2634 if (within_current_scope
)
2636 /* We use value_{,free_to_}mark because it could be a
2637 *long* time before we return to the command level and
2638 call free_all_values. We can't call free_all_values because
2639 we might be in the middle of evaluating a function call. */
2641 struct value
*mark
= value_mark ();
2642 struct value
*new_val
= evaluate_expression (bs
->breakpoint_at
->exp
);
2643 if (!value_equal (b
->val
, new_val
))
2645 release_value (new_val
);
2646 value_free_to_mark (mark
);
2647 bs
->old_val
= b
->val
;
2649 /* We will stop here */
2650 return WP_VALUE_CHANGED
;
2654 /* Nothing changed, don't do anything. */
2655 value_free_to_mark (mark
);
2656 /* We won't stop here */
2657 return WP_VALUE_NOT_CHANGED
;
2662 /* This seems like the only logical thing to do because
2663 if we temporarily ignored the watchpoint, then when
2664 we reenter the block in which it is valid it contains
2665 garbage (in the case of a function, it may have two
2666 garbage values, one before and one after the prologue).
2667 So we can't even detect the first assignment to it and
2668 watch after that (since the garbage may or may not equal
2669 the first value assigned). */
2670 /* We print all the stop information in print_it_typical(), but
2671 in this case, by the time we call print_it_typical() this bp
2672 will be deleted already. So we have no choice but print the
2673 information here. */
2674 if (ui_out_is_mi_like_p (uiout
))
2676 (uiout
, "reason", async_reason_lookup (EXEC_ASYNC_WATCHPOINT_SCOPE
));
2677 ui_out_text (uiout
, "\nWatchpoint ");
2678 ui_out_field_int (uiout
, "wpnum", bs
->breakpoint_at
->number
);
2679 ui_out_text (uiout
, " deleted because the program has left the block in\n\
2680 which its expression is valid.\n");
2682 if (b
->related_breakpoint
)
2683 b
->related_breakpoint
->disposition
= disp_del_at_next_stop
;
2684 b
->disposition
= disp_del_at_next_stop
;
2690 /* Get a bpstat associated with having just stopped at address
2691 BP_ADDR in thread PTID. STOPPED_BY_WATCHPOINT is 1 if the
2692 target thinks we stopped due to a hardware watchpoint, 0 if we
2693 know we did not trigger a hardware watchpoint, and -1 if we do not know. */
2695 /* Determine whether we stopped at a breakpoint, etc, or whether we
2696 don't understand this stop. Result is a chain of bpstat's such that:
2698 if we don't understand the stop, the result is a null pointer.
2700 if we understand why we stopped, the result is not null.
2702 Each element of the chain refers to a particular breakpoint or
2703 watchpoint at which we have stopped. (We may have stopped for
2704 several reasons concurrently.)
2706 Each element of the chain has valid next, breakpoint_at,
2707 commands, FIXME??? fields. */
2710 bpstat_stop_status (CORE_ADDR bp_addr
, ptid_t ptid
, int stopped_by_watchpoint
)
2712 struct breakpoint
*b
, *temp
;
2713 /* True if we've hit a breakpoint (as opposed to a watchpoint). */
2714 int real_breakpoint
= 0;
2715 /* Root of the chain of bpstat's */
2716 struct bpstats root_bs
[1];
2717 /* Pointer to the last thing in the chain currently. */
2718 bpstat bs
= root_bs
;
2719 int thread_id
= pid_to_thread_id (ptid
);
2721 ALL_BREAKPOINTS_SAFE (b
, temp
)
2723 if (!breakpoint_enabled (b
) && b
->enable_state
!= bp_permanent
)
2726 if (b
->type
!= bp_watchpoint
2727 && b
->type
!= bp_hardware_watchpoint
2728 && b
->type
!= bp_read_watchpoint
2729 && b
->type
!= bp_access_watchpoint
2730 && b
->type
!= bp_hardware_breakpoint
2731 && b
->type
!= bp_catch_fork
2732 && b
->type
!= bp_catch_vfork
2733 && b
->type
!= bp_catch_exec
2734 && b
->type
!= bp_catch_catch
2735 && b
->type
!= bp_catch_throw
) /* a non-watchpoint bp */
2737 if (b
->loc
->address
!= bp_addr
) /* address doesn't match */
2739 if (overlay_debugging
/* unmapped overlay section */
2740 && section_is_overlay (b
->loc
->section
)
2741 && !section_is_mapped (b
->loc
->section
))
2745 /* Continuable hardware watchpoints are treated as non-existent if the
2746 reason we stopped wasn't a hardware watchpoint (we didn't stop on
2747 some data address). Otherwise gdb won't stop on a break instruction
2748 in the code (not from a breakpoint) when a hardware watchpoint has
2751 if ((b
->type
== bp_hardware_watchpoint
2752 || b
->type
== bp_read_watchpoint
2753 || b
->type
== bp_access_watchpoint
)
2754 && !stopped_by_watchpoint
)
2757 if (b
->type
== bp_hardware_breakpoint
)
2759 if (b
->loc
->address
!= bp_addr
)
2761 if (overlay_debugging
/* unmapped overlay section */
2762 && section_is_overlay (b
->loc
->section
)
2763 && !section_is_mapped (b
->loc
->section
))
2767 /* Is this a catchpoint of a load or unload? If so, did we
2768 get a load or unload of the specified library? If not,
2770 if ((b
->type
== bp_catch_load
)
2771 #if defined(SOLIB_HAVE_LOAD_EVENT)
2772 && (!SOLIB_HAVE_LOAD_EVENT (PIDGET (inferior_ptid
))
2773 || ((b
->dll_pathname
!= NULL
)
2774 && (strcmp (b
->dll_pathname
,
2775 SOLIB_LOADED_LIBRARY_PATHNAME (
2776 PIDGET (inferior_ptid
)))
2782 if ((b
->type
== bp_catch_unload
)
2783 #if defined(SOLIB_HAVE_UNLOAD_EVENT)
2784 && (!SOLIB_HAVE_UNLOAD_EVENT (PIDGET (inferior_ptid
))
2785 || ((b
->dll_pathname
!= NULL
)
2786 && (strcmp (b
->dll_pathname
,
2787 SOLIB_UNLOADED_LIBRARY_PATHNAME (
2788 PIDGET (inferior_ptid
)))
2794 if ((b
->type
== bp_catch_fork
)
2795 && !inferior_has_forked (PIDGET (inferior_ptid
),
2796 &b
->forked_inferior_pid
))
2799 if ((b
->type
== bp_catch_vfork
)
2800 && !inferior_has_vforked (PIDGET (inferior_ptid
),
2801 &b
->forked_inferior_pid
))
2804 if ((b
->type
== bp_catch_exec
)
2805 && !inferior_has_execd (PIDGET (inferior_ptid
), &b
->exec_pathname
))
2808 if (ep_is_exception_catchpoint (b
) &&
2809 !(current_exception_event
= target_get_current_exception_event ()))
2812 /* Come here if it's a watchpoint, or if the break address matches */
2814 bs
= bpstat_alloc (b
, bs
); /* Alloc a bpstat to explain stop */
2816 /* Watchpoints may change this, if not found to have triggered. */
2820 if (b
->type
== bp_watchpoint
||
2821 b
->type
== bp_hardware_watchpoint
)
2823 char *message
= xstrprintf ("Error evaluating expression for watchpoint %d\n",
2825 struct cleanup
*cleanups
= make_cleanup (xfree
, message
);
2826 int e
= catch_errors (watchpoint_check
, bs
, message
,
2828 do_cleanups (cleanups
);
2832 /* We've already printed what needs to be printed. */
2833 /* Actually this is superfluous, because by the time we
2834 call print_it_typical() the wp will be already deleted,
2835 and the function will return immediately. */
2836 bs
->print_it
= print_it_done
;
2839 case WP_VALUE_CHANGED
:
2843 case WP_VALUE_NOT_CHANGED
:
2845 bs
->print_it
= print_it_noop
;
2852 /* Error from catch_errors. */
2853 printf_filtered (_("Watchpoint %d deleted.\n"), b
->number
);
2854 if (b
->related_breakpoint
)
2855 b
->related_breakpoint
->disposition
= disp_del_at_next_stop
;
2856 b
->disposition
= disp_del_at_next_stop
;
2857 /* We've already printed what needs to be printed. */
2858 bs
->print_it
= print_it_done
;
2864 else if (b
->type
== bp_read_watchpoint
||
2865 b
->type
== bp_access_watchpoint
)
2871 if (!target_stopped_data_address (¤t_target
, &addr
))
2873 for (v
= b
->val_chain
; v
; v
= value_next (v
))
2875 if (VALUE_LVAL (v
) == lval_memory
2876 && ! value_lazy (v
))
2878 struct type
*vtype
= check_typedef (value_type (v
));
2880 if (v
== b
->val_chain
2881 || (TYPE_CODE (vtype
) != TYPE_CODE_STRUCT
2882 && TYPE_CODE (vtype
) != TYPE_CODE_ARRAY
))
2886 vaddr
= VALUE_ADDRESS (v
) + value_offset (v
);
2887 /* Exact match not required. Within range is
2889 if (addr
>= vaddr
&&
2890 addr
< vaddr
+ TYPE_LENGTH (value_type (v
)))
2897 char *message
= xstrprintf ("Error evaluating expression for watchpoint %d\n",
2899 struct cleanup
*cleanups
= make_cleanup (xfree
, message
);
2900 int e
= catch_errors (watchpoint_check
, bs
, message
,
2902 do_cleanups (cleanups
);
2906 /* We've already printed what needs to be printed. */
2907 bs
->print_it
= print_it_done
;
2910 case WP_VALUE_CHANGED
:
2911 if (b
->type
== bp_read_watchpoint
)
2913 /* Don't stop: read watchpoints shouldn't fire if
2914 the value has changed. This is for targets
2915 which cannot set read-only watchpoints. */
2916 bs
->print_it
= print_it_noop
;
2922 case WP_VALUE_NOT_CHANGED
:
2929 /* Error from catch_errors. */
2930 printf_filtered (_("Watchpoint %d deleted.\n"), b
->number
);
2931 if (b
->related_breakpoint
)
2932 b
->related_breakpoint
->disposition
= disp_del_at_next_stop
;
2933 b
->disposition
= disp_del_at_next_stop
;
2934 /* We've already printed what needs to be printed. */
2935 bs
->print_it
= print_it_done
;
2939 else /* found == 0 */
2941 /* This is a case where some watchpoint(s) triggered,
2942 but not at the address of this watchpoint (FOUND
2943 was left zero). So don't print anything for this
2945 bs
->print_it
= print_it_noop
;
2952 /* By definition, an encountered breakpoint is a triggered
2956 real_breakpoint
= 1;
2959 if (frame_id_p (b
->frame_id
)
2960 && !frame_id_eq (b
->frame_id
, get_frame_id (get_current_frame ())))
2964 int value_is_zero
= 0;
2968 /* Need to select the frame, with all that implies
2969 so that the conditions will have the right context. */
2970 select_frame (get_current_frame ());
2972 = catch_errors (breakpoint_cond_eval
, (b
->cond
),
2973 "Error in testing breakpoint condition:\n",
2975 /* FIXME-someday, should give breakpoint # */
2978 if (b
->cond
&& value_is_zero
)
2981 /* Don't consider this a hit. */
2984 else if (b
->thread
!= -1 && b
->thread
!= thread_id
)
2987 /* Don't consider this a hit. */
2990 else if (b
->ignore_count
> 0)
2993 annotate_ignore_count_change ();
2998 /* We will stop here */
2999 if (b
->disposition
== disp_disable
)
3000 b
->enable_state
= bp_disabled
;
3003 bs
->commands
= b
->commands
;
3005 (strcmp ("silent", bs
->commands
->line
) == 0
3006 || (xdb_commands
&& strcmp ("Q", bs
->commands
->line
) == 0)))
3008 bs
->commands
= bs
->commands
->next
;
3011 bs
->commands
= copy_command_lines (bs
->commands
);
3014 /* Print nothing for this entry if we dont stop or if we dont print. */
3015 if (bs
->stop
== 0 || bs
->print
== 0)
3016 bs
->print_it
= print_it_noop
;
3019 bs
->next
= NULL
; /* Terminate the chain */
3020 bs
= root_bs
->next
; /* Re-grab the head of the chain */
3022 /* The value of a hardware watchpoint hasn't changed, but the
3023 intermediate memory locations we are watching may have. */
3024 if (bs
&& !bs
->stop
&&
3025 (bs
->breakpoint_at
->type
== bp_hardware_watchpoint
||
3026 bs
->breakpoint_at
->type
== bp_read_watchpoint
||
3027 bs
->breakpoint_at
->type
== bp_access_watchpoint
))
3029 remove_breakpoints ();
3030 insert_breakpoints ();
3035 /* Tell what to do about this bpstat. */
3037 bpstat_what (bpstat bs
)
3039 /* Classify each bpstat as one of the following. */
3042 /* This bpstat element has no effect on the main_action. */
3045 /* There was a watchpoint, stop but don't print. */
3048 /* There was a watchpoint, stop and print. */
3051 /* There was a breakpoint but we're not stopping. */
3054 /* There was a breakpoint, stop but don't print. */
3057 /* There was a breakpoint, stop and print. */
3060 /* We hit the longjmp breakpoint. */
3063 /* We hit the longjmp_resume breakpoint. */
3066 /* We hit the step_resume breakpoint. */
3069 /* We hit the through_sigtramp breakpoint. */
3072 /* We hit the shared library event breakpoint. */
3075 /* We caught a shared library event. */
3078 /* This is just used to count how many enums there are. */
3082 /* Here is the table which drives this routine. So that we can
3083 format it pretty, we define some abbreviations for the
3084 enum bpstat_what codes. */
3085 #define kc BPSTAT_WHAT_KEEP_CHECKING
3086 #define ss BPSTAT_WHAT_STOP_SILENT
3087 #define sn BPSTAT_WHAT_STOP_NOISY
3088 #define sgl BPSTAT_WHAT_SINGLE
3089 #define slr BPSTAT_WHAT_SET_LONGJMP_RESUME
3090 #define clr BPSTAT_WHAT_CLEAR_LONGJMP_RESUME
3091 #define clrs BPSTAT_WHAT_CLEAR_LONGJMP_RESUME_SINGLE
3092 #define sr BPSTAT_WHAT_STEP_RESUME
3093 #define ts BPSTAT_WHAT_THROUGH_SIGTRAMP
3094 #define shl BPSTAT_WHAT_CHECK_SHLIBS
3095 #define shlr BPSTAT_WHAT_CHECK_SHLIBS_RESUME_FROM_HOOK
3097 /* "Can't happen." Might want to print an error message.
3098 abort() is not out of the question, but chances are GDB is just
3099 a bit confused, not unusable. */
3100 #define err BPSTAT_WHAT_STOP_NOISY
3102 /* Given an old action and a class, come up with a new action. */
3103 /* One interesting property of this table is that wp_silent is the same
3104 as bp_silent and wp_noisy is the same as bp_noisy. That is because
3105 after stopping, the check for whether to step over a breakpoint
3106 (BPSTAT_WHAT_SINGLE type stuff) is handled in proceed() without
3107 reference to how we stopped. We retain separate wp_silent and
3108 bp_silent codes in case we want to change that someday.
3110 Another possibly interesting property of this table is that
3111 there's a partial ordering, priority-like, of the actions. Once
3112 you've decided that some action is appropriate, you'll never go
3113 back and decide something of a lower priority is better. The
3116 kc < clr sgl shl shlr slr sn sr ss ts
3117 sgl < clrs shl shlr slr sn sr ss ts
3118 slr < err shl shlr sn sr ss ts
3119 clr < clrs err shl shlr sn sr ss ts
3120 clrs < err shl shlr sn sr ss ts
3121 ss < shl shlr sn sr ts
3128 What I think this means is that we don't need a damned table
3129 here. If you just put the rows and columns in the right order,
3130 it'd look awfully regular. We could simply walk the bpstat list
3131 and choose the highest priority action we find, with a little
3132 logic to handle the 'err' cases, and the CLEAR_LONGJMP_RESUME/
3133 CLEAR_LONGJMP_RESUME_SINGLE distinction (which breakpoint.h says
3134 is messy anyway). */
3136 /* step_resume entries: a step resume breakpoint overrides another
3137 breakpoint of signal handling (see comment in wait_for_inferior
3138 at where we set the step_resume breakpoint). */
3140 static const enum bpstat_what_main_action
3141 table
[(int) class_last
][(int) BPSTAT_WHAT_LAST
] =
3144 /* kc ss sn sgl slr clr clrs sr ts shl shlr
3147 {kc
, ss
, sn
, sgl
, slr
, clr
, clrs
, sr
, ts
, shl
, shlr
},
3149 {ss
, ss
, sn
, ss
, ss
, ss
, ss
, sr
, ts
, shl
, shlr
},
3151 {sn
, sn
, sn
, sn
, sn
, sn
, sn
, sr
, ts
, shl
, shlr
},
3153 {sgl
, ss
, sn
, sgl
, slr
, clrs
, clrs
, sr
, ts
, shl
, shlr
},
3155 {ss
, ss
, sn
, ss
, ss
, ss
, ss
, sr
, ts
, shl
, shlr
},
3157 {sn
, sn
, sn
, sn
, sn
, sn
, sn
, sr
, ts
, shl
, shlr
},
3159 {slr
, ss
, sn
, slr
, slr
, err
, err
, sr
, ts
, shl
, shlr
},
3161 {clr
, ss
, sn
, clrs
, err
, err
, err
, sr
, ts
, shl
, shlr
},
3163 {sr
, sr
, sr
, sr
, sr
, sr
, sr
, sr
, ts
, shl
, shlr
},
3165 {ts
, ts
, ts
, ts
, ts
, ts
, ts
, ts
, ts
, shl
, shlr
},
3167 {shl
, shl
, shl
, shl
, shl
, shl
, shl
, shl
, ts
, shl
, shlr
},
3169 {shlr
, shlr
, shlr
, shlr
, shlr
, shlr
, shlr
, shlr
, ts
, shlr
, shlr
}
3184 enum bpstat_what_main_action current_action
= BPSTAT_WHAT_KEEP_CHECKING
;
3185 struct bpstat_what retval
;
3187 retval
.call_dummy
= 0;
3188 for (; bs
!= NULL
; bs
= bs
->next
)
3190 enum class bs_class
= no_effect
;
3191 if (bs
->breakpoint_at
== NULL
)
3192 /* I suspect this can happen if it was a momentary breakpoint
3193 which has since been deleted. */
3195 switch (bs
->breakpoint_at
->type
)
3201 case bp_hardware_breakpoint
:
3207 bs_class
= bp_noisy
;
3209 bs_class
= bp_silent
;
3212 bs_class
= bp_nostop
;
3215 case bp_hardware_watchpoint
:
3216 case bp_read_watchpoint
:
3217 case bp_access_watchpoint
:
3221 bs_class
= wp_noisy
;
3223 bs_class
= wp_silent
;
3226 /* There was a watchpoint, but we're not stopping.
3227 This requires no further action. */
3228 bs_class
= no_effect
;
3231 bs_class
= long_jump
;
3233 case bp_longjmp_resume
:
3234 bs_class
= long_resume
;
3236 case bp_step_resume
:
3239 bs_class
= step_resume
;
3242 /* It is for the wrong frame. */
3243 bs_class
= bp_nostop
;
3245 case bp_through_sigtramp
:
3246 bs_class
= through_sig
;
3248 case bp_watchpoint_scope
:
3249 bs_class
= bp_nostop
;
3251 case bp_shlib_event
:
3252 bs_class
= shlib_event
;
3254 case bp_thread_event
:
3255 case bp_overlay_event
:
3256 bs_class
= bp_nostop
;
3259 case bp_catch_unload
:
3260 /* Only if this catchpoint triggered should we cause the
3261 step-out-of-dld behaviour. Otherwise, we ignore this
3264 bs_class
= catch_shlib_event
;
3266 bs_class
= no_effect
;
3269 case bp_catch_vfork
:
3274 bs_class
= bp_noisy
;
3276 bs_class
= bp_silent
;
3279 /* There was a catchpoint, but we're not stopping.
3280 This requires no further action. */
3281 bs_class
= no_effect
;
3283 case bp_catch_catch
:
3284 if (!bs
->stop
|| CURRENT_EXCEPTION_KIND
!= EX_EVENT_CATCH
)
3285 bs_class
= bp_nostop
;
3287 bs_class
= bs
->print
? bp_noisy
: bp_silent
;
3289 case bp_catch_throw
:
3290 if (!bs
->stop
|| CURRENT_EXCEPTION_KIND
!= EX_EVENT_THROW
)
3291 bs_class
= bp_nostop
;
3293 bs_class
= bs
->print
? bp_noisy
: bp_silent
;
3296 /* Make sure the action is stop (silent or noisy),
3297 so infrun.c pops the dummy frame. */
3298 bs_class
= bp_silent
;
3299 retval
.call_dummy
= 1;
3302 current_action
= table
[(int) bs_class
][(int) current_action
];
3304 retval
.main_action
= current_action
;
3308 /* Nonzero if we should step constantly (e.g. watchpoints on machines
3309 without hardware support). This isn't related to a specific bpstat,
3310 just to things like whether watchpoints are set. */
3313 bpstat_should_step (void)
3315 struct breakpoint
*b
;
3317 if (breakpoint_enabled (b
) && b
->type
== bp_watchpoint
)
3322 /* Nonzero if there are enabled hardware watchpoints. */
3324 bpstat_have_active_hw_watchpoints (void)
3326 struct bp_location
*bpt
;
3327 ALL_BP_LOCATIONS (bpt
)
3328 if (breakpoint_enabled (bpt
->owner
)
3330 && bpt
->loc_type
== bp_loc_hardware_watchpoint
)
3336 /* Given a bpstat that records zero or more triggered eventpoints, this
3337 function returns another bpstat which contains only the catchpoints
3338 on that first list, if any. */
3340 bpstat_get_triggered_catchpoints (bpstat ep_list
, bpstat
*cp_list
)
3342 struct bpstats root_bs
[1];
3343 bpstat bs
= root_bs
;
3344 struct breakpoint
*ep
;
3347 bpstat_clear (cp_list
);
3348 root_bs
->next
= NULL
;
3350 for (; ep_list
!= NULL
; ep_list
= ep_list
->next
)
3352 /* Is this eventpoint a catchpoint? If not, ignore it. */
3353 ep
= ep_list
->breakpoint_at
;
3356 if ((ep
->type
!= bp_catch_load
) &&
3357 (ep
->type
!= bp_catch_unload
) &&
3358 (ep
->type
!= bp_catch_catch
) &&
3359 (ep
->type
!= bp_catch_throw
))
3360 /* pai: (temp) ADD fork/vfork here!! */
3363 /* Yes; add it to the list. */
3364 bs
= bpstat_alloc (ep
, bs
);
3369 #if defined(SOLIB_ADD)
3370 /* Also, for each triggered catchpoint, tag it with the name of
3371 the library that caused this trigger. (We copy the name now,
3372 because it's only guaranteed to be available NOW, when the
3373 catchpoint triggers. Clients who may wish to know the name
3374 later must get it from the catchpoint itself.) */
3375 if (ep
->triggered_dll_pathname
!= NULL
)
3376 xfree (ep
->triggered_dll_pathname
);
3377 if (ep
->type
== bp_catch_load
)
3378 dll_pathname
= SOLIB_LOADED_LIBRARY_PATHNAME (
3379 PIDGET (inferior_ptid
));
3381 dll_pathname
= SOLIB_UNLOADED_LIBRARY_PATHNAME (
3382 PIDGET (inferior_ptid
));
3384 dll_pathname
= NULL
;
3388 ep
->triggered_dll_pathname
= (char *)
3389 xmalloc (strlen (dll_pathname
) + 1);
3390 strcpy (ep
->triggered_dll_pathname
, dll_pathname
);
3393 ep
->triggered_dll_pathname
= NULL
;
3399 /* Print B to gdb_stdout. */
3401 print_one_breakpoint (struct breakpoint
*b
,
3402 CORE_ADDR
*last_addr
)
3404 struct command_line
*l
;
3406 struct ep_type_description
3411 static struct ep_type_description bptypes
[] =
3413 {bp_none
, "?deleted?"},
3414 {bp_breakpoint
, "breakpoint"},
3415 {bp_hardware_breakpoint
, "hw breakpoint"},
3416 {bp_until
, "until"},
3417 {bp_finish
, "finish"},
3418 {bp_watchpoint
, "watchpoint"},
3419 {bp_hardware_watchpoint
, "hw watchpoint"},
3420 {bp_read_watchpoint
, "read watchpoint"},
3421 {bp_access_watchpoint
, "acc watchpoint"},
3422 {bp_longjmp
, "longjmp"},
3423 {bp_longjmp_resume
, "longjmp resume"},
3424 {bp_step_resume
, "step resume"},
3425 {bp_through_sigtramp
, "sigtramp"},
3426 {bp_watchpoint_scope
, "watchpoint scope"},
3427 {bp_call_dummy
, "call dummy"},
3428 {bp_shlib_event
, "shlib events"},
3429 {bp_thread_event
, "thread events"},
3430 {bp_overlay_event
, "overlay events"},
3431 {bp_catch_load
, "catch load"},
3432 {bp_catch_unload
, "catch unload"},
3433 {bp_catch_fork
, "catch fork"},
3434 {bp_catch_vfork
, "catch vfork"},
3435 {bp_catch_exec
, "catch exec"},
3436 {bp_catch_catch
, "catch catch"},
3437 {bp_catch_throw
, "catch throw"}
3440 static char *bpdisps
[] =
3441 {"del", "dstp", "dis", "keep"};
3442 static char bpenables
[] = "nynny";
3443 char wrap_indent
[80];
3444 struct ui_stream
*stb
= ui_out_stream_new (uiout
);
3445 struct cleanup
*old_chain
= make_cleanup_ui_out_stream_delete (stb
);
3446 struct cleanup
*bkpt_chain
;
3449 bkpt_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "bkpt");
3453 ui_out_field_int (uiout
, "number", b
->number
);
3457 if (((int) b
->type
> (sizeof (bptypes
) / sizeof (bptypes
[0])))
3458 || ((int) b
->type
!= bptypes
[(int) b
->type
].type
))
3459 internal_error (__FILE__
, __LINE__
,
3460 _("bptypes table does not describe type #%d."),
3462 ui_out_field_string (uiout
, "type", bptypes
[(int) b
->type
].description
);
3466 ui_out_field_string (uiout
, "disp", bpdisps
[(int) b
->disposition
]);
3470 ui_out_field_fmt (uiout
, "enabled", "%c", bpenables
[(int) b
->enable_state
]);
3471 ui_out_spaces (uiout
, 2);
3474 strcpy (wrap_indent
, " ");
3477 if (TARGET_ADDR_BIT
<= 32)
3478 strcat (wrap_indent
, " ");
3480 strcat (wrap_indent
, " ");
3483 if (b
->ops
!= NULL
&& b
->ops
->print_one
!= NULL
)
3484 b
->ops
->print_one (b
, last_addr
);
3489 internal_error (__FILE__
, __LINE__
,
3490 _("print_one_breakpoint: bp_none encountered\n"));
3494 case bp_hardware_watchpoint
:
3495 case bp_read_watchpoint
:
3496 case bp_access_watchpoint
:
3497 /* Field 4, the address, is omitted (which makes the columns
3498 not line up too nicely with the headers, but the effect
3499 is relatively readable). */
3501 ui_out_field_skip (uiout
, "addr");
3503 print_expression (b
->exp
, stb
->stream
);
3504 ui_out_field_stream (uiout
, "what", stb
);
3508 case bp_catch_unload
:
3509 /* Field 4, the address, is omitted (which makes the columns
3510 not line up too nicely with the headers, but the effect
3511 is relatively readable). */
3513 ui_out_field_skip (uiout
, "addr");
3515 if (b
->dll_pathname
== NULL
)
3517 ui_out_field_string (uiout
, "what", "<any library>");
3518 ui_out_spaces (uiout
, 1);
3522 ui_out_text (uiout
, "library \"");
3523 ui_out_field_string (uiout
, "what", b
->dll_pathname
);
3524 ui_out_text (uiout
, "\" ");
3529 case bp_catch_vfork
:
3530 /* Field 4, the address, is omitted (which makes the columns
3531 not line up too nicely with the headers, but the effect
3532 is relatively readable). */
3534 ui_out_field_skip (uiout
, "addr");
3536 if (b
->forked_inferior_pid
!= 0)
3538 ui_out_text (uiout
, "process ");
3539 ui_out_field_int (uiout
, "what", b
->forked_inferior_pid
);
3540 ui_out_spaces (uiout
, 1);
3545 /* Field 4, the address, is omitted (which makes the columns
3546 not line up too nicely with the headers, but the effect
3547 is relatively readable). */
3549 ui_out_field_skip (uiout
, "addr");
3551 if (b
->exec_pathname
!= NULL
)
3553 ui_out_text (uiout
, "program \"");
3554 ui_out_field_string (uiout
, "what", b
->exec_pathname
);
3555 ui_out_text (uiout
, "\" ");
3559 case bp_catch_catch
:
3560 /* Field 4, the address, is omitted (which makes the columns
3561 not line up too nicely with the headers, but the effect
3562 is relatively readable). */
3564 ui_out_field_skip (uiout
, "addr");
3566 ui_out_field_string (uiout
, "what", "exception catch");
3567 ui_out_spaces (uiout
, 1);
3570 case bp_catch_throw
:
3571 /* Field 4, the address, is omitted (which makes the columns
3572 not line up too nicely with the headers, but the effect
3573 is relatively readable). */
3575 ui_out_field_skip (uiout
, "addr");
3577 ui_out_field_string (uiout
, "what", "exception throw");
3578 ui_out_spaces (uiout
, 1);
3582 case bp_hardware_breakpoint
:
3586 case bp_longjmp_resume
:
3587 case bp_step_resume
:
3588 case bp_through_sigtramp
:
3589 case bp_watchpoint_scope
:
3591 case bp_shlib_event
:
3592 case bp_thread_event
:
3593 case bp_overlay_event
:
3598 ui_out_field_string (uiout
, "addr", "<PENDING>");
3600 ui_out_field_core_addr (uiout
, "addr", b
->loc
->address
);
3603 *last_addr
= b
->loc
->address
;
3606 sym
= find_pc_sect_function (b
->loc
->address
, b
->loc
->section
);
3609 ui_out_text (uiout
, "in ");
3610 ui_out_field_string (uiout
, "func",
3611 SYMBOL_PRINT_NAME (sym
));
3612 ui_out_wrap_hint (uiout
, wrap_indent
);
3613 ui_out_text (uiout
, " at ");
3615 ui_out_field_string (uiout
, "file", b
->source_file
);
3616 ui_out_text (uiout
, ":");
3618 if (ui_out_is_mi_like_p (uiout
))
3620 struct symtab_and_line sal
= find_pc_line (b
->loc
->address
, 0);
3621 char *fullname
= symtab_to_fullname (sal
.symtab
);
3624 ui_out_field_string (uiout
, "fullname", fullname
);
3627 ui_out_field_int (uiout
, "line", b
->line_number
);
3629 else if (b
->pending
)
3631 ui_out_field_string (uiout
, "pending", b
->addr_string
);
3635 print_address_symbolic (b
->loc
->address
, stb
->stream
, demangle
, "");
3636 ui_out_field_stream (uiout
, "at", stb
);
3641 if (b
->thread
!= -1)
3643 /* FIXME: This seems to be redundant and lost here; see the
3644 "stop only in" line a little further down. */
3645 ui_out_text (uiout
, " thread ");
3646 ui_out_field_int (uiout
, "thread", b
->thread
);
3649 ui_out_text (uiout
, "\n");
3651 if (frame_id_p (b
->frame_id
))
3654 ui_out_text (uiout
, "\tstop only in stack frame at ");
3655 /* FIXME: cagney/2002-12-01: Shouldn't be poeking around inside
3657 ui_out_field_core_addr (uiout
, "frame", b
->frame_id
.stack_addr
);
3658 ui_out_text (uiout
, "\n");
3661 if (b
->cond
&& !ada_exception_catchpoint_p (b
))
3663 /* We do not print the condition for Ada exception catchpoints
3664 because the condition is an internal implementation detail
3665 that we do not want to expose to the user. */
3667 ui_out_text (uiout
, "\tstop only if ");
3668 print_expression (b
->cond
, stb
->stream
);
3669 ui_out_field_stream (uiout
, "cond", stb
);
3670 ui_out_text (uiout
, "\n");
3673 if (b
->pending
&& b
->cond_string
)
3676 ui_out_text (uiout
, "\tstop only if ");
3677 ui_out_field_string (uiout
, "cond", b
->cond_string
);
3678 ui_out_text (uiout
, "\n");
3681 if (b
->thread
!= -1)
3683 /* FIXME should make an annotation for this */
3684 ui_out_text (uiout
, "\tstop only in thread ");
3685 ui_out_field_int (uiout
, "thread", b
->thread
);
3686 ui_out_text (uiout
, "\n");
3689 if (show_breakpoint_hit_counts
&& b
->hit_count
)
3691 /* FIXME should make an annotation for this */
3692 if (ep_is_catchpoint (b
))
3693 ui_out_text (uiout
, "\tcatchpoint");
3695 ui_out_text (uiout
, "\tbreakpoint");
3696 ui_out_text (uiout
, " already hit ");
3697 ui_out_field_int (uiout
, "times", b
->hit_count
);
3698 if (b
->hit_count
== 1)
3699 ui_out_text (uiout
, " time\n");
3701 ui_out_text (uiout
, " times\n");
3704 /* Output the count also if it is zero, but only if this is
3705 mi. FIXME: Should have a better test for this. */
3706 if (ui_out_is_mi_like_p (uiout
))
3707 if (show_breakpoint_hit_counts
&& b
->hit_count
== 0)
3708 ui_out_field_int (uiout
, "times", b
->hit_count
);
3710 if (b
->ignore_count
)
3713 ui_out_text (uiout
, "\tignore next ");
3714 ui_out_field_int (uiout
, "ignore", b
->ignore_count
);
3715 ui_out_text (uiout
, " hits\n");
3718 if ((l
= b
->commands
))
3720 struct cleanup
*script_chain
;
3723 script_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "script");
3724 print_command_lines (uiout
, l
, 4);
3725 do_cleanups (script_chain
);
3727 do_cleanups (bkpt_chain
);
3728 do_cleanups (old_chain
);
3731 struct captured_breakpoint_query_args
3737 do_captured_breakpoint_query (struct ui_out
*uiout
, void *data
)
3739 struct captured_breakpoint_query_args
*args
= data
;
3740 struct breakpoint
*b
;
3741 CORE_ADDR dummy_addr
= 0;
3744 if (args
->bnum
== b
->number
)
3746 print_one_breakpoint (b
, &dummy_addr
);
3754 gdb_breakpoint_query (struct ui_out
*uiout
, int bnum
, char **error_message
)
3756 struct captured_breakpoint_query_args args
;
3758 /* For the moment we don't trust print_one_breakpoint() to not throw
3760 if (catch_exceptions_with_msg (uiout
, do_captured_breakpoint_query
, &args
,
3761 error_message
, RETURN_MASK_ALL
) < 0)
3767 /* Return non-zero if B is user settable (breakpoints, watchpoints,
3768 catchpoints, et.al.). */
3771 user_settable_breakpoint (const struct breakpoint
*b
)
3773 return (b
->type
== bp_breakpoint
3774 || b
->type
== bp_catch_load
3775 || b
->type
== bp_catch_unload
3776 || b
->type
== bp_catch_fork
3777 || b
->type
== bp_catch_vfork
3778 || b
->type
== bp_catch_exec
3779 || b
->type
== bp_catch_catch
3780 || b
->type
== bp_catch_throw
3781 || b
->type
== bp_hardware_breakpoint
3782 || b
->type
== bp_watchpoint
3783 || b
->type
== bp_read_watchpoint
3784 || b
->type
== bp_access_watchpoint
3785 || b
->type
== bp_hardware_watchpoint
);
3788 /* Print information on user settable breakpoint (watchpoint, etc)
3789 number BNUM. If BNUM is -1 print all user settable breakpoints.
3790 If ALLFLAG is non-zero, include non- user settable breakpoints. */
3793 breakpoint_1 (int bnum
, int allflag
)
3795 struct breakpoint
*b
;
3796 CORE_ADDR last_addr
= (CORE_ADDR
) -1;
3797 int nr_printable_breakpoints
;
3798 struct cleanup
*bkpttbl_chain
;
3800 /* Compute the number of rows in the table. */
3801 nr_printable_breakpoints
= 0;
3804 || bnum
== b
->number
)
3806 if (allflag
|| user_settable_breakpoint (b
))
3807 nr_printable_breakpoints
++;
3812 = make_cleanup_ui_out_table_begin_end (uiout
, 6, nr_printable_breakpoints
,
3816 = make_cleanup_ui_out_table_begin_end (uiout
, 5, nr_printable_breakpoints
,
3819 if (nr_printable_breakpoints
> 0)
3820 annotate_breakpoints_headers ();
3821 if (nr_printable_breakpoints
> 0)
3823 ui_out_table_header (uiout
, 3, ui_left
, "number", "Num"); /* 1 */
3824 if (nr_printable_breakpoints
> 0)
3826 ui_out_table_header (uiout
, 14, ui_left
, "type", "Type"); /* 2 */
3827 if (nr_printable_breakpoints
> 0)
3829 ui_out_table_header (uiout
, 4, ui_left
, "disp", "Disp"); /* 3 */
3830 if (nr_printable_breakpoints
> 0)
3832 ui_out_table_header (uiout
, 3, ui_left
, "enabled", "Enb"); /* 4 */
3835 if (nr_printable_breakpoints
> 0)
3837 if (TARGET_ADDR_BIT
<= 32)
3838 ui_out_table_header (uiout
, 10, ui_left
, "addr", "Address");/* 5 */
3840 ui_out_table_header (uiout
, 18, ui_left
, "addr", "Address");/* 5 */
3842 if (nr_printable_breakpoints
> 0)
3844 ui_out_table_header (uiout
, 40, ui_noalign
, "what", "What"); /* 6 */
3845 ui_out_table_body (uiout
);
3846 if (nr_printable_breakpoints
> 0)
3847 annotate_breakpoints_table ();
3851 || bnum
== b
->number
)
3853 /* We only print out user settable breakpoints unless the
3855 if (allflag
|| user_settable_breakpoint (b
))
3856 print_one_breakpoint (b
, &last_addr
);
3859 do_cleanups (bkpttbl_chain
);
3861 if (nr_printable_breakpoints
== 0)
3864 ui_out_message (uiout
, 0, "No breakpoints or watchpoints.\n");
3866 ui_out_message (uiout
, 0, "No breakpoint or watchpoint number %d.\n",
3871 /* Compare against (CORE_ADDR)-1 in case some compiler decides
3872 that a comparison of an unsigned with -1 is always false. */
3873 if (last_addr
!= (CORE_ADDR
) -1)
3874 set_next_address (last_addr
);
3877 /* FIXME? Should this be moved up so that it is only called when
3878 there have been breakpoints? */
3879 annotate_breakpoints_table_end ();
3883 breakpoints_info (char *bnum_exp
, int from_tty
)
3888 bnum
= parse_and_eval_long (bnum_exp
);
3890 breakpoint_1 (bnum
, 0);
3894 maintenance_info_breakpoints (char *bnum_exp
, int from_tty
)
3899 bnum
= parse_and_eval_long (bnum_exp
);
3901 breakpoint_1 (bnum
, 1);
3904 /* Print a message describing any breakpoints set at PC. */
3907 describe_other_breakpoints (CORE_ADDR pc
, asection
*section
, int thread
)
3910 struct breakpoint
*b
;
3913 if (b
->loc
->address
== pc
) /* address match / overlay match */
3914 if (!b
->pending
&& (!overlay_debugging
|| b
->loc
->section
== section
))
3919 printf_filtered (_("Note: breakpoint "));
3920 else /* if (others == ???) */
3921 printf_filtered (_("Note: breakpoints "));
3923 if (b
->loc
->address
== pc
) /* address match / overlay match */
3924 if (!b
->pending
&& (!overlay_debugging
|| b
->loc
->section
== section
))
3927 printf_filtered ("%d", b
->number
);
3928 if (b
->thread
== -1 && thread
!= -1)
3929 printf_filtered (" (all threads)");
3930 else if (b
->thread
!= -1)
3931 printf_filtered (" (thread %d)", b
->thread
);
3932 printf_filtered ("%s%s ",
3933 ((b
->enable_state
== bp_disabled
||
3934 b
->enable_state
== bp_shlib_disabled
||
3935 b
->enable_state
== bp_call_disabled
)
3937 : b
->enable_state
== bp_permanent
3941 : ((others
== 1) ? " and" : ""));
3943 printf_filtered (_("also set at pc "));
3944 deprecated_print_address_numeric (pc
, 1, gdb_stdout
);
3945 printf_filtered (".\n");
3949 /* Set the default place to put a breakpoint
3950 for the `break' command with no arguments. */
3953 set_default_breakpoint (int valid
, CORE_ADDR addr
, struct symtab
*symtab
,
3956 default_breakpoint_valid
= valid
;
3957 default_breakpoint_address
= addr
;
3958 default_breakpoint_symtab
= symtab
;
3959 default_breakpoint_line
= line
;
3962 /* Return true iff it is meaningful to use the address member of
3963 BPT. For some breakpoint types, the address member is irrelevant
3964 and it makes no sense to attempt to compare it to other addresses
3965 (or use it for any other purpose either).
3967 More specifically, each of the following breakpoint types will always
3968 have a zero valued address and we don't want check_duplicates() to mark
3969 breakpoints of any of these types to be a duplicate of an actual
3970 breakpoint at address zero:
3973 bp_hardware_watchpoint
3975 bp_access_watchpoint
3982 breakpoint_address_is_meaningful (struct breakpoint
*bpt
)
3984 enum bptype type
= bpt
->type
;
3986 return (type
!= bp_watchpoint
3987 && type
!= bp_hardware_watchpoint
3988 && type
!= bp_read_watchpoint
3989 && type
!= bp_access_watchpoint
3990 && type
!= bp_catch_exec
3991 && type
!= bp_longjmp_resume
3992 && type
!= bp_catch_fork
3993 && type
!= bp_catch_vfork
);
3996 /* Rescan breakpoints at the same address and section as BPT,
3997 marking the first one as "first" and any others as "duplicates".
3998 This is so that the bpt instruction is only inserted once.
3999 If we have a permanent breakpoint at the same place as BPT, make
4000 that one the official one, and the rest as duplicates. */
4003 check_duplicates (struct breakpoint
*bpt
)
4005 struct bp_location
*b
;
4007 struct bp_location
*perm_bp
= 0;
4008 CORE_ADDR address
= bpt
->loc
->address
;
4009 asection
*section
= bpt
->loc
->section
;
4011 if (! breakpoint_address_is_meaningful (bpt
))
4014 ALL_BP_LOCATIONS (b
)
4015 if (b
->owner
->enable_state
!= bp_disabled
4016 && b
->owner
->enable_state
!= bp_shlib_disabled
4017 && !b
->owner
->pending
4018 && b
->owner
->enable_state
!= bp_call_disabled
4019 && b
->address
== address
/* address / overlay match */
4020 && (!overlay_debugging
|| b
->section
== section
)
4021 && breakpoint_address_is_meaningful (b
->owner
))
4023 /* Have we found a permanent breakpoint? */
4024 if (b
->owner
->enable_state
== bp_permanent
)
4031 b
->duplicate
= count
> 1;
4034 /* If we found a permanent breakpoint at this address, go over the
4035 list again and declare all the other breakpoints there to be the
4039 perm_bp
->duplicate
= 0;
4041 /* Permanent breakpoint should always be inserted. */
4042 if (! perm_bp
->inserted
)
4043 internal_error (__FILE__
, __LINE__
,
4044 _("allegedly permanent breakpoint is not "
4045 "actually inserted"));
4047 ALL_BP_LOCATIONS (b
)
4050 if (b
->owner
->enable_state
!= bp_disabled
4051 && b
->owner
->enable_state
!= bp_shlib_disabled
4052 && !b
->owner
->pending
4053 && b
->owner
->enable_state
!= bp_call_disabled
4054 && b
->address
== address
/* address / overlay match */
4055 && (!overlay_debugging
|| b
->section
== section
)
4056 && breakpoint_address_is_meaningful (b
->owner
))
4059 internal_error (__FILE__
, __LINE__
,
4060 _("another breakpoint was inserted on top of "
4061 "a permanent breakpoint"));
4070 breakpoint_adjustment_warning (CORE_ADDR from_addr
, CORE_ADDR to_addr
,
4071 int bnum
, int have_bnum
)
4076 strcpy (astr1
, hex_string_custom ((unsigned long) from_addr
, 8));
4077 strcpy (astr2
, hex_string_custom ((unsigned long) to_addr
, 8));
4079 warning (_("Breakpoint %d address previously adjusted from %s to %s."),
4080 bnum
, astr1
, astr2
);
4082 warning (_("Breakpoint address adjusted from %s to %s."), astr1
, astr2
);
4085 /* Adjust a breakpoint's address to account for architectural constraints
4086 on breakpoint placement. Return the adjusted address. Note: Very
4087 few targets require this kind of adjustment. For most targets,
4088 this function is simply the identity function. */
4091 adjust_breakpoint_address (CORE_ADDR bpaddr
, enum bptype bptype
)
4093 if (!gdbarch_adjust_breakpoint_address_p (current_gdbarch
))
4095 /* Very few targets need any kind of breakpoint adjustment. */
4098 else if (bptype
== bp_watchpoint
4099 || bptype
== bp_hardware_watchpoint
4100 || bptype
== bp_read_watchpoint
4101 || bptype
== bp_access_watchpoint
4102 || bptype
== bp_catch_fork
4103 || bptype
== bp_catch_vfork
4104 || bptype
== bp_catch_exec
)
4106 /* Watchpoints and the various bp_catch_* eventpoints should not
4107 have their addresses modified. */
4112 CORE_ADDR adjusted_bpaddr
;
4114 /* Some targets have architectural constraints on the placement
4115 of breakpoint instructions. Obtain the adjusted address. */
4116 adjusted_bpaddr
= gdbarch_adjust_breakpoint_address (current_gdbarch
,
4119 /* An adjusted breakpoint address can significantly alter
4120 a user's expectations. Print a warning if an adjustment
4122 if (adjusted_bpaddr
!= bpaddr
)
4123 breakpoint_adjustment_warning (bpaddr
, adjusted_bpaddr
, 0, 0);
4125 return adjusted_bpaddr
;
4129 /* Allocate a struct bp_location. */
4131 static struct bp_location
*
4132 allocate_bp_location (struct breakpoint
*bpt
, enum bptype bp_type
)
4134 struct bp_location
*loc
, *loc_p
;
4136 loc
= xmalloc (sizeof (struct bp_location
));
4137 memset (loc
, 0, sizeof (*loc
));
4147 case bp_longjmp_resume
:
4148 case bp_step_resume
:
4149 case bp_through_sigtramp
:
4150 case bp_watchpoint_scope
:
4152 case bp_shlib_event
:
4153 case bp_thread_event
:
4154 case bp_overlay_event
:
4156 case bp_catch_unload
:
4157 loc
->loc_type
= bp_loc_software_breakpoint
;
4159 case bp_hardware_breakpoint
:
4160 loc
->loc_type
= bp_loc_hardware_breakpoint
;
4162 case bp_hardware_watchpoint
:
4163 case bp_read_watchpoint
:
4164 case bp_access_watchpoint
:
4165 loc
->loc_type
= bp_loc_hardware_watchpoint
;
4169 case bp_catch_vfork
:
4171 case bp_catch_catch
:
4172 case bp_catch_throw
:
4173 loc
->loc_type
= bp_loc_other
;
4176 internal_error (__FILE__
, __LINE__
, _("unknown breakpoint type"));
4179 /* Add this breakpoint to the end of the chain. */
4181 loc_p
= bp_location_chain
;
4183 bp_location_chain
= loc
;
4187 loc_p
= loc_p
->next
;
4194 /* set_raw_breakpoint() is a low level routine for allocating and
4195 partially initializing a breakpoint of type BPTYPE. The newly
4196 created breakpoint's address, section, source file name, and line
4197 number are provided by SAL. The newly created and partially
4198 initialized breakpoint is added to the breakpoint chain and
4199 is also returned as the value of this function.
4201 It is expected that the caller will complete the initialization of
4202 the newly created breakpoint struct as well as output any status
4203 information regarding the creation of a new breakpoint. In
4204 particular, set_raw_breakpoint() does NOT set the breakpoint
4205 number! Care should be taken to not allow an error() to occur
4206 prior to completing the initialization of the breakpoint. If this
4207 should happen, a bogus breakpoint will be left on the chain. */
4210 set_raw_breakpoint (struct symtab_and_line sal
, enum bptype bptype
)
4212 struct breakpoint
*b
, *b1
;
4214 b
= (struct breakpoint
*) xmalloc (sizeof (struct breakpoint
));
4215 memset (b
, 0, sizeof (*b
));
4216 b
->loc
= allocate_bp_location (b
, bptype
);
4217 b
->loc
->requested_address
= sal
.pc
;
4218 b
->loc
->address
= adjust_breakpoint_address (b
->loc
->requested_address
,
4220 if (sal
.symtab
== NULL
)
4221 b
->source_file
= NULL
;
4223 b
->source_file
= savestring (sal
.symtab
->filename
,
4224 strlen (sal
.symtab
->filename
));
4225 b
->loc
->section
= sal
.section
;
4227 b
->language
= current_language
->la_language
;
4228 b
->input_radix
= input_radix
;
4230 b
->line_number
= sal
.line
;
4231 b
->enable_state
= bp_enabled
;
4234 b
->ignore_count
= 0;
4236 b
->frame_id
= null_frame_id
;
4237 b
->dll_pathname
= NULL
;
4238 b
->triggered_dll_pathname
= NULL
;
4239 b
->forked_inferior_pid
= 0;
4240 b
->exec_pathname
= NULL
;
4244 /* Add this breakpoint to the end of the chain
4245 so that a list of breakpoints will come out in order
4246 of increasing numbers. */
4248 b1
= breakpoint_chain
;
4250 breakpoint_chain
= b
;
4258 check_duplicates (b
);
4259 breakpoints_changed ();
4265 /* Note that the breakpoint object B describes a permanent breakpoint
4266 instruction, hard-wired into the inferior's code. */
4268 make_breakpoint_permanent (struct breakpoint
*b
)
4270 b
->enable_state
= bp_permanent
;
4272 /* By definition, permanent breakpoints are already present in the code. */
4273 b
->loc
->inserted
= 1;
4276 static struct breakpoint
*
4277 create_internal_breakpoint (CORE_ADDR address
, enum bptype type
)
4279 static int internal_breakpoint_number
= -1;
4280 struct symtab_and_line sal
;
4281 struct breakpoint
*b
;
4283 init_sal (&sal
); /* initialize to zeroes */
4286 sal
.section
= find_pc_overlay (sal
.pc
);
4288 b
= set_raw_breakpoint (sal
, type
);
4289 b
->number
= internal_breakpoint_number
--;
4290 b
->disposition
= disp_donttouch
;
4297 create_longjmp_breakpoint (char *func_name
)
4299 struct breakpoint
*b
;
4300 struct minimal_symbol
*m
;
4302 if (func_name
== NULL
)
4303 b
= create_internal_breakpoint (0, bp_longjmp_resume
);
4306 if ((m
= lookup_minimal_symbol_text (func_name
, NULL
)) == NULL
)
4309 b
= create_internal_breakpoint (SYMBOL_VALUE_ADDRESS (m
), bp_longjmp
);
4312 b
->enable_state
= bp_disabled
;
4315 b
->addr_string
= xstrdup (func_name
);
4318 /* Call this routine when stepping and nexting to enable a breakpoint
4319 if we do a longjmp(). When we hit that breakpoint, call
4320 set_longjmp_resume_breakpoint() to figure out where we are going. */
4323 enable_longjmp_breakpoint (void)
4325 struct breakpoint
*b
;
4328 if (b
->type
== bp_longjmp
)
4330 b
->enable_state
= bp_enabled
;
4331 check_duplicates (b
);
4336 disable_longjmp_breakpoint (void)
4338 struct breakpoint
*b
;
4341 if (b
->type
== bp_longjmp
4342 || b
->type
== bp_longjmp_resume
)
4344 b
->enable_state
= bp_disabled
;
4345 check_duplicates (b
);
4350 create_overlay_event_breakpoint (char *func_name
)
4352 struct breakpoint
*b
;
4353 struct minimal_symbol
*m
;
4355 if ((m
= lookup_minimal_symbol_text (func_name
, NULL
)) == NULL
)
4358 b
= create_internal_breakpoint (SYMBOL_VALUE_ADDRESS (m
),
4360 b
->addr_string
= xstrdup (func_name
);
4362 if (overlay_debugging
== ovly_auto
)
4364 b
->enable_state
= bp_enabled
;
4365 overlay_events_enabled
= 1;
4369 b
->enable_state
= bp_disabled
;
4370 overlay_events_enabled
= 0;
4375 enable_overlay_breakpoints (void)
4377 struct breakpoint
*b
;
4380 if (b
->type
== bp_overlay_event
)
4382 b
->enable_state
= bp_enabled
;
4383 check_duplicates (b
);
4384 overlay_events_enabled
= 1;
4389 disable_overlay_breakpoints (void)
4391 struct breakpoint
*b
;
4394 if (b
->type
== bp_overlay_event
)
4396 b
->enable_state
= bp_disabled
;
4397 check_duplicates (b
);
4398 overlay_events_enabled
= 0;
4403 create_thread_event_breakpoint (CORE_ADDR address
)
4405 struct breakpoint
*b
;
4407 b
= create_internal_breakpoint (address
, bp_thread_event
);
4409 b
->enable_state
= bp_enabled
;
4410 /* addr_string has to be used or breakpoint_re_set will delete me. */
4411 b
->addr_string
= xstrprintf ("*0x%s", paddr (b
->loc
->address
));
4417 remove_thread_event_breakpoints (void)
4419 struct breakpoint
*b
, *temp
;
4421 ALL_BREAKPOINTS_SAFE (b
, temp
)
4422 if (b
->type
== bp_thread_event
)
4423 delete_breakpoint (b
);
4426 struct captured_parse_breakpoint_args
4429 struct symtabs_and_lines
*sals_p
;
4430 char ***addr_string_p
;
4434 struct lang_and_radix
4440 /* Cleanup helper routine to restore the current language and
4443 do_restore_lang_radix_cleanup (void *old
)
4445 struct lang_and_radix
*p
= old
;
4446 set_language (p
->lang
);
4447 input_radix
= p
->radix
;
4450 /* Try and resolve a pending breakpoint. */
4452 resolve_pending_breakpoint (struct breakpoint
*b
)
4454 /* Try and reparse the breakpoint in case the shared library
4456 struct symtabs_and_lines sals
;
4457 struct symtab_and_line pending_sal
;
4458 char **cond_string
= (char **) NULL
;
4459 char *copy_arg
= b
->addr_string
;
4464 struct ui_file
*old_gdb_stderr
;
4465 struct lang_and_radix old_lr
;
4466 struct cleanup
*old_chain
;
4468 /* Set language, input-radix, then reissue breakpoint command.
4469 Ensure the language and input-radix are restored afterwards. */
4470 old_lr
.lang
= current_language
->la_language
;
4471 old_lr
.radix
= input_radix
;
4472 old_chain
= make_cleanup (do_restore_lang_radix_cleanup
, &old_lr
);
4474 set_language (b
->language
);
4475 input_radix
= b
->input_radix
;
4476 rc
= break_command_1 (b
->addr_string
, b
->flag
, b
->from_tty
, b
);
4478 if (rc
== GDB_RC_OK
)
4479 /* Pending breakpoint has been resolved. */
4480 printf_filtered (_("Pending breakpoint \"%s\" resolved\n"), b
->addr_string
);
4482 do_cleanups (old_chain
);
4487 remove_solib_event_breakpoints (void)
4489 struct breakpoint
*b
, *temp
;
4491 ALL_BREAKPOINTS_SAFE (b
, temp
)
4492 if (b
->type
== bp_shlib_event
)
4493 delete_breakpoint (b
);
4497 create_solib_event_breakpoint (CORE_ADDR address
)
4499 struct breakpoint
*b
;
4501 b
= create_internal_breakpoint (address
, bp_shlib_event
);
4505 /* Disable any breakpoints that are on code in shared libraries. Only
4506 apply to enabled breakpoints, disabled ones can just stay disabled. */
4509 disable_breakpoints_in_shlibs (int silent
)
4511 struct breakpoint
*b
;
4512 int disabled_shlib_breaks
= 0;
4514 /* See also: insert_breakpoints, under DISABLE_UNSETTABLE_BREAK. */
4517 if (((b
->type
== bp_breakpoint
) || (b
->type
== bp_hardware_breakpoint
))
4518 && breakpoint_enabled (b
) && !b
->loc
->duplicate
4520 && PC_SOLIB (b
->loc
->address
)
4522 && solib_address (b
->loc
->address
)
4526 b
->enable_state
= bp_shlib_disabled
;
4529 if (!disabled_shlib_breaks
)
4531 target_terminal_ours_for_output ();
4532 warning (_("Temporarily disabling shared library breakpoints:"));
4534 disabled_shlib_breaks
= 1;
4535 warning (_("breakpoint #%d "), b
->number
);
4541 /* Disable any breakpoints that are in in an unloaded shared library. Only
4542 apply to enabled breakpoints, disabled ones can just stay disabled. */
4545 disable_breakpoints_in_unloaded_shlib (struct so_list
*solib
)
4547 struct breakpoint
*b
;
4548 int disabled_shlib_breaks
= 0;
4550 /* See also: insert_breakpoints, under DISABLE_UNSETTABLE_BREAK. */
4553 if ((b
->loc
->loc_type
== bp_loc_hardware_breakpoint
4554 || b
->loc
->loc_type
== bp_loc_software_breakpoint
)
4555 && breakpoint_enabled (b
) && !b
->loc
->duplicate
)
4558 char *so_name
= PC_SOLIB (b
->loc
->address
);
4560 char *so_name
= solib_address (b
->loc
->address
);
4562 if (so_name
&& !strcmp (so_name
, solib
->so_name
))
4564 b
->enable_state
= bp_shlib_disabled
;
4565 /* At this point, we cannot rely on remove_breakpoint
4566 succeeding so we must mark the breakpoint as not inserted
4567 to prevent future errors occurring in remove_breakpoints. */
4568 b
->loc
->inserted
= 0;
4569 if (!disabled_shlib_breaks
)
4571 target_terminal_ours_for_output ();
4572 warning (_("Temporarily disabling breakpoints for unloaded shared library \"%s\""),
4575 disabled_shlib_breaks
= 1;
4581 /* Try to reenable any breakpoints in shared libraries. */
4583 re_enable_breakpoints_in_shlibs (void)
4585 struct breakpoint
*b
, *tmp
;
4587 ALL_BREAKPOINTS_SAFE (b
, tmp
)
4589 if (b
->enable_state
== bp_shlib_disabled
)
4594 /* Do not reenable the breakpoint if the shared library is
4595 still not mapped in. */
4597 lib
= PC_SOLIB (b
->loc
->address
);
4599 lib
= solib_address (b
->loc
->address
);
4601 if (lib
!= NULL
&& target_read_memory (b
->loc
->address
, buf
, 1) == 0)
4602 b
->enable_state
= bp_enabled
;
4604 else if (b
->pending
&& (b
->enable_state
== bp_enabled
))
4606 if (resolve_pending_breakpoint (b
) == GDB_RC_OK
)
4607 delete_breakpoint (b
);
4613 solib_load_unload_1 (char *hookname
, int tempflag
, char *dll_pathname
,
4614 char *cond_string
, enum bptype bp_kind
)
4616 struct breakpoint
*b
;
4617 struct symtabs_and_lines sals
;
4618 struct cleanup
*old_chain
;
4619 struct cleanup
*canonical_strings_chain
= NULL
;
4620 char *addr_start
= hookname
;
4621 char *addr_end
= NULL
;
4622 char **canonical
= (char **) NULL
;
4623 int thread
= -1; /* All threads. */
4625 /* Set a breakpoint on the specified hook. */
4626 sals
= decode_line_1 (&hookname
, 1, (struct symtab
*) NULL
,
4627 0, &canonical
, NULL
);
4628 addr_end
= hookname
;
4630 if (sals
.nelts
== 0)
4632 warning (_("Unable to set a breakpoint on dynamic linker callback.\n"
4633 "Suggest linking with /opt/langtools/lib/end.o.\n"
4634 "GDB will be unable to track shl_load/shl_unload calls."));
4637 if (sals
.nelts
!= 1)
4639 warning (_("Unable to set unique breakpoint on dynamic linker callback.\n"
4640 "GDB will be unable to track shl_load/shl_unload calls."));
4644 /* Make sure that all storage allocated in decode_line_1 gets freed
4645 in case the following errors out. */
4646 old_chain
= make_cleanup (xfree
, sals
.sals
);
4647 if (canonical
!= (char **) NULL
)
4649 make_cleanup (xfree
, canonical
);
4650 canonical_strings_chain
= make_cleanup (null_cleanup
, 0);
4651 if (canonical
[0] != NULL
)
4652 make_cleanup (xfree
, canonical
[0]);
4655 resolve_sal_pc (&sals
.sals
[0]);
4657 /* Remove the canonical strings from the cleanup, they are needed below. */
4658 if (canonical
!= (char **) NULL
)
4659 discard_cleanups (canonical_strings_chain
);
4661 b
= set_raw_breakpoint (sals
.sals
[0], bp_kind
);
4662 set_breakpoint_count (breakpoint_count
+ 1);
4663 b
->number
= breakpoint_count
;
4665 b
->cond_string
= (cond_string
== NULL
) ?
4666 NULL
: savestring (cond_string
, strlen (cond_string
));
4669 if (canonical
!= (char **) NULL
&& canonical
[0] != NULL
)
4670 b
->addr_string
= canonical
[0];
4671 else if (addr_start
)
4672 b
->addr_string
= savestring (addr_start
, addr_end
- addr_start
);
4674 b
->enable_state
= bp_enabled
;
4675 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
4677 if (dll_pathname
== NULL
)
4678 b
->dll_pathname
= NULL
;
4681 b
->dll_pathname
= (char *) xmalloc (strlen (dll_pathname
) + 1);
4682 strcpy (b
->dll_pathname
, dll_pathname
);
4686 do_cleanups (old_chain
);
4690 create_solib_load_event_breakpoint (char *hookname
, int tempflag
,
4691 char *dll_pathname
, char *cond_string
)
4693 solib_load_unload_1 (hookname
, tempflag
, dll_pathname
,
4694 cond_string
, bp_catch_load
);
4698 create_solib_unload_event_breakpoint (char *hookname
, int tempflag
,
4699 char *dll_pathname
, char *cond_string
)
4701 solib_load_unload_1 (hookname
, tempflag
, dll_pathname
,
4702 cond_string
, bp_catch_unload
);
4706 create_fork_vfork_event_catchpoint (int tempflag
, char *cond_string
,
4707 enum bptype bp_kind
)
4709 struct symtab_and_line sal
;
4710 struct breakpoint
*b
;
4711 int thread
= -1; /* All threads. */
4718 b
= set_raw_breakpoint (sal
, bp_kind
);
4719 set_breakpoint_count (breakpoint_count
+ 1);
4720 b
->number
= breakpoint_count
;
4722 b
->cond_string
= (cond_string
== NULL
) ?
4723 NULL
: savestring (cond_string
, strlen (cond_string
));
4725 b
->addr_string
= NULL
;
4726 b
->enable_state
= bp_enabled
;
4727 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
4728 b
->forked_inferior_pid
= 0;
4734 create_fork_event_catchpoint (int tempflag
, char *cond_string
)
4736 create_fork_vfork_event_catchpoint (tempflag
, cond_string
, bp_catch_fork
);
4740 create_vfork_event_catchpoint (int tempflag
, char *cond_string
)
4742 create_fork_vfork_event_catchpoint (tempflag
, cond_string
, bp_catch_vfork
);
4746 create_exec_event_catchpoint (int tempflag
, char *cond_string
)
4748 struct symtab_and_line sal
;
4749 struct breakpoint
*b
;
4750 int thread
= -1; /* All threads. */
4757 b
= set_raw_breakpoint (sal
, bp_catch_exec
);
4758 set_breakpoint_count (breakpoint_count
+ 1);
4759 b
->number
= breakpoint_count
;
4761 b
->cond_string
= (cond_string
== NULL
) ?
4762 NULL
: savestring (cond_string
, strlen (cond_string
));
4764 b
->addr_string
= NULL
;
4765 b
->enable_state
= bp_enabled
;
4766 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
4772 hw_breakpoint_used_count (void)
4774 struct breakpoint
*b
;
4779 if (b
->type
== bp_hardware_breakpoint
&& b
->enable_state
== bp_enabled
)
4787 hw_watchpoint_used_count (enum bptype type
, int *other_type_used
)
4789 struct breakpoint
*b
;
4792 *other_type_used
= 0;
4795 if (breakpoint_enabled (b
))
4797 if (b
->type
== type
)
4799 else if ((b
->type
== bp_hardware_watchpoint
||
4800 b
->type
== bp_read_watchpoint
||
4801 b
->type
== bp_access_watchpoint
))
4802 *other_type_used
= 1;
4808 /* Call this after hitting the longjmp() breakpoint. Use this to set
4809 a new breakpoint at the target of the jmp_buf.
4811 FIXME - This ought to be done by setting a temporary breakpoint
4812 that gets deleted automatically... */
4815 set_longjmp_resume_breakpoint (CORE_ADDR pc
, struct frame_id frame_id
)
4817 struct breakpoint
*b
;
4820 if (b
->type
== bp_longjmp_resume
)
4822 b
->loc
->requested_address
= pc
;
4823 b
->loc
->address
= adjust_breakpoint_address (b
->loc
->requested_address
,
4825 b
->enable_state
= bp_enabled
;
4826 b
->frame_id
= frame_id
;
4827 check_duplicates (b
);
4833 disable_watchpoints_before_interactive_call_start (void)
4835 struct breakpoint
*b
;
4839 if (((b
->type
== bp_watchpoint
)
4840 || (b
->type
== bp_hardware_watchpoint
)
4841 || (b
->type
== bp_read_watchpoint
)
4842 || (b
->type
== bp_access_watchpoint
)
4843 || ep_is_exception_catchpoint (b
))
4844 && breakpoint_enabled (b
))
4846 b
->enable_state
= bp_call_disabled
;
4847 check_duplicates (b
);
4853 enable_watchpoints_after_interactive_call_stop (void)
4855 struct breakpoint
*b
;
4859 if (((b
->type
== bp_watchpoint
)
4860 || (b
->type
== bp_hardware_watchpoint
)
4861 || (b
->type
== bp_read_watchpoint
)
4862 || (b
->type
== bp_access_watchpoint
)
4863 || ep_is_exception_catchpoint (b
))
4864 && (b
->enable_state
== bp_call_disabled
))
4866 b
->enable_state
= bp_enabled
;
4867 check_duplicates (b
);
4873 /* Set a breakpoint that will evaporate an end of command
4874 at address specified by SAL.
4875 Restrict it to frame FRAME if FRAME is nonzero. */
4878 set_momentary_breakpoint (struct symtab_and_line sal
, struct frame_id frame_id
,
4881 struct breakpoint
*b
;
4882 b
= set_raw_breakpoint (sal
, type
);
4883 b
->enable_state
= bp_enabled
;
4884 b
->disposition
= disp_donttouch
;
4885 b
->frame_id
= frame_id
;
4887 /* If we're debugging a multi-threaded program, then we
4888 want momentary breakpoints to be active in only a
4889 single thread of control. */
4890 if (in_thread_list (inferior_ptid
))
4891 b
->thread
= pid_to_thread_id (inferior_ptid
);
4897 /* Tell the user we have just set a breakpoint B. */
4900 mention (struct breakpoint
*b
)
4903 struct cleanup
*old_chain
, *ui_out_chain
;
4904 struct ui_stream
*stb
;
4906 stb
= ui_out_stream_new (uiout
);
4907 old_chain
= make_cleanup_ui_out_stream_delete (stb
);
4909 /* FIXME: This is misplaced; mention() is called by things (like
4910 hitting a watchpoint) other than breakpoint creation. It should
4911 be possible to clean this up and at the same time replace the
4912 random calls to breakpoint_changed with this hook, as has already
4913 been done for deprecated_delete_breakpoint_hook and so on. */
4914 if (deprecated_create_breakpoint_hook
)
4915 deprecated_create_breakpoint_hook (b
);
4916 breakpoint_create_event (b
->number
);
4918 if (b
->ops
!= NULL
&& b
->ops
->print_mention
!= NULL
)
4919 b
->ops
->print_mention (b
);
4924 printf_filtered (_("(apparently deleted?) Eventpoint %d: "), b
->number
);
4927 ui_out_text (uiout
, "Watchpoint ");
4928 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "wpt");
4929 ui_out_field_int (uiout
, "number", b
->number
);
4930 ui_out_text (uiout
, ": ");
4931 print_expression (b
->exp
, stb
->stream
);
4932 ui_out_field_stream (uiout
, "exp", stb
);
4933 do_cleanups (ui_out_chain
);
4935 case bp_hardware_watchpoint
:
4936 ui_out_text (uiout
, "Hardware watchpoint ");
4937 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "wpt");
4938 ui_out_field_int (uiout
, "number", b
->number
);
4939 ui_out_text (uiout
, ": ");
4940 print_expression (b
->exp
, stb
->stream
);
4941 ui_out_field_stream (uiout
, "exp", stb
);
4942 do_cleanups (ui_out_chain
);
4944 case bp_read_watchpoint
:
4945 ui_out_text (uiout
, "Hardware read watchpoint ");
4946 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "hw-rwpt");
4947 ui_out_field_int (uiout
, "number", b
->number
);
4948 ui_out_text (uiout
, ": ");
4949 print_expression (b
->exp
, stb
->stream
);
4950 ui_out_field_stream (uiout
, "exp", stb
);
4951 do_cleanups (ui_out_chain
);
4953 case bp_access_watchpoint
:
4954 ui_out_text (uiout
, "Hardware access (read/write) watchpoint ");
4955 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "hw-awpt");
4956 ui_out_field_int (uiout
, "number", b
->number
);
4957 ui_out_text (uiout
, ": ");
4958 print_expression (b
->exp
, stb
->stream
);
4959 ui_out_field_stream (uiout
, "exp", stb
);
4960 do_cleanups (ui_out_chain
);
4963 if (ui_out_is_mi_like_p (uiout
))
4968 printf_filtered (_("Breakpoint %d"), b
->number
);
4971 case bp_hardware_breakpoint
:
4972 if (ui_out_is_mi_like_p (uiout
))
4977 printf_filtered (_("Hardware assisted breakpoint %d"), b
->number
);
4981 case bp_catch_unload
:
4982 printf_filtered (_("Catchpoint %d (%s %s)"),
4984 (b
->type
== bp_catch_load
) ? "load" : "unload",
4985 (b
->dll_pathname
!= NULL
) ?
4986 b
->dll_pathname
: "<any library>");
4989 case bp_catch_vfork
:
4990 printf_filtered (_("Catchpoint %d (%s)"),
4992 (b
->type
== bp_catch_fork
) ? "fork" : "vfork");
4995 printf_filtered (_("Catchpoint %d (exec)"),
4998 case bp_catch_catch
:
4999 case bp_catch_throw
:
5000 printf_filtered (_("Catchpoint %d (%s)"),
5002 (b
->type
== bp_catch_catch
) ? "catch" : "throw");
5008 case bp_longjmp_resume
:
5009 case bp_step_resume
:
5010 case bp_through_sigtramp
:
5012 case bp_watchpoint_scope
:
5013 case bp_shlib_event
:
5014 case bp_thread_event
:
5015 case bp_overlay_event
:
5021 /* i18n: cagney/2005-02-11: Below needs to be merged into a
5025 printf_filtered (_(" (%s) pending."), b
->addr_string
);
5029 if (addressprint
|| b
->source_file
== NULL
)
5031 printf_filtered (" at ");
5032 deprecated_print_address_numeric (b
->loc
->address
, 1, gdb_stdout
);
5035 printf_filtered (": file %s, line %d.",
5036 b
->source_file
, b
->line_number
);
5039 do_cleanups (old_chain
);
5040 if (ui_out_is_mi_like_p (uiout
))
5042 printf_filtered ("\n");
5046 /* Add SALS.nelts breakpoints to the breakpoint table. For each
5047 SALS.sal[i] breakpoint, include the corresponding ADDR_STRING[i],
5048 COND[i] and COND_STRING[i] values.
5050 The parameter PENDING_BP points to a pending breakpoint that is
5051 the basis of the breakpoints currently being created. The pending
5052 breakpoint may contain a separate condition string or commands
5053 that were added after the initial pending breakpoint was created.
5055 NOTE: If the function succeeds, the caller is expected to cleanup
5056 the arrays ADDR_STRING, COND_STRING, COND and SALS (but not the
5057 array contents). If the function fails (error() is called), the
5058 caller is expected to cleanups both the ADDR_STRING, COND_STRING,
5059 COND and SALS arrays and each of those arrays contents. */
5062 create_breakpoints (struct symtabs_and_lines sals
, char **addr_string
,
5063 struct expression
**cond
, char **cond_string
,
5064 enum bptype type
, enum bpdisp disposition
,
5065 int thread
, int ignore_count
, int from_tty
,
5066 struct breakpoint
*pending_bp
)
5068 if (type
== bp_hardware_breakpoint
)
5070 int i
= hw_breakpoint_used_count ();
5071 int target_resources_ok
=
5072 TARGET_CAN_USE_HARDWARE_WATCHPOINT (bp_hardware_breakpoint
,
5074 if (target_resources_ok
== 0)
5075 error (_("No hardware breakpoint support in the target."));
5076 else if (target_resources_ok
< 0)
5077 error (_("Hardware breakpoints used exceeds limit."));
5080 /* Now set all the breakpoints. */
5083 for (i
= 0; i
< sals
.nelts
; i
++)
5085 struct breakpoint
*b
;
5086 struct symtab_and_line sal
= sals
.sals
[i
];
5089 describe_other_breakpoints (sal
.pc
, sal
.section
, thread
);
5091 b
= set_raw_breakpoint (sal
, type
);
5092 set_breakpoint_count (breakpoint_count
+ 1);
5093 b
->number
= breakpoint_count
;
5097 b
->addr_string
= addr_string
[i
];
5099 /* addr_string has to be used or breakpoint_re_set will delete
5101 b
->addr_string
= xstrprintf ("*0x%s", paddr (b
->loc
->address
));
5102 b
->cond_string
= cond_string
[i
];
5103 b
->ignore_count
= ignore_count
;
5104 b
->enable_state
= bp_enabled
;
5105 b
->disposition
= disposition
;
5106 /* If resolving a pending breakpoint, a check must be made to see if
5107 the user has specified a new condition or commands for the
5108 breakpoint. A new condition will override any condition that was
5109 initially specified with the initial breakpoint command. */
5113 if (pending_bp
->cond_string
)
5115 arg
= pending_bp
->cond_string
;
5116 b
->cond_string
= savestring (arg
, strlen (arg
));
5117 b
->cond
= parse_exp_1 (&arg
, block_for_pc (b
->loc
->address
), 0);
5119 error (_("Junk at end of pending breakpoint condition expression"));
5121 /* If there are commands associated with the breakpoint, they should
5123 if (pending_bp
->commands
)
5124 b
->commands
= copy_command_lines (pending_bp
->commands
);
5126 /* We have to copy over the ignore_count and thread as well. */
5127 b
->ignore_count
= pending_bp
->ignore_count
;
5128 b
->thread
= pending_bp
->thread
;
5135 /* Parse ARG which is assumed to be a SAL specification possibly
5136 followed by conditionals. On return, SALS contains an array of SAL
5137 addresses found. ADDR_STRING contains a vector of (canonical)
5138 address strings. ARG points to the end of the SAL. */
5141 parse_breakpoint_sals (char **address
,
5142 struct symtabs_and_lines
*sals
,
5143 char ***addr_string
,
5146 char *addr_start
= *address
;
5147 *addr_string
= NULL
;
5148 /* If no arg given, or if first arg is 'if ', use the default
5150 if ((*address
) == NULL
5151 || (strncmp ((*address
), "if", 2) == 0 && isspace ((*address
)[2])))
5153 if (default_breakpoint_valid
)
5155 struct symtab_and_line sal
;
5156 init_sal (&sal
); /* initialize to zeroes */
5157 sals
->sals
= (struct symtab_and_line
*)
5158 xmalloc (sizeof (struct symtab_and_line
));
5159 sal
.pc
= default_breakpoint_address
;
5160 sal
.line
= default_breakpoint_line
;
5161 sal
.symtab
= default_breakpoint_symtab
;
5162 sal
.section
= find_pc_overlay (sal
.pc
);
5163 sals
->sals
[0] = sal
;
5167 error (_("No default breakpoint address now."));
5171 /* Force almost all breakpoints to be in terms of the
5172 current_source_symtab (which is decode_line_1's default). This
5173 should produce the results we want almost all of the time while
5174 leaving default_breakpoint_* alone.
5175 ObjC: However, don't match an Objective-C method name which
5176 may have a '+' or '-' succeeded by a '[' */
5178 struct symtab_and_line cursal
= get_current_source_symtab_and_line ();
5180 if (default_breakpoint_valid
5182 || ((strchr ("+-", (*address
)[0]) != NULL
)
5183 && ((*address
)[1] != '['))))
5184 *sals
= decode_line_1 (address
, 1, default_breakpoint_symtab
,
5185 default_breakpoint_line
, addr_string
,
5188 *sals
= decode_line_1 (address
, 1, (struct symtab
*) NULL
, 0,
5189 addr_string
, not_found_ptr
);
5191 /* For any SAL that didn't have a canonical string, fill one in. */
5192 if (sals
->nelts
> 0 && *addr_string
== NULL
)
5193 *addr_string
= xcalloc (sals
->nelts
, sizeof (char **));
5194 if (addr_start
!= (*address
))
5197 for (i
= 0; i
< sals
->nelts
; i
++)
5199 /* Add the string if not present. */
5200 if ((*addr_string
)[i
] == NULL
)
5201 (*addr_string
)[i
] = savestring (addr_start
, (*address
) - addr_start
);
5207 /* Convert each SAL into a real PC. Verify that the PC can be
5208 inserted as a breakpoint. If it can't throw an error. */
5211 breakpoint_sals_to_pc (struct symtabs_and_lines
*sals
,
5215 for (i
= 0; i
< sals
->nelts
; i
++)
5217 resolve_sal_pc (&sals
->sals
[i
]);
5219 /* It's possible for the PC to be nonzero, but still an illegal
5220 value on some targets.
5222 For example, on HP-UX if you start gdb, and before running the
5223 inferior you try to set a breakpoint on a shared library function
5224 "foo" where the inferior doesn't call "foo" directly but does
5225 pass its address to another function call, then we do find a
5226 minimal symbol for the "foo", but it's address is invalid.
5227 (Appears to be an index into a table that the loader sets up
5228 when the inferior is run.)
5230 Give the target a chance to bless sals.sals[i].pc before we
5231 try to make a breakpoint for it. */
5232 #ifdef DEPRECATED_PC_REQUIRES_RUN_BEFORE_USE
5233 if (DEPRECATED_PC_REQUIRES_RUN_BEFORE_USE (sals
->sals
[i
].pc
))
5235 if (address
== NULL
)
5236 error (_("Cannot break without a running program."));
5238 error (_("Cannot break on %s without a running program."),
5246 do_captured_parse_breakpoint (struct ui_out
*ui
, void *data
)
5248 struct captured_parse_breakpoint_args
*args
= data
;
5250 parse_breakpoint_sals (args
->arg_p
, args
->sals_p
, args
->addr_string_p
,
5251 args
->not_found_ptr
);
5254 /* Set a breakpoint according to ARG (function, linenum or *address)
5255 flag: first bit : 0 non-temporary, 1 temporary.
5256 second bit : 0 normal breakpoint, 1 hardware breakpoint.
5258 PENDING_BP is non-NULL when this function is being called to resolve
5259 a pending breakpoint. */
5262 break_command_1 (char *arg
, int flag
, int from_tty
, struct breakpoint
*pending_bp
)
5264 struct gdb_exception e
;
5265 int tempflag
, hardwareflag
;
5266 struct symtabs_and_lines sals
;
5267 struct expression
**cond
= 0;
5268 struct symtab_and_line pending_sal
;
5269 char **cond_string
= (char **) NULL
;
5272 char *addr_start
= arg
;
5274 struct cleanup
*old_chain
;
5275 struct cleanup
*breakpoint_chain
= NULL
;
5276 struct captured_parse_breakpoint_args parse_args
;
5280 int ignore_count
= 0;
5283 hardwareflag
= flag
& BP_HARDWAREFLAG
;
5284 tempflag
= flag
& BP_TEMPFLAG
;
5290 parse_args
.arg_p
= &arg
;
5291 parse_args
.sals_p
= &sals
;
5292 parse_args
.addr_string_p
= &addr_string
;
5293 parse_args
.not_found_ptr
= ¬_found
;
5295 e
= catch_exception (uiout
, do_captured_parse_breakpoint
,
5296 &parse_args
, RETURN_MASK_ALL
);
5298 /* If caller is interested in rc value from parse, set value. */
5302 exception_print (gdb_stderr
, e
);
5307 case NOT_FOUND_ERROR
:
5308 /* If called to resolve pending breakpoint, just return
5313 exception_print (gdb_stderr
, e
);
5315 /* If pending breakpoint support is turned off, throw
5318 if (pending_break_support
== AUTO_BOOLEAN_FALSE
)
5319 deprecated_throw_reason (RETURN_ERROR
);
5321 /* If pending breakpoint support is auto query and the user
5322 selects no, then simply return the error code. */
5323 if (pending_break_support
== AUTO_BOOLEAN_AUTO
&&
5324 !nquery ("Make breakpoint pending on future shared library load? "))
5327 /* At this point, either the user was queried about setting
5328 a pending breakpoint and selected yes, or pending
5329 breakpoint behavior is on and thus a pending breakpoint
5330 is defaulted on behalf of the user. */
5331 copy_arg
= xstrdup (addr_start
);
5332 addr_string
= ©_arg
;
5334 sals
.sals
= &pending_sal
;
5339 exception_print (gdb_stderr
, e
);
5347 /* Create a chain of things that always need to be cleaned up. */
5348 old_chain
= make_cleanup (null_cleanup
, 0);
5352 /* Make sure that all storage allocated to SALS gets freed. */
5353 make_cleanup (xfree
, sals
.sals
);
5355 /* Cleanup the addr_string array but not its contents. */
5356 make_cleanup (xfree
, addr_string
);
5359 /* Allocate space for all the cond expressions. */
5360 cond
= xcalloc (sals
.nelts
, sizeof (struct expression
*));
5361 make_cleanup (xfree
, cond
);
5363 /* Allocate space for all the cond strings. */
5364 cond_string
= xcalloc (sals
.nelts
, sizeof (char **));
5365 make_cleanup (xfree
, cond_string
);
5367 /* ----------------------------- SNIP -----------------------------
5368 Anything added to the cleanup chain beyond this point is assumed
5369 to be part of a breakpoint. If the breakpoint create succeeds
5370 then the memory is not reclaimed. */
5371 breakpoint_chain
= make_cleanup (null_cleanup
, 0);
5373 /* Mark the contents of the addr_string for cleanup. These go on
5374 the breakpoint_chain and only occure if the breakpoint create
5376 for (i
= 0; i
< sals
.nelts
; i
++)
5378 if (addr_string
[i
] != NULL
)
5379 make_cleanup (xfree
, addr_string
[i
]);
5382 /* Resolve all line numbers to PC's and verify that the addresses
5383 are ok for the target. */
5385 breakpoint_sals_to_pc (&sals
, addr_start
);
5387 /* Verify that condition can be parsed, before setting any
5388 breakpoints. Allocate a separate condition expression for each
5390 thread
= -1; /* No specific thread yet */
5393 for (i
= 0; i
< sals
.nelts
; i
++)
5400 char *cond_start
= NULL
;
5401 char *cond_end
= NULL
;
5402 while (*tok
== ' ' || *tok
== '\t')
5407 while (*end_tok
!= ' ' && *end_tok
!= '\t' && *end_tok
!= '\000')
5410 toklen
= end_tok
- tok
;
5412 if (toklen
>= 1 && strncmp (tok
, "if", toklen
) == 0)
5414 tok
= cond_start
= end_tok
+ 1;
5415 cond
[i
] = parse_exp_1 (&tok
, block_for_pc (sals
.sals
[i
].pc
),
5417 make_cleanup (xfree
, cond
[i
]);
5419 cond_string
[i
] = savestring (cond_start
,
5420 cond_end
- cond_start
);
5421 make_cleanup (xfree
, cond_string
[i
]);
5423 else if (toklen
>= 1 && strncmp (tok
, "thread", toklen
) == 0)
5429 thread
= strtol (tok
, &tok
, 0);
5431 error (_("Junk after thread keyword."));
5432 if (!valid_thread_id (thread
))
5433 error (_("Unknown thread %d."), thread
);
5436 error (_("Junk at end of arguments."));
5439 create_breakpoints (sals
, addr_string
, cond
, cond_string
,
5440 hardwareflag
? bp_hardware_breakpoint
5442 tempflag
? disp_del
: disp_donttouch
,
5443 thread
, ignore_count
, from_tty
,
5448 struct symtab_and_line sal
;
5449 struct breakpoint
*b
;
5454 make_cleanup (xfree
, copy_arg
);
5456 b
= set_raw_breakpoint (sal
, hardwareflag
? bp_hardware_breakpoint
5458 set_breakpoint_count (breakpoint_count
+ 1);
5459 b
->number
= breakpoint_count
;
5462 b
->addr_string
= *addr_string
;
5463 b
->cond_string
= *cond_string
;
5464 b
->ignore_count
= ignore_count
;
5466 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
5467 b
->from_tty
= from_tty
;
5473 warning (_("Multiple breakpoints were set.\n"
5474 "Use the \"delete\" command to delete unwanted breakpoints."));
5475 /* That's it. Discard the cleanups for data inserted into the
5477 discard_cleanups (breakpoint_chain
);
5478 /* But cleanup everything else. */
5479 do_cleanups (old_chain
);
5484 /* Set a breakpoint of TYPE/DISPOSITION according to ARG (function,
5485 linenum or *address) with COND and IGNORE_COUNT. */
5487 struct captured_breakpoint_args
5498 do_captured_breakpoint (struct ui_out
*uiout
, void *data
)
5500 struct captured_breakpoint_args
*args
= data
;
5501 struct symtabs_and_lines sals
;
5502 struct expression
**cond
;
5503 struct cleanup
*old_chain
;
5504 struct cleanup
*breakpoint_chain
= NULL
;
5511 /* Parse the source and lines spec. Delay check that the expression
5512 didn't contain trailing garbage until after cleanups are in
5516 address_end
= args
->address
;
5518 parse_breakpoint_sals (&address_end
, &sals
, &addr_string
, 0);
5523 /* Create a chain of things at always need to be cleaned up. */
5524 old_chain
= make_cleanup (null_cleanup
, 0);
5526 /* Always have a addr_string array, even if it is empty. */
5527 make_cleanup (xfree
, addr_string
);
5529 /* Make sure that all storage allocated to SALS gets freed. */
5530 make_cleanup (xfree
, sals
.sals
);
5532 /* Allocate space for all the cond expressions. */
5533 cond
= xcalloc (sals
.nelts
, sizeof (struct expression
*));
5534 make_cleanup (xfree
, cond
);
5536 /* Allocate space for all the cond strings. */
5537 cond_string
= xcalloc (sals
.nelts
, sizeof (char **));
5538 make_cleanup (xfree
, cond_string
);
5540 /* ----------------------------- SNIP -----------------------------
5541 Anything added to the cleanup chain beyond this point is assumed
5542 to be part of a breakpoint. If the breakpoint create goes
5543 through then that memory is not cleaned up. */
5544 breakpoint_chain
= make_cleanup (null_cleanup
, 0);
5546 /* Mark the contents of the addr_string for cleanup. These go on
5547 the breakpoint_chain and only occure if the breakpoint create
5549 for (i
= 0; i
< sals
.nelts
; i
++)
5551 if (addr_string
[i
] != NULL
)
5552 make_cleanup (xfree
, addr_string
[i
]);
5555 /* Wait until now before checking for garbage at the end of the
5556 address. That way cleanups can take care of freeing any
5558 if (*address_end
!= '\0')
5559 error (_("Garbage %s following breakpoint address"), address_end
);
5561 /* Resolve all line numbers to PC's. */
5562 breakpoint_sals_to_pc (&sals
, args
->address
);
5564 /* Verify that conditions can be parsed, before setting any
5566 for (i
= 0; i
< sals
.nelts
; i
++)
5568 if (args
->condition
!= NULL
)
5570 char *tok
= args
->condition
;
5571 cond
[i
] = parse_exp_1 (&tok
, block_for_pc (sals
.sals
[i
].pc
), 0);
5573 error (_("Garbage %s follows condition"), tok
);
5574 make_cleanup (xfree
, cond
[i
]);
5575 cond_string
[i
] = xstrdup (args
->condition
);
5579 create_breakpoints (sals
, addr_string
, cond
, cond_string
,
5580 args
->hardwareflag
? bp_hardware_breakpoint
: bp_breakpoint
,
5581 args
->tempflag
? disp_del
: disp_donttouch
,
5582 args
->thread
, args
->ignore_count
, 0/*from-tty*/,
5583 NULL
/*pending_bp*/);
5585 /* That's it. Discard the cleanups for data inserted into the
5587 discard_cleanups (breakpoint_chain
);
5588 /* But cleanup everything else. */
5589 do_cleanups (old_chain
);
5594 gdb_breakpoint (char *address
, char *condition
,
5595 int hardwareflag
, int tempflag
,
5596 int thread
, int ignore_count
,
5597 char **error_message
)
5599 struct captured_breakpoint_args args
;
5600 args
.address
= address
;
5601 args
.condition
= condition
;
5602 args
.hardwareflag
= hardwareflag
;
5603 args
.tempflag
= tempflag
;
5604 args
.thread
= thread
;
5605 args
.ignore_count
= ignore_count
;
5606 if (catch_exceptions_with_msg (uiout
, do_captured_breakpoint
, &args
,
5607 error_message
, RETURN_MASK_ALL
) < 0)
5614 /* Helper function for break_command_1 and disassemble_command. */
5617 resolve_sal_pc (struct symtab_and_line
*sal
)
5621 if (sal
->pc
== 0 && sal
->symtab
!= NULL
)
5623 if (!find_line_pc (sal
->symtab
, sal
->line
, &pc
))
5624 error (_("No line %d in file \"%s\"."),
5625 sal
->line
, sal
->symtab
->filename
);
5629 if (sal
->section
== 0 && sal
->symtab
!= NULL
)
5631 struct blockvector
*bv
;
5636 bv
= blockvector_for_pc_sect (sal
->pc
, 0, &index
, sal
->symtab
);
5639 b
= BLOCKVECTOR_BLOCK (bv
, index
);
5640 sym
= block_function (b
);
5643 fixup_symbol_section (sym
, sal
->symtab
->objfile
);
5644 sal
->section
= SYMBOL_BFD_SECTION (sym
);
5648 /* It really is worthwhile to have the section, so we'll just
5649 have to look harder. This case can be executed if we have
5650 line numbers but no functions (as can happen in assembly
5653 struct minimal_symbol
*msym
;
5655 msym
= lookup_minimal_symbol_by_pc (sal
->pc
);
5657 sal
->section
= SYMBOL_BFD_SECTION (msym
);
5664 break_command (char *arg
, int from_tty
)
5666 break_command_1 (arg
, 0, from_tty
, NULL
);
5670 tbreak_command (char *arg
, int from_tty
)
5672 break_command_1 (arg
, BP_TEMPFLAG
, from_tty
, NULL
);
5676 hbreak_command (char *arg
, int from_tty
)
5678 break_command_1 (arg
, BP_HARDWAREFLAG
, from_tty
, NULL
);
5682 thbreak_command (char *arg
, int from_tty
)
5684 break_command_1 (arg
, (BP_TEMPFLAG
| BP_HARDWAREFLAG
), from_tty
, NULL
);
5688 stop_command (char *arg
, int from_tty
)
5690 printf_filtered (_("Specify the type of breakpoint to set.\n\
5691 Usage: stop in <function | address>\n\
5692 stop at <line>\n"));
5696 stopin_command (char *arg
, int from_tty
)
5700 if (arg
== (char *) NULL
)
5702 else if (*arg
!= '*')
5707 /* look for a ':'. If this is a line number specification, then
5708 say it is bad, otherwise, it should be an address or
5709 function/method name */
5710 while (*argptr
&& !hasColon
)
5712 hasColon
= (*argptr
== ':');
5717 badInput
= (*argptr
!= ':'); /* Not a class::method */
5719 badInput
= isdigit (*arg
); /* a simple line number */
5723 printf_filtered (_("Usage: stop in <function | address>\n"));
5725 break_command_1 (arg
, 0, from_tty
, NULL
);
5729 stopat_command (char *arg
, int from_tty
)
5733 if (arg
== (char *) NULL
|| *arg
== '*') /* no line number */
5740 /* look for a ':'. If there is a '::' then get out, otherwise
5741 it is probably a line number. */
5742 while (*argptr
&& !hasColon
)
5744 hasColon
= (*argptr
== ':');
5749 badInput
= (*argptr
== ':'); /* we have class::method */
5751 badInput
= !isdigit (*arg
); /* not a line number */
5755 printf_filtered (_("Usage: stop at <line>\n"));
5757 break_command_1 (arg
, 0, from_tty
, NULL
);
5760 /* accessflag: hw_write: watch write,
5761 hw_read: watch read,
5762 hw_access: watch access (read or write) */
5764 watch_command_1 (char *arg
, int accessflag
, int from_tty
)
5766 struct breakpoint
*b
;
5767 struct symtab_and_line sal
;
5768 struct expression
*exp
;
5769 struct block
*exp_valid_block
;
5770 struct value
*val
, *mark
;
5771 struct frame_info
*frame
;
5772 struct frame_info
*prev_frame
= NULL
;
5773 char *exp_start
= NULL
;
5774 char *exp_end
= NULL
;
5775 char *tok
, *end_tok
;
5777 char *cond_start
= NULL
;
5778 char *cond_end
= NULL
;
5779 struct expression
*cond
= NULL
;
5780 int i
, other_type_used
, target_resources_ok
= 0;
5781 enum bptype bp_type
;
5784 init_sal (&sal
); /* initialize to zeroes */
5786 /* Parse arguments. */
5787 innermost_block
= NULL
;
5789 exp
= parse_exp_1 (&arg
, 0, 0);
5791 exp_valid_block
= innermost_block
;
5792 mark
= value_mark ();
5793 val
= evaluate_expression (exp
);
5794 release_value (val
);
5795 if (value_lazy (val
))
5796 value_fetch_lazy (val
);
5799 while (*tok
== ' ' || *tok
== '\t')
5803 while (*end_tok
!= ' ' && *end_tok
!= '\t' && *end_tok
!= '\000')
5806 toklen
= end_tok
- tok
;
5807 if (toklen
>= 1 && strncmp (tok
, "if", toklen
) == 0)
5809 tok
= cond_start
= end_tok
+ 1;
5810 cond
= parse_exp_1 (&tok
, 0, 0);
5814 error (_("Junk at end of command."));
5816 if (accessflag
== hw_read
)
5817 bp_type
= bp_read_watchpoint
;
5818 else if (accessflag
== hw_access
)
5819 bp_type
= bp_access_watchpoint
;
5821 bp_type
= bp_hardware_watchpoint
;
5823 mem_cnt
= can_use_hardware_watchpoint (val
);
5824 if (mem_cnt
== 0 && bp_type
!= bp_hardware_watchpoint
)
5825 error (_("Expression cannot be implemented with read/access watchpoint."));
5828 i
= hw_watchpoint_used_count (bp_type
, &other_type_used
);
5829 target_resources_ok
=
5830 TARGET_CAN_USE_HARDWARE_WATCHPOINT (bp_type
, i
+ mem_cnt
,
5832 if (target_resources_ok
== 0 && bp_type
!= bp_hardware_watchpoint
)
5833 error (_("Target does not support this type of hardware watchpoint."));
5835 if (target_resources_ok
< 0 && bp_type
!= bp_hardware_watchpoint
)
5836 error (_("Target can only support one kind of HW watchpoint at a time."));
5839 #if defined(HPUXHPPA)
5840 /* On HP-UX if you set a h/w
5841 watchpoint before the "run" command, the inferior dies with a e.g.,
5842 SIGILL once you start it. I initially believed this was due to a
5843 bad interaction between page protection traps and the initial
5844 startup sequence by the dynamic linker.
5846 However, I tried avoiding that by having HP-UX's implementation of
5847 TARGET_CAN_USE_HW_WATCHPOINT return FALSE if there was no inferior_ptid
5848 yet, which forced slow watches before a "run" or "attach", and it
5849 still fails somewhere in the startup code.
5851 Until I figure out what's happening, I'm disallowing watches altogether
5852 before the "run" or "attach" command. We'll tell the user they must
5853 set watches after getting the program started. */
5854 if (!target_has_execution
)
5856 warning (_("can't do that without a running program; try \"break main\"), \"run\" first");
5859 #endif /* HPUXHPPA */
5861 /* Change the type of breakpoint to an ordinary watchpoint if a hardware
5862 watchpoint could not be set. */
5863 if (!mem_cnt
|| target_resources_ok
<= 0)
5864 bp_type
= bp_watchpoint
;
5866 /* Now set up the breakpoint. */
5867 b
= set_raw_breakpoint (sal
, bp_type
);
5868 set_breakpoint_count (breakpoint_count
+ 1);
5869 b
->number
= breakpoint_count
;
5870 b
->disposition
= disp_donttouch
;
5872 b
->exp_valid_block
= exp_valid_block
;
5873 b
->exp_string
= savestring (exp_start
, exp_end
- exp_start
);
5877 b
->cond_string
= savestring (cond_start
, cond_end
- cond_start
);
5881 frame
= block_innermost_frame (exp_valid_block
);
5884 prev_frame
= get_prev_frame (frame
);
5885 b
->watchpoint_frame
= get_frame_id (frame
);
5889 memset (&b
->watchpoint_frame
, 0, sizeof (b
->watchpoint_frame
));
5892 /* If the expression is "local", then set up a "watchpoint scope"
5893 breakpoint at the point where we've left the scope of the watchpoint
5895 if (innermost_block
)
5899 struct breakpoint
*scope_breakpoint
;
5900 scope_breakpoint
= create_internal_breakpoint (get_frame_pc (prev_frame
),
5901 bp_watchpoint_scope
);
5903 scope_breakpoint
->enable_state
= bp_enabled
;
5905 /* Automatically delete the breakpoint when it hits. */
5906 scope_breakpoint
->disposition
= disp_del
;
5908 /* Only break in the proper frame (help with recursion). */
5909 scope_breakpoint
->frame_id
= get_frame_id (prev_frame
);
5911 /* Set the address at which we will stop. */
5912 scope_breakpoint
->loc
->requested_address
5913 = get_frame_pc (prev_frame
);
5914 scope_breakpoint
->loc
->address
5915 = adjust_breakpoint_address (scope_breakpoint
->loc
->requested_address
,
5916 scope_breakpoint
->type
);
5918 /* The scope breakpoint is related to the watchpoint. We
5919 will need to act on them together. */
5920 b
->related_breakpoint
= scope_breakpoint
;
5923 value_free_to_mark (mark
);
5927 /* Return count of locations need to be watched and can be handled
5928 in hardware. If the watchpoint can not be handled
5929 in hardware return zero. */
5932 can_use_hardware_watchpoint (struct value
*v
)
5934 int found_memory_cnt
= 0;
5935 struct value
*head
= v
;
5937 /* Did the user specifically forbid us to use hardware watchpoints? */
5938 if (!can_use_hw_watchpoints
)
5941 /* Make sure that the value of the expression depends only upon
5942 memory contents, and values computed from them within GDB. If we
5943 find any register references or function calls, we can't use a
5944 hardware watchpoint.
5946 The idea here is that evaluating an expression generates a series
5947 of values, one holding the value of every subexpression. (The
5948 expression a*b+c has five subexpressions: a, b, a*b, c, and
5949 a*b+c.) GDB's values hold almost enough information to establish
5950 the criteria given above --- they identify memory lvalues,
5951 register lvalues, computed values, etcetera. So we can evaluate
5952 the expression, and then scan the chain of values that leaves
5953 behind to decide whether we can detect any possible change to the
5954 expression's final value using only hardware watchpoints.
5956 However, I don't think that the values returned by inferior
5957 function calls are special in any way. So this function may not
5958 notice that an expression involving an inferior function call
5959 can't be watched with hardware watchpoints. FIXME. */
5960 for (; v
; v
= value_next (v
))
5962 if (VALUE_LVAL (v
) == lval_memory
)
5965 /* A lazy memory lvalue is one that GDB never needed to fetch;
5966 we either just used its address (e.g., `a' in `a.b') or
5967 we never needed it at all (e.g., `a' in `a,b'). */
5971 /* Ahh, memory we actually used! Check if we can cover
5972 it with hardware watchpoints. */
5973 struct type
*vtype
= check_typedef (value_type (v
));
5975 /* We only watch structs and arrays if user asked for it
5976 explicitly, never if they just happen to appear in a
5977 middle of some value chain. */
5979 || (TYPE_CODE (vtype
) != TYPE_CODE_STRUCT
5980 && TYPE_CODE (vtype
) != TYPE_CODE_ARRAY
))
5982 CORE_ADDR vaddr
= VALUE_ADDRESS (v
) + value_offset (v
);
5983 int len
= TYPE_LENGTH (value_type (v
));
5985 if (!TARGET_REGION_OK_FOR_HW_WATCHPOINT (vaddr
, len
))
5992 else if (VALUE_LVAL (v
) != not_lval
5993 && deprecated_value_modifiable (v
) == 0)
5994 return 0; /* ??? What does this represent? */
5995 else if (VALUE_LVAL (v
) == lval_register
)
5996 return 0; /* cannot watch a register with a HW watchpoint */
5999 /* The expression itself looks suitable for using a hardware
6000 watchpoint, but give the target machine a chance to reject it. */
6001 return found_memory_cnt
;
6005 watch_command_wrapper (char *arg
, int from_tty
)
6007 watch_command (arg
, from_tty
);
6011 watch_command (char *arg
, int from_tty
)
6013 watch_command_1 (arg
, hw_write
, from_tty
);
6017 rwatch_command_wrapper (char *arg
, int from_tty
)
6019 rwatch_command (arg
, from_tty
);
6023 rwatch_command (char *arg
, int from_tty
)
6025 watch_command_1 (arg
, hw_read
, from_tty
);
6029 awatch_command_wrapper (char *arg
, int from_tty
)
6031 awatch_command (arg
, from_tty
);
6035 awatch_command (char *arg
, int from_tty
)
6037 watch_command_1 (arg
, hw_access
, from_tty
);
6041 /* Helper routines for the until_command routine in infcmd.c. Here
6042 because it uses the mechanisms of breakpoints. */
6044 /* This function is called by fetch_inferior_event via the
6045 cmd_continuation pointer, to complete the until command. It takes
6046 care of cleaning up the temporary breakpoints set up by the until
6049 until_break_command_continuation (struct continuation_arg
*arg
)
6051 struct cleanup
*cleanups
;
6053 cleanups
= (struct cleanup
*) arg
->data
.pointer
;
6054 do_exec_cleanups (cleanups
);
6058 until_break_command (char *arg
, int from_tty
, int anywhere
)
6060 struct symtabs_and_lines sals
;
6061 struct symtab_and_line sal
;
6062 struct frame_info
*frame
= get_selected_frame (NULL
);
6063 struct frame_info
*prev_frame
= get_prev_frame (frame
);
6064 struct breakpoint
*breakpoint
;
6065 struct cleanup
*old_chain
;
6066 struct continuation_arg
*arg1
;
6069 clear_proceed_status ();
6071 /* Set a breakpoint where the user wants it and at return from
6074 if (default_breakpoint_valid
)
6075 sals
= decode_line_1 (&arg
, 1, default_breakpoint_symtab
,
6076 default_breakpoint_line
, (char ***) NULL
, NULL
);
6078 sals
= decode_line_1 (&arg
, 1, (struct symtab
*) NULL
,
6079 0, (char ***) NULL
, NULL
);
6081 if (sals
.nelts
!= 1)
6082 error (_("Couldn't get information on specified line."));
6085 xfree (sals
.sals
); /* malloc'd, so freed */
6088 error (_("Junk at end of arguments."));
6090 resolve_sal_pc (&sal
);
6093 /* If the user told us to continue until a specified location,
6094 we don't specify a frame at which we need to stop. */
6095 breakpoint
= set_momentary_breakpoint (sal
, null_frame_id
, bp_until
);
6097 /* Otherwise, specify the current frame, because we want to stop only
6098 at the very same frame. */
6099 breakpoint
= set_momentary_breakpoint (sal
, get_frame_id (frame
),
6102 if (!target_can_async_p ())
6103 old_chain
= make_cleanup_delete_breakpoint (breakpoint
);
6105 old_chain
= make_exec_cleanup_delete_breakpoint (breakpoint
);
6107 /* If we are running asynchronously, and the target supports async
6108 execution, we are not waiting for the target to stop, in the call
6109 tp proceed, below. This means that we cannot delete the
6110 brekpoints until the target has actually stopped. The only place
6111 where we get a chance to do that is in fetch_inferior_event, so
6112 we must set things up for that. */
6114 if (target_can_async_p ())
6116 /* In this case the arg for the continuation is just the point
6117 in the exec_cleanups chain from where to start doing
6118 cleanups, because all the continuation does is the cleanups in
6119 the exec_cleanup_chain. */
6121 (struct continuation_arg
*) xmalloc (sizeof (struct continuation_arg
));
6123 arg1
->data
.pointer
= old_chain
;
6125 add_continuation (until_break_command_continuation
, arg1
);
6128 /* Keep within the current frame, or in frames called by the current
6132 sal
= find_pc_line (get_frame_pc (prev_frame
), 0);
6133 sal
.pc
= get_frame_pc (prev_frame
);
6134 breakpoint
= set_momentary_breakpoint (sal
, get_frame_id (prev_frame
),
6136 if (!target_can_async_p ())
6137 make_cleanup_delete_breakpoint (breakpoint
);
6139 make_exec_cleanup_delete_breakpoint (breakpoint
);
6142 proceed (-1, TARGET_SIGNAL_DEFAULT
, 0);
6143 /* Do the cleanups now, anly if we are not running asynchronously,
6144 of if we are, but the target is still synchronous. */
6145 if (!target_can_async_p ())
6146 do_cleanups (old_chain
);
6150 ep_skip_leading_whitespace (char **s
)
6152 if ((s
== NULL
) || (*s
== NULL
))
6154 while (isspace (**s
))
6158 /* This function examines a string, and attempts to find a token
6159 that might be an event name in the leading characters. If a
6160 possible match is found, a pointer to the last character of
6161 the token is returned. Else, NULL is returned. */
6164 ep_find_event_name_end (char *arg
)
6167 char *event_name_end
= NULL
;
6169 /* If we could depend upon the presense of strrpbrk, we'd use that... */
6173 /* We break out of the loop when we find a token delimiter.
6174 Basically, we're looking for alphanumerics and underscores;
6175 anything else delimites the token. */
6178 if (!isalnum (*s
) && (*s
!= '_'))
6184 return event_name_end
;
6188 /* This function attempts to parse an optional "if <cond>" clause
6189 from the arg string. If one is not found, it returns NULL.
6191 Else, it returns a pointer to the condition string. (It does not
6192 attempt to evaluate the string against a particular block.) And,
6193 it updates arg to point to the first character following the parsed
6194 if clause in the arg string. */
6197 ep_parse_optional_if_clause (char **arg
)
6201 if (((*arg
)[0] != 'i') || ((*arg
)[1] != 'f') || !isspace ((*arg
)[2]))
6204 /* Skip the "if" keyword. */
6207 /* Skip any extra leading whitespace, and record the start of the
6208 condition string. */
6209 ep_skip_leading_whitespace (arg
);
6212 /* Assume that the condition occupies the remainder of the arg string. */
6213 (*arg
) += strlen (cond_string
);
6218 /* This function attempts to parse an optional filename from the arg
6219 string. If one is not found, it returns NULL.
6221 Else, it returns a pointer to the parsed filename. (This function
6222 makes no attempt to verify that a file of that name exists, or is
6223 accessible.) And, it updates arg to point to the first character
6224 following the parsed filename in the arg string.
6226 Note that clients needing to preserve the returned filename for
6227 future access should copy it to their own buffers. */
6229 ep_parse_optional_filename (char **arg
)
6231 static char filename
[1024];
6236 if ((*arg_p
== '\0') || isspace (*arg_p
))
6254 /* Commands to deal with catching events, such as signals, exceptions,
6255 process start/exit, etc. */
6259 catch_fork
, catch_vfork
6264 catch_fork_command_1 (catch_fork_kind fork_kind
, char *arg
, int tempflag
,
6267 char *cond_string
= NULL
;
6269 ep_skip_leading_whitespace (&arg
);
6271 /* The allowed syntax is:
6273 catch [v]fork if <cond>
6275 First, check if there's an if clause. */
6276 cond_string
= ep_parse_optional_if_clause (&arg
);
6278 if ((*arg
!= '\0') && !isspace (*arg
))
6279 error (_("Junk at end of arguments."));
6281 /* If this target supports it, create a fork or vfork catchpoint
6282 and enable reporting of such events. */
6286 create_fork_event_catchpoint (tempflag
, cond_string
);
6289 create_vfork_event_catchpoint (tempflag
, cond_string
);
6292 error (_("unsupported or unknown fork kind; cannot catch it"));
6298 catch_exec_command_1 (char *arg
, int tempflag
, int from_tty
)
6300 char *cond_string
= NULL
;
6302 ep_skip_leading_whitespace (&arg
);
6304 /* The allowed syntax is:
6306 catch exec if <cond>
6308 First, check if there's an if clause. */
6309 cond_string
= ep_parse_optional_if_clause (&arg
);
6311 if ((*arg
!= '\0') && !isspace (*arg
))
6312 error (_("Junk at end of arguments."));
6314 /* If this target supports it, create an exec catchpoint
6315 and enable reporting of such events. */
6316 create_exec_event_catchpoint (tempflag
, cond_string
);
6320 catch_load_command_1 (char *arg
, int tempflag
, int from_tty
)
6322 char *dll_pathname
= NULL
;
6323 char *cond_string
= NULL
;
6325 ep_skip_leading_whitespace (&arg
);
6327 /* The allowed syntax is:
6329 catch load if <cond>
6330 catch load <filename>
6331 catch load <filename> if <cond>
6333 The user is not allowed to specify the <filename> after an
6336 We'll ignore the pathological case of a file named "if".
6338 First, check if there's an if clause. If so, then there
6339 cannot be a filename. */
6340 cond_string
= ep_parse_optional_if_clause (&arg
);
6342 /* If there was an if clause, then there cannot be a filename.
6343 Else, there might be a filename and an if clause. */
6344 if (cond_string
== NULL
)
6346 dll_pathname
= ep_parse_optional_filename (&arg
);
6347 ep_skip_leading_whitespace (&arg
);
6348 cond_string
= ep_parse_optional_if_clause (&arg
);
6351 if ((*arg
!= '\0') && !isspace (*arg
))
6352 error (_("Junk at end of arguments."));
6354 /* Create a load breakpoint that only triggers when a load of
6355 the specified dll (or any dll, if no pathname was specified)
6357 SOLIB_CREATE_CATCH_LOAD_HOOK (PIDGET (inferior_ptid
), tempflag
,
6358 dll_pathname
, cond_string
);
6362 catch_unload_command_1 (char *arg
, int tempflag
, int from_tty
)
6364 char *dll_pathname
= NULL
;
6365 char *cond_string
= NULL
;
6367 ep_skip_leading_whitespace (&arg
);
6369 /* The allowed syntax is:
6371 catch unload if <cond>
6372 catch unload <filename>
6373 catch unload <filename> if <cond>
6375 The user is not allowed to specify the <filename> after an
6378 We'll ignore the pathological case of a file named "if".
6380 First, check if there's an if clause. If so, then there
6381 cannot be a filename. */
6382 cond_string
= ep_parse_optional_if_clause (&arg
);
6384 /* If there was an if clause, then there cannot be a filename.
6385 Else, there might be a filename and an if clause. */
6386 if (cond_string
== NULL
)
6388 dll_pathname
= ep_parse_optional_filename (&arg
);
6389 ep_skip_leading_whitespace (&arg
);
6390 cond_string
= ep_parse_optional_if_clause (&arg
);
6393 if ((*arg
!= '\0') && !isspace (*arg
))
6394 error (_("Junk at end of arguments."));
6396 /* Create an unload breakpoint that only triggers when an unload of
6397 the specified dll (or any dll, if no pathname was specified)
6399 SOLIB_CREATE_CATCH_UNLOAD_HOOK (PIDGET (inferior_ptid
), tempflag
,
6400 dll_pathname
, cond_string
);
6403 /* Commands to deal with catching exceptions. */
6405 /* Set a breakpoint at the specified callback routine for an
6406 exception event callback */
6409 create_exception_catchpoint (int tempflag
, char *cond_string
,
6410 enum exception_event_kind ex_event
,
6411 struct symtab_and_line
*sal
)
6413 struct breakpoint
*b
;
6414 int thread
= -1; /* All threads. */
6417 if (!sal
) /* no exception support? */
6422 case EX_EVENT_THROW
:
6423 bptype
= bp_catch_throw
;
6425 case EX_EVENT_CATCH
:
6426 bptype
= bp_catch_catch
;
6428 default: /* error condition */
6429 error (_("Internal error -- invalid catchpoint kind"));
6432 b
= set_raw_breakpoint (*sal
, bptype
);
6433 set_breakpoint_count (breakpoint_count
+ 1);
6434 b
->number
= breakpoint_count
;
6436 b
->cond_string
= (cond_string
== NULL
) ?
6437 NULL
: savestring (cond_string
, strlen (cond_string
));
6439 b
->addr_string
= NULL
;
6440 b
->enable_state
= bp_enabled
;
6441 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
6445 static enum print_stop_action
6446 print_exception_catchpoint (struct breakpoint
*b
)
6448 annotate_catchpoint (b
->number
);
6450 if (strstr (b
->addr_string
, "throw") != NULL
)
6451 printf_filtered (_("\nCatchpoint %d (exception thrown)\n"),
6454 printf_filtered (_("\nCatchpoint %d (exception caught)\n"),
6457 return PRINT_SRC_AND_LOC
;
6461 print_one_exception_catchpoint (struct breakpoint
*b
, CORE_ADDR
*last_addr
)
6466 ui_out_field_core_addr (uiout
, "addr", b
->loc
->address
);
6469 *last_addr
= b
->loc
->address
;
6470 if (strstr (b
->addr_string
, "throw") != NULL
)
6471 ui_out_field_string (uiout
, "what", "exception throw");
6473 ui_out_field_string (uiout
, "what", "exception catch");
6477 print_mention_exception_catchpoint (struct breakpoint
*b
)
6479 if (strstr (b
->addr_string
, "throw") != NULL
)
6480 printf_filtered (_("Catchpoint %d (throw)"), b
->number
);
6482 printf_filtered (_("Catchpoint %d (catch)"), b
->number
);
6485 static struct breakpoint_ops gnu_v3_exception_catchpoint_ops
= {
6486 print_exception_catchpoint
,
6487 print_one_exception_catchpoint
,
6488 print_mention_exception_catchpoint
6492 handle_gnu_v3_exceptions (int tempflag
, char *cond_string
,
6493 enum exception_event_kind ex_event
, int from_tty
)
6495 char *trigger_func_name
, *nameptr
;
6496 struct symtabs_and_lines sals
;
6497 struct breakpoint
*b
;
6499 if (ex_event
== EX_EVENT_CATCH
)
6500 trigger_func_name
= xstrdup ("__cxa_begin_catch");
6502 trigger_func_name
= xstrdup ("__cxa_throw");
6504 nameptr
= trigger_func_name
;
6505 sals
= decode_line_1 (&nameptr
, 1, NULL
, 0, NULL
, NULL
);
6506 if (sals
.nelts
== 0)
6508 xfree (trigger_func_name
);
6512 b
= set_raw_breakpoint (sals
.sals
[0], bp_breakpoint
);
6513 set_breakpoint_count (breakpoint_count
+ 1);
6514 b
->number
= breakpoint_count
;
6516 b
->cond_string
= (cond_string
== NULL
) ?
6517 NULL
: savestring (cond_string
, strlen (cond_string
));
6519 b
->addr_string
= trigger_func_name
;
6520 b
->enable_state
= bp_enabled
;
6521 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
6522 b
->ops
= &gnu_v3_exception_catchpoint_ops
;
6529 /* Deal with "catch catch" and "catch throw" commands */
6532 catch_exception_command_1 (enum exception_event_kind ex_event
, char *arg
,
6533 int tempflag
, int from_tty
)
6535 char *cond_string
= NULL
;
6536 struct symtab_and_line
*sal
= NULL
;
6538 ep_skip_leading_whitespace (&arg
);
6540 cond_string
= ep_parse_optional_if_clause (&arg
);
6542 if ((*arg
!= '\0') && !isspace (*arg
))
6543 error (_("Junk at end of arguments."));
6545 if ((ex_event
!= EX_EVENT_THROW
) &&
6546 (ex_event
!= EX_EVENT_CATCH
))
6547 error (_("Unsupported or unknown exception event; cannot catch it"));
6549 if (handle_gnu_v3_exceptions (tempflag
, cond_string
, ex_event
, from_tty
))
6552 /* See if we can find a callback routine */
6553 sal
= target_enable_exception_callback (ex_event
, 1);
6557 /* We have callbacks from the runtime system for exceptions.
6558 Set a breakpoint on the sal found, if no errors */
6559 if (sal
!= (struct symtab_and_line
*) -1)
6560 create_exception_catchpoint (tempflag
, cond_string
, ex_event
, sal
);
6562 return; /* something went wrong with setting up callbacks */
6565 warning (_("Unsupported with this platform/compiler combination."));
6568 /* Create a breakpoint struct for Ada exception catchpoints. */
6571 create_ada_exception_breakpoint (struct symtab_and_line sal
,
6575 struct expression
*cond
,
6576 struct breakpoint_ops
*ops
,
6580 struct breakpoint
*b
;
6584 describe_other_breakpoints (sal
.pc
, sal
.section
, -1);
6585 /* FIXME: brobecker/2006-12-28: Actually, re-implement a special
6586 version for exception catchpoints, because two catchpoints
6587 used for different exception names will use the same address.
6588 In this case, a "breakpoint ... also set at..." warning is
6589 unproductive. Besides. the warning phrasing is also a bit
6590 inapropriate, we should use the word catchpoint, and tell
6591 the user what type of catchpoint it is. The above is good
6592 enough for now, though. */
6595 b
= set_raw_breakpoint (sal
, bp_breakpoint
);
6596 set_breakpoint_count (breakpoint_count
+ 1);
6598 b
->enable_state
= bp_enabled
;
6599 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
6600 b
->number
= breakpoint_count
;
6601 b
->ignore_count
= 0;
6603 b
->addr_string
= addr_string
;
6604 b
->language
= language_ada
;
6605 b
->cond_string
= cond_string
;
6606 b
->exp_string
= exp_string
;
6609 b
->from_tty
= from_tty
;
6614 /* Implement the "catch exception" command. */
6617 catch_ada_exception_command (char *arg
, int tempflag
, int from_tty
)
6619 struct symtab_and_line sal
;
6621 char *addr_string
= NULL
;
6622 char *exp_string
= NULL
;
6623 char *cond_string
= NULL
;
6624 struct expression
*cond
= NULL
;
6625 struct breakpoint_ops
*ops
= NULL
;
6627 sal
= ada_decode_exception_location (arg
, &addr_string
, &exp_string
,
6628 &cond_string
, &cond
, &ops
);
6629 create_ada_exception_breakpoint (sal
, addr_string
, exp_string
,
6630 cond_string
, cond
, ops
, tempflag
,
6634 /* Implement the "catch assert" command. */
6637 catch_assert_command (char *arg
, int tempflag
, int from_tty
)
6639 struct symtab_and_line sal
;
6640 char *addr_string
= NULL
;
6641 struct breakpoint_ops
*ops
= NULL
;
6643 sal
= ada_decode_assert_location (arg
, &addr_string
, &ops
);
6644 create_ada_exception_breakpoint (sal
, addr_string
, NULL
, NULL
, NULL
, ops
,
6645 tempflag
, from_tty
);
6648 /* Cover routine to allow wrapping target_enable_exception_catchpoints
6649 inside a catch_errors */
6652 cover_target_enable_exception_callback (void *arg
)
6654 args_for_catchpoint_enable
*args
= arg
;
6655 struct symtab_and_line
*sal
;
6656 sal
= target_enable_exception_callback (args
->kind
, args
->enable_p
);
6659 else if (sal
== (struct symtab_and_line
*) -1)
6662 return 1; /*is valid */
6666 catch_command_1 (char *arg
, int tempflag
, int from_tty
)
6669 /* The first argument may be an event name, such as "start" or "load".
6670 If so, then handle it as such. If it doesn't match an event name,
6671 then attempt to interpret it as an exception name. (This latter is
6672 the v4.16-and-earlier GDB meaning of the "catch" command.)
6674 First, try to find the bounds of what might be an event name. */
6675 char *arg1_start
= arg
;
6679 if (arg1_start
== NULL
)
6681 /* Old behaviour was to use pre-v-4.16 syntax */
6682 /* catch_throw_command_1 (arg1_start, tempflag, from_tty); */
6684 /* Now, this is not allowed */
6685 error (_("Catch requires an event name."));
6688 arg1_end
= ep_find_event_name_end (arg1_start
);
6689 if (arg1_end
== NULL
)
6690 error (_("catch requires an event"));
6691 arg1_length
= arg1_end
+ 1 - arg1_start
;
6693 /* Try to match what we found against known event names. */
6694 if (strncmp (arg1_start
, "signal", arg1_length
) == 0)
6696 error (_("Catch of signal not yet implemented"));
6698 else if (strncmp (arg1_start
, "catch", arg1_length
) == 0)
6700 catch_exception_command_1 (EX_EVENT_CATCH
, arg1_end
+ 1,
6701 tempflag
, from_tty
);
6703 else if (strncmp (arg1_start
, "throw", arg1_length
) == 0)
6705 catch_exception_command_1 (EX_EVENT_THROW
, arg1_end
+ 1,
6706 tempflag
, from_tty
);
6708 else if (strncmp (arg1_start
, "thread_start", arg1_length
) == 0)
6710 error (_("Catch of thread_start not yet implemented"));
6712 else if (strncmp (arg1_start
, "thread_exit", arg1_length
) == 0)
6714 error (_("Catch of thread_exit not yet implemented"));
6716 else if (strncmp (arg1_start
, "thread_join", arg1_length
) == 0)
6718 error (_("Catch of thread_join not yet implemented"));
6720 else if (strncmp (arg1_start
, "start", arg1_length
) == 0)
6722 error (_("Catch of start not yet implemented"));
6724 else if (strncmp (arg1_start
, "exit", arg1_length
) == 0)
6726 error (_("Catch of exit not yet implemented"));
6728 else if (strncmp (arg1_start
, "fork", arg1_length
) == 0)
6730 catch_fork_command_1 (catch_fork
, arg1_end
+ 1, tempflag
, from_tty
);
6732 else if (strncmp (arg1_start
, "vfork", arg1_length
) == 0)
6734 catch_fork_command_1 (catch_vfork
, arg1_end
+ 1, tempflag
, from_tty
);
6736 else if (strncmp (arg1_start
, "exec", arg1_length
) == 0)
6738 catch_exec_command_1 (arg1_end
+ 1, tempflag
, from_tty
);
6740 else if (strncmp (arg1_start
, "load", arg1_length
) == 0)
6742 catch_load_command_1 (arg1_end
+ 1, tempflag
, from_tty
);
6744 else if (strncmp (arg1_start
, "unload", arg1_length
) == 0)
6746 catch_unload_command_1 (arg1_end
+ 1, tempflag
, from_tty
);
6748 else if (strncmp (arg1_start
, "stop", arg1_length
) == 0)
6750 error (_("Catch of stop not yet implemented"));
6752 else if (strncmp (arg1_start
, "exception", arg1_length
) == 0)
6754 catch_ada_exception_command (arg1_end
+ 1, tempflag
, from_tty
);
6757 else if (strncmp (arg1_start
, "assert", arg1_length
) == 0)
6759 catch_assert_command (arg1_end
+ 1, tempflag
, from_tty
);
6762 /* This doesn't appear to be an event name */
6766 /* Pre-v.4.16 behaviour was to treat the argument
6767 as the name of an exception */
6768 /* catch_throw_command_1 (arg1_start, tempflag, from_tty); */
6769 /* Now this is not allowed */
6770 error (_("Unknown event kind specified for catch"));
6775 /* Used by the gui, could be made a worker for other things. */
6778 set_breakpoint_sal (struct symtab_and_line sal
)
6780 struct breakpoint
*b
;
6781 b
= set_raw_breakpoint (sal
, bp_breakpoint
);
6782 set_breakpoint_count (breakpoint_count
+ 1);
6783 b
->number
= breakpoint_count
;
6790 catch_command (char *arg
, int from_tty
)
6792 catch_command_1 (arg
, 0, from_tty
);
6797 tcatch_command (char *arg
, int from_tty
)
6799 catch_command_1 (arg
, 1, from_tty
);
6802 /* Delete breakpoints by address or line. */
6805 clear_command (char *arg
, int from_tty
)
6807 struct breakpoint
*b
, *tmp
, *prev
, *found
;
6809 struct symtabs_and_lines sals
;
6810 struct symtab_and_line sal
;
6815 sals
= decode_line_spec (arg
, 1);
6820 sals
.sals
= (struct symtab_and_line
*)
6821 xmalloc (sizeof (struct symtab_and_line
));
6822 make_cleanup (xfree
, sals
.sals
);
6823 init_sal (&sal
); /* initialize to zeroes */
6824 sal
.line
= default_breakpoint_line
;
6825 sal
.symtab
= default_breakpoint_symtab
;
6826 sal
.pc
= default_breakpoint_address
;
6827 if (sal
.symtab
== 0)
6828 error (_("No source file specified."));
6836 /* For each line spec given, delete bps which correspond
6837 to it. Do it in two passes, solely to preserve the current
6838 behavior that from_tty is forced true if we delete more than
6842 for (i
= 0; i
< sals
.nelts
; i
++)
6844 /* If exact pc given, clear bpts at that pc.
6845 If line given (pc == 0), clear all bpts on specified line.
6846 If defaulting, clear all bpts on default line
6849 defaulting sal.pc != 0 tests to do
6854 1 0 <can't happen> */
6859 /* Find all matching breakpoints, remove them from the
6860 breakpoint chain, and add them to the 'found' chain. */
6861 ALL_BREAKPOINTS_SAFE (b
, tmp
)
6863 /* Are we going to delete b? */
6864 if (b
->type
!= bp_none
6865 && b
->type
!= bp_watchpoint
6866 && b
->type
!= bp_hardware_watchpoint
6867 && b
->type
!= bp_read_watchpoint
6868 && b
->type
!= bp_access_watchpoint
6869 /* Not if b is a watchpoint of any sort... */
6870 && (((sal
.pc
&& (b
->loc
->address
== sal
.pc
))
6871 && (!section_is_overlay (b
->loc
->section
)
6872 || b
->loc
->section
== sal
.section
))
6873 /* Yes, if sal.pc matches b (modulo overlays). */
6874 || ((default_match
|| (0 == sal
.pc
))
6875 && b
->source_file
!= NULL
6876 && sal
.symtab
!= NULL
6877 && strcmp (b
->source_file
, sal
.symtab
->filename
) == 0
6878 && b
->line_number
== sal
.line
)))
6879 /* Yes, if sal source file and line matches b. */
6881 /* Remove it from breakpoint_chain... */
6882 if (b
== breakpoint_chain
)
6884 /* b is at the head of the list */
6885 breakpoint_chain
= b
->next
;
6889 prev
->next
= b
->next
;
6891 /* And add it to 'found' chain. */
6897 /* Keep b, and keep a pointer to it. */
6902 /* Now go thru the 'found' chain and delete them. */
6906 error (_("No breakpoint at %s."), arg
);
6908 error (_("No breakpoint at this line."));
6912 from_tty
= 1; /* Always report if deleted more than one */
6916 printf_unfiltered (_("Deleted breakpoint "));
6918 printf_unfiltered (_("Deleted breakpoints "));
6920 breakpoints_changed ();
6924 printf_unfiltered ("%d ", found
->number
);
6926 delete_breakpoint (found
);
6930 putchar_unfiltered ('\n');
6933 /* Delete breakpoint in BS if they are `delete' breakpoints and
6934 all breakpoints that are marked for deletion, whether hit or not.
6935 This is called after any breakpoint is hit, or after errors. */
6938 breakpoint_auto_delete (bpstat bs
)
6940 struct breakpoint
*b
, *temp
;
6942 for (; bs
; bs
= bs
->next
)
6943 if (bs
->breakpoint_at
&& bs
->breakpoint_at
->disposition
== disp_del
6945 delete_breakpoint (bs
->breakpoint_at
);
6947 ALL_BREAKPOINTS_SAFE (b
, temp
)
6949 if (b
->disposition
== disp_del_at_next_stop
)
6950 delete_breakpoint (b
);
6954 /* Delete a breakpoint and clean up all traces of it in the data
6958 delete_breakpoint (struct breakpoint
*bpt
)
6960 struct breakpoint
*b
;
6962 struct bp_location
*loc
;
6964 gdb_assert (bpt
!= NULL
);
6966 /* Has this bp already been deleted? This can happen because multiple
6967 lists can hold pointers to bp's. bpstat lists are especial culprits.
6969 One example of this happening is a watchpoint's scope bp. When the
6970 scope bp triggers, we notice that the watchpoint is out of scope, and
6971 delete it. We also delete its scope bp. But the scope bp is marked
6972 "auto-deleting", and is already on a bpstat. That bpstat is then
6973 checked for auto-deleting bp's, which are deleted.
6975 A real solution to this problem might involve reference counts in bp's,
6976 and/or giving them pointers back to their referencing bpstat's, and
6977 teaching delete_breakpoint to only free a bp's storage when no more
6978 references were extent. A cheaper bandaid was chosen. */
6979 if (bpt
->type
== bp_none
)
6982 if (deprecated_delete_breakpoint_hook
)
6983 deprecated_delete_breakpoint_hook (bpt
);
6984 breakpoint_delete_event (bpt
->number
);
6986 if (bpt
->loc
->inserted
)
6987 remove_breakpoint (bpt
->loc
, mark_inserted
);
6989 free_valchain (bpt
->loc
);
6991 if (breakpoint_chain
== bpt
)
6992 breakpoint_chain
= bpt
->next
;
6994 if (bp_location_chain
== bpt
->loc
)
6995 bp_location_chain
= bpt
->loc
->next
;
6997 /* If we have callback-style exception catchpoints, don't go through
6998 the adjustments to the C++ runtime library etc. if the inferior
6999 isn't actually running. target_enable_exception_callback for a
7000 null target ops vector gives an undesirable error message, so we
7001 check here and avoid it. Since currently (1997-09-17) only HP-UX aCC's
7002 exceptions are supported in this way, it's OK for now. FIXME */
7003 if (ep_is_exception_catchpoint (bpt
) && target_has_execution
)
7005 /* Format possible error msg */
7006 char *message
= xstrprintf ("Error in deleting catchpoint %d:\n",
7008 struct cleanup
*cleanups
= make_cleanup (xfree
, message
);
7009 args_for_catchpoint_enable args
;
7010 args
.kind
= bpt
->type
== bp_catch_catch
?
7011 EX_EVENT_CATCH
: EX_EVENT_THROW
;
7013 catch_errors (cover_target_enable_exception_callback
, &args
,
7014 message
, RETURN_MASK_ALL
);
7015 do_cleanups (cleanups
);
7022 b
->next
= bpt
->next
;
7026 ALL_BP_LOCATIONS (loc
)
7027 if (loc
->next
== bpt
->loc
)
7029 loc
->next
= bpt
->loc
->next
;
7033 check_duplicates (bpt
);
7034 /* If this breakpoint was inserted, and there is another breakpoint
7035 at the same address, we need to insert the other breakpoint. */
7036 if (bpt
->loc
->inserted
7037 && bpt
->type
!= bp_hardware_watchpoint
7038 && bpt
->type
!= bp_read_watchpoint
7039 && bpt
->type
!= bp_access_watchpoint
7040 && bpt
->type
!= bp_catch_fork
7041 && bpt
->type
!= bp_catch_vfork
7042 && bpt
->type
!= bp_catch_exec
)
7045 if (b
->loc
->address
== bpt
->loc
->address
7046 && b
->loc
->section
== bpt
->loc
->section
7047 && !b
->loc
->duplicate
7048 && b
->enable_state
!= bp_disabled
7049 && b
->enable_state
!= bp_shlib_disabled
7051 && b
->enable_state
!= bp_call_disabled
)
7055 /* We should never reach this point if there is a permanent
7056 breakpoint at the same address as the one being deleted.
7057 If there is a permanent breakpoint somewhere, it should
7058 always be the only one inserted. */
7059 if (b
->enable_state
== bp_permanent
)
7060 internal_error (__FILE__
, __LINE__
,
7061 _("another breakpoint was inserted on top of "
7062 "a permanent breakpoint"));
7064 memset (&b
->loc
->target_info
, 0, sizeof (b
->loc
->target_info
));
7065 b
->loc
->target_info
.placed_address
= b
->loc
->address
;
7066 if (b
->type
== bp_hardware_breakpoint
)
7067 val
= target_insert_hw_breakpoint (&b
->loc
->target_info
);
7069 val
= target_insert_breakpoint (&b
->loc
->target_info
);
7071 /* If there was an error in the insert, print a message, then stop execution. */
7074 struct ui_file
*tmp_error_stream
= mem_fileopen ();
7075 make_cleanup_ui_file_delete (tmp_error_stream
);
7078 if (b
->type
== bp_hardware_breakpoint
)
7080 fprintf_unfiltered (tmp_error_stream
,
7081 "Cannot insert hardware breakpoint %d.\n"
7082 "You may have requested too many hardware breakpoints.\n",
7087 fprintf_unfiltered (tmp_error_stream
, "Cannot insert breakpoint %d.\n", b
->number
);
7088 fprintf_filtered (tmp_error_stream
, "Error accessing memory address ");
7089 deprecated_print_address_numeric (b
->loc
->address
, 1, tmp_error_stream
);
7090 fprintf_filtered (tmp_error_stream
, ": %s.\n",
7091 safe_strerror (val
));
7094 fprintf_unfiltered (tmp_error_stream
,"The same program may be running in another process.");
7095 target_terminal_ours_for_output ();
7096 error_stream(tmp_error_stream
);
7099 b
->loc
->inserted
= 1;
7103 free_command_lines (&bpt
->commands
);
7106 if (bpt
->cond_string
!= NULL
)
7107 xfree (bpt
->cond_string
);
7108 if (bpt
->addr_string
!= NULL
)
7109 xfree (bpt
->addr_string
);
7110 if (bpt
->exp
!= NULL
)
7112 if (bpt
->exp_string
!= NULL
)
7113 xfree (bpt
->exp_string
);
7114 if (bpt
->val
!= NULL
)
7115 value_free (bpt
->val
);
7116 if (bpt
->source_file
!= NULL
)
7117 xfree (bpt
->source_file
);
7118 if (bpt
->dll_pathname
!= NULL
)
7119 xfree (bpt
->dll_pathname
);
7120 if (bpt
->triggered_dll_pathname
!= NULL
)
7121 xfree (bpt
->triggered_dll_pathname
);
7122 if (bpt
->exec_pathname
!= NULL
)
7123 xfree (bpt
->exec_pathname
);
7125 /* Be sure no bpstat's are pointing at it after it's been freed. */
7126 /* FIXME, how can we find all bpstat's?
7127 We just check stop_bpstat for now. */
7128 for (bs
= stop_bpstat
; bs
; bs
= bs
->next
)
7129 if (bs
->breakpoint_at
== bpt
)
7131 bs
->breakpoint_at
= NULL
;
7133 /* bs->commands will be freed later. */
7135 /* On the chance that someone will soon try again to delete this same
7136 bp, we mark it as deleted before freeing its storage. */
7137 bpt
->type
= bp_none
;
7144 do_delete_breakpoint_cleanup (void *b
)
7146 delete_breakpoint (b
);
7150 make_cleanup_delete_breakpoint (struct breakpoint
*b
)
7152 return make_cleanup (do_delete_breakpoint_cleanup
, b
);
7156 make_exec_cleanup_delete_breakpoint (struct breakpoint
*b
)
7158 return make_exec_cleanup (do_delete_breakpoint_cleanup
, b
);
7162 delete_command (char *arg
, int from_tty
)
7164 struct breakpoint
*b
, *temp
;
7170 int breaks_to_delete
= 0;
7172 /* Delete all breakpoints if no argument.
7173 Do not delete internal or call-dummy breakpoints, these
7174 have to be deleted with an explicit breakpoint number argument. */
7177 if (b
->type
!= bp_call_dummy
&&
7178 b
->type
!= bp_shlib_event
&&
7179 b
->type
!= bp_thread_event
&&
7180 b
->type
!= bp_overlay_event
&&
7183 breaks_to_delete
= 1;
7188 /* Ask user only if there are some breakpoints to delete. */
7190 || (breaks_to_delete
&& query (_("Delete all breakpoints? "))))
7192 ALL_BREAKPOINTS_SAFE (b
, temp
)
7194 if (b
->type
!= bp_call_dummy
&&
7195 b
->type
!= bp_shlib_event
&&
7196 b
->type
!= bp_thread_event
&&
7197 b
->type
!= bp_overlay_event
&&
7199 delete_breakpoint (b
);
7204 map_breakpoint_numbers (arg
, delete_breakpoint
);
7207 /* Reset a breakpoint given it's struct breakpoint * BINT.
7208 The value we return ends up being the return value from catch_errors.
7209 Unused in this case. */
7212 breakpoint_re_set_one (void *bint
)
7214 /* get past catch_errs */
7215 struct breakpoint
*b
= (struct breakpoint
*) bint
;
7219 int *not_found_ptr
= NULL
;
7220 struct symtabs_and_lines sals
;
7222 enum enable_state save_enable
;
7227 warning (_("attempted to reset apparently deleted breakpoint #%d?"),
7231 case bp_hardware_breakpoint
:
7233 case bp_catch_unload
:
7234 if (b
->addr_string
== NULL
)
7236 /* Anything without a string can't be re-set. */
7237 delete_breakpoint (b
);
7240 /* HACK: cagney/2001-11-11: kettenis/2001-11-11: MarkK wrote:
7242 ``And a hack it is, although Apple's Darwin version of GDB
7243 contains an almost identical hack to implement a "future
7244 break" command. It seems to work in many real world cases,
7245 but it is easy to come up with a test case where the patch
7246 doesn't help at all.''
7248 ``It seems that the way GDB implements breakpoints - in -
7249 shared - libraries was designed for a.out shared library
7250 systems (SunOS 4) where shared libraries were loaded at a
7251 fixed address in memory. Since ELF shared libraries can (and
7252 will) be loaded at any address in memory, things break.
7253 Fixing this is not trivial. Therefore, I'm not sure whether
7254 we should add this hack to the branch only. I cannot
7255 guarantee that things will be fixed on the trunk in the near
7258 In case we have a problem, disable this breakpoint. We'll
7259 restore its status if we succeed. Don't disable a
7260 shlib_disabled breakpoint though. There's a fair chance we
7261 can't re-set it if the shared library it's in hasn't been
7267 save_enable
= b
->enable_state
;
7268 if (b
->enable_state
!= bp_shlib_disabled
)
7269 b
->enable_state
= bp_disabled
;
7271 /* If resetting a shlib-disabled breakpoint, we don't want to
7272 see an error message if it is not found since we will expect
7273 this to occur until the shared library is finally reloaded.
7274 We accomplish this by giving decode_line_1 a pointer to use
7275 for silent notification that the symbol is not found. */
7276 not_found_ptr
= ¬_found
;
7278 set_language (b
->language
);
7279 input_radix
= b
->input_radix
;
7281 sals
= decode_line_1 (&s
, 1, (struct symtab
*) NULL
, 0, (char ***) NULL
,
7283 for (i
= 0; i
< sals
.nelts
; i
++)
7285 resolve_sal_pc (&sals
.sals
[i
]);
7287 /* Reparse conditions, they might contain references to the
7289 if (b
->cond_string
!= NULL
)
7295 /* Avoid re-freeing b->exp if an error during the call
7299 b
->cond
= parse_exp_1 (&s
, block_for_pc (sals
.sals
[i
].pc
), 0);
7302 /* We need to re-set the breakpoint if the address changes... */
7303 if (b
->loc
->address
!= sals
.sals
[i
].pc
7304 /* ...or new and old breakpoints both have source files, and
7305 the source file name or the line number changes... */
7306 || (b
->source_file
!= NULL
7307 && sals
.sals
[i
].symtab
!= NULL
7308 && (strcmp (b
->source_file
, sals
.sals
[i
].symtab
->filename
) != 0
7309 || b
->line_number
!= sals
.sals
[i
].line
)
7311 /* ...or we switch between having a source file and not having
7313 || ((b
->source_file
== NULL
) != (sals
.sals
[i
].symtab
== NULL
))
7316 if (b
->source_file
!= NULL
)
7317 xfree (b
->source_file
);
7318 if (sals
.sals
[i
].symtab
== NULL
)
7319 b
->source_file
= NULL
;
7322 savestring (sals
.sals
[i
].symtab
->filename
,
7323 strlen (sals
.sals
[i
].symtab
->filename
));
7324 b
->line_number
= sals
.sals
[i
].line
;
7325 b
->loc
->requested_address
= sals
.sals
[i
].pc
;
7327 = adjust_breakpoint_address (b
->loc
->requested_address
,
7330 /* Used to check for duplicates here, but that can
7331 cause trouble, as it doesn't check for disabled
7336 /* Might be better to do this just once per breakpoint_re_set,
7337 rather than once for every breakpoint. */
7338 breakpoints_changed ();
7340 b
->loc
->section
= sals
.sals
[i
].section
;
7341 b
->enable_state
= save_enable
; /* Restore it, this worked. */
7344 /* Now that this is re-enabled, check_duplicates
7346 check_duplicates (b
);
7353 case bp_hardware_watchpoint
:
7354 case bp_read_watchpoint
:
7355 case bp_access_watchpoint
:
7356 innermost_block
= NULL
;
7357 /* The issue arises of what context to evaluate this in. The
7358 same one as when it was set, but what does that mean when
7359 symbols have been re-read? We could save the filename and
7360 functionname, but if the context is more local than that, the
7361 best we could do would be something like how many levels deep
7362 and which index at that particular level, but that's going to
7363 be less stable than filenames or function names. */
7365 /* So for now, just use a global context. */
7369 /* Avoid re-freeing b->exp if an error during the call to
7370 parse_expression. */
7373 b
->exp
= parse_expression (b
->exp_string
);
7374 b
->exp_valid_block
= innermost_block
;
7375 mark
= value_mark ();
7378 value_free (b
->val
);
7379 /* Avoid re-freeing b->val if an error during the call to
7380 evaluate_expression. */
7383 b
->val
= evaluate_expression (b
->exp
);
7384 release_value (b
->val
);
7385 if (value_lazy (b
->val
) && breakpoint_enabled (b
))
7386 value_fetch_lazy (b
->val
);
7388 if (b
->cond_string
!= NULL
)
7394 /* Avoid re-freeing b->exp if an error during the call
7398 b
->cond
= parse_exp_1 (&s
, (struct block
*) 0, 0);
7400 if (breakpoint_enabled (b
))
7402 value_free_to_mark (mark
);
7404 case bp_catch_catch
:
7405 case bp_catch_throw
:
7407 /* We needn't really do anything to reset these, since the mask
7408 that requests them is unaffected by e.g., new libraries being
7411 case bp_catch_vfork
:
7416 printf_filtered (_("Deleting unknown breakpoint type %d\n"), b
->type
);
7418 /* Delete longjmp and overlay event breakpoints; they will be
7419 reset later by breakpoint_re_set. */
7421 case bp_longjmp_resume
:
7422 case bp_overlay_event
:
7423 delete_breakpoint (b
);
7426 /* This breakpoint is special, it's set up when the inferior
7427 starts and we really don't want to touch it. */
7428 case bp_shlib_event
:
7430 /* Like bp_shlib_event, this breakpoint type is special.
7431 Once it is set up, we do not want to touch it. */
7432 case bp_thread_event
:
7434 /* Keep temporary breakpoints, which can be encountered when we step
7435 over a dlopen call and SOLIB_ADD is resetting the breakpoints.
7436 Otherwise these should have been blown away via the cleanup chain
7437 or by breakpoint_init_inferior when we rerun the executable. */
7440 case bp_watchpoint_scope
:
7442 case bp_step_resume
:
7449 /* Re-set all breakpoints after symbols have been re-loaded. */
7451 breakpoint_re_set (void)
7453 struct breakpoint
*b
, *temp
;
7454 enum language save_language
;
7455 int save_input_radix
;
7457 save_language
= current_language
->la_language
;
7458 save_input_radix
= input_radix
;
7459 ALL_BREAKPOINTS_SAFE (b
, temp
)
7461 /* Format possible error msg */
7462 char *message
= xstrprintf ("Error in re-setting breakpoint %d:\n",
7464 struct cleanup
*cleanups
= make_cleanup (xfree
, message
);
7465 catch_errors (breakpoint_re_set_one
, b
, message
, RETURN_MASK_ALL
);
7466 do_cleanups (cleanups
);
7468 set_language (save_language
);
7469 input_radix
= save_input_radix
;
7471 if (GET_LONGJMP_TARGET_P ())
7473 create_longjmp_breakpoint ("longjmp");
7474 create_longjmp_breakpoint ("_longjmp");
7475 create_longjmp_breakpoint ("siglongjmp");
7476 create_longjmp_breakpoint ("_siglongjmp");
7477 create_longjmp_breakpoint (NULL
);
7480 create_overlay_event_breakpoint ("_ovly_debug_event");
7483 /* Reset the thread number of this breakpoint:
7485 - If the breakpoint is for all threads, leave it as-is.
7486 - Else, reset it to the current thread for inferior_ptid. */
7488 breakpoint_re_set_thread (struct breakpoint
*b
)
7490 if (b
->thread
!= -1)
7492 if (in_thread_list (inferior_ptid
))
7493 b
->thread
= pid_to_thread_id (inferior_ptid
);
7497 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
7498 If from_tty is nonzero, it prints a message to that effect,
7499 which ends with a period (no newline). */
7502 set_ignore_count (int bptnum
, int count
, int from_tty
)
7504 struct breakpoint
*b
;
7510 if (b
->number
== bptnum
)
7512 b
->ignore_count
= count
;
7516 printf_filtered (_("Will stop next time breakpoint %d is reached."),
7518 else if (count
== 1)
7519 printf_filtered (_("Will ignore next crossing of breakpoint %d."),
7522 printf_filtered (_("Will ignore next %d crossings of breakpoint %d."),
7525 breakpoints_changed ();
7526 breakpoint_modify_event (b
->number
);
7530 error (_("No breakpoint number %d."), bptnum
);
7533 /* Clear the ignore counts of all breakpoints. */
7535 breakpoint_clear_ignore_counts (void)
7537 struct breakpoint
*b
;
7540 b
->ignore_count
= 0;
7543 /* Command to set ignore-count of breakpoint N to COUNT. */
7546 ignore_command (char *args
, int from_tty
)
7552 error_no_arg (_("a breakpoint number"));
7554 num
= get_number (&p
);
7556 error (_("bad breakpoint number: '%s'"), args
);
7558 error (_("Second argument (specified ignore-count) is missing."));
7560 set_ignore_count (num
,
7561 longest_to_int (value_as_long (parse_and_eval (p
))),
7564 printf_filtered ("\n");
7567 /* Call FUNCTION on each of the breakpoints
7568 whose numbers are given in ARGS. */
7571 map_breakpoint_numbers (char *args
, void (*function
) (struct breakpoint
*))
7576 struct breakpoint
*b
, *tmp
;
7580 error_no_arg (_("one or more breakpoint numbers"));
7587 num
= get_number_or_range (&p1
);
7590 warning (_("bad breakpoint number at or near '%s'"), p
);
7594 ALL_BREAKPOINTS_SAFE (b
, tmp
)
7595 if (b
->number
== num
)
7597 struct breakpoint
*related_breakpoint
= b
->related_breakpoint
;
7600 if (related_breakpoint
)
7601 function (related_breakpoint
);
7605 printf_unfiltered (_("No breakpoint number %d.\n"), num
);
7611 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
7612 If from_tty is nonzero, it prints a message to that effect,
7613 which ends with a period (no newline). */
7616 disable_breakpoint (struct breakpoint
*bpt
)
7618 /* Never disable a watchpoint scope breakpoint; we want to
7619 hit them when we leave scope so we can delete both the
7620 watchpoint and its scope breakpoint at that time. */
7621 if (bpt
->type
== bp_watchpoint_scope
)
7624 /* You can't disable permanent breakpoints. */
7625 if (bpt
->enable_state
== bp_permanent
)
7628 bpt
->enable_state
= bp_disabled
;
7630 check_duplicates (bpt
);
7632 if (deprecated_modify_breakpoint_hook
)
7633 deprecated_modify_breakpoint_hook (bpt
);
7634 breakpoint_modify_event (bpt
->number
);
7638 disable_command (char *args
, int from_tty
)
7640 struct breakpoint
*bpt
;
7642 ALL_BREAKPOINTS (bpt
)
7646 warning (_("attempted to disable apparently deleted breakpoint #%d?"),
7651 case bp_catch_unload
:
7653 case bp_catch_vfork
:
7655 case bp_catch_catch
:
7656 case bp_catch_throw
:
7657 case bp_hardware_breakpoint
:
7659 case bp_hardware_watchpoint
:
7660 case bp_read_watchpoint
:
7661 case bp_access_watchpoint
:
7662 disable_breakpoint (bpt
);
7667 map_breakpoint_numbers (args
, disable_breakpoint
);
7671 do_enable_breakpoint (struct breakpoint
*bpt
, enum bpdisp disposition
)
7673 int target_resources_ok
, other_type_used
;
7676 if (bpt
->type
== bp_hardware_breakpoint
)
7679 i
= hw_breakpoint_used_count ();
7680 target_resources_ok
=
7681 TARGET_CAN_USE_HARDWARE_WATCHPOINT (bp_hardware_breakpoint
,
7683 if (target_resources_ok
== 0)
7684 error (_("No hardware breakpoint support in the target."));
7685 else if (target_resources_ok
< 0)
7686 error (_("Hardware breakpoints used exceeds limit."));
7691 if (bpt
->enable_state
!= bp_enabled
)
7693 /* When enabling a pending breakpoint, we need to check if the breakpoint
7694 is resolvable since shared libraries could have been loaded
7695 after the breakpoint was disabled. */
7696 breakpoints_changed ();
7697 if (resolve_pending_breakpoint (bpt
) == GDB_RC_OK
)
7699 delete_breakpoint (bpt
);
7702 bpt
->enable_state
= bp_enabled
;
7703 bpt
->disposition
= disposition
;
7706 else /* Not a pending breakpoint. */
7708 if (bpt
->enable_state
!= bp_permanent
)
7709 bpt
->enable_state
= bp_enabled
;
7710 bpt
->disposition
= disposition
;
7711 check_duplicates (bpt
);
7712 breakpoints_changed ();
7714 if (bpt
->type
== bp_watchpoint
||
7715 bpt
->type
== bp_hardware_watchpoint
||
7716 bpt
->type
== bp_read_watchpoint
||
7717 bpt
->type
== bp_access_watchpoint
)
7719 struct frame_id saved_frame_id
;
7721 saved_frame_id
= get_frame_id (get_selected_frame (NULL
));
7722 if (bpt
->exp_valid_block
!= NULL
)
7724 struct frame_info
*fr
=
7725 fr
= frame_find_by_id (bpt
->watchpoint_frame
);
7728 printf_filtered (_("\
7729 Cannot enable watchpoint %d because the block in which its expression\n\
7730 is valid is not currently in scope.\n"), bpt
->number
);
7731 bpt
->enable_state
= bp_disabled
;
7737 value_free (bpt
->val
);
7738 mark
= value_mark ();
7739 bpt
->val
= evaluate_expression (bpt
->exp
);
7740 release_value (bpt
->val
);
7741 if (value_lazy (bpt
->val
))
7742 value_fetch_lazy (bpt
->val
);
7744 if (bpt
->type
== bp_hardware_watchpoint
||
7745 bpt
->type
== bp_read_watchpoint
||
7746 bpt
->type
== bp_access_watchpoint
)
7748 int i
= hw_watchpoint_used_count (bpt
->type
, &other_type_used
);
7749 int mem_cnt
= can_use_hardware_watchpoint (bpt
->val
);
7751 /* Hack around 'unused var' error for some targets here */
7752 (void) mem_cnt
, (void) i
;
7753 target_resources_ok
= TARGET_CAN_USE_HARDWARE_WATCHPOINT (
7754 bpt
->type
, i
+ mem_cnt
, other_type_used
);
7755 /* we can consider of type is bp_hardware_watchpoint, convert to
7756 bp_watchpoint in the following condition */
7757 if (target_resources_ok
< 0)
7759 printf_filtered (_("\
7760 Cannot enable watchpoint %d because target watch resources\n\
7761 have been allocated for other watchpoints.\n"), bpt
->number
);
7762 bpt
->enable_state
= bp_disabled
;
7763 value_free_to_mark (mark
);
7768 select_frame (frame_find_by_id (saved_frame_id
));
7769 value_free_to_mark (mark
);
7773 if (deprecated_modify_breakpoint_hook
)
7774 deprecated_modify_breakpoint_hook (bpt
);
7775 breakpoint_modify_event (bpt
->number
);
7779 enable_breakpoint (struct breakpoint
*bpt
)
7781 do_enable_breakpoint (bpt
, bpt
->disposition
);
7784 /* The enable command enables the specified breakpoints (or all defined
7785 breakpoints) so they once again become (or continue to be) effective
7786 in stopping the inferior. */
7789 enable_command (char *args
, int from_tty
)
7791 struct breakpoint
*bpt
;
7793 ALL_BREAKPOINTS (bpt
)
7797 warning (_("attempted to enable apparently deleted breakpoint #%d?"),
7802 case bp_catch_unload
:
7804 case bp_catch_vfork
:
7806 case bp_catch_catch
:
7807 case bp_catch_throw
:
7808 case bp_hardware_breakpoint
:
7810 case bp_hardware_watchpoint
:
7811 case bp_read_watchpoint
:
7812 case bp_access_watchpoint
:
7813 enable_breakpoint (bpt
);
7818 map_breakpoint_numbers (args
, enable_breakpoint
);
7822 enable_once_breakpoint (struct breakpoint
*bpt
)
7824 do_enable_breakpoint (bpt
, disp_disable
);
7828 enable_once_command (char *args
, int from_tty
)
7830 map_breakpoint_numbers (args
, enable_once_breakpoint
);
7834 enable_delete_breakpoint (struct breakpoint
*bpt
)
7836 do_enable_breakpoint (bpt
, disp_del
);
7840 enable_delete_command (char *args
, int from_tty
)
7842 map_breakpoint_numbers (args
, enable_delete_breakpoint
);
7846 set_breakpoint_cmd (char *args
, int from_tty
)
7851 show_breakpoint_cmd (char *args
, int from_tty
)
7855 /* Use default_breakpoint_'s, or nothing if they aren't valid. */
7857 struct symtabs_and_lines
7858 decode_line_spec_1 (char *string
, int funfirstline
)
7860 struct symtabs_and_lines sals
;
7862 error (_("Empty line specification."));
7863 if (default_breakpoint_valid
)
7864 sals
= decode_line_1 (&string
, funfirstline
,
7865 default_breakpoint_symtab
,
7866 default_breakpoint_line
,
7867 (char ***) NULL
, NULL
);
7869 sals
= decode_line_1 (&string
, funfirstline
,
7870 (struct symtab
*) NULL
, 0, (char ***) NULL
, NULL
);
7872 error (_("Junk at end of line specification: %s"), string
);
7876 /* Create and insert a raw software breakpoint at PC. Return an
7877 identifier, which should be used to remove the breakpoint later.
7878 In general, places which call this should be using something on the
7879 breakpoint chain instead; this function should be eliminated
7883 deprecated_insert_raw_breakpoint (CORE_ADDR pc
)
7885 struct bp_target_info
*bp_tgt
;
7887 bp_tgt
= xmalloc (sizeof (struct bp_target_info
));
7888 memset (bp_tgt
, 0, sizeof (struct bp_target_info
));
7890 bp_tgt
->placed_address
= pc
;
7891 if (target_insert_breakpoint (bp_tgt
) != 0)
7893 /* Could not insert the breakpoint. */
7901 /* Remove a breakpoint BP inserted by deprecated_insert_raw_breakpoint. */
7904 deprecated_remove_raw_breakpoint (void *bp
)
7906 struct bp_target_info
*bp_tgt
= bp
;
7909 ret
= target_remove_breakpoint (bp_tgt
);
7915 /* One (or perhaps two) breakpoints used for software single stepping. */
7917 static void *single_step_breakpoints
[2];
7919 /* Create and insert a breakpoint for software single step. */
7922 insert_single_step_breakpoint (CORE_ADDR next_pc
)
7926 if (single_step_breakpoints
[0] == NULL
)
7927 bpt_p
= &single_step_breakpoints
[0];
7930 gdb_assert (single_step_breakpoints
[1] == NULL
);
7931 bpt_p
= &single_step_breakpoints
[1];
7934 /* NOTE drow/2006-04-11: A future improvement to this function would be
7935 to only create the breakpoints once, and actually put them on the
7936 breakpoint chain. That would let us use set_raw_breakpoint. We could
7937 adjust the addresses each time they were needed. Doing this requires
7938 corresponding changes elsewhere where single step breakpoints are
7939 handled, however. So, for now, we use this. */
7941 *bpt_p
= deprecated_insert_raw_breakpoint (next_pc
);
7943 error (_("Could not insert single-step breakpoint at 0x%s"),
7944 paddr_nz (next_pc
));
7947 /* Remove and delete any breakpoints used for software single step. */
7950 remove_single_step_breakpoints (void)
7952 gdb_assert (single_step_breakpoints
[0] != NULL
);
7954 /* See insert_single_step_breakpoint for more about this deprecated
7956 deprecated_remove_raw_breakpoint (single_step_breakpoints
[0]);
7957 single_step_breakpoints
[0] = NULL
;
7959 if (single_step_breakpoints
[1] != NULL
)
7961 deprecated_remove_raw_breakpoint (single_step_breakpoints
[1]);
7962 single_step_breakpoints
[1] = NULL
;
7967 /* This help string is used for the break, hbreak, tbreak and thbreak commands.
7968 It is defined as a macro to prevent duplication.
7969 COMMAND should be a string constant containing the name of the command. */
7970 #define BREAK_ARGS_HELP(command) \
7971 command" [LOCATION] [thread THREADNUM] [if CONDITION]\n\
7972 LOCATION may be a line number, function name, or \"*\" and an address.\n\
7973 If a line number is specified, break at start of code for that line.\n\
7974 If a function is specified, break at start of code for that function.\n\
7975 If an address is specified, break at that exact address.\n\
7976 With no LOCATION, uses current execution address of selected stack frame.\n\
7977 This is useful for breaking on return to a stack frame.\n\
7979 THREADNUM is the number from \"info threads\".\n\
7980 CONDITION is a boolean expression.\n\
7982 Multiple breakpoints at one place are permitted, and useful if conditional.\n\
7984 Do \"help breakpoints\" for info on other commands dealing with breakpoints."
7987 _initialize_breakpoint (void)
7989 static struct cmd_list_element
*breakpoint_set_cmdlist
;
7990 static struct cmd_list_element
*breakpoint_show_cmdlist
;
7991 struct cmd_list_element
*c
;
7993 observer_attach_solib_unloaded (disable_breakpoints_in_unloaded_shlib
);
7995 breakpoint_chain
= 0;
7996 /* Don't bother to call set_breakpoint_count. $bpnum isn't useful
7997 before a breakpoint is set. */
7998 breakpoint_count
= 0;
8000 add_com ("ignore", class_breakpoint
, ignore_command
, _("\
8001 Set ignore-count of breakpoint number N to COUNT.\n\
8002 Usage is `ignore N COUNT'."));
8004 add_com_alias ("bc", "ignore", class_breakpoint
, 1);
8006 add_com ("commands", class_breakpoint
, commands_command
, _("\
8007 Set commands to be executed when a breakpoint is hit.\n\
8008 Give breakpoint number as argument after \"commands\".\n\
8009 With no argument, the targeted breakpoint is the last one set.\n\
8010 The commands themselves follow starting on the next line.\n\
8011 Type a line containing \"end\" to indicate the end of them.\n\
8012 Give \"silent\" as the first line to make the breakpoint silent;\n\
8013 then no output is printed when it is hit, except what the commands print."));
8015 add_com ("condition", class_breakpoint
, condition_command
, _("\
8016 Specify breakpoint number N to break only if COND is true.\n\
8017 Usage is `condition N COND', where N is an integer and COND is an\n\
8018 expression to be evaluated whenever breakpoint N is reached."));
8020 c
= add_com ("tbreak", class_breakpoint
, tbreak_command
, _("\
8021 Set a temporary breakpoint.\n\
8022 Like \"break\" except the breakpoint is only temporary,\n\
8023 so it will be deleted when hit. Equivalent to \"break\" followed\n\
8024 by using \"enable delete\" on the breakpoint number.\n\
8026 BREAK_ARGS_HELP ("tbreak")));
8027 set_cmd_completer (c
, location_completer
);
8029 c
= add_com ("hbreak", class_breakpoint
, hbreak_command
, _("\
8030 Set a hardware assisted breakpoint.\n\
8031 Like \"break\" except the breakpoint requires hardware support,\n\
8032 some target hardware may not have this support.\n\
8034 BREAK_ARGS_HELP ("hbreak")));
8035 set_cmd_completer (c
, location_completer
);
8037 c
= add_com ("thbreak", class_breakpoint
, thbreak_command
, _("\
8038 Set a temporary hardware assisted breakpoint.\n\
8039 Like \"hbreak\" except the breakpoint is only temporary,\n\
8040 so it will be deleted when hit.\n\
8042 BREAK_ARGS_HELP ("thbreak")));
8043 set_cmd_completer (c
, location_completer
);
8045 add_prefix_cmd ("enable", class_breakpoint
, enable_command
, _("\
8046 Enable some breakpoints.\n\
8047 Give breakpoint numbers (separated by spaces) as arguments.\n\
8048 With no subcommand, breakpoints are enabled until you command otherwise.\n\
8049 This is used to cancel the effect of the \"disable\" command.\n\
8050 With a subcommand you can enable temporarily."),
8051 &enablelist
, "enable ", 1, &cmdlist
);
8053 add_com ("ab", class_breakpoint
, enable_command
, _("\
8054 Enable some breakpoints.\n\
8055 Give breakpoint numbers (separated by spaces) as arguments.\n\
8056 With no subcommand, breakpoints are enabled until you command otherwise.\n\
8057 This is used to cancel the effect of the \"disable\" command.\n\
8058 With a subcommand you can enable temporarily."));
8060 add_com_alias ("en", "enable", class_breakpoint
, 1);
8062 add_abbrev_prefix_cmd ("breakpoints", class_breakpoint
, enable_command
, _("\
8063 Enable some breakpoints.\n\
8064 Give breakpoint numbers (separated by spaces) as arguments.\n\
8065 This is used to cancel the effect of the \"disable\" command.\n\
8066 May be abbreviated to simply \"enable\".\n"),
8067 &enablebreaklist
, "enable breakpoints ", 1, &enablelist
);
8069 add_cmd ("once", no_class
, enable_once_command
, _("\
8070 Enable breakpoints for one hit. Give breakpoint numbers.\n\
8071 If a breakpoint is hit while enabled in this fashion, it becomes disabled."),
8074 add_cmd ("delete", no_class
, enable_delete_command
, _("\
8075 Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
8076 If a breakpoint is hit while enabled in this fashion, it is deleted."),
8079 add_cmd ("delete", no_class
, enable_delete_command
, _("\
8080 Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
8081 If a breakpoint is hit while enabled in this fashion, it is deleted."),
8084 add_cmd ("once", no_class
, enable_once_command
, _("\
8085 Enable breakpoints for one hit. Give breakpoint numbers.\n\
8086 If a breakpoint is hit while enabled in this fashion, it becomes disabled."),
8089 add_prefix_cmd ("disable", class_breakpoint
, disable_command
, _("\
8090 Disable some breakpoints.\n\
8091 Arguments are breakpoint numbers with spaces in between.\n\
8092 To disable all breakpoints, give no argument.\n\
8093 A disabled breakpoint is not forgotten, but has no effect until reenabled."),
8094 &disablelist
, "disable ", 1, &cmdlist
);
8095 add_com_alias ("dis", "disable", class_breakpoint
, 1);
8096 add_com_alias ("disa", "disable", class_breakpoint
, 1);
8098 add_com ("sb", class_breakpoint
, disable_command
, _("\
8099 Disable some breakpoints.\n\
8100 Arguments are breakpoint numbers with spaces in between.\n\
8101 To disable all breakpoints, give no argument.\n\
8102 A disabled breakpoint is not forgotten, but has no effect until reenabled."));
8104 add_cmd ("breakpoints", class_alias
, disable_command
, _("\
8105 Disable some breakpoints.\n\
8106 Arguments are breakpoint numbers with spaces in between.\n\
8107 To disable all breakpoints, give no argument.\n\
8108 A disabled breakpoint is not forgotten, but has no effect until reenabled.\n\
8109 This command may be abbreviated \"disable\"."),
8112 add_prefix_cmd ("delete", class_breakpoint
, delete_command
, _("\
8113 Delete some breakpoints or auto-display expressions.\n\
8114 Arguments are breakpoint numbers with spaces in between.\n\
8115 To delete all breakpoints, give no argument.\n\
8117 Also a prefix command for deletion of other GDB objects.\n\
8118 The \"unset\" command is also an alias for \"delete\"."),
8119 &deletelist
, "delete ", 1, &cmdlist
);
8120 add_com_alias ("d", "delete", class_breakpoint
, 1);
8121 add_com_alias ("del", "delete", class_breakpoint
, 1);
8123 add_com ("db", class_breakpoint
, delete_command
, _("\
8124 Delete some breakpoints.\n\
8125 Arguments are breakpoint numbers with spaces in between.\n\
8126 To delete all breakpoints, give no argument.\n"));
8128 add_cmd ("breakpoints", class_alias
, delete_command
, _("\
8129 Delete some breakpoints or auto-display expressions.\n\
8130 Arguments are breakpoint numbers with spaces in between.\n\
8131 To delete all breakpoints, give no argument.\n\
8132 This command may be abbreviated \"delete\"."),
8135 add_com ("clear", class_breakpoint
, clear_command
, _("\
8136 Clear breakpoint at specified line or function.\n\
8137 Argument may be line number, function name, or \"*\" and an address.\n\
8138 If line number is specified, all breakpoints in that line are cleared.\n\
8139 If function is specified, breakpoints at beginning of function are cleared.\n\
8140 If an address is specified, breakpoints at that address are cleared.\n\
8142 With no argument, clears all breakpoints in the line that the selected frame\n\
8145 See also the \"delete\" command which clears breakpoints by number."));
8147 c
= add_com ("break", class_breakpoint
, break_command
, _("\
8148 Set breakpoint at specified line or function.\n"
8149 BREAK_ARGS_HELP ("break")));
8150 set_cmd_completer (c
, location_completer
);
8152 add_com_alias ("b", "break", class_run
, 1);
8153 add_com_alias ("br", "break", class_run
, 1);
8154 add_com_alias ("bre", "break", class_run
, 1);
8155 add_com_alias ("brea", "break", class_run
, 1);
8159 add_com_alias ("ba", "break", class_breakpoint
, 1);
8160 add_com_alias ("bu", "ubreak", class_breakpoint
, 1);
8165 add_abbrev_prefix_cmd ("stop", class_breakpoint
, stop_command
, _("\
8166 Break in function/address or break at a line in the current file."),
8167 &stoplist
, "stop ", 1, &cmdlist
);
8168 add_cmd ("in", class_breakpoint
, stopin_command
,
8169 _("Break in function or address."), &stoplist
);
8170 add_cmd ("at", class_breakpoint
, stopat_command
,
8171 _("Break at a line in the current file."), &stoplist
);
8172 add_com ("status", class_info
, breakpoints_info
, _("\
8173 Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
8174 The \"Type\" column indicates one of:\n\
8175 \tbreakpoint - normal breakpoint\n\
8176 \twatchpoint - watchpoint\n\
8177 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
8178 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
8179 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
8180 address and file/line number respectively.\n\
8182 Convenience variable \"$_\" and default examine address for \"x\"\n\
8183 are set to the address of the last breakpoint listed.\n\n\
8184 Convenience variable \"$bpnum\" contains the number of the last\n\
8188 add_info ("breakpoints", breakpoints_info
, _("\
8189 Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
8190 The \"Type\" column indicates one of:\n\
8191 \tbreakpoint - normal breakpoint\n\
8192 \twatchpoint - watchpoint\n\
8193 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
8194 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
8195 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
8196 address and file/line number respectively.\n\
8198 Convenience variable \"$_\" and default examine address for \"x\"\n\
8199 are set to the address of the last breakpoint listed.\n\n\
8200 Convenience variable \"$bpnum\" contains the number of the last\n\
8204 add_com ("lb", class_breakpoint
, breakpoints_info
, _("\
8205 Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
8206 The \"Type\" column indicates one of:\n\
8207 \tbreakpoint - normal breakpoint\n\
8208 \twatchpoint - watchpoint\n\
8209 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
8210 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
8211 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
8212 address and file/line number respectively.\n\
8214 Convenience variable \"$_\" and default examine address for \"x\"\n\
8215 are set to the address of the last breakpoint listed.\n\n\
8216 Convenience variable \"$bpnum\" contains the number of the last\n\
8219 add_cmd ("breakpoints", class_maintenance
, maintenance_info_breakpoints
, _("\
8220 Status of all breakpoints, or breakpoint number NUMBER.\n\
8221 The \"Type\" column indicates one of:\n\
8222 \tbreakpoint - normal breakpoint\n\
8223 \twatchpoint - watchpoint\n\
8224 \tlongjmp - internal breakpoint used to step through longjmp()\n\
8225 \tlongjmp resume - internal breakpoint at the target of longjmp()\n\
8226 \tuntil - internal breakpoint used by the \"until\" command\n\
8227 \tfinish - internal breakpoint used by the \"finish\" command\n\
8228 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
8229 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
8230 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
8231 address and file/line number respectively.\n\
8233 Convenience variable \"$_\" and default examine address for \"x\"\n\
8234 are set to the address of the last breakpoint listed.\n\
8236 Convenience variable \"$bpnum\" contains the number of the last\n\
8238 &maintenanceinfolist
);
8240 add_com ("catch", class_breakpoint
, catch_command
, _("\
8241 Set catchpoints to catch events.\n\
8242 Raised signals may be caught:\n\
8243 \tcatch signal - all signals\n\
8244 \tcatch signal <signame> - a particular signal\n\
8245 Raised exceptions may be caught:\n\
8246 \tcatch throw - all exceptions, when thrown\n\
8247 \tcatch throw <exceptname> - a particular exception, when thrown\n\
8248 \tcatch catch - all exceptions, when caught\n\
8249 \tcatch catch <exceptname> - a particular exception, when caught\n\
8250 Thread or process events may be caught:\n\
8251 \tcatch thread_start - any threads, just after creation\n\
8252 \tcatch thread_exit - any threads, just before expiration\n\
8253 \tcatch thread_join - any threads, just after joins\n\
8254 Process events may be caught:\n\
8255 \tcatch start - any processes, just after creation\n\
8256 \tcatch exit - any processes, just before expiration\n\
8257 \tcatch fork - calls to fork()\n\
8258 \tcatch vfork - calls to vfork()\n\
8259 \tcatch exec - calls to exec()\n\
8260 Dynamically-linked library events may be caught:\n\
8261 \tcatch load - loads of any library\n\
8262 \tcatch load <libname> - loads of a particular library\n\
8263 \tcatch unload - unloads of any library\n\
8264 \tcatch unload <libname> - unloads of a particular library\n\
8265 The act of your program's execution stopping may also be caught:\n\
8267 C++ exceptions may be caught:\n\
8268 \tcatch throw - all exceptions, when thrown\n\
8269 \tcatch catch - all exceptions, when caught\n\
8270 Ada exceptions may be caught:\n\
8271 \tcatch exception - all exceptions, when raised\n\
8272 \tcatch exception <name> - a particular exception, when raised\n\
8273 \tcatch exception unhandled - all unhandled exceptions, when raised\n\
8274 \tcatch assert - all failed assertions, when raised\n\
8276 Do \"help set follow-fork-mode\" for info on debugging your program\n\
8277 after a fork or vfork is caught.\n\n\
8278 Do \"help breakpoints\" for info on other commands dealing with breakpoints."));
8280 add_com ("tcatch", class_breakpoint
, tcatch_command
, _("\
8281 Set temporary catchpoints to catch events.\n\
8282 Args like \"catch\" command.\n\
8283 Like \"catch\" except the catchpoint is only temporary,\n\
8284 so it will be deleted when hit. Equivalent to \"catch\" followed\n\
8285 by using \"enable delete\" on the catchpoint number."));
8287 c
= add_com ("watch", class_breakpoint
, watch_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 changes."));
8291 set_cmd_completer (c
, location_completer
);
8293 c
= add_com ("rwatch", class_breakpoint
, rwatch_command
, _("\
8294 Set a read watchpoint for an expression.\n\
8295 A watchpoint stops execution of your program whenever the value of\n\
8296 an expression is read."));
8297 set_cmd_completer (c
, location_completer
);
8299 c
= add_com ("awatch", class_breakpoint
, awatch_command
, _("\
8300 Set a watchpoint for an expression.\n\
8301 A watchpoint stops execution of your program whenever the value of\n\
8302 an expression is either read or written."));
8303 set_cmd_completer (c
, location_completer
);
8305 add_info ("watchpoints", breakpoints_info
,
8306 _("Synonym for ``info breakpoints''."));
8309 /* XXX: cagney/2005-02-23: This should be a boolean, and should
8310 respond to changes - contrary to the description. */
8311 add_setshow_zinteger_cmd ("can-use-hw-watchpoints", class_support
,
8312 &can_use_hw_watchpoints
, _("\
8313 Set debugger's willingness to use watchpoint hardware."), _("\
8314 Show debugger's willingness to use watchpoint hardware."), _("\
8315 If zero, gdb will not use hardware for new watchpoints, even if\n\
8316 such is available. (However, any hardware watchpoints that were\n\
8317 created before setting this to nonzero, will continue to use watchpoint\n\
8320 show_can_use_hw_watchpoints
,
8321 &setlist
, &showlist
);
8323 can_use_hw_watchpoints
= 1;
8325 add_prefix_cmd ("breakpoint", class_maintenance
, set_breakpoint_cmd
, _("\
8326 Breakpoint specific settings\n\
8327 Configure various breakpoint-specific variables such as\n\
8328 pending breakpoint behavior"),
8329 &breakpoint_set_cmdlist
, "set breakpoint ",
8330 0/*allow-unknown*/, &setlist
);
8331 add_prefix_cmd ("breakpoint", class_maintenance
, show_breakpoint_cmd
, _("\
8332 Breakpoint specific settings\n\
8333 Configure various breakpoint-specific variables such as\n\
8334 pending breakpoint behavior"),
8335 &breakpoint_show_cmdlist
, "show breakpoint ",
8336 0/*allow-unknown*/, &showlist
);
8338 add_setshow_auto_boolean_cmd ("pending", no_class
,
8339 &pending_break_support
, _("\
8340 Set debugger's behavior regarding pending breakpoints."), _("\
8341 Show debugger's behavior regarding pending breakpoints."), _("\
8342 If on, an unrecognized breakpoint location will cause gdb to create a\n\
8343 pending breakpoint. If off, an unrecognized breakpoint location results in\n\
8344 an error. If auto, an unrecognized breakpoint location results in a\n\
8345 user-query to see if a pending breakpoint should be created."),
8347 show_pending_break_support
,
8348 &breakpoint_set_cmdlist
,
8349 &breakpoint_show_cmdlist
);
8351 pending_break_support
= AUTO_BOOLEAN_AUTO
;
8353 add_setshow_boolean_cmd ("auto-hw", no_class
,
8354 &automatic_hardware_breakpoints
, _("\
8355 Set automatic usage of hardware breakpoints."), _("\
8356 Show automatic usage of hardware breakpoints."), _("\
8357 If set, the debugger will automatically use hardware breakpoints for\n\
8358 breakpoints set with \"break\" but falling in read-only memory. If not set,\n\
8359 a warning will be emitted for such breakpoints."),
8361 show_automatic_hardware_breakpoints
,
8362 &breakpoint_set_cmdlist
,
8363 &breakpoint_show_cmdlist
);
8365 automatic_hardware_breakpoints
= 1;