1 /* Everything about breakpoints, for GDB.
3 Copyright (C) 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
4 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007
5 Free Software Foundation, Inc.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 51 Franklin Street, Fifth Floor,
22 Boston, MA 02110-1301, USA. */
28 #include "breakpoint.h"
30 #include "expression.h"
36 #include "gdbthread.h"
39 #include "gdb_string.h"
46 #include "completer.h"
49 #include "cli/cli-script.h"
50 #include "gdb_assert.h"
55 #include "exceptions.h"
59 #include "gdb-events.h"
60 #include "mi/mi-common.h"
62 /* Prototypes for local functions. */
64 static void until_break_command_continuation (struct continuation_arg
*arg
);
66 static void catch_command_1 (char *, int, int);
68 static void enable_delete_command (char *, int);
70 static void enable_delete_breakpoint (struct breakpoint
*);
72 static void enable_once_command (char *, int);
74 static void enable_once_breakpoint (struct breakpoint
*);
76 static void disable_command (char *, int);
78 static void enable_command (char *, int);
80 static void map_breakpoint_numbers (char *, void (*)(struct breakpoint
*));
82 static void ignore_command (char *, int);
84 static int breakpoint_re_set_one (void *);
86 static void clear_command (char *, int);
88 static void catch_command (char *, int);
90 static void watch_command (char *, int);
92 static int can_use_hardware_watchpoint (struct value
*);
94 static int break_command_1 (char *, int, int, struct breakpoint
*);
96 static void mention (struct breakpoint
*);
98 struct breakpoint
*set_raw_breakpoint (struct symtab_and_line
, enum bptype
);
100 static void check_duplicates (struct breakpoint
*);
102 static void breakpoint_adjustment_warning (CORE_ADDR
, CORE_ADDR
, int, int);
104 static CORE_ADDR
adjust_breakpoint_address (CORE_ADDR bpaddr
,
107 static void describe_other_breakpoints (CORE_ADDR
, asection
*, int);
109 static void breakpoints_info (char *, int);
111 static void breakpoint_1 (int, int);
113 static bpstat
bpstat_alloc (struct breakpoint
*, bpstat
);
115 static int breakpoint_cond_eval (void *);
117 static void cleanup_executing_breakpoints (void *);
119 static void commands_command (char *, int);
121 static void condition_command (char *, int);
123 static int get_number_trailer (char **, int);
125 void set_breakpoint_count (int);
134 static int remove_breakpoint (struct bp_location
*, insertion_state_t
);
136 static enum print_stop_action
print_it_typical (bpstat
);
138 static enum print_stop_action
print_bp_stop_message (bpstat bs
);
142 enum exception_event_kind kind
;
145 args_for_catchpoint_enable
;
147 static int watchpoint_check (void *);
149 static int cover_target_enable_exception_callback (void *);
151 static void maintenance_info_breakpoints (char *, int);
153 static void create_longjmp_breakpoint (char *);
155 static void create_overlay_event_breakpoint (char *);
157 static int hw_breakpoint_used_count (void);
159 static int hw_watchpoint_used_count (enum bptype
, int *);
161 static void hbreak_command (char *, int);
163 static void thbreak_command (char *, int);
165 static void watch_command_1 (char *, int, int);
167 static void rwatch_command (char *, int);
169 static void awatch_command (char *, int);
171 static void do_enable_breakpoint (struct breakpoint
*, enum bpdisp
);
173 static void solib_load_unload_1 (char *hookname
,
176 char *cond_string
, enum bptype bp_kind
);
178 static void create_fork_vfork_event_catchpoint (int tempflag
,
180 enum bptype bp_kind
);
182 static void stop_command (char *arg
, int from_tty
);
184 static void stopin_command (char *arg
, int from_tty
);
186 static void stopat_command (char *arg
, int from_tty
);
188 static char *ep_find_event_name_end (char *arg
);
190 static char *ep_parse_optional_if_clause (char **arg
);
192 static char *ep_parse_optional_filename (char **arg
);
194 static void create_exception_catchpoint (int tempflag
, char *cond_string
,
195 enum exception_event_kind ex_event
,
196 struct symtab_and_line
*sal
);
198 static void catch_exception_command_1 (enum exception_event_kind ex_event
,
199 char *arg
, int tempflag
, int from_tty
);
201 static void tcatch_command (char *arg
, int from_tty
);
203 static void ep_skip_leading_whitespace (char **s
);
205 /* Prototypes for exported functions. */
207 /* If FALSE, gdb will not use hardware support for watchpoints, even
208 if such is available. */
209 static int can_use_hw_watchpoints
;
212 show_can_use_hw_watchpoints (struct ui_file
*file
, int from_tty
,
213 struct cmd_list_element
*c
,
216 fprintf_filtered (file
, _("\
217 Debugger's willingness to use watchpoint hardware is %s.\n"),
221 /* If AUTO_BOOLEAN_FALSE, gdb will not attempt to create pending breakpoints.
222 If AUTO_BOOLEAN_TRUE, gdb will automatically create pending breakpoints
223 for unrecognized breakpoint locations.
224 If AUTO_BOOLEAN_AUTO, gdb will query when breakpoints are unrecognized. */
225 static enum auto_boolean pending_break_support
;
227 show_pending_break_support (struct ui_file
*file
, int from_tty
,
228 struct cmd_list_element
*c
,
231 fprintf_filtered (file
, _("\
232 Debugger's behavior regarding pending breakpoints is %s.\n"),
236 /* If 1, gdb will automatically use hardware breakpoints for breakpoints
237 set with "break" but falling in read-only memory.
238 If 0, gdb will warn about such breakpoints, but won't automatically
239 use hardware breakpoints. */
240 static int automatic_hardware_breakpoints
;
242 show_automatic_hardware_breakpoints (struct ui_file
*file
, int from_tty
,
243 struct cmd_list_element
*c
,
246 fprintf_filtered (file
, _("\
247 Automatic usage of hardware breakpoints is %s.\n"),
252 void _initialize_breakpoint (void);
254 extern int addressprint
; /* Print machine addresses? */
256 /* Are we executing breakpoint commands? */
257 static int executing_breakpoint_commands
;
259 /* Are overlay event breakpoints enabled? */
260 static int overlay_events_enabled
;
262 /* Walk the following statement or block through all breakpoints.
263 ALL_BREAKPOINTS_SAFE does so even if the statment deletes the current
266 #define ALL_BREAKPOINTS(B) for (B = breakpoint_chain; B; B = B->next)
268 #define ALL_BREAKPOINTS_SAFE(B,TMP) \
269 for (B = breakpoint_chain; \
270 B ? (TMP=B->next, 1): 0; \
273 /* Similar iterators for the low-level breakpoints. */
275 #define ALL_BP_LOCATIONS(B) for (B = bp_location_chain; B; B = B->next)
277 #define ALL_BP_LOCATIONS_SAFE(B,TMP) \
278 for (B = bp_location_chain; \
279 B ? (TMP=B->next, 1): 0; \
282 /* True if breakpoint hit counts should be displayed in breakpoint info. */
284 int show_breakpoint_hit_counts
= 1;
286 /* Chains of all breakpoints defined. */
288 struct breakpoint
*breakpoint_chain
;
290 struct bp_location
*bp_location_chain
;
292 /* Number of last breakpoint made. */
294 int breakpoint_count
;
296 /* Pointer to current exception event record */
297 static struct exception_event_record
*current_exception_event
;
299 /* Indicator of whether exception catchpoints should be nuked between
300 runs of a program. */
301 int deprecated_exception_catchpoints_are_fragile
= 0;
303 /* Indicator of when exception catchpoints set-up should be
304 reinitialized -- e.g. when program is re-run. */
305 int deprecated_exception_support_initialized
= 0;
307 /* This function returns a pointer to the string representation of the
308 pathname of the dynamically-linked library that has just been
311 This function must be used only when SOLIB_HAVE_LOAD_EVENT is TRUE,
312 or undefined results are guaranteed.
314 This string's contents are only valid immediately after the
315 inferior has stopped in the dynamic linker hook, and becomes
316 invalid as soon as the inferior is continued. Clients should make
317 a copy of this string if they wish to continue the inferior and
318 then access the string. */
320 #ifndef SOLIB_LOADED_LIBRARY_PATHNAME
321 #define SOLIB_LOADED_LIBRARY_PATHNAME(pid) ""
324 /* This function returns a pointer to the string representation of the
325 pathname of the dynamically-linked library that has just been
328 This function must be used only when SOLIB_HAVE_UNLOAD_EVENT is
329 TRUE, or undefined results are guaranteed.
331 This string's contents are only valid immediately after the
332 inferior has stopped in the dynamic linker hook, and becomes
333 invalid as soon as the inferior is continued. Clients should make
334 a copy of this string if they wish to continue the inferior and
335 then access the string. */
337 #ifndef SOLIB_UNLOADED_LIBRARY_PATHNAME
338 #define SOLIB_UNLOADED_LIBRARY_PATHNAME(pid) ""
341 /* This function is called by the "catch load" command. It allows the
342 debugger to be notified by the dynamic linker when a specified
343 library file (or any library file, if filename is NULL) is loaded. */
345 #ifndef SOLIB_CREATE_CATCH_LOAD_HOOK
346 #define SOLIB_CREATE_CATCH_LOAD_HOOK(pid,tempflag,filename,cond_string) \
347 error (_("catch of library loads not yet implemented on this platform"))
350 /* This function is called by the "catch unload" command. It allows
351 the debugger to be notified by the dynamic linker when a specified
352 library file (or any library file, if filename is NULL) is
355 #ifndef SOLIB_CREATE_CATCH_UNLOAD_HOOK
356 #define SOLIB_CREATE_CATCH_UNLOAD_HOOK(pid, tempflag, filename, cond_string) \
357 error (_("catch of library unloads not yet implemented on this platform"))
360 /* Return whether a breakpoint is an active enabled breakpoint. */
362 breakpoint_enabled (struct breakpoint
*b
)
364 return (b
->enable_state
== bp_enabled
&& !b
->pending
);
367 /* Set breakpoint count to NUM. */
370 set_breakpoint_count (int num
)
372 breakpoint_count
= num
;
373 set_internalvar (lookup_internalvar ("bpnum"),
374 value_from_longest (builtin_type_int
, (LONGEST
) num
));
377 /* Used in run_command to zero the hit count when a new run starts. */
380 clear_breakpoint_hit_counts (void)
382 struct breakpoint
*b
;
388 /* Default address, symtab and line to put a breakpoint at
389 for "break" command with no arg.
390 if default_breakpoint_valid is zero, the other three are
391 not valid, and "break" with no arg is an error.
393 This set by print_stack_frame, which calls set_default_breakpoint. */
395 int default_breakpoint_valid
;
396 CORE_ADDR default_breakpoint_address
;
397 struct symtab
*default_breakpoint_symtab
;
398 int default_breakpoint_line
;
400 /* *PP is a string denoting a breakpoint. Get the number of the breakpoint.
401 Advance *PP after the string and any trailing whitespace.
403 Currently the string can either be a number or "$" followed by the name
404 of a convenience variable. Making it an expression wouldn't work well
405 for map_breakpoint_numbers (e.g. "4 + 5 + 6").
407 If the string is a NULL pointer, that denotes the last breakpoint.
409 TRAILER is a character which can be found after the number; most
410 commonly this is `-'. If you don't want a trailer, use \0. */
412 get_number_trailer (char **pp
, int trailer
)
414 int retval
= 0; /* default */
418 /* Empty line means refer to the last breakpoint. */
419 return breakpoint_count
;
422 /* Make a copy of the name, so we can null-terminate it
423 to pass to lookup_internalvar(). */
428 while (isalnum (*p
) || *p
== '_')
430 varname
= (char *) alloca (p
- start
+ 1);
431 strncpy (varname
, start
, p
- start
);
432 varname
[p
- start
] = '\0';
433 val
= value_of_internalvar (lookup_internalvar (varname
));
434 if (TYPE_CODE (value_type (val
)) == TYPE_CODE_INT
)
435 retval
= (int) value_as_long (val
);
438 printf_filtered (_("Convenience variable must have integer value.\n"));
446 while (*p
>= '0' && *p
<= '9')
449 /* There is no number here. (e.g. "cond a == b"). */
451 /* Skip non-numeric token */
452 while (*p
&& !isspace((int) *p
))
454 /* Return zero, which caller must interpret as error. */
460 if (!(isspace (*p
) || *p
== '\0' || *p
== trailer
))
462 /* Trailing junk: return 0 and let caller print error msg. */
463 while (!(isspace (*p
) || *p
== '\0' || *p
== trailer
))
474 /* Like get_number_trailer, but don't allow a trailer. */
476 get_number (char **pp
)
478 return get_number_trailer (pp
, '\0');
481 /* Parse a number or a range.
482 * A number will be of the form handled by get_number.
483 * A range will be of the form <number1> - <number2>, and
484 * will represent all the integers between number1 and number2,
487 * While processing a range, this fuction is called iteratively;
488 * At each call it will return the next value in the range.
490 * At the beginning of parsing a range, the char pointer PP will
491 * be advanced past <number1> and left pointing at the '-' token.
492 * Subsequent calls will not advance the pointer until the range
493 * is completed. The call that completes the range will advance
494 * pointer PP past <number2>.
498 get_number_or_range (char **pp
)
500 static int last_retval
, end_value
;
501 static char *end_ptr
;
502 static int in_range
= 0;
506 /* Default case: pp is pointing either to a solo number,
507 or to the first number of a range. */
508 last_retval
= get_number_trailer (pp
, '-');
513 /* This is the start of a range (<number1> - <number2>).
514 Skip the '-', parse and remember the second number,
515 and also remember the end of the final token. */
519 while (isspace ((int) *end_ptr
))
520 end_ptr
++; /* skip white space */
521 end_value
= get_number (temp
);
522 if (end_value
< last_retval
)
524 error (_("inverted range"));
526 else if (end_value
== last_retval
)
528 /* degenerate range (number1 == number2). Advance the
529 token pointer so that the range will be treated as a
538 error (_("negative value"));
541 /* pp points to the '-' that betokens a range. All
542 number-parsing has already been done. Return the next
543 integer value (one greater than the saved previous value).
544 Do not advance the token pointer 'pp' until the end of range
547 if (++last_retval
== end_value
)
549 /* End of range reached; advance token pointer. */
559 /* condition N EXP -- set break condition of breakpoint N to EXP. */
562 condition_command (char *arg
, int from_tty
)
564 struct breakpoint
*b
;
569 error_no_arg (_("breakpoint number"));
572 bnum
= get_number (&p
);
574 error (_("Bad breakpoint argument: '%s'"), arg
);
577 if (b
->number
== bnum
)
584 if (b
->cond_string
!= NULL
)
585 xfree (b
->cond_string
);
590 b
->cond_string
= NULL
;
592 printf_filtered (_("Breakpoint %d now unconditional.\n"), bnum
);
597 /* I don't know if it matters whether this is the string the user
598 typed in or the decompiled expression. */
599 b
->cond_string
= savestring (arg
, strlen (arg
));
602 b
->cond
= parse_exp_1 (&arg
, block_for_pc (b
->loc
->address
), 0);
604 error (_("Junk at end of expression"));
607 breakpoints_changed ();
608 breakpoint_modify_event (b
->number
);
612 error (_("No breakpoint number %d."), bnum
);
616 commands_command (char *arg
, int from_tty
)
618 struct breakpoint
*b
;
621 struct command_line
*l
;
623 /* If we allowed this, we would have problems with when to
624 free the storage, if we change the commands currently
627 if (executing_breakpoint_commands
)
628 error (_("Can't use the \"commands\" command among a breakpoint's commands."));
631 bnum
= get_number (&p
);
634 error (_("Unexpected extra arguments following breakpoint number."));
637 if (b
->number
== bnum
)
639 char *tmpbuf
= xstrprintf ("Type commands for when breakpoint %d is hit, one per line.",
641 struct cleanup
*cleanups
= make_cleanup (xfree
, tmpbuf
);
642 l
= read_command_lines (tmpbuf
, from_tty
);
643 do_cleanups (cleanups
);
644 free_command_lines (&b
->commands
);
646 breakpoints_changed ();
647 breakpoint_modify_event (b
->number
);
650 error (_("No breakpoint number %d."), bnum
);
653 /* Like commands_command, but instead of reading the commands from
654 input stream, takes them from an already parsed command structure.
656 This is used by cli-script.c to DTRT with breakpoint commands
657 that are part of if and while bodies. */
658 enum command_control_type
659 commands_from_control_command (char *arg
, struct command_line
*cmd
)
661 struct breakpoint
*b
;
665 /* If we allowed this, we would have problems with when to
666 free the storage, if we change the commands currently
669 if (executing_breakpoint_commands
)
670 error (_("Can't use the \"commands\" command among a breakpoint's commands."));
672 /* An empty string for the breakpoint number means the last
673 breakpoint, but get_number expects a NULL pointer. */
678 bnum
= get_number (&p
);
681 error (_("Unexpected extra arguments following breakpoint number."));
684 if (b
->number
== bnum
)
686 free_command_lines (&b
->commands
);
687 if (cmd
->body_count
!= 1)
688 error (_("Invalid \"commands\" block structure."));
689 /* We need to copy the commands because if/while will free the
690 list after it finishes execution. */
691 b
->commands
= copy_command_lines (cmd
->body_list
[0]);
692 breakpoints_changed ();
693 breakpoint_modify_event (b
->number
);
694 return simple_control
;
696 error (_("No breakpoint number %d."), bnum
);
699 /* Like target_read_memory() but if breakpoints are inserted, return
700 the shadow contents instead of the breakpoints themselves.
702 Read "memory data" from whatever target or inferior we have.
703 Returns zero if successful, errno value if not. EIO is used
704 for address out of bounds. If breakpoints are inserted, returns
705 shadow contents, not the breakpoints themselves. From breakpoint.c. */
708 read_memory_nobpt (CORE_ADDR memaddr
, gdb_byte
*myaddr
, unsigned len
)
711 struct bp_location
*b
;
712 CORE_ADDR bp_addr
= 0;
715 if (BREAKPOINT_FROM_PC (&bp_addr
, &bp_size
) == NULL
)
716 /* No breakpoints on this machine. */
717 return target_read_memory (memaddr
, myaddr
, len
);
721 if (b
->owner
->type
== bp_none
)
722 warning (_("reading through apparently deleted breakpoint #%d?"),
725 if (b
->loc_type
!= bp_loc_software_breakpoint
)
729 /* Addresses and length of the part of the breakpoint that
731 bp_addr
= b
->target_info
.placed_address
;
732 bp_size
= b
->target_info
.shadow_len
;
734 /* bp isn't valid, or doesn't shadow memory. */
736 if (bp_addr
+ bp_size
<= memaddr
)
737 /* The breakpoint is entirely before the chunk of memory we
740 if (bp_addr
>= memaddr
+ len
)
741 /* The breakpoint is entirely after the chunk of memory we are
744 /* Copy the breakpoint from the shadow contents, and recurse for
745 the things before and after. */
747 /* Offset within shadow_contents. */
750 if (bp_addr
< memaddr
)
752 /* Only copy the second part of the breakpoint. */
753 bp_size
-= memaddr
- bp_addr
;
754 bptoffset
= memaddr
- bp_addr
;
758 if (bp_addr
+ bp_size
> memaddr
+ len
)
760 /* Only copy the first part of the breakpoint. */
761 bp_size
-= (bp_addr
+ bp_size
) - (memaddr
+ len
);
764 memcpy (myaddr
+ bp_addr
- memaddr
,
765 b
->target_info
.shadow_contents
+ bptoffset
, bp_size
);
767 if (bp_addr
> memaddr
)
769 /* Copy the section of memory before the breakpoint. */
770 status
= read_memory_nobpt (memaddr
, myaddr
, bp_addr
- memaddr
);
775 if (bp_addr
+ bp_size
< memaddr
+ len
)
777 /* Copy the section of memory after the breakpoint. */
778 status
= read_memory_nobpt (bp_addr
+ bp_size
,
779 myaddr
+ bp_addr
+ bp_size
- memaddr
,
780 memaddr
+ len
- (bp_addr
+ bp_size
));
787 /* Nothing overlaps. Just call read_memory_noerr. */
788 return target_read_memory (memaddr
, myaddr
, len
);
792 /* A wrapper function for inserting catchpoints. */
794 insert_catchpoint (struct ui_out
*uo
, void *args
)
796 struct breakpoint
*b
= (struct breakpoint
*) args
;
802 target_insert_fork_catchpoint (PIDGET (inferior_ptid
));
805 target_insert_vfork_catchpoint (PIDGET (inferior_ptid
));
808 target_insert_exec_catchpoint (PIDGET (inferior_ptid
));
811 internal_error (__FILE__
, __LINE__
, _("unknown breakpoint type"));
816 /* Helper routine: free the value chain for a breakpoint (watchpoint). */
819 free_valchain (struct bp_location
*b
)
824 /* Free the saved value chain. We will construct a new one
825 the next time the watchpoint is inserted. */
826 for (v
= b
->owner
->val_chain
; v
; v
= n
)
831 b
->owner
->val_chain
= NULL
;
834 /* Insert a low-level "breakpoint" of some type. BPT is the breakpoint.
835 Any error messages are printed to TMP_ERROR_STREAM; and DISABLED_BREAKS,
836 PROCESS_WARNING, and HW_BREAKPOINT_ERROR are used to report problems.
838 NOTE drow/2003-09-09: This routine could be broken down to an object-style
839 method for each breakpoint or catchpoint type. */
841 insert_bp_location (struct bp_location
*bpt
,
842 struct ui_file
*tmp_error_stream
,
843 int *disabled_breaks
, int *process_warning
,
844 int *hw_breakpoint_error
)
848 /* Permanent breakpoints cannot be inserted or removed. Disabled
849 breakpoints should not be inserted. */
850 if (!breakpoint_enabled (bpt
->owner
))
853 if (bpt
->inserted
|| bpt
->duplicate
)
856 /* Initialize the target-specific information. */
857 memset (&bpt
->target_info
, 0, sizeof (bpt
->target_info
));
858 bpt
->target_info
.placed_address
= bpt
->address
;
860 if (bpt
->loc_type
== bp_loc_software_breakpoint
861 || bpt
->loc_type
== bp_loc_hardware_breakpoint
)
863 if (bpt
->owner
->type
!= bp_hardware_breakpoint
)
865 /* If the explicitly specified breakpoint type
866 is not hardware breakpoint, check the memory map to see
867 if the breakpoint address is in read only memory or not.
868 Two important cases are:
869 - location type is not hardware breakpoint, memory
870 is readonly. We change the type of the location to
872 - location type is hardware breakpoint, memory is read-write.
873 This means we've previously made the location hardware one, but
874 then the memory map changed, so we undo.
876 When breakpoints are removed, remove_breakpoints will
877 use location types we've just set here, the only possible
878 problem is that memory map has changed during running program,
879 but it's not going to work anyway with current gdb. */
880 struct mem_region
*mr
881 = lookup_mem_region (bpt
->target_info
.placed_address
);
885 if (automatic_hardware_breakpoints
)
888 enum bp_loc_type new_type
;
890 if (mr
->attrib
.mode
!= MEM_RW
)
891 new_type
= bp_loc_hardware_breakpoint
;
893 new_type
= bp_loc_software_breakpoint
;
895 if (new_type
!= bpt
->loc_type
)
898 bpt
->loc_type
= new_type
;
901 fprintf_filtered (gdb_stdout
, _("\
902 Note: automatically using hardware breakpoints for read-only addresses.\n"));
907 else if (bpt
->loc_type
== bp_loc_software_breakpoint
908 && mr
->attrib
.mode
!= MEM_RW
)
909 warning (_("cannot set software breakpoint at readonly address %s"),
910 paddr (bpt
->address
));
914 /* First check to see if we have to handle an overlay. */
915 if (overlay_debugging
== ovly_off
916 || bpt
->section
== NULL
917 || !(section_is_overlay (bpt
->section
)))
919 /* No overlay handling: just set the breakpoint. */
921 if (bpt
->loc_type
== bp_loc_hardware_breakpoint
)
922 val
= target_insert_hw_breakpoint (&bpt
->target_info
);
924 val
= target_insert_breakpoint (&bpt
->target_info
);
928 /* This breakpoint is in an overlay section.
929 Shall we set a breakpoint at the LMA? */
930 if (!overlay_events_enabled
)
932 /* Yes -- overlay event support is not active,
933 so we must try to set a breakpoint at the LMA.
934 This will not work for a hardware breakpoint. */
935 if (bpt
->loc_type
== bp_loc_hardware_breakpoint
)
936 warning (_("hardware breakpoint %d not supported in overlay!"),
940 CORE_ADDR addr
= overlay_unmapped_address (bpt
->address
,
942 /* Set a software (trap) breakpoint at the LMA. */
943 bpt
->overlay_target_info
= bpt
->target_info
;
944 bpt
->overlay_target_info
.placed_address
= addr
;
945 val
= target_insert_breakpoint (&bpt
->overlay_target_info
);
947 fprintf_unfiltered (tmp_error_stream
,
948 "Overlay breakpoint %d failed: in ROM?",
952 /* Shall we set a breakpoint at the VMA? */
953 if (section_is_mapped (bpt
->section
))
955 /* Yes. This overlay section is mapped into memory. */
956 if (bpt
->loc_type
== bp_loc_hardware_breakpoint
)
957 val
= target_insert_hw_breakpoint (&bpt
->target_info
);
959 val
= target_insert_breakpoint (&bpt
->target_info
);
963 /* No. This breakpoint will not be inserted.
964 No error, but do not mark the bp as 'inserted'. */
971 /* Can't set the breakpoint. */
973 #if defined (DISABLE_UNSETTABLE_BREAK)
974 DISABLE_UNSETTABLE_BREAK (bpt
->address
)
976 solib_address (bpt
->address
)
980 /* See also: disable_breakpoints_in_shlibs. */
982 bpt
->owner
->enable_state
= bp_shlib_disabled
;
983 if (!*disabled_breaks
)
985 fprintf_unfiltered (tmp_error_stream
,
986 "Cannot insert breakpoint %d.\n",
988 fprintf_unfiltered (tmp_error_stream
,
989 "Temporarily disabling shared library breakpoints:\n");
991 *disabled_breaks
= 1;
992 fprintf_unfiltered (tmp_error_stream
,
993 "breakpoint #%d\n", bpt
->owner
->number
);
997 #ifdef ONE_PROCESS_WRITETEXT
998 *process_warning
= 1;
1000 if (bpt
->loc_type
== bp_loc_hardware_breakpoint
)
1002 *hw_breakpoint_error
= 1;
1003 fprintf_unfiltered (tmp_error_stream
,
1004 "Cannot insert hardware breakpoint %d.\n",
1005 bpt
->owner
->number
);
1009 fprintf_unfiltered (tmp_error_stream
,
1010 "Cannot insert breakpoint %d.\n",
1011 bpt
->owner
->number
);
1012 fprintf_filtered (tmp_error_stream
,
1013 "Error accessing memory address ");
1014 deprecated_print_address_numeric (bpt
->address
, 1, tmp_error_stream
);
1015 fprintf_filtered (tmp_error_stream
, ": %s.\n",
1016 safe_strerror (val
));
1027 else if (bpt
->loc_type
== bp_loc_hardware_watchpoint
1028 /* NOTE drow/2003-09-08: This state only exists for removing
1029 watchpoints. It's not clear that it's necessary... */
1030 && bpt
->owner
->disposition
!= disp_del_at_next_stop
)
1032 /* FIXME drow/2003-09-08: This code sets multiple hardware watchpoints
1033 based on the expression. Ideally this should happen at a higher level,
1034 and there should be one bp_location for each computed address we
1035 must watch. As soon as a many-to-one mapping is available I'll
1038 int within_current_scope
;
1039 struct value
*mark
= value_mark ();
1041 struct frame_id saved_frame_id
;
1043 /* Save the current frame's ID so we can restore it after
1044 evaluating the watchpoint expression on its own frame. */
1045 /* FIXME drow/2003-09-09: It would be nice if evaluate_expression
1046 took a frame parameter, so that we didn't have to change the
1048 saved_frame_id
= get_frame_id (get_selected_frame (NULL
));
1050 /* Determine if the watchpoint is within scope. */
1051 if (bpt
->owner
->exp_valid_block
== NULL
)
1052 within_current_scope
= 1;
1055 struct frame_info
*fi
;
1056 fi
= frame_find_by_id (bpt
->owner
->watchpoint_frame
);
1057 within_current_scope
= (fi
!= NULL
);
1058 if (within_current_scope
)
1062 if (within_current_scope
)
1064 free_valchain (bpt
);
1066 /* Evaluate the expression and cut the chain of values
1067 produced off from the value chain.
1069 Make sure the value returned isn't lazy; we use
1070 laziness to determine what memory GDB actually needed
1071 in order to compute the value of the expression. */
1072 v
= evaluate_expression (bpt
->owner
->exp
);
1074 value_release_to_mark (mark
);
1076 bpt
->owner
->val_chain
= v
;
1079 /* Look at each value on the value chain. */
1080 for (; v
; v
= value_next (v
))
1082 /* If it's a memory location, and GDB actually needed
1083 its contents to evaluate the expression, then we
1085 if (VALUE_LVAL (v
) == lval_memory
1086 && ! value_lazy (v
))
1088 struct type
*vtype
= check_typedef (value_type (v
));
1090 /* We only watch structs and arrays if user asked
1091 for it explicitly, never if they just happen to
1092 appear in the middle of some value chain. */
1093 if (v
== bpt
->owner
->val_chain
1094 || (TYPE_CODE (vtype
) != TYPE_CODE_STRUCT
1095 && TYPE_CODE (vtype
) != TYPE_CODE_ARRAY
))
1100 addr
= VALUE_ADDRESS (v
) + value_offset (v
);
1101 len
= TYPE_LENGTH (value_type (v
));
1103 if (bpt
->owner
->type
== bp_read_watchpoint
)
1105 else if (bpt
->owner
->type
== bp_access_watchpoint
)
1108 val
= target_insert_watchpoint (addr
, len
, type
);
1111 /* Don't exit the loop, try to insert
1112 every value on the value chain. That's
1113 because we will be removing all the
1114 watches below, and removing a
1115 watchpoint we didn't insert could have
1123 /* Failure to insert a watchpoint on any memory value in the
1124 value chain brings us here. */
1127 remove_breakpoint (bpt
, mark_uninserted
);
1128 *hw_breakpoint_error
= 1;
1129 fprintf_unfiltered (tmp_error_stream
,
1130 "Could not insert hardware watchpoint %d.\n",
1131 bpt
->owner
->number
);
1137 printf_filtered (_("\
1138 Hardware watchpoint %d deleted because the program has left the block \n\
1139 in which its expression is valid.\n"),
1140 bpt
->owner
->number
);
1141 if (bpt
->owner
->related_breakpoint
)
1142 bpt
->owner
->related_breakpoint
->disposition
= disp_del_at_next_stop
;
1143 bpt
->owner
->disposition
= disp_del_at_next_stop
;
1146 /* Restore the selected frame. */
1147 select_frame (frame_find_by_id (saved_frame_id
));
1152 else if (ep_is_exception_catchpoint (bpt
->owner
))
1154 /* FIXME drow/2003-09-09: This code sets both a catchpoint and a
1155 breakpoint. Once again, it would be better if this was represented
1156 as two bp_locations. */
1158 /* If we get here, we must have a callback mechanism for exception
1159 events -- with g++ style embedded label support, we insert
1160 ordinary breakpoints and not catchpoints. */
1161 val
= target_insert_breakpoint (&bpt
->target_info
);
1164 /* Couldn't set breakpoint for some reason */
1165 fprintf_unfiltered (tmp_error_stream
,
1166 "Cannot insert catchpoint %d; disabling it.\n",
1167 bpt
->owner
->number
);
1168 fprintf_filtered (tmp_error_stream
,
1169 "Error accessing memory address ");
1170 deprecated_print_address_numeric (bpt
->address
, 1, tmp_error_stream
);
1171 fprintf_filtered (tmp_error_stream
, ": %s.\n",
1172 safe_strerror (val
));
1173 bpt
->owner
->enable_state
= bp_disabled
;
1177 /* Bp set, now make sure callbacks are enabled */
1178 /* Format possible error msg */
1179 char *message
= xstrprintf ("Error inserting catchpoint %d:\n",
1180 bpt
->owner
->number
);
1181 struct cleanup
*cleanups
= make_cleanup (xfree
, message
);
1183 args_for_catchpoint_enable args
;
1184 args
.kind
= bpt
->owner
->type
== bp_catch_catch
?
1185 EX_EVENT_CATCH
: EX_EVENT_THROW
;
1187 val
= catch_errors (cover_target_enable_exception_callback
,
1188 &args
, message
, RETURN_MASK_ALL
);
1189 do_cleanups (cleanups
);
1190 if (val
!= 0 && val
!= -1)
1193 /* Check if something went wrong; val == 0 can be ignored */
1196 /* something went wrong */
1197 fprintf_unfiltered (tmp_error_stream
,
1198 "Cannot insert catchpoint %d; disabling it.\n",
1199 bpt
->owner
->number
);
1200 bpt
->owner
->enable_state
= bp_disabled
;
1207 else if (bpt
->owner
->type
== bp_catch_fork
1208 || bpt
->owner
->type
== bp_catch_vfork
1209 || bpt
->owner
->type
== bp_catch_exec
)
1211 struct gdb_exception e
= catch_exception (uiout
, insert_catchpoint
,
1212 bpt
->owner
, RETURN_MASK_ERROR
);
1213 exception_fprintf (gdb_stderr
, e
, "warning: inserting catchpoint %d: ",
1214 bpt
->owner
->number
);
1216 bpt
->owner
->enable_state
= bp_disabled
;
1220 /* We've already printed an error message if there was a problem
1221 inserting this catchpoint, and we've disabled the catchpoint,
1222 so just return success. */
1229 /* insert_breakpoints is used when starting or continuing the program.
1230 remove_breakpoints is used when the program stops.
1231 Both return zero if successful,
1232 or an `errno' value if could not write the inferior. */
1235 insert_breakpoints (void)
1237 struct bp_location
*b
, *temp
;
1238 int return_val
= 0; /* return success code. */
1240 int disabled_breaks
= 0;
1241 int hw_breakpoint_error
= 0;
1242 int process_warning
= 0;
1244 struct ui_file
*tmp_error_stream
= mem_fileopen ();
1245 make_cleanup_ui_file_delete (tmp_error_stream
);
1247 /* Explicitly mark the warning -- this will only be printed if
1248 there was an error. */
1249 fprintf_unfiltered (tmp_error_stream
, "Warning:\n");
1251 ALL_BP_LOCATIONS_SAFE (b
, temp
)
1253 /* Permanent breakpoints cannot be inserted or removed. Disabled
1254 breakpoints should not be inserted. */
1255 if (!breakpoint_enabled (b
->owner
))
1258 /* There is no point inserting thread-specific breakpoints if the
1259 thread no longer exists. */
1260 if (b
->owner
->thread
!= -1
1261 && !valid_thread_id (b
->owner
->thread
))
1264 /* FIXME drow/2003-10-07: This code should be pushed elsewhere when
1265 hardware watchpoints are split into multiple loc breakpoints. */
1266 if ((b
->loc_type
== bp_loc_hardware_watchpoint
1267 || b
->owner
->type
== bp_watchpoint
) && !b
->owner
->val
)
1270 val
= evaluate_expression (b
->owner
->exp
);
1271 release_value (val
);
1272 if (value_lazy (val
))
1273 value_fetch_lazy (val
);
1274 b
->owner
->val
= val
;
1277 val
= insert_bp_location (b
, tmp_error_stream
,
1278 &disabled_breaks
, &process_warning
,
1279 &hw_breakpoint_error
);
1286 /* If a hardware breakpoint or watchpoint was inserted, add a
1287 message about possibly exhausted resources. */
1288 if (hw_breakpoint_error
)
1290 fprintf_unfiltered (tmp_error_stream
,
1291 "Could not insert hardware breakpoints:\n\
1292 You may have requested too many hardware breakpoints/watchpoints.\n");
1294 #ifdef ONE_PROCESS_WRITETEXT
1295 if (process_warning
)
1296 fprintf_unfiltered (tmp_error_stream
,
1297 "The same program may be running in another process.");
1299 target_terminal_ours_for_output ();
1300 error_stream (tmp_error_stream
);
1306 remove_breakpoints (void)
1308 struct bp_location
*b
;
1311 ALL_BP_LOCATIONS (b
)
1315 val
= remove_breakpoint (b
, mark_uninserted
);
1324 remove_hw_watchpoints (void)
1326 struct bp_location
*b
;
1329 ALL_BP_LOCATIONS (b
)
1331 if (b
->inserted
&& b
->loc_type
== bp_loc_hardware_watchpoint
)
1333 val
= remove_breakpoint (b
, mark_uninserted
);
1342 reattach_breakpoints (int pid
)
1344 struct bp_location
*b
;
1346 struct cleanup
*old_chain
= save_inferior_ptid ();
1348 /* Set inferior_ptid; remove_breakpoint uses this global. */
1349 inferior_ptid
= pid_to_ptid (pid
);
1350 ALL_BP_LOCATIONS (b
)
1354 remove_breakpoint (b
, mark_inserted
);
1355 /* Note: since we insert a breakpoint right after removing,
1356 any decisions about automatically using hardware breakpoints
1357 made in insert_bp_location are preserved. */
1358 if (b
->loc_type
== bp_loc_hardware_breakpoint
)
1359 val
= target_insert_hw_breakpoint (&b
->target_info
);
1361 val
= target_insert_breakpoint (&b
->target_info
);
1362 /* FIXME drow/2003-10-07: This doesn't handle any other kinds of
1363 breakpoints. It's wrong for watchpoints, for example. */
1366 do_cleanups (old_chain
);
1371 do_cleanups (old_chain
);
1376 update_breakpoints_after_exec (void)
1378 struct breakpoint
*b
;
1379 struct breakpoint
*temp
;
1381 /* Doing this first prevents the badness of having delete_breakpoint()
1382 write a breakpoint's current "shadow contents" to lift the bp. That
1383 shadow is NOT valid after an exec()! */
1384 mark_breakpoints_out ();
1386 ALL_BREAKPOINTS_SAFE (b
, temp
)
1388 /* Solib breakpoints must be explicitly reset after an exec(). */
1389 if (b
->type
== bp_shlib_event
)
1391 delete_breakpoint (b
);
1395 /* Thread event breakpoints must be set anew after an exec(),
1396 as must overlay event breakpoints. */
1397 if (b
->type
== bp_thread_event
|| b
->type
== bp_overlay_event
)
1399 delete_breakpoint (b
);
1403 /* Step-resume breakpoints are meaningless after an exec(). */
1404 if (b
->type
== bp_step_resume
)
1406 delete_breakpoint (b
);
1410 /* Ditto the exception-handling catchpoints. */
1411 if ((b
->type
== bp_catch_catch
) || (b
->type
== bp_catch_throw
))
1413 delete_breakpoint (b
);
1417 /* Don't delete an exec catchpoint, because else the inferior
1418 won't stop when it ought!
1420 Similarly, we probably ought to keep vfork catchpoints, 'cause
1421 on this target, we may not be able to stop when the vfork is
1422 seen, but only when the subsequent exec is seen. (And because
1423 deleting fork catchpoints here but not vfork catchpoints will
1424 seem mysterious to users, keep those too.)
1426 ??rehrauer: Let's hope that merely clearing out this catchpoint's
1427 target address field, if any, is sufficient to have it be reset
1428 automagically. Certainly on HP-UX that's true.
1430 Jim Blandy <jimb@redhat.com>: Actually, zero is a perfectly
1431 valid code address on some platforms (like the mn10300
1432 simulators). We shouldn't assign any special interpretation to
1433 a breakpoint with a zero address. And in fact, GDB doesn't ---
1434 I can't see what that comment above is talking about. As far
1435 as I can tell, setting the address of a
1436 bp_catch_exec/bp_catch_vfork/bp_catch_fork breakpoint to zero
1437 is meaningless, since those are implemented with HP-UX kernel
1438 hackery, not by storing breakpoint instructions somewhere. */
1439 if ((b
->type
== bp_catch_exec
) ||
1440 (b
->type
== bp_catch_vfork
) ||
1441 (b
->type
== bp_catch_fork
))
1443 b
->loc
->address
= (CORE_ADDR
) 0;
1447 /* bp_finish is a special case. The only way we ought to be able
1448 to see one of these when an exec() has happened, is if the user
1449 caught a vfork, and then said "finish". Ordinarily a finish just
1450 carries them to the call-site of the current callee, by setting
1451 a temporary bp there and resuming. But in this case, the finish
1452 will carry them entirely through the vfork & exec.
1454 We don't want to allow a bp_finish to remain inserted now. But
1455 we can't safely delete it, 'cause finish_command has a handle to
1456 the bp on a bpstat, and will later want to delete it. There's a
1457 chance (and I've seen it happen) that if we delete the bp_finish
1458 here, that its storage will get reused by the time finish_command
1459 gets 'round to deleting the "use to be a bp_finish" breakpoint.
1460 We really must allow finish_command to delete a bp_finish.
1462 In the absense of a general solution for the "how do we know
1463 it's safe to delete something others may have handles to?"
1464 problem, what we'll do here is just uninsert the bp_finish, and
1465 let finish_command delete it.
1467 (We know the bp_finish is "doomed" in the sense that it's
1468 momentary, and will be deleted as soon as finish_command sees
1469 the inferior stopped. So it doesn't matter that the bp's
1470 address is probably bogus in the new a.out, unlike e.g., the
1471 solib breakpoints.) */
1473 if (b
->type
== bp_finish
)
1478 /* Without a symbolic address, we have little hope of the
1479 pre-exec() address meaning the same thing in the post-exec()
1481 if (b
->addr_string
== NULL
)
1483 delete_breakpoint (b
);
1487 /* If this breakpoint has survived the above battery of checks, then
1488 it must have a symbolic address. Be sure that it gets reevaluated
1489 to a target address, rather than reusing the old evaluation.
1491 Jim Blandy <jimb@redhat.com>: As explained above in the comment
1492 for bp_catch_exec and friends, I'm pretty sure this is entirely
1493 unnecessary. A call to breakpoint_re_set_one always recomputes
1494 the breakpoint's address from scratch, or deletes it if it can't.
1495 So I think this assignment could be deleted without effect. */
1496 b
->loc
->address
= (CORE_ADDR
) 0;
1498 /* FIXME what about longjmp breakpoints? Re-create them here? */
1499 create_overlay_event_breakpoint ("_ovly_debug_event");
1503 detach_breakpoints (int pid
)
1505 struct bp_location
*b
;
1507 struct cleanup
*old_chain
= save_inferior_ptid ();
1509 if (pid
== PIDGET (inferior_ptid
))
1510 error (_("Cannot detach breakpoints of inferior_ptid"));
1512 /* Set inferior_ptid; remove_breakpoint uses this global. */
1513 inferior_ptid
= pid_to_ptid (pid
);
1514 ALL_BP_LOCATIONS (b
)
1518 val
= remove_breakpoint (b
, mark_inserted
);
1521 do_cleanups (old_chain
);
1526 do_cleanups (old_chain
);
1531 remove_breakpoint (struct bp_location
*b
, insertion_state_t is
)
1535 if (b
->owner
->enable_state
== bp_permanent
)
1536 /* Permanent breakpoints cannot be inserted or removed. */
1539 if (b
->owner
->type
== bp_none
)
1540 warning (_("attempted to remove apparently deleted breakpoint #%d?"),
1543 if (b
->loc_type
== bp_loc_software_breakpoint
1544 || b
->loc_type
== bp_loc_hardware_breakpoint
)
1546 /* "Normal" instruction breakpoint: either the standard
1547 trap-instruction bp (bp_breakpoint), or a
1548 bp_hardware_breakpoint. */
1550 /* First check to see if we have to handle an overlay. */
1551 if (overlay_debugging
== ovly_off
1552 || b
->section
== NULL
1553 || !(section_is_overlay (b
->section
)))
1555 /* No overlay handling: just remove the breakpoint. */
1557 if (b
->loc_type
== bp_loc_hardware_breakpoint
)
1558 val
= target_remove_hw_breakpoint (&b
->target_info
);
1560 val
= target_remove_breakpoint (&b
->target_info
);
1564 /* This breakpoint is in an overlay section.
1565 Did we set a breakpoint at the LMA? */
1566 if (!overlay_events_enabled
)
1568 /* Yes -- overlay event support is not active, so we
1569 should have set a breakpoint at the LMA. Remove it.
1571 /* Ignore any failures: if the LMA is in ROM, we will
1572 have already warned when we failed to insert it. */
1573 if (b
->loc_type
== bp_loc_hardware_breakpoint
)
1574 target_remove_hw_breakpoint (&b
->overlay_target_info
);
1576 target_remove_breakpoint (&b
->overlay_target_info
);
1578 /* Did we set a breakpoint at the VMA?
1579 If so, we will have marked the breakpoint 'inserted'. */
1582 /* Yes -- remove it. Previously we did not bother to
1583 remove the breakpoint if the section had been
1584 unmapped, but let's not rely on that being safe. We
1585 don't know what the overlay manager might do. */
1586 if (b
->loc_type
== bp_loc_hardware_breakpoint
)
1587 val
= target_remove_hw_breakpoint (&b
->target_info
);
1589 val
= target_remove_breakpoint (&b
->target_info
);
1593 /* No -- not inserted, so no need to remove. No error. */
1599 b
->inserted
= (is
== mark_inserted
);
1601 else if (b
->loc_type
== bp_loc_hardware_watchpoint
1602 && breakpoint_enabled (b
->owner
)
1608 b
->inserted
= (is
== mark_inserted
);
1609 /* Walk down the saved value chain. */
1610 for (v
= b
->owner
->val_chain
; v
; v
= value_next (v
))
1612 /* For each memory reference remove the watchpoint
1614 if (VALUE_LVAL (v
) == lval_memory
1615 && ! value_lazy (v
))
1617 struct type
*vtype
= check_typedef (value_type (v
));
1619 if (v
== b
->owner
->val_chain
1620 || (TYPE_CODE (vtype
) != TYPE_CODE_STRUCT
1621 && TYPE_CODE (vtype
) != TYPE_CODE_ARRAY
))
1626 addr
= VALUE_ADDRESS (v
) + value_offset (v
);
1627 len
= TYPE_LENGTH (value_type (v
));
1629 if (b
->owner
->type
== bp_read_watchpoint
)
1631 else if (b
->owner
->type
== bp_access_watchpoint
)
1634 val
= target_remove_watchpoint (addr
, len
, type
);
1641 /* Failure to remove any of the hardware watchpoints comes here. */
1642 if ((is
== mark_uninserted
) && (b
->inserted
))
1643 warning (_("Could not remove hardware watchpoint %d."),
1646 else if ((b
->owner
->type
== bp_catch_fork
||
1647 b
->owner
->type
== bp_catch_vfork
||
1648 b
->owner
->type
== bp_catch_exec
)
1649 && breakpoint_enabled (b
->owner
)
1653 switch (b
->owner
->type
)
1656 val
= target_remove_fork_catchpoint (PIDGET (inferior_ptid
));
1658 case bp_catch_vfork
:
1659 val
= target_remove_vfork_catchpoint (PIDGET (inferior_ptid
));
1662 val
= target_remove_exec_catchpoint (PIDGET (inferior_ptid
));
1665 warning (_("Internal error, %s line %d."), __FILE__
, __LINE__
);
1670 b
->inserted
= (is
== mark_inserted
);
1672 else if ((b
->owner
->type
== bp_catch_catch
||
1673 b
->owner
->type
== bp_catch_throw
)
1674 && breakpoint_enabled (b
->owner
)
1677 val
= target_remove_breakpoint (&b
->target_info
);
1680 b
->inserted
= (is
== mark_inserted
);
1686 /* Clear the "inserted" flag in all breakpoints. */
1689 mark_breakpoints_out (void)
1691 struct bp_location
*bpt
;
1693 ALL_BP_LOCATIONS (bpt
)
1697 /* Clear the "inserted" flag in all breakpoints and delete any
1698 breakpoints which should go away between runs of the program.
1700 Plus other such housekeeping that has to be done for breakpoints
1703 Note: this function gets called at the end of a run (by
1704 generic_mourn_inferior) and when a run begins (by
1705 init_wait_for_inferior). */
1710 breakpoint_init_inferior (enum inf_context context
)
1712 struct breakpoint
*b
, *temp
;
1713 struct bp_location
*bpt
;
1714 static int warning_needed
= 0;
1716 ALL_BP_LOCATIONS (bpt
)
1719 ALL_BREAKPOINTS_SAFE (b
, temp
)
1724 case bp_watchpoint_scope
:
1726 /* If the call dummy breakpoint is at the entry point it will
1727 cause problems when the inferior is rerun, so we better
1730 Also get rid of scope breakpoints. */
1731 delete_breakpoint (b
);
1735 case bp_hardware_watchpoint
:
1736 case bp_read_watchpoint
:
1737 case bp_access_watchpoint
:
1739 /* Likewise for watchpoints on local expressions. */
1740 if (b
->exp_valid_block
!= NULL
)
1741 delete_breakpoint (b
);
1742 if (context
== inf_starting
)
1744 /* Reset val field to force reread of starting value
1745 in insert_breakpoints. */
1747 value_free (b
->val
);
1752 /* Likewise for exception catchpoints in dynamic-linked
1753 executables where required */
1754 if (ep_is_exception_catchpoint (b
)
1755 && deprecated_exception_catchpoints_are_fragile
)
1758 delete_breakpoint (b
);
1764 if (deprecated_exception_catchpoints_are_fragile
)
1765 deprecated_exception_support_initialized
= 0;
1767 /* Don't issue the warning unless it's really needed... */
1768 if (warning_needed
&& (context
!= inf_exited
))
1770 warning (_("Exception catchpoints from last run were deleted.\n"
1771 "You must reinsert them explicitly."));
1776 /* breakpoint_here_p (PC) returns non-zero if an enabled breakpoint
1777 exists at PC. It returns ordinary_breakpoint_here if it's an
1778 ordinary breakpoint, or permanent_breakpoint_here if it's a
1779 permanent breakpoint.
1780 - When continuing from a location with an ordinary breakpoint, we
1781 actually single step once before calling insert_breakpoints.
1782 - When continuing from a localion with a permanent breakpoint, we
1783 need to use the `SKIP_PERMANENT_BREAKPOINT' macro, provided by
1784 the target, to advance the PC past the breakpoint. */
1786 enum breakpoint_here
1787 breakpoint_here_p (CORE_ADDR pc
)
1789 struct bp_location
*bpt
;
1790 int any_breakpoint_here
= 0;
1792 ALL_BP_LOCATIONS (bpt
)
1794 if (bpt
->loc_type
!= bp_loc_software_breakpoint
1795 && bpt
->loc_type
!= bp_loc_hardware_breakpoint
)
1798 if ((breakpoint_enabled (bpt
->owner
)
1799 || bpt
->owner
->enable_state
== bp_permanent
)
1800 && bpt
->address
== pc
) /* bp is enabled and matches pc */
1802 if (overlay_debugging
1803 && section_is_overlay (bpt
->section
)
1804 && !section_is_mapped (bpt
->section
))
1805 continue; /* unmapped overlay -- can't be a match */
1806 else if (bpt
->owner
->enable_state
== bp_permanent
)
1807 return permanent_breakpoint_here
;
1809 any_breakpoint_here
= 1;
1813 return any_breakpoint_here
? ordinary_breakpoint_here
: 0;
1817 /* breakpoint_inserted_here_p (PC) is just like breakpoint_here_p(),
1818 but it only returns true if there is actually a breakpoint inserted
1822 breakpoint_inserted_here_p (CORE_ADDR pc
)
1824 struct bp_location
*bpt
;
1826 ALL_BP_LOCATIONS (bpt
)
1828 if (bpt
->loc_type
!= bp_loc_software_breakpoint
1829 && bpt
->loc_type
!= bp_loc_hardware_breakpoint
)
1833 && bpt
->address
== pc
) /* bp is inserted and matches pc */
1835 if (overlay_debugging
1836 && section_is_overlay (bpt
->section
)
1837 && !section_is_mapped (bpt
->section
))
1838 continue; /* unmapped overlay -- can't be a match */
1847 /* This function returns non-zero iff there is a software breakpoint
1851 software_breakpoint_inserted_here_p (CORE_ADDR pc
)
1853 struct bp_location
*bpt
;
1854 int any_breakpoint_here
= 0;
1856 ALL_BP_LOCATIONS (bpt
)
1858 if (bpt
->loc_type
!= bp_loc_software_breakpoint
)
1861 if ((breakpoint_enabled (bpt
->owner
)
1862 || bpt
->owner
->enable_state
== bp_permanent
)
1864 && bpt
->address
== pc
) /* bp is enabled and matches pc */
1866 if (overlay_debugging
1867 && section_is_overlay (bpt
->section
)
1868 && !section_is_mapped (bpt
->section
))
1869 continue; /* unmapped overlay -- can't be a match */
1878 /* breakpoint_thread_match (PC, PTID) returns true if the breakpoint at
1879 PC is valid for process/thread PTID. */
1882 breakpoint_thread_match (CORE_ADDR pc
, ptid_t ptid
)
1884 struct bp_location
*bpt
;
1887 thread
= pid_to_thread_id (ptid
);
1889 ALL_BP_LOCATIONS (bpt
)
1891 if (bpt
->loc_type
!= bp_loc_software_breakpoint
1892 && bpt
->loc_type
!= bp_loc_hardware_breakpoint
)
1895 if ((breakpoint_enabled (bpt
->owner
)
1896 || bpt
->owner
->enable_state
== bp_permanent
)
1897 && bpt
->address
== pc
1898 && (bpt
->owner
->thread
== -1 || bpt
->owner
->thread
== thread
))
1900 if (overlay_debugging
1901 && section_is_overlay (bpt
->section
)
1902 && !section_is_mapped (bpt
->section
))
1903 continue; /* unmapped overlay -- can't be a match */
1913 /* bpstat stuff. External routines' interfaces are documented
1917 ep_is_catchpoint (struct breakpoint
*ep
)
1920 (ep
->type
== bp_catch_load
)
1921 || (ep
->type
== bp_catch_unload
)
1922 || (ep
->type
== bp_catch_fork
)
1923 || (ep
->type
== bp_catch_vfork
)
1924 || (ep
->type
== bp_catch_exec
)
1925 || (ep
->type
== bp_catch_catch
)
1926 || (ep
->type
== bp_catch_throw
);
1928 /* ??rehrauer: Add more kinds here, as are implemented... */
1932 ep_is_shlib_catchpoint (struct breakpoint
*ep
)
1935 (ep
->type
== bp_catch_load
)
1936 || (ep
->type
== bp_catch_unload
);
1940 ep_is_exception_catchpoint (struct breakpoint
*ep
)
1943 (ep
->type
== bp_catch_catch
)
1944 || (ep
->type
== bp_catch_throw
);
1947 /* Clear a bpstat so that it says we are not at any breakpoint.
1948 Also free any storage that is part of a bpstat. */
1951 bpstat_clear (bpstat
*bsp
)
1962 if (p
->old_val
!= NULL
)
1963 value_free (p
->old_val
);
1964 free_command_lines (&p
->commands
);
1971 /* Return a copy of a bpstat. Like "bs1 = bs2" but all storage that
1972 is part of the bpstat is copied as well. */
1975 bpstat_copy (bpstat bs
)
1979 bpstat retval
= NULL
;
1984 for (; bs
!= NULL
; bs
= bs
->next
)
1986 tmp
= (bpstat
) xmalloc (sizeof (*tmp
));
1987 memcpy (tmp
, bs
, sizeof (*tmp
));
1988 if (bs
->commands
!= NULL
)
1989 tmp
->commands
= copy_command_lines (bs
->commands
);
1990 if (bs
->old_val
!= NULL
)
1991 tmp
->old_val
= value_copy (bs
->old_val
);
1994 /* This is the first thing in the chain. */
2004 /* Find the bpstat associated with this breakpoint */
2007 bpstat_find_breakpoint (bpstat bsp
, struct breakpoint
*breakpoint
)
2012 for (; bsp
!= NULL
; bsp
= bsp
->next
)
2014 if (bsp
->breakpoint_at
== breakpoint
)
2020 /* Find a step_resume breakpoint associated with this bpstat.
2021 (If there are multiple step_resume bp's on the list, this function
2022 will arbitrarily pick one.)
2024 It is an error to use this function if BPSTAT doesn't contain a
2025 step_resume breakpoint.
2027 See wait_for_inferior's use of this function. */
2029 bpstat_find_step_resume_breakpoint (bpstat bsp
)
2033 gdb_assert (bsp
!= NULL
);
2035 current_thread
= pid_to_thread_id (inferior_ptid
);
2037 for (; bsp
!= NULL
; bsp
= bsp
->next
)
2039 if ((bsp
->breakpoint_at
!= NULL
) &&
2040 (bsp
->breakpoint_at
->type
== bp_step_resume
) &&
2041 (bsp
->breakpoint_at
->thread
== current_thread
||
2042 bsp
->breakpoint_at
->thread
== -1))
2043 return bsp
->breakpoint_at
;
2046 internal_error (__FILE__
, __LINE__
, _("No step_resume breakpoint found."));
2050 /* Put in *NUM the breakpoint number of the first breakpoint we are stopped
2051 at. *BSP upon return is a bpstat which points to the remaining
2052 breakpoints stopped at (but which is not guaranteed to be good for
2053 anything but further calls to bpstat_num).
2054 Return 0 if passed a bpstat which does not indicate any breakpoints.
2055 Return -1 if stopped at a breakpoint that has been deleted since
2057 Return 1 otherwise. */
2060 bpstat_num (bpstat
*bsp
, int *num
)
2062 struct breakpoint
*b
;
2065 return 0; /* No more breakpoint values */
2067 b
= (*bsp
)->breakpoint_at
;
2068 *bsp
= (*bsp
)->next
;
2070 return -1; /* breakpoint that's been deleted since */
2072 *num
= b
->number
; /* We have its number */
2076 /* Modify BS so that the actions will not be performed. */
2079 bpstat_clear_actions (bpstat bs
)
2081 for (; bs
!= NULL
; bs
= bs
->next
)
2083 free_command_lines (&bs
->commands
);
2084 if (bs
->old_val
!= NULL
)
2086 value_free (bs
->old_val
);
2092 /* Stub for cleaning up our state if we error-out of a breakpoint command */
2094 cleanup_executing_breakpoints (void *ignore
)
2096 executing_breakpoint_commands
= 0;
2099 /* Execute all the commands associated with all the breakpoints at this
2100 location. Any of these commands could cause the process to proceed
2101 beyond this point, etc. We look out for such changes by checking
2102 the global "breakpoint_proceeded" after each command. */
2105 bpstat_do_actions (bpstat
*bsp
)
2108 struct cleanup
*old_chain
;
2110 /* Avoid endless recursion if a `source' command is contained
2112 if (executing_breakpoint_commands
)
2115 executing_breakpoint_commands
= 1;
2116 old_chain
= make_cleanup (cleanup_executing_breakpoints
, 0);
2119 /* Note that (as of this writing), our callers all appear to
2120 be passing us the address of global stop_bpstat. And, if
2121 our calls to execute_control_command cause the inferior to
2122 proceed, that global (and hence, *bsp) will change.
2124 We must be careful to not touch *bsp unless the inferior
2125 has not proceeded. */
2127 /* This pointer will iterate over the list of bpstat's. */
2130 breakpoint_proceeded
= 0;
2131 for (; bs
!= NULL
; bs
= bs
->next
)
2133 struct command_line
*cmd
;
2134 struct cleanup
*this_cmd_tree_chain
;
2136 /* Take ownership of the BSP's command tree, if it has one.
2138 The command tree could legitimately contain commands like
2139 'step' and 'next', which call clear_proceed_status, which
2140 frees stop_bpstat's command tree. To make sure this doesn't
2141 free the tree we're executing out from under us, we need to
2142 take ownership of the tree ourselves. Since a given bpstat's
2143 commands are only executed once, we don't need to copy it; we
2144 can clear the pointer in the bpstat, and make sure we free
2145 the tree when we're done. */
2148 this_cmd_tree_chain
= make_cleanup_free_command_lines (&cmd
);
2152 execute_control_command (cmd
);
2154 if (breakpoint_proceeded
)
2160 /* We can free this command tree now. */
2161 do_cleanups (this_cmd_tree_chain
);
2163 if (breakpoint_proceeded
)
2164 /* The inferior is proceeded by the command; bomb out now.
2165 The bpstat chain has been blown away by wait_for_inferior.
2166 But since execution has stopped again, there is a new bpstat
2167 to look at, so start over. */
2170 do_cleanups (old_chain
);
2173 /* This is the normal print function for a bpstat. In the future,
2174 much of this logic could (should?) be moved to bpstat_stop_status,
2175 by having it set different print_it values.
2177 Current scheme: When we stop, bpstat_print() is called. It loops
2178 through the bpstat list of things causing this stop, calling the
2179 print_bp_stop_message function on each one. The behavior of the
2180 print_bp_stop_message function depends on the print_it field of
2181 bpstat. If such field so indicates, call this function here.
2183 Return values from this routine (ultimately used by bpstat_print()
2184 and normal_stop() to decide what to do):
2185 PRINT_NOTHING: Means we already printed all we needed to print,
2186 don't print anything else.
2187 PRINT_SRC_ONLY: Means we printed something, and we do *not* desire
2188 that something to be followed by a location.
2189 PRINT_SCR_AND_LOC: Means we printed something, and we *do* desire
2190 that something to be followed by a location.
2191 PRINT_UNKNOWN: Means we printed nothing or we need to do some more
2194 static enum print_stop_action
2195 print_it_typical (bpstat bs
)
2197 struct cleanup
*old_chain
, *ui_out_chain
;
2198 struct ui_stream
*stb
;
2199 stb
= ui_out_stream_new (uiout
);
2200 old_chain
= make_cleanup_ui_out_stream_delete (stb
);
2201 /* bs->breakpoint_at can be NULL if it was a momentary breakpoint
2202 which has since been deleted. */
2203 if (bs
->breakpoint_at
== NULL
)
2204 return PRINT_UNKNOWN
;
2206 switch (bs
->breakpoint_at
->type
)
2209 case bp_hardware_breakpoint
:
2210 if (bs
->breakpoint_at
->loc
->address
!= bs
->breakpoint_at
->loc
->requested_address
)
2211 breakpoint_adjustment_warning (bs
->breakpoint_at
->loc
->requested_address
,
2212 bs
->breakpoint_at
->loc
->address
,
2213 bs
->breakpoint_at
->number
, 1);
2214 annotate_breakpoint (bs
->breakpoint_at
->number
);
2215 ui_out_text (uiout
, "\nBreakpoint ");
2216 if (ui_out_is_mi_like_p (uiout
))
2217 ui_out_field_string (uiout
, "reason",
2218 async_reason_lookup (EXEC_ASYNC_BREAKPOINT_HIT
));
2219 ui_out_field_int (uiout
, "bkptno", bs
->breakpoint_at
->number
);
2220 ui_out_text (uiout
, ", ");
2221 return PRINT_SRC_AND_LOC
;
2224 case bp_shlib_event
:
2225 /* Did we stop because the user set the stop_on_solib_events
2226 variable? (If so, we report this as a generic, "Stopped due
2227 to shlib event" message.) */
2228 printf_filtered (_("Stopped due to shared library event\n"));
2229 return PRINT_NOTHING
;
2232 case bp_thread_event
:
2233 /* Not sure how we will get here.
2234 GDB should not stop for these breakpoints. */
2235 printf_filtered (_("Thread Event Breakpoint: gdb should not stop!\n"));
2236 return PRINT_NOTHING
;
2239 case bp_overlay_event
:
2240 /* By analogy with the thread event, GDB should not stop for these. */
2241 printf_filtered (_("Overlay Event Breakpoint: gdb should not stop!\n"));
2242 return PRINT_NOTHING
;
2246 annotate_catchpoint (bs
->breakpoint_at
->number
);
2247 printf_filtered (_("\nCatchpoint %d (loaded %s), "),
2248 bs
->breakpoint_at
->number
,
2249 bs
->breakpoint_at
->triggered_dll_pathname
);
2250 return PRINT_SRC_AND_LOC
;
2253 case bp_catch_unload
:
2254 annotate_catchpoint (bs
->breakpoint_at
->number
);
2255 printf_filtered (_("\nCatchpoint %d (unloaded %s), "),
2256 bs
->breakpoint_at
->number
,
2257 bs
->breakpoint_at
->triggered_dll_pathname
);
2258 return PRINT_SRC_AND_LOC
;
2262 annotate_catchpoint (bs
->breakpoint_at
->number
);
2263 printf_filtered (_("\nCatchpoint %d (forked process %d), "),
2264 bs
->breakpoint_at
->number
,
2265 bs
->breakpoint_at
->forked_inferior_pid
);
2266 return PRINT_SRC_AND_LOC
;
2269 case bp_catch_vfork
:
2270 annotate_catchpoint (bs
->breakpoint_at
->number
);
2271 printf_filtered (_("\nCatchpoint %d (vforked process %d), "),
2272 bs
->breakpoint_at
->number
,
2273 bs
->breakpoint_at
->forked_inferior_pid
);
2274 return PRINT_SRC_AND_LOC
;
2278 annotate_catchpoint (bs
->breakpoint_at
->number
);
2279 printf_filtered (_("\nCatchpoint %d (exec'd %s), "),
2280 bs
->breakpoint_at
->number
,
2281 bs
->breakpoint_at
->exec_pathname
);
2282 return PRINT_SRC_AND_LOC
;
2285 case bp_catch_catch
:
2286 if (current_exception_event
&&
2287 (CURRENT_EXCEPTION_KIND
== EX_EVENT_CATCH
))
2289 annotate_catchpoint (bs
->breakpoint_at
->number
);
2290 printf_filtered (_("\nCatchpoint %d (exception caught), "),
2291 bs
->breakpoint_at
->number
);
2292 if (CURRENT_EXCEPTION_THROW_PC
&& CURRENT_EXCEPTION_THROW_LINE
)
2293 printf_filtered (_("throw location %s:%d, "),
2294 CURRENT_EXCEPTION_THROW_FILE
,
2295 CURRENT_EXCEPTION_THROW_LINE
);
2297 printf_filtered (_("throw location unknown, "));
2299 if (CURRENT_EXCEPTION_CATCH_PC
&& CURRENT_EXCEPTION_CATCH_LINE
)
2300 printf_filtered (_("catch location %s:%d\n"),
2301 CURRENT_EXCEPTION_CATCH_FILE
,
2302 CURRENT_EXCEPTION_CATCH_LINE
);
2304 printf_filtered (_("catch location unknown\n"));
2306 /* don't bother to print location frame info */
2307 return PRINT_SRC_ONLY
;
2311 /* really throw, some other bpstat will handle it */
2312 return PRINT_UNKNOWN
;
2316 case bp_catch_throw
:
2317 if (current_exception_event
&&
2318 (CURRENT_EXCEPTION_KIND
== EX_EVENT_THROW
))
2320 annotate_catchpoint (bs
->breakpoint_at
->number
);
2321 printf_filtered (_("\nCatchpoint %d (exception thrown), "),
2322 bs
->breakpoint_at
->number
);
2323 if (CURRENT_EXCEPTION_THROW_PC
&& CURRENT_EXCEPTION_THROW_LINE
)
2324 printf_filtered (_("throw location %s:%d, "),
2325 CURRENT_EXCEPTION_THROW_FILE
,
2326 CURRENT_EXCEPTION_THROW_LINE
);
2328 printf_filtered (_("throw location unknown, "));
2330 if (CURRENT_EXCEPTION_CATCH_PC
&& CURRENT_EXCEPTION_CATCH_LINE
)
2331 printf_filtered (_("catch location %s:%d\n"),
2332 CURRENT_EXCEPTION_CATCH_FILE
,
2333 CURRENT_EXCEPTION_CATCH_LINE
);
2335 printf_filtered (_("catch location unknown\n"));
2337 /* don't bother to print location frame info */
2338 return PRINT_SRC_ONLY
;
2342 /* really catch, some other bpstat will handle it */
2343 return PRINT_UNKNOWN
;
2348 case bp_hardware_watchpoint
:
2349 if (bs
->old_val
!= NULL
)
2351 annotate_watchpoint (bs
->breakpoint_at
->number
);
2352 if (ui_out_is_mi_like_p (uiout
))
2355 async_reason_lookup (EXEC_ASYNC_WATCHPOINT_TRIGGER
));
2356 mention (bs
->breakpoint_at
);
2357 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "value");
2358 ui_out_text (uiout
, "\nOld value = ");
2359 value_print (bs
->old_val
, stb
->stream
, 0, Val_pretty_default
);
2360 ui_out_field_stream (uiout
, "old", stb
);
2361 ui_out_text (uiout
, "\nNew value = ");
2362 value_print (bs
->breakpoint_at
->val
, stb
->stream
, 0, Val_pretty_default
);
2363 ui_out_field_stream (uiout
, "new", stb
);
2364 do_cleanups (ui_out_chain
);
2365 ui_out_text (uiout
, "\n");
2366 value_free (bs
->old_val
);
2369 /* More than one watchpoint may have been triggered. */
2370 return PRINT_UNKNOWN
;
2373 case bp_read_watchpoint
:
2374 if (ui_out_is_mi_like_p (uiout
))
2377 async_reason_lookup (EXEC_ASYNC_READ_WATCHPOINT_TRIGGER
));
2378 mention (bs
->breakpoint_at
);
2379 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "value");
2380 ui_out_text (uiout
, "\nValue = ");
2381 value_print (bs
->breakpoint_at
->val
, stb
->stream
, 0, Val_pretty_default
);
2382 ui_out_field_stream (uiout
, "value", stb
);
2383 do_cleanups (ui_out_chain
);
2384 ui_out_text (uiout
, "\n");
2385 return PRINT_UNKNOWN
;
2388 case bp_access_watchpoint
:
2389 if (bs
->old_val
!= NULL
)
2391 annotate_watchpoint (bs
->breakpoint_at
->number
);
2392 if (ui_out_is_mi_like_p (uiout
))
2395 async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER
));
2396 mention (bs
->breakpoint_at
);
2397 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "value");
2398 ui_out_text (uiout
, "\nOld value = ");
2399 value_print (bs
->old_val
, stb
->stream
, 0, Val_pretty_default
);
2400 ui_out_field_stream (uiout
, "old", stb
);
2401 value_free (bs
->old_val
);
2403 ui_out_text (uiout
, "\nNew value = ");
2407 mention (bs
->breakpoint_at
);
2408 if (ui_out_is_mi_like_p (uiout
))
2411 async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER
));
2412 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "value");
2413 ui_out_text (uiout
, "\nValue = ");
2415 value_print (bs
->breakpoint_at
->val
, stb
->stream
, 0,Val_pretty_default
);
2416 ui_out_field_stream (uiout
, "new", stb
);
2417 do_cleanups (ui_out_chain
);
2418 ui_out_text (uiout
, "\n");
2419 return PRINT_UNKNOWN
;
2422 /* Fall through, we don't deal with these types of breakpoints
2426 if (ui_out_is_mi_like_p (uiout
))
2429 async_reason_lookup (EXEC_ASYNC_FUNCTION_FINISHED
));
2430 return PRINT_UNKNOWN
;
2434 if (ui_out_is_mi_like_p (uiout
))
2437 async_reason_lookup (EXEC_ASYNC_LOCATION_REACHED
));
2438 return PRINT_UNKNOWN
;
2443 case bp_longjmp_resume
:
2444 case bp_step_resume
:
2445 case bp_watchpoint_scope
:
2448 return PRINT_UNKNOWN
;
2452 /* Generic routine for printing messages indicating why we
2453 stopped. The behavior of this function depends on the value
2454 'print_it' in the bpstat structure. Under some circumstances we
2455 may decide not to print anything here and delegate the task to
2458 static enum print_stop_action
2459 print_bp_stop_message (bpstat bs
)
2461 switch (bs
->print_it
)
2464 /* Nothing should be printed for this bpstat entry. */
2465 return PRINT_UNKNOWN
;
2469 /* We still want to print the frame, but we already printed the
2470 relevant messages. */
2471 return PRINT_SRC_AND_LOC
;
2474 case print_it_normal
:
2475 /* Normal case. Call the breakpoint's print_it method, or
2476 print_it_typical. */
2477 if (bs
->breakpoint_at
!= NULL
&& bs
->breakpoint_at
->ops
!= NULL
2478 && bs
->breakpoint_at
->ops
->print_it
!= NULL
)
2479 return bs
->breakpoint_at
->ops
->print_it (bs
->breakpoint_at
);
2481 return print_it_typical (bs
);
2485 internal_error (__FILE__
, __LINE__
,
2486 _("print_bp_stop_message: unrecognized enum value"));
2491 /* Print a message indicating what happened. This is called from
2492 normal_stop(). The input to this routine is the head of the bpstat
2493 list - a list of the eventpoints that caused this stop. This
2494 routine calls the generic print routine for printing a message
2495 about reasons for stopping. This will print (for example) the
2496 "Breakpoint n," part of the output. The return value of this
2499 PRINT_UNKNOWN: Means we printed nothing
2500 PRINT_SRC_AND_LOC: Means we printed something, and expect subsequent
2501 code to print the location. An example is
2502 "Breakpoint 1, " which should be followed by
2504 PRINT_SRC_ONLY: Means we printed something, but there is no need
2505 to also print the location part of the message.
2506 An example is the catch/throw messages, which
2507 don't require a location appended to the end.
2508 PRINT_NOTHING: We have done some printing and we don't need any
2509 further info to be printed.*/
2511 enum print_stop_action
2512 bpstat_print (bpstat bs
)
2516 /* Maybe another breakpoint in the chain caused us to stop.
2517 (Currently all watchpoints go on the bpstat whether hit or not.
2518 That probably could (should) be changed, provided care is taken
2519 with respect to bpstat_explains_signal). */
2520 for (; bs
; bs
= bs
->next
)
2522 val
= print_bp_stop_message (bs
);
2523 if (val
== PRINT_SRC_ONLY
2524 || val
== PRINT_SRC_AND_LOC
2525 || val
== PRINT_NOTHING
)
2529 /* We reached the end of the chain, or we got a null BS to start
2530 with and nothing was printed. */
2531 return PRINT_UNKNOWN
;
2534 /* Evaluate the expression EXP and return 1 if value is zero.
2535 This is used inside a catch_errors to evaluate the breakpoint condition.
2536 The argument is a "struct expression *" that has been cast to char * to
2537 make it pass through catch_errors. */
2540 breakpoint_cond_eval (void *exp
)
2542 struct value
*mark
= value_mark ();
2543 int i
= !value_true (evaluate_expression ((struct expression
*) exp
));
2544 value_free_to_mark (mark
);
2548 /* Allocate a new bpstat and chain it to the current one. */
2551 bpstat_alloc (struct breakpoint
*b
, bpstat cbs
/* Current "bs" value */ )
2555 bs
= (bpstat
) xmalloc (sizeof (*bs
));
2557 bs
->breakpoint_at
= b
;
2558 /* If the condition is false, etc., don't do the commands. */
2559 bs
->commands
= NULL
;
2561 bs
->print_it
= print_it_normal
;
2565 /* Possible return values for watchpoint_check (this can't be an enum
2566 because of check_errors). */
2567 /* The watchpoint has been deleted. */
2568 #define WP_DELETED 1
2569 /* The value has changed. */
2570 #define WP_VALUE_CHANGED 2
2571 /* The value has not changed. */
2572 #define WP_VALUE_NOT_CHANGED 3
2574 #define BP_TEMPFLAG 1
2575 #define BP_HARDWAREFLAG 2
2577 /* Check watchpoint condition. */
2580 watchpoint_check (void *p
)
2582 bpstat bs
= (bpstat
) p
;
2583 struct breakpoint
*b
;
2584 struct frame_info
*fr
;
2585 int within_current_scope
;
2587 b
= bs
->breakpoint_at
;
2589 if (b
->exp_valid_block
== NULL
)
2590 within_current_scope
= 1;
2593 /* There is no current frame at this moment. If we're going to have
2594 any chance of handling watchpoints on local variables, we'll need
2595 the frame chain (so we can determine if we're in scope). */
2596 reinit_frame_cache ();
2597 fr
= frame_find_by_id (b
->watchpoint_frame
);
2598 within_current_scope
= (fr
!= NULL
);
2600 /* If we've gotten confused in the unwinder, we might have
2601 returned a frame that can't describe this variable. */
2602 if (within_current_scope
2603 && block_function (b
->exp_valid_block
) != get_frame_function (fr
))
2604 within_current_scope
= 0;
2606 /* in_function_epilogue_p() returns a non-zero value if we're still
2607 in the function but the stack frame has already been invalidated.
2608 Since we can't rely on the values of local variables after the
2609 stack has been destroyed, we are treating the watchpoint in that
2610 state as `not changed' without further checking.
2612 vinschen/2003-09-04: The former implementation left out the case
2613 that the watchpoint frame couldn't be found by frame_find_by_id()
2614 because the current PC is currently in an epilogue. Calling
2615 gdbarch_in_function_epilogue_p() also when fr == NULL fixes that. */
2616 if ((!within_current_scope
|| fr
== get_current_frame ())
2617 && gdbarch_in_function_epilogue_p (current_gdbarch
, read_pc ()))
2618 return WP_VALUE_NOT_CHANGED
;
2619 if (fr
&& within_current_scope
)
2620 /* If we end up stopping, the current frame will get selected
2621 in normal_stop. So this call to select_frame won't affect
2626 if (within_current_scope
)
2628 /* We use value_{,free_to_}mark because it could be a
2629 *long* time before we return to the command level and
2630 call free_all_values. We can't call free_all_values because
2631 we might be in the middle of evaluating a function call. */
2633 struct value
*mark
= value_mark ();
2634 struct value
*new_val
= evaluate_expression (bs
->breakpoint_at
->exp
);
2635 if (!value_equal (b
->val
, new_val
))
2637 release_value (new_val
);
2638 value_free_to_mark (mark
);
2639 bs
->old_val
= b
->val
;
2641 /* We will stop here */
2642 return WP_VALUE_CHANGED
;
2646 /* Nothing changed, don't do anything. */
2647 value_free_to_mark (mark
);
2648 /* We won't stop here */
2649 return WP_VALUE_NOT_CHANGED
;
2654 /* This seems like the only logical thing to do because
2655 if we temporarily ignored the watchpoint, then when
2656 we reenter the block in which it is valid it contains
2657 garbage (in the case of a function, it may have two
2658 garbage values, one before and one after the prologue).
2659 So we can't even detect the first assignment to it and
2660 watch after that (since the garbage may or may not equal
2661 the first value assigned). */
2662 /* We print all the stop information in print_it_typical(), but
2663 in this case, by the time we call print_it_typical() this bp
2664 will be deleted already. So we have no choice but print the
2665 information here. */
2666 if (ui_out_is_mi_like_p (uiout
))
2668 (uiout
, "reason", async_reason_lookup (EXEC_ASYNC_WATCHPOINT_SCOPE
));
2669 ui_out_text (uiout
, "\nWatchpoint ");
2670 ui_out_field_int (uiout
, "wpnum", bs
->breakpoint_at
->number
);
2671 ui_out_text (uiout
, " deleted because the program has left the block in\n\
2672 which its expression is valid.\n");
2674 if (b
->related_breakpoint
)
2675 b
->related_breakpoint
->disposition
= disp_del_at_next_stop
;
2676 b
->disposition
= disp_del_at_next_stop
;
2682 /* Get a bpstat associated with having just stopped at address
2683 BP_ADDR in thread PTID. STOPPED_BY_WATCHPOINT is 1 if the
2684 target thinks we stopped due to a hardware watchpoint, 0 if we
2685 know we did not trigger a hardware watchpoint, and -1 if we do not know. */
2687 /* Determine whether we stopped at a breakpoint, etc, or whether we
2688 don't understand this stop. Result is a chain of bpstat's such that:
2690 if we don't understand the stop, the result is a null pointer.
2692 if we understand why we stopped, the result is not null.
2694 Each element of the chain refers to a particular breakpoint or
2695 watchpoint at which we have stopped. (We may have stopped for
2696 several reasons concurrently.)
2698 Each element of the chain has valid next, breakpoint_at,
2699 commands, FIXME??? fields. */
2702 bpstat_stop_status (CORE_ADDR bp_addr
, ptid_t ptid
, int stopped_by_watchpoint
)
2704 struct breakpoint
*b
, *temp
;
2705 /* True if we've hit a breakpoint (as opposed to a watchpoint). */
2706 int real_breakpoint
= 0;
2707 /* Root of the chain of bpstat's */
2708 struct bpstats root_bs
[1];
2709 /* Pointer to the last thing in the chain currently. */
2710 bpstat bs
= root_bs
;
2711 int thread_id
= pid_to_thread_id (ptid
);
2713 ALL_BREAKPOINTS_SAFE (b
, temp
)
2715 if (!breakpoint_enabled (b
) && b
->enable_state
!= bp_permanent
)
2718 if (b
->type
!= bp_watchpoint
2719 && b
->type
!= bp_hardware_watchpoint
2720 && b
->type
!= bp_read_watchpoint
2721 && b
->type
!= bp_access_watchpoint
2722 && b
->type
!= bp_hardware_breakpoint
2723 && b
->type
!= bp_catch_fork
2724 && b
->type
!= bp_catch_vfork
2725 && b
->type
!= bp_catch_exec
2726 && b
->type
!= bp_catch_catch
2727 && b
->type
!= bp_catch_throw
) /* a non-watchpoint bp */
2729 if (b
->loc
->address
!= bp_addr
) /* address doesn't match */
2731 if (overlay_debugging
/* unmapped overlay section */
2732 && section_is_overlay (b
->loc
->section
)
2733 && !section_is_mapped (b
->loc
->section
))
2737 /* Continuable hardware watchpoints are treated as non-existent if the
2738 reason we stopped wasn't a hardware watchpoint (we didn't stop on
2739 some data address). Otherwise gdb won't stop on a break instruction
2740 in the code (not from a breakpoint) when a hardware watchpoint has
2743 if ((b
->type
== bp_hardware_watchpoint
2744 || b
->type
== bp_read_watchpoint
2745 || b
->type
== bp_access_watchpoint
)
2746 && !stopped_by_watchpoint
)
2749 if (b
->type
== bp_hardware_breakpoint
)
2751 if (b
->loc
->address
!= bp_addr
)
2753 if (overlay_debugging
/* unmapped overlay section */
2754 && section_is_overlay (b
->loc
->section
)
2755 && !section_is_mapped (b
->loc
->section
))
2759 /* Is this a catchpoint of a load or unload? If so, did we
2760 get a load or unload of the specified library? If not,
2762 if ((b
->type
== bp_catch_load
)
2763 #if defined(SOLIB_HAVE_LOAD_EVENT)
2764 && (!SOLIB_HAVE_LOAD_EVENT (PIDGET (inferior_ptid
))
2765 || ((b
->dll_pathname
!= NULL
)
2766 && (strcmp (b
->dll_pathname
,
2767 SOLIB_LOADED_LIBRARY_PATHNAME (
2768 PIDGET (inferior_ptid
)))
2774 if ((b
->type
== bp_catch_unload
)
2775 #if defined(SOLIB_HAVE_UNLOAD_EVENT)
2776 && (!SOLIB_HAVE_UNLOAD_EVENT (PIDGET (inferior_ptid
))
2777 || ((b
->dll_pathname
!= NULL
)
2778 && (strcmp (b
->dll_pathname
,
2779 SOLIB_UNLOADED_LIBRARY_PATHNAME (
2780 PIDGET (inferior_ptid
)))
2786 if ((b
->type
== bp_catch_fork
)
2787 && !inferior_has_forked (PIDGET (inferior_ptid
),
2788 &b
->forked_inferior_pid
))
2791 if ((b
->type
== bp_catch_vfork
)
2792 && !inferior_has_vforked (PIDGET (inferior_ptid
),
2793 &b
->forked_inferior_pid
))
2796 if ((b
->type
== bp_catch_exec
)
2797 && !inferior_has_execd (PIDGET (inferior_ptid
), &b
->exec_pathname
))
2800 if (ep_is_exception_catchpoint (b
) &&
2801 !(current_exception_event
= target_get_current_exception_event ()))
2804 /* Come here if it's a watchpoint, or if the break address matches */
2806 bs
= bpstat_alloc (b
, bs
); /* Alloc a bpstat to explain stop */
2808 /* Watchpoints may change this, if not found to have triggered. */
2812 if (b
->type
== bp_watchpoint
||
2813 b
->type
== bp_hardware_watchpoint
)
2815 char *message
= xstrprintf ("Error evaluating expression for watchpoint %d\n",
2817 struct cleanup
*cleanups
= make_cleanup (xfree
, message
);
2818 int e
= catch_errors (watchpoint_check
, bs
, message
,
2820 do_cleanups (cleanups
);
2824 /* We've already printed what needs to be printed. */
2825 /* Actually this is superfluous, because by the time we
2826 call print_it_typical() the wp will be already deleted,
2827 and the function will return immediately. */
2828 bs
->print_it
= print_it_done
;
2831 case WP_VALUE_CHANGED
:
2835 case WP_VALUE_NOT_CHANGED
:
2837 bs
->print_it
= print_it_noop
;
2844 /* Error from catch_errors. */
2845 printf_filtered (_("Watchpoint %d deleted.\n"), b
->number
);
2846 if (b
->related_breakpoint
)
2847 b
->related_breakpoint
->disposition
= disp_del_at_next_stop
;
2848 b
->disposition
= disp_del_at_next_stop
;
2849 /* We've already printed what needs to be printed. */
2850 bs
->print_it
= print_it_done
;
2856 else if (b
->type
== bp_read_watchpoint
||
2857 b
->type
== bp_access_watchpoint
)
2863 if (!target_stopped_data_address (¤t_target
, &addr
))
2865 for (v
= b
->val_chain
; v
; v
= value_next (v
))
2867 if (VALUE_LVAL (v
) == lval_memory
2868 && ! value_lazy (v
))
2870 struct type
*vtype
= check_typedef (value_type (v
));
2872 if (v
== b
->val_chain
2873 || (TYPE_CODE (vtype
) != TYPE_CODE_STRUCT
2874 && TYPE_CODE (vtype
) != TYPE_CODE_ARRAY
))
2878 vaddr
= VALUE_ADDRESS (v
) + value_offset (v
);
2879 /* Exact match not required. Within range is
2881 if (addr
>= vaddr
&&
2882 addr
< vaddr
+ TYPE_LENGTH (value_type (v
)))
2889 char *message
= xstrprintf ("Error evaluating expression for watchpoint %d\n",
2891 struct cleanup
*cleanups
= make_cleanup (xfree
, message
);
2892 int e
= catch_errors (watchpoint_check
, bs
, message
,
2894 do_cleanups (cleanups
);
2898 /* We've already printed what needs to be printed. */
2899 bs
->print_it
= print_it_done
;
2902 case WP_VALUE_CHANGED
:
2903 if (b
->type
== bp_read_watchpoint
)
2905 /* Don't stop: read watchpoints shouldn't fire if
2906 the value has changed. This is for targets
2907 which cannot set read-only watchpoints. */
2908 bs
->print_it
= print_it_noop
;
2914 case WP_VALUE_NOT_CHANGED
:
2921 /* Error from catch_errors. */
2922 printf_filtered (_("Watchpoint %d deleted.\n"), b
->number
);
2923 if (b
->related_breakpoint
)
2924 b
->related_breakpoint
->disposition
= disp_del_at_next_stop
;
2925 b
->disposition
= disp_del_at_next_stop
;
2926 /* We've already printed what needs to be printed. */
2927 bs
->print_it
= print_it_done
;
2931 else /* found == 0 */
2933 /* This is a case where some watchpoint(s) triggered,
2934 but not at the address of this watchpoint (FOUND
2935 was left zero). So don't print anything for this
2937 bs
->print_it
= print_it_noop
;
2944 /* By definition, an encountered breakpoint is a triggered
2948 real_breakpoint
= 1;
2951 if (frame_id_p (b
->frame_id
)
2952 && !frame_id_eq (b
->frame_id
, get_frame_id (get_current_frame ())))
2956 int value_is_zero
= 0;
2960 /* Need to select the frame, with all that implies
2961 so that the conditions will have the right context. */
2962 select_frame (get_current_frame ());
2964 = catch_errors (breakpoint_cond_eval
, (b
->cond
),
2965 "Error in testing breakpoint condition:\n",
2967 /* FIXME-someday, should give breakpoint # */
2970 if (b
->cond
&& value_is_zero
)
2973 /* Don't consider this a hit. */
2976 else if (b
->thread
!= -1 && b
->thread
!= thread_id
)
2979 /* Don't consider this a hit. */
2982 else if (b
->ignore_count
> 0)
2985 annotate_ignore_count_change ();
2990 /* We will stop here */
2991 if (b
->disposition
== disp_disable
)
2992 b
->enable_state
= bp_disabled
;
2995 bs
->commands
= b
->commands
;
2997 (strcmp ("silent", bs
->commands
->line
) == 0
2998 || (xdb_commands
&& strcmp ("Q", bs
->commands
->line
) == 0)))
3000 bs
->commands
= bs
->commands
->next
;
3003 bs
->commands
= copy_command_lines (bs
->commands
);
3006 /* Print nothing for this entry if we dont stop or if we dont print. */
3007 if (bs
->stop
== 0 || bs
->print
== 0)
3008 bs
->print_it
= print_it_noop
;
3011 bs
->next
= NULL
; /* Terminate the chain */
3012 bs
= root_bs
->next
; /* Re-grab the head of the chain */
3014 /* The value of a hardware watchpoint hasn't changed, but the
3015 intermediate memory locations we are watching may have. */
3016 if (bs
&& !bs
->stop
&&
3017 (bs
->breakpoint_at
->type
== bp_hardware_watchpoint
||
3018 bs
->breakpoint_at
->type
== bp_read_watchpoint
||
3019 bs
->breakpoint_at
->type
== bp_access_watchpoint
))
3021 remove_breakpoints ();
3022 insert_breakpoints ();
3027 /* Tell what to do about this bpstat. */
3029 bpstat_what (bpstat bs
)
3031 /* Classify each bpstat as one of the following. */
3034 /* This bpstat element has no effect on the main_action. */
3037 /* There was a watchpoint, stop but don't print. */
3040 /* There was a watchpoint, stop and print. */
3043 /* There was a breakpoint but we're not stopping. */
3046 /* There was a breakpoint, stop but don't print. */
3049 /* There was a breakpoint, stop and print. */
3052 /* We hit the longjmp breakpoint. */
3055 /* We hit the longjmp_resume breakpoint. */
3058 /* We hit the step_resume breakpoint. */
3061 /* We hit the shared library event breakpoint. */
3064 /* We caught a shared library event. */
3067 /* This is just used to count how many enums there are. */
3071 /* Here is the table which drives this routine. So that we can
3072 format it pretty, we define some abbreviations for the
3073 enum bpstat_what codes. */
3074 #define kc BPSTAT_WHAT_KEEP_CHECKING
3075 #define ss BPSTAT_WHAT_STOP_SILENT
3076 #define sn BPSTAT_WHAT_STOP_NOISY
3077 #define sgl BPSTAT_WHAT_SINGLE
3078 #define slr BPSTAT_WHAT_SET_LONGJMP_RESUME
3079 #define clr BPSTAT_WHAT_CLEAR_LONGJMP_RESUME
3080 #define clrs BPSTAT_WHAT_CLEAR_LONGJMP_RESUME_SINGLE
3081 #define sr BPSTAT_WHAT_STEP_RESUME
3082 #define shl BPSTAT_WHAT_CHECK_SHLIBS
3083 #define shlr BPSTAT_WHAT_CHECK_SHLIBS_RESUME_FROM_HOOK
3085 /* "Can't happen." Might want to print an error message.
3086 abort() is not out of the question, but chances are GDB is just
3087 a bit confused, not unusable. */
3088 #define err BPSTAT_WHAT_STOP_NOISY
3090 /* Given an old action and a class, come up with a new action. */
3091 /* One interesting property of this table is that wp_silent is the same
3092 as bp_silent and wp_noisy is the same as bp_noisy. That is because
3093 after stopping, the check for whether to step over a breakpoint
3094 (BPSTAT_WHAT_SINGLE type stuff) is handled in proceed() without
3095 reference to how we stopped. We retain separate wp_silent and
3096 bp_silent codes in case we want to change that someday.
3098 Another possibly interesting property of this table is that
3099 there's a partial ordering, priority-like, of the actions. Once
3100 you've decided that some action is appropriate, you'll never go
3101 back and decide something of a lower priority is better. The
3104 kc < clr sgl shl shlr slr sn sr ss
3105 sgl < clrs shl shlr slr sn sr ss
3106 slr < err shl shlr sn sr ss
3107 clr < clrs err shl shlr sn sr ss
3108 clrs < err shl shlr sn sr ss
3115 What I think this means is that we don't need a damned table
3116 here. If you just put the rows and columns in the right order,
3117 it'd look awfully regular. We could simply walk the bpstat list
3118 and choose the highest priority action we find, with a little
3119 logic to handle the 'err' cases, and the CLEAR_LONGJMP_RESUME/
3120 CLEAR_LONGJMP_RESUME_SINGLE distinction (which breakpoint.h says
3121 is messy anyway). */
3123 /* step_resume entries: a step resume breakpoint overrides another
3124 breakpoint of signal handling (see comment in wait_for_inferior
3125 at where we set the step_resume breakpoint). */
3127 static const enum bpstat_what_main_action
3128 table
[(int) class_last
][(int) BPSTAT_WHAT_LAST
] =
3131 /* kc ss sn sgl slr clr clrs sr shl shlr
3134 {kc
, ss
, sn
, sgl
, slr
, clr
, clrs
, sr
, shl
, shlr
},
3136 {ss
, ss
, sn
, ss
, ss
, ss
, ss
, sr
, shl
, shlr
},
3138 {sn
, sn
, sn
, sn
, sn
, sn
, sn
, sr
, shl
, shlr
},
3140 {sgl
, ss
, sn
, sgl
, slr
, clrs
, clrs
, sr
, shl
, shlr
},
3142 {ss
, ss
, sn
, ss
, ss
, ss
, ss
, sr
, shl
, shlr
},
3144 {sn
, sn
, sn
, sn
, sn
, sn
, sn
, sr
, shl
, shlr
},
3146 {slr
, ss
, sn
, slr
, slr
, err
, err
, sr
, shl
, shlr
},
3148 {clr
, ss
, sn
, clrs
, err
, err
, err
, sr
, shl
, shlr
},
3150 {sr
, sr
, sr
, sr
, sr
, sr
, sr
, sr
, sr
, sr
},
3152 {shl
, shl
, shl
, shl
, shl
, shl
, shl
, sr
, shl
, shlr
},
3154 {shlr
, shlr
, shlr
, shlr
, shlr
, shlr
, shlr
, sr
, shlr
, shlr
}
3169 enum bpstat_what_main_action current_action
= BPSTAT_WHAT_KEEP_CHECKING
;
3170 struct bpstat_what retval
;
3172 retval
.call_dummy
= 0;
3173 for (; bs
!= NULL
; bs
= bs
->next
)
3175 enum class bs_class
= no_effect
;
3176 if (bs
->breakpoint_at
== NULL
)
3177 /* I suspect this can happen if it was a momentary breakpoint
3178 which has since been deleted. */
3180 switch (bs
->breakpoint_at
->type
)
3186 case bp_hardware_breakpoint
:
3192 bs_class
= bp_noisy
;
3194 bs_class
= bp_silent
;
3197 bs_class
= bp_nostop
;
3200 case bp_hardware_watchpoint
:
3201 case bp_read_watchpoint
:
3202 case bp_access_watchpoint
:
3206 bs_class
= wp_noisy
;
3208 bs_class
= wp_silent
;
3211 /* There was a watchpoint, but we're not stopping.
3212 This requires no further action. */
3213 bs_class
= no_effect
;
3216 bs_class
= long_jump
;
3218 case bp_longjmp_resume
:
3219 bs_class
= long_resume
;
3221 case bp_step_resume
:
3224 bs_class
= step_resume
;
3227 /* It is for the wrong frame. */
3228 bs_class
= bp_nostop
;
3230 case bp_watchpoint_scope
:
3231 bs_class
= bp_nostop
;
3233 case bp_shlib_event
:
3234 bs_class
= shlib_event
;
3236 case bp_thread_event
:
3237 case bp_overlay_event
:
3238 bs_class
= bp_nostop
;
3241 case bp_catch_unload
:
3242 /* Only if this catchpoint triggered should we cause the
3243 step-out-of-dld behaviour. Otherwise, we ignore this
3246 bs_class
= catch_shlib_event
;
3248 bs_class
= no_effect
;
3251 case bp_catch_vfork
:
3256 bs_class
= bp_noisy
;
3258 bs_class
= bp_silent
;
3261 /* There was a catchpoint, but we're not stopping.
3262 This requires no further action. */
3263 bs_class
= no_effect
;
3265 case bp_catch_catch
:
3266 if (!bs
->stop
|| CURRENT_EXCEPTION_KIND
!= EX_EVENT_CATCH
)
3267 bs_class
= bp_nostop
;
3269 bs_class
= bs
->print
? bp_noisy
: bp_silent
;
3271 case bp_catch_throw
:
3272 if (!bs
->stop
|| CURRENT_EXCEPTION_KIND
!= EX_EVENT_THROW
)
3273 bs_class
= bp_nostop
;
3275 bs_class
= bs
->print
? bp_noisy
: bp_silent
;
3278 /* Make sure the action is stop (silent or noisy),
3279 so infrun.c pops the dummy frame. */
3280 bs_class
= bp_silent
;
3281 retval
.call_dummy
= 1;
3284 current_action
= table
[(int) bs_class
][(int) current_action
];
3286 retval
.main_action
= current_action
;
3290 /* Nonzero if we should step constantly (e.g. watchpoints on machines
3291 without hardware support). This isn't related to a specific bpstat,
3292 just to things like whether watchpoints are set. */
3295 bpstat_should_step (void)
3297 struct breakpoint
*b
;
3299 if (breakpoint_enabled (b
) && b
->type
== bp_watchpoint
)
3304 /* Nonzero if there are enabled hardware watchpoints. */
3306 bpstat_have_active_hw_watchpoints (void)
3308 struct bp_location
*bpt
;
3309 ALL_BP_LOCATIONS (bpt
)
3310 if (breakpoint_enabled (bpt
->owner
)
3312 && bpt
->loc_type
== bp_loc_hardware_watchpoint
)
3318 /* Given a bpstat that records zero or more triggered eventpoints, this
3319 function returns another bpstat which contains only the catchpoints
3320 on that first list, if any. */
3322 bpstat_get_triggered_catchpoints (bpstat ep_list
, bpstat
*cp_list
)
3324 struct bpstats root_bs
[1];
3325 bpstat bs
= root_bs
;
3326 struct breakpoint
*ep
;
3329 bpstat_clear (cp_list
);
3330 root_bs
->next
= NULL
;
3332 for (; ep_list
!= NULL
; ep_list
= ep_list
->next
)
3334 /* Is this eventpoint a catchpoint? If not, ignore it. */
3335 ep
= ep_list
->breakpoint_at
;
3338 if ((ep
->type
!= bp_catch_load
) &&
3339 (ep
->type
!= bp_catch_unload
) &&
3340 (ep
->type
!= bp_catch_catch
) &&
3341 (ep
->type
!= bp_catch_throw
))
3342 /* pai: (temp) ADD fork/vfork here!! */
3345 /* Yes; add it to the list. */
3346 bs
= bpstat_alloc (ep
, bs
);
3351 #if defined(SOLIB_ADD)
3352 /* Also, for each triggered catchpoint, tag it with the name of
3353 the library that caused this trigger. (We copy the name now,
3354 because it's only guaranteed to be available NOW, when the
3355 catchpoint triggers. Clients who may wish to know the name
3356 later must get it from the catchpoint itself.) */
3357 if (ep
->triggered_dll_pathname
!= NULL
)
3358 xfree (ep
->triggered_dll_pathname
);
3359 if (ep
->type
== bp_catch_load
)
3360 dll_pathname
= SOLIB_LOADED_LIBRARY_PATHNAME (
3361 PIDGET (inferior_ptid
));
3363 dll_pathname
= SOLIB_UNLOADED_LIBRARY_PATHNAME (
3364 PIDGET (inferior_ptid
));
3366 dll_pathname
= NULL
;
3370 ep
->triggered_dll_pathname
= (char *)
3371 xmalloc (strlen (dll_pathname
) + 1);
3372 strcpy (ep
->triggered_dll_pathname
, dll_pathname
);
3375 ep
->triggered_dll_pathname
= NULL
;
3381 /* Print B to gdb_stdout. */
3383 print_one_breakpoint (struct breakpoint
*b
,
3384 CORE_ADDR
*last_addr
)
3386 struct command_line
*l
;
3388 struct ep_type_description
3393 static struct ep_type_description bptypes
[] =
3395 {bp_none
, "?deleted?"},
3396 {bp_breakpoint
, "breakpoint"},
3397 {bp_hardware_breakpoint
, "hw breakpoint"},
3398 {bp_until
, "until"},
3399 {bp_finish
, "finish"},
3400 {bp_watchpoint
, "watchpoint"},
3401 {bp_hardware_watchpoint
, "hw watchpoint"},
3402 {bp_read_watchpoint
, "read watchpoint"},
3403 {bp_access_watchpoint
, "acc watchpoint"},
3404 {bp_longjmp
, "longjmp"},
3405 {bp_longjmp_resume
, "longjmp resume"},
3406 {bp_step_resume
, "step resume"},
3407 {bp_watchpoint_scope
, "watchpoint scope"},
3408 {bp_call_dummy
, "call dummy"},
3409 {bp_shlib_event
, "shlib events"},
3410 {bp_thread_event
, "thread events"},
3411 {bp_overlay_event
, "overlay events"},
3412 {bp_catch_load
, "catch load"},
3413 {bp_catch_unload
, "catch unload"},
3414 {bp_catch_fork
, "catch fork"},
3415 {bp_catch_vfork
, "catch vfork"},
3416 {bp_catch_exec
, "catch exec"},
3417 {bp_catch_catch
, "catch catch"},
3418 {bp_catch_throw
, "catch throw"}
3421 static char *bpdisps
[] =
3422 {"del", "dstp", "dis", "keep"};
3423 static char bpenables
[] = "nynny";
3424 char wrap_indent
[80];
3425 struct ui_stream
*stb
= ui_out_stream_new (uiout
);
3426 struct cleanup
*old_chain
= make_cleanup_ui_out_stream_delete (stb
);
3427 struct cleanup
*bkpt_chain
;
3430 bkpt_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "bkpt");
3434 ui_out_field_int (uiout
, "number", b
->number
);
3438 if (((int) b
->type
> (sizeof (bptypes
) / sizeof (bptypes
[0])))
3439 || ((int) b
->type
!= bptypes
[(int) b
->type
].type
))
3440 internal_error (__FILE__
, __LINE__
,
3441 _("bptypes table does not describe type #%d."),
3443 ui_out_field_string (uiout
, "type", bptypes
[(int) b
->type
].description
);
3447 ui_out_field_string (uiout
, "disp", bpdisps
[(int) b
->disposition
]);
3451 ui_out_field_fmt (uiout
, "enabled", "%c", bpenables
[(int) b
->enable_state
]);
3452 ui_out_spaces (uiout
, 2);
3455 strcpy (wrap_indent
, " ");
3458 if (TARGET_ADDR_BIT
<= 32)
3459 strcat (wrap_indent
, " ");
3461 strcat (wrap_indent
, " ");
3464 if (b
->ops
!= NULL
&& b
->ops
->print_one
!= NULL
)
3465 b
->ops
->print_one (b
, last_addr
);
3470 internal_error (__FILE__
, __LINE__
,
3471 _("print_one_breakpoint: bp_none encountered\n"));
3475 case bp_hardware_watchpoint
:
3476 case bp_read_watchpoint
:
3477 case bp_access_watchpoint
:
3478 /* Field 4, the address, is omitted (which makes the columns
3479 not line up too nicely with the headers, but the effect
3480 is relatively readable). */
3482 ui_out_field_skip (uiout
, "addr");
3484 print_expression (b
->exp
, stb
->stream
);
3485 ui_out_field_stream (uiout
, "what", stb
);
3489 case bp_catch_unload
:
3490 /* Field 4, the address, is omitted (which makes the columns
3491 not line up too nicely with the headers, but the effect
3492 is relatively readable). */
3494 ui_out_field_skip (uiout
, "addr");
3496 if (b
->dll_pathname
== NULL
)
3498 ui_out_field_string (uiout
, "what", "<any library>");
3499 ui_out_spaces (uiout
, 1);
3503 ui_out_text (uiout
, "library \"");
3504 ui_out_field_string (uiout
, "what", b
->dll_pathname
);
3505 ui_out_text (uiout
, "\" ");
3510 case bp_catch_vfork
:
3511 /* Field 4, the address, is omitted (which makes the columns
3512 not line up too nicely with the headers, but the effect
3513 is relatively readable). */
3515 ui_out_field_skip (uiout
, "addr");
3517 if (b
->forked_inferior_pid
!= 0)
3519 ui_out_text (uiout
, "process ");
3520 ui_out_field_int (uiout
, "what", b
->forked_inferior_pid
);
3521 ui_out_spaces (uiout
, 1);
3526 /* Field 4, the address, is omitted (which makes the columns
3527 not line up too nicely with the headers, but the effect
3528 is relatively readable). */
3530 ui_out_field_skip (uiout
, "addr");
3532 if (b
->exec_pathname
!= NULL
)
3534 ui_out_text (uiout
, "program \"");
3535 ui_out_field_string (uiout
, "what", b
->exec_pathname
);
3536 ui_out_text (uiout
, "\" ");
3540 case bp_catch_catch
:
3541 /* Field 4, the address, is omitted (which makes the columns
3542 not line up too nicely with the headers, but the effect
3543 is relatively readable). */
3545 ui_out_field_skip (uiout
, "addr");
3547 ui_out_field_string (uiout
, "what", "exception catch");
3548 ui_out_spaces (uiout
, 1);
3551 case bp_catch_throw
:
3552 /* Field 4, the address, is omitted (which makes the columns
3553 not line up too nicely with the headers, but the effect
3554 is relatively readable). */
3556 ui_out_field_skip (uiout
, "addr");
3558 ui_out_field_string (uiout
, "what", "exception throw");
3559 ui_out_spaces (uiout
, 1);
3563 case bp_hardware_breakpoint
:
3567 case bp_longjmp_resume
:
3568 case bp_step_resume
:
3569 case bp_watchpoint_scope
:
3571 case bp_shlib_event
:
3572 case bp_thread_event
:
3573 case bp_overlay_event
:
3578 ui_out_field_string (uiout
, "addr", "<PENDING>");
3580 ui_out_field_core_addr (uiout
, "addr", b
->loc
->address
);
3583 *last_addr
= b
->loc
->address
;
3586 sym
= find_pc_sect_function (b
->loc
->address
, b
->loc
->section
);
3589 ui_out_text (uiout
, "in ");
3590 ui_out_field_string (uiout
, "func",
3591 SYMBOL_PRINT_NAME (sym
));
3592 ui_out_wrap_hint (uiout
, wrap_indent
);
3593 ui_out_text (uiout
, " at ");
3595 ui_out_field_string (uiout
, "file", b
->source_file
);
3596 ui_out_text (uiout
, ":");
3598 if (ui_out_is_mi_like_p (uiout
))
3600 struct symtab_and_line sal
= find_pc_line (b
->loc
->address
, 0);
3601 char *fullname
= symtab_to_fullname (sal
.symtab
);
3604 ui_out_field_string (uiout
, "fullname", fullname
);
3607 ui_out_field_int (uiout
, "line", b
->line_number
);
3609 else if (b
->pending
)
3611 ui_out_field_string (uiout
, "pending", b
->addr_string
);
3615 print_address_symbolic (b
->loc
->address
, stb
->stream
, demangle
, "");
3616 ui_out_field_stream (uiout
, "at", stb
);
3621 if (b
->thread
!= -1)
3623 /* FIXME: This seems to be redundant and lost here; see the
3624 "stop only in" line a little further down. */
3625 ui_out_text (uiout
, " thread ");
3626 ui_out_field_int (uiout
, "thread", b
->thread
);
3629 ui_out_text (uiout
, "\n");
3631 if (frame_id_p (b
->frame_id
))
3634 ui_out_text (uiout
, "\tstop only in stack frame at ");
3635 /* FIXME: cagney/2002-12-01: Shouldn't be poeking around inside
3637 ui_out_field_core_addr (uiout
, "frame", b
->frame_id
.stack_addr
);
3638 ui_out_text (uiout
, "\n");
3641 if (b
->cond
&& !ada_exception_catchpoint_p (b
))
3643 /* We do not print the condition for Ada exception catchpoints
3644 because the condition is an internal implementation detail
3645 that we do not want to expose to the user. */
3647 ui_out_text (uiout
, "\tstop only if ");
3648 print_expression (b
->cond
, stb
->stream
);
3649 ui_out_field_stream (uiout
, "cond", stb
);
3650 ui_out_text (uiout
, "\n");
3653 if (b
->pending
&& b
->cond_string
)
3656 ui_out_text (uiout
, "\tstop only if ");
3657 ui_out_field_string (uiout
, "cond", b
->cond_string
);
3658 ui_out_text (uiout
, "\n");
3661 if (b
->thread
!= -1)
3663 /* FIXME should make an annotation for this */
3664 ui_out_text (uiout
, "\tstop only in thread ");
3665 ui_out_field_int (uiout
, "thread", b
->thread
);
3666 ui_out_text (uiout
, "\n");
3669 if (show_breakpoint_hit_counts
&& b
->hit_count
)
3671 /* FIXME should make an annotation for this */
3672 if (ep_is_catchpoint (b
))
3673 ui_out_text (uiout
, "\tcatchpoint");
3675 ui_out_text (uiout
, "\tbreakpoint");
3676 ui_out_text (uiout
, " already hit ");
3677 ui_out_field_int (uiout
, "times", b
->hit_count
);
3678 if (b
->hit_count
== 1)
3679 ui_out_text (uiout
, " time\n");
3681 ui_out_text (uiout
, " times\n");
3684 /* Output the count also if it is zero, but only if this is
3685 mi. FIXME: Should have a better test for this. */
3686 if (ui_out_is_mi_like_p (uiout
))
3687 if (show_breakpoint_hit_counts
&& b
->hit_count
== 0)
3688 ui_out_field_int (uiout
, "times", b
->hit_count
);
3690 if (b
->ignore_count
)
3693 ui_out_text (uiout
, "\tignore next ");
3694 ui_out_field_int (uiout
, "ignore", b
->ignore_count
);
3695 ui_out_text (uiout
, " hits\n");
3698 if ((l
= b
->commands
))
3700 struct cleanup
*script_chain
;
3703 script_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "script");
3704 print_command_lines (uiout
, l
, 4);
3705 do_cleanups (script_chain
);
3707 do_cleanups (bkpt_chain
);
3708 do_cleanups (old_chain
);
3711 struct captured_breakpoint_query_args
3717 do_captured_breakpoint_query (struct ui_out
*uiout
, void *data
)
3719 struct captured_breakpoint_query_args
*args
= data
;
3720 struct breakpoint
*b
;
3721 CORE_ADDR dummy_addr
= 0;
3724 if (args
->bnum
== b
->number
)
3726 print_one_breakpoint (b
, &dummy_addr
);
3734 gdb_breakpoint_query (struct ui_out
*uiout
, int bnum
, char **error_message
)
3736 struct captured_breakpoint_query_args args
;
3738 /* For the moment we don't trust print_one_breakpoint() to not throw
3740 if (catch_exceptions_with_msg (uiout
, do_captured_breakpoint_query
, &args
,
3741 error_message
, RETURN_MASK_ALL
) < 0)
3747 /* Return non-zero if B is user settable (breakpoints, watchpoints,
3748 catchpoints, et.al.). */
3751 user_settable_breakpoint (const struct breakpoint
*b
)
3753 return (b
->type
== bp_breakpoint
3754 || b
->type
== bp_catch_load
3755 || b
->type
== bp_catch_unload
3756 || b
->type
== bp_catch_fork
3757 || b
->type
== bp_catch_vfork
3758 || b
->type
== bp_catch_exec
3759 || b
->type
== bp_catch_catch
3760 || b
->type
== bp_catch_throw
3761 || b
->type
== bp_hardware_breakpoint
3762 || b
->type
== bp_watchpoint
3763 || b
->type
== bp_read_watchpoint
3764 || b
->type
== bp_access_watchpoint
3765 || b
->type
== bp_hardware_watchpoint
);
3768 /* Print information on user settable breakpoint (watchpoint, etc)
3769 number BNUM. If BNUM is -1 print all user settable breakpoints.
3770 If ALLFLAG is non-zero, include non- user settable breakpoints. */
3773 breakpoint_1 (int bnum
, int allflag
)
3775 struct breakpoint
*b
;
3776 CORE_ADDR last_addr
= (CORE_ADDR
) -1;
3777 int nr_printable_breakpoints
;
3778 struct cleanup
*bkpttbl_chain
;
3780 /* Compute the number of rows in the table. */
3781 nr_printable_breakpoints
= 0;
3784 || bnum
== b
->number
)
3786 if (allflag
|| user_settable_breakpoint (b
))
3787 nr_printable_breakpoints
++;
3792 = make_cleanup_ui_out_table_begin_end (uiout
, 6, nr_printable_breakpoints
,
3796 = make_cleanup_ui_out_table_begin_end (uiout
, 5, nr_printable_breakpoints
,
3799 if (nr_printable_breakpoints
> 0)
3800 annotate_breakpoints_headers ();
3801 if (nr_printable_breakpoints
> 0)
3803 ui_out_table_header (uiout
, 3, ui_left
, "number", "Num"); /* 1 */
3804 if (nr_printable_breakpoints
> 0)
3806 ui_out_table_header (uiout
, 14, ui_left
, "type", "Type"); /* 2 */
3807 if (nr_printable_breakpoints
> 0)
3809 ui_out_table_header (uiout
, 4, ui_left
, "disp", "Disp"); /* 3 */
3810 if (nr_printable_breakpoints
> 0)
3812 ui_out_table_header (uiout
, 3, ui_left
, "enabled", "Enb"); /* 4 */
3815 if (nr_printable_breakpoints
> 0)
3817 if (TARGET_ADDR_BIT
<= 32)
3818 ui_out_table_header (uiout
, 10, ui_left
, "addr", "Address");/* 5 */
3820 ui_out_table_header (uiout
, 18, ui_left
, "addr", "Address");/* 5 */
3822 if (nr_printable_breakpoints
> 0)
3824 ui_out_table_header (uiout
, 40, ui_noalign
, "what", "What"); /* 6 */
3825 ui_out_table_body (uiout
);
3826 if (nr_printable_breakpoints
> 0)
3827 annotate_breakpoints_table ();
3831 || bnum
== b
->number
)
3833 /* We only print out user settable breakpoints unless the
3835 if (allflag
|| user_settable_breakpoint (b
))
3836 print_one_breakpoint (b
, &last_addr
);
3839 do_cleanups (bkpttbl_chain
);
3841 if (nr_printable_breakpoints
== 0)
3844 ui_out_message (uiout
, 0, "No breakpoints or watchpoints.\n");
3846 ui_out_message (uiout
, 0, "No breakpoint or watchpoint number %d.\n",
3851 /* Compare against (CORE_ADDR)-1 in case some compiler decides
3852 that a comparison of an unsigned with -1 is always false. */
3853 if (last_addr
!= (CORE_ADDR
) -1)
3854 set_next_address (last_addr
);
3857 /* FIXME? Should this be moved up so that it is only called when
3858 there have been breakpoints? */
3859 annotate_breakpoints_table_end ();
3863 breakpoints_info (char *bnum_exp
, int from_tty
)
3868 bnum
= parse_and_eval_long (bnum_exp
);
3870 breakpoint_1 (bnum
, 0);
3874 maintenance_info_breakpoints (char *bnum_exp
, int from_tty
)
3879 bnum
= parse_and_eval_long (bnum_exp
);
3881 breakpoint_1 (bnum
, 1);
3884 /* Print a message describing any breakpoints set at PC. */
3887 describe_other_breakpoints (CORE_ADDR pc
, asection
*section
, int thread
)
3890 struct breakpoint
*b
;
3893 if (b
->loc
->address
== pc
) /* address match / overlay match */
3894 if (!b
->pending
&& (!overlay_debugging
|| b
->loc
->section
== section
))
3899 printf_filtered (_("Note: breakpoint "));
3900 else /* if (others == ???) */
3901 printf_filtered (_("Note: breakpoints "));
3903 if (b
->loc
->address
== pc
) /* address match / overlay match */
3904 if (!b
->pending
&& (!overlay_debugging
|| b
->loc
->section
== section
))
3907 printf_filtered ("%d", b
->number
);
3908 if (b
->thread
== -1 && thread
!= -1)
3909 printf_filtered (" (all threads)");
3910 else if (b
->thread
!= -1)
3911 printf_filtered (" (thread %d)", b
->thread
);
3912 printf_filtered ("%s%s ",
3913 ((b
->enable_state
== bp_disabled
||
3914 b
->enable_state
== bp_shlib_disabled
||
3915 b
->enable_state
== bp_call_disabled
)
3917 : b
->enable_state
== bp_permanent
3921 : ((others
== 1) ? " and" : ""));
3923 printf_filtered (_("also set at pc "));
3924 deprecated_print_address_numeric (pc
, 1, gdb_stdout
);
3925 printf_filtered (".\n");
3929 /* Set the default place to put a breakpoint
3930 for the `break' command with no arguments. */
3933 set_default_breakpoint (int valid
, CORE_ADDR addr
, struct symtab
*symtab
,
3936 default_breakpoint_valid
= valid
;
3937 default_breakpoint_address
= addr
;
3938 default_breakpoint_symtab
= symtab
;
3939 default_breakpoint_line
= line
;
3942 /* Return true iff it is meaningful to use the address member of
3943 BPT. For some breakpoint types, the address member is irrelevant
3944 and it makes no sense to attempt to compare it to other addresses
3945 (or use it for any other purpose either).
3947 More specifically, each of the following breakpoint types will always
3948 have a zero valued address and we don't want check_duplicates() to mark
3949 breakpoints of any of these types to be a duplicate of an actual
3950 breakpoint at address zero:
3953 bp_hardware_watchpoint
3955 bp_access_watchpoint
3962 breakpoint_address_is_meaningful (struct breakpoint
*bpt
)
3964 enum bptype type
= bpt
->type
;
3966 return (type
!= bp_watchpoint
3967 && type
!= bp_hardware_watchpoint
3968 && type
!= bp_read_watchpoint
3969 && type
!= bp_access_watchpoint
3970 && type
!= bp_catch_exec
3971 && type
!= bp_longjmp_resume
3972 && type
!= bp_catch_fork
3973 && type
!= bp_catch_vfork
);
3976 /* Rescan breakpoints at the same address and section as BPT,
3977 marking the first one as "first" and any others as "duplicates".
3978 This is so that the bpt instruction is only inserted once.
3979 If we have a permanent breakpoint at the same place as BPT, make
3980 that one the official one, and the rest as duplicates. */
3983 check_duplicates (struct breakpoint
*bpt
)
3985 struct bp_location
*b
;
3987 struct bp_location
*perm_bp
= 0;
3988 CORE_ADDR address
= bpt
->loc
->address
;
3989 asection
*section
= bpt
->loc
->section
;
3991 if (! breakpoint_address_is_meaningful (bpt
))
3994 ALL_BP_LOCATIONS (b
)
3995 if (b
->owner
->enable_state
!= bp_disabled
3996 && b
->owner
->enable_state
!= bp_shlib_disabled
3997 && !b
->owner
->pending
3998 && b
->owner
->enable_state
!= bp_call_disabled
3999 && b
->address
== address
/* address / overlay match */
4000 && (!overlay_debugging
|| b
->section
== section
)
4001 && breakpoint_address_is_meaningful (b
->owner
))
4003 /* Have we found a permanent breakpoint? */
4004 if (b
->owner
->enable_state
== bp_permanent
)
4011 b
->duplicate
= count
> 1;
4014 /* If we found a permanent breakpoint at this address, go over the
4015 list again and declare all the other breakpoints there to be the
4019 perm_bp
->duplicate
= 0;
4021 /* Permanent breakpoint should always be inserted. */
4022 if (! perm_bp
->inserted
)
4023 internal_error (__FILE__
, __LINE__
,
4024 _("allegedly permanent breakpoint is not "
4025 "actually inserted"));
4027 ALL_BP_LOCATIONS (b
)
4030 if (b
->owner
->enable_state
!= bp_disabled
4031 && b
->owner
->enable_state
!= bp_shlib_disabled
4032 && !b
->owner
->pending
4033 && b
->owner
->enable_state
!= bp_call_disabled
4034 && b
->address
== address
/* address / overlay match */
4035 && (!overlay_debugging
|| b
->section
== section
)
4036 && breakpoint_address_is_meaningful (b
->owner
))
4039 internal_error (__FILE__
, __LINE__
,
4040 _("another breakpoint was inserted on top of "
4041 "a permanent breakpoint"));
4050 breakpoint_adjustment_warning (CORE_ADDR from_addr
, CORE_ADDR to_addr
,
4051 int bnum
, int have_bnum
)
4056 strcpy (astr1
, hex_string_custom ((unsigned long) from_addr
, 8));
4057 strcpy (astr2
, hex_string_custom ((unsigned long) to_addr
, 8));
4059 warning (_("Breakpoint %d address previously adjusted from %s to %s."),
4060 bnum
, astr1
, astr2
);
4062 warning (_("Breakpoint address adjusted from %s to %s."), astr1
, astr2
);
4065 /* Adjust a breakpoint's address to account for architectural constraints
4066 on breakpoint placement. Return the adjusted address. Note: Very
4067 few targets require this kind of adjustment. For most targets,
4068 this function is simply the identity function. */
4071 adjust_breakpoint_address (CORE_ADDR bpaddr
, enum bptype bptype
)
4073 if (!gdbarch_adjust_breakpoint_address_p (current_gdbarch
))
4075 /* Very few targets need any kind of breakpoint adjustment. */
4078 else if (bptype
== bp_watchpoint
4079 || bptype
== bp_hardware_watchpoint
4080 || bptype
== bp_read_watchpoint
4081 || bptype
== bp_access_watchpoint
4082 || bptype
== bp_catch_fork
4083 || bptype
== bp_catch_vfork
4084 || bptype
== bp_catch_exec
)
4086 /* Watchpoints and the various bp_catch_* eventpoints should not
4087 have their addresses modified. */
4092 CORE_ADDR adjusted_bpaddr
;
4094 /* Some targets have architectural constraints on the placement
4095 of breakpoint instructions. Obtain the adjusted address. */
4096 adjusted_bpaddr
= gdbarch_adjust_breakpoint_address (current_gdbarch
,
4099 /* An adjusted breakpoint address can significantly alter
4100 a user's expectations. Print a warning if an adjustment
4102 if (adjusted_bpaddr
!= bpaddr
)
4103 breakpoint_adjustment_warning (bpaddr
, adjusted_bpaddr
, 0, 0);
4105 return adjusted_bpaddr
;
4109 /* Allocate a struct bp_location. */
4111 static struct bp_location
*
4112 allocate_bp_location (struct breakpoint
*bpt
, enum bptype bp_type
)
4114 struct bp_location
*loc
, *loc_p
;
4116 loc
= xmalloc (sizeof (struct bp_location
));
4117 memset (loc
, 0, sizeof (*loc
));
4127 case bp_longjmp_resume
:
4128 case bp_step_resume
:
4129 case bp_watchpoint_scope
:
4131 case bp_shlib_event
:
4132 case bp_thread_event
:
4133 case bp_overlay_event
:
4135 case bp_catch_unload
:
4136 loc
->loc_type
= bp_loc_software_breakpoint
;
4138 case bp_hardware_breakpoint
:
4139 loc
->loc_type
= bp_loc_hardware_breakpoint
;
4141 case bp_hardware_watchpoint
:
4142 case bp_read_watchpoint
:
4143 case bp_access_watchpoint
:
4144 loc
->loc_type
= bp_loc_hardware_watchpoint
;
4148 case bp_catch_vfork
:
4150 case bp_catch_catch
:
4151 case bp_catch_throw
:
4152 loc
->loc_type
= bp_loc_other
;
4155 internal_error (__FILE__
, __LINE__
, _("unknown breakpoint type"));
4158 /* Add this breakpoint to the end of the chain. */
4160 loc_p
= bp_location_chain
;
4162 bp_location_chain
= loc
;
4166 loc_p
= loc_p
->next
;
4173 /* set_raw_breakpoint() is a low level routine for allocating and
4174 partially initializing a breakpoint of type BPTYPE. The newly
4175 created breakpoint's address, section, source file name, and line
4176 number are provided by SAL. The newly created and partially
4177 initialized breakpoint is added to the breakpoint chain and
4178 is also returned as the value of this function.
4180 It is expected that the caller will complete the initialization of
4181 the newly created breakpoint struct as well as output any status
4182 information regarding the creation of a new breakpoint. In
4183 particular, set_raw_breakpoint() does NOT set the breakpoint
4184 number! Care should be taken to not allow an error() to occur
4185 prior to completing the initialization of the breakpoint. If this
4186 should happen, a bogus breakpoint will be left on the chain. */
4189 set_raw_breakpoint (struct symtab_and_line sal
, enum bptype bptype
)
4191 struct breakpoint
*b
, *b1
;
4193 b
= (struct breakpoint
*) xmalloc (sizeof (struct breakpoint
));
4194 memset (b
, 0, sizeof (*b
));
4195 b
->loc
= allocate_bp_location (b
, bptype
);
4196 b
->loc
->requested_address
= sal
.pc
;
4197 b
->loc
->address
= adjust_breakpoint_address (b
->loc
->requested_address
,
4199 if (sal
.symtab
== NULL
)
4200 b
->source_file
= NULL
;
4202 b
->source_file
= savestring (sal
.symtab
->filename
,
4203 strlen (sal
.symtab
->filename
));
4204 b
->loc
->section
= sal
.section
;
4206 b
->language
= current_language
->la_language
;
4207 b
->input_radix
= input_radix
;
4209 b
->line_number
= sal
.line
;
4210 b
->enable_state
= bp_enabled
;
4213 b
->ignore_count
= 0;
4215 b
->frame_id
= null_frame_id
;
4216 b
->dll_pathname
= NULL
;
4217 b
->triggered_dll_pathname
= NULL
;
4218 b
->forked_inferior_pid
= 0;
4219 b
->exec_pathname
= NULL
;
4223 /* Add this breakpoint to the end of the chain
4224 so that a list of breakpoints will come out in order
4225 of increasing numbers. */
4227 b1
= breakpoint_chain
;
4229 breakpoint_chain
= b
;
4237 check_duplicates (b
);
4238 breakpoints_changed ();
4244 /* Note that the breakpoint object B describes a permanent breakpoint
4245 instruction, hard-wired into the inferior's code. */
4247 make_breakpoint_permanent (struct breakpoint
*b
)
4249 b
->enable_state
= bp_permanent
;
4251 /* By definition, permanent breakpoints are already present in the code. */
4252 b
->loc
->inserted
= 1;
4255 static struct breakpoint
*
4256 create_internal_breakpoint (CORE_ADDR address
, enum bptype type
)
4258 static int internal_breakpoint_number
= -1;
4259 struct symtab_and_line sal
;
4260 struct breakpoint
*b
;
4262 init_sal (&sal
); /* initialize to zeroes */
4265 sal
.section
= find_pc_overlay (sal
.pc
);
4267 b
= set_raw_breakpoint (sal
, type
);
4268 b
->number
= internal_breakpoint_number
--;
4269 b
->disposition
= disp_donttouch
;
4276 create_longjmp_breakpoint (char *func_name
)
4278 struct breakpoint
*b
;
4279 struct minimal_symbol
*m
;
4281 if (func_name
== NULL
)
4282 b
= create_internal_breakpoint (0, bp_longjmp_resume
);
4285 if ((m
= lookup_minimal_symbol_text (func_name
, NULL
)) == NULL
)
4288 b
= create_internal_breakpoint (SYMBOL_VALUE_ADDRESS (m
), bp_longjmp
);
4291 b
->enable_state
= bp_disabled
;
4294 b
->addr_string
= xstrdup (func_name
);
4297 /* Call this routine when stepping and nexting to enable a breakpoint
4298 if we do a longjmp(). When we hit that breakpoint, call
4299 set_longjmp_resume_breakpoint() to figure out where we are going. */
4302 enable_longjmp_breakpoint (void)
4304 struct breakpoint
*b
;
4307 if (b
->type
== bp_longjmp
)
4309 b
->enable_state
= bp_enabled
;
4310 check_duplicates (b
);
4315 disable_longjmp_breakpoint (void)
4317 struct breakpoint
*b
;
4320 if (b
->type
== bp_longjmp
4321 || b
->type
== bp_longjmp_resume
)
4323 b
->enable_state
= bp_disabled
;
4324 check_duplicates (b
);
4329 create_overlay_event_breakpoint (char *func_name
)
4331 struct breakpoint
*b
;
4332 struct minimal_symbol
*m
;
4334 if ((m
= lookup_minimal_symbol_text (func_name
, NULL
)) == NULL
)
4337 b
= create_internal_breakpoint (SYMBOL_VALUE_ADDRESS (m
),
4339 b
->addr_string
= xstrdup (func_name
);
4341 if (overlay_debugging
== ovly_auto
)
4343 b
->enable_state
= bp_enabled
;
4344 overlay_events_enabled
= 1;
4348 b
->enable_state
= bp_disabled
;
4349 overlay_events_enabled
= 0;
4354 enable_overlay_breakpoints (void)
4356 struct breakpoint
*b
;
4359 if (b
->type
== bp_overlay_event
)
4361 b
->enable_state
= bp_enabled
;
4362 check_duplicates (b
);
4363 overlay_events_enabled
= 1;
4368 disable_overlay_breakpoints (void)
4370 struct breakpoint
*b
;
4373 if (b
->type
== bp_overlay_event
)
4375 b
->enable_state
= bp_disabled
;
4376 check_duplicates (b
);
4377 overlay_events_enabled
= 0;
4382 create_thread_event_breakpoint (CORE_ADDR address
)
4384 struct breakpoint
*b
;
4386 b
= create_internal_breakpoint (address
, bp_thread_event
);
4388 b
->enable_state
= bp_enabled
;
4389 /* addr_string has to be used or breakpoint_re_set will delete me. */
4390 b
->addr_string
= xstrprintf ("*0x%s", paddr (b
->loc
->address
));
4396 remove_thread_event_breakpoints (void)
4398 struct breakpoint
*b
, *temp
;
4400 ALL_BREAKPOINTS_SAFE (b
, temp
)
4401 if (b
->type
== bp_thread_event
)
4402 delete_breakpoint (b
);
4405 struct captured_parse_breakpoint_args
4408 struct symtabs_and_lines
*sals_p
;
4409 char ***addr_string_p
;
4413 struct lang_and_radix
4419 /* Cleanup helper routine to restore the current language and
4422 do_restore_lang_radix_cleanup (void *old
)
4424 struct lang_and_radix
*p
= old
;
4425 set_language (p
->lang
);
4426 input_radix
= p
->radix
;
4429 /* Try and resolve a pending breakpoint. */
4431 resolve_pending_breakpoint (struct breakpoint
*b
)
4433 /* Try and reparse the breakpoint in case the shared library
4435 struct symtabs_and_lines sals
;
4436 struct symtab_and_line pending_sal
;
4437 char **cond_string
= (char **) NULL
;
4438 char *copy_arg
= b
->addr_string
;
4443 struct ui_file
*old_gdb_stderr
;
4444 struct lang_and_radix old_lr
;
4445 struct cleanup
*old_chain
;
4447 /* Set language, input-radix, then reissue breakpoint command.
4448 Ensure the language and input-radix are restored afterwards. */
4449 old_lr
.lang
= current_language
->la_language
;
4450 old_lr
.radix
= input_radix
;
4451 old_chain
= make_cleanup (do_restore_lang_radix_cleanup
, &old_lr
);
4453 set_language (b
->language
);
4454 input_radix
= b
->input_radix
;
4455 rc
= break_command_1 (b
->addr_string
, b
->flag
, b
->from_tty
, b
);
4457 if (rc
== GDB_RC_OK
)
4458 /* Pending breakpoint has been resolved. */
4459 printf_filtered (_("Pending breakpoint \"%s\" resolved\n"), b
->addr_string
);
4461 do_cleanups (old_chain
);
4466 remove_solib_event_breakpoints (void)
4468 struct breakpoint
*b
, *temp
;
4470 ALL_BREAKPOINTS_SAFE (b
, temp
)
4471 if (b
->type
== bp_shlib_event
)
4472 delete_breakpoint (b
);
4476 create_solib_event_breakpoint (CORE_ADDR address
)
4478 struct breakpoint
*b
;
4480 b
= create_internal_breakpoint (address
, bp_shlib_event
);
4484 /* Disable any breakpoints that are on code in shared libraries. Only
4485 apply to enabled breakpoints, disabled ones can just stay disabled. */
4488 disable_breakpoints_in_shlibs (int silent
)
4490 struct breakpoint
*b
;
4491 int disabled_shlib_breaks
= 0;
4493 /* See also: insert_breakpoints, under DISABLE_UNSETTABLE_BREAK. */
4496 if (((b
->type
== bp_breakpoint
) || (b
->type
== bp_hardware_breakpoint
))
4497 && breakpoint_enabled (b
) && !b
->loc
->duplicate
4499 && PC_SOLIB (b
->loc
->address
)
4501 && solib_address (b
->loc
->address
)
4505 b
->enable_state
= bp_shlib_disabled
;
4508 if (!disabled_shlib_breaks
)
4510 target_terminal_ours_for_output ();
4511 warning (_("Temporarily disabling shared library breakpoints:"));
4513 disabled_shlib_breaks
= 1;
4514 warning (_("breakpoint #%d "), b
->number
);
4520 /* Disable any breakpoints that are in in an unloaded shared library. Only
4521 apply to enabled breakpoints, disabled ones can just stay disabled. */
4524 disable_breakpoints_in_unloaded_shlib (struct so_list
*solib
)
4526 struct breakpoint
*b
;
4527 int disabled_shlib_breaks
= 0;
4529 /* See also: insert_breakpoints, under DISABLE_UNSETTABLE_BREAK. */
4532 if ((b
->loc
->loc_type
== bp_loc_hardware_breakpoint
4533 || b
->loc
->loc_type
== bp_loc_software_breakpoint
)
4534 && breakpoint_enabled (b
) && !b
->loc
->duplicate
)
4537 char *so_name
= PC_SOLIB (b
->loc
->address
);
4539 char *so_name
= solib_address (b
->loc
->address
);
4541 if (so_name
&& !strcmp (so_name
, solib
->so_name
))
4543 b
->enable_state
= bp_shlib_disabled
;
4544 /* At this point, we cannot rely on remove_breakpoint
4545 succeeding so we must mark the breakpoint as not inserted
4546 to prevent future errors occurring in remove_breakpoints. */
4547 b
->loc
->inserted
= 0;
4548 if (!disabled_shlib_breaks
)
4550 target_terminal_ours_for_output ();
4551 warning (_("Temporarily disabling breakpoints for unloaded shared library \"%s\""),
4554 disabled_shlib_breaks
= 1;
4560 /* Try to reenable any breakpoints in shared libraries. */
4562 re_enable_breakpoints_in_shlibs (void)
4564 struct breakpoint
*b
, *tmp
;
4566 ALL_BREAKPOINTS_SAFE (b
, tmp
)
4568 if (b
->enable_state
== bp_shlib_disabled
)
4573 /* Do not reenable the breakpoint if the shared library is
4574 still not mapped in. */
4576 lib
= PC_SOLIB (b
->loc
->address
);
4578 lib
= solib_address (b
->loc
->address
);
4580 if (lib
!= NULL
&& target_read_memory (b
->loc
->address
, buf
, 1) == 0)
4581 b
->enable_state
= bp_enabled
;
4583 else if (b
->pending
&& (b
->enable_state
== bp_enabled
))
4585 if (resolve_pending_breakpoint (b
) == GDB_RC_OK
)
4586 delete_breakpoint (b
);
4592 solib_load_unload_1 (char *hookname
, int tempflag
, char *dll_pathname
,
4593 char *cond_string
, enum bptype bp_kind
)
4595 struct breakpoint
*b
;
4596 struct symtabs_and_lines sals
;
4597 struct cleanup
*old_chain
;
4598 struct cleanup
*canonical_strings_chain
= NULL
;
4599 char *addr_start
= hookname
;
4600 char *addr_end
= NULL
;
4601 char **canonical
= (char **) NULL
;
4602 int thread
= -1; /* All threads. */
4604 /* Set a breakpoint on the specified hook. */
4605 sals
= decode_line_1 (&hookname
, 1, (struct symtab
*) NULL
,
4606 0, &canonical
, NULL
);
4607 addr_end
= hookname
;
4609 if (sals
.nelts
== 0)
4611 warning (_("Unable to set a breakpoint on dynamic linker callback.\n"
4612 "Suggest linking with /opt/langtools/lib/end.o.\n"
4613 "GDB will be unable to track shl_load/shl_unload calls."));
4616 if (sals
.nelts
!= 1)
4618 warning (_("Unable to set unique breakpoint on dynamic linker callback.\n"
4619 "GDB will be unable to track shl_load/shl_unload calls."));
4623 /* Make sure that all storage allocated in decode_line_1 gets freed
4624 in case the following errors out. */
4625 old_chain
= make_cleanup (xfree
, sals
.sals
);
4626 if (canonical
!= (char **) NULL
)
4628 make_cleanup (xfree
, canonical
);
4629 canonical_strings_chain
= make_cleanup (null_cleanup
, 0);
4630 if (canonical
[0] != NULL
)
4631 make_cleanup (xfree
, canonical
[0]);
4634 resolve_sal_pc (&sals
.sals
[0]);
4636 /* Remove the canonical strings from the cleanup, they are needed below. */
4637 if (canonical
!= (char **) NULL
)
4638 discard_cleanups (canonical_strings_chain
);
4640 b
= set_raw_breakpoint (sals
.sals
[0], bp_kind
);
4641 set_breakpoint_count (breakpoint_count
+ 1);
4642 b
->number
= breakpoint_count
;
4644 b
->cond_string
= (cond_string
== NULL
) ?
4645 NULL
: savestring (cond_string
, strlen (cond_string
));
4648 if (canonical
!= (char **) NULL
&& canonical
[0] != NULL
)
4649 b
->addr_string
= canonical
[0];
4650 else if (addr_start
)
4651 b
->addr_string
= savestring (addr_start
, addr_end
- addr_start
);
4653 b
->enable_state
= bp_enabled
;
4654 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
4656 if (dll_pathname
== NULL
)
4657 b
->dll_pathname
= NULL
;
4660 b
->dll_pathname
= (char *) xmalloc (strlen (dll_pathname
) + 1);
4661 strcpy (b
->dll_pathname
, dll_pathname
);
4665 do_cleanups (old_chain
);
4669 create_solib_load_event_breakpoint (char *hookname
, int tempflag
,
4670 char *dll_pathname
, char *cond_string
)
4672 solib_load_unload_1 (hookname
, tempflag
, dll_pathname
,
4673 cond_string
, bp_catch_load
);
4677 create_solib_unload_event_breakpoint (char *hookname
, int tempflag
,
4678 char *dll_pathname
, char *cond_string
)
4680 solib_load_unload_1 (hookname
, tempflag
, dll_pathname
,
4681 cond_string
, bp_catch_unload
);
4685 create_fork_vfork_event_catchpoint (int tempflag
, char *cond_string
,
4686 enum bptype bp_kind
)
4688 struct symtab_and_line sal
;
4689 struct breakpoint
*b
;
4690 int thread
= -1; /* All threads. */
4697 b
= set_raw_breakpoint (sal
, bp_kind
);
4698 set_breakpoint_count (breakpoint_count
+ 1);
4699 b
->number
= breakpoint_count
;
4701 b
->cond_string
= (cond_string
== NULL
) ?
4702 NULL
: savestring (cond_string
, strlen (cond_string
));
4704 b
->addr_string
= NULL
;
4705 b
->enable_state
= bp_enabled
;
4706 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
4707 b
->forked_inferior_pid
= 0;
4713 create_fork_event_catchpoint (int tempflag
, char *cond_string
)
4715 create_fork_vfork_event_catchpoint (tempflag
, cond_string
, bp_catch_fork
);
4719 create_vfork_event_catchpoint (int tempflag
, char *cond_string
)
4721 create_fork_vfork_event_catchpoint (tempflag
, cond_string
, bp_catch_vfork
);
4725 create_exec_event_catchpoint (int tempflag
, char *cond_string
)
4727 struct symtab_and_line sal
;
4728 struct breakpoint
*b
;
4729 int thread
= -1; /* All threads. */
4736 b
= set_raw_breakpoint (sal
, bp_catch_exec
);
4737 set_breakpoint_count (breakpoint_count
+ 1);
4738 b
->number
= breakpoint_count
;
4740 b
->cond_string
= (cond_string
== NULL
) ?
4741 NULL
: savestring (cond_string
, strlen (cond_string
));
4743 b
->addr_string
= NULL
;
4744 b
->enable_state
= bp_enabled
;
4745 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
4751 hw_breakpoint_used_count (void)
4753 struct breakpoint
*b
;
4758 if (b
->type
== bp_hardware_breakpoint
&& b
->enable_state
== bp_enabled
)
4766 hw_watchpoint_used_count (enum bptype type
, int *other_type_used
)
4768 struct breakpoint
*b
;
4771 *other_type_used
= 0;
4774 if (breakpoint_enabled (b
))
4776 if (b
->type
== type
)
4778 else if ((b
->type
== bp_hardware_watchpoint
||
4779 b
->type
== bp_read_watchpoint
||
4780 b
->type
== bp_access_watchpoint
))
4781 *other_type_used
= 1;
4787 /* Call this after hitting the longjmp() breakpoint. Use this to set
4788 a new breakpoint at the target of the jmp_buf.
4790 FIXME - This ought to be done by setting a temporary breakpoint
4791 that gets deleted automatically... */
4794 set_longjmp_resume_breakpoint (CORE_ADDR pc
, struct frame_id frame_id
)
4796 struct breakpoint
*b
;
4799 if (b
->type
== bp_longjmp_resume
)
4801 b
->loc
->requested_address
= pc
;
4802 b
->loc
->address
= adjust_breakpoint_address (b
->loc
->requested_address
,
4804 b
->enable_state
= bp_enabled
;
4805 b
->frame_id
= frame_id
;
4806 check_duplicates (b
);
4812 disable_watchpoints_before_interactive_call_start (void)
4814 struct breakpoint
*b
;
4818 if (((b
->type
== bp_watchpoint
)
4819 || (b
->type
== bp_hardware_watchpoint
)
4820 || (b
->type
== bp_read_watchpoint
)
4821 || (b
->type
== bp_access_watchpoint
)
4822 || ep_is_exception_catchpoint (b
))
4823 && breakpoint_enabled (b
))
4825 b
->enable_state
= bp_call_disabled
;
4826 check_duplicates (b
);
4832 enable_watchpoints_after_interactive_call_stop (void)
4834 struct breakpoint
*b
;
4838 if (((b
->type
== bp_watchpoint
)
4839 || (b
->type
== bp_hardware_watchpoint
)
4840 || (b
->type
== bp_read_watchpoint
)
4841 || (b
->type
== bp_access_watchpoint
)
4842 || ep_is_exception_catchpoint (b
))
4843 && (b
->enable_state
== bp_call_disabled
))
4845 b
->enable_state
= bp_enabled
;
4846 check_duplicates (b
);
4852 /* Set a breakpoint that will evaporate an end of command
4853 at address specified by SAL.
4854 Restrict it to frame FRAME if FRAME is nonzero. */
4857 set_momentary_breakpoint (struct symtab_and_line sal
, struct frame_id frame_id
,
4860 struct breakpoint
*b
;
4861 b
= set_raw_breakpoint (sal
, type
);
4862 b
->enable_state
= bp_enabled
;
4863 b
->disposition
= disp_donttouch
;
4864 b
->frame_id
= frame_id
;
4866 /* If we're debugging a multi-threaded program, then we
4867 want momentary breakpoints to be active in only a
4868 single thread of control. */
4869 if (in_thread_list (inferior_ptid
))
4870 b
->thread
= pid_to_thread_id (inferior_ptid
);
4876 /* Tell the user we have just set a breakpoint B. */
4879 mention (struct breakpoint
*b
)
4882 struct cleanup
*old_chain
, *ui_out_chain
;
4883 struct ui_stream
*stb
;
4885 stb
= ui_out_stream_new (uiout
);
4886 old_chain
= make_cleanup_ui_out_stream_delete (stb
);
4888 /* FIXME: This is misplaced; mention() is called by things (like
4889 hitting a watchpoint) other than breakpoint creation. It should
4890 be possible to clean this up and at the same time replace the
4891 random calls to breakpoint_changed with this hook, as has already
4892 been done for deprecated_delete_breakpoint_hook and so on. */
4893 if (deprecated_create_breakpoint_hook
)
4894 deprecated_create_breakpoint_hook (b
);
4895 breakpoint_create_event (b
->number
);
4897 if (b
->ops
!= NULL
&& b
->ops
->print_mention
!= NULL
)
4898 b
->ops
->print_mention (b
);
4903 printf_filtered (_("(apparently deleted?) Eventpoint %d: "), b
->number
);
4906 ui_out_text (uiout
, "Watchpoint ");
4907 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "wpt");
4908 ui_out_field_int (uiout
, "number", b
->number
);
4909 ui_out_text (uiout
, ": ");
4910 print_expression (b
->exp
, stb
->stream
);
4911 ui_out_field_stream (uiout
, "exp", stb
);
4912 do_cleanups (ui_out_chain
);
4914 case bp_hardware_watchpoint
:
4915 ui_out_text (uiout
, "Hardware watchpoint ");
4916 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "wpt");
4917 ui_out_field_int (uiout
, "number", b
->number
);
4918 ui_out_text (uiout
, ": ");
4919 print_expression (b
->exp
, stb
->stream
);
4920 ui_out_field_stream (uiout
, "exp", stb
);
4921 do_cleanups (ui_out_chain
);
4923 case bp_read_watchpoint
:
4924 ui_out_text (uiout
, "Hardware read watchpoint ");
4925 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "hw-rwpt");
4926 ui_out_field_int (uiout
, "number", b
->number
);
4927 ui_out_text (uiout
, ": ");
4928 print_expression (b
->exp
, stb
->stream
);
4929 ui_out_field_stream (uiout
, "exp", stb
);
4930 do_cleanups (ui_out_chain
);
4932 case bp_access_watchpoint
:
4933 ui_out_text (uiout
, "Hardware access (read/write) watchpoint ");
4934 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "hw-awpt");
4935 ui_out_field_int (uiout
, "number", b
->number
);
4936 ui_out_text (uiout
, ": ");
4937 print_expression (b
->exp
, stb
->stream
);
4938 ui_out_field_stream (uiout
, "exp", stb
);
4939 do_cleanups (ui_out_chain
);
4942 if (ui_out_is_mi_like_p (uiout
))
4947 printf_filtered (_("Breakpoint %d"), b
->number
);
4950 case bp_hardware_breakpoint
:
4951 if (ui_out_is_mi_like_p (uiout
))
4956 printf_filtered (_("Hardware assisted breakpoint %d"), b
->number
);
4960 case bp_catch_unload
:
4961 printf_filtered (_("Catchpoint %d (%s %s)"),
4963 (b
->type
== bp_catch_load
) ? "load" : "unload",
4964 (b
->dll_pathname
!= NULL
) ?
4965 b
->dll_pathname
: "<any library>");
4968 case bp_catch_vfork
:
4969 printf_filtered (_("Catchpoint %d (%s)"),
4971 (b
->type
== bp_catch_fork
) ? "fork" : "vfork");
4974 printf_filtered (_("Catchpoint %d (exec)"),
4977 case bp_catch_catch
:
4978 case bp_catch_throw
:
4979 printf_filtered (_("Catchpoint %d (%s)"),
4981 (b
->type
== bp_catch_catch
) ? "catch" : "throw");
4987 case bp_longjmp_resume
:
4988 case bp_step_resume
:
4990 case bp_watchpoint_scope
:
4991 case bp_shlib_event
:
4992 case bp_thread_event
:
4993 case bp_overlay_event
:
4999 /* i18n: cagney/2005-02-11: Below needs to be merged into a
5003 printf_filtered (_(" (%s) pending."), b
->addr_string
);
5007 if (addressprint
|| b
->source_file
== NULL
)
5009 printf_filtered (" at ");
5010 deprecated_print_address_numeric (b
->loc
->address
, 1, gdb_stdout
);
5013 printf_filtered (": file %s, line %d.",
5014 b
->source_file
, b
->line_number
);
5017 do_cleanups (old_chain
);
5018 if (ui_out_is_mi_like_p (uiout
))
5020 printf_filtered ("\n");
5024 /* Add SALS.nelts breakpoints to the breakpoint table. For each
5025 SALS.sal[i] breakpoint, include the corresponding ADDR_STRING[i],
5026 COND[i] and COND_STRING[i] values.
5028 The parameter PENDING_BP points to a pending breakpoint that is
5029 the basis of the breakpoints currently being created. The pending
5030 breakpoint may contain a separate condition string or commands
5031 that were added after the initial pending breakpoint was created.
5033 NOTE: If the function succeeds, the caller is expected to cleanup
5034 the arrays ADDR_STRING, COND_STRING, COND and SALS (but not the
5035 array contents). If the function fails (error() is called), the
5036 caller is expected to cleanups both the ADDR_STRING, COND_STRING,
5037 COND and SALS arrays and each of those arrays contents. */
5040 create_breakpoints (struct symtabs_and_lines sals
, char **addr_string
,
5041 struct expression
**cond
, char **cond_string
,
5042 enum bptype type
, enum bpdisp disposition
,
5043 int thread
, int ignore_count
, int from_tty
,
5044 struct breakpoint
*pending_bp
)
5046 if (type
== bp_hardware_breakpoint
)
5048 int i
= hw_breakpoint_used_count ();
5049 int target_resources_ok
=
5050 TARGET_CAN_USE_HARDWARE_WATCHPOINT (bp_hardware_breakpoint
,
5052 if (target_resources_ok
== 0)
5053 error (_("No hardware breakpoint support in the target."));
5054 else if (target_resources_ok
< 0)
5055 error (_("Hardware breakpoints used exceeds limit."));
5058 /* Now set all the breakpoints. */
5061 for (i
= 0; i
< sals
.nelts
; i
++)
5063 struct breakpoint
*b
;
5064 struct symtab_and_line sal
= sals
.sals
[i
];
5067 describe_other_breakpoints (sal
.pc
, sal
.section
, thread
);
5069 b
= set_raw_breakpoint (sal
, type
);
5070 set_breakpoint_count (breakpoint_count
+ 1);
5071 b
->number
= breakpoint_count
;
5075 b
->addr_string
= addr_string
[i
];
5077 /* addr_string has to be used or breakpoint_re_set will delete
5079 b
->addr_string
= xstrprintf ("*0x%s", paddr (b
->loc
->address
));
5080 b
->cond_string
= cond_string
[i
];
5081 b
->ignore_count
= ignore_count
;
5082 b
->enable_state
= bp_enabled
;
5083 b
->disposition
= disposition
;
5084 /* If resolving a pending breakpoint, a check must be made to see if
5085 the user has specified a new condition or commands for the
5086 breakpoint. A new condition will override any condition that was
5087 initially specified with the initial breakpoint command. */
5091 if (pending_bp
->cond_string
)
5093 arg
= pending_bp
->cond_string
;
5094 b
->cond_string
= savestring (arg
, strlen (arg
));
5095 b
->cond
= parse_exp_1 (&arg
, block_for_pc (b
->loc
->address
), 0);
5097 error (_("Junk at end of pending breakpoint condition expression"));
5099 /* If there are commands associated with the breakpoint, they should
5101 if (pending_bp
->commands
)
5102 b
->commands
= copy_command_lines (pending_bp
->commands
);
5104 /* We have to copy over the ignore_count and thread as well. */
5105 b
->ignore_count
= pending_bp
->ignore_count
;
5106 b
->thread
= pending_bp
->thread
;
5113 /* Parse ARG which is assumed to be a SAL specification possibly
5114 followed by conditionals. On return, SALS contains an array of SAL
5115 addresses found. ADDR_STRING contains a vector of (canonical)
5116 address strings. ARG points to the end of the SAL. */
5119 parse_breakpoint_sals (char **address
,
5120 struct symtabs_and_lines
*sals
,
5121 char ***addr_string
,
5124 char *addr_start
= *address
;
5125 *addr_string
= NULL
;
5126 /* If no arg given, or if first arg is 'if ', use the default
5128 if ((*address
) == NULL
5129 || (strncmp ((*address
), "if", 2) == 0 && isspace ((*address
)[2])))
5131 if (default_breakpoint_valid
)
5133 struct symtab_and_line sal
;
5134 init_sal (&sal
); /* initialize to zeroes */
5135 sals
->sals
= (struct symtab_and_line
*)
5136 xmalloc (sizeof (struct symtab_and_line
));
5137 sal
.pc
= default_breakpoint_address
;
5138 sal
.line
= default_breakpoint_line
;
5139 sal
.symtab
= default_breakpoint_symtab
;
5140 sal
.section
= find_pc_overlay (sal
.pc
);
5141 sals
->sals
[0] = sal
;
5145 error (_("No default breakpoint address now."));
5149 /* Force almost all breakpoints to be in terms of the
5150 current_source_symtab (which is decode_line_1's default). This
5151 should produce the results we want almost all of the time while
5152 leaving default_breakpoint_* alone.
5153 ObjC: However, don't match an Objective-C method name which
5154 may have a '+' or '-' succeeded by a '[' */
5156 struct symtab_and_line cursal
= get_current_source_symtab_and_line ();
5158 if (default_breakpoint_valid
5160 || ((strchr ("+-", (*address
)[0]) != NULL
)
5161 && ((*address
)[1] != '['))))
5162 *sals
= decode_line_1 (address
, 1, default_breakpoint_symtab
,
5163 default_breakpoint_line
, addr_string
,
5166 *sals
= decode_line_1 (address
, 1, (struct symtab
*) NULL
, 0,
5167 addr_string
, not_found_ptr
);
5169 /* For any SAL that didn't have a canonical string, fill one in. */
5170 if (sals
->nelts
> 0 && *addr_string
== NULL
)
5171 *addr_string
= xcalloc (sals
->nelts
, sizeof (char **));
5172 if (addr_start
!= (*address
))
5175 for (i
= 0; i
< sals
->nelts
; i
++)
5177 /* Add the string if not present. */
5178 if ((*addr_string
)[i
] == NULL
)
5179 (*addr_string
)[i
] = savestring (addr_start
, (*address
) - addr_start
);
5185 /* Convert each SAL into a real PC. Verify that the PC can be
5186 inserted as a breakpoint. If it can't throw an error. */
5189 breakpoint_sals_to_pc (struct symtabs_and_lines
*sals
,
5193 for (i
= 0; i
< sals
->nelts
; i
++)
5195 resolve_sal_pc (&sals
->sals
[i
]);
5197 /* It's possible for the PC to be nonzero, but still an illegal
5198 value on some targets.
5200 For example, on HP-UX if you start gdb, and before running the
5201 inferior you try to set a breakpoint on a shared library function
5202 "foo" where the inferior doesn't call "foo" directly but does
5203 pass its address to another function call, then we do find a
5204 minimal symbol for the "foo", but it's address is invalid.
5205 (Appears to be an index into a table that the loader sets up
5206 when the inferior is run.)
5208 Give the target a chance to bless sals.sals[i].pc before we
5209 try to make a breakpoint for it. */
5210 #ifdef DEPRECATED_PC_REQUIRES_RUN_BEFORE_USE
5211 if (DEPRECATED_PC_REQUIRES_RUN_BEFORE_USE (sals
->sals
[i
].pc
))
5213 if (address
== NULL
)
5214 error (_("Cannot break without a running program."));
5216 error (_("Cannot break on %s without a running program."),
5224 do_captured_parse_breakpoint (struct ui_out
*ui
, void *data
)
5226 struct captured_parse_breakpoint_args
*args
= data
;
5228 parse_breakpoint_sals (args
->arg_p
, args
->sals_p
, args
->addr_string_p
,
5229 args
->not_found_ptr
);
5232 /* Set a breakpoint according to ARG (function, linenum or *address)
5233 flag: first bit : 0 non-temporary, 1 temporary.
5234 second bit : 0 normal breakpoint, 1 hardware breakpoint.
5236 PENDING_BP is non-NULL when this function is being called to resolve
5237 a pending breakpoint. */
5240 break_command_1 (char *arg
, int flag
, int from_tty
, struct breakpoint
*pending_bp
)
5242 struct gdb_exception e
;
5243 int tempflag
, hardwareflag
;
5244 struct symtabs_and_lines sals
;
5245 struct expression
**cond
= 0;
5246 struct symtab_and_line pending_sal
;
5247 char **cond_string
= (char **) NULL
;
5250 char *addr_start
= arg
;
5252 struct cleanup
*old_chain
;
5253 struct cleanup
*breakpoint_chain
= NULL
;
5254 struct captured_parse_breakpoint_args parse_args
;
5258 int ignore_count
= 0;
5261 hardwareflag
= flag
& BP_HARDWAREFLAG
;
5262 tempflag
= flag
& BP_TEMPFLAG
;
5268 parse_args
.arg_p
= &arg
;
5269 parse_args
.sals_p
= &sals
;
5270 parse_args
.addr_string_p
= &addr_string
;
5271 parse_args
.not_found_ptr
= ¬_found
;
5273 e
= catch_exception (uiout
, do_captured_parse_breakpoint
,
5274 &parse_args
, RETURN_MASK_ALL
);
5276 /* If caller is interested in rc value from parse, set value. */
5280 exception_print (gdb_stderr
, e
);
5285 case NOT_FOUND_ERROR
:
5286 /* If called to resolve pending breakpoint, just return
5291 exception_print (gdb_stderr
, e
);
5293 /* If pending breakpoint support is turned off, throw
5296 if (pending_break_support
== AUTO_BOOLEAN_FALSE
)
5297 deprecated_throw_reason (RETURN_ERROR
);
5299 /* If pending breakpoint support is auto query and the user
5300 selects no, then simply return the error code. */
5301 if (pending_break_support
== AUTO_BOOLEAN_AUTO
&&
5302 !nquery ("Make breakpoint pending on future shared library load? "))
5305 /* At this point, either the user was queried about setting
5306 a pending breakpoint and selected yes, or pending
5307 breakpoint behavior is on and thus a pending breakpoint
5308 is defaulted on behalf of the user. */
5309 copy_arg
= xstrdup (addr_start
);
5310 addr_string
= ©_arg
;
5312 sals
.sals
= &pending_sal
;
5317 exception_print (gdb_stderr
, e
);
5325 /* Create a chain of things that always need to be cleaned up. */
5326 old_chain
= make_cleanup (null_cleanup
, 0);
5330 /* Make sure that all storage allocated to SALS gets freed. */
5331 make_cleanup (xfree
, sals
.sals
);
5333 /* Cleanup the addr_string array but not its contents. */
5334 make_cleanup (xfree
, addr_string
);
5337 /* Allocate space for all the cond expressions. */
5338 cond
= xcalloc (sals
.nelts
, sizeof (struct expression
*));
5339 make_cleanup (xfree
, cond
);
5341 /* Allocate space for all the cond strings. */
5342 cond_string
= xcalloc (sals
.nelts
, sizeof (char **));
5343 make_cleanup (xfree
, cond_string
);
5345 /* ----------------------------- SNIP -----------------------------
5346 Anything added to the cleanup chain beyond this point is assumed
5347 to be part of a breakpoint. If the breakpoint create succeeds
5348 then the memory is not reclaimed. */
5349 breakpoint_chain
= make_cleanup (null_cleanup
, 0);
5351 /* Mark the contents of the addr_string for cleanup. These go on
5352 the breakpoint_chain and only occure if the breakpoint create
5354 for (i
= 0; i
< sals
.nelts
; i
++)
5356 if (addr_string
[i
] != NULL
)
5357 make_cleanup (xfree
, addr_string
[i
]);
5360 /* Resolve all line numbers to PC's and verify that the addresses
5361 are ok for the target. */
5363 breakpoint_sals_to_pc (&sals
, addr_start
);
5365 /* Verify that condition can be parsed, before setting any
5366 breakpoints. Allocate a separate condition expression for each
5368 thread
= -1; /* No specific thread yet */
5371 for (i
= 0; i
< sals
.nelts
; i
++)
5378 char *cond_start
= NULL
;
5379 char *cond_end
= NULL
;
5380 while (*tok
== ' ' || *tok
== '\t')
5385 while (*end_tok
!= ' ' && *end_tok
!= '\t' && *end_tok
!= '\000')
5388 toklen
= end_tok
- tok
;
5390 if (toklen
>= 1 && strncmp (tok
, "if", toklen
) == 0)
5392 tok
= cond_start
= end_tok
+ 1;
5393 cond
[i
] = parse_exp_1 (&tok
, block_for_pc (sals
.sals
[i
].pc
),
5395 make_cleanup (xfree
, cond
[i
]);
5397 cond_string
[i
] = savestring (cond_start
,
5398 cond_end
- cond_start
);
5399 make_cleanup (xfree
, cond_string
[i
]);
5401 else if (toklen
>= 1 && strncmp (tok
, "thread", toklen
) == 0)
5407 thread
= strtol (tok
, &tok
, 0);
5409 error (_("Junk after thread keyword."));
5410 if (!valid_thread_id (thread
))
5411 error (_("Unknown thread %d."), thread
);
5414 error (_("Junk at end of arguments."));
5417 create_breakpoints (sals
, addr_string
, cond
, cond_string
,
5418 hardwareflag
? bp_hardware_breakpoint
5420 tempflag
? disp_del
: disp_donttouch
,
5421 thread
, ignore_count
, from_tty
,
5426 struct symtab_and_line sal
;
5427 struct breakpoint
*b
;
5432 make_cleanup (xfree
, copy_arg
);
5434 b
= set_raw_breakpoint (sal
, hardwareflag
? bp_hardware_breakpoint
5436 set_breakpoint_count (breakpoint_count
+ 1);
5437 b
->number
= breakpoint_count
;
5440 b
->addr_string
= *addr_string
;
5441 b
->cond_string
= *cond_string
;
5442 b
->ignore_count
= ignore_count
;
5444 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
5445 b
->from_tty
= from_tty
;
5451 warning (_("Multiple breakpoints were set.\n"
5452 "Use the \"delete\" command to delete unwanted breakpoints."));
5453 /* That's it. Discard the cleanups for data inserted into the
5455 discard_cleanups (breakpoint_chain
);
5456 /* But cleanup everything else. */
5457 do_cleanups (old_chain
);
5462 /* Set a breakpoint of TYPE/DISPOSITION according to ARG (function,
5463 linenum or *address) with COND and IGNORE_COUNT. */
5465 struct captured_breakpoint_args
5476 do_captured_breakpoint (struct ui_out
*uiout
, void *data
)
5478 struct captured_breakpoint_args
*args
= data
;
5479 struct symtabs_and_lines sals
;
5480 struct expression
**cond
;
5481 struct cleanup
*old_chain
;
5482 struct cleanup
*breakpoint_chain
= NULL
;
5489 /* Parse the source and lines spec. Delay check that the expression
5490 didn't contain trailing garbage until after cleanups are in
5494 address_end
= args
->address
;
5496 parse_breakpoint_sals (&address_end
, &sals
, &addr_string
, 0);
5501 /* Create a chain of things at always need to be cleaned up. */
5502 old_chain
= make_cleanup (null_cleanup
, 0);
5504 /* Always have a addr_string array, even if it is empty. */
5505 make_cleanup (xfree
, addr_string
);
5507 /* Make sure that all storage allocated to SALS gets freed. */
5508 make_cleanup (xfree
, sals
.sals
);
5510 /* Allocate space for all the cond expressions. */
5511 cond
= xcalloc (sals
.nelts
, sizeof (struct expression
*));
5512 make_cleanup (xfree
, cond
);
5514 /* Allocate space for all the cond strings. */
5515 cond_string
= xcalloc (sals
.nelts
, sizeof (char **));
5516 make_cleanup (xfree
, cond_string
);
5518 /* ----------------------------- SNIP -----------------------------
5519 Anything added to the cleanup chain beyond this point is assumed
5520 to be part of a breakpoint. If the breakpoint create goes
5521 through then that memory is not cleaned up. */
5522 breakpoint_chain
= make_cleanup (null_cleanup
, 0);
5524 /* Mark the contents of the addr_string for cleanup. These go on
5525 the breakpoint_chain and only occure if the breakpoint create
5527 for (i
= 0; i
< sals
.nelts
; i
++)
5529 if (addr_string
[i
] != NULL
)
5530 make_cleanup (xfree
, addr_string
[i
]);
5533 /* Wait until now before checking for garbage at the end of the
5534 address. That way cleanups can take care of freeing any
5536 if (*address_end
!= '\0')
5537 error (_("Garbage %s following breakpoint address"), address_end
);
5539 /* Resolve all line numbers to PC's. */
5540 breakpoint_sals_to_pc (&sals
, args
->address
);
5542 /* Verify that conditions can be parsed, before setting any
5544 for (i
= 0; i
< sals
.nelts
; i
++)
5546 if (args
->condition
!= NULL
)
5548 char *tok
= args
->condition
;
5549 cond
[i
] = parse_exp_1 (&tok
, block_for_pc (sals
.sals
[i
].pc
), 0);
5551 error (_("Garbage %s follows condition"), tok
);
5552 make_cleanup (xfree
, cond
[i
]);
5553 cond_string
[i
] = xstrdup (args
->condition
);
5557 create_breakpoints (sals
, addr_string
, cond
, cond_string
,
5558 args
->hardwareflag
? bp_hardware_breakpoint
: bp_breakpoint
,
5559 args
->tempflag
? disp_del
: disp_donttouch
,
5560 args
->thread
, args
->ignore_count
, 0/*from-tty*/,
5561 NULL
/*pending_bp*/);
5563 /* That's it. Discard the cleanups for data inserted into the
5565 discard_cleanups (breakpoint_chain
);
5566 /* But cleanup everything else. */
5567 do_cleanups (old_chain
);
5572 gdb_breakpoint (char *address
, char *condition
,
5573 int hardwareflag
, int tempflag
,
5574 int thread
, int ignore_count
,
5575 char **error_message
)
5577 struct captured_breakpoint_args args
;
5578 args
.address
= address
;
5579 args
.condition
= condition
;
5580 args
.hardwareflag
= hardwareflag
;
5581 args
.tempflag
= tempflag
;
5582 args
.thread
= thread
;
5583 args
.ignore_count
= ignore_count
;
5584 if (catch_exceptions_with_msg (uiout
, do_captured_breakpoint
, &args
,
5585 error_message
, RETURN_MASK_ALL
) < 0)
5592 /* Helper function for break_command_1 and disassemble_command. */
5595 resolve_sal_pc (struct symtab_and_line
*sal
)
5599 if (sal
->pc
== 0 && sal
->symtab
!= NULL
)
5601 if (!find_line_pc (sal
->symtab
, sal
->line
, &pc
))
5602 error (_("No line %d in file \"%s\"."),
5603 sal
->line
, sal
->symtab
->filename
);
5607 if (sal
->section
== 0 && sal
->symtab
!= NULL
)
5609 struct blockvector
*bv
;
5614 bv
= blockvector_for_pc_sect (sal
->pc
, 0, &index
, sal
->symtab
);
5617 b
= BLOCKVECTOR_BLOCK (bv
, index
);
5618 sym
= block_function (b
);
5621 fixup_symbol_section (sym
, sal
->symtab
->objfile
);
5622 sal
->section
= SYMBOL_BFD_SECTION (sym
);
5626 /* It really is worthwhile to have the section, so we'll just
5627 have to look harder. This case can be executed if we have
5628 line numbers but no functions (as can happen in assembly
5631 struct minimal_symbol
*msym
;
5633 msym
= lookup_minimal_symbol_by_pc (sal
->pc
);
5635 sal
->section
= SYMBOL_BFD_SECTION (msym
);
5642 break_command (char *arg
, int from_tty
)
5644 break_command_1 (arg
, 0, from_tty
, NULL
);
5648 tbreak_command (char *arg
, int from_tty
)
5650 break_command_1 (arg
, BP_TEMPFLAG
, from_tty
, NULL
);
5654 hbreak_command (char *arg
, int from_tty
)
5656 break_command_1 (arg
, BP_HARDWAREFLAG
, from_tty
, NULL
);
5660 thbreak_command (char *arg
, int from_tty
)
5662 break_command_1 (arg
, (BP_TEMPFLAG
| BP_HARDWAREFLAG
), from_tty
, NULL
);
5666 stop_command (char *arg
, int from_tty
)
5668 printf_filtered (_("Specify the type of breakpoint to set.\n\
5669 Usage: stop in <function | address>\n\
5670 stop at <line>\n"));
5674 stopin_command (char *arg
, int from_tty
)
5678 if (arg
== (char *) NULL
)
5680 else if (*arg
!= '*')
5685 /* look for a ':'. If this is a line number specification, then
5686 say it is bad, otherwise, it should be an address or
5687 function/method name */
5688 while (*argptr
&& !hasColon
)
5690 hasColon
= (*argptr
== ':');
5695 badInput
= (*argptr
!= ':'); /* Not a class::method */
5697 badInput
= isdigit (*arg
); /* a simple line number */
5701 printf_filtered (_("Usage: stop in <function | address>\n"));
5703 break_command_1 (arg
, 0, from_tty
, NULL
);
5707 stopat_command (char *arg
, int from_tty
)
5711 if (arg
== (char *) NULL
|| *arg
== '*') /* no line number */
5718 /* look for a ':'. If there is a '::' then get out, otherwise
5719 it is probably a line number. */
5720 while (*argptr
&& !hasColon
)
5722 hasColon
= (*argptr
== ':');
5727 badInput
= (*argptr
== ':'); /* we have class::method */
5729 badInput
= !isdigit (*arg
); /* not a line number */
5733 printf_filtered (_("Usage: stop at <line>\n"));
5735 break_command_1 (arg
, 0, from_tty
, NULL
);
5738 /* accessflag: hw_write: watch write,
5739 hw_read: watch read,
5740 hw_access: watch access (read or write) */
5742 watch_command_1 (char *arg
, int accessflag
, int from_tty
)
5744 struct breakpoint
*b
;
5745 struct symtab_and_line sal
;
5746 struct expression
*exp
;
5747 struct block
*exp_valid_block
;
5748 struct value
*val
, *mark
;
5749 struct frame_info
*frame
;
5750 struct frame_info
*prev_frame
= NULL
;
5751 char *exp_start
= NULL
;
5752 char *exp_end
= NULL
;
5753 char *tok
, *end_tok
;
5755 char *cond_start
= NULL
;
5756 char *cond_end
= NULL
;
5757 struct expression
*cond
= NULL
;
5758 int i
, other_type_used
, target_resources_ok
= 0;
5759 enum bptype bp_type
;
5762 init_sal (&sal
); /* initialize to zeroes */
5764 /* Parse arguments. */
5765 innermost_block
= NULL
;
5767 exp
= parse_exp_1 (&arg
, 0, 0);
5769 exp_valid_block
= innermost_block
;
5770 mark
= value_mark ();
5771 val
= evaluate_expression (exp
);
5772 release_value (val
);
5773 if (value_lazy (val
))
5774 value_fetch_lazy (val
);
5777 while (*tok
== ' ' || *tok
== '\t')
5781 while (*end_tok
!= ' ' && *end_tok
!= '\t' && *end_tok
!= '\000')
5784 toklen
= end_tok
- tok
;
5785 if (toklen
>= 1 && strncmp (tok
, "if", toklen
) == 0)
5787 tok
= cond_start
= end_tok
+ 1;
5788 cond
= parse_exp_1 (&tok
, 0, 0);
5792 error (_("Junk at end of command."));
5794 if (accessflag
== hw_read
)
5795 bp_type
= bp_read_watchpoint
;
5796 else if (accessflag
== hw_access
)
5797 bp_type
= bp_access_watchpoint
;
5799 bp_type
= bp_hardware_watchpoint
;
5801 mem_cnt
= can_use_hardware_watchpoint (val
);
5802 if (mem_cnt
== 0 && bp_type
!= bp_hardware_watchpoint
)
5803 error (_("Expression cannot be implemented with read/access watchpoint."));
5806 i
= hw_watchpoint_used_count (bp_type
, &other_type_used
);
5807 target_resources_ok
=
5808 TARGET_CAN_USE_HARDWARE_WATCHPOINT (bp_type
, i
+ mem_cnt
,
5810 if (target_resources_ok
== 0 && bp_type
!= bp_hardware_watchpoint
)
5811 error (_("Target does not support this type of hardware watchpoint."));
5813 if (target_resources_ok
< 0 && bp_type
!= bp_hardware_watchpoint
)
5814 error (_("Target can only support one kind of HW watchpoint at a time."));
5817 #if defined(HPUXHPPA)
5818 /* On HP-UX if you set a h/w
5819 watchpoint before the "run" command, the inferior dies with a e.g.,
5820 SIGILL once you start it. I initially believed this was due to a
5821 bad interaction between page protection traps and the initial
5822 startup sequence by the dynamic linker.
5824 However, I tried avoiding that by having HP-UX's implementation of
5825 TARGET_CAN_USE_HW_WATCHPOINT return FALSE if there was no inferior_ptid
5826 yet, which forced slow watches before a "run" or "attach", and it
5827 still fails somewhere in the startup code.
5829 Until I figure out what's happening, I'm disallowing watches altogether
5830 before the "run" or "attach" command. We'll tell the user they must
5831 set watches after getting the program started. */
5832 if (!target_has_execution
)
5834 warning (_("can't do that without a running program; try \"break main\"), \"run\" first");
5837 #endif /* HPUXHPPA */
5839 /* Change the type of breakpoint to an ordinary watchpoint if a hardware
5840 watchpoint could not be set. */
5841 if (!mem_cnt
|| target_resources_ok
<= 0)
5842 bp_type
= bp_watchpoint
;
5844 /* Now set up the breakpoint. */
5845 b
= set_raw_breakpoint (sal
, bp_type
);
5846 set_breakpoint_count (breakpoint_count
+ 1);
5847 b
->number
= breakpoint_count
;
5848 b
->disposition
= disp_donttouch
;
5850 b
->exp_valid_block
= exp_valid_block
;
5851 b
->exp_string
= savestring (exp_start
, exp_end
- exp_start
);
5855 b
->cond_string
= savestring (cond_start
, cond_end
- cond_start
);
5859 frame
= block_innermost_frame (exp_valid_block
);
5862 prev_frame
= get_prev_frame (frame
);
5863 b
->watchpoint_frame
= get_frame_id (frame
);
5867 memset (&b
->watchpoint_frame
, 0, sizeof (b
->watchpoint_frame
));
5870 /* If the expression is "local", then set up a "watchpoint scope"
5871 breakpoint at the point where we've left the scope of the watchpoint
5873 if (innermost_block
)
5877 struct breakpoint
*scope_breakpoint
;
5878 scope_breakpoint
= create_internal_breakpoint (get_frame_pc (prev_frame
),
5879 bp_watchpoint_scope
);
5881 scope_breakpoint
->enable_state
= bp_enabled
;
5883 /* Automatically delete the breakpoint when it hits. */
5884 scope_breakpoint
->disposition
= disp_del
;
5886 /* Only break in the proper frame (help with recursion). */
5887 scope_breakpoint
->frame_id
= get_frame_id (prev_frame
);
5889 /* Set the address at which we will stop. */
5890 scope_breakpoint
->loc
->requested_address
5891 = get_frame_pc (prev_frame
);
5892 scope_breakpoint
->loc
->address
5893 = adjust_breakpoint_address (scope_breakpoint
->loc
->requested_address
,
5894 scope_breakpoint
->type
);
5896 /* The scope breakpoint is related to the watchpoint. We
5897 will need to act on them together. */
5898 b
->related_breakpoint
= scope_breakpoint
;
5901 value_free_to_mark (mark
);
5905 /* Return count of locations need to be watched and can be handled
5906 in hardware. If the watchpoint can not be handled
5907 in hardware return zero. */
5910 can_use_hardware_watchpoint (struct value
*v
)
5912 int found_memory_cnt
= 0;
5913 struct value
*head
= v
;
5915 /* Did the user specifically forbid us to use hardware watchpoints? */
5916 if (!can_use_hw_watchpoints
)
5919 /* Make sure that the value of the expression depends only upon
5920 memory contents, and values computed from them within GDB. If we
5921 find any register references or function calls, we can't use a
5922 hardware watchpoint.
5924 The idea here is that evaluating an expression generates a series
5925 of values, one holding the value of every subexpression. (The
5926 expression a*b+c has five subexpressions: a, b, a*b, c, and
5927 a*b+c.) GDB's values hold almost enough information to establish
5928 the criteria given above --- they identify memory lvalues,
5929 register lvalues, computed values, etcetera. So we can evaluate
5930 the expression, and then scan the chain of values that leaves
5931 behind to decide whether we can detect any possible change to the
5932 expression's final value using only hardware watchpoints.
5934 However, I don't think that the values returned by inferior
5935 function calls are special in any way. So this function may not
5936 notice that an expression involving an inferior function call
5937 can't be watched with hardware watchpoints. FIXME. */
5938 for (; v
; v
= value_next (v
))
5940 if (VALUE_LVAL (v
) == lval_memory
)
5943 /* A lazy memory lvalue is one that GDB never needed to fetch;
5944 we either just used its address (e.g., `a' in `a.b') or
5945 we never needed it at all (e.g., `a' in `a,b'). */
5949 /* Ahh, memory we actually used! Check if we can cover
5950 it with hardware watchpoints. */
5951 struct type
*vtype
= check_typedef (value_type (v
));
5953 /* We only watch structs and arrays if user asked for it
5954 explicitly, never if they just happen to appear in a
5955 middle of some value chain. */
5957 || (TYPE_CODE (vtype
) != TYPE_CODE_STRUCT
5958 && TYPE_CODE (vtype
) != TYPE_CODE_ARRAY
))
5960 CORE_ADDR vaddr
= VALUE_ADDRESS (v
) + value_offset (v
);
5961 int len
= TYPE_LENGTH (value_type (v
));
5963 if (!TARGET_REGION_OK_FOR_HW_WATCHPOINT (vaddr
, len
))
5970 else if (VALUE_LVAL (v
) != not_lval
5971 && deprecated_value_modifiable (v
) == 0)
5972 return 0; /* ??? What does this represent? */
5973 else if (VALUE_LVAL (v
) == lval_register
)
5974 return 0; /* cannot watch a register with a HW watchpoint */
5977 /* The expression itself looks suitable for using a hardware
5978 watchpoint, but give the target machine a chance to reject it. */
5979 return found_memory_cnt
;
5983 watch_command_wrapper (char *arg
, int from_tty
)
5985 watch_command (arg
, from_tty
);
5989 watch_command (char *arg
, int from_tty
)
5991 watch_command_1 (arg
, hw_write
, from_tty
);
5995 rwatch_command_wrapper (char *arg
, int from_tty
)
5997 rwatch_command (arg
, from_tty
);
6001 rwatch_command (char *arg
, int from_tty
)
6003 watch_command_1 (arg
, hw_read
, from_tty
);
6007 awatch_command_wrapper (char *arg
, int from_tty
)
6009 awatch_command (arg
, from_tty
);
6013 awatch_command (char *arg
, int from_tty
)
6015 watch_command_1 (arg
, hw_access
, from_tty
);
6019 /* Helper routines for the until_command routine in infcmd.c. Here
6020 because it uses the mechanisms of breakpoints. */
6022 /* This function is called by fetch_inferior_event via the
6023 cmd_continuation pointer, to complete the until command. It takes
6024 care of cleaning up the temporary breakpoints set up by the until
6027 until_break_command_continuation (struct continuation_arg
*arg
)
6029 struct cleanup
*cleanups
;
6031 cleanups
= (struct cleanup
*) arg
->data
.pointer
;
6032 do_exec_cleanups (cleanups
);
6036 until_break_command (char *arg
, int from_tty
, int anywhere
)
6038 struct symtabs_and_lines sals
;
6039 struct symtab_and_line sal
;
6040 struct frame_info
*frame
= get_selected_frame (NULL
);
6041 struct frame_info
*prev_frame
= get_prev_frame (frame
);
6042 struct breakpoint
*breakpoint
;
6043 struct cleanup
*old_chain
;
6044 struct continuation_arg
*arg1
;
6047 clear_proceed_status ();
6049 /* Set a breakpoint where the user wants it and at return from
6052 if (default_breakpoint_valid
)
6053 sals
= decode_line_1 (&arg
, 1, default_breakpoint_symtab
,
6054 default_breakpoint_line
, (char ***) NULL
, NULL
);
6056 sals
= decode_line_1 (&arg
, 1, (struct symtab
*) NULL
,
6057 0, (char ***) NULL
, NULL
);
6059 if (sals
.nelts
!= 1)
6060 error (_("Couldn't get information on specified line."));
6063 xfree (sals
.sals
); /* malloc'd, so freed */
6066 error (_("Junk at end of arguments."));
6068 resolve_sal_pc (&sal
);
6071 /* If the user told us to continue until a specified location,
6072 we don't specify a frame at which we need to stop. */
6073 breakpoint
= set_momentary_breakpoint (sal
, null_frame_id
, bp_until
);
6075 /* Otherwise, specify the current frame, because we want to stop only
6076 at the very same frame. */
6077 breakpoint
= set_momentary_breakpoint (sal
, get_frame_id (frame
),
6080 if (!target_can_async_p ())
6081 old_chain
= make_cleanup_delete_breakpoint (breakpoint
);
6083 old_chain
= make_exec_cleanup_delete_breakpoint (breakpoint
);
6085 /* If we are running asynchronously, and the target supports async
6086 execution, we are not waiting for the target to stop, in the call
6087 tp proceed, below. This means that we cannot delete the
6088 brekpoints until the target has actually stopped. The only place
6089 where we get a chance to do that is in fetch_inferior_event, so
6090 we must set things up for that. */
6092 if (target_can_async_p ())
6094 /* In this case the arg for the continuation is just the point
6095 in the exec_cleanups chain from where to start doing
6096 cleanups, because all the continuation does is the cleanups in
6097 the exec_cleanup_chain. */
6099 (struct continuation_arg
*) xmalloc (sizeof (struct continuation_arg
));
6101 arg1
->data
.pointer
= old_chain
;
6103 add_continuation (until_break_command_continuation
, arg1
);
6106 /* Keep within the current frame, or in frames called by the current
6110 sal
= find_pc_line (get_frame_pc (prev_frame
), 0);
6111 sal
.pc
= get_frame_pc (prev_frame
);
6112 breakpoint
= set_momentary_breakpoint (sal
, get_frame_id (prev_frame
),
6114 if (!target_can_async_p ())
6115 make_cleanup_delete_breakpoint (breakpoint
);
6117 make_exec_cleanup_delete_breakpoint (breakpoint
);
6120 proceed (-1, TARGET_SIGNAL_DEFAULT
, 0);
6121 /* Do the cleanups now, anly if we are not running asynchronously,
6122 of if we are, but the target is still synchronous. */
6123 if (!target_can_async_p ())
6124 do_cleanups (old_chain
);
6128 ep_skip_leading_whitespace (char **s
)
6130 if ((s
== NULL
) || (*s
== NULL
))
6132 while (isspace (**s
))
6136 /* This function examines a string, and attempts to find a token
6137 that might be an event name in the leading characters. If a
6138 possible match is found, a pointer to the last character of
6139 the token is returned. Else, NULL is returned. */
6142 ep_find_event_name_end (char *arg
)
6145 char *event_name_end
= NULL
;
6147 /* If we could depend upon the presense of strrpbrk, we'd use that... */
6151 /* We break out of the loop when we find a token delimiter.
6152 Basically, we're looking for alphanumerics and underscores;
6153 anything else delimites the token. */
6156 if (!isalnum (*s
) && (*s
!= '_'))
6162 return event_name_end
;
6166 /* This function attempts to parse an optional "if <cond>" clause
6167 from the arg string. If one is not found, it returns NULL.
6169 Else, it returns a pointer to the condition string. (It does not
6170 attempt to evaluate the string against a particular block.) And,
6171 it updates arg to point to the first character following the parsed
6172 if clause in the arg string. */
6175 ep_parse_optional_if_clause (char **arg
)
6179 if (((*arg
)[0] != 'i') || ((*arg
)[1] != 'f') || !isspace ((*arg
)[2]))
6182 /* Skip the "if" keyword. */
6185 /* Skip any extra leading whitespace, and record the start of the
6186 condition string. */
6187 ep_skip_leading_whitespace (arg
);
6190 /* Assume that the condition occupies the remainder of the arg string. */
6191 (*arg
) += strlen (cond_string
);
6196 /* This function attempts to parse an optional filename from the arg
6197 string. If one is not found, it returns NULL.
6199 Else, it returns a pointer to the parsed filename. (This function
6200 makes no attempt to verify that a file of that name exists, or is
6201 accessible.) And, it updates arg to point to the first character
6202 following the parsed filename in the arg string.
6204 Note that clients needing to preserve the returned filename for
6205 future access should copy it to their own buffers. */
6207 ep_parse_optional_filename (char **arg
)
6209 static char filename
[1024];
6214 if ((*arg_p
== '\0') || isspace (*arg_p
))
6232 /* Commands to deal with catching events, such as signals, exceptions,
6233 process start/exit, etc. */
6237 catch_fork
, catch_vfork
6242 catch_fork_command_1 (catch_fork_kind fork_kind
, char *arg
, int tempflag
,
6245 char *cond_string
= NULL
;
6247 ep_skip_leading_whitespace (&arg
);
6249 /* The allowed syntax is:
6251 catch [v]fork if <cond>
6253 First, check if there's an if clause. */
6254 cond_string
= ep_parse_optional_if_clause (&arg
);
6256 if ((*arg
!= '\0') && !isspace (*arg
))
6257 error (_("Junk at end of arguments."));
6259 /* If this target supports it, create a fork or vfork catchpoint
6260 and enable reporting of such events. */
6264 create_fork_event_catchpoint (tempflag
, cond_string
);
6267 create_vfork_event_catchpoint (tempflag
, cond_string
);
6270 error (_("unsupported or unknown fork kind; cannot catch it"));
6276 catch_exec_command_1 (char *arg
, int tempflag
, int from_tty
)
6278 char *cond_string
= NULL
;
6280 ep_skip_leading_whitespace (&arg
);
6282 /* The allowed syntax is:
6284 catch exec if <cond>
6286 First, check if there's an if clause. */
6287 cond_string
= ep_parse_optional_if_clause (&arg
);
6289 if ((*arg
!= '\0') && !isspace (*arg
))
6290 error (_("Junk at end of arguments."));
6292 /* If this target supports it, create an exec catchpoint
6293 and enable reporting of such events. */
6294 create_exec_event_catchpoint (tempflag
, cond_string
);
6298 catch_load_command_1 (char *arg
, int tempflag
, int from_tty
)
6300 char *dll_pathname
= NULL
;
6301 char *cond_string
= NULL
;
6303 ep_skip_leading_whitespace (&arg
);
6305 /* The allowed syntax is:
6307 catch load if <cond>
6308 catch load <filename>
6309 catch load <filename> if <cond>
6311 The user is not allowed to specify the <filename> after an
6314 We'll ignore the pathological case of a file named "if".
6316 First, check if there's an if clause. If so, then there
6317 cannot be a filename. */
6318 cond_string
= ep_parse_optional_if_clause (&arg
);
6320 /* If there was an if clause, then there cannot be a filename.
6321 Else, there might be a filename and an if clause. */
6322 if (cond_string
== NULL
)
6324 dll_pathname
= ep_parse_optional_filename (&arg
);
6325 ep_skip_leading_whitespace (&arg
);
6326 cond_string
= ep_parse_optional_if_clause (&arg
);
6329 if ((*arg
!= '\0') && !isspace (*arg
))
6330 error (_("Junk at end of arguments."));
6332 /* Create a load breakpoint that only triggers when a load of
6333 the specified dll (or any dll, if no pathname was specified)
6335 SOLIB_CREATE_CATCH_LOAD_HOOK (PIDGET (inferior_ptid
), tempflag
,
6336 dll_pathname
, cond_string
);
6340 catch_unload_command_1 (char *arg
, int tempflag
, int from_tty
)
6342 char *dll_pathname
= NULL
;
6343 char *cond_string
= NULL
;
6345 ep_skip_leading_whitespace (&arg
);
6347 /* The allowed syntax is:
6349 catch unload if <cond>
6350 catch unload <filename>
6351 catch unload <filename> if <cond>
6353 The user is not allowed to specify the <filename> after an
6356 We'll ignore the pathological case of a file named "if".
6358 First, check if there's an if clause. If so, then there
6359 cannot be a filename. */
6360 cond_string
= ep_parse_optional_if_clause (&arg
);
6362 /* If there was an if clause, then there cannot be a filename.
6363 Else, there might be a filename and an if clause. */
6364 if (cond_string
== NULL
)
6366 dll_pathname
= ep_parse_optional_filename (&arg
);
6367 ep_skip_leading_whitespace (&arg
);
6368 cond_string
= ep_parse_optional_if_clause (&arg
);
6371 if ((*arg
!= '\0') && !isspace (*arg
))
6372 error (_("Junk at end of arguments."));
6374 /* Create an unload breakpoint that only triggers when an unload of
6375 the specified dll (or any dll, if no pathname was specified)
6377 SOLIB_CREATE_CATCH_UNLOAD_HOOK (PIDGET (inferior_ptid
), tempflag
,
6378 dll_pathname
, cond_string
);
6381 /* Commands to deal with catching exceptions. */
6383 /* Set a breakpoint at the specified callback routine for an
6384 exception event callback */
6387 create_exception_catchpoint (int tempflag
, char *cond_string
,
6388 enum exception_event_kind ex_event
,
6389 struct symtab_and_line
*sal
)
6391 struct breakpoint
*b
;
6392 int thread
= -1; /* All threads. */
6395 if (!sal
) /* no exception support? */
6400 case EX_EVENT_THROW
:
6401 bptype
= bp_catch_throw
;
6403 case EX_EVENT_CATCH
:
6404 bptype
= bp_catch_catch
;
6406 default: /* error condition */
6407 error (_("Internal error -- invalid catchpoint kind"));
6410 b
= set_raw_breakpoint (*sal
, bptype
);
6411 set_breakpoint_count (breakpoint_count
+ 1);
6412 b
->number
= breakpoint_count
;
6414 b
->cond_string
= (cond_string
== NULL
) ?
6415 NULL
: savestring (cond_string
, strlen (cond_string
));
6417 b
->addr_string
= NULL
;
6418 b
->enable_state
= bp_enabled
;
6419 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
6423 static enum print_stop_action
6424 print_exception_catchpoint (struct breakpoint
*b
)
6426 annotate_catchpoint (b
->number
);
6428 if (strstr (b
->addr_string
, "throw") != NULL
)
6429 printf_filtered (_("\nCatchpoint %d (exception thrown)\n"),
6432 printf_filtered (_("\nCatchpoint %d (exception caught)\n"),
6435 return PRINT_SRC_AND_LOC
;
6439 print_one_exception_catchpoint (struct breakpoint
*b
, CORE_ADDR
*last_addr
)
6444 ui_out_field_core_addr (uiout
, "addr", b
->loc
->address
);
6447 *last_addr
= b
->loc
->address
;
6448 if (strstr (b
->addr_string
, "throw") != NULL
)
6449 ui_out_field_string (uiout
, "what", "exception throw");
6451 ui_out_field_string (uiout
, "what", "exception catch");
6455 print_mention_exception_catchpoint (struct breakpoint
*b
)
6457 if (strstr (b
->addr_string
, "throw") != NULL
)
6458 printf_filtered (_("Catchpoint %d (throw)"), b
->number
);
6460 printf_filtered (_("Catchpoint %d (catch)"), b
->number
);
6463 static struct breakpoint_ops gnu_v3_exception_catchpoint_ops
= {
6464 print_exception_catchpoint
,
6465 print_one_exception_catchpoint
,
6466 print_mention_exception_catchpoint
6470 handle_gnu_v3_exceptions (int tempflag
, char *cond_string
,
6471 enum exception_event_kind ex_event
, int from_tty
)
6473 char *trigger_func_name
, *nameptr
;
6474 struct symtabs_and_lines sals
;
6475 struct breakpoint
*b
;
6477 if (ex_event
== EX_EVENT_CATCH
)
6478 trigger_func_name
= xstrdup ("__cxa_begin_catch");
6480 trigger_func_name
= xstrdup ("__cxa_throw");
6482 nameptr
= trigger_func_name
;
6483 sals
= decode_line_1 (&nameptr
, 1, NULL
, 0, NULL
, NULL
);
6484 if (sals
.nelts
== 0)
6486 xfree (trigger_func_name
);
6490 b
= set_raw_breakpoint (sals
.sals
[0], bp_breakpoint
);
6491 set_breakpoint_count (breakpoint_count
+ 1);
6492 b
->number
= breakpoint_count
;
6494 b
->cond_string
= (cond_string
== NULL
) ?
6495 NULL
: savestring (cond_string
, strlen (cond_string
));
6497 b
->addr_string
= trigger_func_name
;
6498 b
->enable_state
= bp_enabled
;
6499 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
6500 b
->ops
= &gnu_v3_exception_catchpoint_ops
;
6507 /* Deal with "catch catch" and "catch throw" commands */
6510 catch_exception_command_1 (enum exception_event_kind ex_event
, char *arg
,
6511 int tempflag
, int from_tty
)
6513 char *cond_string
= NULL
;
6514 struct symtab_and_line
*sal
= NULL
;
6516 ep_skip_leading_whitespace (&arg
);
6518 cond_string
= ep_parse_optional_if_clause (&arg
);
6520 if ((*arg
!= '\0') && !isspace (*arg
))
6521 error (_("Junk at end of arguments."));
6523 if ((ex_event
!= EX_EVENT_THROW
) &&
6524 (ex_event
!= EX_EVENT_CATCH
))
6525 error (_("Unsupported or unknown exception event; cannot catch it"));
6527 if (handle_gnu_v3_exceptions (tempflag
, cond_string
, ex_event
, from_tty
))
6530 /* See if we can find a callback routine */
6531 sal
= target_enable_exception_callback (ex_event
, 1);
6535 /* We have callbacks from the runtime system for exceptions.
6536 Set a breakpoint on the sal found, if no errors */
6537 if (sal
!= (struct symtab_and_line
*) -1)
6538 create_exception_catchpoint (tempflag
, cond_string
, ex_event
, sal
);
6540 return; /* something went wrong with setting up callbacks */
6543 warning (_("Unsupported with this platform/compiler combination."));
6546 /* Create a breakpoint struct for Ada exception catchpoints. */
6549 create_ada_exception_breakpoint (struct symtab_and_line sal
,
6553 struct expression
*cond
,
6554 struct breakpoint_ops
*ops
,
6558 struct breakpoint
*b
;
6562 describe_other_breakpoints (sal
.pc
, sal
.section
, -1);
6563 /* FIXME: brobecker/2006-12-28: Actually, re-implement a special
6564 version for exception catchpoints, because two catchpoints
6565 used for different exception names will use the same address.
6566 In this case, a "breakpoint ... also set at..." warning is
6567 unproductive. Besides. the warning phrasing is also a bit
6568 inapropriate, we should use the word catchpoint, and tell
6569 the user what type of catchpoint it is. The above is good
6570 enough for now, though. */
6573 b
= set_raw_breakpoint (sal
, bp_breakpoint
);
6574 set_breakpoint_count (breakpoint_count
+ 1);
6576 b
->enable_state
= bp_enabled
;
6577 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
6578 b
->number
= breakpoint_count
;
6579 b
->ignore_count
= 0;
6581 b
->addr_string
= addr_string
;
6582 b
->language
= language_ada
;
6583 b
->cond_string
= cond_string
;
6584 b
->exp_string
= exp_string
;
6587 b
->from_tty
= from_tty
;
6592 /* Implement the "catch exception" command. */
6595 catch_ada_exception_command (char *arg
, int tempflag
, int from_tty
)
6597 struct symtab_and_line sal
;
6599 char *addr_string
= NULL
;
6600 char *exp_string
= NULL
;
6601 char *cond_string
= NULL
;
6602 struct expression
*cond
= NULL
;
6603 struct breakpoint_ops
*ops
= NULL
;
6605 sal
= ada_decode_exception_location (arg
, &addr_string
, &exp_string
,
6606 &cond_string
, &cond
, &ops
);
6607 create_ada_exception_breakpoint (sal
, addr_string
, exp_string
,
6608 cond_string
, cond
, ops
, tempflag
,
6612 /* Implement the "catch assert" command. */
6615 catch_assert_command (char *arg
, int tempflag
, int from_tty
)
6617 struct symtab_and_line sal
;
6618 char *addr_string
= NULL
;
6619 struct breakpoint_ops
*ops
= NULL
;
6621 sal
= ada_decode_assert_location (arg
, &addr_string
, &ops
);
6622 create_ada_exception_breakpoint (sal
, addr_string
, NULL
, NULL
, NULL
, ops
,
6623 tempflag
, from_tty
);
6626 /* Cover routine to allow wrapping target_enable_exception_catchpoints
6627 inside a catch_errors */
6630 cover_target_enable_exception_callback (void *arg
)
6632 args_for_catchpoint_enable
*args
= arg
;
6633 struct symtab_and_line
*sal
;
6634 sal
= target_enable_exception_callback (args
->kind
, args
->enable_p
);
6637 else if (sal
== (struct symtab_and_line
*) -1)
6640 return 1; /*is valid */
6644 catch_command_1 (char *arg
, int tempflag
, int from_tty
)
6647 /* The first argument may be an event name, such as "start" or "load".
6648 If so, then handle it as such. If it doesn't match an event name,
6649 then attempt to interpret it as an exception name. (This latter is
6650 the v4.16-and-earlier GDB meaning of the "catch" command.)
6652 First, try to find the bounds of what might be an event name. */
6653 char *arg1_start
= arg
;
6657 if (arg1_start
== NULL
)
6659 /* Old behaviour was to use pre-v-4.16 syntax */
6660 /* catch_throw_command_1 (arg1_start, tempflag, from_tty); */
6662 /* Now, this is not allowed */
6663 error (_("Catch requires an event name."));
6666 arg1_end
= ep_find_event_name_end (arg1_start
);
6667 if (arg1_end
== NULL
)
6668 error (_("catch requires an event"));
6669 arg1_length
= arg1_end
+ 1 - arg1_start
;
6671 /* Try to match what we found against known event names. */
6672 if (strncmp (arg1_start
, "signal", arg1_length
) == 0)
6674 error (_("Catch of signal not yet implemented"));
6676 else if (strncmp (arg1_start
, "catch", arg1_length
) == 0)
6678 catch_exception_command_1 (EX_EVENT_CATCH
, arg1_end
+ 1,
6679 tempflag
, from_tty
);
6681 else if (strncmp (arg1_start
, "throw", arg1_length
) == 0)
6683 catch_exception_command_1 (EX_EVENT_THROW
, arg1_end
+ 1,
6684 tempflag
, from_tty
);
6686 else if (strncmp (arg1_start
, "thread_start", arg1_length
) == 0)
6688 error (_("Catch of thread_start not yet implemented"));
6690 else if (strncmp (arg1_start
, "thread_exit", arg1_length
) == 0)
6692 error (_("Catch of thread_exit not yet implemented"));
6694 else if (strncmp (arg1_start
, "thread_join", arg1_length
) == 0)
6696 error (_("Catch of thread_join not yet implemented"));
6698 else if (strncmp (arg1_start
, "start", arg1_length
) == 0)
6700 error (_("Catch of start not yet implemented"));
6702 else if (strncmp (arg1_start
, "exit", arg1_length
) == 0)
6704 error (_("Catch of exit not yet implemented"));
6706 else if (strncmp (arg1_start
, "fork", arg1_length
) == 0)
6708 catch_fork_command_1 (catch_fork
, arg1_end
+ 1, tempflag
, from_tty
);
6710 else if (strncmp (arg1_start
, "vfork", arg1_length
) == 0)
6712 catch_fork_command_1 (catch_vfork
, arg1_end
+ 1, tempflag
, from_tty
);
6714 else if (strncmp (arg1_start
, "exec", arg1_length
) == 0)
6716 catch_exec_command_1 (arg1_end
+ 1, tempflag
, from_tty
);
6718 else if (strncmp (arg1_start
, "load", arg1_length
) == 0)
6720 catch_load_command_1 (arg1_end
+ 1, tempflag
, from_tty
);
6722 else if (strncmp (arg1_start
, "unload", arg1_length
) == 0)
6724 catch_unload_command_1 (arg1_end
+ 1, tempflag
, from_tty
);
6726 else if (strncmp (arg1_start
, "stop", arg1_length
) == 0)
6728 error (_("Catch of stop not yet implemented"));
6730 else if (strncmp (arg1_start
, "exception", arg1_length
) == 0)
6732 catch_ada_exception_command (arg1_end
+ 1, tempflag
, from_tty
);
6735 else if (strncmp (arg1_start
, "assert", arg1_length
) == 0)
6737 catch_assert_command (arg1_end
+ 1, tempflag
, from_tty
);
6740 /* This doesn't appear to be an event name */
6744 /* Pre-v.4.16 behaviour was to treat the argument
6745 as the name of an exception */
6746 /* catch_throw_command_1 (arg1_start, tempflag, from_tty); */
6747 /* Now this is not allowed */
6748 error (_("Unknown event kind specified for catch"));
6753 /* Used by the gui, could be made a worker for other things. */
6756 set_breakpoint_sal (struct symtab_and_line sal
)
6758 struct breakpoint
*b
;
6759 b
= set_raw_breakpoint (sal
, bp_breakpoint
);
6760 set_breakpoint_count (breakpoint_count
+ 1);
6761 b
->number
= breakpoint_count
;
6768 catch_command (char *arg
, int from_tty
)
6770 catch_command_1 (arg
, 0, from_tty
);
6775 tcatch_command (char *arg
, int from_tty
)
6777 catch_command_1 (arg
, 1, from_tty
);
6780 /* Delete breakpoints by address or line. */
6783 clear_command (char *arg
, int from_tty
)
6785 struct breakpoint
*b
, *tmp
, *prev
, *found
;
6787 struct symtabs_and_lines sals
;
6788 struct symtab_and_line sal
;
6793 sals
= decode_line_spec (arg
, 1);
6798 sals
.sals
= (struct symtab_and_line
*)
6799 xmalloc (sizeof (struct symtab_and_line
));
6800 make_cleanup (xfree
, sals
.sals
);
6801 init_sal (&sal
); /* initialize to zeroes */
6802 sal
.line
= default_breakpoint_line
;
6803 sal
.symtab
= default_breakpoint_symtab
;
6804 sal
.pc
= default_breakpoint_address
;
6805 if (sal
.symtab
== 0)
6806 error (_("No source file specified."));
6814 /* For each line spec given, delete bps which correspond
6815 to it. Do it in two passes, solely to preserve the current
6816 behavior that from_tty is forced true if we delete more than
6820 for (i
= 0; i
< sals
.nelts
; i
++)
6822 /* If exact pc given, clear bpts at that pc.
6823 If line given (pc == 0), clear all bpts on specified line.
6824 If defaulting, clear all bpts on default line
6827 defaulting sal.pc != 0 tests to do
6832 1 0 <can't happen> */
6837 /* Find all matching breakpoints, remove them from the
6838 breakpoint chain, and add them to the 'found' chain. */
6839 ALL_BREAKPOINTS_SAFE (b
, tmp
)
6841 /* Are we going to delete b? */
6842 if (b
->type
!= bp_none
6843 && b
->type
!= bp_watchpoint
6844 && b
->type
!= bp_hardware_watchpoint
6845 && b
->type
!= bp_read_watchpoint
6846 && b
->type
!= bp_access_watchpoint
6847 /* Not if b is a watchpoint of any sort... */
6848 && (((sal
.pc
&& (b
->loc
->address
== sal
.pc
))
6849 && (!section_is_overlay (b
->loc
->section
)
6850 || b
->loc
->section
== sal
.section
))
6851 /* Yes, if sal.pc matches b (modulo overlays). */
6852 || ((default_match
|| (0 == sal
.pc
))
6853 && b
->source_file
!= NULL
6854 && sal
.symtab
!= NULL
6855 && strcmp (b
->source_file
, sal
.symtab
->filename
) == 0
6856 && b
->line_number
== sal
.line
)))
6857 /* Yes, if sal source file and line matches b. */
6859 /* Remove it from breakpoint_chain... */
6860 if (b
== breakpoint_chain
)
6862 /* b is at the head of the list */
6863 breakpoint_chain
= b
->next
;
6867 prev
->next
= b
->next
;
6869 /* And add it to 'found' chain. */
6875 /* Keep b, and keep a pointer to it. */
6880 /* Now go thru the 'found' chain and delete them. */
6884 error (_("No breakpoint at %s."), arg
);
6886 error (_("No breakpoint at this line."));
6890 from_tty
= 1; /* Always report if deleted more than one */
6894 printf_unfiltered (_("Deleted breakpoint "));
6896 printf_unfiltered (_("Deleted breakpoints "));
6898 breakpoints_changed ();
6902 printf_unfiltered ("%d ", found
->number
);
6904 delete_breakpoint (found
);
6908 putchar_unfiltered ('\n');
6911 /* Delete breakpoint in BS if they are `delete' breakpoints and
6912 all breakpoints that are marked for deletion, whether hit or not.
6913 This is called after any breakpoint is hit, or after errors. */
6916 breakpoint_auto_delete (bpstat bs
)
6918 struct breakpoint
*b
, *temp
;
6920 for (; bs
; bs
= bs
->next
)
6921 if (bs
->breakpoint_at
&& bs
->breakpoint_at
->disposition
== disp_del
6923 delete_breakpoint (bs
->breakpoint_at
);
6925 ALL_BREAKPOINTS_SAFE (b
, temp
)
6927 if (b
->disposition
== disp_del_at_next_stop
)
6928 delete_breakpoint (b
);
6932 /* Delete a breakpoint and clean up all traces of it in the data
6936 delete_breakpoint (struct breakpoint
*bpt
)
6938 struct breakpoint
*b
;
6940 struct bp_location
*loc
;
6942 gdb_assert (bpt
!= NULL
);
6944 /* Has this bp already been deleted? This can happen because multiple
6945 lists can hold pointers to bp's. bpstat lists are especial culprits.
6947 One example of this happening is a watchpoint's scope bp. When the
6948 scope bp triggers, we notice that the watchpoint is out of scope, and
6949 delete it. We also delete its scope bp. But the scope bp is marked
6950 "auto-deleting", and is already on a bpstat. That bpstat is then
6951 checked for auto-deleting bp's, which are deleted.
6953 A real solution to this problem might involve reference counts in bp's,
6954 and/or giving them pointers back to their referencing bpstat's, and
6955 teaching delete_breakpoint to only free a bp's storage when no more
6956 references were extent. A cheaper bandaid was chosen. */
6957 if (bpt
->type
== bp_none
)
6960 if (deprecated_delete_breakpoint_hook
)
6961 deprecated_delete_breakpoint_hook (bpt
);
6962 breakpoint_delete_event (bpt
->number
);
6964 if (bpt
->loc
->inserted
)
6965 remove_breakpoint (bpt
->loc
, mark_inserted
);
6967 free_valchain (bpt
->loc
);
6969 if (breakpoint_chain
== bpt
)
6970 breakpoint_chain
= bpt
->next
;
6972 if (bp_location_chain
== bpt
->loc
)
6973 bp_location_chain
= bpt
->loc
->next
;
6975 /* If we have callback-style exception catchpoints, don't go through
6976 the adjustments to the C++ runtime library etc. if the inferior
6977 isn't actually running. target_enable_exception_callback for a
6978 null target ops vector gives an undesirable error message, so we
6979 check here and avoid it. Since currently (1997-09-17) only HP-UX aCC's
6980 exceptions are supported in this way, it's OK for now. FIXME */
6981 if (ep_is_exception_catchpoint (bpt
) && target_has_execution
)
6983 /* Format possible error msg */
6984 char *message
= xstrprintf ("Error in deleting catchpoint %d:\n",
6986 struct cleanup
*cleanups
= make_cleanup (xfree
, message
);
6987 args_for_catchpoint_enable args
;
6988 args
.kind
= bpt
->type
== bp_catch_catch
?
6989 EX_EVENT_CATCH
: EX_EVENT_THROW
;
6991 catch_errors (cover_target_enable_exception_callback
, &args
,
6992 message
, RETURN_MASK_ALL
);
6993 do_cleanups (cleanups
);
7000 b
->next
= bpt
->next
;
7004 ALL_BP_LOCATIONS (loc
)
7005 if (loc
->next
== bpt
->loc
)
7007 loc
->next
= bpt
->loc
->next
;
7011 check_duplicates (bpt
);
7012 /* If this breakpoint was inserted, and there is another breakpoint
7013 at the same address, we need to insert the other breakpoint. */
7014 if (bpt
->loc
->inserted
7015 && bpt
->type
!= bp_hardware_watchpoint
7016 && bpt
->type
!= bp_read_watchpoint
7017 && bpt
->type
!= bp_access_watchpoint
7018 && bpt
->type
!= bp_catch_fork
7019 && bpt
->type
!= bp_catch_vfork
7020 && bpt
->type
!= bp_catch_exec
)
7023 if (b
->loc
->address
== bpt
->loc
->address
7024 && b
->loc
->section
== bpt
->loc
->section
7025 && !b
->loc
->duplicate
7026 && b
->enable_state
!= bp_disabled
7027 && b
->enable_state
!= bp_shlib_disabled
7029 && b
->enable_state
!= bp_call_disabled
)
7033 /* We should never reach this point if there is a permanent
7034 breakpoint at the same address as the one being deleted.
7035 If there is a permanent breakpoint somewhere, it should
7036 always be the only one inserted. */
7037 if (b
->enable_state
== bp_permanent
)
7038 internal_error (__FILE__
, __LINE__
,
7039 _("another breakpoint was inserted on top of "
7040 "a permanent breakpoint"));
7042 memset (&b
->loc
->target_info
, 0, sizeof (b
->loc
->target_info
));
7043 b
->loc
->target_info
.placed_address
= b
->loc
->address
;
7044 if (b
->type
== bp_hardware_breakpoint
)
7045 val
= target_insert_hw_breakpoint (&b
->loc
->target_info
);
7047 val
= target_insert_breakpoint (&b
->loc
->target_info
);
7049 /* If there was an error in the insert, print a message, then stop execution. */
7052 struct ui_file
*tmp_error_stream
= mem_fileopen ();
7053 make_cleanup_ui_file_delete (tmp_error_stream
);
7056 if (b
->type
== bp_hardware_breakpoint
)
7058 fprintf_unfiltered (tmp_error_stream
,
7059 "Cannot insert hardware breakpoint %d.\n"
7060 "You may have requested too many hardware breakpoints.\n",
7065 fprintf_unfiltered (tmp_error_stream
, "Cannot insert breakpoint %d.\n", b
->number
);
7066 fprintf_filtered (tmp_error_stream
, "Error accessing memory address ");
7067 deprecated_print_address_numeric (b
->loc
->address
, 1, tmp_error_stream
);
7068 fprintf_filtered (tmp_error_stream
, ": %s.\n",
7069 safe_strerror (val
));
7072 fprintf_unfiltered (tmp_error_stream
,"The same program may be running in another process.");
7073 target_terminal_ours_for_output ();
7074 error_stream(tmp_error_stream
);
7077 b
->loc
->inserted
= 1;
7081 free_command_lines (&bpt
->commands
);
7084 if (bpt
->cond_string
!= NULL
)
7085 xfree (bpt
->cond_string
);
7086 if (bpt
->addr_string
!= NULL
)
7087 xfree (bpt
->addr_string
);
7088 if (bpt
->exp
!= NULL
)
7090 if (bpt
->exp_string
!= NULL
)
7091 xfree (bpt
->exp_string
);
7092 if (bpt
->val
!= NULL
)
7093 value_free (bpt
->val
);
7094 if (bpt
->source_file
!= NULL
)
7095 xfree (bpt
->source_file
);
7096 if (bpt
->dll_pathname
!= NULL
)
7097 xfree (bpt
->dll_pathname
);
7098 if (bpt
->triggered_dll_pathname
!= NULL
)
7099 xfree (bpt
->triggered_dll_pathname
);
7100 if (bpt
->exec_pathname
!= NULL
)
7101 xfree (bpt
->exec_pathname
);
7103 /* Be sure no bpstat's are pointing at it after it's been freed. */
7104 /* FIXME, how can we find all bpstat's?
7105 We just check stop_bpstat for now. */
7106 for (bs
= stop_bpstat
; bs
; bs
= bs
->next
)
7107 if (bs
->breakpoint_at
== bpt
)
7109 bs
->breakpoint_at
= NULL
;
7111 /* bs->commands will be freed later. */
7113 /* On the chance that someone will soon try again to delete this same
7114 bp, we mark it as deleted before freeing its storage. */
7115 bpt
->type
= bp_none
;
7122 do_delete_breakpoint_cleanup (void *b
)
7124 delete_breakpoint (b
);
7128 make_cleanup_delete_breakpoint (struct breakpoint
*b
)
7130 return make_cleanup (do_delete_breakpoint_cleanup
, b
);
7134 make_exec_cleanup_delete_breakpoint (struct breakpoint
*b
)
7136 return make_exec_cleanup (do_delete_breakpoint_cleanup
, b
);
7140 delete_command (char *arg
, int from_tty
)
7142 struct breakpoint
*b
, *temp
;
7148 int breaks_to_delete
= 0;
7150 /* Delete all breakpoints if no argument.
7151 Do not delete internal or call-dummy breakpoints, these
7152 have to be deleted with an explicit breakpoint number argument. */
7155 if (b
->type
!= bp_call_dummy
&&
7156 b
->type
!= bp_shlib_event
&&
7157 b
->type
!= bp_thread_event
&&
7158 b
->type
!= bp_overlay_event
&&
7161 breaks_to_delete
= 1;
7166 /* Ask user only if there are some breakpoints to delete. */
7168 || (breaks_to_delete
&& query (_("Delete all breakpoints? "))))
7170 ALL_BREAKPOINTS_SAFE (b
, temp
)
7172 if (b
->type
!= bp_call_dummy
&&
7173 b
->type
!= bp_shlib_event
&&
7174 b
->type
!= bp_thread_event
&&
7175 b
->type
!= bp_overlay_event
&&
7177 delete_breakpoint (b
);
7182 map_breakpoint_numbers (arg
, delete_breakpoint
);
7185 /* Reset a breakpoint given it's struct breakpoint * BINT.
7186 The value we return ends up being the return value from catch_errors.
7187 Unused in this case. */
7190 breakpoint_re_set_one (void *bint
)
7192 /* get past catch_errs */
7193 struct breakpoint
*b
= (struct breakpoint
*) bint
;
7197 int *not_found_ptr
= NULL
;
7198 struct symtabs_and_lines sals
;
7200 enum enable_state save_enable
;
7205 warning (_("attempted to reset apparently deleted breakpoint #%d?"),
7209 case bp_hardware_breakpoint
:
7211 case bp_catch_unload
:
7212 if (b
->addr_string
== NULL
)
7214 /* Anything without a string can't be re-set. */
7215 delete_breakpoint (b
);
7218 /* HACK: cagney/2001-11-11: kettenis/2001-11-11: MarkK wrote:
7220 ``And a hack it is, although Apple's Darwin version of GDB
7221 contains an almost identical hack to implement a "future
7222 break" command. It seems to work in many real world cases,
7223 but it is easy to come up with a test case where the patch
7224 doesn't help at all.''
7226 ``It seems that the way GDB implements breakpoints - in -
7227 shared - libraries was designed for a.out shared library
7228 systems (SunOS 4) where shared libraries were loaded at a
7229 fixed address in memory. Since ELF shared libraries can (and
7230 will) be loaded at any address in memory, things break.
7231 Fixing this is not trivial. Therefore, I'm not sure whether
7232 we should add this hack to the branch only. I cannot
7233 guarantee that things will be fixed on the trunk in the near
7236 In case we have a problem, disable this breakpoint. We'll
7237 restore its status if we succeed. Don't disable a
7238 shlib_disabled breakpoint though. There's a fair chance we
7239 can't re-set it if the shared library it's in hasn't been
7245 save_enable
= b
->enable_state
;
7246 if (b
->enable_state
!= bp_shlib_disabled
)
7247 b
->enable_state
= bp_disabled
;
7249 /* If resetting a shlib-disabled breakpoint, we don't want to
7250 see an error message if it is not found since we will expect
7251 this to occur until the shared library is finally reloaded.
7252 We accomplish this by giving decode_line_1 a pointer to use
7253 for silent notification that the symbol is not found. */
7254 not_found_ptr
= ¬_found
;
7256 set_language (b
->language
);
7257 input_radix
= b
->input_radix
;
7259 sals
= decode_line_1 (&s
, 1, (struct symtab
*) NULL
, 0, (char ***) NULL
,
7261 for (i
= 0; i
< sals
.nelts
; i
++)
7263 resolve_sal_pc (&sals
.sals
[i
]);
7265 /* Reparse conditions, they might contain references to the
7267 if (b
->cond_string
!= NULL
)
7273 /* Avoid re-freeing b->exp if an error during the call
7277 b
->cond
= parse_exp_1 (&s
, block_for_pc (sals
.sals
[i
].pc
), 0);
7280 /* We need to re-set the breakpoint if the address changes... */
7281 if (b
->loc
->address
!= sals
.sals
[i
].pc
7282 /* ...or new and old breakpoints both have source files, and
7283 the source file name or the line number changes... */
7284 || (b
->source_file
!= NULL
7285 && sals
.sals
[i
].symtab
!= NULL
7286 && (strcmp (b
->source_file
, sals
.sals
[i
].symtab
->filename
) != 0
7287 || b
->line_number
!= sals
.sals
[i
].line
)
7289 /* ...or we switch between having a source file and not having
7291 || ((b
->source_file
== NULL
) != (sals
.sals
[i
].symtab
== NULL
))
7294 if (b
->source_file
!= NULL
)
7295 xfree (b
->source_file
);
7296 if (sals
.sals
[i
].symtab
== NULL
)
7297 b
->source_file
= NULL
;
7300 savestring (sals
.sals
[i
].symtab
->filename
,
7301 strlen (sals
.sals
[i
].symtab
->filename
));
7302 b
->line_number
= sals
.sals
[i
].line
;
7303 b
->loc
->requested_address
= sals
.sals
[i
].pc
;
7305 = adjust_breakpoint_address (b
->loc
->requested_address
,
7308 /* Used to check for duplicates here, but that can
7309 cause trouble, as it doesn't check for disabled
7314 /* Might be better to do this just once per breakpoint_re_set,
7315 rather than once for every breakpoint. */
7316 breakpoints_changed ();
7318 b
->loc
->section
= sals
.sals
[i
].section
;
7319 b
->enable_state
= save_enable
; /* Restore it, this worked. */
7322 /* Now that this is re-enabled, check_duplicates
7324 check_duplicates (b
);
7331 case bp_hardware_watchpoint
:
7332 case bp_read_watchpoint
:
7333 case bp_access_watchpoint
:
7334 innermost_block
= NULL
;
7335 /* The issue arises of what context to evaluate this in. The
7336 same one as when it was set, but what does that mean when
7337 symbols have been re-read? We could save the filename and
7338 functionname, but if the context is more local than that, the
7339 best we could do would be something like how many levels deep
7340 and which index at that particular level, but that's going to
7341 be less stable than filenames or function names. */
7343 /* So for now, just use a global context. */
7347 /* Avoid re-freeing b->exp if an error during the call to
7348 parse_expression. */
7351 b
->exp
= parse_expression (b
->exp_string
);
7352 b
->exp_valid_block
= innermost_block
;
7353 mark
= value_mark ();
7356 value_free (b
->val
);
7357 /* Avoid re-freeing b->val if an error during the call to
7358 evaluate_expression. */
7361 b
->val
= evaluate_expression (b
->exp
);
7362 release_value (b
->val
);
7363 if (value_lazy (b
->val
) && breakpoint_enabled (b
))
7364 value_fetch_lazy (b
->val
);
7366 if (b
->cond_string
!= NULL
)
7372 /* Avoid re-freeing b->exp if an error during the call
7376 b
->cond
= parse_exp_1 (&s
, (struct block
*) 0, 0);
7378 if (breakpoint_enabled (b
))
7380 value_free_to_mark (mark
);
7382 case bp_catch_catch
:
7383 case bp_catch_throw
:
7385 /* We needn't really do anything to reset these, since the mask
7386 that requests them is unaffected by e.g., new libraries being
7389 case bp_catch_vfork
:
7394 printf_filtered (_("Deleting unknown breakpoint type %d\n"), b
->type
);
7396 /* Delete longjmp and overlay event breakpoints; they will be
7397 reset later by breakpoint_re_set. */
7399 case bp_longjmp_resume
:
7400 case bp_overlay_event
:
7401 delete_breakpoint (b
);
7404 /* This breakpoint is special, it's set up when the inferior
7405 starts and we really don't want to touch it. */
7406 case bp_shlib_event
:
7408 /* Like bp_shlib_event, this breakpoint type is special.
7409 Once it is set up, we do not want to touch it. */
7410 case bp_thread_event
:
7412 /* Keep temporary breakpoints, which can be encountered when we step
7413 over a dlopen call and SOLIB_ADD is resetting the breakpoints.
7414 Otherwise these should have been blown away via the cleanup chain
7415 or by breakpoint_init_inferior when we rerun the executable. */
7418 case bp_watchpoint_scope
:
7420 case bp_step_resume
:
7427 /* Re-set all breakpoints after symbols have been re-loaded. */
7429 breakpoint_re_set (void)
7431 struct breakpoint
*b
, *temp
;
7432 enum language save_language
;
7433 int save_input_radix
;
7435 save_language
= current_language
->la_language
;
7436 save_input_radix
= input_radix
;
7437 ALL_BREAKPOINTS_SAFE (b
, temp
)
7439 /* Format possible error msg */
7440 char *message
= xstrprintf ("Error in re-setting breakpoint %d:\n",
7442 struct cleanup
*cleanups
= make_cleanup (xfree
, message
);
7443 catch_errors (breakpoint_re_set_one
, b
, message
, RETURN_MASK_ALL
);
7444 do_cleanups (cleanups
);
7446 set_language (save_language
);
7447 input_radix
= save_input_radix
;
7449 if (GET_LONGJMP_TARGET_P ())
7451 create_longjmp_breakpoint ("longjmp");
7452 create_longjmp_breakpoint ("_longjmp");
7453 create_longjmp_breakpoint ("siglongjmp");
7454 create_longjmp_breakpoint ("_siglongjmp");
7455 create_longjmp_breakpoint (NULL
);
7458 create_overlay_event_breakpoint ("_ovly_debug_event");
7461 /* Reset the thread number of this breakpoint:
7463 - If the breakpoint is for all threads, leave it as-is.
7464 - Else, reset it to the current thread for inferior_ptid. */
7466 breakpoint_re_set_thread (struct breakpoint
*b
)
7468 if (b
->thread
!= -1)
7470 if (in_thread_list (inferior_ptid
))
7471 b
->thread
= pid_to_thread_id (inferior_ptid
);
7475 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
7476 If from_tty is nonzero, it prints a message to that effect,
7477 which ends with a period (no newline). */
7480 set_ignore_count (int bptnum
, int count
, int from_tty
)
7482 struct breakpoint
*b
;
7488 if (b
->number
== bptnum
)
7490 b
->ignore_count
= count
;
7494 printf_filtered (_("Will stop next time breakpoint %d is reached."),
7496 else if (count
== 1)
7497 printf_filtered (_("Will ignore next crossing of breakpoint %d."),
7500 printf_filtered (_("Will ignore next %d crossings of breakpoint %d."),
7503 breakpoints_changed ();
7504 breakpoint_modify_event (b
->number
);
7508 error (_("No breakpoint number %d."), bptnum
);
7511 /* Clear the ignore counts of all breakpoints. */
7513 breakpoint_clear_ignore_counts (void)
7515 struct breakpoint
*b
;
7518 b
->ignore_count
= 0;
7521 /* Command to set ignore-count of breakpoint N to COUNT. */
7524 ignore_command (char *args
, int from_tty
)
7530 error_no_arg (_("a breakpoint number"));
7532 num
= get_number (&p
);
7534 error (_("bad breakpoint number: '%s'"), args
);
7536 error (_("Second argument (specified ignore-count) is missing."));
7538 set_ignore_count (num
,
7539 longest_to_int (value_as_long (parse_and_eval (p
))),
7542 printf_filtered ("\n");
7545 /* Call FUNCTION on each of the breakpoints
7546 whose numbers are given in ARGS. */
7549 map_breakpoint_numbers (char *args
, void (*function
) (struct breakpoint
*))
7554 struct breakpoint
*b
, *tmp
;
7558 error_no_arg (_("one or more breakpoint numbers"));
7565 num
= get_number_or_range (&p1
);
7568 warning (_("bad breakpoint number at or near '%s'"), p
);
7572 ALL_BREAKPOINTS_SAFE (b
, tmp
)
7573 if (b
->number
== num
)
7575 struct breakpoint
*related_breakpoint
= b
->related_breakpoint
;
7578 if (related_breakpoint
)
7579 function (related_breakpoint
);
7583 printf_unfiltered (_("No breakpoint number %d.\n"), num
);
7589 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
7590 If from_tty is nonzero, it prints a message to that effect,
7591 which ends with a period (no newline). */
7594 disable_breakpoint (struct breakpoint
*bpt
)
7596 /* Never disable a watchpoint scope breakpoint; we want to
7597 hit them when we leave scope so we can delete both the
7598 watchpoint and its scope breakpoint at that time. */
7599 if (bpt
->type
== bp_watchpoint_scope
)
7602 /* You can't disable permanent breakpoints. */
7603 if (bpt
->enable_state
== bp_permanent
)
7606 bpt
->enable_state
= bp_disabled
;
7608 check_duplicates (bpt
);
7610 if (deprecated_modify_breakpoint_hook
)
7611 deprecated_modify_breakpoint_hook (bpt
);
7612 breakpoint_modify_event (bpt
->number
);
7616 disable_command (char *args
, int from_tty
)
7618 struct breakpoint
*bpt
;
7620 ALL_BREAKPOINTS (bpt
)
7624 warning (_("attempted to disable apparently deleted breakpoint #%d?"),
7629 case bp_catch_unload
:
7631 case bp_catch_vfork
:
7633 case bp_catch_catch
:
7634 case bp_catch_throw
:
7635 case bp_hardware_breakpoint
:
7637 case bp_hardware_watchpoint
:
7638 case bp_read_watchpoint
:
7639 case bp_access_watchpoint
:
7640 disable_breakpoint (bpt
);
7645 map_breakpoint_numbers (args
, disable_breakpoint
);
7649 do_enable_breakpoint (struct breakpoint
*bpt
, enum bpdisp disposition
)
7651 int target_resources_ok
, other_type_used
;
7654 if (bpt
->type
== bp_hardware_breakpoint
)
7657 i
= hw_breakpoint_used_count ();
7658 target_resources_ok
=
7659 TARGET_CAN_USE_HARDWARE_WATCHPOINT (bp_hardware_breakpoint
,
7661 if (target_resources_ok
== 0)
7662 error (_("No hardware breakpoint support in the target."));
7663 else if (target_resources_ok
< 0)
7664 error (_("Hardware breakpoints used exceeds limit."));
7669 if (bpt
->enable_state
!= bp_enabled
)
7671 /* When enabling a pending breakpoint, we need to check if the breakpoint
7672 is resolvable since shared libraries could have been loaded
7673 after the breakpoint was disabled. */
7674 breakpoints_changed ();
7675 if (resolve_pending_breakpoint (bpt
) == GDB_RC_OK
)
7677 delete_breakpoint (bpt
);
7680 bpt
->enable_state
= bp_enabled
;
7681 bpt
->disposition
= disposition
;
7684 else /* Not a pending breakpoint. */
7686 if (bpt
->enable_state
!= bp_permanent
)
7687 bpt
->enable_state
= bp_enabled
;
7688 bpt
->disposition
= disposition
;
7689 check_duplicates (bpt
);
7690 breakpoints_changed ();
7692 if (bpt
->type
== bp_watchpoint
||
7693 bpt
->type
== bp_hardware_watchpoint
||
7694 bpt
->type
== bp_read_watchpoint
||
7695 bpt
->type
== bp_access_watchpoint
)
7697 struct frame_id saved_frame_id
;
7699 saved_frame_id
= get_frame_id (get_selected_frame (NULL
));
7700 if (bpt
->exp_valid_block
!= NULL
)
7702 struct frame_info
*fr
=
7703 fr
= frame_find_by_id (bpt
->watchpoint_frame
);
7706 printf_filtered (_("\
7707 Cannot enable watchpoint %d because the block in which its expression\n\
7708 is valid is not currently in scope.\n"), bpt
->number
);
7709 bpt
->enable_state
= bp_disabled
;
7715 value_free (bpt
->val
);
7716 mark
= value_mark ();
7717 bpt
->val
= evaluate_expression (bpt
->exp
);
7718 release_value (bpt
->val
);
7719 if (value_lazy (bpt
->val
))
7720 value_fetch_lazy (bpt
->val
);
7722 if (bpt
->type
== bp_hardware_watchpoint
||
7723 bpt
->type
== bp_read_watchpoint
||
7724 bpt
->type
== bp_access_watchpoint
)
7726 int i
= hw_watchpoint_used_count (bpt
->type
, &other_type_used
);
7727 int mem_cnt
= can_use_hardware_watchpoint (bpt
->val
);
7729 /* Hack around 'unused var' error for some targets here */
7730 (void) mem_cnt
, (void) i
;
7731 target_resources_ok
= TARGET_CAN_USE_HARDWARE_WATCHPOINT (
7732 bpt
->type
, i
+ mem_cnt
, other_type_used
);
7733 /* we can consider of type is bp_hardware_watchpoint, convert to
7734 bp_watchpoint in the following condition */
7735 if (target_resources_ok
< 0)
7737 printf_filtered (_("\
7738 Cannot enable watchpoint %d because target watch resources\n\
7739 have been allocated for other watchpoints.\n"), bpt
->number
);
7740 bpt
->enable_state
= bp_disabled
;
7741 value_free_to_mark (mark
);
7746 select_frame (frame_find_by_id (saved_frame_id
));
7747 value_free_to_mark (mark
);
7751 if (deprecated_modify_breakpoint_hook
)
7752 deprecated_modify_breakpoint_hook (bpt
);
7753 breakpoint_modify_event (bpt
->number
);
7757 enable_breakpoint (struct breakpoint
*bpt
)
7759 do_enable_breakpoint (bpt
, bpt
->disposition
);
7762 /* The enable command enables the specified breakpoints (or all defined
7763 breakpoints) so they once again become (or continue to be) effective
7764 in stopping the inferior. */
7767 enable_command (char *args
, int from_tty
)
7769 struct breakpoint
*bpt
;
7771 ALL_BREAKPOINTS (bpt
)
7775 warning (_("attempted to enable apparently deleted breakpoint #%d?"),
7780 case bp_catch_unload
:
7782 case bp_catch_vfork
:
7784 case bp_catch_catch
:
7785 case bp_catch_throw
:
7786 case bp_hardware_breakpoint
:
7788 case bp_hardware_watchpoint
:
7789 case bp_read_watchpoint
:
7790 case bp_access_watchpoint
:
7791 enable_breakpoint (bpt
);
7796 map_breakpoint_numbers (args
, enable_breakpoint
);
7800 enable_once_breakpoint (struct breakpoint
*bpt
)
7802 do_enable_breakpoint (bpt
, disp_disable
);
7806 enable_once_command (char *args
, int from_tty
)
7808 map_breakpoint_numbers (args
, enable_once_breakpoint
);
7812 enable_delete_breakpoint (struct breakpoint
*bpt
)
7814 do_enable_breakpoint (bpt
, disp_del
);
7818 enable_delete_command (char *args
, int from_tty
)
7820 map_breakpoint_numbers (args
, enable_delete_breakpoint
);
7824 set_breakpoint_cmd (char *args
, int from_tty
)
7829 show_breakpoint_cmd (char *args
, int from_tty
)
7833 /* Use default_breakpoint_'s, or nothing if they aren't valid. */
7835 struct symtabs_and_lines
7836 decode_line_spec_1 (char *string
, int funfirstline
)
7838 struct symtabs_and_lines sals
;
7840 error (_("Empty line specification."));
7841 if (default_breakpoint_valid
)
7842 sals
= decode_line_1 (&string
, funfirstline
,
7843 default_breakpoint_symtab
,
7844 default_breakpoint_line
,
7845 (char ***) NULL
, NULL
);
7847 sals
= decode_line_1 (&string
, funfirstline
,
7848 (struct symtab
*) NULL
, 0, (char ***) NULL
, NULL
);
7850 error (_("Junk at end of line specification: %s"), string
);
7854 /* Create and insert a raw software breakpoint at PC. Return an
7855 identifier, which should be used to remove the breakpoint later.
7856 In general, places which call this should be using something on the
7857 breakpoint chain instead; this function should be eliminated
7861 deprecated_insert_raw_breakpoint (CORE_ADDR pc
)
7863 struct bp_target_info
*bp_tgt
;
7865 bp_tgt
= xmalloc (sizeof (struct bp_target_info
));
7866 memset (bp_tgt
, 0, sizeof (struct bp_target_info
));
7868 bp_tgt
->placed_address
= pc
;
7869 if (target_insert_breakpoint (bp_tgt
) != 0)
7871 /* Could not insert the breakpoint. */
7879 /* Remove a breakpoint BP inserted by deprecated_insert_raw_breakpoint. */
7882 deprecated_remove_raw_breakpoint (void *bp
)
7884 struct bp_target_info
*bp_tgt
= bp
;
7887 ret
= target_remove_breakpoint (bp_tgt
);
7893 /* One (or perhaps two) breakpoints used for software single stepping. */
7895 static void *single_step_breakpoints
[2];
7897 /* Create and insert a breakpoint for software single step. */
7900 insert_single_step_breakpoint (CORE_ADDR next_pc
)
7904 if (single_step_breakpoints
[0] == NULL
)
7905 bpt_p
= &single_step_breakpoints
[0];
7908 gdb_assert (single_step_breakpoints
[1] == NULL
);
7909 bpt_p
= &single_step_breakpoints
[1];
7912 /* NOTE drow/2006-04-11: A future improvement to this function would be
7913 to only create the breakpoints once, and actually put them on the
7914 breakpoint chain. That would let us use set_raw_breakpoint. We could
7915 adjust the addresses each time they were needed. Doing this requires
7916 corresponding changes elsewhere where single step breakpoints are
7917 handled, however. So, for now, we use this. */
7919 *bpt_p
= deprecated_insert_raw_breakpoint (next_pc
);
7921 error (_("Could not insert single-step breakpoint at 0x%s"),
7922 paddr_nz (next_pc
));
7925 /* Remove and delete any breakpoints used for software single step. */
7928 remove_single_step_breakpoints (void)
7930 gdb_assert (single_step_breakpoints
[0] != NULL
);
7932 /* See insert_single_step_breakpoint for more about this deprecated
7934 deprecated_remove_raw_breakpoint (single_step_breakpoints
[0]);
7935 single_step_breakpoints
[0] = NULL
;
7937 if (single_step_breakpoints
[1] != NULL
)
7939 deprecated_remove_raw_breakpoint (single_step_breakpoints
[1]);
7940 single_step_breakpoints
[1] = NULL
;
7945 /* This help string is used for the break, hbreak, tbreak and thbreak commands.
7946 It is defined as a macro to prevent duplication.
7947 COMMAND should be a string constant containing the name of the command. */
7948 #define BREAK_ARGS_HELP(command) \
7949 command" [LOCATION] [thread THREADNUM] [if CONDITION]\n\
7950 LOCATION may be a line number, function name, or \"*\" and an address.\n\
7951 If a line number is specified, break at start of code for that line.\n\
7952 If a function is specified, break at start of code for that function.\n\
7953 If an address is specified, break at that exact address.\n\
7954 With no LOCATION, uses current execution address of selected stack frame.\n\
7955 This is useful for breaking on return to a stack frame.\n\
7957 THREADNUM is the number from \"info threads\".\n\
7958 CONDITION is a boolean expression.\n\
7960 Multiple breakpoints at one place are permitted, and useful if conditional.\n\
7962 Do \"help breakpoints\" for info on other commands dealing with breakpoints."
7965 _initialize_breakpoint (void)
7967 static struct cmd_list_element
*breakpoint_set_cmdlist
;
7968 static struct cmd_list_element
*breakpoint_show_cmdlist
;
7969 struct cmd_list_element
*c
;
7971 observer_attach_solib_unloaded (disable_breakpoints_in_unloaded_shlib
);
7973 breakpoint_chain
= 0;
7974 /* Don't bother to call set_breakpoint_count. $bpnum isn't useful
7975 before a breakpoint is set. */
7976 breakpoint_count
= 0;
7978 add_com ("ignore", class_breakpoint
, ignore_command
, _("\
7979 Set ignore-count of breakpoint number N to COUNT.\n\
7980 Usage is `ignore N COUNT'."));
7982 add_com_alias ("bc", "ignore", class_breakpoint
, 1);
7984 add_com ("commands", class_breakpoint
, commands_command
, _("\
7985 Set commands to be executed when a breakpoint is hit.\n\
7986 Give breakpoint number as argument after \"commands\".\n\
7987 With no argument, the targeted breakpoint is the last one set.\n\
7988 The commands themselves follow starting on the next line.\n\
7989 Type a line containing \"end\" to indicate the end of them.\n\
7990 Give \"silent\" as the first line to make the breakpoint silent;\n\
7991 then no output is printed when it is hit, except what the commands print."));
7993 add_com ("condition", class_breakpoint
, condition_command
, _("\
7994 Specify breakpoint number N to break only if COND is true.\n\
7995 Usage is `condition N COND', where N is an integer and COND is an\n\
7996 expression to be evaluated whenever breakpoint N is reached."));
7998 c
= add_com ("tbreak", class_breakpoint
, tbreak_command
, _("\
7999 Set a temporary breakpoint.\n\
8000 Like \"break\" except the breakpoint is only temporary,\n\
8001 so it will be deleted when hit. Equivalent to \"break\" followed\n\
8002 by using \"enable delete\" on the breakpoint number.\n\
8004 BREAK_ARGS_HELP ("tbreak")));
8005 set_cmd_completer (c
, location_completer
);
8007 c
= add_com ("hbreak", class_breakpoint
, hbreak_command
, _("\
8008 Set a hardware assisted breakpoint.\n\
8009 Like \"break\" except the breakpoint requires hardware support,\n\
8010 some target hardware may not have this support.\n\
8012 BREAK_ARGS_HELP ("hbreak")));
8013 set_cmd_completer (c
, location_completer
);
8015 c
= add_com ("thbreak", class_breakpoint
, thbreak_command
, _("\
8016 Set a temporary hardware assisted breakpoint.\n\
8017 Like \"hbreak\" except the breakpoint is only temporary,\n\
8018 so it will be deleted when hit.\n\
8020 BREAK_ARGS_HELP ("thbreak")));
8021 set_cmd_completer (c
, location_completer
);
8023 add_prefix_cmd ("enable", class_breakpoint
, enable_command
, _("\
8024 Enable some breakpoints.\n\
8025 Give breakpoint numbers (separated by spaces) as arguments.\n\
8026 With no subcommand, breakpoints are enabled until you command otherwise.\n\
8027 This is used to cancel the effect of the \"disable\" command.\n\
8028 With a subcommand you can enable temporarily."),
8029 &enablelist
, "enable ", 1, &cmdlist
);
8031 add_com ("ab", class_breakpoint
, enable_command
, _("\
8032 Enable some breakpoints.\n\
8033 Give breakpoint numbers (separated by spaces) as arguments.\n\
8034 With no subcommand, breakpoints are enabled until you command otherwise.\n\
8035 This is used to cancel the effect of the \"disable\" command.\n\
8036 With a subcommand you can enable temporarily."));
8038 add_com_alias ("en", "enable", class_breakpoint
, 1);
8040 add_abbrev_prefix_cmd ("breakpoints", class_breakpoint
, enable_command
, _("\
8041 Enable some breakpoints.\n\
8042 Give breakpoint numbers (separated by spaces) as arguments.\n\
8043 This is used to cancel the effect of the \"disable\" command.\n\
8044 May be abbreviated to simply \"enable\".\n"),
8045 &enablebreaklist
, "enable breakpoints ", 1, &enablelist
);
8047 add_cmd ("once", no_class
, enable_once_command
, _("\
8048 Enable breakpoints for one hit. Give breakpoint numbers.\n\
8049 If a breakpoint is hit while enabled in this fashion, it becomes disabled."),
8052 add_cmd ("delete", no_class
, enable_delete_command
, _("\
8053 Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
8054 If a breakpoint is hit while enabled in this fashion, it is deleted."),
8057 add_cmd ("delete", no_class
, enable_delete_command
, _("\
8058 Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
8059 If a breakpoint is hit while enabled in this fashion, it is deleted."),
8062 add_cmd ("once", no_class
, enable_once_command
, _("\
8063 Enable breakpoints for one hit. Give breakpoint numbers.\n\
8064 If a breakpoint is hit while enabled in this fashion, it becomes disabled."),
8067 add_prefix_cmd ("disable", class_breakpoint
, disable_command
, _("\
8068 Disable some breakpoints.\n\
8069 Arguments are breakpoint numbers with spaces in between.\n\
8070 To disable all breakpoints, give no argument.\n\
8071 A disabled breakpoint is not forgotten, but has no effect until reenabled."),
8072 &disablelist
, "disable ", 1, &cmdlist
);
8073 add_com_alias ("dis", "disable", class_breakpoint
, 1);
8074 add_com_alias ("disa", "disable", class_breakpoint
, 1);
8076 add_com ("sb", class_breakpoint
, disable_command
, _("\
8077 Disable some breakpoints.\n\
8078 Arguments are breakpoint numbers with spaces in between.\n\
8079 To disable all breakpoints, give no argument.\n\
8080 A disabled breakpoint is not forgotten, but has no effect until reenabled."));
8082 add_cmd ("breakpoints", class_alias
, disable_command
, _("\
8083 Disable some breakpoints.\n\
8084 Arguments are breakpoint numbers with spaces in between.\n\
8085 To disable all breakpoints, give no argument.\n\
8086 A disabled breakpoint is not forgotten, but has no effect until reenabled.\n\
8087 This command may be abbreviated \"disable\"."),
8090 add_prefix_cmd ("delete", class_breakpoint
, delete_command
, _("\
8091 Delete some breakpoints or auto-display expressions.\n\
8092 Arguments are breakpoint numbers with spaces in between.\n\
8093 To delete all breakpoints, give no argument.\n\
8095 Also a prefix command for deletion of other GDB objects.\n\
8096 The \"unset\" command is also an alias for \"delete\"."),
8097 &deletelist
, "delete ", 1, &cmdlist
);
8098 add_com_alias ("d", "delete", class_breakpoint
, 1);
8099 add_com_alias ("del", "delete", class_breakpoint
, 1);
8101 add_com ("db", class_breakpoint
, delete_command
, _("\
8102 Delete some breakpoints.\n\
8103 Arguments are breakpoint numbers with spaces in between.\n\
8104 To delete all breakpoints, give no argument.\n"));
8106 add_cmd ("breakpoints", class_alias
, delete_command
, _("\
8107 Delete some breakpoints or auto-display expressions.\n\
8108 Arguments are breakpoint numbers with spaces in between.\n\
8109 To delete all breakpoints, give no argument.\n\
8110 This command may be abbreviated \"delete\"."),
8113 add_com ("clear", class_breakpoint
, clear_command
, _("\
8114 Clear breakpoint at specified line or function.\n\
8115 Argument may be line number, function name, or \"*\" and an address.\n\
8116 If line number is specified, all breakpoints in that line are cleared.\n\
8117 If function is specified, breakpoints at beginning of function are cleared.\n\
8118 If an address is specified, breakpoints at that address are cleared.\n\
8120 With no argument, clears all breakpoints in the line that the selected frame\n\
8123 See also the \"delete\" command which clears breakpoints by number."));
8125 c
= add_com ("break", class_breakpoint
, break_command
, _("\
8126 Set breakpoint at specified line or function.\n"
8127 BREAK_ARGS_HELP ("break")));
8128 set_cmd_completer (c
, location_completer
);
8130 add_com_alias ("b", "break", class_run
, 1);
8131 add_com_alias ("br", "break", class_run
, 1);
8132 add_com_alias ("bre", "break", class_run
, 1);
8133 add_com_alias ("brea", "break", class_run
, 1);
8137 add_com_alias ("ba", "break", class_breakpoint
, 1);
8138 add_com_alias ("bu", "ubreak", class_breakpoint
, 1);
8143 add_abbrev_prefix_cmd ("stop", class_breakpoint
, stop_command
, _("\
8144 Break in function/address or break at a line in the current file."),
8145 &stoplist
, "stop ", 1, &cmdlist
);
8146 add_cmd ("in", class_breakpoint
, stopin_command
,
8147 _("Break in function or address."), &stoplist
);
8148 add_cmd ("at", class_breakpoint
, stopat_command
,
8149 _("Break at a line in the current file."), &stoplist
);
8150 add_com ("status", class_info
, breakpoints_info
, _("\
8151 Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
8152 The \"Type\" column indicates one of:\n\
8153 \tbreakpoint - normal breakpoint\n\
8154 \twatchpoint - watchpoint\n\
8155 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
8156 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
8157 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
8158 address and file/line number respectively.\n\
8160 Convenience variable \"$_\" and default examine address for \"x\"\n\
8161 are set to the address of the last breakpoint listed.\n\n\
8162 Convenience variable \"$bpnum\" contains the number of the last\n\
8166 add_info ("breakpoints", breakpoints_info
, _("\
8167 Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
8168 The \"Type\" column indicates one of:\n\
8169 \tbreakpoint - normal breakpoint\n\
8170 \twatchpoint - watchpoint\n\
8171 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
8172 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
8173 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
8174 address and file/line number respectively.\n\
8176 Convenience variable \"$_\" and default examine address for \"x\"\n\
8177 are set to the address of the last breakpoint listed.\n\n\
8178 Convenience variable \"$bpnum\" contains the number of the last\n\
8182 add_com ("lb", class_breakpoint
, breakpoints_info
, _("\
8183 Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
8184 The \"Type\" column indicates one of:\n\
8185 \tbreakpoint - normal breakpoint\n\
8186 \twatchpoint - watchpoint\n\
8187 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
8188 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
8189 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
8190 address and file/line number respectively.\n\
8192 Convenience variable \"$_\" and default examine address for \"x\"\n\
8193 are set to the address of the last breakpoint listed.\n\n\
8194 Convenience variable \"$bpnum\" contains the number of the last\n\
8197 add_cmd ("breakpoints", class_maintenance
, maintenance_info_breakpoints
, _("\
8198 Status of all breakpoints, or breakpoint number NUMBER.\n\
8199 The \"Type\" column indicates one of:\n\
8200 \tbreakpoint - normal breakpoint\n\
8201 \twatchpoint - watchpoint\n\
8202 \tlongjmp - internal breakpoint used to step through longjmp()\n\
8203 \tlongjmp resume - internal breakpoint at the target of longjmp()\n\
8204 \tuntil - internal breakpoint used by the \"until\" command\n\
8205 \tfinish - internal breakpoint used by the \"finish\" command\n\
8206 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
8207 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
8208 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
8209 address and file/line number respectively.\n\
8211 Convenience variable \"$_\" and default examine address for \"x\"\n\
8212 are set to the address of the last breakpoint listed.\n\
8214 Convenience variable \"$bpnum\" contains the number of the last\n\
8216 &maintenanceinfolist
);
8218 add_com ("catch", class_breakpoint
, catch_command
, _("\
8219 Set catchpoints to catch events.\n\
8220 Raised signals may be caught:\n\
8221 \tcatch signal - all signals\n\
8222 \tcatch signal <signame> - a particular signal\n\
8223 Raised exceptions may be caught:\n\
8224 \tcatch throw - all exceptions, when thrown\n\
8225 \tcatch throw <exceptname> - a particular exception, when thrown\n\
8226 \tcatch catch - all exceptions, when caught\n\
8227 \tcatch catch <exceptname> - a particular exception, when caught\n\
8228 Thread or process events may be caught:\n\
8229 \tcatch thread_start - any threads, just after creation\n\
8230 \tcatch thread_exit - any threads, just before expiration\n\
8231 \tcatch thread_join - any threads, just after joins\n\
8232 Process events may be caught:\n\
8233 \tcatch start - any processes, just after creation\n\
8234 \tcatch exit - any processes, just before expiration\n\
8235 \tcatch fork - calls to fork()\n\
8236 \tcatch vfork - calls to vfork()\n\
8237 \tcatch exec - calls to exec()\n\
8238 Dynamically-linked library events may be caught:\n\
8239 \tcatch load - loads of any library\n\
8240 \tcatch load <libname> - loads of a particular library\n\
8241 \tcatch unload - unloads of any library\n\
8242 \tcatch unload <libname> - unloads of a particular library\n\
8243 The act of your program's execution stopping may also be caught:\n\
8245 C++ exceptions may be caught:\n\
8246 \tcatch throw - all exceptions, when thrown\n\
8247 \tcatch catch - all exceptions, when caught\n\
8248 Ada exceptions may be caught:\n\
8249 \tcatch exception - all exceptions, when raised\n\
8250 \tcatch exception <name> - a particular exception, when raised\n\
8251 \tcatch exception unhandled - all unhandled exceptions, when raised\n\
8252 \tcatch assert - all failed assertions, when raised\n\
8254 Do \"help set follow-fork-mode\" for info on debugging your program\n\
8255 after a fork or vfork is caught.\n\n\
8256 Do \"help breakpoints\" for info on other commands dealing with breakpoints."));
8258 add_com ("tcatch", class_breakpoint
, tcatch_command
, _("\
8259 Set temporary catchpoints to catch events.\n\
8260 Args like \"catch\" command.\n\
8261 Like \"catch\" except the catchpoint is only temporary,\n\
8262 so it will be deleted when hit. Equivalent to \"catch\" followed\n\
8263 by using \"enable delete\" on the catchpoint number."));
8265 c
= add_com ("watch", class_breakpoint
, watch_command
, _("\
8266 Set a watchpoint for an expression.\n\
8267 A watchpoint stops execution of your program whenever the value of\n\
8268 an expression changes."));
8269 set_cmd_completer (c
, location_completer
);
8271 c
= add_com ("rwatch", class_breakpoint
, rwatch_command
, _("\
8272 Set a read watchpoint for an expression.\n\
8273 A watchpoint stops execution of your program whenever the value of\n\
8274 an expression is read."));
8275 set_cmd_completer (c
, location_completer
);
8277 c
= add_com ("awatch", class_breakpoint
, awatch_command
, _("\
8278 Set a watchpoint for an expression.\n\
8279 A watchpoint stops execution of your program whenever the value of\n\
8280 an expression is either read or written."));
8281 set_cmd_completer (c
, location_completer
);
8283 add_info ("watchpoints", breakpoints_info
,
8284 _("Synonym for ``info breakpoints''."));
8287 /* XXX: cagney/2005-02-23: This should be a boolean, and should
8288 respond to changes - contrary to the description. */
8289 add_setshow_zinteger_cmd ("can-use-hw-watchpoints", class_support
,
8290 &can_use_hw_watchpoints
, _("\
8291 Set debugger's willingness to use watchpoint hardware."), _("\
8292 Show debugger's willingness to use watchpoint hardware."), _("\
8293 If zero, gdb will not use hardware for new watchpoints, even if\n\
8294 such is available. (However, any hardware watchpoints that were\n\
8295 created before setting this to nonzero, will continue to use watchpoint\n\
8298 show_can_use_hw_watchpoints
,
8299 &setlist
, &showlist
);
8301 can_use_hw_watchpoints
= 1;
8303 add_prefix_cmd ("breakpoint", class_maintenance
, set_breakpoint_cmd
, _("\
8304 Breakpoint specific settings\n\
8305 Configure various breakpoint-specific variables such as\n\
8306 pending breakpoint behavior"),
8307 &breakpoint_set_cmdlist
, "set breakpoint ",
8308 0/*allow-unknown*/, &setlist
);
8309 add_prefix_cmd ("breakpoint", class_maintenance
, show_breakpoint_cmd
, _("\
8310 Breakpoint specific settings\n\
8311 Configure various breakpoint-specific variables such as\n\
8312 pending breakpoint behavior"),
8313 &breakpoint_show_cmdlist
, "show breakpoint ",
8314 0/*allow-unknown*/, &showlist
);
8316 add_setshow_auto_boolean_cmd ("pending", no_class
,
8317 &pending_break_support
, _("\
8318 Set debugger's behavior regarding pending breakpoints."), _("\
8319 Show debugger's behavior regarding pending breakpoints."), _("\
8320 If on, an unrecognized breakpoint location will cause gdb to create a\n\
8321 pending breakpoint. If off, an unrecognized breakpoint location results in\n\
8322 an error. If auto, an unrecognized breakpoint location results in a\n\
8323 user-query to see if a pending breakpoint should be created."),
8325 show_pending_break_support
,
8326 &breakpoint_set_cmdlist
,
8327 &breakpoint_show_cmdlist
);
8329 pending_break_support
= AUTO_BOOLEAN_AUTO
;
8331 add_setshow_boolean_cmd ("auto-hw", no_class
,
8332 &automatic_hardware_breakpoints
, _("\
8333 Set automatic usage of hardware breakpoints."), _("\
8334 Show automatic usage of hardware breakpoints."), _("\
8335 If set, the debugger will automatically use hardware breakpoints for\n\
8336 breakpoints set with \"break\" but falling in read-only memory. If not set,\n\
8337 a warning will be emitted for such breakpoints."),
8339 show_automatic_hardware_breakpoints
,
8340 &breakpoint_set_cmdlist
,
8341 &breakpoint_show_cmdlist
);
8343 automatic_hardware_breakpoints
= 1;