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 3 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, see <http://www.gnu.org/licenses/>. */
26 #include "breakpoint.h"
28 #include "expression.h"
34 #include "gdbthread.h"
37 #include "gdb_string.h"
44 #include "completer.h"
47 #include "cli/cli-script.h"
48 #include "gdb_assert.h"
53 #include "exceptions.h"
58 #include "gdb-events.h"
59 #include "mi/mi-common.h"
61 /* Prototypes for local functions. */
63 static void until_break_command_continuation (struct continuation_arg
*arg
);
65 static void catch_command_1 (char *, int, int);
67 static void enable_delete_command (char *, int);
69 static void enable_delete_breakpoint (struct breakpoint
*);
71 static void enable_once_command (char *, int);
73 static void enable_once_breakpoint (struct breakpoint
*);
75 static void disable_command (char *, int);
77 static void enable_command (char *, int);
79 static void map_breakpoint_numbers (char *, void (*)(struct breakpoint
*));
81 static void ignore_command (char *, int);
83 static int breakpoint_re_set_one (void *);
85 static void clear_command (char *, int);
87 static void catch_command (char *, int);
89 static void watch_command (char *, int);
91 static int can_use_hardware_watchpoint (struct value
*);
93 static int break_command_1 (char *, int, int, struct breakpoint
*);
95 static void mention (struct breakpoint
*);
97 struct breakpoint
*set_raw_breakpoint (struct symtab_and_line
, enum bptype
);
99 static void check_duplicates (struct breakpoint
*);
101 static void breakpoint_adjustment_warning (CORE_ADDR
, CORE_ADDR
, int, int);
103 static CORE_ADDR
adjust_breakpoint_address (CORE_ADDR bpaddr
,
106 static void describe_other_breakpoints (CORE_ADDR
, asection
*, int);
108 static void breakpoints_info (char *, int);
110 static void breakpoint_1 (int, int);
112 static bpstat
bpstat_alloc (struct bp_location
*, bpstat
);
114 static int breakpoint_cond_eval (void *);
116 static void cleanup_executing_breakpoints (void *);
118 static void commands_command (char *, int);
120 static void condition_command (char *, int);
122 static int get_number_trailer (char **, int);
124 void set_breakpoint_count (int);
133 static int remove_breakpoint (struct bp_location
*, insertion_state_t
);
135 static enum print_stop_action
print_it_typical (bpstat
);
137 static enum print_stop_action
print_bp_stop_message (bpstat bs
);
141 enum exception_event_kind kind
;
144 args_for_catchpoint_enable
;
146 static int watchpoint_check (void *);
148 static int cover_target_enable_exception_callback (void *);
150 static void maintenance_info_breakpoints (char *, int);
152 static void create_longjmp_breakpoint (char *);
154 static void create_overlay_event_breakpoint (char *);
156 static int hw_breakpoint_used_count (void);
158 static int hw_watchpoint_used_count (enum bptype
, int *);
160 static void hbreak_command (char *, int);
162 static void thbreak_command (char *, int);
164 static void watch_command_1 (char *, int, int);
166 static void rwatch_command (char *, int);
168 static void awatch_command (char *, int);
170 static void do_enable_breakpoint (struct breakpoint
*, enum bpdisp
);
172 static void solib_load_unload_1 (char *hookname
,
175 char *cond_string
, enum bptype bp_kind
);
177 static void create_fork_vfork_event_catchpoint (int tempflag
,
179 enum bptype bp_kind
);
181 static void stop_command (char *arg
, int from_tty
);
183 static void stopin_command (char *arg
, int from_tty
);
185 static void stopat_command (char *arg
, int from_tty
);
187 static char *ep_find_event_name_end (char *arg
);
189 static char *ep_parse_optional_if_clause (char **arg
);
191 static char *ep_parse_optional_filename (char **arg
);
193 static void create_exception_catchpoint (int tempflag
, char *cond_string
,
194 enum exception_event_kind ex_event
,
195 struct symtab_and_line
*sal
);
197 static void catch_exception_command_1 (enum exception_event_kind ex_event
,
198 char *arg
, int tempflag
, int from_tty
);
200 static void tcatch_command (char *arg
, int from_tty
);
202 static void ep_skip_leading_whitespace (char **s
);
204 static int single_step_breakpoint_inserted_here_p (CORE_ADDR pc
);
206 static void free_bp_location (struct bp_location
*loc
);
208 /* Prototypes for exported functions. */
210 /* If FALSE, gdb will not use hardware support for watchpoints, even
211 if such is available. */
212 static int can_use_hw_watchpoints
;
215 show_can_use_hw_watchpoints (struct ui_file
*file
, int from_tty
,
216 struct cmd_list_element
*c
,
219 fprintf_filtered (file
, _("\
220 Debugger's willingness to use watchpoint hardware is %s.\n"),
224 /* If AUTO_BOOLEAN_FALSE, gdb will not attempt to create pending breakpoints.
225 If AUTO_BOOLEAN_TRUE, gdb will automatically create pending breakpoints
226 for unrecognized breakpoint locations.
227 If AUTO_BOOLEAN_AUTO, gdb will query when breakpoints are unrecognized. */
228 static enum auto_boolean pending_break_support
;
230 show_pending_break_support (struct ui_file
*file
, int from_tty
,
231 struct cmd_list_element
*c
,
234 fprintf_filtered (file
, _("\
235 Debugger's behavior regarding pending breakpoints is %s.\n"),
239 /* If 1, gdb will automatically use hardware breakpoints for breakpoints
240 set with "break" but falling in read-only memory.
241 If 0, gdb will warn about such breakpoints, but won't automatically
242 use hardware breakpoints. */
243 static int automatic_hardware_breakpoints
;
245 show_automatic_hardware_breakpoints (struct ui_file
*file
, int from_tty
,
246 struct cmd_list_element
*c
,
249 fprintf_filtered (file
, _("\
250 Automatic usage of hardware breakpoints is %s.\n"),
255 void _initialize_breakpoint (void);
257 extern int addressprint
; /* Print machine addresses? */
259 /* Are we executing breakpoint commands? */
260 static int executing_breakpoint_commands
;
262 /* Are overlay event breakpoints enabled? */
263 static int overlay_events_enabled
;
265 /* Walk the following statement or block through all breakpoints.
266 ALL_BREAKPOINTS_SAFE does so even if the statment deletes the current
269 #define ALL_BREAKPOINTS(B) for (B = breakpoint_chain; B; B = B->next)
271 #define ALL_BREAKPOINTS_SAFE(B,TMP) \
272 for (B = breakpoint_chain; \
273 B ? (TMP=B->next, 1): 0; \
276 /* Similar iterators for the low-level breakpoints. */
278 #define ALL_BP_LOCATIONS(B) for (B = bp_location_chain; B; B = B->global_next)
280 #define ALL_BP_LOCATIONS_SAFE(B,TMP) \
281 for (B = bp_location_chain; \
282 B ? (TMP=B->global_next, 1): 0; \
285 /* True if breakpoint hit counts should be displayed in breakpoint info. */
287 int show_breakpoint_hit_counts
= 1;
289 /* Chains of all breakpoints defined. */
291 struct breakpoint
*breakpoint_chain
;
293 struct bp_location
*bp_location_chain
;
295 /* Number of last breakpoint made. */
297 int breakpoint_count
;
299 /* Pointer to current exception event record */
300 static struct exception_event_record
*current_exception_event
;
302 /* This function returns a pointer to the string representation of the
303 pathname of the dynamically-linked library that has just been
306 This function must be used only when SOLIB_HAVE_LOAD_EVENT is TRUE,
307 or undefined results are guaranteed.
309 This string's contents are only valid immediately after the
310 inferior has stopped in the dynamic linker hook, and becomes
311 invalid as soon as the inferior is continued. Clients should make
312 a copy of this string if they wish to continue the inferior and
313 then access the string. */
315 #ifndef SOLIB_LOADED_LIBRARY_PATHNAME
316 #define SOLIB_LOADED_LIBRARY_PATHNAME(pid) ""
319 /* This function returns a pointer to the string representation of the
320 pathname of the dynamically-linked library that has just been
323 This function must be used only when SOLIB_HAVE_UNLOAD_EVENT is
324 TRUE, or undefined results are guaranteed.
326 This string's contents are only valid immediately after the
327 inferior has stopped in the dynamic linker hook, and becomes
328 invalid as soon as the inferior is continued. Clients should make
329 a copy of this string if they wish to continue the inferior and
330 then access the string. */
332 #ifndef SOLIB_UNLOADED_LIBRARY_PATHNAME
333 #define SOLIB_UNLOADED_LIBRARY_PATHNAME(pid) ""
336 /* This function is called by the "catch load" command. It allows the
337 debugger to be notified by the dynamic linker when a specified
338 library file (or any library file, if filename is NULL) is loaded. */
340 #ifndef SOLIB_CREATE_CATCH_LOAD_HOOK
341 #define SOLIB_CREATE_CATCH_LOAD_HOOK(pid,tempflag,filename,cond_string) \
342 error (_("catch of library loads not yet implemented on this platform"))
345 /* This function is called by the "catch unload" command. It allows
346 the debugger to be notified by the dynamic linker when a specified
347 library file (or any library file, if filename is NULL) is
350 #ifndef SOLIB_CREATE_CATCH_UNLOAD_HOOK
351 #define SOLIB_CREATE_CATCH_UNLOAD_HOOK(pid, tempflag, filename, cond_string) \
352 error (_("catch of library unloads not yet implemented on this platform"))
355 /* Return whether a breakpoint is an active enabled breakpoint. */
357 breakpoint_enabled (struct breakpoint
*b
)
359 return (b
->enable_state
== bp_enabled
);
362 /* Set breakpoint count to NUM. */
365 set_breakpoint_count (int num
)
367 breakpoint_count
= num
;
368 set_internalvar (lookup_internalvar ("bpnum"),
369 value_from_longest (builtin_type_int
, (LONGEST
) num
));
372 /* Used in run_command to zero the hit count when a new run starts. */
375 clear_breakpoint_hit_counts (void)
377 struct breakpoint
*b
;
383 /* Default address, symtab and line to put a breakpoint at
384 for "break" command with no arg.
385 if default_breakpoint_valid is zero, the other three are
386 not valid, and "break" with no arg is an error.
388 This set by print_stack_frame, which calls set_default_breakpoint. */
390 int default_breakpoint_valid
;
391 CORE_ADDR default_breakpoint_address
;
392 struct symtab
*default_breakpoint_symtab
;
393 int default_breakpoint_line
;
395 /* *PP is a string denoting a breakpoint. Get the number of the breakpoint.
396 Advance *PP after the string and any trailing whitespace.
398 Currently the string can either be a number or "$" followed by the name
399 of a convenience variable. Making it an expression wouldn't work well
400 for map_breakpoint_numbers (e.g. "4 + 5 + 6").
402 If the string is a NULL pointer, that denotes the last breakpoint.
404 TRAILER is a character which can be found after the number; most
405 commonly this is `-'. If you don't want a trailer, use \0. */
407 get_number_trailer (char **pp
, int trailer
)
409 int retval
= 0; /* default */
413 /* Empty line means refer to the last breakpoint. */
414 return breakpoint_count
;
417 /* Make a copy of the name, so we can null-terminate it
418 to pass to lookup_internalvar(). */
423 while (isalnum (*p
) || *p
== '_')
425 varname
= (char *) alloca (p
- start
+ 1);
426 strncpy (varname
, start
, p
- start
);
427 varname
[p
- start
] = '\0';
428 val
= value_of_internalvar (lookup_internalvar (varname
));
429 if (TYPE_CODE (value_type (val
)) == TYPE_CODE_INT
)
430 retval
= (int) value_as_long (val
);
433 printf_filtered (_("Convenience variable must have integer value.\n"));
441 while (*p
>= '0' && *p
<= '9')
444 /* There is no number here. (e.g. "cond a == b"). */
446 /* Skip non-numeric token */
447 while (*p
&& !isspace((int) *p
))
449 /* Return zero, which caller must interpret as error. */
455 if (!(isspace (*p
) || *p
== '\0' || *p
== trailer
))
457 /* Trailing junk: return 0 and let caller print error msg. */
458 while (!(isspace (*p
) || *p
== '\0' || *p
== trailer
))
469 /* Like get_number_trailer, but don't allow a trailer. */
471 get_number (char **pp
)
473 return get_number_trailer (pp
, '\0');
476 /* Parse a number or a range.
477 * A number will be of the form handled by get_number.
478 * A range will be of the form <number1> - <number2>, and
479 * will represent all the integers between number1 and number2,
482 * While processing a range, this fuction is called iteratively;
483 * At each call it will return the next value in the range.
485 * At the beginning of parsing a range, the char pointer PP will
486 * be advanced past <number1> and left pointing at the '-' token.
487 * Subsequent calls will not advance the pointer until the range
488 * is completed. The call that completes the range will advance
489 * pointer PP past <number2>.
493 get_number_or_range (char **pp
)
495 static int last_retval
, end_value
;
496 static char *end_ptr
;
497 static int in_range
= 0;
501 /* Default case: pp is pointing either to a solo number,
502 or to the first number of a range. */
503 last_retval
= get_number_trailer (pp
, '-');
508 /* This is the start of a range (<number1> - <number2>).
509 Skip the '-', parse and remember the second number,
510 and also remember the end of the final token. */
514 while (isspace ((int) *end_ptr
))
515 end_ptr
++; /* skip white space */
516 end_value
= get_number (temp
);
517 if (end_value
< last_retval
)
519 error (_("inverted range"));
521 else if (end_value
== last_retval
)
523 /* degenerate range (number1 == number2). Advance the
524 token pointer so that the range will be treated as a
533 error (_("negative value"));
536 /* pp points to the '-' that betokens a range. All
537 number-parsing has already been done. Return the next
538 integer value (one greater than the saved previous value).
539 Do not advance the token pointer 'pp' until the end of range
542 if (++last_retval
== end_value
)
544 /* End of range reached; advance token pointer. */
554 /* condition N EXP -- set break condition of breakpoint N to EXP. */
557 condition_command (char *arg
, int from_tty
)
559 struct breakpoint
*b
;
564 error_no_arg (_("breakpoint number"));
567 bnum
= get_number (&p
);
569 error (_("Bad breakpoint argument: '%s'"), arg
);
572 if (b
->number
== bnum
)
574 struct bp_location
*loc
= b
->loc
;
575 for (; loc
; loc
= loc
->next
)
583 if (b
->cond_string
!= NULL
)
584 xfree (b
->cond_string
);
588 b
->cond_string
= NULL
;
590 printf_filtered (_("Breakpoint %d now unconditional.\n"), bnum
);
595 /* I don't know if it matters whether this is the string the user
596 typed in or the decompiled expression. */
597 b
->cond_string
= savestring (arg
, strlen (arg
));
598 b
->condition_not_parsed
= 0;
599 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
602 loc
->cond
= parse_exp_1 (&arg
, block_for_pc (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 (gdbarch_breakpoint_from_pc (current_gdbarch
, &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
->enabled
|| bpt
->shlib_disabled
|| 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. */
972 if (solib_address (bpt
->address
))
974 /* See also: disable_breakpoints_in_shlibs. */
976 bpt
->shlib_disabled
= 1;
977 if (!*disabled_breaks
)
979 fprintf_unfiltered (tmp_error_stream
,
980 "Cannot insert breakpoint %d.\n",
982 fprintf_unfiltered (tmp_error_stream
,
983 "Temporarily disabling shared library breakpoints:\n");
985 *disabled_breaks
= 1;
986 fprintf_unfiltered (tmp_error_stream
,
987 "breakpoint #%d\n", bpt
->owner
->number
);
991 #ifdef ONE_PROCESS_WRITETEXT
992 *process_warning
= 1;
994 if (bpt
->loc_type
== bp_loc_hardware_breakpoint
)
996 *hw_breakpoint_error
= 1;
997 fprintf_unfiltered (tmp_error_stream
,
998 "Cannot insert hardware breakpoint %d.\n",
1003 fprintf_unfiltered (tmp_error_stream
,
1004 "Cannot insert breakpoint %d.\n",
1005 bpt
->owner
->number
);
1006 fprintf_filtered (tmp_error_stream
,
1007 "Error accessing memory address ");
1008 deprecated_print_address_numeric (bpt
->address
, 1, tmp_error_stream
);
1009 fprintf_filtered (tmp_error_stream
, ": %s.\n",
1010 safe_strerror (val
));
1021 else if (bpt
->loc_type
== bp_loc_hardware_watchpoint
1022 /* NOTE drow/2003-09-08: This state only exists for removing
1023 watchpoints. It's not clear that it's necessary... */
1024 && bpt
->owner
->disposition
!= disp_del_at_next_stop
)
1026 /* FIXME drow/2003-09-08: This code sets multiple hardware watchpoints
1027 based on the expression. Ideally this should happen at a higher level,
1028 and there should be one bp_location for each computed address we
1029 must watch. As soon as a many-to-one mapping is available I'll
1032 int within_current_scope
;
1033 struct value
*mark
= value_mark ();
1035 struct frame_id saved_frame_id
;
1037 /* Save the current frame's ID so we can restore it after
1038 evaluating the watchpoint expression on its own frame. */
1039 /* FIXME drow/2003-09-09: It would be nice if evaluate_expression
1040 took a frame parameter, so that we didn't have to change the
1042 saved_frame_id
= get_frame_id (get_selected_frame (NULL
));
1044 /* Determine if the watchpoint is within scope. */
1045 if (bpt
->owner
->exp_valid_block
== NULL
)
1046 within_current_scope
= 1;
1049 struct frame_info
*fi
;
1050 fi
= frame_find_by_id (bpt
->owner
->watchpoint_frame
);
1051 within_current_scope
= (fi
!= NULL
);
1052 if (within_current_scope
)
1056 if (within_current_scope
)
1058 free_valchain (bpt
);
1060 /* Evaluate the expression and cut the chain of values
1061 produced off from the value chain.
1063 Make sure the value returned isn't lazy; we use
1064 laziness to determine what memory GDB actually needed
1065 in order to compute the value of the expression. */
1066 v
= evaluate_expression (bpt
->owner
->exp
);
1068 value_release_to_mark (mark
);
1070 bpt
->owner
->val_chain
= v
;
1073 /* Look at each value on the value chain. */
1074 for (; v
; v
= value_next (v
))
1076 /* If it's a memory location, and GDB actually needed
1077 its contents to evaluate the expression, then we
1079 if (VALUE_LVAL (v
) == lval_memory
1080 && ! value_lazy (v
))
1082 struct type
*vtype
= check_typedef (value_type (v
));
1084 /* We only watch structs and arrays if user asked
1085 for it explicitly, never if they just happen to
1086 appear in the middle of some value chain. */
1087 if (v
== bpt
->owner
->val_chain
1088 || (TYPE_CODE (vtype
) != TYPE_CODE_STRUCT
1089 && TYPE_CODE (vtype
) != TYPE_CODE_ARRAY
))
1094 addr
= VALUE_ADDRESS (v
) + value_offset (v
);
1095 len
= TYPE_LENGTH (value_type (v
));
1097 if (bpt
->owner
->type
== bp_read_watchpoint
)
1099 else if (bpt
->owner
->type
== bp_access_watchpoint
)
1102 val
= target_insert_watchpoint (addr
, len
, type
);
1105 /* Don't exit the loop, try to insert
1106 every value on the value chain. That's
1107 because we will be removing all the
1108 watches below, and removing a
1109 watchpoint we didn't insert could have
1117 /* Failure to insert a watchpoint on any memory value in the
1118 value chain brings us here. */
1121 remove_breakpoint (bpt
, mark_uninserted
);
1122 *hw_breakpoint_error
= 1;
1123 fprintf_unfiltered (tmp_error_stream
,
1124 "Could not insert hardware watchpoint %d.\n",
1125 bpt
->owner
->number
);
1131 printf_filtered (_("\
1132 Hardware watchpoint %d deleted because the program has left the block \n\
1133 in which its expression is valid.\n"),
1134 bpt
->owner
->number
);
1135 if (bpt
->owner
->related_breakpoint
)
1136 bpt
->owner
->related_breakpoint
->disposition
= disp_del_at_next_stop
;
1137 bpt
->owner
->disposition
= disp_del_at_next_stop
;
1140 /* Restore the selected frame. */
1141 select_frame (frame_find_by_id (saved_frame_id
));
1146 else if (ep_is_exception_catchpoint (bpt
->owner
))
1148 /* FIXME drow/2003-09-09: This code sets both a catchpoint and a
1149 breakpoint. Once again, it would be better if this was represented
1150 as two bp_locations. */
1152 /* If we get here, we must have a callback mechanism for exception
1153 events -- with g++ style embedded label support, we insert
1154 ordinary breakpoints and not catchpoints. */
1155 val
= target_insert_breakpoint (&bpt
->target_info
);
1158 /* Couldn't set breakpoint for some reason */
1159 fprintf_unfiltered (tmp_error_stream
,
1160 "Cannot insert catchpoint %d; disabling it.\n",
1161 bpt
->owner
->number
);
1162 fprintf_filtered (tmp_error_stream
,
1163 "Error accessing memory address ");
1164 deprecated_print_address_numeric (bpt
->address
, 1, tmp_error_stream
);
1165 fprintf_filtered (tmp_error_stream
, ": %s.\n",
1166 safe_strerror (val
));
1167 bpt
->owner
->enable_state
= bp_disabled
;
1171 /* Bp set, now make sure callbacks are enabled */
1172 /* Format possible error msg */
1173 char *message
= xstrprintf ("Error inserting catchpoint %d:\n",
1174 bpt
->owner
->number
);
1175 struct cleanup
*cleanups
= make_cleanup (xfree
, message
);
1177 args_for_catchpoint_enable args
;
1178 args
.kind
= bpt
->owner
->type
== bp_catch_catch
?
1179 EX_EVENT_CATCH
: EX_EVENT_THROW
;
1181 val
= catch_errors (cover_target_enable_exception_callback
,
1182 &args
, message
, RETURN_MASK_ALL
);
1183 do_cleanups (cleanups
);
1184 if (val
!= 0 && val
!= -1)
1187 /* Check if something went wrong; val == 0 can be ignored */
1190 /* something went wrong */
1191 fprintf_unfiltered (tmp_error_stream
,
1192 "Cannot insert catchpoint %d; disabling it.\n",
1193 bpt
->owner
->number
);
1194 bpt
->owner
->enable_state
= bp_disabled
;
1201 else if (bpt
->owner
->type
== bp_catch_fork
1202 || bpt
->owner
->type
== bp_catch_vfork
1203 || bpt
->owner
->type
== bp_catch_exec
)
1205 struct gdb_exception e
= catch_exception (uiout
, insert_catchpoint
,
1206 bpt
->owner
, RETURN_MASK_ERROR
);
1207 exception_fprintf (gdb_stderr
, e
, "warning: inserting catchpoint %d: ",
1208 bpt
->owner
->number
);
1210 bpt
->owner
->enable_state
= bp_disabled
;
1214 /* We've already printed an error message if there was a problem
1215 inserting this catchpoint, and we've disabled the catchpoint,
1216 so just return success. */
1223 /* insert_breakpoints is used when starting or continuing the program.
1224 remove_breakpoints is used when the program stops.
1225 Both return zero if successful,
1226 or an `errno' value if could not write the inferior. */
1229 insert_breakpoints (void)
1231 struct bp_location
*b
, *temp
;
1232 int return_val
= 0; /* return success code. */
1234 int disabled_breaks
= 0;
1235 int hw_breakpoint_error
= 0;
1236 int process_warning
= 0;
1238 struct ui_file
*tmp_error_stream
= mem_fileopen ();
1239 make_cleanup_ui_file_delete (tmp_error_stream
);
1241 /* Explicitly mark the warning -- this will only be printed if
1242 there was an error. */
1243 fprintf_unfiltered (tmp_error_stream
, "Warning:\n");
1245 ALL_BP_LOCATIONS_SAFE (b
, temp
)
1247 /* Permanent breakpoints cannot be inserted or removed. Disabled
1248 breakpoints should not be inserted. */
1249 if (!breakpoint_enabled (b
->owner
))
1252 /* There is no point inserting thread-specific breakpoints if the
1253 thread no longer exists. */
1254 if (b
->owner
->thread
!= -1
1255 && !valid_thread_id (b
->owner
->thread
))
1258 /* FIXME drow/2003-10-07: This code should be pushed elsewhere when
1259 hardware watchpoints are split into multiple loc breakpoints. */
1260 if ((b
->loc_type
== bp_loc_hardware_watchpoint
1261 || b
->owner
->type
== bp_watchpoint
) && !b
->owner
->val
)
1264 val
= evaluate_expression (b
->owner
->exp
);
1265 release_value (val
);
1266 if (value_lazy (val
))
1267 value_fetch_lazy (val
);
1268 b
->owner
->val
= val
;
1271 val
= insert_bp_location (b
, tmp_error_stream
,
1272 &disabled_breaks
, &process_warning
,
1273 &hw_breakpoint_error
);
1280 /* If a hardware breakpoint or watchpoint was inserted, add a
1281 message about possibly exhausted resources. */
1282 if (hw_breakpoint_error
)
1284 fprintf_unfiltered (tmp_error_stream
,
1285 "Could not insert hardware breakpoints:\n\
1286 You may have requested too many hardware breakpoints/watchpoints.\n");
1288 #ifdef ONE_PROCESS_WRITETEXT
1289 if (process_warning
)
1290 fprintf_unfiltered (tmp_error_stream
,
1291 "The same program may be running in another process.");
1293 target_terminal_ours_for_output ();
1294 error_stream (tmp_error_stream
);
1300 remove_breakpoints (void)
1302 struct bp_location
*b
;
1305 ALL_BP_LOCATIONS (b
)
1309 val
= remove_breakpoint (b
, mark_uninserted
);
1318 remove_hw_watchpoints (void)
1320 struct bp_location
*b
;
1323 ALL_BP_LOCATIONS (b
)
1325 if (b
->inserted
&& b
->loc_type
== bp_loc_hardware_watchpoint
)
1327 val
= remove_breakpoint (b
, mark_uninserted
);
1336 reattach_breakpoints (int pid
)
1338 struct bp_location
*b
;
1340 struct cleanup
*old_chain
= save_inferior_ptid ();
1341 struct ui_file
*tmp_error_stream
= mem_fileopen ();
1342 int dummy1
= 0, dummy2
= 0, dummy3
= 0;
1344 make_cleanup_ui_file_delete (tmp_error_stream
);
1346 inferior_ptid
= pid_to_ptid (pid
);
1347 ALL_BP_LOCATIONS (b
)
1352 val
= insert_bp_location (b
, tmp_error_stream
,
1353 &dummy1
, &dummy2
, &dummy3
);
1356 do_cleanups (old_chain
);
1361 do_cleanups (old_chain
);
1366 update_breakpoints_after_exec (void)
1368 struct breakpoint
*b
;
1369 struct breakpoint
*temp
;
1371 /* Doing this first prevents the badness of having delete_breakpoint()
1372 write a breakpoint's current "shadow contents" to lift the bp. That
1373 shadow is NOT valid after an exec()! */
1374 mark_breakpoints_out ();
1376 ALL_BREAKPOINTS_SAFE (b
, temp
)
1378 /* Solib breakpoints must be explicitly reset after an exec(). */
1379 if (b
->type
== bp_shlib_event
)
1381 delete_breakpoint (b
);
1385 /* Thread event breakpoints must be set anew after an exec(),
1386 as must overlay event breakpoints. */
1387 if (b
->type
== bp_thread_event
|| b
->type
== bp_overlay_event
)
1389 delete_breakpoint (b
);
1393 /* Step-resume breakpoints are meaningless after an exec(). */
1394 if (b
->type
== bp_step_resume
)
1396 delete_breakpoint (b
);
1400 /* Ditto the exception-handling catchpoints. */
1401 if ((b
->type
== bp_catch_catch
) || (b
->type
== bp_catch_throw
))
1403 delete_breakpoint (b
);
1407 /* Don't delete an exec catchpoint, because else the inferior
1408 won't stop when it ought!
1410 Similarly, we probably ought to keep vfork catchpoints, 'cause
1411 on this target, we may not be able to stop when the vfork is
1412 seen, but only when the subsequent exec is seen. (And because
1413 deleting fork catchpoints here but not vfork catchpoints will
1414 seem mysterious to users, keep those too.) */
1415 if ((b
->type
== bp_catch_exec
) ||
1416 (b
->type
== bp_catch_vfork
) ||
1417 (b
->type
== bp_catch_fork
))
1422 /* bp_finish is a special case. The only way we ought to be able
1423 to see one of these when an exec() has happened, is if the user
1424 caught a vfork, and then said "finish". Ordinarily a finish just
1425 carries them to the call-site of the current callee, by setting
1426 a temporary bp there and resuming. But in this case, the finish
1427 will carry them entirely through the vfork & exec.
1429 We don't want to allow a bp_finish to remain inserted now. But
1430 we can't safely delete it, 'cause finish_command has a handle to
1431 the bp on a bpstat, and will later want to delete it. There's a
1432 chance (and I've seen it happen) that if we delete the bp_finish
1433 here, that its storage will get reused by the time finish_command
1434 gets 'round to deleting the "use to be a bp_finish" breakpoint.
1435 We really must allow finish_command to delete a bp_finish.
1437 In the absense of a general solution for the "how do we know
1438 it's safe to delete something others may have handles to?"
1439 problem, what we'll do here is just uninsert the bp_finish, and
1440 let finish_command delete it.
1442 (We know the bp_finish is "doomed" in the sense that it's
1443 momentary, and will be deleted as soon as finish_command sees
1444 the inferior stopped. So it doesn't matter that the bp's
1445 address is probably bogus in the new a.out, unlike e.g., the
1446 solib breakpoints.) */
1448 if (b
->type
== bp_finish
)
1453 /* Without a symbolic address, we have little hope of the
1454 pre-exec() address meaning the same thing in the post-exec()
1456 if (b
->addr_string
== NULL
)
1458 delete_breakpoint (b
);
1462 /* FIXME what about longjmp breakpoints? Re-create them here? */
1463 create_overlay_event_breakpoint ("_ovly_debug_event");
1467 detach_breakpoints (int pid
)
1469 struct bp_location
*b
;
1471 struct cleanup
*old_chain
= save_inferior_ptid ();
1473 if (pid
== PIDGET (inferior_ptid
))
1474 error (_("Cannot detach breakpoints of inferior_ptid"));
1476 /* Set inferior_ptid; remove_breakpoint uses this global. */
1477 inferior_ptid
= pid_to_ptid (pid
);
1478 ALL_BP_LOCATIONS (b
)
1482 val
= remove_breakpoint (b
, mark_inserted
);
1485 do_cleanups (old_chain
);
1490 do_cleanups (old_chain
);
1495 remove_breakpoint (struct bp_location
*b
, insertion_state_t is
)
1499 if (b
->owner
->enable_state
== bp_permanent
)
1500 /* Permanent breakpoints cannot be inserted or removed. */
1503 if (b
->owner
->type
== bp_none
)
1504 warning (_("attempted to remove apparently deleted breakpoint #%d?"),
1507 if (b
->loc_type
== bp_loc_software_breakpoint
1508 || b
->loc_type
== bp_loc_hardware_breakpoint
)
1510 /* "Normal" instruction breakpoint: either the standard
1511 trap-instruction bp (bp_breakpoint), or a
1512 bp_hardware_breakpoint. */
1514 /* First check to see if we have to handle an overlay. */
1515 if (overlay_debugging
== ovly_off
1516 || b
->section
== NULL
1517 || !(section_is_overlay (b
->section
)))
1519 /* No overlay handling: just remove the breakpoint. */
1521 if (b
->loc_type
== bp_loc_hardware_breakpoint
)
1522 val
= target_remove_hw_breakpoint (&b
->target_info
);
1524 val
= target_remove_breakpoint (&b
->target_info
);
1528 /* This breakpoint is in an overlay section.
1529 Did we set a breakpoint at the LMA? */
1530 if (!overlay_events_enabled
)
1532 /* Yes -- overlay event support is not active, so we
1533 should have set a breakpoint at the LMA. Remove it.
1535 /* Ignore any failures: if the LMA is in ROM, we will
1536 have already warned when we failed to insert it. */
1537 if (b
->loc_type
== bp_loc_hardware_breakpoint
)
1538 target_remove_hw_breakpoint (&b
->overlay_target_info
);
1540 target_remove_breakpoint (&b
->overlay_target_info
);
1542 /* Did we set a breakpoint at the VMA?
1543 If so, we will have marked the breakpoint 'inserted'. */
1546 /* Yes -- remove it. Previously we did not bother to
1547 remove the breakpoint if the section had been
1548 unmapped, but let's not rely on that being safe. We
1549 don't know what the overlay manager might do. */
1550 if (b
->loc_type
== bp_loc_hardware_breakpoint
)
1551 val
= target_remove_hw_breakpoint (&b
->target_info
);
1553 /* However, we should remove *software* breakpoints only
1554 if the section is still mapped, or else we overwrite
1555 wrong code with the saved shadow contents. */
1556 else if (section_is_mapped (b
->section
))
1557 val
= target_remove_breakpoint (&b
->target_info
);
1563 /* No -- not inserted, so no need to remove. No error. */
1569 b
->inserted
= (is
== mark_inserted
);
1571 else if (b
->loc_type
== bp_loc_hardware_watchpoint
1572 && breakpoint_enabled (b
->owner
)
1578 b
->inserted
= (is
== mark_inserted
);
1579 /* Walk down the saved value chain. */
1580 for (v
= b
->owner
->val_chain
; v
; v
= value_next (v
))
1582 /* For each memory reference remove the watchpoint
1584 if (VALUE_LVAL (v
) == lval_memory
1585 && ! value_lazy (v
))
1587 struct type
*vtype
= check_typedef (value_type (v
));
1589 if (v
== b
->owner
->val_chain
1590 || (TYPE_CODE (vtype
) != TYPE_CODE_STRUCT
1591 && TYPE_CODE (vtype
) != TYPE_CODE_ARRAY
))
1596 addr
= VALUE_ADDRESS (v
) + value_offset (v
);
1597 len
= TYPE_LENGTH (value_type (v
));
1599 if (b
->owner
->type
== bp_read_watchpoint
)
1601 else if (b
->owner
->type
== bp_access_watchpoint
)
1604 val
= target_remove_watchpoint (addr
, len
, type
);
1611 /* Failure to remove any of the hardware watchpoints comes here. */
1612 if ((is
== mark_uninserted
) && (b
->inserted
))
1613 warning (_("Could not remove hardware watchpoint %d."),
1616 else if ((b
->owner
->type
== bp_catch_fork
||
1617 b
->owner
->type
== bp_catch_vfork
||
1618 b
->owner
->type
== bp_catch_exec
)
1619 && breakpoint_enabled (b
->owner
)
1623 switch (b
->owner
->type
)
1626 val
= target_remove_fork_catchpoint (PIDGET (inferior_ptid
));
1628 case bp_catch_vfork
:
1629 val
= target_remove_vfork_catchpoint (PIDGET (inferior_ptid
));
1632 val
= target_remove_exec_catchpoint (PIDGET (inferior_ptid
));
1635 warning (_("Internal error, %s line %d."), __FILE__
, __LINE__
);
1640 b
->inserted
= (is
== mark_inserted
);
1642 else if ((b
->owner
->type
== bp_catch_catch
||
1643 b
->owner
->type
== bp_catch_throw
)
1644 && breakpoint_enabled (b
->owner
)
1647 val
= target_remove_breakpoint (&b
->target_info
);
1650 b
->inserted
= (is
== mark_inserted
);
1656 /* Clear the "inserted" flag in all breakpoints. */
1659 mark_breakpoints_out (void)
1661 struct bp_location
*bpt
;
1663 ALL_BP_LOCATIONS (bpt
)
1667 /* Clear the "inserted" flag in all breakpoints and delete any
1668 breakpoints which should go away between runs of the program.
1670 Plus other such housekeeping that has to be done for breakpoints
1673 Note: this function gets called at the end of a run (by
1674 generic_mourn_inferior) and when a run begins (by
1675 init_wait_for_inferior). */
1680 breakpoint_init_inferior (enum inf_context context
)
1682 struct breakpoint
*b
, *temp
;
1683 struct bp_location
*bpt
;
1685 ALL_BP_LOCATIONS (bpt
)
1688 ALL_BREAKPOINTS_SAFE (b
, temp
)
1693 case bp_watchpoint_scope
:
1695 /* If the call dummy breakpoint is at the entry point it will
1696 cause problems when the inferior is rerun, so we better
1699 Also get rid of scope breakpoints. */
1700 delete_breakpoint (b
);
1704 case bp_hardware_watchpoint
:
1705 case bp_read_watchpoint
:
1706 case bp_access_watchpoint
:
1708 /* Likewise for watchpoints on local expressions. */
1709 if (b
->exp_valid_block
!= NULL
)
1710 delete_breakpoint (b
);
1711 else if (context
== inf_starting
)
1713 /* Reset val field to force reread of starting value
1714 in insert_breakpoints. */
1716 value_free (b
->val
);
1726 /* breakpoint_here_p (PC) returns non-zero if an enabled breakpoint
1727 exists at PC. It returns ordinary_breakpoint_here if it's an
1728 ordinary breakpoint, or permanent_breakpoint_here if it's a
1729 permanent breakpoint.
1730 - When continuing from a location with an ordinary breakpoint, we
1731 actually single step once before calling insert_breakpoints.
1732 - When continuing from a localion with a permanent breakpoint, we
1733 need to use the `SKIP_PERMANENT_BREAKPOINT' macro, provided by
1734 the target, to advance the PC past the breakpoint. */
1736 enum breakpoint_here
1737 breakpoint_here_p (CORE_ADDR pc
)
1739 struct bp_location
*bpt
;
1740 int any_breakpoint_here
= 0;
1742 ALL_BP_LOCATIONS (bpt
)
1744 if (bpt
->loc_type
!= bp_loc_software_breakpoint
1745 && bpt
->loc_type
!= bp_loc_hardware_breakpoint
)
1748 if ((breakpoint_enabled (bpt
->owner
)
1749 || bpt
->owner
->enable_state
== bp_permanent
)
1750 && bpt
->address
== pc
) /* bp is enabled and matches pc */
1752 if (overlay_debugging
1753 && section_is_overlay (bpt
->section
)
1754 && !section_is_mapped (bpt
->section
))
1755 continue; /* unmapped overlay -- can't be a match */
1756 else if (bpt
->owner
->enable_state
== bp_permanent
)
1757 return permanent_breakpoint_here
;
1759 any_breakpoint_here
= 1;
1763 return any_breakpoint_here
? ordinary_breakpoint_here
: 0;
1767 /* breakpoint_inserted_here_p (PC) is just like breakpoint_here_p(),
1768 but it only returns true if there is actually a breakpoint inserted
1772 breakpoint_inserted_here_p (CORE_ADDR pc
)
1774 struct bp_location
*bpt
;
1776 ALL_BP_LOCATIONS (bpt
)
1778 if (bpt
->loc_type
!= bp_loc_software_breakpoint
1779 && bpt
->loc_type
!= bp_loc_hardware_breakpoint
)
1783 && bpt
->address
== pc
) /* bp is inserted and matches pc */
1785 if (overlay_debugging
1786 && section_is_overlay (bpt
->section
)
1787 && !section_is_mapped (bpt
->section
))
1788 continue; /* unmapped overlay -- can't be a match */
1794 /* Also check for software single-step breakpoints. */
1795 if (single_step_breakpoint_inserted_here_p (pc
))
1801 /* This function returns non-zero iff there is a software breakpoint
1805 software_breakpoint_inserted_here_p (CORE_ADDR pc
)
1807 struct bp_location
*bpt
;
1808 int any_breakpoint_here
= 0;
1810 ALL_BP_LOCATIONS (bpt
)
1812 if (bpt
->loc_type
!= bp_loc_software_breakpoint
)
1816 && bpt
->address
== pc
) /* bp is enabled and matches pc */
1818 if (overlay_debugging
1819 && section_is_overlay (bpt
->section
)
1820 && !section_is_mapped (bpt
->section
))
1821 continue; /* unmapped overlay -- can't be a match */
1827 /* Also check for software single-step breakpoints. */
1828 if (single_step_breakpoint_inserted_here_p (pc
))
1834 /* breakpoint_thread_match (PC, PTID) returns true if the breakpoint at
1835 PC is valid for process/thread PTID. */
1838 breakpoint_thread_match (CORE_ADDR pc
, ptid_t ptid
)
1840 struct bp_location
*bpt
;
1843 thread
= pid_to_thread_id (ptid
);
1845 ALL_BP_LOCATIONS (bpt
)
1847 if (bpt
->loc_type
!= bp_loc_software_breakpoint
1848 && bpt
->loc_type
!= bp_loc_hardware_breakpoint
)
1851 if ((breakpoint_enabled (bpt
->owner
)
1852 || bpt
->owner
->enable_state
== bp_permanent
)
1853 && bpt
->address
== pc
1854 && (bpt
->owner
->thread
== -1 || bpt
->owner
->thread
== thread
))
1856 if (overlay_debugging
1857 && section_is_overlay (bpt
->section
)
1858 && !section_is_mapped (bpt
->section
))
1859 continue; /* unmapped overlay -- can't be a match */
1869 /* bpstat stuff. External routines' interfaces are documented
1873 ep_is_catchpoint (struct breakpoint
*ep
)
1876 (ep
->type
== bp_catch_load
)
1877 || (ep
->type
== bp_catch_unload
)
1878 || (ep
->type
== bp_catch_fork
)
1879 || (ep
->type
== bp_catch_vfork
)
1880 || (ep
->type
== bp_catch_exec
)
1881 || (ep
->type
== bp_catch_catch
)
1882 || (ep
->type
== bp_catch_throw
);
1884 /* ??rehrauer: Add more kinds here, as are implemented... */
1888 ep_is_shlib_catchpoint (struct breakpoint
*ep
)
1891 (ep
->type
== bp_catch_load
)
1892 || (ep
->type
== bp_catch_unload
);
1896 ep_is_exception_catchpoint (struct breakpoint
*ep
)
1899 (ep
->type
== bp_catch_catch
)
1900 || (ep
->type
== bp_catch_throw
);
1904 bpstat_free (bpstat bs
)
1906 if (bs
->old_val
!= NULL
)
1907 value_free (bs
->old_val
);
1908 free_command_lines (&bs
->commands
);
1912 /* Clear a bpstat so that it says we are not at any breakpoint.
1913 Also free any storage that is part of a bpstat. */
1916 bpstat_clear (bpstat
*bsp
)
1933 /* Return a copy of a bpstat. Like "bs1 = bs2" but all storage that
1934 is part of the bpstat is copied as well. */
1937 bpstat_copy (bpstat bs
)
1941 bpstat retval
= NULL
;
1946 for (; bs
!= NULL
; bs
= bs
->next
)
1948 tmp
= (bpstat
) xmalloc (sizeof (*tmp
));
1949 memcpy (tmp
, bs
, sizeof (*tmp
));
1950 if (bs
->commands
!= NULL
)
1951 tmp
->commands
= copy_command_lines (bs
->commands
);
1952 if (bs
->old_val
!= NULL
)
1953 tmp
->old_val
= value_copy (bs
->old_val
);
1956 /* This is the first thing in the chain. */
1966 /* Find the bpstat associated with this breakpoint */
1969 bpstat_find_breakpoint (bpstat bsp
, struct breakpoint
*breakpoint
)
1974 for (; bsp
!= NULL
; bsp
= bsp
->next
)
1976 if (bsp
->breakpoint_at
&& bsp
->breakpoint_at
->owner
== breakpoint
)
1982 /* Find a step_resume breakpoint associated with this bpstat.
1983 (If there are multiple step_resume bp's on the list, this function
1984 will arbitrarily pick one.)
1986 It is an error to use this function if BPSTAT doesn't contain a
1987 step_resume breakpoint.
1989 See wait_for_inferior's use of this function. */
1991 bpstat_find_step_resume_breakpoint (bpstat bsp
)
1995 gdb_assert (bsp
!= NULL
);
1997 current_thread
= pid_to_thread_id (inferior_ptid
);
1999 for (; bsp
!= NULL
; bsp
= bsp
->next
)
2001 if ((bsp
->breakpoint_at
!= NULL
) &&
2002 (bsp
->breakpoint_at
->owner
->type
== bp_step_resume
) &&
2003 (bsp
->breakpoint_at
->owner
->thread
== current_thread
||
2004 bsp
->breakpoint_at
->owner
->thread
== -1))
2005 return bsp
->breakpoint_at
->owner
;
2008 internal_error (__FILE__
, __LINE__
, _("No step_resume breakpoint found."));
2012 /* Put in *NUM the breakpoint number of the first breakpoint we are stopped
2013 at. *BSP upon return is a bpstat which points to the remaining
2014 breakpoints stopped at (but which is not guaranteed to be good for
2015 anything but further calls to bpstat_num).
2016 Return 0 if passed a bpstat which does not indicate any breakpoints.
2017 Return -1 if stopped at a breakpoint that has been deleted since
2019 Return 1 otherwise. */
2022 bpstat_num (bpstat
*bsp
, int *num
)
2024 struct breakpoint
*b
;
2027 return 0; /* No more breakpoint values */
2029 /* We assume we'll never have several bpstats that
2030 correspond to a single breakpoint -- otherwise,
2031 this function might return the same number more
2032 than once and this will look ugly. */
2033 b
= (*bsp
)->breakpoint_at
? (*bsp
)->breakpoint_at
->owner
: NULL
;
2034 *bsp
= (*bsp
)->next
;
2036 return -1; /* breakpoint that's been deleted since */
2038 *num
= b
->number
; /* We have its number */
2042 /* Modify BS so that the actions will not be performed. */
2045 bpstat_clear_actions (bpstat bs
)
2047 for (; bs
!= NULL
; bs
= bs
->next
)
2049 free_command_lines (&bs
->commands
);
2050 if (bs
->old_val
!= NULL
)
2052 value_free (bs
->old_val
);
2058 /* Stub for cleaning up our state if we error-out of a breakpoint command */
2060 cleanup_executing_breakpoints (void *ignore
)
2062 executing_breakpoint_commands
= 0;
2065 /* Execute all the commands associated with all the breakpoints at this
2066 location. Any of these commands could cause the process to proceed
2067 beyond this point, etc. We look out for such changes by checking
2068 the global "breakpoint_proceeded" after each command. */
2071 bpstat_do_actions (bpstat
*bsp
)
2074 struct cleanup
*old_chain
;
2076 /* Avoid endless recursion if a `source' command is contained
2078 if (executing_breakpoint_commands
)
2081 executing_breakpoint_commands
= 1;
2082 old_chain
= make_cleanup (cleanup_executing_breakpoints
, 0);
2085 /* Note that (as of this writing), our callers all appear to
2086 be passing us the address of global stop_bpstat. And, if
2087 our calls to execute_control_command cause the inferior to
2088 proceed, that global (and hence, *bsp) will change.
2090 We must be careful to not touch *bsp unless the inferior
2091 has not proceeded. */
2093 /* This pointer will iterate over the list of bpstat's. */
2096 breakpoint_proceeded
= 0;
2097 for (; bs
!= NULL
; bs
= bs
->next
)
2099 struct command_line
*cmd
;
2100 struct cleanup
*this_cmd_tree_chain
;
2102 /* Take ownership of the BSP's command tree, if it has one.
2104 The command tree could legitimately contain commands like
2105 'step' and 'next', which call clear_proceed_status, which
2106 frees stop_bpstat's command tree. To make sure this doesn't
2107 free the tree we're executing out from under us, we need to
2108 take ownership of the tree ourselves. Since a given bpstat's
2109 commands are only executed once, we don't need to copy it; we
2110 can clear the pointer in the bpstat, and make sure we free
2111 the tree when we're done. */
2114 this_cmd_tree_chain
= make_cleanup_free_command_lines (&cmd
);
2118 execute_control_command (cmd
);
2120 if (breakpoint_proceeded
)
2126 /* We can free this command tree now. */
2127 do_cleanups (this_cmd_tree_chain
);
2129 if (breakpoint_proceeded
)
2130 /* The inferior is proceeded by the command; bomb out now.
2131 The bpstat chain has been blown away by wait_for_inferior.
2132 But since execution has stopped again, there is a new bpstat
2133 to look at, so start over. */
2136 do_cleanups (old_chain
);
2139 /* This is the normal print function for a bpstat. In the future,
2140 much of this logic could (should?) be moved to bpstat_stop_status,
2141 by having it set different print_it values.
2143 Current scheme: When we stop, bpstat_print() is called. It loops
2144 through the bpstat list of things causing this stop, calling the
2145 print_bp_stop_message function on each one. The behavior of the
2146 print_bp_stop_message function depends on the print_it field of
2147 bpstat. If such field so indicates, call this function here.
2149 Return values from this routine (ultimately used by bpstat_print()
2150 and normal_stop() to decide what to do):
2151 PRINT_NOTHING: Means we already printed all we needed to print,
2152 don't print anything else.
2153 PRINT_SRC_ONLY: Means we printed something, and we do *not* desire
2154 that something to be followed by a location.
2155 PRINT_SCR_AND_LOC: Means we printed something, and we *do* desire
2156 that something to be followed by a location.
2157 PRINT_UNKNOWN: Means we printed nothing or we need to do some more
2160 static enum print_stop_action
2161 print_it_typical (bpstat bs
)
2163 struct cleanup
*old_chain
, *ui_out_chain
;
2164 struct breakpoint
*b
;
2165 struct bp_location
*bl
;
2166 struct ui_stream
*stb
;
2167 stb
= ui_out_stream_new (uiout
);
2168 old_chain
= make_cleanup_ui_out_stream_delete (stb
);
2169 /* bs->breakpoint_at can be NULL if it was a momentary breakpoint
2170 which has since been deleted. */
2171 if (bs
->breakpoint_at
== NULL
)
2172 return PRINT_UNKNOWN
;
2173 bl
= bs
->breakpoint_at
;
2179 case bp_hardware_breakpoint
:
2180 if (bl
->address
!= bl
->requested_address
)
2181 breakpoint_adjustment_warning (bl
->requested_address
,
2184 annotate_breakpoint (b
->number
);
2185 ui_out_text (uiout
, "\nBreakpoint ");
2186 if (ui_out_is_mi_like_p (uiout
))
2187 ui_out_field_string (uiout
, "reason",
2188 async_reason_lookup (EXEC_ASYNC_BREAKPOINT_HIT
));
2189 ui_out_field_int (uiout
, "bkptno", b
->number
);
2190 ui_out_text (uiout
, ", ");
2191 return PRINT_SRC_AND_LOC
;
2194 case bp_shlib_event
:
2195 /* Did we stop because the user set the stop_on_solib_events
2196 variable? (If so, we report this as a generic, "Stopped due
2197 to shlib event" message.) */
2198 printf_filtered (_("Stopped due to shared library event\n"));
2199 return PRINT_NOTHING
;
2202 case bp_thread_event
:
2203 /* Not sure how we will get here.
2204 GDB should not stop for these breakpoints. */
2205 printf_filtered (_("Thread Event Breakpoint: gdb should not stop!\n"));
2206 return PRINT_NOTHING
;
2209 case bp_overlay_event
:
2210 /* By analogy with the thread event, GDB should not stop for these. */
2211 printf_filtered (_("Overlay Event Breakpoint: gdb should not stop!\n"));
2212 return PRINT_NOTHING
;
2216 annotate_catchpoint (b
->number
);
2217 printf_filtered (_("\nCatchpoint %d (loaded %s), "),
2219 b
->triggered_dll_pathname
);
2220 return PRINT_SRC_AND_LOC
;
2223 case bp_catch_unload
:
2224 annotate_catchpoint (b
->number
);
2225 printf_filtered (_("\nCatchpoint %d (unloaded %s), "),
2227 b
->triggered_dll_pathname
);
2228 return PRINT_SRC_AND_LOC
;
2232 annotate_catchpoint (b
->number
);
2233 printf_filtered (_("\nCatchpoint %d (forked process %d), "),
2235 b
->forked_inferior_pid
);
2236 return PRINT_SRC_AND_LOC
;
2239 case bp_catch_vfork
:
2240 annotate_catchpoint (b
->number
);
2241 printf_filtered (_("\nCatchpoint %d (vforked process %d), "),
2243 b
->forked_inferior_pid
);
2244 return PRINT_SRC_AND_LOC
;
2248 annotate_catchpoint (b
->number
);
2249 printf_filtered (_("\nCatchpoint %d (exec'd %s), "),
2252 return PRINT_SRC_AND_LOC
;
2255 case bp_catch_catch
:
2256 if (current_exception_event
&&
2257 (CURRENT_EXCEPTION_KIND
== EX_EVENT_CATCH
))
2259 annotate_catchpoint (b
->number
);
2260 printf_filtered (_("\nCatchpoint %d (exception caught), "),
2262 if (CURRENT_EXCEPTION_THROW_PC
&& CURRENT_EXCEPTION_THROW_LINE
)
2263 printf_filtered (_("throw location %s:%d, "),
2264 CURRENT_EXCEPTION_THROW_FILE
,
2265 CURRENT_EXCEPTION_THROW_LINE
);
2267 printf_filtered (_("throw location unknown, "));
2269 if (CURRENT_EXCEPTION_CATCH_PC
&& CURRENT_EXCEPTION_CATCH_LINE
)
2270 printf_filtered (_("catch location %s:%d\n"),
2271 CURRENT_EXCEPTION_CATCH_FILE
,
2272 CURRENT_EXCEPTION_CATCH_LINE
);
2274 printf_filtered (_("catch location unknown\n"));
2276 /* don't bother to print location frame info */
2277 return PRINT_SRC_ONLY
;
2281 /* really throw, some other bpstat will handle it */
2282 return PRINT_UNKNOWN
;
2286 case bp_catch_throw
:
2287 if (current_exception_event
&&
2288 (CURRENT_EXCEPTION_KIND
== EX_EVENT_THROW
))
2290 annotate_catchpoint (b
->number
);
2291 printf_filtered (_("\nCatchpoint %d (exception thrown), "),
2293 if (CURRENT_EXCEPTION_THROW_PC
&& CURRENT_EXCEPTION_THROW_LINE
)
2294 printf_filtered (_("throw location %s:%d, "),
2295 CURRENT_EXCEPTION_THROW_FILE
,
2296 CURRENT_EXCEPTION_THROW_LINE
);
2298 printf_filtered (_("throw location unknown, "));
2300 if (CURRENT_EXCEPTION_CATCH_PC
&& CURRENT_EXCEPTION_CATCH_LINE
)
2301 printf_filtered (_("catch location %s:%d\n"),
2302 CURRENT_EXCEPTION_CATCH_FILE
,
2303 CURRENT_EXCEPTION_CATCH_LINE
);
2305 printf_filtered (_("catch location unknown\n"));
2307 /* don't bother to print location frame info */
2308 return PRINT_SRC_ONLY
;
2312 /* really catch, some other bpstat will handle it */
2313 return PRINT_UNKNOWN
;
2318 case bp_hardware_watchpoint
:
2319 if (bs
->old_val
!= NULL
)
2321 annotate_watchpoint (b
->number
);
2322 if (ui_out_is_mi_like_p (uiout
))
2325 async_reason_lookup (EXEC_ASYNC_WATCHPOINT_TRIGGER
));
2327 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "value");
2328 ui_out_text (uiout
, "\nOld value = ");
2329 value_print (bs
->old_val
, stb
->stream
, 0, Val_pretty_default
);
2330 ui_out_field_stream (uiout
, "old", stb
);
2331 ui_out_text (uiout
, "\nNew value = ");
2332 value_print (b
->val
, stb
->stream
, 0, Val_pretty_default
);
2333 ui_out_field_stream (uiout
, "new", stb
);
2334 do_cleanups (ui_out_chain
);
2335 ui_out_text (uiout
, "\n");
2336 value_free (bs
->old_val
);
2339 /* More than one watchpoint may have been triggered. */
2340 return PRINT_UNKNOWN
;
2343 case bp_read_watchpoint
:
2344 if (ui_out_is_mi_like_p (uiout
))
2347 async_reason_lookup (EXEC_ASYNC_READ_WATCHPOINT_TRIGGER
));
2349 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "value");
2350 ui_out_text (uiout
, "\nValue = ");
2351 value_print (b
->val
, stb
->stream
, 0, Val_pretty_default
);
2352 ui_out_field_stream (uiout
, "value", stb
);
2353 do_cleanups (ui_out_chain
);
2354 ui_out_text (uiout
, "\n");
2355 return PRINT_UNKNOWN
;
2358 case bp_access_watchpoint
:
2359 if (bs
->old_val
!= NULL
)
2361 annotate_watchpoint (b
->number
);
2362 if (ui_out_is_mi_like_p (uiout
))
2365 async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER
));
2367 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "value");
2368 ui_out_text (uiout
, "\nOld value = ");
2369 value_print (bs
->old_val
, stb
->stream
, 0, Val_pretty_default
);
2370 ui_out_field_stream (uiout
, "old", stb
);
2371 value_free (bs
->old_val
);
2373 ui_out_text (uiout
, "\nNew value = ");
2378 if (ui_out_is_mi_like_p (uiout
))
2381 async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER
));
2382 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "value");
2383 ui_out_text (uiout
, "\nValue = ");
2385 value_print (b
->val
, stb
->stream
, 0,Val_pretty_default
);
2386 ui_out_field_stream (uiout
, "new", stb
);
2387 do_cleanups (ui_out_chain
);
2388 ui_out_text (uiout
, "\n");
2389 return PRINT_UNKNOWN
;
2392 /* Fall through, we don't deal with these types of breakpoints
2396 if (ui_out_is_mi_like_p (uiout
))
2399 async_reason_lookup (EXEC_ASYNC_FUNCTION_FINISHED
));
2400 return PRINT_UNKNOWN
;
2404 if (ui_out_is_mi_like_p (uiout
))
2407 async_reason_lookup (EXEC_ASYNC_LOCATION_REACHED
));
2408 return PRINT_UNKNOWN
;
2413 case bp_longjmp_resume
:
2414 case bp_step_resume
:
2415 case bp_watchpoint_scope
:
2418 return PRINT_UNKNOWN
;
2422 /* Generic routine for printing messages indicating why we
2423 stopped. The behavior of this function depends on the value
2424 'print_it' in the bpstat structure. Under some circumstances we
2425 may decide not to print anything here and delegate the task to
2428 static enum print_stop_action
2429 print_bp_stop_message (bpstat bs
)
2431 switch (bs
->print_it
)
2434 /* Nothing should be printed for this bpstat entry. */
2435 return PRINT_UNKNOWN
;
2439 /* We still want to print the frame, but we already printed the
2440 relevant messages. */
2441 return PRINT_SRC_AND_LOC
;
2444 case print_it_normal
:
2446 struct bp_location
*bl
= bs
->breakpoint_at
;
2447 struct breakpoint
*b
= bl
? bl
->owner
: NULL
;
2449 /* Normal case. Call the breakpoint's print_it method, or
2450 print_it_typical. */
2451 /* FIXME: how breakpoint can ever be NULL here? */
2452 if (b
!= NULL
&& b
->ops
!= NULL
&& b
->ops
->print_it
!= NULL
)
2453 return b
->ops
->print_it (b
);
2455 return print_it_typical (bs
);
2460 internal_error (__FILE__
, __LINE__
,
2461 _("print_bp_stop_message: unrecognized enum value"));
2466 /* Print a message indicating what happened. This is called from
2467 normal_stop(). The input to this routine is the head of the bpstat
2468 list - a list of the eventpoints that caused this stop. This
2469 routine calls the generic print routine for printing a message
2470 about reasons for stopping. This will print (for example) the
2471 "Breakpoint n," part of the output. The return value of this
2474 PRINT_UNKNOWN: Means we printed nothing
2475 PRINT_SRC_AND_LOC: Means we printed something, and expect subsequent
2476 code to print the location. An example is
2477 "Breakpoint 1, " which should be followed by
2479 PRINT_SRC_ONLY: Means we printed something, but there is no need
2480 to also print the location part of the message.
2481 An example is the catch/throw messages, which
2482 don't require a location appended to the end.
2483 PRINT_NOTHING: We have done some printing and we don't need any
2484 further info to be printed.*/
2486 enum print_stop_action
2487 bpstat_print (bpstat bs
)
2491 /* Maybe another breakpoint in the chain caused us to stop.
2492 (Currently all watchpoints go on the bpstat whether hit or not.
2493 That probably could (should) be changed, provided care is taken
2494 with respect to bpstat_explains_signal). */
2495 for (; bs
; bs
= bs
->next
)
2497 val
= print_bp_stop_message (bs
);
2498 if (val
== PRINT_SRC_ONLY
2499 || val
== PRINT_SRC_AND_LOC
2500 || val
== PRINT_NOTHING
)
2504 /* We reached the end of the chain, or we got a null BS to start
2505 with and nothing was printed. */
2506 return PRINT_UNKNOWN
;
2509 /* Evaluate the expression EXP and return 1 if value is zero.
2510 This is used inside a catch_errors to evaluate the breakpoint condition.
2511 The argument is a "struct expression *" that has been cast to char * to
2512 make it pass through catch_errors. */
2515 breakpoint_cond_eval (void *exp
)
2517 struct value
*mark
= value_mark ();
2518 int i
= !value_true (evaluate_expression ((struct expression
*) exp
));
2519 value_free_to_mark (mark
);
2523 /* Allocate a new bpstat and chain it to the current one. */
2526 bpstat_alloc (struct bp_location
*bl
, bpstat cbs
/* Current "bs" value */ )
2530 bs
= (bpstat
) xmalloc (sizeof (*bs
));
2532 bs
->breakpoint_at
= bl
;
2533 /* If the condition is false, etc., don't do the commands. */
2534 bs
->commands
= NULL
;
2536 bs
->print_it
= print_it_normal
;
2540 /* The target has stopped with waitstatus WS. Check if any hardware
2541 watchpoints have triggered, according to the target. */
2544 watchpoints_triggered (struct target_waitstatus
*ws
)
2546 int stopped_by_watchpoint
= STOPPED_BY_WATCHPOINT (*ws
);
2548 struct breakpoint
*b
;
2550 if (!stopped_by_watchpoint
)
2552 /* We were not stopped by a watchpoint. Mark all watchpoints
2553 as not triggered. */
2555 if (b
->type
== bp_hardware_watchpoint
2556 || b
->type
== bp_read_watchpoint
2557 || b
->type
== bp_access_watchpoint
)
2558 b
->watchpoint_triggered
= watch_triggered_no
;
2563 if (!target_stopped_data_address (¤t_target
, &addr
))
2565 /* We were stopped by a watchpoint, but we don't know where.
2566 Mark all watchpoints as unknown. */
2568 if (b
->type
== bp_hardware_watchpoint
2569 || b
->type
== bp_read_watchpoint
2570 || b
->type
== bp_access_watchpoint
)
2571 b
->watchpoint_triggered
= watch_triggered_unknown
;
2573 return stopped_by_watchpoint
;
2576 /* The target could report the data address. Mark watchpoints
2577 affected by this data address as triggered, and all others as not
2581 if (b
->type
== bp_hardware_watchpoint
2582 || b
->type
== bp_read_watchpoint
2583 || b
->type
== bp_access_watchpoint
)
2587 b
->watchpoint_triggered
= watch_triggered_no
;
2588 for (v
= b
->val_chain
; v
; v
= value_next (v
))
2590 if (VALUE_LVAL (v
) == lval_memory
&& ! value_lazy (v
))
2592 struct type
*vtype
= check_typedef (value_type (v
));
2594 if (v
== b
->val_chain
2595 || (TYPE_CODE (vtype
) != TYPE_CODE_STRUCT
2596 && TYPE_CODE (vtype
) != TYPE_CODE_ARRAY
))
2600 vaddr
= VALUE_ADDRESS (v
) + value_offset (v
);
2601 /* Exact match not required. Within range is
2604 && addr
< vaddr
+ TYPE_LENGTH (value_type (v
)))
2606 b
->watchpoint_triggered
= watch_triggered_yes
;
2617 /* Possible return values for watchpoint_check (this can't be an enum
2618 because of check_errors). */
2619 /* The watchpoint has been deleted. */
2620 #define WP_DELETED 1
2621 /* The value has changed. */
2622 #define WP_VALUE_CHANGED 2
2623 /* The value has not changed. */
2624 #define WP_VALUE_NOT_CHANGED 3
2626 #define BP_TEMPFLAG 1
2627 #define BP_HARDWAREFLAG 2
2629 /* Check watchpoint condition. */
2632 watchpoint_check (void *p
)
2634 bpstat bs
= (bpstat
) p
;
2635 struct breakpoint
*b
;
2636 struct frame_info
*fr
;
2637 int within_current_scope
;
2639 b
= bs
->breakpoint_at
->owner
;
2641 if (b
->exp_valid_block
== NULL
)
2642 within_current_scope
= 1;
2645 /* There is no current frame at this moment. If we're going to have
2646 any chance of handling watchpoints on local variables, we'll need
2647 the frame chain (so we can determine if we're in scope). */
2648 reinit_frame_cache ();
2649 fr
= frame_find_by_id (b
->watchpoint_frame
);
2650 within_current_scope
= (fr
!= NULL
);
2652 /* If we've gotten confused in the unwinder, we might have
2653 returned a frame that can't describe this variable. */
2654 if (within_current_scope
2655 && block_function (b
->exp_valid_block
) != get_frame_function (fr
))
2656 within_current_scope
= 0;
2658 /* in_function_epilogue_p() returns a non-zero value if we're still
2659 in the function but the stack frame has already been invalidated.
2660 Since we can't rely on the values of local variables after the
2661 stack has been destroyed, we are treating the watchpoint in that
2662 state as `not changed' without further checking.
2664 vinschen/2003-09-04: The former implementation left out the case
2665 that the watchpoint frame couldn't be found by frame_find_by_id()
2666 because the current PC is currently in an epilogue. Calling
2667 gdbarch_in_function_epilogue_p() also when fr == NULL fixes that. */
2668 if ((!within_current_scope
|| fr
== get_current_frame ())
2669 && gdbarch_in_function_epilogue_p (current_gdbarch
, read_pc ()))
2670 return WP_VALUE_NOT_CHANGED
;
2671 if (fr
&& within_current_scope
)
2672 /* If we end up stopping, the current frame will get selected
2673 in normal_stop. So this call to select_frame won't affect
2678 if (within_current_scope
)
2680 /* We use value_{,free_to_}mark because it could be a
2681 *long* time before we return to the command level and
2682 call free_all_values. We can't call free_all_values because
2683 we might be in the middle of evaluating a function call. */
2685 struct value
*mark
= value_mark ();
2686 struct value
*new_val
= evaluate_expression (b
->exp
);
2687 if (!value_equal (b
->val
, new_val
))
2689 release_value (new_val
);
2690 value_free_to_mark (mark
);
2691 bs
->old_val
= b
->val
;
2693 /* We will stop here */
2694 return WP_VALUE_CHANGED
;
2698 /* Nothing changed, don't do anything. */
2699 value_free_to_mark (mark
);
2700 /* We won't stop here */
2701 return WP_VALUE_NOT_CHANGED
;
2706 /* This seems like the only logical thing to do because
2707 if we temporarily ignored the watchpoint, then when
2708 we reenter the block in which it is valid it contains
2709 garbage (in the case of a function, it may have two
2710 garbage values, one before and one after the prologue).
2711 So we can't even detect the first assignment to it and
2712 watch after that (since the garbage may or may not equal
2713 the first value assigned). */
2714 /* We print all the stop information in print_it_typical(), but
2715 in this case, by the time we call print_it_typical() this bp
2716 will be deleted already. So we have no choice but print the
2717 information here. */
2718 if (ui_out_is_mi_like_p (uiout
))
2720 (uiout
, "reason", async_reason_lookup (EXEC_ASYNC_WATCHPOINT_SCOPE
));
2721 ui_out_text (uiout
, "\nWatchpoint ");
2722 ui_out_field_int (uiout
, "wpnum", b
->number
);
2723 ui_out_text (uiout
, " deleted because the program has left the block in\n\
2724 which its expression is valid.\n");
2726 if (b
->related_breakpoint
)
2727 b
->related_breakpoint
->disposition
= disp_del_at_next_stop
;
2728 b
->disposition
= disp_del_at_next_stop
;
2734 /* Get a bpstat associated with having just stopped at address
2735 BP_ADDR in thread PTID.
2737 Determine whether we stopped at a breakpoint, etc, or whether we
2738 don't understand this stop. Result is a chain of bpstat's such that:
2740 if we don't understand the stop, the result is a null pointer.
2742 if we understand why we stopped, the result is not null.
2744 Each element of the chain refers to a particular breakpoint or
2745 watchpoint at which we have stopped. (We may have stopped for
2746 several reasons concurrently.)
2748 Each element of the chain has valid next, breakpoint_at,
2749 commands, FIXME??? fields. */
2752 bpstat_stop_status (CORE_ADDR bp_addr
, ptid_t ptid
)
2754 struct breakpoint
*b
= NULL
;
2755 struct bp_location
*bl
;
2756 /* True if we've hit a breakpoint (as opposed to a watchpoint). */
2757 int real_breakpoint
= 0;
2758 /* Root of the chain of bpstat's */
2759 struct bpstats root_bs
[1];
2760 /* Pointer to the last thing in the chain currently. */
2761 bpstat bs
= root_bs
;
2762 int thread_id
= pid_to_thread_id (ptid
);
2764 ALL_BP_LOCATIONS (bl
)
2768 if (!breakpoint_enabled (b
) && b
->enable_state
!= bp_permanent
)
2771 if (b
->type
!= bp_watchpoint
2772 && b
->type
!= bp_hardware_watchpoint
2773 && b
->type
!= bp_read_watchpoint
2774 && b
->type
!= bp_access_watchpoint
2775 && b
->type
!= bp_hardware_breakpoint
2776 && b
->type
!= bp_catch_fork
2777 && b
->type
!= bp_catch_vfork
2778 && b
->type
!= bp_catch_exec
2779 && b
->type
!= bp_catch_catch
2780 && b
->type
!= bp_catch_throw
) /* a non-watchpoint bp */
2782 if (bl
->address
!= bp_addr
) /* address doesn't match */
2784 if (overlay_debugging
/* unmapped overlay section */
2785 && section_is_overlay (bl
->section
)
2786 && !section_is_mapped (bl
->section
))
2790 /* Continuable hardware watchpoints are treated as non-existent if the
2791 reason we stopped wasn't a hardware watchpoint (we didn't stop on
2792 some data address). Otherwise gdb won't stop on a break instruction
2793 in the code (not from a breakpoint) when a hardware watchpoint has
2794 been defined. Also skip watchpoints which we know did not trigger
2795 (did not match the data address). */
2797 if ((b
->type
== bp_hardware_watchpoint
2798 || b
->type
== bp_read_watchpoint
2799 || b
->type
== bp_access_watchpoint
)
2800 && b
->watchpoint_triggered
== watch_triggered_no
)
2803 if (b
->type
== bp_hardware_breakpoint
)
2805 if (bl
->address
!= bp_addr
)
2807 if (overlay_debugging
/* unmapped overlay section */
2808 && section_is_overlay (bl
->section
)
2809 && !section_is_mapped (bl
->section
))
2813 /* Is this a catchpoint of a load or unload? If so, did we
2814 get a load or unload of the specified library? If not,
2816 if ((b
->type
== bp_catch_load
)
2817 #if defined(SOLIB_HAVE_LOAD_EVENT)
2818 && (!SOLIB_HAVE_LOAD_EVENT (PIDGET (inferior_ptid
))
2819 || ((b
->dll_pathname
!= NULL
)
2820 && (strcmp (b
->dll_pathname
,
2821 SOLIB_LOADED_LIBRARY_PATHNAME (
2822 PIDGET (inferior_ptid
)))
2828 if ((b
->type
== bp_catch_unload
)
2829 #if defined(SOLIB_HAVE_UNLOAD_EVENT)
2830 && (!SOLIB_HAVE_UNLOAD_EVENT (PIDGET (inferior_ptid
))
2831 || ((b
->dll_pathname
!= NULL
)
2832 && (strcmp (b
->dll_pathname
,
2833 SOLIB_UNLOADED_LIBRARY_PATHNAME (
2834 PIDGET (inferior_ptid
)))
2840 if ((b
->type
== bp_catch_fork
)
2841 && !inferior_has_forked (PIDGET (inferior_ptid
),
2842 &b
->forked_inferior_pid
))
2845 if ((b
->type
== bp_catch_vfork
)
2846 && !inferior_has_vforked (PIDGET (inferior_ptid
),
2847 &b
->forked_inferior_pid
))
2850 if ((b
->type
== bp_catch_exec
)
2851 && !inferior_has_execd (PIDGET (inferior_ptid
), &b
->exec_pathname
))
2854 if (ep_is_exception_catchpoint (b
) &&
2855 !(current_exception_event
= target_get_current_exception_event ()))
2858 /* Come here if it's a watchpoint, or if the break address matches */
2860 bs
= bpstat_alloc (bl
, bs
); /* Alloc a bpstat to explain stop */
2862 /* Watchpoints may change this, if not found to have triggered. */
2866 if (b
->type
== bp_watchpoint
2867 || b
->type
== bp_read_watchpoint
2868 || b
->type
== bp_access_watchpoint
2869 || b
->type
== bp_hardware_watchpoint
)
2873 int must_check_value
= 0;
2875 if (b
->type
== bp_watchpoint
)
2876 /* For a software watchpoint, we must always check the
2878 must_check_value
= 1;
2879 else if (b
->watchpoint_triggered
== watch_triggered_yes
)
2880 /* We have a hardware watchpoint (read, write, or access)
2881 and the target earlier reported an address watched by
2883 must_check_value
= 1;
2884 else if (b
->watchpoint_triggered
== watch_triggered_unknown
2885 && b
->type
== bp_hardware_watchpoint
)
2886 /* We were stopped by a hardware watchpoint, but the target could
2887 not report the data address. We must check the watchpoint's
2888 value. Access and read watchpoints are out of luck; without
2889 a data address, we can't figure it out. */
2890 must_check_value
= 1;
2892 if (must_check_value
)
2894 char *message
= xstrprintf ("Error evaluating expression for watchpoint %d\n",
2896 struct cleanup
*cleanups
= make_cleanup (xfree
, message
);
2897 int e
= catch_errors (watchpoint_check
, bs
, message
,
2899 do_cleanups (cleanups
);
2903 /* We've already printed what needs to be printed. */
2904 bs
->print_it
= print_it_done
;
2907 case WP_VALUE_CHANGED
:
2908 if (b
->type
== bp_read_watchpoint
)
2910 /* Don't stop: read watchpoints shouldn't fire if
2911 the value has changed. This is for targets
2912 which cannot set read-only watchpoints. */
2913 bs
->print_it
= print_it_noop
;
2919 case WP_VALUE_NOT_CHANGED
:
2920 if (b
->type
== bp_hardware_watchpoint
2921 || b
->type
== bp_watchpoint
)
2923 /* Don't stop: write watchpoints shouldn't fire if
2924 the value hasn't changed. */
2925 bs
->print_it
= print_it_noop
;
2935 /* Error from catch_errors. */
2936 printf_filtered (_("Watchpoint %d deleted.\n"), b
->number
);
2937 if (b
->related_breakpoint
)
2938 b
->related_breakpoint
->disposition
= disp_del_at_next_stop
;
2939 b
->disposition
= disp_del_at_next_stop
;
2940 /* We've already printed what needs to be printed. */
2941 bs
->print_it
= print_it_done
;
2945 else /* must_check_value == 0 */
2947 /* This is a case where some watchpoint(s) triggered, but
2948 not at the address of this watchpoint, or else no
2949 watchpoint triggered after all. So don't print
2950 anything for this watchpoint. */
2951 bs
->print_it
= print_it_noop
;
2958 /* By definition, an encountered breakpoint is a triggered
2962 real_breakpoint
= 1;
2965 if (frame_id_p (b
->frame_id
)
2966 && !frame_id_eq (b
->frame_id
, get_frame_id (get_current_frame ())))
2970 int value_is_zero
= 0;
2972 /* If this is a scope breakpoint, mark the associated
2973 watchpoint as triggered so that we will handle the
2974 out-of-scope event. We'll get to the watchpoint next
2976 if (b
->type
== bp_watchpoint_scope
)
2977 b
->related_breakpoint
->watchpoint_triggered
= watch_triggered_yes
;
2981 /* Need to select the frame, with all that implies
2982 so that the conditions will have the right context. */
2983 select_frame (get_current_frame ());
2985 = catch_errors (breakpoint_cond_eval
, (bl
->cond
),
2986 "Error in testing breakpoint condition:\n",
2988 /* FIXME-someday, should give breakpoint # */
2991 if (bl
->cond
&& value_is_zero
)
2994 /* Don't consider this a hit. */
2997 else if (b
->thread
!= -1 && b
->thread
!= thread_id
)
3000 /* Don't consider this a hit. */
3003 else if (b
->ignore_count
> 0)
3006 annotate_ignore_count_change ();
3009 else if (b
->type
== bp_thread_event
|| b
->type
== bp_overlay_event
)
3010 /* We do not stop for these. */
3014 /* We will stop here */
3015 if (b
->disposition
== disp_disable
)
3016 b
->enable_state
= bp_disabled
;
3019 bs
->commands
= b
->commands
;
3021 (strcmp ("silent", bs
->commands
->line
) == 0
3022 || (xdb_commands
&& strcmp ("Q", bs
->commands
->line
) == 0)))
3024 bs
->commands
= bs
->commands
->next
;
3027 bs
->commands
= copy_command_lines (bs
->commands
);
3030 /* Print nothing for this entry if we dont stop or if we dont print. */
3031 if (bs
->stop
== 0 || bs
->print
== 0)
3032 bs
->print_it
= print_it_noop
;
3035 bs
->next
= NULL
; /* Terminate the chain */
3036 bs
= root_bs
->next
; /* Re-grab the head of the chain */
3038 /* If we aren't stopping, the value of some hardware watchpoint may
3039 not have changed, but the intermediate memory locations we are
3040 watching may have. Don't bother if we're stopping; this will get
3042 for (bs
= root_bs
->next
; bs
!= NULL
; bs
= bs
->next
)
3047 for (bs
= root_bs
->next
; bs
!= NULL
; bs
= bs
->next
)
3049 && (bs
->breakpoint_at
->owner
->type
== bp_hardware_watchpoint
3050 || bs
->breakpoint_at
->owner
->type
== bp_read_watchpoint
3051 || bs
->breakpoint_at
->owner
->type
== bp_access_watchpoint
))
3053 remove_breakpoints ();
3054 insert_breakpoints ();
3058 return root_bs
->next
;
3061 /* Tell what to do about this bpstat. */
3063 bpstat_what (bpstat bs
)
3065 /* Classify each bpstat as one of the following. */
3068 /* This bpstat element has no effect on the main_action. */
3071 /* There was a watchpoint, stop but don't print. */
3074 /* There was a watchpoint, stop and print. */
3077 /* There was a breakpoint but we're not stopping. */
3080 /* There was a breakpoint, stop but don't print. */
3083 /* There was a breakpoint, stop and print. */
3086 /* We hit the longjmp breakpoint. */
3089 /* We hit the longjmp_resume breakpoint. */
3092 /* We hit the step_resume breakpoint. */
3095 /* We hit the shared library event breakpoint. */
3098 /* We caught a shared library event. */
3101 /* This is just used to count how many enums there are. */
3105 /* Here is the table which drives this routine. So that we can
3106 format it pretty, we define some abbreviations for the
3107 enum bpstat_what codes. */
3108 #define kc BPSTAT_WHAT_KEEP_CHECKING
3109 #define ss BPSTAT_WHAT_STOP_SILENT
3110 #define sn BPSTAT_WHAT_STOP_NOISY
3111 #define sgl BPSTAT_WHAT_SINGLE
3112 #define slr BPSTAT_WHAT_SET_LONGJMP_RESUME
3113 #define clr BPSTAT_WHAT_CLEAR_LONGJMP_RESUME
3114 #define clrs BPSTAT_WHAT_CLEAR_LONGJMP_RESUME_SINGLE
3115 #define sr BPSTAT_WHAT_STEP_RESUME
3116 #define shl BPSTAT_WHAT_CHECK_SHLIBS
3117 #define shlr BPSTAT_WHAT_CHECK_SHLIBS_RESUME_FROM_HOOK
3119 /* "Can't happen." Might want to print an error message.
3120 abort() is not out of the question, but chances are GDB is just
3121 a bit confused, not unusable. */
3122 #define err BPSTAT_WHAT_STOP_NOISY
3124 /* Given an old action and a class, come up with a new action. */
3125 /* One interesting property of this table is that wp_silent is the same
3126 as bp_silent and wp_noisy is the same as bp_noisy. That is because
3127 after stopping, the check for whether to step over a breakpoint
3128 (BPSTAT_WHAT_SINGLE type stuff) is handled in proceed() without
3129 reference to how we stopped. We retain separate wp_silent and
3130 bp_silent codes in case we want to change that someday.
3132 Another possibly interesting property of this table is that
3133 there's a partial ordering, priority-like, of the actions. Once
3134 you've decided that some action is appropriate, you'll never go
3135 back and decide something of a lower priority is better. The
3138 kc < clr sgl shl shlr slr sn sr ss
3139 sgl < clrs shl shlr slr sn sr ss
3140 slr < err shl shlr sn sr ss
3141 clr < clrs err shl shlr sn sr ss
3142 clrs < err shl shlr sn sr ss
3149 What I think this means is that we don't need a damned table
3150 here. If you just put the rows and columns in the right order,
3151 it'd look awfully regular. We could simply walk the bpstat list
3152 and choose the highest priority action we find, with a little
3153 logic to handle the 'err' cases, and the CLEAR_LONGJMP_RESUME/
3154 CLEAR_LONGJMP_RESUME_SINGLE distinction (which breakpoint.h says
3155 is messy anyway). */
3157 /* step_resume entries: a step resume breakpoint overrides another
3158 breakpoint of signal handling (see comment in wait_for_inferior
3159 at where we set the step_resume breakpoint). */
3161 static const enum bpstat_what_main_action
3162 table
[(int) class_last
][(int) BPSTAT_WHAT_LAST
] =
3165 /* kc ss sn sgl slr clr clrs sr shl shlr
3168 {kc
, ss
, sn
, sgl
, slr
, clr
, clrs
, sr
, shl
, shlr
},
3170 {ss
, ss
, sn
, ss
, ss
, ss
, ss
, sr
, shl
, shlr
},
3172 {sn
, sn
, sn
, sn
, sn
, sn
, sn
, sr
, shl
, shlr
},
3174 {sgl
, ss
, sn
, sgl
, slr
, clrs
, clrs
, sr
, shl
, shlr
},
3176 {ss
, ss
, sn
, ss
, ss
, ss
, ss
, sr
, shl
, shlr
},
3178 {sn
, sn
, sn
, sn
, sn
, sn
, sn
, sr
, shl
, shlr
},
3180 {slr
, ss
, sn
, slr
, slr
, err
, err
, sr
, shl
, shlr
},
3182 {clr
, ss
, sn
, clrs
, err
, err
, err
, sr
, shl
, shlr
},
3184 {sr
, sr
, sr
, sr
, sr
, sr
, sr
, sr
, sr
, sr
},
3186 {shl
, shl
, shl
, shl
, shl
, shl
, shl
, sr
, shl
, shlr
},
3188 {shlr
, shlr
, shlr
, shlr
, shlr
, shlr
, shlr
, sr
, shlr
, shlr
}
3203 enum bpstat_what_main_action current_action
= BPSTAT_WHAT_KEEP_CHECKING
;
3204 struct bpstat_what retval
;
3206 retval
.call_dummy
= 0;
3207 for (; bs
!= NULL
; bs
= bs
->next
)
3209 enum class bs_class
= no_effect
;
3210 if (bs
->breakpoint_at
== NULL
)
3211 /* I suspect this can happen if it was a momentary breakpoint
3212 which has since been deleted. */
3214 switch (bs
->breakpoint_at
->owner
->type
)
3220 case bp_hardware_breakpoint
:
3226 bs_class
= bp_noisy
;
3228 bs_class
= bp_silent
;
3231 bs_class
= bp_nostop
;
3234 case bp_hardware_watchpoint
:
3235 case bp_read_watchpoint
:
3236 case bp_access_watchpoint
:
3240 bs_class
= wp_noisy
;
3242 bs_class
= wp_silent
;
3245 /* There was a watchpoint, but we're not stopping.
3246 This requires no further action. */
3247 bs_class
= no_effect
;
3250 bs_class
= long_jump
;
3252 case bp_longjmp_resume
:
3253 bs_class
= long_resume
;
3255 case bp_step_resume
:
3258 bs_class
= step_resume
;
3261 /* It is for the wrong frame. */
3262 bs_class
= bp_nostop
;
3264 case bp_watchpoint_scope
:
3265 bs_class
= bp_nostop
;
3267 case bp_shlib_event
:
3268 bs_class
= shlib_event
;
3270 case bp_thread_event
:
3271 case bp_overlay_event
:
3272 bs_class
= bp_nostop
;
3275 case bp_catch_unload
:
3276 /* Only if this catchpoint triggered should we cause the
3277 step-out-of-dld behaviour. Otherwise, we ignore this
3280 bs_class
= catch_shlib_event
;
3282 bs_class
= no_effect
;
3285 case bp_catch_vfork
:
3290 bs_class
= bp_noisy
;
3292 bs_class
= bp_silent
;
3295 /* There was a catchpoint, but we're not stopping.
3296 This requires no further action. */
3297 bs_class
= no_effect
;
3299 case bp_catch_catch
:
3300 if (!bs
->stop
|| CURRENT_EXCEPTION_KIND
!= EX_EVENT_CATCH
)
3301 bs_class
= bp_nostop
;
3303 bs_class
= bs
->print
? bp_noisy
: bp_silent
;
3305 case bp_catch_throw
:
3306 if (!bs
->stop
|| CURRENT_EXCEPTION_KIND
!= EX_EVENT_THROW
)
3307 bs_class
= bp_nostop
;
3309 bs_class
= bs
->print
? bp_noisy
: bp_silent
;
3312 /* Make sure the action is stop (silent or noisy),
3313 so infrun.c pops the dummy frame. */
3314 bs_class
= bp_silent
;
3315 retval
.call_dummy
= 1;
3318 current_action
= table
[(int) bs_class
][(int) current_action
];
3320 retval
.main_action
= current_action
;
3324 /* Nonzero if we should step constantly (e.g. watchpoints on machines
3325 without hardware support). This isn't related to a specific bpstat,
3326 just to things like whether watchpoints are set. */
3329 bpstat_should_step (void)
3331 struct breakpoint
*b
;
3333 if (breakpoint_enabled (b
) && b
->type
== bp_watchpoint
)
3338 /* Nonzero if there are enabled hardware watchpoints. */
3340 bpstat_have_active_hw_watchpoints (void)
3342 struct bp_location
*bpt
;
3343 ALL_BP_LOCATIONS (bpt
)
3344 if (breakpoint_enabled (bpt
->owner
)
3346 && bpt
->loc_type
== bp_loc_hardware_watchpoint
)
3352 /* Given a bpstat that records zero or more triggered eventpoints, this
3353 function returns another bpstat which contains only the catchpoints
3354 on that first list, if any. */
3356 bpstat_get_triggered_catchpoints (bpstat ep_list
, bpstat
*cp_list
)
3358 struct bpstats root_bs
[1];
3359 bpstat bs
= root_bs
;
3360 struct breakpoint
*ep
;
3363 bpstat_clear (cp_list
);
3364 root_bs
->next
= NULL
;
3366 for (; ep_list
!= NULL
; ep_list
= ep_list
->next
)
3368 /* Is this eventpoint a catchpoint? If not, ignore it. */
3369 ep
= ep_list
->breakpoint_at
->owner
;
3372 if ((ep
->type
!= bp_catch_load
) &&
3373 (ep
->type
!= bp_catch_unload
) &&
3374 (ep
->type
!= bp_catch_catch
) &&
3375 (ep
->type
!= bp_catch_throw
))
3376 /* pai: (temp) ADD fork/vfork here!! */
3379 /* Yes; add it to the list. */
3380 bs
= bpstat_alloc (ep_list
->breakpoint_at
, bs
);
3385 #if defined(SOLIB_ADD)
3386 /* Also, for each triggered catchpoint, tag it with the name of
3387 the library that caused this trigger. (We copy the name now,
3388 because it's only guaranteed to be available NOW, when the
3389 catchpoint triggers. Clients who may wish to know the name
3390 later must get it from the catchpoint itself.) */
3391 if (ep
->triggered_dll_pathname
!= NULL
)
3392 xfree (ep
->triggered_dll_pathname
);
3393 if (ep
->type
== bp_catch_load
)
3394 dll_pathname
= SOLIB_LOADED_LIBRARY_PATHNAME (
3395 PIDGET (inferior_ptid
));
3397 dll_pathname
= SOLIB_UNLOADED_LIBRARY_PATHNAME (
3398 PIDGET (inferior_ptid
));
3400 dll_pathname
= NULL
;
3404 ep
->triggered_dll_pathname
= (char *)
3405 xmalloc (strlen (dll_pathname
) + 1);
3406 strcpy (ep
->triggered_dll_pathname
, dll_pathname
);
3409 ep
->triggered_dll_pathname
= NULL
;
3415 static void print_breakpoint_location (struct breakpoint
*b
,
3416 struct bp_location
*loc
,
3418 struct ui_stream
*stb
)
3423 = find_pc_sect_function (loc
->address
, loc
->section
);
3426 ui_out_text (uiout
, "in ");
3427 ui_out_field_string (uiout
, "func",
3428 SYMBOL_PRINT_NAME (sym
));
3429 ui_out_wrap_hint (uiout
, wrap_indent
);
3430 ui_out_text (uiout
, " at ");
3432 ui_out_field_string (uiout
, "file", b
->source_file
);
3433 ui_out_text (uiout
, ":");
3435 if (ui_out_is_mi_like_p (uiout
))
3437 struct symtab_and_line sal
= find_pc_line (loc
->address
, 0);
3438 char *fullname
= symtab_to_fullname (sal
.symtab
);
3441 ui_out_field_string (uiout
, "fullname", fullname
);
3444 ui_out_field_int (uiout
, "line", b
->line_number
);
3448 ui_out_field_string (uiout
, "pending", b
->addr_string
);
3452 print_address_symbolic (loc
->address
, stb
->stream
, demangle
, "");
3453 ui_out_field_stream (uiout
, "at", stb
);
3457 /* Print B to gdb_stdout. */
3459 print_one_breakpoint_location (struct breakpoint
*b
,
3460 struct bp_location
*loc
,
3462 CORE_ADDR
*last_addr
)
3464 struct command_line
*l
;
3466 struct ep_type_description
3471 static struct ep_type_description bptypes
[] =
3473 {bp_none
, "?deleted?"},
3474 {bp_breakpoint
, "breakpoint"},
3475 {bp_hardware_breakpoint
, "hw breakpoint"},
3476 {bp_until
, "until"},
3477 {bp_finish
, "finish"},
3478 {bp_watchpoint
, "watchpoint"},
3479 {bp_hardware_watchpoint
, "hw watchpoint"},
3480 {bp_read_watchpoint
, "read watchpoint"},
3481 {bp_access_watchpoint
, "acc watchpoint"},
3482 {bp_longjmp
, "longjmp"},
3483 {bp_longjmp_resume
, "longjmp resume"},
3484 {bp_step_resume
, "step resume"},
3485 {bp_watchpoint_scope
, "watchpoint scope"},
3486 {bp_call_dummy
, "call dummy"},
3487 {bp_shlib_event
, "shlib events"},
3488 {bp_thread_event
, "thread events"},
3489 {bp_overlay_event
, "overlay events"},
3490 {bp_catch_load
, "catch load"},
3491 {bp_catch_unload
, "catch unload"},
3492 {bp_catch_fork
, "catch fork"},
3493 {bp_catch_vfork
, "catch vfork"},
3494 {bp_catch_exec
, "catch exec"},
3495 {bp_catch_catch
, "catch catch"},
3496 {bp_catch_throw
, "catch throw"}
3499 static char *bpdisps
[] =
3500 {"del", "dstp", "dis", "keep"};
3501 static char bpenables
[] = "nynny";
3502 char wrap_indent
[80];
3503 struct ui_stream
*stb
= ui_out_stream_new (uiout
);
3504 struct cleanup
*old_chain
= make_cleanup_ui_out_stream_delete (stb
);
3505 struct cleanup
*bkpt_chain
;
3507 int header_of_multiple
= 0;
3508 int part_of_multiple
= (loc
!= NULL
);
3510 gdb_assert (!loc
|| loc_number
!= 0);
3511 /* See comment in print_one_breakpoint concerning
3512 treatment of breakpoints with single disabled
3516 && (b
->loc
->next
!= NULL
|| !b
->loc
->enabled
)))
3517 header_of_multiple
= 1;
3522 bkpt_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "bkpt");
3526 if (part_of_multiple
)
3529 formatted
= xstrprintf ("%d.%d", b
->number
, loc_number
);
3530 ui_out_field_string (uiout
, "number", formatted
);
3535 ui_out_field_int (uiout
, "number", b
->number
);
3540 if (part_of_multiple
)
3541 ui_out_field_skip (uiout
, "type");
3544 if (((int) b
->type
>= (sizeof (bptypes
) / sizeof (bptypes
[0])))
3545 || ((int) b
->type
!= bptypes
[(int) b
->type
].type
))
3546 internal_error (__FILE__
, __LINE__
,
3547 _("bptypes table does not describe type #%d."),
3549 ui_out_field_string (uiout
, "type", bptypes
[(int) b
->type
].description
);
3554 if (part_of_multiple
)
3555 ui_out_field_skip (uiout
, "disp");
3557 ui_out_field_string (uiout
, "disp", bpdisps
[(int) b
->disposition
]);
3562 if (part_of_multiple
)
3563 ui_out_field_string (uiout
, "enabled",
3565 ? (loc
->enabled
? "y(p)" : "n(p)")
3566 : (loc
->enabled
? "y" : "n"));
3569 int pending
= (b
->loc
== NULL
|| b
->loc
->shlib_disabled
);
3570 /* For header of multiple, there's no point showing pending
3571 state -- it will be apparent from the locations. */
3572 if (header_of_multiple
)
3574 ui_out_field_fmt (uiout
, "enabled", "%c%s",
3575 bpenables
[(int) b
->enable_state
],
3576 pending
? "(p)" : "");
3578 ui_out_spaces (uiout
, 3);
3583 strcpy (wrap_indent
, " ");
3586 if (gdbarch_addr_bit (current_gdbarch
) <= 32)
3587 strcat (wrap_indent
, " ");
3589 strcat (wrap_indent
, " ");
3592 if (b
->ops
!= NULL
&& b
->ops
->print_one
!= NULL
)
3594 /* Although the print_one can possibly print
3595 all locations, calling it here is not likely
3596 to get any nice result. So, make sure there's
3597 just one location. */
3598 gdb_assert (b
->loc
== NULL
|| b
->loc
->next
== NULL
);
3599 b
->ops
->print_one (b
, last_addr
);
3605 internal_error (__FILE__
, __LINE__
,
3606 _("print_one_breakpoint: bp_none encountered\n"));
3610 case bp_hardware_watchpoint
:
3611 case bp_read_watchpoint
:
3612 case bp_access_watchpoint
:
3613 /* Field 4, the address, is omitted (which makes the columns
3614 not line up too nicely with the headers, but the effect
3615 is relatively readable). */
3617 ui_out_field_skip (uiout
, "addr");
3619 print_expression (b
->exp
, stb
->stream
);
3620 ui_out_field_stream (uiout
, "what", stb
);
3624 case bp_catch_unload
:
3625 /* Field 4, the address, is omitted (which makes the columns
3626 not line up too nicely with the headers, but the effect
3627 is relatively readable). */
3629 ui_out_field_skip (uiout
, "addr");
3631 if (b
->dll_pathname
== NULL
)
3633 ui_out_field_string (uiout
, "what", "<any library>");
3634 ui_out_spaces (uiout
, 1);
3638 ui_out_text (uiout
, "library \"");
3639 ui_out_field_string (uiout
, "what", b
->dll_pathname
);
3640 ui_out_text (uiout
, "\" ");
3645 case bp_catch_vfork
:
3646 /* Field 4, the address, is omitted (which makes the columns
3647 not line up too nicely with the headers, but the effect
3648 is relatively readable). */
3650 ui_out_field_skip (uiout
, "addr");
3652 if (b
->forked_inferior_pid
!= 0)
3654 ui_out_text (uiout
, "process ");
3655 ui_out_field_int (uiout
, "what", b
->forked_inferior_pid
);
3656 ui_out_spaces (uiout
, 1);
3661 /* Field 4, the address, is omitted (which makes the columns
3662 not line up too nicely with the headers, but the effect
3663 is relatively readable). */
3665 ui_out_field_skip (uiout
, "addr");
3667 if (b
->exec_pathname
!= NULL
)
3669 ui_out_text (uiout
, "program \"");
3670 ui_out_field_string (uiout
, "what", b
->exec_pathname
);
3671 ui_out_text (uiout
, "\" ");
3675 case bp_catch_catch
:
3676 /* Field 4, the address, is omitted (which makes the columns
3677 not line up too nicely with the headers, but the effect
3678 is relatively readable). */
3680 ui_out_field_skip (uiout
, "addr");
3682 ui_out_field_string (uiout
, "what", "exception catch");
3683 ui_out_spaces (uiout
, 1);
3686 case bp_catch_throw
:
3687 /* Field 4, the address, is omitted (which makes the columns
3688 not line up too nicely with the headers, but the effect
3689 is relatively readable). */
3691 ui_out_field_skip (uiout
, "addr");
3693 ui_out_field_string (uiout
, "what", "exception throw");
3694 ui_out_spaces (uiout
, 1);
3698 case bp_hardware_breakpoint
:
3702 case bp_longjmp_resume
:
3703 case bp_step_resume
:
3704 case bp_watchpoint_scope
:
3706 case bp_shlib_event
:
3707 case bp_thread_event
:
3708 case bp_overlay_event
:
3713 ui_out_field_string (uiout
, "addr", "<PENDING>");
3714 else if (header_of_multiple
)
3715 ui_out_field_string (uiout
, "addr", "<MULTIPLE>");
3717 ui_out_field_core_addr (uiout
, "addr", loc
->address
);
3720 if (!header_of_multiple
)
3721 print_breakpoint_location (b
, loc
, wrap_indent
, stb
);
3723 *last_addr
= b
->loc
->address
;
3727 if (!part_of_multiple
&& b
->thread
!= -1)
3729 /* FIXME: This seems to be redundant and lost here; see the
3730 "stop only in" line a little further down. */
3731 ui_out_text (uiout
, " thread ");
3732 ui_out_field_int (uiout
, "thread", b
->thread
);
3735 ui_out_text (uiout
, "\n");
3737 if (part_of_multiple
&& frame_id_p (b
->frame_id
))
3740 ui_out_text (uiout
, "\tstop only in stack frame at ");
3741 /* FIXME: cagney/2002-12-01: Shouldn't be poeking around inside
3743 ui_out_field_core_addr (uiout
, "frame", b
->frame_id
.stack_addr
);
3744 ui_out_text (uiout
, "\n");
3747 if (!part_of_multiple
&& b
->cond_string
&& !ada_exception_catchpoint_p (b
))
3749 /* We do not print the condition for Ada exception catchpoints
3750 because the condition is an internal implementation detail
3751 that we do not want to expose to the user. */
3753 ui_out_text (uiout
, "\tstop only if ");
3754 ui_out_field_string (uiout
, "cond", b
->cond_string
);
3755 ui_out_text (uiout
, "\n");
3758 if (!part_of_multiple
&& b
->thread
!= -1)
3760 /* FIXME should make an annotation for this */
3761 ui_out_text (uiout
, "\tstop only in thread ");
3762 ui_out_field_int (uiout
, "thread", b
->thread
);
3763 ui_out_text (uiout
, "\n");
3766 if (!part_of_multiple
&& show_breakpoint_hit_counts
&& b
->hit_count
)
3768 /* FIXME should make an annotation for this */
3769 if (ep_is_catchpoint (b
))
3770 ui_out_text (uiout
, "\tcatchpoint");
3772 ui_out_text (uiout
, "\tbreakpoint");
3773 ui_out_text (uiout
, " already hit ");
3774 ui_out_field_int (uiout
, "times", b
->hit_count
);
3775 if (b
->hit_count
== 1)
3776 ui_out_text (uiout
, " time\n");
3778 ui_out_text (uiout
, " times\n");
3781 /* Output the count also if it is zero, but only if this is
3782 mi. FIXME: Should have a better test for this. */
3783 if (ui_out_is_mi_like_p (uiout
))
3784 if (!part_of_multiple
&& show_breakpoint_hit_counts
&& b
->hit_count
== 0)
3785 ui_out_field_int (uiout
, "times", b
->hit_count
);
3787 if (!part_of_multiple
&& b
->ignore_count
)
3790 ui_out_text (uiout
, "\tignore next ");
3791 ui_out_field_int (uiout
, "ignore", b
->ignore_count
);
3792 ui_out_text (uiout
, " hits\n");
3795 if (!part_of_multiple
&& (l
= b
->commands
))
3797 struct cleanup
*script_chain
;
3800 script_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "script");
3801 print_command_lines (uiout
, l
, 4);
3802 do_cleanups (script_chain
);
3804 do_cleanups (bkpt_chain
);
3805 do_cleanups (old_chain
);
3809 print_one_breakpoint (struct breakpoint
*b
,
3810 CORE_ADDR
*last_addr
)
3812 print_one_breakpoint_location (b
, NULL
, 0, last_addr
);
3814 /* If this breakpoint has custom print function,
3815 it's already printed. Otherwise, print individual
3816 locations, if any. */
3817 if (b
->ops
== NULL
|| b
->ops
->print_one
== NULL
)
3819 /* If breakpoint has a single location that is
3820 disabled, we print it as if it had
3821 several locations, since otherwise it's hard to
3822 represent "breakpoint enabled, location disabled"
3825 && (b
->loc
->next
|| !b
->loc
->enabled
)
3826 && !ui_out_is_mi_like_p (uiout
))
3828 struct bp_location
*loc
;
3830 for (loc
= b
->loc
; loc
; loc
= loc
->next
, ++n
)
3831 print_one_breakpoint_location (b
, loc
, n
, last_addr
);
3837 struct captured_breakpoint_query_args
3843 do_captured_breakpoint_query (struct ui_out
*uiout
, void *data
)
3845 struct captured_breakpoint_query_args
*args
= data
;
3846 struct breakpoint
*b
;
3847 CORE_ADDR dummy_addr
= 0;
3850 if (args
->bnum
== b
->number
)
3852 print_one_breakpoint (b
, &dummy_addr
);
3860 gdb_breakpoint_query (struct ui_out
*uiout
, int bnum
, char **error_message
)
3862 struct captured_breakpoint_query_args args
;
3864 /* For the moment we don't trust print_one_breakpoint() to not throw
3866 if (catch_exceptions_with_msg (uiout
, do_captured_breakpoint_query
, &args
,
3867 error_message
, RETURN_MASK_ALL
) < 0)
3873 /* Return non-zero if B is user settable (breakpoints, watchpoints,
3874 catchpoints, et.al.). */
3877 user_settable_breakpoint (const struct breakpoint
*b
)
3879 return (b
->type
== bp_breakpoint
3880 || b
->type
== bp_catch_load
3881 || b
->type
== bp_catch_unload
3882 || b
->type
== bp_catch_fork
3883 || b
->type
== bp_catch_vfork
3884 || b
->type
== bp_catch_exec
3885 || b
->type
== bp_catch_catch
3886 || b
->type
== bp_catch_throw
3887 || b
->type
== bp_hardware_breakpoint
3888 || b
->type
== bp_watchpoint
3889 || b
->type
== bp_read_watchpoint
3890 || b
->type
== bp_access_watchpoint
3891 || b
->type
== bp_hardware_watchpoint
);
3894 /* Print information on user settable breakpoint (watchpoint, etc)
3895 number BNUM. If BNUM is -1 print all user settable breakpoints.
3896 If ALLFLAG is non-zero, include non- user settable breakpoints. */
3899 breakpoint_1 (int bnum
, int allflag
)
3901 struct breakpoint
*b
;
3902 CORE_ADDR last_addr
= (CORE_ADDR
) -1;
3903 int nr_printable_breakpoints
;
3904 struct cleanup
*bkpttbl_chain
;
3906 /* Compute the number of rows in the table. */
3907 nr_printable_breakpoints
= 0;
3910 || bnum
== b
->number
)
3912 if (allflag
|| user_settable_breakpoint (b
))
3913 nr_printable_breakpoints
++;
3918 = make_cleanup_ui_out_table_begin_end (uiout
, 6, nr_printable_breakpoints
,
3922 = make_cleanup_ui_out_table_begin_end (uiout
, 5, nr_printable_breakpoints
,
3925 if (nr_printable_breakpoints
> 0)
3926 annotate_breakpoints_headers ();
3927 if (nr_printable_breakpoints
> 0)
3929 ui_out_table_header (uiout
, 7, ui_left
, "number", "Num"); /* 1 */
3930 if (nr_printable_breakpoints
> 0)
3932 ui_out_table_header (uiout
, 14, ui_left
, "type", "Type"); /* 2 */
3933 if (nr_printable_breakpoints
> 0)
3935 ui_out_table_header (uiout
, 4, ui_left
, "disp", "Disp"); /* 3 */
3936 if (nr_printable_breakpoints
> 0)
3938 ui_out_table_header (uiout
, 4, ui_left
, "enabled", "Enb"); /* 4 */
3941 if (nr_printable_breakpoints
> 0)
3943 if (gdbarch_addr_bit (current_gdbarch
) <= 32)
3944 ui_out_table_header (uiout
, 10, ui_left
, "addr", "Address");/* 5 */
3946 ui_out_table_header (uiout
, 18, ui_left
, "addr", "Address");/* 5 */
3948 if (nr_printable_breakpoints
> 0)
3950 ui_out_table_header (uiout
, 40, ui_noalign
, "what", "What"); /* 6 */
3951 ui_out_table_body (uiout
);
3952 if (nr_printable_breakpoints
> 0)
3953 annotate_breakpoints_table ();
3957 || bnum
== b
->number
)
3959 /* We only print out user settable breakpoints unless the
3961 if (allflag
|| user_settable_breakpoint (b
))
3962 print_one_breakpoint (b
, &last_addr
);
3965 do_cleanups (bkpttbl_chain
);
3967 if (nr_printable_breakpoints
== 0)
3970 ui_out_message (uiout
, 0, "No breakpoints or watchpoints.\n");
3972 ui_out_message (uiout
, 0, "No breakpoint or watchpoint number %d.\n",
3977 /* Compare against (CORE_ADDR)-1 in case some compiler decides
3978 that a comparison of an unsigned with -1 is always false. */
3979 if (last_addr
!= (CORE_ADDR
) -1 && !server_command
)
3980 set_next_address (last_addr
);
3983 /* FIXME? Should this be moved up so that it is only called when
3984 there have been breakpoints? */
3985 annotate_breakpoints_table_end ();
3989 breakpoints_info (char *bnum_exp
, int from_tty
)
3994 bnum
= parse_and_eval_long (bnum_exp
);
3996 breakpoint_1 (bnum
, 0);
4000 maintenance_info_breakpoints (char *bnum_exp
, int from_tty
)
4005 bnum
= parse_and_eval_long (bnum_exp
);
4007 breakpoint_1 (bnum
, 1);
4011 breakpoint_has_pc (struct breakpoint
*b
, CORE_ADDR pc
, asection
*section
)
4013 struct bp_location
*bl
= b
->loc
;
4014 for (; bl
; bl
= bl
->next
)
4016 if (bl
->address
== pc
4017 && (!overlay_debugging
|| bl
->section
== section
))
4023 /* Print a message describing any breakpoints set at PC. */
4026 describe_other_breakpoints (CORE_ADDR pc
, asection
*section
, int thread
)
4029 struct breakpoint
*b
;
4032 others
+= breakpoint_has_pc (b
, pc
, section
);
4036 printf_filtered (_("Note: breakpoint "));
4037 else /* if (others == ???) */
4038 printf_filtered (_("Note: breakpoints "));
4040 if (breakpoint_has_pc (b
, pc
, section
))
4043 printf_filtered ("%d", b
->number
);
4044 if (b
->thread
== -1 && thread
!= -1)
4045 printf_filtered (" (all threads)");
4046 else if (b
->thread
!= -1)
4047 printf_filtered (" (thread %d)", b
->thread
);
4048 printf_filtered ("%s%s ",
4049 ((b
->enable_state
== bp_disabled
||
4050 b
->enable_state
== bp_call_disabled
)
4052 : b
->enable_state
== bp_permanent
4056 : ((others
== 1) ? " and" : ""));
4058 printf_filtered (_("also set at pc "));
4059 deprecated_print_address_numeric (pc
, 1, gdb_stdout
);
4060 printf_filtered (".\n");
4064 /* Set the default place to put a breakpoint
4065 for the `break' command with no arguments. */
4068 set_default_breakpoint (int valid
, CORE_ADDR addr
, struct symtab
*symtab
,
4071 default_breakpoint_valid
= valid
;
4072 default_breakpoint_address
= addr
;
4073 default_breakpoint_symtab
= symtab
;
4074 default_breakpoint_line
= line
;
4077 /* Return true iff it is meaningful to use the address member of
4078 BPT. For some breakpoint types, the address member is irrelevant
4079 and it makes no sense to attempt to compare it to other addresses
4080 (or use it for any other purpose either).
4082 More specifically, each of the following breakpoint types will always
4083 have a zero valued address and we don't want check_duplicates() to mark
4084 breakpoints of any of these types to be a duplicate of an actual
4085 breakpoint at address zero:
4088 bp_hardware_watchpoint
4090 bp_access_watchpoint
4097 breakpoint_address_is_meaningful (struct breakpoint
*bpt
)
4099 enum bptype type
= bpt
->type
;
4101 return (type
!= bp_watchpoint
4102 && type
!= bp_hardware_watchpoint
4103 && type
!= bp_read_watchpoint
4104 && type
!= bp_access_watchpoint
4105 && type
!= bp_catch_exec
4106 && type
!= bp_longjmp_resume
4107 && type
!= bp_catch_fork
4108 && type
!= bp_catch_vfork
);
4111 /* Rescan breakpoints at the same address and section as BPT,
4112 marking the first one as "first" and any others as "duplicates".
4113 This is so that the bpt instruction is only inserted once.
4114 If we have a permanent breakpoint at the same place as BPT, make
4115 that one the official one, and the rest as duplicates. */
4118 check_duplicates_for (CORE_ADDR address
, asection
*section
)
4120 struct bp_location
*b
;
4122 struct bp_location
*perm_bp
= 0;
4124 ALL_BP_LOCATIONS (b
)
4125 if (b
->owner
->enable_state
!= bp_disabled
4126 && b
->owner
->enable_state
!= bp_call_disabled
4128 && !b
->shlib_disabled
4129 && b
->address
== address
/* address / overlay match */
4130 && (!overlay_debugging
|| b
->section
== section
)
4131 && breakpoint_address_is_meaningful (b
->owner
))
4133 /* Have we found a permanent breakpoint? */
4134 if (b
->owner
->enable_state
== bp_permanent
)
4141 b
->duplicate
= count
> 1;
4144 /* If we found a permanent breakpoint at this address, go over the
4145 list again and declare all the other breakpoints there to be the
4149 perm_bp
->duplicate
= 0;
4151 /* Permanent breakpoint should always be inserted. */
4152 if (! perm_bp
->inserted
)
4153 internal_error (__FILE__
, __LINE__
,
4154 _("allegedly permanent breakpoint is not "
4155 "actually inserted"));
4157 ALL_BP_LOCATIONS (b
)
4160 if (b
->owner
->enable_state
!= bp_disabled
4161 && b
->owner
->enable_state
!= bp_call_disabled
4162 && b
->enabled
&& !b
->shlib_disabled
4163 && b
->address
== address
/* address / overlay match */
4164 && (!overlay_debugging
|| b
->section
== section
)
4165 && breakpoint_address_is_meaningful (b
->owner
))
4168 internal_error (__FILE__
, __LINE__
,
4169 _("another breakpoint was inserted on top of "
4170 "a permanent breakpoint"));
4179 check_duplicates (struct breakpoint
*bpt
)
4181 struct bp_location
*bl
= bpt
->loc
;
4183 if (! breakpoint_address_is_meaningful (bpt
))
4186 for (; bl
; bl
= bl
->next
)
4187 check_duplicates_for (bl
->address
, bl
->section
);
4191 breakpoint_adjustment_warning (CORE_ADDR from_addr
, CORE_ADDR to_addr
,
4192 int bnum
, int have_bnum
)
4197 strcpy (astr1
, hex_string_custom ((unsigned long) from_addr
, 8));
4198 strcpy (astr2
, hex_string_custom ((unsigned long) to_addr
, 8));
4200 warning (_("Breakpoint %d address previously adjusted from %s to %s."),
4201 bnum
, astr1
, astr2
);
4203 warning (_("Breakpoint address adjusted from %s to %s."), astr1
, astr2
);
4206 /* Adjust a breakpoint's address to account for architectural constraints
4207 on breakpoint placement. Return the adjusted address. Note: Very
4208 few targets require this kind of adjustment. For most targets,
4209 this function is simply the identity function. */
4212 adjust_breakpoint_address (CORE_ADDR bpaddr
, enum bptype bptype
)
4214 if (!gdbarch_adjust_breakpoint_address_p (current_gdbarch
))
4216 /* Very few targets need any kind of breakpoint adjustment. */
4219 else if (bptype
== bp_watchpoint
4220 || bptype
== bp_hardware_watchpoint
4221 || bptype
== bp_read_watchpoint
4222 || bptype
== bp_access_watchpoint
4223 || bptype
== bp_catch_fork
4224 || bptype
== bp_catch_vfork
4225 || bptype
== bp_catch_exec
)
4227 /* Watchpoints and the various bp_catch_* eventpoints should not
4228 have their addresses modified. */
4233 CORE_ADDR adjusted_bpaddr
;
4235 /* Some targets have architectural constraints on the placement
4236 of breakpoint instructions. Obtain the adjusted address. */
4237 adjusted_bpaddr
= gdbarch_adjust_breakpoint_address (current_gdbarch
,
4240 /* An adjusted breakpoint address can significantly alter
4241 a user's expectations. Print a warning if an adjustment
4243 if (adjusted_bpaddr
!= bpaddr
)
4244 breakpoint_adjustment_warning (bpaddr
, adjusted_bpaddr
, 0, 0);
4246 return adjusted_bpaddr
;
4250 /* Allocate a struct bp_location. */
4252 static struct bp_location
*
4253 allocate_bp_location (struct breakpoint
*bpt
, enum bptype bp_type
)
4255 struct bp_location
*loc
, *loc_p
;
4257 loc
= xmalloc (sizeof (struct bp_location
));
4258 memset (loc
, 0, sizeof (*loc
));
4262 loc
->shlib_disabled
= 0;
4271 case bp_longjmp_resume
:
4272 case bp_step_resume
:
4273 case bp_watchpoint_scope
:
4275 case bp_shlib_event
:
4276 case bp_thread_event
:
4277 case bp_overlay_event
:
4279 case bp_catch_unload
:
4280 loc
->loc_type
= bp_loc_software_breakpoint
;
4282 case bp_hardware_breakpoint
:
4283 loc
->loc_type
= bp_loc_hardware_breakpoint
;
4285 case bp_hardware_watchpoint
:
4286 case bp_read_watchpoint
:
4287 case bp_access_watchpoint
:
4288 loc
->loc_type
= bp_loc_hardware_watchpoint
;
4292 case bp_catch_vfork
:
4294 case bp_catch_catch
:
4295 case bp_catch_throw
:
4296 loc
->loc_type
= bp_loc_other
;
4299 internal_error (__FILE__
, __LINE__
, _("unknown breakpoint type"));
4302 /* Add this breakpoint to the end of the chain. */
4304 loc_p
= bp_location_chain
;
4306 bp_location_chain
= loc
;
4309 while (loc_p
->global_next
)
4310 loc_p
= loc_p
->global_next
;
4311 loc_p
->global_next
= loc
;
4317 static void free_bp_location (struct bp_location
*loc
)
4324 /* Helper to set_raw_breakpoint below. Creates a breakpoint
4325 that has type BPTYPE and has no locations as yet. */
4328 set_raw_breakpoint_without_location (enum bptype bptype
)
4330 struct breakpoint
*b
, *b1
;
4332 b
= (struct breakpoint
*) xmalloc (sizeof (struct breakpoint
));
4333 memset (b
, 0, sizeof (*b
));
4336 b
->language
= current_language
->la_language
;
4337 b
->input_radix
= input_radix
;
4339 b
->enable_state
= bp_enabled
;
4342 b
->ignore_count
= 0;
4344 b
->frame_id
= null_frame_id
;
4345 b
->dll_pathname
= NULL
;
4346 b
->triggered_dll_pathname
= NULL
;
4347 b
->forked_inferior_pid
= 0;
4348 b
->exec_pathname
= NULL
;
4350 b
->condition_not_parsed
= 0;
4352 /* Add this breakpoint to the end of the chain
4353 so that a list of breakpoints will come out in order
4354 of increasing numbers. */
4356 b1
= breakpoint_chain
;
4358 breakpoint_chain
= b
;
4368 /* Initialize loc->function_name. */
4370 set_breakpoint_location_function (struct bp_location
*loc
)
4372 if (loc
->owner
->type
== bp_breakpoint
4373 || loc
->owner
->type
== bp_hardware_breakpoint
)
4375 find_pc_partial_function (loc
->address
, &(loc
->function_name
),
4377 if (loc
->function_name
)
4378 loc
->function_name
= xstrdup (loc
->function_name
);
4382 /* set_raw_breakpoint is a low level routine for allocating and
4383 partially initializing a breakpoint of type BPTYPE. The newly
4384 created breakpoint's address, section, source file name, and line
4385 number are provided by SAL. The newly created and partially
4386 initialized breakpoint is added to the breakpoint chain and
4387 is also returned as the value of this function.
4389 It is expected that the caller will complete the initialization of
4390 the newly created breakpoint struct as well as output any status
4391 information regarding the creation of a new breakpoint. In
4392 particular, set_raw_breakpoint does NOT set the breakpoint
4393 number! Care should be taken to not allow an error to occur
4394 prior to completing the initialization of the breakpoint. If this
4395 should happen, a bogus breakpoint will be left on the chain. */
4398 set_raw_breakpoint (struct symtab_and_line sal
, enum bptype bptype
)
4400 struct breakpoint
*b
= set_raw_breakpoint_without_location (bptype
);
4401 CORE_ADDR adjusted_address
;
4403 /* Adjust the breakpoint's address prior to allocating a location.
4404 Once we call allocate_bp_location(), that mostly uninitialized
4405 location will be placed on the location chain. Adjustment of the
4406 breakpoint may cause read_memory_nobpt() to be called and we do
4407 not want its scan of the location chain to find a breakpoint and
4408 location that's only been partially initialized. */
4409 adjusted_address
= adjust_breakpoint_address (sal
.pc
, bptype
);
4411 b
->loc
= allocate_bp_location (b
, bptype
);
4412 b
->loc
->requested_address
= sal
.pc
;
4413 b
->loc
->address
= adjusted_address
;
4415 if (sal
.symtab
== NULL
)
4416 b
->source_file
= NULL
;
4418 b
->source_file
= savestring (sal
.symtab
->filename
,
4419 strlen (sal
.symtab
->filename
));
4420 b
->loc
->section
= sal
.section
;
4421 b
->line_number
= sal
.line
;
4423 set_breakpoint_location_function (b
->loc
);
4425 check_duplicates (b
);
4426 breakpoints_changed ();
4432 /* Note that the breakpoint object B describes a permanent breakpoint
4433 instruction, hard-wired into the inferior's code. */
4435 make_breakpoint_permanent (struct breakpoint
*b
)
4437 struct bp_location
*bl
;
4438 b
->enable_state
= bp_permanent
;
4440 /* By definition, permanent breakpoints are already present in the code.
4441 Mark all locations as inserted. For now, make_breakpoint_permanent
4442 is called in just one place, so it's hard to say if it's reasonable
4443 to have permanent breakpoint with multiple locations or not,
4444 but it's easy to implmement. */
4445 for (bl
= b
->loc
; bl
; bl
= bl
->next
)
4449 static struct breakpoint
*
4450 create_internal_breakpoint (CORE_ADDR address
, enum bptype type
)
4452 static int internal_breakpoint_number
= -1;
4453 struct symtab_and_line sal
;
4454 struct breakpoint
*b
;
4456 init_sal (&sal
); /* initialize to zeroes */
4459 sal
.section
= find_pc_overlay (sal
.pc
);
4461 b
= set_raw_breakpoint (sal
, type
);
4462 b
->number
= internal_breakpoint_number
--;
4463 b
->disposition
= disp_donttouch
;
4470 create_longjmp_breakpoint (char *func_name
)
4472 struct breakpoint
*b
;
4473 struct minimal_symbol
*m
;
4475 if (func_name
== NULL
)
4476 b
= create_internal_breakpoint (0, bp_longjmp_resume
);
4479 if ((m
= lookup_minimal_symbol_text (func_name
, NULL
)) == NULL
)
4482 b
= create_internal_breakpoint (SYMBOL_VALUE_ADDRESS (m
), bp_longjmp
);
4485 b
->enable_state
= bp_disabled
;
4488 b
->addr_string
= xstrdup (func_name
);
4491 /* Call this routine when stepping and nexting to enable a breakpoint
4492 if we do a longjmp(). When we hit that breakpoint, call
4493 set_longjmp_resume_breakpoint() to figure out where we are going. */
4496 enable_longjmp_breakpoint (void)
4498 struct breakpoint
*b
;
4501 if (b
->type
== bp_longjmp
)
4503 b
->enable_state
= bp_enabled
;
4504 check_duplicates (b
);
4509 disable_longjmp_breakpoint (void)
4511 struct breakpoint
*b
;
4514 if (b
->type
== bp_longjmp
4515 || b
->type
== bp_longjmp_resume
)
4517 b
->enable_state
= bp_disabled
;
4518 check_duplicates (b
);
4523 create_overlay_event_breakpoint (char *func_name
)
4525 struct breakpoint
*b
;
4526 struct minimal_symbol
*m
;
4528 if ((m
= lookup_minimal_symbol_text (func_name
, NULL
)) == NULL
)
4531 b
= create_internal_breakpoint (SYMBOL_VALUE_ADDRESS (m
),
4533 b
->addr_string
= xstrdup (func_name
);
4535 if (overlay_debugging
== ovly_auto
)
4537 b
->enable_state
= bp_enabled
;
4538 overlay_events_enabled
= 1;
4542 b
->enable_state
= bp_disabled
;
4543 overlay_events_enabled
= 0;
4548 enable_overlay_breakpoints (void)
4550 struct breakpoint
*b
;
4553 if (b
->type
== bp_overlay_event
)
4555 b
->enable_state
= bp_enabled
;
4556 check_duplicates (b
);
4557 overlay_events_enabled
= 1;
4562 disable_overlay_breakpoints (void)
4564 struct breakpoint
*b
;
4567 if (b
->type
== bp_overlay_event
)
4569 b
->enable_state
= bp_disabled
;
4570 check_duplicates (b
);
4571 overlay_events_enabled
= 0;
4576 create_thread_event_breakpoint (CORE_ADDR address
)
4578 struct breakpoint
*b
;
4580 b
= create_internal_breakpoint (address
, bp_thread_event
);
4582 b
->enable_state
= bp_enabled
;
4583 /* addr_string has to be used or breakpoint_re_set will delete me. */
4584 b
->addr_string
= xstrprintf ("*0x%s", paddr (b
->loc
->address
));
4590 remove_thread_event_breakpoints (void)
4592 struct breakpoint
*b
, *temp
;
4594 ALL_BREAKPOINTS_SAFE (b
, temp
)
4595 if (b
->type
== bp_thread_event
)
4596 delete_breakpoint (b
);
4599 struct captured_parse_breakpoint_args
4602 struct symtabs_and_lines
*sals_p
;
4603 char ***addr_string_p
;
4607 struct lang_and_radix
4615 remove_solib_event_breakpoints (void)
4617 struct breakpoint
*b
, *temp
;
4619 ALL_BREAKPOINTS_SAFE (b
, temp
)
4620 if (b
->type
== bp_shlib_event
)
4621 delete_breakpoint (b
);
4625 create_solib_event_breakpoint (CORE_ADDR address
)
4627 struct breakpoint
*b
;
4629 b
= create_internal_breakpoint (address
, bp_shlib_event
);
4633 /* Disable any breakpoints that are on code in shared libraries. Only
4634 apply to enabled breakpoints, disabled ones can just stay disabled. */
4637 disable_breakpoints_in_shlibs (void)
4639 struct bp_location
*loc
;
4640 int disabled_shlib_breaks
= 0;
4642 ALL_BP_LOCATIONS (loc
)
4644 struct breakpoint
*b
= loc
->owner
;
4645 /* We apply the check to all breakpoints, including disabled
4646 for those with loc->duplicate set. This is so that when breakpoint
4647 becomes enabled, or the duplicate is removed, gdb will try to insert
4648 all breakpoints. If we don't set shlib_disabled here, we'll try
4649 to insert those breakpoints and fail. */
4650 if (((b
->type
== bp_breakpoint
) || (b
->type
== bp_hardware_breakpoint
))
4651 && !loc
->shlib_disabled
4653 && PC_SOLIB (loc
->address
)
4655 && solib_address (loc
->address
)
4659 loc
->shlib_disabled
= 1;
4664 /* Disable any breakpoints that are in in an unloaded shared library. Only
4665 apply to enabled breakpoints, disabled ones can just stay disabled. */
4668 disable_breakpoints_in_unloaded_shlib (struct so_list
*solib
)
4670 struct bp_location
*loc
;
4671 int disabled_shlib_breaks
= 0;
4673 ALL_BP_LOCATIONS (loc
)
4675 struct breakpoint
*b
= loc
->owner
;
4676 if ((loc
->loc_type
== bp_loc_hardware_breakpoint
4677 || loc
->loc_type
== bp_loc_software_breakpoint
)
4678 && !loc
->shlib_disabled
)
4681 char *so_name
= PC_SOLIB (loc
->address
);
4683 char *so_name
= solib_address (loc
->address
);
4685 if (so_name
&& !strcmp (so_name
, solib
->so_name
))
4687 loc
->shlib_disabled
= 1;
4688 /* At this point, we cannot rely on remove_breakpoint
4689 succeeding so we must mark the breakpoint as not inserted
4690 to prevent future errors occurring in remove_breakpoints. */
4692 if (!disabled_shlib_breaks
)
4694 target_terminal_ours_for_output ();
4695 warning (_("Temporarily disabling breakpoints for unloaded shared library \"%s\""),
4698 disabled_shlib_breaks
= 1;
4705 solib_load_unload_1 (char *hookname
, int tempflag
, char *dll_pathname
,
4706 char *cond_string
, enum bptype bp_kind
)
4708 struct breakpoint
*b
;
4709 struct symtabs_and_lines sals
;
4710 struct cleanup
*old_chain
;
4711 struct cleanup
*canonical_strings_chain
= NULL
;
4712 char *addr_start
= hookname
;
4713 char *addr_end
= NULL
;
4714 char **canonical
= (char **) NULL
;
4715 int thread
= -1; /* All threads. */
4717 /* Set a breakpoint on the specified hook. */
4718 sals
= decode_line_1 (&hookname
, 1, (struct symtab
*) NULL
,
4719 0, &canonical
, NULL
);
4720 addr_end
= hookname
;
4722 if (sals
.nelts
== 0)
4724 warning (_("Unable to set a breakpoint on dynamic linker callback.\n"
4725 "Suggest linking with /opt/langtools/lib/end.o.\n"
4726 "GDB will be unable to track shl_load/shl_unload calls."));
4729 if (sals
.nelts
!= 1)
4731 warning (_("Unable to set unique breakpoint on dynamic linker callback.\n"
4732 "GDB will be unable to track shl_load/shl_unload calls."));
4736 /* Make sure that all storage allocated in decode_line_1 gets freed
4737 in case the following errors out. */
4738 old_chain
= make_cleanup (xfree
, sals
.sals
);
4739 if (canonical
!= (char **) NULL
)
4741 make_cleanup (xfree
, canonical
);
4742 canonical_strings_chain
= make_cleanup (null_cleanup
, 0);
4743 if (canonical
[0] != NULL
)
4744 make_cleanup (xfree
, canonical
[0]);
4747 resolve_sal_pc (&sals
.sals
[0]);
4749 /* Remove the canonical strings from the cleanup, they are needed below. */
4750 if (canonical
!= (char **) NULL
)
4751 discard_cleanups (canonical_strings_chain
);
4753 b
= set_raw_breakpoint (sals
.sals
[0], bp_kind
);
4754 set_breakpoint_count (breakpoint_count
+ 1);
4755 b
->number
= breakpoint_count
;
4756 b
->cond_string
= (cond_string
== NULL
) ?
4757 NULL
: savestring (cond_string
, strlen (cond_string
));
4760 if (canonical
!= (char **) NULL
&& canonical
[0] != NULL
)
4761 b
->addr_string
= canonical
[0];
4762 else if (addr_start
)
4763 b
->addr_string
= savestring (addr_start
, addr_end
- addr_start
);
4765 b
->enable_state
= bp_enabled
;
4766 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
4768 if (dll_pathname
== NULL
)
4769 b
->dll_pathname
= NULL
;
4772 b
->dll_pathname
= (char *) xmalloc (strlen (dll_pathname
) + 1);
4773 strcpy (b
->dll_pathname
, dll_pathname
);
4777 do_cleanups (old_chain
);
4781 create_solib_load_event_breakpoint (char *hookname
, int tempflag
,
4782 char *dll_pathname
, char *cond_string
)
4784 solib_load_unload_1 (hookname
, tempflag
, dll_pathname
,
4785 cond_string
, bp_catch_load
);
4789 create_solib_unload_event_breakpoint (char *hookname
, int tempflag
,
4790 char *dll_pathname
, char *cond_string
)
4792 solib_load_unload_1 (hookname
, tempflag
, dll_pathname
,
4793 cond_string
, bp_catch_unload
);
4797 create_fork_vfork_event_catchpoint (int tempflag
, char *cond_string
,
4798 enum bptype bp_kind
)
4800 struct symtab_and_line sal
;
4801 struct breakpoint
*b
;
4802 int thread
= -1; /* All threads. */
4809 b
= set_raw_breakpoint (sal
, bp_kind
);
4810 set_breakpoint_count (breakpoint_count
+ 1);
4811 b
->number
= breakpoint_count
;
4812 b
->cond_string
= (cond_string
== NULL
) ?
4813 NULL
: savestring (cond_string
, strlen (cond_string
));
4815 b
->addr_string
= NULL
;
4816 b
->enable_state
= bp_enabled
;
4817 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
4818 b
->forked_inferior_pid
= 0;
4824 create_fork_event_catchpoint (int tempflag
, char *cond_string
)
4826 create_fork_vfork_event_catchpoint (tempflag
, cond_string
, bp_catch_fork
);
4830 create_vfork_event_catchpoint (int tempflag
, char *cond_string
)
4832 create_fork_vfork_event_catchpoint (tempflag
, cond_string
, bp_catch_vfork
);
4836 create_exec_event_catchpoint (int tempflag
, char *cond_string
)
4838 struct symtab_and_line sal
;
4839 struct breakpoint
*b
;
4840 int thread
= -1; /* All threads. */
4847 b
= set_raw_breakpoint (sal
, bp_catch_exec
);
4848 set_breakpoint_count (breakpoint_count
+ 1);
4849 b
->number
= breakpoint_count
;
4850 b
->cond_string
= (cond_string
== NULL
) ?
4851 NULL
: savestring (cond_string
, strlen (cond_string
));
4853 b
->addr_string
= NULL
;
4854 b
->enable_state
= bp_enabled
;
4855 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
4861 hw_breakpoint_used_count (void)
4863 struct breakpoint
*b
;
4868 if (b
->type
== bp_hardware_breakpoint
&& b
->enable_state
== bp_enabled
)
4876 hw_watchpoint_used_count (enum bptype type
, int *other_type_used
)
4878 struct breakpoint
*b
;
4881 *other_type_used
= 0;
4884 if (breakpoint_enabled (b
))
4886 if (b
->type
== type
)
4888 else if ((b
->type
== bp_hardware_watchpoint
||
4889 b
->type
== bp_read_watchpoint
||
4890 b
->type
== bp_access_watchpoint
))
4891 *other_type_used
= 1;
4897 /* Call this after hitting the longjmp() breakpoint. Use this to set
4898 a new breakpoint at the target of the jmp_buf.
4900 FIXME - This ought to be done by setting a temporary breakpoint
4901 that gets deleted automatically... */
4904 set_longjmp_resume_breakpoint (CORE_ADDR pc
, struct frame_id frame_id
)
4906 struct breakpoint
*b
;
4909 if (b
->type
== bp_longjmp_resume
)
4911 b
->loc
->requested_address
= pc
;
4912 b
->loc
->address
= adjust_breakpoint_address (b
->loc
->requested_address
,
4914 b
->enable_state
= bp_enabled
;
4915 b
->frame_id
= frame_id
;
4916 check_duplicates (b
);
4922 disable_watchpoints_before_interactive_call_start (void)
4924 struct breakpoint
*b
;
4928 if (((b
->type
== bp_watchpoint
)
4929 || (b
->type
== bp_hardware_watchpoint
)
4930 || (b
->type
== bp_read_watchpoint
)
4931 || (b
->type
== bp_access_watchpoint
)
4932 || ep_is_exception_catchpoint (b
))
4933 && breakpoint_enabled (b
))
4935 b
->enable_state
= bp_call_disabled
;
4936 check_duplicates (b
);
4942 enable_watchpoints_after_interactive_call_stop (void)
4944 struct breakpoint
*b
;
4948 if (((b
->type
== bp_watchpoint
)
4949 || (b
->type
== bp_hardware_watchpoint
)
4950 || (b
->type
== bp_read_watchpoint
)
4951 || (b
->type
== bp_access_watchpoint
)
4952 || ep_is_exception_catchpoint (b
))
4953 && (b
->enable_state
== bp_call_disabled
))
4955 b
->enable_state
= bp_enabled
;
4956 check_duplicates (b
);
4962 /* Set a breakpoint that will evaporate an end of command
4963 at address specified by SAL.
4964 Restrict it to frame FRAME if FRAME is nonzero. */
4967 set_momentary_breakpoint (struct symtab_and_line sal
, struct frame_id frame_id
,
4970 struct breakpoint
*b
;
4971 b
= set_raw_breakpoint (sal
, type
);
4972 b
->enable_state
= bp_enabled
;
4973 b
->disposition
= disp_donttouch
;
4974 b
->frame_id
= frame_id
;
4976 /* If we're debugging a multi-threaded program, then we
4977 want momentary breakpoints to be active in only a
4978 single thread of control. */
4979 if (in_thread_list (inferior_ptid
))
4980 b
->thread
= pid_to_thread_id (inferior_ptid
);
4986 /* Tell the user we have just set a breakpoint B. */
4989 mention (struct breakpoint
*b
)
4992 struct cleanup
*old_chain
, *ui_out_chain
;
4993 struct ui_stream
*stb
;
4995 stb
= ui_out_stream_new (uiout
);
4996 old_chain
= make_cleanup_ui_out_stream_delete (stb
);
4998 /* FIXME: This is misplaced; mention() is called by things (like
4999 hitting a watchpoint) other than breakpoint creation. It should
5000 be possible to clean this up and at the same time replace the
5001 random calls to breakpoint_changed with this hook, as has already
5002 been done for deprecated_delete_breakpoint_hook and so on. */
5003 if (deprecated_create_breakpoint_hook
)
5004 deprecated_create_breakpoint_hook (b
);
5005 breakpoint_create_event (b
->number
);
5007 if (b
->ops
!= NULL
&& b
->ops
->print_mention
!= NULL
)
5008 b
->ops
->print_mention (b
);
5013 printf_filtered (_("(apparently deleted?) Eventpoint %d: "), b
->number
);
5016 ui_out_text (uiout
, "Watchpoint ");
5017 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "wpt");
5018 ui_out_field_int (uiout
, "number", b
->number
);
5019 ui_out_text (uiout
, ": ");
5020 print_expression (b
->exp
, stb
->stream
);
5021 ui_out_field_stream (uiout
, "exp", stb
);
5022 do_cleanups (ui_out_chain
);
5024 case bp_hardware_watchpoint
:
5025 ui_out_text (uiout
, "Hardware watchpoint ");
5026 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "wpt");
5027 ui_out_field_int (uiout
, "number", b
->number
);
5028 ui_out_text (uiout
, ": ");
5029 print_expression (b
->exp
, stb
->stream
);
5030 ui_out_field_stream (uiout
, "exp", stb
);
5031 do_cleanups (ui_out_chain
);
5033 case bp_read_watchpoint
:
5034 ui_out_text (uiout
, "Hardware read watchpoint ");
5035 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "hw-rwpt");
5036 ui_out_field_int (uiout
, "number", b
->number
);
5037 ui_out_text (uiout
, ": ");
5038 print_expression (b
->exp
, stb
->stream
);
5039 ui_out_field_stream (uiout
, "exp", stb
);
5040 do_cleanups (ui_out_chain
);
5042 case bp_access_watchpoint
:
5043 ui_out_text (uiout
, "Hardware access (read/write) watchpoint ");
5044 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "hw-awpt");
5045 ui_out_field_int (uiout
, "number", b
->number
);
5046 ui_out_text (uiout
, ": ");
5047 print_expression (b
->exp
, stb
->stream
);
5048 ui_out_field_stream (uiout
, "exp", stb
);
5049 do_cleanups (ui_out_chain
);
5052 if (ui_out_is_mi_like_p (uiout
))
5057 printf_filtered (_("Breakpoint %d"), b
->number
);
5060 case bp_hardware_breakpoint
:
5061 if (ui_out_is_mi_like_p (uiout
))
5066 printf_filtered (_("Hardware assisted breakpoint %d"), b
->number
);
5070 case bp_catch_unload
:
5071 printf_filtered (_("Catchpoint %d (%s %s)"),
5073 (b
->type
== bp_catch_load
) ? "load" : "unload",
5074 (b
->dll_pathname
!= NULL
) ?
5075 b
->dll_pathname
: "<any library>");
5078 case bp_catch_vfork
:
5079 printf_filtered (_("Catchpoint %d (%s)"),
5081 (b
->type
== bp_catch_fork
) ? "fork" : "vfork");
5084 printf_filtered (_("Catchpoint %d (exec)"),
5087 case bp_catch_catch
:
5088 case bp_catch_throw
:
5089 printf_filtered (_("Catchpoint %d (%s)"),
5091 (b
->type
== bp_catch_catch
) ? "catch" : "throw");
5097 case bp_longjmp_resume
:
5098 case bp_step_resume
:
5100 case bp_watchpoint_scope
:
5101 case bp_shlib_event
:
5102 case bp_thread_event
:
5103 case bp_overlay_event
:
5109 /* i18n: cagney/2005-02-11: Below needs to be merged into a
5113 printf_filtered (_(" (%s) pending."), b
->addr_string
);
5117 if (addressprint
|| b
->source_file
== NULL
)
5119 printf_filtered (" at ");
5120 deprecated_print_address_numeric (b
->loc
->address
, 1, gdb_stdout
);
5123 printf_filtered (": file %s, line %d.",
5124 b
->source_file
, b
->line_number
);
5128 struct bp_location
*loc
= b
->loc
;
5130 for (; loc
; loc
= loc
->next
)
5132 printf_filtered (" (%d locations)", n
);
5137 do_cleanups (old_chain
);
5138 if (ui_out_is_mi_like_p (uiout
))
5140 printf_filtered ("\n");
5144 static struct bp_location
*
5145 add_location_to_breakpoint (struct breakpoint
*b
, enum bptype bptype
,
5146 const struct symtab_and_line
*sal
)
5148 struct bp_location
*loc
, **tmp
;
5150 loc
= allocate_bp_location (b
, bptype
);
5151 for (tmp
= &(b
->loc
); *tmp
!= NULL
; tmp
= &((*tmp
)->next
))
5154 loc
->requested_address
= sal
->pc
;
5155 loc
->address
= adjust_breakpoint_address (loc
->requested_address
,
5157 loc
->section
= sal
->section
;
5159 set_breakpoint_location_function (loc
);
5163 /* Create a breakpoint with SAL as location. Use ADDR_STRING
5164 as textual description of the location, and COND_STRING
5165 as condition expression.
5167 The paramter PENDING_BP is same as for the
5168 create_breakpoints function. */
5171 create_breakpoint (struct symtabs_and_lines sals
, char *addr_string
,
5173 enum bptype type
, enum bpdisp disposition
,
5174 int thread
, int ignore_count
, int from_tty
,
5175 struct breakpoint
*pending_bp
)
5177 struct breakpoint
*b
= NULL
;
5180 if (type
== bp_hardware_breakpoint
)
5182 int i
= hw_breakpoint_used_count ();
5183 int target_resources_ok
=
5184 TARGET_CAN_USE_HARDWARE_WATCHPOINT (bp_hardware_breakpoint
,
5186 if (target_resources_ok
== 0)
5187 error (_("No hardware breakpoint support in the target."));
5188 else if (target_resources_ok
< 0)
5189 error (_("Hardware breakpoints used exceeds limit."));
5192 for (i
= 0; i
< sals
.nelts
; ++i
)
5194 struct symtab_and_line sal
= sals
.sals
[i
];
5195 struct bp_location
*loc
;
5198 describe_other_breakpoints (sal
.pc
, sal
.section
, thread
);
5202 b
= set_raw_breakpoint (sal
, type
);
5203 set_breakpoint_count (breakpoint_count
+ 1);
5204 b
->number
= breakpoint_count
;
5207 b
->cond_string
= cond_string
;
5208 b
->ignore_count
= ignore_count
;
5209 b
->enable_state
= bp_enabled
;
5210 b
->disposition
= disposition
;
5216 loc
= add_location_to_breakpoint (b
, type
, &sal
);
5221 char *arg
= b
->cond_string
;
5222 loc
->cond
= parse_exp_1 (&arg
, block_for_pc (loc
->address
), 0);
5226 error (_("Junk at end of pending breakpoint condition expression"));
5228 error (_("Garbage %s follows condition"), arg
);
5234 b
->addr_string
= addr_string
;
5236 /* addr_string has to be used or breakpoint_re_set will delete
5238 b
->addr_string
= xstrprintf ("*0x%s", paddr (b
->loc
->address
));
5243 /* Remove element at INDEX_TO_REMOVE from SAL, shifting other
5244 elements to fill the void space. */
5245 static void remove_sal (struct symtabs_and_lines
*sal
, int index_to_remove
)
5247 int i
= index_to_remove
+1;
5248 int last_index
= sal
->nelts
-1;
5250 for (;i
<= last_index
; ++i
)
5251 sal
->sals
[i
-1] = sal
->sals
[i
];
5256 /* If appropriate, obtains all sals that correspond
5257 to the same file and line as SAL. This is done
5258 only if SAL does not have explicit PC and has
5259 line and file information. If we got just a single
5260 expanded sal, return the original.
5262 Otherwise, if SAL.explicit_line is not set, filter out
5263 all sals for which the name of enclosing function
5264 is different from SAL. This makes sure that if we have
5265 breakpoint originally set in template instantiation, say
5266 foo<int>(), we won't expand SAL to locations at the same
5267 line in all existing instantiations of 'foo'.
5270 struct symtabs_and_lines
5271 expand_line_sal_maybe (struct symtab_and_line sal
)
5273 struct symtabs_and_lines expanded
;
5274 CORE_ADDR original_pc
= sal
.pc
;
5275 char *original_function
= NULL
;
5279 /* If we have explicit pc, don't expand.
5280 If we have no line number, we can't expand. */
5281 if (sal
.explicit_pc
|| sal
.line
== 0 || sal
.symtab
== NULL
)
5284 expanded
.sals
= xmalloc (sizeof (struct symtab_and_line
));
5285 expanded
.sals
[0] = sal
;
5290 find_pc_partial_function (original_pc
, &original_function
, NULL
, NULL
);
5292 expanded
= expand_line_sal (sal
);
5293 if (expanded
.nelts
== 1)
5295 /* We had one sal, we got one sal. Without futher
5296 processing, just return the original sal. */
5297 xfree (expanded
.sals
);
5299 expanded
.sals
= xmalloc (sizeof (struct symtab_and_line
));
5300 sal
.pc
= original_pc
;
5301 expanded
.sals
[0] = sal
;
5305 if (!sal
.explicit_line
)
5307 CORE_ADDR func_addr
, func_end
;
5308 for (i
= 0; i
< expanded
.nelts
; ++i
)
5310 CORE_ADDR pc
= expanded
.sals
[i
].pc
;
5311 char *this_function
;
5312 if (find_pc_partial_function (pc
, &this_function
,
5313 &func_addr
, &func_end
))
5315 if (this_function
&&
5316 strcmp (this_function
, original_function
) != 0)
5318 remove_sal (&expanded
, i
);
5321 else if (func_addr
== pc
)
5323 /* We're at beginning of a function, and should
5325 struct symbol
*sym
= find_pc_function (pc
);
5327 expanded
.sals
[i
] = find_function_start_sal (sym
, 1);
5330 = gdbarch_skip_prologue (current_gdbarch
, pc
);
5337 if (expanded
.nelts
<= 1)
5339 /* This is un ugly workaround. If we get zero
5340 expanded sals then something is really wrong.
5341 Fix that by returnign the original sal. */
5342 xfree (expanded
.sals
);
5344 expanded
.sals
= xmalloc (sizeof (struct symtab_and_line
));
5345 sal
.pc
= original_pc
;
5346 expanded
.sals
[0] = sal
;
5353 for (i
= 0; i
< expanded
.nelts
; ++i
)
5354 if (expanded
.sals
[i
].pc
== original_pc
)
5365 /* Add SALS.nelts breakpoints to the breakpoint table. For each
5366 SALS.sal[i] breakpoint, include the corresponding ADDR_STRING[i]
5367 value. COND_STRING, if not NULL, specified the condition to be
5368 used for all breakpoints. Essentially the only case where
5369 SALS.nelts is not 1 is when we set a breakpoint on an overloaded
5370 function. In that case, it's still not possible to specify
5371 separate conditions for different overloaded functions, so
5372 we take just a single condition string.
5374 The parameter PENDING_BP points to a pending breakpoint that is
5375 the basis of the breakpoints currently being created. The pending
5376 breakpoint may contain a separate condition string or commands
5377 that were added after the initial pending breakpoint was created.
5379 NOTE: If the function succeeds, the caller is expected to cleanup
5380 the arrays ADDR_STRING, COND_STRING, and SALS (but not the
5381 array contents). If the function fails (error() is called), the
5382 caller is expected to cleanups both the ADDR_STRING, COND_STRING,
5383 COND and SALS arrays and each of those arrays contents. */
5386 create_breakpoints (struct symtabs_and_lines sals
, char **addr_string
,
5388 enum bptype type
, enum bpdisp disposition
,
5389 int thread
, int ignore_count
, int from_tty
,
5390 struct breakpoint
*pending_bp
)
5393 for (i
= 0; i
< sals
.nelts
; ++i
)
5395 struct symtabs_and_lines expanded
=
5396 expand_line_sal_maybe (sals
.sals
[i
]);
5398 create_breakpoint (expanded
, addr_string
[i
],
5399 cond_string
, type
, disposition
,
5400 thread
, ignore_count
, from_tty
,
5405 /* Parse ARG which is assumed to be a SAL specification possibly
5406 followed by conditionals. On return, SALS contains an array of SAL
5407 addresses found. ADDR_STRING contains a vector of (canonical)
5408 address strings. ARG points to the end of the SAL. */
5411 parse_breakpoint_sals (char **address
,
5412 struct symtabs_and_lines
*sals
,
5413 char ***addr_string
,
5416 char *addr_start
= *address
;
5417 *addr_string
= NULL
;
5418 /* If no arg given, or if first arg is 'if ', use the default
5420 if ((*address
) == NULL
5421 || (strncmp ((*address
), "if", 2) == 0 && isspace ((*address
)[2])))
5423 if (default_breakpoint_valid
)
5425 struct symtab_and_line sal
;
5426 init_sal (&sal
); /* initialize to zeroes */
5427 sals
->sals
= (struct symtab_and_line
*)
5428 xmalloc (sizeof (struct symtab_and_line
));
5429 sal
.pc
= default_breakpoint_address
;
5430 sal
.line
= default_breakpoint_line
;
5431 sal
.symtab
= default_breakpoint_symtab
;
5432 sal
.section
= find_pc_overlay (sal
.pc
);
5433 sals
->sals
[0] = sal
;
5437 error (_("No default breakpoint address now."));
5441 /* Force almost all breakpoints to be in terms of the
5442 current_source_symtab (which is decode_line_1's default). This
5443 should produce the results we want almost all of the time while
5444 leaving default_breakpoint_* alone.
5445 ObjC: However, don't match an Objective-C method name which
5446 may have a '+' or '-' succeeded by a '[' */
5448 struct symtab_and_line cursal
= get_current_source_symtab_and_line ();
5450 if (default_breakpoint_valid
5452 || ((strchr ("+-", (*address
)[0]) != NULL
)
5453 && ((*address
)[1] != '['))))
5454 *sals
= decode_line_1 (address
, 1, default_breakpoint_symtab
,
5455 default_breakpoint_line
, addr_string
,
5458 *sals
= decode_line_1 (address
, 1, (struct symtab
*) NULL
, 0,
5459 addr_string
, not_found_ptr
);
5461 /* For any SAL that didn't have a canonical string, fill one in. */
5462 if (sals
->nelts
> 0 && *addr_string
== NULL
)
5463 *addr_string
= xcalloc (sals
->nelts
, sizeof (char **));
5464 if (addr_start
!= (*address
))
5467 for (i
= 0; i
< sals
->nelts
; i
++)
5469 /* Add the string if not present. */
5470 if ((*addr_string
)[i
] == NULL
)
5471 (*addr_string
)[i
] = savestring (addr_start
, (*address
) - addr_start
);
5477 /* Convert each SAL into a real PC. Verify that the PC can be
5478 inserted as a breakpoint. If it can't throw an error. */
5481 breakpoint_sals_to_pc (struct symtabs_and_lines
*sals
,
5485 for (i
= 0; i
< sals
->nelts
; i
++)
5486 resolve_sal_pc (&sals
->sals
[i
]);
5490 do_captured_parse_breakpoint (struct ui_out
*ui
, void *data
)
5492 struct captured_parse_breakpoint_args
*args
= data
;
5494 parse_breakpoint_sals (args
->arg_p
, args
->sals_p
, args
->addr_string_p
,
5495 args
->not_found_ptr
);
5498 /* Given TOK, a string specification of condition and thread, as
5499 accepted by the 'break' command, extract the condition
5500 string and thread number and set *COND_STRING and *THREAD.
5501 PC identifies the context at which the condition should be parsed.
5502 If no condition is found, *COND_STRING is set to NULL.
5503 If no thread is found, *THREAD is set to -1. */
5505 find_condition_and_thread (char *tok
, CORE_ADDR pc
,
5506 char **cond_string
, int *thread
)
5508 *cond_string
= NULL
;
5514 char *cond_start
= NULL
;
5515 char *cond_end
= NULL
;
5516 while (*tok
== ' ' || *tok
== '\t')
5521 while (*end_tok
!= ' ' && *end_tok
!= '\t' && *end_tok
!= '\000')
5524 toklen
= end_tok
- tok
;
5526 if (toklen
>= 1 && strncmp (tok
, "if", toklen
) == 0)
5528 tok
= cond_start
= end_tok
+ 1;
5529 parse_exp_1 (&tok
, block_for_pc (pc
), 0);
5531 *cond_string
= savestring (cond_start
,
5532 cond_end
- cond_start
);
5534 else if (toklen
>= 1 && strncmp (tok
, "thread", toklen
) == 0)
5540 *thread
= strtol (tok
, &tok
, 0);
5542 error (_("Junk after thread keyword."));
5543 if (!valid_thread_id (*thread
))
5544 error (_("Unknown thread %d."), *thread
);
5547 error (_("Junk at end of arguments."));
5551 /* Set a breakpoint according to ARG (function, linenum or *address)
5552 flag: first bit : 0 non-temporary, 1 temporary.
5553 second bit : 0 normal breakpoint, 1 hardware breakpoint.
5555 PENDING_BP is non-NULL when this function is being called to resolve
5556 a pending breakpoint. */
5559 break_command_1 (char *arg
, int flag
, int from_tty
, struct breakpoint
*pending_bp
)
5561 struct gdb_exception e
;
5562 int tempflag
, hardwareflag
;
5563 struct symtabs_and_lines sals
;
5564 struct symtab_and_line pending_sal
;
5565 char *cond_string
= NULL
;
5568 char *addr_start
= arg
;
5570 struct cleanup
*old_chain
;
5571 struct cleanup
*breakpoint_chain
= NULL
;
5572 struct captured_parse_breakpoint_args parse_args
;
5576 int ignore_count
= 0;
5579 hardwareflag
= flag
& BP_HARDWAREFLAG
;
5580 tempflag
= flag
& BP_TEMPFLAG
;
5586 parse_args
.arg_p
= &arg
;
5587 parse_args
.sals_p
= &sals
;
5588 parse_args
.addr_string_p
= &addr_string
;
5589 parse_args
.not_found_ptr
= ¬_found
;
5591 e
= catch_exception (uiout
, do_captured_parse_breakpoint
,
5592 &parse_args
, RETURN_MASK_ALL
);
5594 /* If caller is interested in rc value from parse, set value. */
5598 exception_print (gdb_stderr
, e
);
5603 case NOT_FOUND_ERROR
:
5604 /* If called to resolve pending breakpoint, just return
5609 exception_print (gdb_stderr
, e
);
5611 /* If pending breakpoint support is turned off, throw
5614 if (pending_break_support
== AUTO_BOOLEAN_FALSE
)
5615 deprecated_throw_reason (RETURN_ERROR
);
5617 /* If pending breakpoint support is auto query and the user
5618 selects no, then simply return the error code. */
5619 if (pending_break_support
== AUTO_BOOLEAN_AUTO
&&
5620 !nquery ("Make breakpoint pending on future shared library load? "))
5623 /* At this point, either the user was queried about setting
5624 a pending breakpoint and selected yes, or pending
5625 breakpoint behavior is on and thus a pending breakpoint
5626 is defaulted on behalf of the user. */
5627 copy_arg
= xstrdup (addr_start
);
5628 addr_string
= ©_arg
;
5630 sals
.sals
= &pending_sal
;
5635 exception_print (gdb_stderr
, e
);
5643 /* Create a chain of things that always need to be cleaned up. */
5644 old_chain
= make_cleanup (null_cleanup
, 0);
5648 /* Make sure that all storage allocated to SALS gets freed. */
5649 make_cleanup (xfree
, sals
.sals
);
5651 /* Cleanup the addr_string array but not its contents. */
5652 make_cleanup (xfree
, addr_string
);
5655 /* ----------------------------- SNIP -----------------------------
5656 Anything added to the cleanup chain beyond this point is assumed
5657 to be part of a breakpoint. If the breakpoint create succeeds
5658 then the memory is not reclaimed. */
5659 breakpoint_chain
= make_cleanup (null_cleanup
, 0);
5661 /* Mark the contents of the addr_string for cleanup. These go on
5662 the breakpoint_chain and only occure if the breakpoint create
5664 for (i
= 0; i
< sals
.nelts
; i
++)
5666 if (addr_string
[i
] != NULL
)
5667 make_cleanup (xfree
, addr_string
[i
]);
5670 /* Resolve all line numbers to PC's and verify that the addresses
5671 are ok for the target. */
5673 breakpoint_sals_to_pc (&sals
, addr_start
);
5675 /* Verify that condition can be parsed, before setting any
5676 breakpoints. Allocate a separate condition expression for each
5680 /* Here we only parse 'arg' to separate condition
5681 from thread number, so parsing in context of first
5682 sal is OK. When setting the breakpoint we'll
5683 re-parse it in context of each sal. */
5684 find_condition_and_thread (arg
, sals
.sals
[0].pc
, &cond_string
, &thread
);
5686 make_cleanup (xfree
, cond_string
);
5687 create_breakpoints (sals
, addr_string
, cond_string
,
5688 hardwareflag
? bp_hardware_breakpoint
5690 tempflag
? disp_del
: disp_donttouch
,
5691 thread
, ignore_count
, from_tty
,
5696 struct symtab_and_line sal
= {0};
5697 struct breakpoint
*b
;
5699 make_cleanup (xfree
, copy_arg
);
5701 b
= set_raw_breakpoint_without_location (hardwareflag
5702 ? bp_hardware_breakpoint
5704 set_breakpoint_count (breakpoint_count
+ 1);
5705 b
->number
= breakpoint_count
;
5707 b
->addr_string
= addr_string
[0];
5708 b
->cond_string
= cond_string
;
5709 b
->ignore_count
= ignore_count
;
5710 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
5711 b
->from_tty
= from_tty
;
5713 b
->condition_not_parsed
= 1;
5718 warning (_("Multiple breakpoints were set.\n"
5719 "Use the \"delete\" command to delete unwanted breakpoints."));
5720 /* That's it. Discard the cleanups for data inserted into the
5722 discard_cleanups (breakpoint_chain
);
5723 /* But cleanup everything else. */
5724 do_cleanups (old_chain
);
5729 /* Set a breakpoint of TYPE/DISPOSITION according to ARG (function,
5730 linenum or *address) with COND and IGNORE_COUNT. */
5732 struct captured_breakpoint_args
5743 do_captured_breakpoint (struct ui_out
*uiout
, void *data
)
5745 struct captured_breakpoint_args
*args
= data
;
5746 struct symtabs_and_lines sals
;
5747 struct expression
**cond
;
5748 struct cleanup
*old_chain
;
5749 struct cleanup
*breakpoint_chain
= NULL
;
5752 char *cond_string
= 0;
5756 /* Parse the source and lines spec. Delay check that the expression
5757 didn't contain trailing garbage until after cleanups are in
5761 address_end
= args
->address
;
5763 parse_breakpoint_sals (&address_end
, &sals
, &addr_string
, 0);
5768 /* Create a chain of things at always need to be cleaned up. */
5769 old_chain
= make_cleanup (null_cleanup
, 0);
5771 /* Always have a addr_string array, even if it is empty. */
5772 make_cleanup (xfree
, addr_string
);
5774 /* Make sure that all storage allocated to SALS gets freed. */
5775 make_cleanup (xfree
, sals
.sals
);
5777 /* Allocate space for all the cond expressions. */
5778 cond
= xcalloc (sals
.nelts
, sizeof (struct expression
*));
5779 make_cleanup (xfree
, cond
);
5781 /* ----------------------------- SNIP -----------------------------
5782 Anything added to the cleanup chain beyond this point is assumed
5783 to be part of a breakpoint. If the breakpoint create goes
5784 through then that memory is not cleaned up. */
5785 breakpoint_chain
= make_cleanup (null_cleanup
, 0);
5787 /* Mark the contents of the addr_string for cleanup. These go on
5788 the breakpoint_chain and only occure if the breakpoint create
5790 for (i
= 0; i
< sals
.nelts
; i
++)
5792 if (addr_string
[i
] != NULL
)
5793 make_cleanup (xfree
, addr_string
[i
]);
5796 /* Wait until now before checking for garbage at the end of the
5797 address. That way cleanups can take care of freeing any
5799 if (*address_end
!= '\0')
5800 error (_("Garbage %s following breakpoint address"), address_end
);
5802 /* Resolve all line numbers to PC's. */
5803 breakpoint_sals_to_pc (&sals
, args
->address
);
5805 if (args
->condition
!= NULL
)
5807 cond_string
= xstrdup (args
->condition
);
5808 make_cleanup (xfree
, cond_string
);
5811 create_breakpoints (sals
, addr_string
, args
->condition
,
5812 args
->hardwareflag
? bp_hardware_breakpoint
: bp_breakpoint
,
5813 args
->tempflag
? disp_del
: disp_donttouch
,
5814 args
->thread
, args
->ignore_count
, 0/*from-tty*/,
5815 NULL
/*pending_bp*/);
5817 /* That's it. Discard the cleanups for data inserted into the
5819 discard_cleanups (breakpoint_chain
);
5820 /* But cleanup everything else. */
5821 do_cleanups (old_chain
);
5826 gdb_breakpoint (char *address
, char *condition
,
5827 int hardwareflag
, int tempflag
,
5828 int thread
, int ignore_count
,
5829 char **error_message
)
5831 struct captured_breakpoint_args args
;
5832 args
.address
= address
;
5833 args
.condition
= condition
;
5834 args
.hardwareflag
= hardwareflag
;
5835 args
.tempflag
= tempflag
;
5836 args
.thread
= thread
;
5837 args
.ignore_count
= ignore_count
;
5838 if (catch_exceptions_with_msg (uiout
, do_captured_breakpoint
, &args
,
5839 error_message
, RETURN_MASK_ALL
) < 0)
5846 /* Helper function for break_command_1 and disassemble_command. */
5849 resolve_sal_pc (struct symtab_and_line
*sal
)
5853 if (sal
->pc
== 0 && sal
->symtab
!= NULL
)
5855 if (!find_line_pc (sal
->symtab
, sal
->line
, &pc
))
5856 error (_("No line %d in file \"%s\"."),
5857 sal
->line
, sal
->symtab
->filename
);
5861 if (sal
->section
== 0 && sal
->symtab
!= NULL
)
5863 struct blockvector
*bv
;
5868 bv
= blockvector_for_pc_sect (sal
->pc
, 0, &index
, sal
->symtab
);
5871 b
= BLOCKVECTOR_BLOCK (bv
, index
);
5872 sym
= block_function (b
);
5875 fixup_symbol_section (sym
, sal
->symtab
->objfile
);
5876 sal
->section
= SYMBOL_BFD_SECTION (sym
);
5880 /* It really is worthwhile to have the section, so we'll just
5881 have to look harder. This case can be executed if we have
5882 line numbers but no functions (as can happen in assembly
5885 struct minimal_symbol
*msym
;
5887 msym
= lookup_minimal_symbol_by_pc (sal
->pc
);
5889 sal
->section
= SYMBOL_BFD_SECTION (msym
);
5896 break_command (char *arg
, int from_tty
)
5898 break_command_1 (arg
, 0, from_tty
, NULL
);
5902 tbreak_command (char *arg
, int from_tty
)
5904 break_command_1 (arg
, BP_TEMPFLAG
, from_tty
, NULL
);
5908 hbreak_command (char *arg
, int from_tty
)
5910 break_command_1 (arg
, BP_HARDWAREFLAG
, from_tty
, NULL
);
5914 thbreak_command (char *arg
, int from_tty
)
5916 break_command_1 (arg
, (BP_TEMPFLAG
| BP_HARDWAREFLAG
), from_tty
, NULL
);
5920 stop_command (char *arg
, int from_tty
)
5922 printf_filtered (_("Specify the type of breakpoint to set.\n\
5923 Usage: stop in <function | address>\n\
5924 stop at <line>\n"));
5928 stopin_command (char *arg
, int from_tty
)
5932 if (arg
== (char *) NULL
)
5934 else if (*arg
!= '*')
5939 /* look for a ':'. If this is a line number specification, then
5940 say it is bad, otherwise, it should be an address or
5941 function/method name */
5942 while (*argptr
&& !hasColon
)
5944 hasColon
= (*argptr
== ':');
5949 badInput
= (*argptr
!= ':'); /* Not a class::method */
5951 badInput
= isdigit (*arg
); /* a simple line number */
5955 printf_filtered (_("Usage: stop in <function | address>\n"));
5957 break_command_1 (arg
, 0, from_tty
, NULL
);
5961 stopat_command (char *arg
, int from_tty
)
5965 if (arg
== (char *) NULL
|| *arg
== '*') /* no line number */
5972 /* look for a ':'. If there is a '::' then get out, otherwise
5973 it is probably a line number. */
5974 while (*argptr
&& !hasColon
)
5976 hasColon
= (*argptr
== ':');
5981 badInput
= (*argptr
== ':'); /* we have class::method */
5983 badInput
= !isdigit (*arg
); /* not a line number */
5987 printf_filtered (_("Usage: stop at <line>\n"));
5989 break_command_1 (arg
, 0, from_tty
, NULL
);
5992 /* accessflag: hw_write: watch write,
5993 hw_read: watch read,
5994 hw_access: watch access (read or write) */
5996 watch_command_1 (char *arg
, int accessflag
, int from_tty
)
5998 struct breakpoint
*b
, *scope_breakpoint
= NULL
;
5999 struct symtab_and_line sal
;
6000 struct expression
*exp
;
6001 struct block
*exp_valid_block
;
6002 struct value
*val
, *mark
;
6003 struct frame_info
*frame
;
6004 struct frame_info
*prev_frame
= NULL
;
6005 char *exp_start
= NULL
;
6006 char *exp_end
= NULL
;
6007 char *tok
, *end_tok
;
6009 char *cond_start
= NULL
;
6010 char *cond_end
= NULL
;
6011 struct expression
*cond
= NULL
;
6012 int i
, other_type_used
, target_resources_ok
= 0;
6013 enum bptype bp_type
;
6016 init_sal (&sal
); /* initialize to zeroes */
6018 /* Parse arguments. */
6019 innermost_block
= NULL
;
6021 exp
= parse_exp_1 (&arg
, 0, 0);
6023 exp_valid_block
= innermost_block
;
6024 mark
= value_mark ();
6025 val
= evaluate_expression (exp
);
6026 release_value (val
);
6027 if (value_lazy (val
))
6028 value_fetch_lazy (val
);
6031 while (*tok
== ' ' || *tok
== '\t')
6035 while (*end_tok
!= ' ' && *end_tok
!= '\t' && *end_tok
!= '\000')
6038 toklen
= end_tok
- tok
;
6039 if (toklen
>= 1 && strncmp (tok
, "if", toklen
) == 0)
6041 tok
= cond_start
= end_tok
+ 1;
6042 cond
= parse_exp_1 (&tok
, 0, 0);
6046 error (_("Junk at end of command."));
6048 if (accessflag
== hw_read
)
6049 bp_type
= bp_read_watchpoint
;
6050 else if (accessflag
== hw_access
)
6051 bp_type
= bp_access_watchpoint
;
6053 bp_type
= bp_hardware_watchpoint
;
6055 mem_cnt
= can_use_hardware_watchpoint (val
);
6056 if (mem_cnt
== 0 && bp_type
!= bp_hardware_watchpoint
)
6057 error (_("Expression cannot be implemented with read/access watchpoint."));
6060 i
= hw_watchpoint_used_count (bp_type
, &other_type_used
);
6061 target_resources_ok
=
6062 TARGET_CAN_USE_HARDWARE_WATCHPOINT (bp_type
, i
+ mem_cnt
,
6064 if (target_resources_ok
== 0 && bp_type
!= bp_hardware_watchpoint
)
6065 error (_("Target does not support this type of hardware watchpoint."));
6067 if (target_resources_ok
< 0 && bp_type
!= bp_hardware_watchpoint
)
6068 error (_("Target can only support one kind of HW watchpoint at a time."));
6071 /* Change the type of breakpoint to an ordinary watchpoint if a hardware
6072 watchpoint could not be set. */
6073 if (!mem_cnt
|| target_resources_ok
<= 0)
6074 bp_type
= bp_watchpoint
;
6076 frame
= block_innermost_frame (exp_valid_block
);
6078 prev_frame
= get_prev_frame (frame
);
6082 /* If the expression is "local", then set up a "watchpoint scope"
6083 breakpoint at the point where we've left the scope of the watchpoint
6084 expression. Create the scope breakpoint before the watchpoint, so
6085 that we will encounter it first in bpstat_stop_status. */
6086 if (innermost_block
&& prev_frame
)
6088 scope_breakpoint
= create_internal_breakpoint (get_frame_pc (prev_frame
),
6089 bp_watchpoint_scope
);
6091 scope_breakpoint
->enable_state
= bp_enabled
;
6093 /* Automatically delete the breakpoint when it hits. */
6094 scope_breakpoint
->disposition
= disp_del
;
6096 /* Only break in the proper frame (help with recursion). */
6097 scope_breakpoint
->frame_id
= get_frame_id (prev_frame
);
6099 /* Set the address at which we will stop. */
6100 scope_breakpoint
->loc
->requested_address
6101 = get_frame_pc (prev_frame
);
6102 scope_breakpoint
->loc
->address
6103 = adjust_breakpoint_address (scope_breakpoint
->loc
->requested_address
,
6104 scope_breakpoint
->type
);
6107 /* Now set up the breakpoint. */
6108 b
= set_raw_breakpoint (sal
, bp_type
);
6109 set_breakpoint_count (breakpoint_count
+ 1);
6110 b
->number
= breakpoint_count
;
6111 b
->disposition
= disp_donttouch
;
6113 b
->exp_valid_block
= exp_valid_block
;
6114 b
->exp_string
= savestring (exp_start
, exp_end
- exp_start
);
6116 b
->loc
->cond
= cond
;
6118 b
->cond_string
= savestring (cond_start
, cond_end
- cond_start
);
6123 b
->watchpoint_frame
= get_frame_id (frame
);
6125 memset (&b
->watchpoint_frame
, 0, sizeof (b
->watchpoint_frame
));
6127 if (scope_breakpoint
!= NULL
)
6129 /* The scope breakpoint is related to the watchpoint. We will
6130 need to act on them together. */
6131 b
->related_breakpoint
= scope_breakpoint
;
6132 scope_breakpoint
->related_breakpoint
= b
;
6135 value_free_to_mark (mark
);
6139 /* Return count of locations need to be watched and can be handled
6140 in hardware. If the watchpoint can not be handled
6141 in hardware return zero. */
6144 can_use_hardware_watchpoint (struct value
*v
)
6146 int found_memory_cnt
= 0;
6147 struct value
*head
= v
;
6149 /* Did the user specifically forbid us to use hardware watchpoints? */
6150 if (!can_use_hw_watchpoints
)
6153 /* Make sure that the value of the expression depends only upon
6154 memory contents, and values computed from them within GDB. If we
6155 find any register references or function calls, we can't use a
6156 hardware watchpoint.
6158 The idea here is that evaluating an expression generates a series
6159 of values, one holding the value of every subexpression. (The
6160 expression a*b+c has five subexpressions: a, b, a*b, c, and
6161 a*b+c.) GDB's values hold almost enough information to establish
6162 the criteria given above --- they identify memory lvalues,
6163 register lvalues, computed values, etcetera. So we can evaluate
6164 the expression, and then scan the chain of values that leaves
6165 behind to decide whether we can detect any possible change to the
6166 expression's final value using only hardware watchpoints.
6168 However, I don't think that the values returned by inferior
6169 function calls are special in any way. So this function may not
6170 notice that an expression involving an inferior function call
6171 can't be watched with hardware watchpoints. FIXME. */
6172 for (; v
; v
= value_next (v
))
6174 if (VALUE_LVAL (v
) == lval_memory
)
6177 /* A lazy memory lvalue is one that GDB never needed to fetch;
6178 we either just used its address (e.g., `a' in `a.b') or
6179 we never needed it at all (e.g., `a' in `a,b'). */
6183 /* Ahh, memory we actually used! Check if we can cover
6184 it with hardware watchpoints. */
6185 struct type
*vtype
= check_typedef (value_type (v
));
6187 /* We only watch structs and arrays if user asked for it
6188 explicitly, never if they just happen to appear in a
6189 middle of some value chain. */
6191 || (TYPE_CODE (vtype
) != TYPE_CODE_STRUCT
6192 && TYPE_CODE (vtype
) != TYPE_CODE_ARRAY
))
6194 CORE_ADDR vaddr
= VALUE_ADDRESS (v
) + value_offset (v
);
6195 int len
= TYPE_LENGTH (value_type (v
));
6197 if (!TARGET_REGION_OK_FOR_HW_WATCHPOINT (vaddr
, len
))
6204 else if (VALUE_LVAL (v
) != not_lval
6205 && deprecated_value_modifiable (v
) == 0)
6206 return 0; /* ??? What does this represent? */
6207 else if (VALUE_LVAL (v
) == lval_register
)
6208 return 0; /* cannot watch a register with a HW watchpoint */
6211 /* The expression itself looks suitable for using a hardware
6212 watchpoint, but give the target machine a chance to reject it. */
6213 return found_memory_cnt
;
6217 watch_command_wrapper (char *arg
, int from_tty
)
6219 watch_command (arg
, from_tty
);
6223 watch_command (char *arg
, int from_tty
)
6225 watch_command_1 (arg
, hw_write
, from_tty
);
6229 rwatch_command_wrapper (char *arg
, int from_tty
)
6231 rwatch_command (arg
, from_tty
);
6235 rwatch_command (char *arg
, int from_tty
)
6237 watch_command_1 (arg
, hw_read
, from_tty
);
6241 awatch_command_wrapper (char *arg
, int from_tty
)
6243 awatch_command (arg
, from_tty
);
6247 awatch_command (char *arg
, int from_tty
)
6249 watch_command_1 (arg
, hw_access
, from_tty
);
6253 /* Helper routines for the until_command routine in infcmd.c. Here
6254 because it uses the mechanisms of breakpoints. */
6256 /* This function is called by fetch_inferior_event via the
6257 cmd_continuation pointer, to complete the until command. It takes
6258 care of cleaning up the temporary breakpoints set up by the until
6261 until_break_command_continuation (struct continuation_arg
*arg
)
6263 struct cleanup
*cleanups
;
6265 cleanups
= (struct cleanup
*) arg
->data
.pointer
;
6266 do_exec_cleanups (cleanups
);
6270 until_break_command (char *arg
, int from_tty
, int anywhere
)
6272 struct symtabs_and_lines sals
;
6273 struct symtab_and_line sal
;
6274 struct frame_info
*frame
= get_selected_frame (NULL
);
6275 struct frame_info
*prev_frame
= get_prev_frame (frame
);
6276 struct breakpoint
*breakpoint
;
6277 struct cleanup
*old_chain
;
6278 struct continuation_arg
*arg1
;
6281 clear_proceed_status ();
6283 /* Set a breakpoint where the user wants it and at return from
6286 if (default_breakpoint_valid
)
6287 sals
= decode_line_1 (&arg
, 1, default_breakpoint_symtab
,
6288 default_breakpoint_line
, (char ***) NULL
, NULL
);
6290 sals
= decode_line_1 (&arg
, 1, (struct symtab
*) NULL
,
6291 0, (char ***) NULL
, NULL
);
6293 if (sals
.nelts
!= 1)
6294 error (_("Couldn't get information on specified line."));
6297 xfree (sals
.sals
); /* malloc'd, so freed */
6300 error (_("Junk at end of arguments."));
6302 resolve_sal_pc (&sal
);
6305 /* If the user told us to continue until a specified location,
6306 we don't specify a frame at which we need to stop. */
6307 breakpoint
= set_momentary_breakpoint (sal
, null_frame_id
, bp_until
);
6309 /* Otherwise, specify the current frame, because we want to stop only
6310 at the very same frame. */
6311 breakpoint
= set_momentary_breakpoint (sal
, get_frame_id (frame
),
6314 if (!target_can_async_p ())
6315 old_chain
= make_cleanup_delete_breakpoint (breakpoint
);
6317 old_chain
= make_exec_cleanup_delete_breakpoint (breakpoint
);
6319 /* If we are running asynchronously, and the target supports async
6320 execution, we are not waiting for the target to stop, in the call
6321 tp proceed, below. This means that we cannot delete the
6322 brekpoints until the target has actually stopped. The only place
6323 where we get a chance to do that is in fetch_inferior_event, so
6324 we must set things up for that. */
6326 if (target_can_async_p ())
6328 /* In this case the arg for the continuation is just the point
6329 in the exec_cleanups chain from where to start doing
6330 cleanups, because all the continuation does is the cleanups in
6331 the exec_cleanup_chain. */
6333 (struct continuation_arg
*) xmalloc (sizeof (struct continuation_arg
));
6335 arg1
->data
.pointer
= old_chain
;
6337 add_continuation (until_break_command_continuation
, arg1
);
6340 /* Keep within the current frame, or in frames called by the current
6344 sal
= find_pc_line (get_frame_pc (prev_frame
), 0);
6345 sal
.pc
= get_frame_pc (prev_frame
);
6346 breakpoint
= set_momentary_breakpoint (sal
, get_frame_id (prev_frame
),
6348 if (!target_can_async_p ())
6349 make_cleanup_delete_breakpoint (breakpoint
);
6351 make_exec_cleanup_delete_breakpoint (breakpoint
);
6354 proceed (-1, TARGET_SIGNAL_DEFAULT
, 0);
6355 /* Do the cleanups now, anly if we are not running asynchronously,
6356 of if we are, but the target is still synchronous. */
6357 if (!target_can_async_p ())
6358 do_cleanups (old_chain
);
6362 ep_skip_leading_whitespace (char **s
)
6364 if ((s
== NULL
) || (*s
== NULL
))
6366 while (isspace (**s
))
6370 /* This function examines a string, and attempts to find a token
6371 that might be an event name in the leading characters. If a
6372 possible match is found, a pointer to the last character of
6373 the token is returned. Else, NULL is returned. */
6376 ep_find_event_name_end (char *arg
)
6379 char *event_name_end
= NULL
;
6381 /* If we could depend upon the presense of strrpbrk, we'd use that... */
6385 /* We break out of the loop when we find a token delimiter.
6386 Basically, we're looking for alphanumerics and underscores;
6387 anything else delimites the token. */
6390 if (!isalnum (*s
) && (*s
!= '_'))
6396 return event_name_end
;
6400 /* This function attempts to parse an optional "if <cond>" clause
6401 from the arg string. If one is not found, it returns NULL.
6403 Else, it returns a pointer to the condition string. (It does not
6404 attempt to evaluate the string against a particular block.) And,
6405 it updates arg to point to the first character following the parsed
6406 if clause in the arg string. */
6409 ep_parse_optional_if_clause (char **arg
)
6413 if (((*arg
)[0] != 'i') || ((*arg
)[1] != 'f') || !isspace ((*arg
)[2]))
6416 /* Skip the "if" keyword. */
6419 /* Skip any extra leading whitespace, and record the start of the
6420 condition string. */
6421 ep_skip_leading_whitespace (arg
);
6424 /* Assume that the condition occupies the remainder of the arg string. */
6425 (*arg
) += strlen (cond_string
);
6430 /* This function attempts to parse an optional filename from the arg
6431 string. If one is not found, it returns NULL.
6433 Else, it returns a pointer to the parsed filename. (This function
6434 makes no attempt to verify that a file of that name exists, or is
6435 accessible.) And, it updates arg to point to the first character
6436 following the parsed filename in the arg string.
6438 Note that clients needing to preserve the returned filename for
6439 future access should copy it to their own buffers. */
6441 ep_parse_optional_filename (char **arg
)
6443 static char filename
[1024];
6448 if ((*arg_p
== '\0') || isspace (*arg_p
))
6466 /* Commands to deal with catching events, such as signals, exceptions,
6467 process start/exit, etc. */
6471 catch_fork
, catch_vfork
6476 catch_fork_command_1 (catch_fork_kind fork_kind
, char *arg
, int tempflag
,
6479 char *cond_string
= NULL
;
6481 ep_skip_leading_whitespace (&arg
);
6483 /* The allowed syntax is:
6485 catch [v]fork if <cond>
6487 First, check if there's an if clause. */
6488 cond_string
= ep_parse_optional_if_clause (&arg
);
6490 if ((*arg
!= '\0') && !isspace (*arg
))
6491 error (_("Junk at end of arguments."));
6493 /* If this target supports it, create a fork or vfork catchpoint
6494 and enable reporting of such events. */
6498 create_fork_event_catchpoint (tempflag
, cond_string
);
6501 create_vfork_event_catchpoint (tempflag
, cond_string
);
6504 error (_("unsupported or unknown fork kind; cannot catch it"));
6510 catch_exec_command_1 (char *arg
, int tempflag
, int from_tty
)
6512 char *cond_string
= NULL
;
6514 ep_skip_leading_whitespace (&arg
);
6516 /* The allowed syntax is:
6518 catch exec if <cond>
6520 First, check if there's an if clause. */
6521 cond_string
= ep_parse_optional_if_clause (&arg
);
6523 if ((*arg
!= '\0') && !isspace (*arg
))
6524 error (_("Junk at end of arguments."));
6526 /* If this target supports it, create an exec catchpoint
6527 and enable reporting of such events. */
6528 create_exec_event_catchpoint (tempflag
, cond_string
);
6532 catch_load_command_1 (char *arg
, int tempflag
, int from_tty
)
6534 char *dll_pathname
= NULL
;
6535 char *cond_string
= NULL
;
6537 ep_skip_leading_whitespace (&arg
);
6539 /* The allowed syntax is:
6541 catch load if <cond>
6542 catch load <filename>
6543 catch load <filename> if <cond>
6545 The user is not allowed to specify the <filename> after an
6548 We'll ignore the pathological case of a file named "if".
6550 First, check if there's an if clause. If so, then there
6551 cannot be a filename. */
6552 cond_string
= ep_parse_optional_if_clause (&arg
);
6554 /* If there was an if clause, then there cannot be a filename.
6555 Else, there might be a filename and an if clause. */
6556 if (cond_string
== NULL
)
6558 dll_pathname
= ep_parse_optional_filename (&arg
);
6559 ep_skip_leading_whitespace (&arg
);
6560 cond_string
= ep_parse_optional_if_clause (&arg
);
6563 if ((*arg
!= '\0') && !isspace (*arg
))
6564 error (_("Junk at end of arguments."));
6566 /* Create a load breakpoint that only triggers when a load of
6567 the specified dll (or any dll, if no pathname was specified)
6569 SOLIB_CREATE_CATCH_LOAD_HOOK (PIDGET (inferior_ptid
), tempflag
,
6570 dll_pathname
, cond_string
);
6574 catch_unload_command_1 (char *arg
, int tempflag
, int from_tty
)
6576 char *dll_pathname
= NULL
;
6577 char *cond_string
= NULL
;
6579 ep_skip_leading_whitespace (&arg
);
6581 /* The allowed syntax is:
6583 catch unload if <cond>
6584 catch unload <filename>
6585 catch unload <filename> if <cond>
6587 The user is not allowed to specify the <filename> after an
6590 We'll ignore the pathological case of a file named "if".
6592 First, check if there's an if clause. If so, then there
6593 cannot be a filename. */
6594 cond_string
= ep_parse_optional_if_clause (&arg
);
6596 /* If there was an if clause, then there cannot be a filename.
6597 Else, there might be a filename and an if clause. */
6598 if (cond_string
== NULL
)
6600 dll_pathname
= ep_parse_optional_filename (&arg
);
6601 ep_skip_leading_whitespace (&arg
);
6602 cond_string
= ep_parse_optional_if_clause (&arg
);
6605 if ((*arg
!= '\0') && !isspace (*arg
))
6606 error (_("Junk at end of arguments."));
6608 /* Create an unload breakpoint that only triggers when an unload of
6609 the specified dll (or any dll, if no pathname was specified)
6611 SOLIB_CREATE_CATCH_UNLOAD_HOOK (PIDGET (inferior_ptid
), tempflag
,
6612 dll_pathname
, cond_string
);
6615 /* Commands to deal with catching exceptions. */
6617 /* Set a breakpoint at the specified callback routine for an
6618 exception event callback */
6621 create_exception_catchpoint (int tempflag
, char *cond_string
,
6622 enum exception_event_kind ex_event
,
6623 struct symtab_and_line
*sal
)
6625 struct breakpoint
*b
;
6626 int thread
= -1; /* All threads. */
6629 if (!sal
) /* no exception support? */
6634 case EX_EVENT_THROW
:
6635 bptype
= bp_catch_throw
;
6637 case EX_EVENT_CATCH
:
6638 bptype
= bp_catch_catch
;
6640 default: /* error condition */
6641 error (_("Internal error -- invalid catchpoint kind"));
6644 b
= set_raw_breakpoint (*sal
, bptype
);
6645 set_breakpoint_count (breakpoint_count
+ 1);
6646 b
->number
= breakpoint_count
;
6647 b
->cond_string
= (cond_string
== NULL
) ?
6648 NULL
: savestring (cond_string
, strlen (cond_string
));
6650 b
->addr_string
= NULL
;
6651 b
->enable_state
= bp_enabled
;
6652 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
6656 static enum print_stop_action
6657 print_exception_catchpoint (struct breakpoint
*b
)
6659 annotate_catchpoint (b
->number
);
6661 if (strstr (b
->addr_string
, "throw") != NULL
)
6662 printf_filtered (_("\nCatchpoint %d (exception thrown)\n"),
6665 printf_filtered (_("\nCatchpoint %d (exception caught)\n"),
6668 return PRINT_SRC_AND_LOC
;
6672 print_one_exception_catchpoint (struct breakpoint
*b
, CORE_ADDR
*last_addr
)
6677 ui_out_field_core_addr (uiout
, "addr", b
->loc
->address
);
6680 *last_addr
= b
->loc
->address
;
6681 if (strstr (b
->addr_string
, "throw") != NULL
)
6682 ui_out_field_string (uiout
, "what", "exception throw");
6684 ui_out_field_string (uiout
, "what", "exception catch");
6688 print_mention_exception_catchpoint (struct breakpoint
*b
)
6690 if (strstr (b
->addr_string
, "throw") != NULL
)
6691 printf_filtered (_("Catchpoint %d (throw)"), b
->number
);
6693 printf_filtered (_("Catchpoint %d (catch)"), b
->number
);
6696 static struct breakpoint_ops gnu_v3_exception_catchpoint_ops
= {
6697 print_exception_catchpoint
,
6698 print_one_exception_catchpoint
,
6699 print_mention_exception_catchpoint
6703 handle_gnu_v3_exceptions (int tempflag
, char *cond_string
,
6704 enum exception_event_kind ex_event
, int from_tty
)
6706 char *trigger_func_name
, *nameptr
;
6707 struct symtabs_and_lines sals
;
6708 struct breakpoint
*b
;
6710 if (ex_event
== EX_EVENT_CATCH
)
6711 trigger_func_name
= xstrdup ("__cxa_begin_catch");
6713 trigger_func_name
= xstrdup ("__cxa_throw");
6715 nameptr
= trigger_func_name
;
6716 sals
= decode_line_1 (&nameptr
, 1, NULL
, 0, NULL
, NULL
);
6717 if (sals
.nelts
== 0)
6719 xfree (trigger_func_name
);
6723 b
= set_raw_breakpoint (sals
.sals
[0], bp_breakpoint
);
6724 set_breakpoint_count (breakpoint_count
+ 1);
6725 b
->number
= breakpoint_count
;
6726 b
->cond_string
= (cond_string
== NULL
) ?
6727 NULL
: savestring (cond_string
, strlen (cond_string
));
6729 b
->addr_string
= trigger_func_name
;
6730 b
->enable_state
= bp_enabled
;
6731 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
6732 b
->ops
= &gnu_v3_exception_catchpoint_ops
;
6739 /* Deal with "catch catch" and "catch throw" commands */
6742 catch_exception_command_1 (enum exception_event_kind ex_event
, char *arg
,
6743 int tempflag
, int from_tty
)
6745 char *cond_string
= NULL
;
6746 struct symtab_and_line
*sal
= NULL
;
6748 ep_skip_leading_whitespace (&arg
);
6750 cond_string
= ep_parse_optional_if_clause (&arg
);
6752 if ((*arg
!= '\0') && !isspace (*arg
))
6753 error (_("Junk at end of arguments."));
6755 if ((ex_event
!= EX_EVENT_THROW
) &&
6756 (ex_event
!= EX_EVENT_CATCH
))
6757 error (_("Unsupported or unknown exception event; cannot catch it"));
6759 if (handle_gnu_v3_exceptions (tempflag
, cond_string
, ex_event
, from_tty
))
6762 /* See if we can find a callback routine */
6763 sal
= target_enable_exception_callback (ex_event
, 1);
6767 /* We have callbacks from the runtime system for exceptions.
6768 Set a breakpoint on the sal found, if no errors */
6769 if (sal
!= (struct symtab_and_line
*) -1)
6770 create_exception_catchpoint (tempflag
, cond_string
, ex_event
, sal
);
6772 return; /* something went wrong with setting up callbacks */
6775 warning (_("Unsupported with this platform/compiler combination."));
6778 /* Create a breakpoint struct for Ada exception catchpoints. */
6781 create_ada_exception_breakpoint (struct symtab_and_line sal
,
6785 struct expression
*cond
,
6786 struct breakpoint_ops
*ops
,
6790 struct breakpoint
*b
;
6794 describe_other_breakpoints (sal
.pc
, sal
.section
, -1);
6795 /* FIXME: brobecker/2006-12-28: Actually, re-implement a special
6796 version for exception catchpoints, because two catchpoints
6797 used for different exception names will use the same address.
6798 In this case, a "breakpoint ... also set at..." warning is
6799 unproductive. Besides. the warning phrasing is also a bit
6800 inapropriate, we should use the word catchpoint, and tell
6801 the user what type of catchpoint it is. The above is good
6802 enough for now, though. */
6805 b
= set_raw_breakpoint (sal
, bp_breakpoint
);
6806 set_breakpoint_count (breakpoint_count
+ 1);
6808 b
->enable_state
= bp_enabled
;
6809 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
6810 b
->number
= breakpoint_count
;
6811 b
->ignore_count
= 0;
6812 b
->loc
->cond
= cond
;
6813 b
->addr_string
= addr_string
;
6814 b
->language
= language_ada
;
6815 b
->cond_string
= cond_string
;
6816 b
->exp_string
= exp_string
;
6819 b
->from_tty
= from_tty
;
6824 /* Implement the "catch exception" command. */
6827 catch_ada_exception_command (char *arg
, int tempflag
, int from_tty
)
6829 struct symtab_and_line sal
;
6831 char *addr_string
= NULL
;
6832 char *exp_string
= NULL
;
6833 char *cond_string
= NULL
;
6834 struct expression
*cond
= NULL
;
6835 struct breakpoint_ops
*ops
= NULL
;
6837 sal
= ada_decode_exception_location (arg
, &addr_string
, &exp_string
,
6838 &cond_string
, &cond
, &ops
);
6839 create_ada_exception_breakpoint (sal
, addr_string
, exp_string
,
6840 cond_string
, cond
, ops
, tempflag
,
6844 /* Implement the "catch assert" command. */
6847 catch_assert_command (char *arg
, int tempflag
, int from_tty
)
6849 struct symtab_and_line sal
;
6850 char *addr_string
= NULL
;
6851 struct breakpoint_ops
*ops
= NULL
;
6853 sal
= ada_decode_assert_location (arg
, &addr_string
, &ops
);
6854 create_ada_exception_breakpoint (sal
, addr_string
, NULL
, NULL
, NULL
, ops
,
6855 tempflag
, from_tty
);
6858 /* Cover routine to allow wrapping target_enable_exception_catchpoints
6859 inside a catch_errors */
6862 cover_target_enable_exception_callback (void *arg
)
6864 args_for_catchpoint_enable
*args
= arg
;
6865 struct symtab_and_line
*sal
;
6866 sal
= target_enable_exception_callback (args
->kind
, args
->enable_p
);
6869 else if (sal
== (struct symtab_and_line
*) -1)
6872 return 1; /*is valid */
6876 catch_command_1 (char *arg
, int tempflag
, int from_tty
)
6879 /* The first argument may be an event name, such as "start" or "load".
6880 If so, then handle it as such. If it doesn't match an event name,
6881 then attempt to interpret it as an exception name. (This latter is
6882 the v4.16-and-earlier GDB meaning of the "catch" command.)
6884 First, try to find the bounds of what might be an event name. */
6885 char *arg1_start
= arg
;
6889 if (arg1_start
== NULL
)
6891 /* Old behaviour was to use pre-v-4.16 syntax */
6892 /* catch_throw_command_1 (arg1_start, tempflag, from_tty); */
6894 /* Now, this is not allowed */
6895 error (_("Catch requires an event name."));
6898 arg1_end
= ep_find_event_name_end (arg1_start
);
6899 if (arg1_end
== NULL
)
6900 error (_("catch requires an event"));
6901 arg1_length
= arg1_end
+ 1 - arg1_start
;
6903 /* Try to match what we found against known event names. */
6904 if (strncmp (arg1_start
, "signal", arg1_length
) == 0)
6906 error (_("Catch of signal not yet implemented"));
6908 else if (strncmp (arg1_start
, "catch", arg1_length
) == 0)
6910 catch_exception_command_1 (EX_EVENT_CATCH
, arg1_end
+ 1,
6911 tempflag
, from_tty
);
6913 else if (strncmp (arg1_start
, "throw", arg1_length
) == 0)
6915 catch_exception_command_1 (EX_EVENT_THROW
, arg1_end
+ 1,
6916 tempflag
, from_tty
);
6918 else if (strncmp (arg1_start
, "thread_start", arg1_length
) == 0)
6920 error (_("Catch of thread_start not yet implemented"));
6922 else if (strncmp (arg1_start
, "thread_exit", arg1_length
) == 0)
6924 error (_("Catch of thread_exit not yet implemented"));
6926 else if (strncmp (arg1_start
, "thread_join", arg1_length
) == 0)
6928 error (_("Catch of thread_join not yet implemented"));
6930 else if (strncmp (arg1_start
, "start", arg1_length
) == 0)
6932 error (_("Catch of start not yet implemented"));
6934 else if (strncmp (arg1_start
, "exit", arg1_length
) == 0)
6936 error (_("Catch of exit not yet implemented"));
6938 else if (strncmp (arg1_start
, "fork", arg1_length
) == 0)
6940 catch_fork_command_1 (catch_fork
, arg1_end
+ 1, tempflag
, from_tty
);
6942 else if (strncmp (arg1_start
, "vfork", arg1_length
) == 0)
6944 catch_fork_command_1 (catch_vfork
, arg1_end
+ 1, tempflag
, from_tty
);
6946 else if (strncmp (arg1_start
, "exec", arg1_length
) == 0)
6948 catch_exec_command_1 (arg1_end
+ 1, tempflag
, from_tty
);
6950 else if (strncmp (arg1_start
, "load", arg1_length
) == 0)
6952 catch_load_command_1 (arg1_end
+ 1, tempflag
, from_tty
);
6954 else if (strncmp (arg1_start
, "unload", arg1_length
) == 0)
6956 catch_unload_command_1 (arg1_end
+ 1, tempflag
, from_tty
);
6958 else if (strncmp (arg1_start
, "stop", arg1_length
) == 0)
6960 error (_("Catch of stop not yet implemented"));
6962 else if (strncmp (arg1_start
, "exception", arg1_length
) == 0)
6964 catch_ada_exception_command (arg1_end
+ 1, tempflag
, from_tty
);
6967 else if (strncmp (arg1_start
, "assert", arg1_length
) == 0)
6969 catch_assert_command (arg1_end
+ 1, tempflag
, from_tty
);
6972 /* This doesn't appear to be an event name */
6976 /* Pre-v.4.16 behaviour was to treat the argument
6977 as the name of an exception */
6978 /* catch_throw_command_1 (arg1_start, tempflag, from_tty); */
6979 /* Now this is not allowed */
6980 error (_("Unknown event kind specified for catch"));
6985 /* Used by the gui, could be made a worker for other things. */
6988 set_breakpoint_sal (struct symtab_and_line sal
)
6990 struct breakpoint
*b
;
6991 b
= set_raw_breakpoint (sal
, bp_breakpoint
);
6992 set_breakpoint_count (breakpoint_count
+ 1);
6993 b
->number
= breakpoint_count
;
6999 catch_command (char *arg
, int from_tty
)
7001 catch_command_1 (arg
, 0, from_tty
);
7006 tcatch_command (char *arg
, int from_tty
)
7008 catch_command_1 (arg
, 1, from_tty
);
7011 /* Delete breakpoints by address or line. */
7014 clear_command (char *arg
, int from_tty
)
7016 struct breakpoint
*b
, *tmp
, *prev
, *found
;
7018 struct symtabs_and_lines sals
;
7019 struct symtab_and_line sal
;
7024 sals
= decode_line_spec (arg
, 1);
7029 sals
.sals
= (struct symtab_and_line
*)
7030 xmalloc (sizeof (struct symtab_and_line
));
7031 make_cleanup (xfree
, sals
.sals
);
7032 init_sal (&sal
); /* initialize to zeroes */
7033 sal
.line
= default_breakpoint_line
;
7034 sal
.symtab
= default_breakpoint_symtab
;
7035 sal
.pc
= default_breakpoint_address
;
7036 if (sal
.symtab
== 0)
7037 error (_("No source file specified."));
7045 /* We don't call resolve_sal_pc here. That's not
7046 as bad as it seems, because all existing breakpoints
7047 typically have both file/line and pc set. So, if
7048 clear is given file/line, we can match this to existing
7049 breakpoint without obtaining pc at all.
7051 We only support clearing given the address explicitly
7052 present in breakpoint table. Say, we've set breakpoint
7053 at file:line. There were several PC values for that file:line,
7054 due to optimization, all in one block.
7055 We've picked one PC value. If "clear" is issued with another
7056 PC corresponding to the same file:line, the breakpoint won't
7057 be cleared. We probably can still clear the breakpoint, but
7058 since the other PC value is never presented to user, user
7059 can only find it by guessing, and it does not seem important
7062 /* For each line spec given, delete bps which correspond
7063 to it. Do it in two passes, solely to preserve the current
7064 behavior that from_tty is forced true if we delete more than
7068 for (i
= 0; i
< sals
.nelts
; i
++)
7070 /* If exact pc given, clear bpts at that pc.
7071 If line given (pc == 0), clear all bpts on specified line.
7072 If defaulting, clear all bpts on default line
7075 defaulting sal.pc != 0 tests to do
7080 1 0 <can't happen> */
7085 /* Find all matching breakpoints, remove them from the
7086 breakpoint chain, and add them to the 'found' chain. */
7087 ALL_BREAKPOINTS_SAFE (b
, tmp
)
7090 /* Are we going to delete b? */
7091 if (b
->type
!= bp_none
7092 && b
->type
!= bp_watchpoint
7093 && b
->type
!= bp_hardware_watchpoint
7094 && b
->type
!= bp_read_watchpoint
7095 && b
->type
!= bp_access_watchpoint
)
7097 struct bp_location
*loc
= b
->loc
;
7098 for (; loc
; loc
= loc
->next
)
7100 int pc_match
= sal
.pc
7101 && (loc
->address
== sal
.pc
)
7102 && (!section_is_overlay (loc
->section
)
7103 || loc
->section
== sal
.section
);
7104 int line_match
= ((default_match
|| (0 == sal
.pc
))
7105 && b
->source_file
!= NULL
7106 && sal
.symtab
!= NULL
7107 && strcmp (b
->source_file
, sal
.symtab
->filename
) == 0
7108 && b
->line_number
== sal
.line
);
7109 if (pc_match
|| line_match
)
7119 /* Remove it from breakpoint_chain... */
7120 if (b
== breakpoint_chain
)
7122 /* b is at the head of the list */
7123 breakpoint_chain
= b
->next
;
7127 prev
->next
= b
->next
;
7129 /* And add it to 'found' chain. */
7135 /* Keep b, and keep a pointer to it. */
7140 /* Now go thru the 'found' chain and delete them. */
7144 error (_("No breakpoint at %s."), arg
);
7146 error (_("No breakpoint at this line."));
7150 from_tty
= 1; /* Always report if deleted more than one */
7154 printf_unfiltered (_("Deleted breakpoint "));
7156 printf_unfiltered (_("Deleted breakpoints "));
7158 breakpoints_changed ();
7162 printf_unfiltered ("%d ", found
->number
);
7164 delete_breakpoint (found
);
7168 putchar_unfiltered ('\n');
7171 /* Delete breakpoint in BS if they are `delete' breakpoints and
7172 all breakpoints that are marked for deletion, whether hit or not.
7173 This is called after any breakpoint is hit, or after errors. */
7176 breakpoint_auto_delete (bpstat bs
)
7178 struct breakpoint
*b
, *temp
;
7180 for (; bs
; bs
= bs
->next
)
7181 if (bs
->breakpoint_at
&& bs
->breakpoint_at
->owner
->disposition
== disp_del
7183 delete_breakpoint (bs
->breakpoint_at
->owner
);
7185 ALL_BREAKPOINTS_SAFE (b
, temp
)
7187 if (b
->disposition
== disp_del_at_next_stop
)
7188 delete_breakpoint (b
);
7192 /* Remove locations of breakpoint BPT from
7193 the global list of breakpoint locations. */
7196 unlink_locations_from_global_list (struct breakpoint
*bpt
)
7198 /* This code assumes that the locations
7199 of a breakpoint are found in the global list
7200 in the same order, but not necessary adjacent. */
7201 struct bp_location
**tmp
= &bp_location_chain
;
7202 struct bp_location
*here
= bpt
->loc
;
7207 for (; *tmp
&& here
;)
7211 *tmp
= here
->global_next
;
7216 tmp
= &((*tmp
)->global_next
);
7221 /* Delete a breakpoint and clean up all traces of it in the data
7225 delete_breakpoint (struct breakpoint
*bpt
)
7227 struct breakpoint
*b
;
7229 struct bp_location
*loc
;
7231 gdb_assert (bpt
!= NULL
);
7233 /* Has this bp already been deleted? This can happen because multiple
7234 lists can hold pointers to bp's. bpstat lists are especial culprits.
7236 One example of this happening is a watchpoint's scope bp. When the
7237 scope bp triggers, we notice that the watchpoint is out of scope, and
7238 delete it. We also delete its scope bp. But the scope bp is marked
7239 "auto-deleting", and is already on a bpstat. That bpstat is then
7240 checked for auto-deleting bp's, which are deleted.
7242 A real solution to this problem might involve reference counts in bp's,
7243 and/or giving them pointers back to their referencing bpstat's, and
7244 teaching delete_breakpoint to only free a bp's storage when no more
7245 references were extent. A cheaper bandaid was chosen. */
7246 if (bpt
->type
== bp_none
)
7249 if (deprecated_delete_breakpoint_hook
)
7250 deprecated_delete_breakpoint_hook (bpt
);
7251 breakpoint_delete_event (bpt
->number
);
7253 for (loc
= bpt
->loc
; loc
; loc
= loc
->next
)
7256 remove_breakpoint (loc
, mark_inserted
);
7258 free_valchain (loc
);
7263 if (loc
->function_name
)
7264 xfree (loc
->function_name
);
7267 if (breakpoint_chain
== bpt
)
7268 breakpoint_chain
= bpt
->next
;
7270 /* If we have callback-style exception catchpoints, don't go through
7271 the adjustments to the C++ runtime library etc. if the inferior
7272 isn't actually running. target_enable_exception_callback for a
7273 null target ops vector gives an undesirable error message, so we
7274 check here and avoid it. Since currently (1997-09-17) only HP-UX aCC's
7275 exceptions are supported in this way, it's OK for now. FIXME */
7276 if (ep_is_exception_catchpoint (bpt
) && target_has_execution
)
7278 /* Format possible error msg */
7279 char *message
= xstrprintf ("Error in deleting catchpoint %d:\n",
7281 struct cleanup
*cleanups
= make_cleanup (xfree
, message
);
7282 args_for_catchpoint_enable args
;
7283 args
.kind
= bpt
->type
== bp_catch_catch
?
7284 EX_EVENT_CATCH
: EX_EVENT_THROW
;
7286 catch_errors (cover_target_enable_exception_callback
, &args
,
7287 message
, RETURN_MASK_ALL
);
7288 do_cleanups (cleanups
);
7295 b
->next
= bpt
->next
;
7299 unlink_locations_from_global_list (bpt
);
7301 check_duplicates (bpt
);
7303 if (bpt
->type
!= bp_hardware_watchpoint
7304 && bpt
->type
!= bp_read_watchpoint
7305 && bpt
->type
!= bp_access_watchpoint
7306 && bpt
->type
!= bp_catch_fork
7307 && bpt
->type
!= bp_catch_vfork
7308 && bpt
->type
!= bp_catch_exec
)
7309 for (loc
= bpt
->loc
; loc
; loc
= loc
->next
)
7311 /* If this breakpoint location was inserted, and there is
7312 another breakpoint at the same address, we need to
7313 insert the other breakpoint. */
7316 struct bp_location
*loc2
;
7317 ALL_BP_LOCATIONS (loc2
)
7318 if (loc2
->address
== loc
->address
7319 && loc2
->section
== loc
->section
7321 && loc2
->owner
->enable_state
!= bp_disabled
7323 && !loc2
->shlib_disabled
7324 && loc2
->owner
->enable_state
!= bp_call_disabled
)
7328 /* We should never reach this point if there is a permanent
7329 breakpoint at the same address as the one being deleted.
7330 If there is a permanent breakpoint somewhere, it should
7331 always be the only one inserted. */
7332 if (loc2
->owner
->enable_state
== bp_permanent
)
7333 internal_error (__FILE__
, __LINE__
,
7334 _("another breakpoint was inserted on top of "
7335 "a permanent breakpoint"));
7337 memset (&loc2
->target_info
, 0, sizeof (loc2
->target_info
));
7338 loc2
->target_info
.placed_address
= loc2
->address
;
7339 if (b
->type
== bp_hardware_breakpoint
)
7340 val
= target_insert_hw_breakpoint (&loc2
->target_info
);
7342 val
= target_insert_breakpoint (&loc2
->target_info
);
7344 /* If there was an error in the insert, print a message, then stop execution. */
7347 struct ui_file
*tmp_error_stream
= mem_fileopen ();
7348 make_cleanup_ui_file_delete (tmp_error_stream
);
7351 if (b
->type
== bp_hardware_breakpoint
)
7353 fprintf_unfiltered (tmp_error_stream
,
7354 "Cannot insert hardware breakpoint %d.\n"
7355 "You may have requested too many hardware breakpoints.\n",
7360 fprintf_unfiltered (tmp_error_stream
, "Cannot insert breakpoint %d.\n", b
->number
);
7361 fprintf_filtered (tmp_error_stream
, "Error accessing memory address ");
7362 deprecated_print_address_numeric (loc2
->address
, 1, tmp_error_stream
);
7363 fprintf_filtered (tmp_error_stream
, ": %s.\n",
7364 safe_strerror (val
));
7367 fprintf_unfiltered (tmp_error_stream
,"The same program may be running in another process.");
7368 target_terminal_ours_for_output ();
7369 error_stream(tmp_error_stream
);
7377 free_command_lines (&bpt
->commands
);
7378 if (bpt
->cond_string
!= NULL
)
7379 xfree (bpt
->cond_string
);
7380 if (bpt
->addr_string
!= NULL
)
7381 xfree (bpt
->addr_string
);
7382 if (bpt
->exp
!= NULL
)
7384 if (bpt
->exp_string
!= NULL
)
7385 xfree (bpt
->exp_string
);
7386 if (bpt
->val
!= NULL
)
7387 value_free (bpt
->val
);
7388 if (bpt
->source_file
!= NULL
)
7389 xfree (bpt
->source_file
);
7390 if (bpt
->dll_pathname
!= NULL
)
7391 xfree (bpt
->dll_pathname
);
7392 if (bpt
->triggered_dll_pathname
!= NULL
)
7393 xfree (bpt
->triggered_dll_pathname
);
7394 if (bpt
->exec_pathname
!= NULL
)
7395 xfree (bpt
->exec_pathname
);
7397 /* Be sure no bpstat's are pointing at it after it's been freed. */
7398 /* FIXME, how can we find all bpstat's?
7399 We just check stop_bpstat for now. Note that we cannot just
7400 remove bpstats pointing at bpt from the stop_bpstat list
7401 entirely, as breakpoint commands are associated with the bpstat;
7402 if we remove it here, then the later call to
7403 bpstat_do_actions (&stop_bpstat);
7404 in event-top.c won't do anything, and temporary breakpoints
7405 with commands won't work. */
7406 for (bs
= stop_bpstat
; bs
; bs
= bs
->next
)
7407 if (bs
->breakpoint_at
&& bs
->breakpoint_at
->owner
== bpt
)
7409 bs
->breakpoint_at
= NULL
;
7411 /* bs->commands will be freed later. */
7413 /* On the chance that someone will soon try again to delete this same
7414 bp, we mark it as deleted before freeing its storage. */
7415 bpt
->type
= bp_none
;
7417 for (loc
= bpt
->loc
; loc
;)
7419 struct bp_location
*loc_next
= loc
->next
;
7427 do_delete_breakpoint_cleanup (void *b
)
7429 delete_breakpoint (b
);
7433 make_cleanup_delete_breakpoint (struct breakpoint
*b
)
7435 return make_cleanup (do_delete_breakpoint_cleanup
, b
);
7439 make_exec_cleanup_delete_breakpoint (struct breakpoint
*b
)
7441 return make_exec_cleanup (do_delete_breakpoint_cleanup
, b
);
7445 delete_command (char *arg
, int from_tty
)
7447 struct breakpoint
*b
, *temp
;
7453 int breaks_to_delete
= 0;
7455 /* Delete all breakpoints if no argument.
7456 Do not delete internal or call-dummy breakpoints, these
7457 have to be deleted with an explicit breakpoint number argument. */
7460 if (b
->type
!= bp_call_dummy
&&
7461 b
->type
!= bp_shlib_event
&&
7462 b
->type
!= bp_thread_event
&&
7463 b
->type
!= bp_overlay_event
&&
7466 breaks_to_delete
= 1;
7471 /* Ask user only if there are some breakpoints to delete. */
7473 || (breaks_to_delete
&& query (_("Delete all breakpoints? "))))
7475 ALL_BREAKPOINTS_SAFE (b
, temp
)
7477 if (b
->type
!= bp_call_dummy
&&
7478 b
->type
!= bp_shlib_event
&&
7479 b
->type
!= bp_thread_event
&&
7480 b
->type
!= bp_overlay_event
&&
7482 delete_breakpoint (b
);
7487 map_breakpoint_numbers (arg
, delete_breakpoint
);
7491 all_locations_are_pending (struct bp_location
*loc
)
7493 for (; loc
; loc
= loc
->next
)
7494 if (!loc
->shlib_disabled
)
7500 update_breakpoint_locations (struct breakpoint
*b
,
7501 struct symtabs_and_lines sals
)
7505 struct bp_location
*existing_locations
= b
->loc
;
7507 /* If there's no new locations, and all existing locations
7508 are pending, don't do anything. This optimizes
7509 the common case where all locations are in the same
7510 shared library, that was unloaded. We'd like to
7511 retain the location, so that when the library
7512 is loaded again, we don't loose the enabled/disabled
7513 status of the individual locations. */
7514 if (all_locations_are_pending (existing_locations
) && sals
.nelts
== 0)
7517 unlink_locations_from_global_list (b
);
7520 for (i
= 0; i
< sals
.nelts
; ++i
)
7522 struct bp_location
*new_loc
=
7523 add_location_to_breakpoint (b
, b
->type
, &(sals
.sals
[i
]));
7525 /* Reparse conditions, they might contain references to the
7527 if (b
->cond_string
!= NULL
)
7529 struct gdb_exception e
;
7532 TRY_CATCH (e
, RETURN_MASK_ERROR
)
7534 new_loc
->cond
= parse_exp_1 (&s
, block_for_pc (sals
.sals
[i
].pc
),
7539 warning (_("failed to reevaluate condition for breakpoint %d: %s"),
7540 b
->number
, e
.message
);
7541 new_loc
->enabled
= 0;
7545 if (b
->source_file
!= NULL
)
7546 xfree (b
->source_file
);
7547 if (sals
.sals
[i
].symtab
== NULL
)
7548 b
->source_file
= NULL
;
7551 savestring (sals
.sals
[i
].symtab
->filename
,
7552 strlen (sals
.sals
[i
].symtab
->filename
));
7554 if (b
->line_number
== 0)
7555 b
->line_number
= sals
.sals
[i
].line
;
7558 /* If possible, carry over 'disable' status from existing breakpoints. */
7560 struct bp_location
*e
= existing_locations
;
7561 for (; e
; e
= e
->next
)
7563 if (!e
->enabled
&& e
->function_name
)
7565 struct bp_location
*l
= b
->loc
;
7566 for (; l
; l
= l
->next
)
7567 if (l
->function_name
7568 && strcmp (e
->function_name
, l
->function_name
) == 0)
7577 while (existing_locations
)
7579 struct bp_location
*next
= existing_locations
->next
;
7580 free_bp_location (existing_locations
);
7581 existing_locations
= next
;
7586 /* Reset a breakpoint given it's struct breakpoint * BINT.
7587 The value we return ends up being the return value from catch_errors.
7588 Unused in this case. */
7591 breakpoint_re_set_one (void *bint
)
7593 /* get past catch_errs */
7594 struct breakpoint
*b
= (struct breakpoint
*) bint
;
7598 int *not_found_ptr
= ¬_found
;
7599 struct symtabs_and_lines sals
= {};
7600 struct symtabs_and_lines expanded
;
7602 enum enable_state save_enable
;
7603 struct gdb_exception e
;
7609 warning (_("attempted to reset apparently deleted breakpoint #%d?"),
7613 case bp_hardware_breakpoint
:
7615 case bp_catch_unload
:
7616 if (b
->addr_string
== NULL
)
7618 /* Anything without a string can't be re-set. */
7619 delete_breakpoint (b
);
7623 set_language (b
->language
);
7624 input_radix
= b
->input_radix
;
7626 TRY_CATCH (e
, RETURN_MASK_ERROR
)
7628 sals
= decode_line_1 (&s
, 1, (struct symtab
*) NULL
, 0, (char ***) NULL
,
7633 int not_found_and_ok
= 0;
7634 /* For pending breakpoints, it's expected that parsing
7635 will fail until the right shared library is loaded.
7636 User has already told to create pending breakpoints and
7637 don't need extra messages. If breakpoint is in bp_shlib_disabled
7638 state, then user already saw the message about that breakpoint
7639 being disabled, and don't want to see more errors. */
7641 && (b
->condition_not_parsed
7642 || (b
->loc
&& b
->loc
->shlib_disabled
)
7643 || b
->enable_state
== bp_disabled
))
7644 not_found_and_ok
= 1;
7646 if (!not_found_and_ok
)
7648 /* We surely don't want to warn about the same breakpoint
7649 10 times. One solution, implemented here, is disable
7650 the breakpoint on error. Another solution would be to
7651 have separate 'warning emitted' flag. Since this
7652 happens only when a binary has changed, I don't know
7653 which approach is better. */
7654 b
->enable_state
= bp_disabled
;
7655 throw_exception (e
);
7662 gdb_assert (sals
.nelts
== 1);
7663 resolve_sal_pc (&sals
.sals
[0]);
7664 if (b
->condition_not_parsed
&& s
&& s
[0])
7666 char *cond_string
= 0;
7668 find_condition_and_thread (s
, sals
.sals
[0].pc
,
7669 &cond_string
, &thread
);
7671 b
->cond_string
= cond_string
;
7673 b
->condition_not_parsed
= 0;
7675 expanded
= expand_line_sal_maybe (sals
.sals
[0]);
7676 update_breakpoint_locations (b
, expanded
);
7678 /* Now that this is re-enabled, check_duplicates
7680 check_duplicates (b
);
7686 case bp_hardware_watchpoint
:
7687 case bp_read_watchpoint
:
7688 case bp_access_watchpoint
:
7689 innermost_block
= NULL
;
7690 /* The issue arises of what context to evaluate this in. The
7691 same one as when it was set, but what does that mean when
7692 symbols have been re-read? We could save the filename and
7693 functionname, but if the context is more local than that, the
7694 best we could do would be something like how many levels deep
7695 and which index at that particular level, but that's going to
7696 be less stable than filenames or function names. */
7698 /* So for now, just use a global context. */
7702 /* Avoid re-freeing b->exp if an error during the call to
7703 parse_expression. */
7706 b
->exp
= parse_expression (b
->exp_string
);
7707 b
->exp_valid_block
= innermost_block
;
7708 mark
= value_mark ();
7711 value_free (b
->val
);
7712 /* Avoid re-freeing b->val if an error during the call to
7713 evaluate_expression. */
7716 b
->val
= evaluate_expression (b
->exp
);
7717 release_value (b
->val
);
7718 if (value_lazy (b
->val
) && breakpoint_enabled (b
))
7719 value_fetch_lazy (b
->val
);
7721 if (b
->cond_string
!= NULL
)
7726 xfree (b
->loc
->cond
);
7727 /* Avoid re-freeing b->exp if an error during the call
7729 b
->loc
->cond
= NULL
;
7731 b
->loc
->cond
= parse_exp_1 (&s
, (struct block
*) 0, 0);
7733 if (breakpoint_enabled (b
))
7735 value_free_to_mark (mark
);
7737 case bp_catch_catch
:
7738 case bp_catch_throw
:
7740 /* We needn't really do anything to reset these, since the mask
7741 that requests them is unaffected by e.g., new libraries being
7744 case bp_catch_vfork
:
7749 printf_filtered (_("Deleting unknown breakpoint type %d\n"), b
->type
);
7751 /* Delete longjmp and overlay event breakpoints; they will be
7752 reset later by breakpoint_re_set. */
7754 case bp_longjmp_resume
:
7755 case bp_overlay_event
:
7756 delete_breakpoint (b
);
7759 /* This breakpoint is special, it's set up when the inferior
7760 starts and we really don't want to touch it. */
7761 case bp_shlib_event
:
7763 /* Like bp_shlib_event, this breakpoint type is special.
7764 Once it is set up, we do not want to touch it. */
7765 case bp_thread_event
:
7767 /* Keep temporary breakpoints, which can be encountered when we step
7768 over a dlopen call and SOLIB_ADD is resetting the breakpoints.
7769 Otherwise these should have been blown away via the cleanup chain
7770 or by breakpoint_init_inferior when we rerun the executable. */
7773 case bp_watchpoint_scope
:
7775 case bp_step_resume
:
7782 /* Re-set all breakpoints after symbols have been re-loaded. */
7784 breakpoint_re_set (void)
7786 struct breakpoint
*b
, *temp
;
7787 enum language save_language
;
7788 int save_input_radix
;
7790 save_language
= current_language
->la_language
;
7791 save_input_radix
= input_radix
;
7792 ALL_BREAKPOINTS_SAFE (b
, temp
)
7794 /* Format possible error msg */
7795 char *message
= xstrprintf ("Error in re-setting breakpoint %d: ",
7797 struct cleanup
*cleanups
= make_cleanup (xfree
, message
);
7798 catch_errors (breakpoint_re_set_one
, b
, message
, RETURN_MASK_ALL
);
7799 do_cleanups (cleanups
);
7801 set_language (save_language
);
7802 input_radix
= save_input_radix
;
7804 if (gdbarch_get_longjmp_target_p (current_gdbarch
))
7806 create_longjmp_breakpoint ("longjmp");
7807 create_longjmp_breakpoint ("_longjmp");
7808 create_longjmp_breakpoint ("siglongjmp");
7809 create_longjmp_breakpoint ("_siglongjmp");
7810 create_longjmp_breakpoint (NULL
);
7813 create_overlay_event_breakpoint ("_ovly_debug_event");
7816 /* Reset the thread number of this breakpoint:
7818 - If the breakpoint is for all threads, leave it as-is.
7819 - Else, reset it to the current thread for inferior_ptid. */
7821 breakpoint_re_set_thread (struct breakpoint
*b
)
7823 if (b
->thread
!= -1)
7825 if (in_thread_list (inferior_ptid
))
7826 b
->thread
= pid_to_thread_id (inferior_ptid
);
7830 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
7831 If from_tty is nonzero, it prints a message to that effect,
7832 which ends with a period (no newline). */
7835 set_ignore_count (int bptnum
, int count
, int from_tty
)
7837 struct breakpoint
*b
;
7843 if (b
->number
== bptnum
)
7845 b
->ignore_count
= count
;
7849 printf_filtered (_("Will stop next time breakpoint %d is reached."),
7851 else if (count
== 1)
7852 printf_filtered (_("Will ignore next crossing of breakpoint %d."),
7855 printf_filtered (_("Will ignore next %d crossings of breakpoint %d."),
7858 breakpoints_changed ();
7859 breakpoint_modify_event (b
->number
);
7863 error (_("No breakpoint number %d."), bptnum
);
7866 /* Clear the ignore counts of all breakpoints. */
7868 breakpoint_clear_ignore_counts (void)
7870 struct breakpoint
*b
;
7873 b
->ignore_count
= 0;
7876 /* Command to set ignore-count of breakpoint N to COUNT. */
7879 ignore_command (char *args
, int from_tty
)
7885 error_no_arg (_("a breakpoint number"));
7887 num
= get_number (&p
);
7889 error (_("bad breakpoint number: '%s'"), args
);
7891 error (_("Second argument (specified ignore-count) is missing."));
7893 set_ignore_count (num
,
7894 longest_to_int (value_as_long (parse_and_eval (p
))),
7897 printf_filtered ("\n");
7900 /* Call FUNCTION on each of the breakpoints
7901 whose numbers are given in ARGS. */
7904 map_breakpoint_numbers (char *args
, void (*function
) (struct breakpoint
*))
7909 struct breakpoint
*b
, *tmp
;
7913 error_no_arg (_("one or more breakpoint numbers"));
7920 num
= get_number_or_range (&p1
);
7923 warning (_("bad breakpoint number at or near '%s'"), p
);
7927 ALL_BREAKPOINTS_SAFE (b
, tmp
)
7928 if (b
->number
== num
)
7930 struct breakpoint
*related_breakpoint
= b
->related_breakpoint
;
7933 if (related_breakpoint
)
7934 function (related_breakpoint
);
7938 printf_unfiltered (_("No breakpoint number %d.\n"), num
);
7944 static struct bp_location
*
7945 find_location_by_number (char *number
)
7947 char *dot
= strchr (number
, '.');
7951 struct breakpoint
*b
;
7952 struct bp_location
*loc
;
7957 bp_num
= get_number_or_range (&p1
);
7959 error (_("Bad breakpoint number '%s'"), number
);
7962 if (b
->number
== bp_num
)
7967 if (!b
|| b
->number
!= bp_num
)
7968 error (_("Bad breakpoint number '%s'"), number
);
7971 loc_num
= get_number_or_range (&p1
);
7973 error (_("Bad breakpoint location number '%s'"), number
);
7977 for (;loc_num
&& loc
; --loc_num
, loc
= loc
->next
)
7980 error (_("Bad breakpoint location number '%s'"), dot
+1);
7986 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
7987 If from_tty is nonzero, it prints a message to that effect,
7988 which ends with a period (no newline). */
7991 disable_breakpoint (struct breakpoint
*bpt
)
7993 /* Never disable a watchpoint scope breakpoint; we want to
7994 hit them when we leave scope so we can delete both the
7995 watchpoint and its scope breakpoint at that time. */
7996 if (bpt
->type
== bp_watchpoint_scope
)
7999 /* You can't disable permanent breakpoints. */
8000 if (bpt
->enable_state
== bp_permanent
)
8003 bpt
->enable_state
= bp_disabled
;
8005 check_duplicates (bpt
);
8007 if (deprecated_modify_breakpoint_hook
)
8008 deprecated_modify_breakpoint_hook (bpt
);
8009 breakpoint_modify_event (bpt
->number
);
8013 disable_command (char *args
, int from_tty
)
8015 struct breakpoint
*bpt
;
8017 ALL_BREAKPOINTS (bpt
)
8021 warning (_("attempted to disable apparently deleted breakpoint #%d?"),
8026 case bp_catch_unload
:
8028 case bp_catch_vfork
:
8030 case bp_catch_catch
:
8031 case bp_catch_throw
:
8032 case bp_hardware_breakpoint
:
8034 case bp_hardware_watchpoint
:
8035 case bp_read_watchpoint
:
8036 case bp_access_watchpoint
:
8037 disable_breakpoint (bpt
);
8041 else if (strchr (args
, '.'))
8043 struct bp_location
*loc
= find_location_by_number (args
);
8046 check_duplicates (loc
->owner
);
8049 map_breakpoint_numbers (args
, disable_breakpoint
);
8053 do_enable_breakpoint (struct breakpoint
*bpt
, enum bpdisp disposition
)
8055 int target_resources_ok
, other_type_used
;
8058 if (bpt
->type
== bp_hardware_breakpoint
)
8061 i
= hw_breakpoint_used_count ();
8062 target_resources_ok
=
8063 TARGET_CAN_USE_HARDWARE_WATCHPOINT (bp_hardware_breakpoint
,
8065 if (target_resources_ok
== 0)
8066 error (_("No hardware breakpoint support in the target."));
8067 else if (target_resources_ok
< 0)
8068 error (_("Hardware breakpoints used exceeds limit."));
8071 if (bpt
->type
== bp_watchpoint
||
8072 bpt
->type
== bp_hardware_watchpoint
||
8073 bpt
->type
== bp_read_watchpoint
||
8074 bpt
->type
== bp_access_watchpoint
)
8076 struct frame_id saved_frame_id
;
8078 saved_frame_id
= get_frame_id (get_selected_frame (NULL
));
8079 if (bpt
->exp_valid_block
!= NULL
)
8081 struct frame_info
*fr
=
8082 fr
= frame_find_by_id (bpt
->watchpoint_frame
);
8085 printf_filtered (_("\
8086 Cannot enable watchpoint %d because the block in which its expression\n\
8087 is valid is not currently in scope.\n"), bpt
->number
);
8094 value_free (bpt
->val
);
8095 mark
= value_mark ();
8096 bpt
->val
= evaluate_expression (bpt
->exp
);
8097 release_value (bpt
->val
);
8098 if (value_lazy (bpt
->val
))
8099 value_fetch_lazy (bpt
->val
);
8101 if (bpt
->type
== bp_hardware_watchpoint
||
8102 bpt
->type
== bp_read_watchpoint
||
8103 bpt
->type
== bp_access_watchpoint
)
8105 int i
= hw_watchpoint_used_count (bpt
->type
, &other_type_used
);
8106 int mem_cnt
= can_use_hardware_watchpoint (bpt
->val
);
8108 /* Hack around 'unused var' error for some targets here */
8109 (void) mem_cnt
, (void) i
;
8110 target_resources_ok
= TARGET_CAN_USE_HARDWARE_WATCHPOINT (
8111 bpt
->type
, i
+ mem_cnt
, other_type_used
);
8112 /* we can consider of type is bp_hardware_watchpoint, convert to
8113 bp_watchpoint in the following condition */
8114 if (target_resources_ok
< 0)
8116 printf_filtered (_("\
8117 Cannot enable watchpoint %d because target watch resources\n\
8118 have been allocated for other watchpoints.\n"), bpt
->number
);
8119 value_free_to_mark (mark
);
8124 select_frame (frame_find_by_id (saved_frame_id
));
8125 value_free_to_mark (mark
);
8128 if (bpt
->enable_state
!= bp_permanent
)
8129 bpt
->enable_state
= bp_enabled
;
8130 bpt
->disposition
= disposition
;
8131 check_duplicates (bpt
);
8132 breakpoints_changed ();
8134 if (deprecated_modify_breakpoint_hook
)
8135 deprecated_modify_breakpoint_hook (bpt
);
8136 breakpoint_modify_event (bpt
->number
);
8141 enable_breakpoint (struct breakpoint
*bpt
)
8143 do_enable_breakpoint (bpt
, bpt
->disposition
);
8146 /* The enable command enables the specified breakpoints (or all defined
8147 breakpoints) so they once again become (or continue to be) effective
8148 in stopping the inferior. */
8151 enable_command (char *args
, int from_tty
)
8153 struct breakpoint
*bpt
;
8155 ALL_BREAKPOINTS (bpt
)
8159 warning (_("attempted to enable apparently deleted breakpoint #%d?"),
8164 case bp_catch_unload
:
8166 case bp_catch_vfork
:
8168 case bp_catch_catch
:
8169 case bp_catch_throw
:
8170 case bp_hardware_breakpoint
:
8172 case bp_hardware_watchpoint
:
8173 case bp_read_watchpoint
:
8174 case bp_access_watchpoint
:
8175 enable_breakpoint (bpt
);
8179 else if (strchr (args
, '.'))
8181 struct bp_location
*loc
= find_location_by_number (args
);
8184 check_duplicates (loc
->owner
);
8187 map_breakpoint_numbers (args
, enable_breakpoint
);
8191 enable_once_breakpoint (struct breakpoint
*bpt
)
8193 do_enable_breakpoint (bpt
, disp_disable
);
8197 enable_once_command (char *args
, int from_tty
)
8199 map_breakpoint_numbers (args
, enable_once_breakpoint
);
8203 enable_delete_breakpoint (struct breakpoint
*bpt
)
8205 do_enable_breakpoint (bpt
, disp_del
);
8209 enable_delete_command (char *args
, int from_tty
)
8211 map_breakpoint_numbers (args
, enable_delete_breakpoint
);
8215 set_breakpoint_cmd (char *args
, int from_tty
)
8220 show_breakpoint_cmd (char *args
, int from_tty
)
8224 /* Use default_breakpoint_'s, or nothing if they aren't valid. */
8226 struct symtabs_and_lines
8227 decode_line_spec_1 (char *string
, int funfirstline
)
8229 struct symtabs_and_lines sals
;
8231 error (_("Empty line specification."));
8232 if (default_breakpoint_valid
)
8233 sals
= decode_line_1 (&string
, funfirstline
,
8234 default_breakpoint_symtab
,
8235 default_breakpoint_line
,
8236 (char ***) NULL
, NULL
);
8238 sals
= decode_line_1 (&string
, funfirstline
,
8239 (struct symtab
*) NULL
, 0, (char ***) NULL
, NULL
);
8241 error (_("Junk at end of line specification: %s"), string
);
8245 /* Create and insert a raw software breakpoint at PC. Return an
8246 identifier, which should be used to remove the breakpoint later.
8247 In general, places which call this should be using something on the
8248 breakpoint chain instead; this function should be eliminated
8252 deprecated_insert_raw_breakpoint (CORE_ADDR pc
)
8254 struct bp_target_info
*bp_tgt
;
8256 bp_tgt
= xmalloc (sizeof (struct bp_target_info
));
8257 memset (bp_tgt
, 0, sizeof (struct bp_target_info
));
8259 bp_tgt
->placed_address
= pc
;
8260 if (target_insert_breakpoint (bp_tgt
) != 0)
8262 /* Could not insert the breakpoint. */
8270 /* Remove a breakpoint BP inserted by deprecated_insert_raw_breakpoint. */
8273 deprecated_remove_raw_breakpoint (void *bp
)
8275 struct bp_target_info
*bp_tgt
= bp
;
8278 ret
= target_remove_breakpoint (bp_tgt
);
8284 /* One (or perhaps two) breakpoints used for software single stepping. */
8286 static void *single_step_breakpoints
[2];
8288 /* Create and insert a breakpoint for software single step. */
8291 insert_single_step_breakpoint (CORE_ADDR next_pc
)
8295 if (single_step_breakpoints
[0] == NULL
)
8296 bpt_p
= &single_step_breakpoints
[0];
8299 gdb_assert (single_step_breakpoints
[1] == NULL
);
8300 bpt_p
= &single_step_breakpoints
[1];
8303 /* NOTE drow/2006-04-11: A future improvement to this function would be
8304 to only create the breakpoints once, and actually put them on the
8305 breakpoint chain. That would let us use set_raw_breakpoint. We could
8306 adjust the addresses each time they were needed. Doing this requires
8307 corresponding changes elsewhere where single step breakpoints are
8308 handled, however. So, for now, we use this. */
8310 *bpt_p
= deprecated_insert_raw_breakpoint (next_pc
);
8312 error (_("Could not insert single-step breakpoint at 0x%s"),
8313 paddr_nz (next_pc
));
8316 /* Remove and delete any breakpoints used for software single step. */
8319 remove_single_step_breakpoints (void)
8321 gdb_assert (single_step_breakpoints
[0] != NULL
);
8323 /* See insert_single_step_breakpoint for more about this deprecated
8325 deprecated_remove_raw_breakpoint (single_step_breakpoints
[0]);
8326 single_step_breakpoints
[0] = NULL
;
8328 if (single_step_breakpoints
[1] != NULL
)
8330 deprecated_remove_raw_breakpoint (single_step_breakpoints
[1]);
8331 single_step_breakpoints
[1] = NULL
;
8335 /* Check whether a software single-step breakpoint is inserted at PC. */
8338 single_step_breakpoint_inserted_here_p (CORE_ADDR pc
)
8342 for (i
= 0; i
< 2; i
++)
8344 struct bp_target_info
*bp_tgt
= single_step_breakpoints
[i
];
8345 if (bp_tgt
&& bp_tgt
->placed_address
== pc
)
8353 /* This help string is used for the break, hbreak, tbreak and thbreak commands.
8354 It is defined as a macro to prevent duplication.
8355 COMMAND should be a string constant containing the name of the command. */
8356 #define BREAK_ARGS_HELP(command) \
8357 command" [LOCATION] [thread THREADNUM] [if CONDITION]\n\
8358 LOCATION may be a line number, function name, or \"*\" and an address.\n\
8359 If a line number is specified, break at start of code for that line.\n\
8360 If a function is specified, break at start of code for that function.\n\
8361 If an address is specified, break at that exact address.\n\
8362 With no LOCATION, uses current execution address of selected stack frame.\n\
8363 This is useful for breaking on return to a stack frame.\n\
8365 THREADNUM is the number from \"info threads\".\n\
8366 CONDITION is a boolean expression.\n\
8368 Multiple breakpoints at one place are permitted, and useful if conditional.\n\
8370 Do \"help breakpoints\" for info on other commands dealing with breakpoints."
8373 _initialize_breakpoint (void)
8375 static struct cmd_list_element
*breakpoint_set_cmdlist
;
8376 static struct cmd_list_element
*breakpoint_show_cmdlist
;
8377 struct cmd_list_element
*c
;
8379 observer_attach_solib_unloaded (disable_breakpoints_in_unloaded_shlib
);
8381 breakpoint_chain
= 0;
8382 /* Don't bother to call set_breakpoint_count. $bpnum isn't useful
8383 before a breakpoint is set. */
8384 breakpoint_count
= 0;
8386 add_com ("ignore", class_breakpoint
, ignore_command
, _("\
8387 Set ignore-count of breakpoint number N to COUNT.\n\
8388 Usage is `ignore N COUNT'."));
8390 add_com_alias ("bc", "ignore", class_breakpoint
, 1);
8392 add_com ("commands", class_breakpoint
, commands_command
, _("\
8393 Set commands to be executed when a breakpoint is hit.\n\
8394 Give breakpoint number as argument after \"commands\".\n\
8395 With no argument, the targeted breakpoint is the last one set.\n\
8396 The commands themselves follow starting on the next line.\n\
8397 Type a line containing \"end\" to indicate the end of them.\n\
8398 Give \"silent\" as the first line to make the breakpoint silent;\n\
8399 then no output is printed when it is hit, except what the commands print."));
8401 add_com ("condition", class_breakpoint
, condition_command
, _("\
8402 Specify breakpoint number N to break only if COND is true.\n\
8403 Usage is `condition N COND', where N is an integer and COND is an\n\
8404 expression to be evaluated whenever breakpoint N is reached."));
8406 c
= add_com ("tbreak", class_breakpoint
, tbreak_command
, _("\
8407 Set a temporary breakpoint.\n\
8408 Like \"break\" except the breakpoint is only temporary,\n\
8409 so it will be deleted when hit. Equivalent to \"break\" followed\n\
8410 by using \"enable delete\" on the breakpoint number.\n\
8412 BREAK_ARGS_HELP ("tbreak")));
8413 set_cmd_completer (c
, location_completer
);
8415 c
= add_com ("hbreak", class_breakpoint
, hbreak_command
, _("\
8416 Set a hardware assisted breakpoint.\n\
8417 Like \"break\" except the breakpoint requires hardware support,\n\
8418 some target hardware may not have this support.\n\
8420 BREAK_ARGS_HELP ("hbreak")));
8421 set_cmd_completer (c
, location_completer
);
8423 c
= add_com ("thbreak", class_breakpoint
, thbreak_command
, _("\
8424 Set a temporary hardware assisted breakpoint.\n\
8425 Like \"hbreak\" except the breakpoint is only temporary,\n\
8426 so it will be deleted when hit.\n\
8428 BREAK_ARGS_HELP ("thbreak")));
8429 set_cmd_completer (c
, location_completer
);
8431 add_prefix_cmd ("enable", class_breakpoint
, enable_command
, _("\
8432 Enable some breakpoints.\n\
8433 Give breakpoint numbers (separated by spaces) as arguments.\n\
8434 With no subcommand, breakpoints are enabled until you command otherwise.\n\
8435 This is used to cancel the effect of the \"disable\" command.\n\
8436 With a subcommand you can enable temporarily."),
8437 &enablelist
, "enable ", 1, &cmdlist
);
8439 add_com ("ab", class_breakpoint
, enable_command
, _("\
8440 Enable some breakpoints.\n\
8441 Give breakpoint numbers (separated by spaces) as arguments.\n\
8442 With no subcommand, breakpoints are enabled until you command otherwise.\n\
8443 This is used to cancel the effect of the \"disable\" command.\n\
8444 With a subcommand you can enable temporarily."));
8446 add_com_alias ("en", "enable", class_breakpoint
, 1);
8448 add_abbrev_prefix_cmd ("breakpoints", class_breakpoint
, enable_command
, _("\
8449 Enable some breakpoints.\n\
8450 Give breakpoint numbers (separated by spaces) as arguments.\n\
8451 This is used to cancel the effect of the \"disable\" command.\n\
8452 May be abbreviated to simply \"enable\".\n"),
8453 &enablebreaklist
, "enable breakpoints ", 1, &enablelist
);
8455 add_cmd ("once", no_class
, enable_once_command
, _("\
8456 Enable breakpoints for one hit. Give breakpoint numbers.\n\
8457 If a breakpoint is hit while enabled in this fashion, it becomes disabled."),
8460 add_cmd ("delete", no_class
, enable_delete_command
, _("\
8461 Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
8462 If a breakpoint is hit while enabled in this fashion, it is deleted."),
8465 add_cmd ("delete", no_class
, enable_delete_command
, _("\
8466 Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
8467 If a breakpoint is hit while enabled in this fashion, it is deleted."),
8470 add_cmd ("once", no_class
, enable_once_command
, _("\
8471 Enable breakpoints for one hit. Give breakpoint numbers.\n\
8472 If a breakpoint is hit while enabled in this fashion, it becomes disabled."),
8475 add_prefix_cmd ("disable", class_breakpoint
, disable_command
, _("\
8476 Disable some breakpoints.\n\
8477 Arguments are breakpoint numbers with spaces in between.\n\
8478 To disable all breakpoints, give no argument.\n\
8479 A disabled breakpoint is not forgotten, but has no effect until reenabled."),
8480 &disablelist
, "disable ", 1, &cmdlist
);
8481 add_com_alias ("dis", "disable", class_breakpoint
, 1);
8482 add_com_alias ("disa", "disable", class_breakpoint
, 1);
8484 add_com ("sb", class_breakpoint
, disable_command
, _("\
8485 Disable some breakpoints.\n\
8486 Arguments are breakpoint numbers with spaces in between.\n\
8487 To disable all breakpoints, give no argument.\n\
8488 A disabled breakpoint is not forgotten, but has no effect until reenabled."));
8490 add_cmd ("breakpoints", class_alias
, disable_command
, _("\
8491 Disable some breakpoints.\n\
8492 Arguments are breakpoint numbers with spaces in between.\n\
8493 To disable all breakpoints, give no argument.\n\
8494 A disabled breakpoint is not forgotten, but has no effect until reenabled.\n\
8495 This command may be abbreviated \"disable\"."),
8498 add_prefix_cmd ("delete", class_breakpoint
, delete_command
, _("\
8499 Delete some breakpoints or auto-display expressions.\n\
8500 Arguments are breakpoint numbers with spaces in between.\n\
8501 To delete all breakpoints, give no argument.\n\
8503 Also a prefix command for deletion of other GDB objects.\n\
8504 The \"unset\" command is also an alias for \"delete\"."),
8505 &deletelist
, "delete ", 1, &cmdlist
);
8506 add_com_alias ("d", "delete", class_breakpoint
, 1);
8507 add_com_alias ("del", "delete", class_breakpoint
, 1);
8509 add_com ("db", class_breakpoint
, delete_command
, _("\
8510 Delete some breakpoints.\n\
8511 Arguments are breakpoint numbers with spaces in between.\n\
8512 To delete all breakpoints, give no argument.\n"));
8514 add_cmd ("breakpoints", class_alias
, delete_command
, _("\
8515 Delete some breakpoints or auto-display expressions.\n\
8516 Arguments are breakpoint numbers with spaces in between.\n\
8517 To delete all breakpoints, give no argument.\n\
8518 This command may be abbreviated \"delete\"."),
8521 add_com ("clear", class_breakpoint
, clear_command
, _("\
8522 Clear breakpoint at specified line or function.\n\
8523 Argument may be line number, function name, or \"*\" and an address.\n\
8524 If line number is specified, all breakpoints in that line are cleared.\n\
8525 If function is specified, breakpoints at beginning of function are cleared.\n\
8526 If an address is specified, breakpoints at that address are cleared.\n\
8528 With no argument, clears all breakpoints in the line that the selected frame\n\
8531 See also the \"delete\" command which clears breakpoints by number."));
8533 c
= add_com ("break", class_breakpoint
, break_command
, _("\
8534 Set breakpoint at specified line or function.\n"
8535 BREAK_ARGS_HELP ("break")));
8536 set_cmd_completer (c
, location_completer
);
8538 add_com_alias ("b", "break", class_run
, 1);
8539 add_com_alias ("br", "break", class_run
, 1);
8540 add_com_alias ("bre", "break", class_run
, 1);
8541 add_com_alias ("brea", "break", class_run
, 1);
8545 add_com_alias ("ba", "break", class_breakpoint
, 1);
8546 add_com_alias ("bu", "ubreak", class_breakpoint
, 1);
8551 add_abbrev_prefix_cmd ("stop", class_breakpoint
, stop_command
, _("\
8552 Break in function/address or break at a line in the current file."),
8553 &stoplist
, "stop ", 1, &cmdlist
);
8554 add_cmd ("in", class_breakpoint
, stopin_command
,
8555 _("Break in function or address."), &stoplist
);
8556 add_cmd ("at", class_breakpoint
, stopat_command
,
8557 _("Break at a line in the current file."), &stoplist
);
8558 add_com ("status", class_info
, breakpoints_info
, _("\
8559 Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
8560 The \"Type\" column indicates one of:\n\
8561 \tbreakpoint - normal breakpoint\n\
8562 \twatchpoint - watchpoint\n\
8563 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
8564 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
8565 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
8566 address and file/line number respectively.\n\
8568 Convenience variable \"$_\" and default examine address for \"x\"\n\
8569 are set to the address of the last breakpoint listed unless the command\n\
8570 is prefixed with \"server \".\n\n\
8571 Convenience variable \"$bpnum\" contains the number of the last\n\
8575 add_info ("breakpoints", breakpoints_info
, _("\
8576 Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
8577 The \"Type\" column indicates one of:\n\
8578 \tbreakpoint - normal breakpoint\n\
8579 \twatchpoint - watchpoint\n\
8580 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
8581 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
8582 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
8583 address and file/line number respectively.\n\
8585 Convenience variable \"$_\" and default examine address for \"x\"\n\
8586 are set to the address of the last breakpoint listed unless the command\n\
8587 is prefixed with \"server \".\n\n\
8588 Convenience variable \"$bpnum\" contains the number of the last\n\
8592 add_com ("lb", class_breakpoint
, breakpoints_info
, _("\
8593 Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
8594 The \"Type\" column indicates one of:\n\
8595 \tbreakpoint - normal breakpoint\n\
8596 \twatchpoint - watchpoint\n\
8597 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
8598 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
8599 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
8600 address and file/line number respectively.\n\
8602 Convenience variable \"$_\" and default examine address for \"x\"\n\
8603 are set to the address of the last breakpoint listed unless the command\n\
8604 is prefixed with \"server \".\n\n\
8605 Convenience variable \"$bpnum\" contains the number of the last\n\
8608 add_cmd ("breakpoints", class_maintenance
, maintenance_info_breakpoints
, _("\
8609 Status of all breakpoints, or breakpoint number NUMBER.\n\
8610 The \"Type\" column indicates one of:\n\
8611 \tbreakpoint - normal breakpoint\n\
8612 \twatchpoint - watchpoint\n\
8613 \tlongjmp - internal breakpoint used to step through longjmp()\n\
8614 \tlongjmp resume - internal breakpoint at the target of longjmp()\n\
8615 \tuntil - internal breakpoint used by the \"until\" command\n\
8616 \tfinish - internal breakpoint used by the \"finish\" command\n\
8617 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
8618 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
8619 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
8620 address and file/line number respectively.\n\
8622 Convenience variable \"$_\" and default examine address for \"x\"\n\
8623 are set to the address of the last breakpoint listed unless the command\n\
8624 is prefixed with \"server \".\n\n\
8625 Convenience variable \"$bpnum\" contains the number of the last\n\
8627 &maintenanceinfolist
);
8629 add_com ("catch", class_breakpoint
, catch_command
, _("\
8630 Set catchpoints to catch events.\n\
8631 Raised signals may be caught:\n\
8632 \tcatch signal - all signals\n\
8633 \tcatch signal <signame> - a particular signal\n\
8634 Raised exceptions may be caught:\n\
8635 \tcatch throw - all exceptions, when thrown\n\
8636 \tcatch throw <exceptname> - a particular exception, when thrown\n\
8637 \tcatch catch - all exceptions, when caught\n\
8638 \tcatch catch <exceptname> - a particular exception, when caught\n\
8639 Thread or process events may be caught:\n\
8640 \tcatch thread_start - any threads, just after creation\n\
8641 \tcatch thread_exit - any threads, just before expiration\n\
8642 \tcatch thread_join - any threads, just after joins\n\
8643 Process events may be caught:\n\
8644 \tcatch start - any processes, just after creation\n\
8645 \tcatch exit - any processes, just before expiration\n\
8646 \tcatch fork - calls to fork()\n\
8647 \tcatch vfork - calls to vfork()\n\
8648 \tcatch exec - calls to exec()\n\
8649 Dynamically-linked library events may be caught:\n\
8650 \tcatch load - loads of any library\n\
8651 \tcatch load <libname> - loads of a particular library\n\
8652 \tcatch unload - unloads of any library\n\
8653 \tcatch unload <libname> - unloads of a particular library\n\
8654 The act of your program's execution stopping may also be caught:\n\
8656 C++ exceptions may be caught:\n\
8657 \tcatch throw - all exceptions, when thrown\n\
8658 \tcatch catch - all exceptions, when caught\n\
8659 Ada exceptions may be caught:\n\
8660 \tcatch exception - all exceptions, when raised\n\
8661 \tcatch exception <name> - a particular exception, when raised\n\
8662 \tcatch exception unhandled - all unhandled exceptions, when raised\n\
8663 \tcatch assert - all failed assertions, when raised\n\
8665 Do \"help set follow-fork-mode\" for info on debugging your program\n\
8666 after a fork or vfork is caught.\n\n\
8667 Do \"help breakpoints\" for info on other commands dealing with breakpoints."));
8669 add_com ("tcatch", class_breakpoint
, tcatch_command
, _("\
8670 Set temporary catchpoints to catch events.\n\
8671 Args like \"catch\" command.\n\
8672 Like \"catch\" except the catchpoint is only temporary,\n\
8673 so it will be deleted when hit. Equivalent to \"catch\" followed\n\
8674 by using \"enable delete\" on the catchpoint number."));
8676 c
= add_com ("watch", class_breakpoint
, watch_command
, _("\
8677 Set a watchpoint for an expression.\n\
8678 A watchpoint stops execution of your program whenever the value of\n\
8679 an expression changes."));
8680 set_cmd_completer (c
, location_completer
);
8682 c
= add_com ("rwatch", class_breakpoint
, rwatch_command
, _("\
8683 Set a read watchpoint for an expression.\n\
8684 A watchpoint stops execution of your program whenever the value of\n\
8685 an expression is read."));
8686 set_cmd_completer (c
, location_completer
);
8688 c
= add_com ("awatch", class_breakpoint
, awatch_command
, _("\
8689 Set a watchpoint for an expression.\n\
8690 A watchpoint stops execution of your program whenever the value of\n\
8691 an expression is either read or written."));
8692 set_cmd_completer (c
, location_completer
);
8694 add_info ("watchpoints", breakpoints_info
,
8695 _("Synonym for ``info breakpoints''."));
8698 /* XXX: cagney/2005-02-23: This should be a boolean, and should
8699 respond to changes - contrary to the description. */
8700 add_setshow_zinteger_cmd ("can-use-hw-watchpoints", class_support
,
8701 &can_use_hw_watchpoints
, _("\
8702 Set debugger's willingness to use watchpoint hardware."), _("\
8703 Show debugger's willingness to use watchpoint hardware."), _("\
8704 If zero, gdb will not use hardware for new watchpoints, even if\n\
8705 such is available. (However, any hardware watchpoints that were\n\
8706 created before setting this to nonzero, will continue to use watchpoint\n\
8709 show_can_use_hw_watchpoints
,
8710 &setlist
, &showlist
);
8712 can_use_hw_watchpoints
= 1;
8714 add_prefix_cmd ("breakpoint", class_maintenance
, set_breakpoint_cmd
, _("\
8715 Breakpoint specific settings\n\
8716 Configure various breakpoint-specific variables such as\n\
8717 pending breakpoint behavior"),
8718 &breakpoint_set_cmdlist
, "set breakpoint ",
8719 0/*allow-unknown*/, &setlist
);
8720 add_prefix_cmd ("breakpoint", class_maintenance
, show_breakpoint_cmd
, _("\
8721 Breakpoint specific settings\n\
8722 Configure various breakpoint-specific variables such as\n\
8723 pending breakpoint behavior"),
8724 &breakpoint_show_cmdlist
, "show breakpoint ",
8725 0/*allow-unknown*/, &showlist
);
8727 add_setshow_auto_boolean_cmd ("pending", no_class
,
8728 &pending_break_support
, _("\
8729 Set debugger's behavior regarding pending breakpoints."), _("\
8730 Show debugger's behavior regarding pending breakpoints."), _("\
8731 If on, an unrecognized breakpoint location will cause gdb to create a\n\
8732 pending breakpoint. If off, an unrecognized breakpoint location results in\n\
8733 an error. If auto, an unrecognized breakpoint location results in a\n\
8734 user-query to see if a pending breakpoint should be created."),
8736 show_pending_break_support
,
8737 &breakpoint_set_cmdlist
,
8738 &breakpoint_show_cmdlist
);
8740 pending_break_support
= AUTO_BOOLEAN_AUTO
;
8742 add_setshow_boolean_cmd ("auto-hw", no_class
,
8743 &automatic_hardware_breakpoints
, _("\
8744 Set automatic usage of hardware breakpoints."), _("\
8745 Show automatic usage of hardware breakpoints."), _("\
8746 If set, the debugger will automatically use hardware breakpoints for\n\
8747 breakpoints set with \"break\" but falling in read-only memory. If not set,\n\
8748 a warning will be emitted for such breakpoints."),
8750 show_automatic_hardware_breakpoints
,
8751 &breakpoint_set_cmdlist
,
8752 &breakpoint_show_cmdlist
);
8754 automatic_hardware_breakpoints
= 1;