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
++)
5487 resolve_sal_pc (&sals
->sals
[i
]);
5489 /* It's possible for the PC to be nonzero, but still an illegal
5490 value on some targets.
5492 For example, on HP-UX if you start gdb, and before running the
5493 inferior you try to set a breakpoint on a shared library function
5494 "foo" where the inferior doesn't call "foo" directly but does
5495 pass its address to another function call, then we do find a
5496 minimal symbol for the "foo", but it's address is invalid.
5497 (Appears to be an index into a table that the loader sets up
5498 when the inferior is run.)
5500 Give the target a chance to bless sals.sals[i].pc before we
5501 try to make a breakpoint for it. */
5502 #ifdef DEPRECATED_PC_REQUIRES_RUN_BEFORE_USE
5503 if (DEPRECATED_PC_REQUIRES_RUN_BEFORE_USE (sals
->sals
[i
].pc
))
5505 if (address
== NULL
)
5506 error (_("Cannot break without a running program."));
5508 error (_("Cannot break on %s without a running program."),
5516 do_captured_parse_breakpoint (struct ui_out
*ui
, void *data
)
5518 struct captured_parse_breakpoint_args
*args
= data
;
5520 parse_breakpoint_sals (args
->arg_p
, args
->sals_p
, args
->addr_string_p
,
5521 args
->not_found_ptr
);
5524 /* Given TOK, a string specification of condition and thread, as
5525 accepted by the 'break' command, extract the condition
5526 string and thread number and set *COND_STRING and *THREAD.
5527 PC identifies the context at which the condition should be parsed.
5528 If no condition is found, *COND_STRING is set to NULL.
5529 If no thread is found, *THREAD is set to -1. */
5531 find_condition_and_thread (char *tok
, CORE_ADDR pc
,
5532 char **cond_string
, int *thread
)
5534 *cond_string
= NULL
;
5540 char *cond_start
= NULL
;
5541 char *cond_end
= NULL
;
5542 while (*tok
== ' ' || *tok
== '\t')
5547 while (*end_tok
!= ' ' && *end_tok
!= '\t' && *end_tok
!= '\000')
5550 toklen
= end_tok
- tok
;
5552 if (toklen
>= 1 && strncmp (tok
, "if", toklen
) == 0)
5554 tok
= cond_start
= end_tok
+ 1;
5555 parse_exp_1 (&tok
, block_for_pc (pc
), 0);
5557 *cond_string
= savestring (cond_start
,
5558 cond_end
- cond_start
);
5560 else if (toklen
>= 1 && strncmp (tok
, "thread", toklen
) == 0)
5566 *thread
= strtol (tok
, &tok
, 0);
5568 error (_("Junk after thread keyword."));
5569 if (!valid_thread_id (*thread
))
5570 error (_("Unknown thread %d."), *thread
);
5573 error (_("Junk at end of arguments."));
5577 /* Set a breakpoint according to ARG (function, linenum or *address)
5578 flag: first bit : 0 non-temporary, 1 temporary.
5579 second bit : 0 normal breakpoint, 1 hardware breakpoint.
5581 PENDING_BP is non-NULL when this function is being called to resolve
5582 a pending breakpoint. */
5585 break_command_1 (char *arg
, int flag
, int from_tty
, struct breakpoint
*pending_bp
)
5587 struct gdb_exception e
;
5588 int tempflag
, hardwareflag
;
5589 struct symtabs_and_lines sals
;
5590 struct symtab_and_line pending_sal
;
5591 char *cond_string
= NULL
;
5594 char *addr_start
= arg
;
5596 struct cleanup
*old_chain
;
5597 struct cleanup
*breakpoint_chain
= NULL
;
5598 struct captured_parse_breakpoint_args parse_args
;
5602 int ignore_count
= 0;
5605 hardwareflag
= flag
& BP_HARDWAREFLAG
;
5606 tempflag
= flag
& BP_TEMPFLAG
;
5612 parse_args
.arg_p
= &arg
;
5613 parse_args
.sals_p
= &sals
;
5614 parse_args
.addr_string_p
= &addr_string
;
5615 parse_args
.not_found_ptr
= ¬_found
;
5617 e
= catch_exception (uiout
, do_captured_parse_breakpoint
,
5618 &parse_args
, RETURN_MASK_ALL
);
5620 /* If caller is interested in rc value from parse, set value. */
5624 exception_print (gdb_stderr
, e
);
5629 case NOT_FOUND_ERROR
:
5630 /* If called to resolve pending breakpoint, just return
5635 exception_print (gdb_stderr
, e
);
5637 /* If pending breakpoint support is turned off, throw
5640 if (pending_break_support
== AUTO_BOOLEAN_FALSE
)
5641 deprecated_throw_reason (RETURN_ERROR
);
5643 /* If pending breakpoint support is auto query and the user
5644 selects no, then simply return the error code. */
5645 if (pending_break_support
== AUTO_BOOLEAN_AUTO
&&
5646 !nquery ("Make breakpoint pending on future shared library load? "))
5649 /* At this point, either the user was queried about setting
5650 a pending breakpoint and selected yes, or pending
5651 breakpoint behavior is on and thus a pending breakpoint
5652 is defaulted on behalf of the user. */
5653 copy_arg
= xstrdup (addr_start
);
5654 addr_string
= ©_arg
;
5656 sals
.sals
= &pending_sal
;
5661 exception_print (gdb_stderr
, e
);
5669 /* Create a chain of things that always need to be cleaned up. */
5670 old_chain
= make_cleanup (null_cleanup
, 0);
5674 /* Make sure that all storage allocated to SALS gets freed. */
5675 make_cleanup (xfree
, sals
.sals
);
5677 /* Cleanup the addr_string array but not its contents. */
5678 make_cleanup (xfree
, addr_string
);
5681 /* ----------------------------- SNIP -----------------------------
5682 Anything added to the cleanup chain beyond this point is assumed
5683 to be part of a breakpoint. If the breakpoint create succeeds
5684 then the memory is not reclaimed. */
5685 breakpoint_chain
= make_cleanup (null_cleanup
, 0);
5687 /* Mark the contents of the addr_string for cleanup. These go on
5688 the breakpoint_chain and only occure if the breakpoint create
5690 for (i
= 0; i
< sals
.nelts
; i
++)
5692 if (addr_string
[i
] != NULL
)
5693 make_cleanup (xfree
, addr_string
[i
]);
5696 /* Resolve all line numbers to PC's and verify that the addresses
5697 are ok for the target. */
5699 breakpoint_sals_to_pc (&sals
, addr_start
);
5701 /* Verify that condition can be parsed, before setting any
5702 breakpoints. Allocate a separate condition expression for each
5706 /* Here we only parse 'arg' to separate condition
5707 from thread number, so parsing in context of first
5708 sal is OK. When setting the breakpoint we'll
5709 re-parse it in context of each sal. */
5710 find_condition_and_thread (arg
, sals
.sals
[0].pc
, &cond_string
, &thread
);
5712 make_cleanup (xfree
, cond_string
);
5713 create_breakpoints (sals
, addr_string
, cond_string
,
5714 hardwareflag
? bp_hardware_breakpoint
5716 tempflag
? disp_del
: disp_donttouch
,
5717 thread
, ignore_count
, from_tty
,
5722 struct symtab_and_line sal
= {0};
5723 struct breakpoint
*b
;
5725 make_cleanup (xfree
, copy_arg
);
5727 b
= set_raw_breakpoint_without_location (hardwareflag
5728 ? bp_hardware_breakpoint
5730 set_breakpoint_count (breakpoint_count
+ 1);
5731 b
->number
= breakpoint_count
;
5733 b
->addr_string
= addr_string
[0];
5734 b
->cond_string
= cond_string
;
5735 b
->ignore_count
= ignore_count
;
5736 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
5737 b
->from_tty
= from_tty
;
5739 b
->condition_not_parsed
= 1;
5744 warning (_("Multiple breakpoints were set.\n"
5745 "Use the \"delete\" command to delete unwanted breakpoints."));
5746 /* That's it. Discard the cleanups for data inserted into the
5748 discard_cleanups (breakpoint_chain
);
5749 /* But cleanup everything else. */
5750 do_cleanups (old_chain
);
5755 /* Set a breakpoint of TYPE/DISPOSITION according to ARG (function,
5756 linenum or *address) with COND and IGNORE_COUNT. */
5758 struct captured_breakpoint_args
5769 do_captured_breakpoint (struct ui_out
*uiout
, void *data
)
5771 struct captured_breakpoint_args
*args
= data
;
5772 struct symtabs_and_lines sals
;
5773 struct expression
**cond
;
5774 struct cleanup
*old_chain
;
5775 struct cleanup
*breakpoint_chain
= NULL
;
5778 char *cond_string
= 0;
5782 /* Parse the source and lines spec. Delay check that the expression
5783 didn't contain trailing garbage until after cleanups are in
5787 address_end
= args
->address
;
5789 parse_breakpoint_sals (&address_end
, &sals
, &addr_string
, 0);
5794 /* Create a chain of things at always need to be cleaned up. */
5795 old_chain
= make_cleanup (null_cleanup
, 0);
5797 /* Always have a addr_string array, even if it is empty. */
5798 make_cleanup (xfree
, addr_string
);
5800 /* Make sure that all storage allocated to SALS gets freed. */
5801 make_cleanup (xfree
, sals
.sals
);
5803 /* Allocate space for all the cond expressions. */
5804 cond
= xcalloc (sals
.nelts
, sizeof (struct expression
*));
5805 make_cleanup (xfree
, cond
);
5807 /* ----------------------------- SNIP -----------------------------
5808 Anything added to the cleanup chain beyond this point is assumed
5809 to be part of a breakpoint. If the breakpoint create goes
5810 through then that memory is not cleaned up. */
5811 breakpoint_chain
= make_cleanup (null_cleanup
, 0);
5813 /* Mark the contents of the addr_string for cleanup. These go on
5814 the breakpoint_chain and only occure if the breakpoint create
5816 for (i
= 0; i
< sals
.nelts
; i
++)
5818 if (addr_string
[i
] != NULL
)
5819 make_cleanup (xfree
, addr_string
[i
]);
5822 /* Wait until now before checking for garbage at the end of the
5823 address. That way cleanups can take care of freeing any
5825 if (*address_end
!= '\0')
5826 error (_("Garbage %s following breakpoint address"), address_end
);
5828 /* Resolve all line numbers to PC's. */
5829 breakpoint_sals_to_pc (&sals
, args
->address
);
5831 if (args
->condition
!= NULL
)
5833 cond_string
= xstrdup (args
->condition
);
5834 make_cleanup (xfree
, cond_string
);
5837 create_breakpoints (sals
, addr_string
, args
->condition
,
5838 args
->hardwareflag
? bp_hardware_breakpoint
: bp_breakpoint
,
5839 args
->tempflag
? disp_del
: disp_donttouch
,
5840 args
->thread
, args
->ignore_count
, 0/*from-tty*/,
5841 NULL
/*pending_bp*/);
5843 /* That's it. Discard the cleanups for data inserted into the
5845 discard_cleanups (breakpoint_chain
);
5846 /* But cleanup everything else. */
5847 do_cleanups (old_chain
);
5852 gdb_breakpoint (char *address
, char *condition
,
5853 int hardwareflag
, int tempflag
,
5854 int thread
, int ignore_count
,
5855 char **error_message
)
5857 struct captured_breakpoint_args args
;
5858 args
.address
= address
;
5859 args
.condition
= condition
;
5860 args
.hardwareflag
= hardwareflag
;
5861 args
.tempflag
= tempflag
;
5862 args
.thread
= thread
;
5863 args
.ignore_count
= ignore_count
;
5864 if (catch_exceptions_with_msg (uiout
, do_captured_breakpoint
, &args
,
5865 error_message
, RETURN_MASK_ALL
) < 0)
5872 /* Helper function for break_command_1 and disassemble_command. */
5875 resolve_sal_pc (struct symtab_and_line
*sal
)
5879 if (sal
->pc
== 0 && sal
->symtab
!= NULL
)
5881 if (!find_line_pc (sal
->symtab
, sal
->line
, &pc
))
5882 error (_("No line %d in file \"%s\"."),
5883 sal
->line
, sal
->symtab
->filename
);
5887 if (sal
->section
== 0 && sal
->symtab
!= NULL
)
5889 struct blockvector
*bv
;
5894 bv
= blockvector_for_pc_sect (sal
->pc
, 0, &index
, sal
->symtab
);
5897 b
= BLOCKVECTOR_BLOCK (bv
, index
);
5898 sym
= block_function (b
);
5901 fixup_symbol_section (sym
, sal
->symtab
->objfile
);
5902 sal
->section
= SYMBOL_BFD_SECTION (sym
);
5906 /* It really is worthwhile to have the section, so we'll just
5907 have to look harder. This case can be executed if we have
5908 line numbers but no functions (as can happen in assembly
5911 struct minimal_symbol
*msym
;
5913 msym
= lookup_minimal_symbol_by_pc (sal
->pc
);
5915 sal
->section
= SYMBOL_BFD_SECTION (msym
);
5922 break_command (char *arg
, int from_tty
)
5924 break_command_1 (arg
, 0, from_tty
, NULL
);
5928 tbreak_command (char *arg
, int from_tty
)
5930 break_command_1 (arg
, BP_TEMPFLAG
, from_tty
, NULL
);
5934 hbreak_command (char *arg
, int from_tty
)
5936 break_command_1 (arg
, BP_HARDWAREFLAG
, from_tty
, NULL
);
5940 thbreak_command (char *arg
, int from_tty
)
5942 break_command_1 (arg
, (BP_TEMPFLAG
| BP_HARDWAREFLAG
), from_tty
, NULL
);
5946 stop_command (char *arg
, int from_tty
)
5948 printf_filtered (_("Specify the type of breakpoint to set.\n\
5949 Usage: stop in <function | address>\n\
5950 stop at <line>\n"));
5954 stopin_command (char *arg
, int from_tty
)
5958 if (arg
== (char *) NULL
)
5960 else if (*arg
!= '*')
5965 /* look for a ':'. If this is a line number specification, then
5966 say it is bad, otherwise, it should be an address or
5967 function/method name */
5968 while (*argptr
&& !hasColon
)
5970 hasColon
= (*argptr
== ':');
5975 badInput
= (*argptr
!= ':'); /* Not a class::method */
5977 badInput
= isdigit (*arg
); /* a simple line number */
5981 printf_filtered (_("Usage: stop in <function | address>\n"));
5983 break_command_1 (arg
, 0, from_tty
, NULL
);
5987 stopat_command (char *arg
, int from_tty
)
5991 if (arg
== (char *) NULL
|| *arg
== '*') /* no line number */
5998 /* look for a ':'. If there is a '::' then get out, otherwise
5999 it is probably a line number. */
6000 while (*argptr
&& !hasColon
)
6002 hasColon
= (*argptr
== ':');
6007 badInput
= (*argptr
== ':'); /* we have class::method */
6009 badInput
= !isdigit (*arg
); /* not a line number */
6013 printf_filtered (_("Usage: stop at <line>\n"));
6015 break_command_1 (arg
, 0, from_tty
, NULL
);
6018 /* accessflag: hw_write: watch write,
6019 hw_read: watch read,
6020 hw_access: watch access (read or write) */
6022 watch_command_1 (char *arg
, int accessflag
, int from_tty
)
6024 struct breakpoint
*b
, *scope_breakpoint
= NULL
;
6025 struct symtab_and_line sal
;
6026 struct expression
*exp
;
6027 struct block
*exp_valid_block
;
6028 struct value
*val
, *mark
;
6029 struct frame_info
*frame
;
6030 struct frame_info
*prev_frame
= NULL
;
6031 char *exp_start
= NULL
;
6032 char *exp_end
= NULL
;
6033 char *tok
, *end_tok
;
6035 char *cond_start
= NULL
;
6036 char *cond_end
= NULL
;
6037 struct expression
*cond
= NULL
;
6038 int i
, other_type_used
, target_resources_ok
= 0;
6039 enum bptype bp_type
;
6042 init_sal (&sal
); /* initialize to zeroes */
6044 /* Parse arguments. */
6045 innermost_block
= NULL
;
6047 exp
= parse_exp_1 (&arg
, 0, 0);
6049 exp_valid_block
= innermost_block
;
6050 mark
= value_mark ();
6051 val
= evaluate_expression (exp
);
6052 release_value (val
);
6053 if (value_lazy (val
))
6054 value_fetch_lazy (val
);
6057 while (*tok
== ' ' || *tok
== '\t')
6061 while (*end_tok
!= ' ' && *end_tok
!= '\t' && *end_tok
!= '\000')
6064 toklen
= end_tok
- tok
;
6065 if (toklen
>= 1 && strncmp (tok
, "if", toklen
) == 0)
6067 tok
= cond_start
= end_tok
+ 1;
6068 cond
= parse_exp_1 (&tok
, 0, 0);
6072 error (_("Junk at end of command."));
6074 if (accessflag
== hw_read
)
6075 bp_type
= bp_read_watchpoint
;
6076 else if (accessflag
== hw_access
)
6077 bp_type
= bp_access_watchpoint
;
6079 bp_type
= bp_hardware_watchpoint
;
6081 mem_cnt
= can_use_hardware_watchpoint (val
);
6082 if (mem_cnt
== 0 && bp_type
!= bp_hardware_watchpoint
)
6083 error (_("Expression cannot be implemented with read/access watchpoint."));
6086 i
= hw_watchpoint_used_count (bp_type
, &other_type_used
);
6087 target_resources_ok
=
6088 TARGET_CAN_USE_HARDWARE_WATCHPOINT (bp_type
, i
+ mem_cnt
,
6090 if (target_resources_ok
== 0 && bp_type
!= bp_hardware_watchpoint
)
6091 error (_("Target does not support this type of hardware watchpoint."));
6093 if (target_resources_ok
< 0 && bp_type
!= bp_hardware_watchpoint
)
6094 error (_("Target can only support one kind of HW watchpoint at a time."));
6097 /* Change the type of breakpoint to an ordinary watchpoint if a hardware
6098 watchpoint could not be set. */
6099 if (!mem_cnt
|| target_resources_ok
<= 0)
6100 bp_type
= bp_watchpoint
;
6102 frame
= block_innermost_frame (exp_valid_block
);
6104 prev_frame
= get_prev_frame (frame
);
6108 /* If the expression is "local", then set up a "watchpoint scope"
6109 breakpoint at the point where we've left the scope of the watchpoint
6110 expression. Create the scope breakpoint before the watchpoint, so
6111 that we will encounter it first in bpstat_stop_status. */
6112 if (innermost_block
&& prev_frame
)
6114 scope_breakpoint
= create_internal_breakpoint (get_frame_pc (prev_frame
),
6115 bp_watchpoint_scope
);
6117 scope_breakpoint
->enable_state
= bp_enabled
;
6119 /* Automatically delete the breakpoint when it hits. */
6120 scope_breakpoint
->disposition
= disp_del
;
6122 /* Only break in the proper frame (help with recursion). */
6123 scope_breakpoint
->frame_id
= get_frame_id (prev_frame
);
6125 /* Set the address at which we will stop. */
6126 scope_breakpoint
->loc
->requested_address
6127 = get_frame_pc (prev_frame
);
6128 scope_breakpoint
->loc
->address
6129 = adjust_breakpoint_address (scope_breakpoint
->loc
->requested_address
,
6130 scope_breakpoint
->type
);
6133 /* Now set up the breakpoint. */
6134 b
= set_raw_breakpoint (sal
, bp_type
);
6135 set_breakpoint_count (breakpoint_count
+ 1);
6136 b
->number
= breakpoint_count
;
6137 b
->disposition
= disp_donttouch
;
6139 b
->exp_valid_block
= exp_valid_block
;
6140 b
->exp_string
= savestring (exp_start
, exp_end
- exp_start
);
6142 b
->loc
->cond
= cond
;
6144 b
->cond_string
= savestring (cond_start
, cond_end
- cond_start
);
6149 b
->watchpoint_frame
= get_frame_id (frame
);
6151 memset (&b
->watchpoint_frame
, 0, sizeof (b
->watchpoint_frame
));
6153 if (scope_breakpoint
!= NULL
)
6155 /* The scope breakpoint is related to the watchpoint. We will
6156 need to act on them together. */
6157 b
->related_breakpoint
= scope_breakpoint
;
6158 scope_breakpoint
->related_breakpoint
= b
;
6161 value_free_to_mark (mark
);
6165 /* Return count of locations need to be watched and can be handled
6166 in hardware. If the watchpoint can not be handled
6167 in hardware return zero. */
6170 can_use_hardware_watchpoint (struct value
*v
)
6172 int found_memory_cnt
= 0;
6173 struct value
*head
= v
;
6175 /* Did the user specifically forbid us to use hardware watchpoints? */
6176 if (!can_use_hw_watchpoints
)
6179 /* Make sure that the value of the expression depends only upon
6180 memory contents, and values computed from them within GDB. If we
6181 find any register references or function calls, we can't use a
6182 hardware watchpoint.
6184 The idea here is that evaluating an expression generates a series
6185 of values, one holding the value of every subexpression. (The
6186 expression a*b+c has five subexpressions: a, b, a*b, c, and
6187 a*b+c.) GDB's values hold almost enough information to establish
6188 the criteria given above --- they identify memory lvalues,
6189 register lvalues, computed values, etcetera. So we can evaluate
6190 the expression, and then scan the chain of values that leaves
6191 behind to decide whether we can detect any possible change to the
6192 expression's final value using only hardware watchpoints.
6194 However, I don't think that the values returned by inferior
6195 function calls are special in any way. So this function may not
6196 notice that an expression involving an inferior function call
6197 can't be watched with hardware watchpoints. FIXME. */
6198 for (; v
; v
= value_next (v
))
6200 if (VALUE_LVAL (v
) == lval_memory
)
6203 /* A lazy memory lvalue is one that GDB never needed to fetch;
6204 we either just used its address (e.g., `a' in `a.b') or
6205 we never needed it at all (e.g., `a' in `a,b'). */
6209 /* Ahh, memory we actually used! Check if we can cover
6210 it with hardware watchpoints. */
6211 struct type
*vtype
= check_typedef (value_type (v
));
6213 /* We only watch structs and arrays if user asked for it
6214 explicitly, never if they just happen to appear in a
6215 middle of some value chain. */
6217 || (TYPE_CODE (vtype
) != TYPE_CODE_STRUCT
6218 && TYPE_CODE (vtype
) != TYPE_CODE_ARRAY
))
6220 CORE_ADDR vaddr
= VALUE_ADDRESS (v
) + value_offset (v
);
6221 int len
= TYPE_LENGTH (value_type (v
));
6223 if (!TARGET_REGION_OK_FOR_HW_WATCHPOINT (vaddr
, len
))
6230 else if (VALUE_LVAL (v
) != not_lval
6231 && deprecated_value_modifiable (v
) == 0)
6232 return 0; /* ??? What does this represent? */
6233 else if (VALUE_LVAL (v
) == lval_register
)
6234 return 0; /* cannot watch a register with a HW watchpoint */
6237 /* The expression itself looks suitable for using a hardware
6238 watchpoint, but give the target machine a chance to reject it. */
6239 return found_memory_cnt
;
6243 watch_command_wrapper (char *arg
, int from_tty
)
6245 watch_command (arg
, from_tty
);
6249 watch_command (char *arg
, int from_tty
)
6251 watch_command_1 (arg
, hw_write
, from_tty
);
6255 rwatch_command_wrapper (char *arg
, int from_tty
)
6257 rwatch_command (arg
, from_tty
);
6261 rwatch_command (char *arg
, int from_tty
)
6263 watch_command_1 (arg
, hw_read
, from_tty
);
6267 awatch_command_wrapper (char *arg
, int from_tty
)
6269 awatch_command (arg
, from_tty
);
6273 awatch_command (char *arg
, int from_tty
)
6275 watch_command_1 (arg
, hw_access
, from_tty
);
6279 /* Helper routines for the until_command routine in infcmd.c. Here
6280 because it uses the mechanisms of breakpoints. */
6282 /* This function is called by fetch_inferior_event via the
6283 cmd_continuation pointer, to complete the until command. It takes
6284 care of cleaning up the temporary breakpoints set up by the until
6287 until_break_command_continuation (struct continuation_arg
*arg
)
6289 struct cleanup
*cleanups
;
6291 cleanups
= (struct cleanup
*) arg
->data
.pointer
;
6292 do_exec_cleanups (cleanups
);
6296 until_break_command (char *arg
, int from_tty
, int anywhere
)
6298 struct symtabs_and_lines sals
;
6299 struct symtab_and_line sal
;
6300 struct frame_info
*frame
= get_selected_frame (NULL
);
6301 struct frame_info
*prev_frame
= get_prev_frame (frame
);
6302 struct breakpoint
*breakpoint
;
6303 struct cleanup
*old_chain
;
6304 struct continuation_arg
*arg1
;
6307 clear_proceed_status ();
6309 /* Set a breakpoint where the user wants it and at return from
6312 if (default_breakpoint_valid
)
6313 sals
= decode_line_1 (&arg
, 1, default_breakpoint_symtab
,
6314 default_breakpoint_line
, (char ***) NULL
, NULL
);
6316 sals
= decode_line_1 (&arg
, 1, (struct symtab
*) NULL
,
6317 0, (char ***) NULL
, NULL
);
6319 if (sals
.nelts
!= 1)
6320 error (_("Couldn't get information on specified line."));
6323 xfree (sals
.sals
); /* malloc'd, so freed */
6326 error (_("Junk at end of arguments."));
6328 resolve_sal_pc (&sal
);
6331 /* If the user told us to continue until a specified location,
6332 we don't specify a frame at which we need to stop. */
6333 breakpoint
= set_momentary_breakpoint (sal
, null_frame_id
, bp_until
);
6335 /* Otherwise, specify the current frame, because we want to stop only
6336 at the very same frame. */
6337 breakpoint
= set_momentary_breakpoint (sal
, get_frame_id (frame
),
6340 if (!target_can_async_p ())
6341 old_chain
= make_cleanup_delete_breakpoint (breakpoint
);
6343 old_chain
= make_exec_cleanup_delete_breakpoint (breakpoint
);
6345 /* If we are running asynchronously, and the target supports async
6346 execution, we are not waiting for the target to stop, in the call
6347 tp proceed, below. This means that we cannot delete the
6348 brekpoints until the target has actually stopped. The only place
6349 where we get a chance to do that is in fetch_inferior_event, so
6350 we must set things up for that. */
6352 if (target_can_async_p ())
6354 /* In this case the arg for the continuation is just the point
6355 in the exec_cleanups chain from where to start doing
6356 cleanups, because all the continuation does is the cleanups in
6357 the exec_cleanup_chain. */
6359 (struct continuation_arg
*) xmalloc (sizeof (struct continuation_arg
));
6361 arg1
->data
.pointer
= old_chain
;
6363 add_continuation (until_break_command_continuation
, arg1
);
6366 /* Keep within the current frame, or in frames called by the current
6370 sal
= find_pc_line (get_frame_pc (prev_frame
), 0);
6371 sal
.pc
= get_frame_pc (prev_frame
);
6372 breakpoint
= set_momentary_breakpoint (sal
, get_frame_id (prev_frame
),
6374 if (!target_can_async_p ())
6375 make_cleanup_delete_breakpoint (breakpoint
);
6377 make_exec_cleanup_delete_breakpoint (breakpoint
);
6380 proceed (-1, TARGET_SIGNAL_DEFAULT
, 0);
6381 /* Do the cleanups now, anly if we are not running asynchronously,
6382 of if we are, but the target is still synchronous. */
6383 if (!target_can_async_p ())
6384 do_cleanups (old_chain
);
6388 ep_skip_leading_whitespace (char **s
)
6390 if ((s
== NULL
) || (*s
== NULL
))
6392 while (isspace (**s
))
6396 /* This function examines a string, and attempts to find a token
6397 that might be an event name in the leading characters. If a
6398 possible match is found, a pointer to the last character of
6399 the token is returned. Else, NULL is returned. */
6402 ep_find_event_name_end (char *arg
)
6405 char *event_name_end
= NULL
;
6407 /* If we could depend upon the presense of strrpbrk, we'd use that... */
6411 /* We break out of the loop when we find a token delimiter.
6412 Basically, we're looking for alphanumerics and underscores;
6413 anything else delimites the token. */
6416 if (!isalnum (*s
) && (*s
!= '_'))
6422 return event_name_end
;
6426 /* This function attempts to parse an optional "if <cond>" clause
6427 from the arg string. If one is not found, it returns NULL.
6429 Else, it returns a pointer to the condition string. (It does not
6430 attempt to evaluate the string against a particular block.) And,
6431 it updates arg to point to the first character following the parsed
6432 if clause in the arg string. */
6435 ep_parse_optional_if_clause (char **arg
)
6439 if (((*arg
)[0] != 'i') || ((*arg
)[1] != 'f') || !isspace ((*arg
)[2]))
6442 /* Skip the "if" keyword. */
6445 /* Skip any extra leading whitespace, and record the start of the
6446 condition string. */
6447 ep_skip_leading_whitespace (arg
);
6450 /* Assume that the condition occupies the remainder of the arg string. */
6451 (*arg
) += strlen (cond_string
);
6456 /* This function attempts to parse an optional filename from the arg
6457 string. If one is not found, it returns NULL.
6459 Else, it returns a pointer to the parsed filename. (This function
6460 makes no attempt to verify that a file of that name exists, or is
6461 accessible.) And, it updates arg to point to the first character
6462 following the parsed filename in the arg string.
6464 Note that clients needing to preserve the returned filename for
6465 future access should copy it to their own buffers. */
6467 ep_parse_optional_filename (char **arg
)
6469 static char filename
[1024];
6474 if ((*arg_p
== '\0') || isspace (*arg_p
))
6492 /* Commands to deal with catching events, such as signals, exceptions,
6493 process start/exit, etc. */
6497 catch_fork
, catch_vfork
6502 catch_fork_command_1 (catch_fork_kind fork_kind
, char *arg
, int tempflag
,
6505 char *cond_string
= NULL
;
6507 ep_skip_leading_whitespace (&arg
);
6509 /* The allowed syntax is:
6511 catch [v]fork if <cond>
6513 First, check if there's an if clause. */
6514 cond_string
= ep_parse_optional_if_clause (&arg
);
6516 if ((*arg
!= '\0') && !isspace (*arg
))
6517 error (_("Junk at end of arguments."));
6519 /* If this target supports it, create a fork or vfork catchpoint
6520 and enable reporting of such events. */
6524 create_fork_event_catchpoint (tempflag
, cond_string
);
6527 create_vfork_event_catchpoint (tempflag
, cond_string
);
6530 error (_("unsupported or unknown fork kind; cannot catch it"));
6536 catch_exec_command_1 (char *arg
, int tempflag
, int from_tty
)
6538 char *cond_string
= NULL
;
6540 ep_skip_leading_whitespace (&arg
);
6542 /* The allowed syntax is:
6544 catch exec if <cond>
6546 First, check if there's an if clause. */
6547 cond_string
= ep_parse_optional_if_clause (&arg
);
6549 if ((*arg
!= '\0') && !isspace (*arg
))
6550 error (_("Junk at end of arguments."));
6552 /* If this target supports it, create an exec catchpoint
6553 and enable reporting of such events. */
6554 create_exec_event_catchpoint (tempflag
, cond_string
);
6558 catch_load_command_1 (char *arg
, int tempflag
, int from_tty
)
6560 char *dll_pathname
= NULL
;
6561 char *cond_string
= NULL
;
6563 ep_skip_leading_whitespace (&arg
);
6565 /* The allowed syntax is:
6567 catch load if <cond>
6568 catch load <filename>
6569 catch load <filename> if <cond>
6571 The user is not allowed to specify the <filename> after an
6574 We'll ignore the pathological case of a file named "if".
6576 First, check if there's an if clause. If so, then there
6577 cannot be a filename. */
6578 cond_string
= ep_parse_optional_if_clause (&arg
);
6580 /* If there was an if clause, then there cannot be a filename.
6581 Else, there might be a filename and an if clause. */
6582 if (cond_string
== NULL
)
6584 dll_pathname
= ep_parse_optional_filename (&arg
);
6585 ep_skip_leading_whitespace (&arg
);
6586 cond_string
= ep_parse_optional_if_clause (&arg
);
6589 if ((*arg
!= '\0') && !isspace (*arg
))
6590 error (_("Junk at end of arguments."));
6592 /* Create a load breakpoint that only triggers when a load of
6593 the specified dll (or any dll, if no pathname was specified)
6595 SOLIB_CREATE_CATCH_LOAD_HOOK (PIDGET (inferior_ptid
), tempflag
,
6596 dll_pathname
, cond_string
);
6600 catch_unload_command_1 (char *arg
, int tempflag
, int from_tty
)
6602 char *dll_pathname
= NULL
;
6603 char *cond_string
= NULL
;
6605 ep_skip_leading_whitespace (&arg
);
6607 /* The allowed syntax is:
6609 catch unload if <cond>
6610 catch unload <filename>
6611 catch unload <filename> if <cond>
6613 The user is not allowed to specify the <filename> after an
6616 We'll ignore the pathological case of a file named "if".
6618 First, check if there's an if clause. If so, then there
6619 cannot be a filename. */
6620 cond_string
= ep_parse_optional_if_clause (&arg
);
6622 /* If there was an if clause, then there cannot be a filename.
6623 Else, there might be a filename and an if clause. */
6624 if (cond_string
== NULL
)
6626 dll_pathname
= ep_parse_optional_filename (&arg
);
6627 ep_skip_leading_whitespace (&arg
);
6628 cond_string
= ep_parse_optional_if_clause (&arg
);
6631 if ((*arg
!= '\0') && !isspace (*arg
))
6632 error (_("Junk at end of arguments."));
6634 /* Create an unload breakpoint that only triggers when an unload of
6635 the specified dll (or any dll, if no pathname was specified)
6637 SOLIB_CREATE_CATCH_UNLOAD_HOOK (PIDGET (inferior_ptid
), tempflag
,
6638 dll_pathname
, cond_string
);
6641 /* Commands to deal with catching exceptions. */
6643 /* Set a breakpoint at the specified callback routine for an
6644 exception event callback */
6647 create_exception_catchpoint (int tempflag
, char *cond_string
,
6648 enum exception_event_kind ex_event
,
6649 struct symtab_and_line
*sal
)
6651 struct breakpoint
*b
;
6652 int thread
= -1; /* All threads. */
6655 if (!sal
) /* no exception support? */
6660 case EX_EVENT_THROW
:
6661 bptype
= bp_catch_throw
;
6663 case EX_EVENT_CATCH
:
6664 bptype
= bp_catch_catch
;
6666 default: /* error condition */
6667 error (_("Internal error -- invalid catchpoint kind"));
6670 b
= set_raw_breakpoint (*sal
, bptype
);
6671 set_breakpoint_count (breakpoint_count
+ 1);
6672 b
->number
= breakpoint_count
;
6673 b
->cond_string
= (cond_string
== NULL
) ?
6674 NULL
: savestring (cond_string
, strlen (cond_string
));
6676 b
->addr_string
= NULL
;
6677 b
->enable_state
= bp_enabled
;
6678 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
6682 static enum print_stop_action
6683 print_exception_catchpoint (struct breakpoint
*b
)
6685 annotate_catchpoint (b
->number
);
6687 if (strstr (b
->addr_string
, "throw") != NULL
)
6688 printf_filtered (_("\nCatchpoint %d (exception thrown)\n"),
6691 printf_filtered (_("\nCatchpoint %d (exception caught)\n"),
6694 return PRINT_SRC_AND_LOC
;
6698 print_one_exception_catchpoint (struct breakpoint
*b
, CORE_ADDR
*last_addr
)
6703 ui_out_field_core_addr (uiout
, "addr", b
->loc
->address
);
6706 *last_addr
= b
->loc
->address
;
6707 if (strstr (b
->addr_string
, "throw") != NULL
)
6708 ui_out_field_string (uiout
, "what", "exception throw");
6710 ui_out_field_string (uiout
, "what", "exception catch");
6714 print_mention_exception_catchpoint (struct breakpoint
*b
)
6716 if (strstr (b
->addr_string
, "throw") != NULL
)
6717 printf_filtered (_("Catchpoint %d (throw)"), b
->number
);
6719 printf_filtered (_("Catchpoint %d (catch)"), b
->number
);
6722 static struct breakpoint_ops gnu_v3_exception_catchpoint_ops
= {
6723 print_exception_catchpoint
,
6724 print_one_exception_catchpoint
,
6725 print_mention_exception_catchpoint
6729 handle_gnu_v3_exceptions (int tempflag
, char *cond_string
,
6730 enum exception_event_kind ex_event
, int from_tty
)
6732 char *trigger_func_name
, *nameptr
;
6733 struct symtabs_and_lines sals
;
6734 struct breakpoint
*b
;
6736 if (ex_event
== EX_EVENT_CATCH
)
6737 trigger_func_name
= xstrdup ("__cxa_begin_catch");
6739 trigger_func_name
= xstrdup ("__cxa_throw");
6741 nameptr
= trigger_func_name
;
6742 sals
= decode_line_1 (&nameptr
, 1, NULL
, 0, NULL
, NULL
);
6743 if (sals
.nelts
== 0)
6745 xfree (trigger_func_name
);
6749 b
= set_raw_breakpoint (sals
.sals
[0], bp_breakpoint
);
6750 set_breakpoint_count (breakpoint_count
+ 1);
6751 b
->number
= breakpoint_count
;
6752 b
->cond_string
= (cond_string
== NULL
) ?
6753 NULL
: savestring (cond_string
, strlen (cond_string
));
6755 b
->addr_string
= trigger_func_name
;
6756 b
->enable_state
= bp_enabled
;
6757 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
6758 b
->ops
= &gnu_v3_exception_catchpoint_ops
;
6765 /* Deal with "catch catch" and "catch throw" commands */
6768 catch_exception_command_1 (enum exception_event_kind ex_event
, char *arg
,
6769 int tempflag
, int from_tty
)
6771 char *cond_string
= NULL
;
6772 struct symtab_and_line
*sal
= NULL
;
6774 ep_skip_leading_whitespace (&arg
);
6776 cond_string
= ep_parse_optional_if_clause (&arg
);
6778 if ((*arg
!= '\0') && !isspace (*arg
))
6779 error (_("Junk at end of arguments."));
6781 if ((ex_event
!= EX_EVENT_THROW
) &&
6782 (ex_event
!= EX_EVENT_CATCH
))
6783 error (_("Unsupported or unknown exception event; cannot catch it"));
6785 if (handle_gnu_v3_exceptions (tempflag
, cond_string
, ex_event
, from_tty
))
6788 /* See if we can find a callback routine */
6789 sal
= target_enable_exception_callback (ex_event
, 1);
6793 /* We have callbacks from the runtime system for exceptions.
6794 Set a breakpoint on the sal found, if no errors */
6795 if (sal
!= (struct symtab_and_line
*) -1)
6796 create_exception_catchpoint (tempflag
, cond_string
, ex_event
, sal
);
6798 return; /* something went wrong with setting up callbacks */
6801 warning (_("Unsupported with this platform/compiler combination."));
6804 /* Create a breakpoint struct for Ada exception catchpoints. */
6807 create_ada_exception_breakpoint (struct symtab_and_line sal
,
6811 struct expression
*cond
,
6812 struct breakpoint_ops
*ops
,
6816 struct breakpoint
*b
;
6820 describe_other_breakpoints (sal
.pc
, sal
.section
, -1);
6821 /* FIXME: brobecker/2006-12-28: Actually, re-implement a special
6822 version for exception catchpoints, because two catchpoints
6823 used for different exception names will use the same address.
6824 In this case, a "breakpoint ... also set at..." warning is
6825 unproductive. Besides. the warning phrasing is also a bit
6826 inapropriate, we should use the word catchpoint, and tell
6827 the user what type of catchpoint it is. The above is good
6828 enough for now, though. */
6831 b
= set_raw_breakpoint (sal
, bp_breakpoint
);
6832 set_breakpoint_count (breakpoint_count
+ 1);
6834 b
->enable_state
= bp_enabled
;
6835 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
6836 b
->number
= breakpoint_count
;
6837 b
->ignore_count
= 0;
6838 b
->loc
->cond
= cond
;
6839 b
->addr_string
= addr_string
;
6840 b
->language
= language_ada
;
6841 b
->cond_string
= cond_string
;
6842 b
->exp_string
= exp_string
;
6845 b
->from_tty
= from_tty
;
6850 /* Implement the "catch exception" command. */
6853 catch_ada_exception_command (char *arg
, int tempflag
, int from_tty
)
6855 struct symtab_and_line sal
;
6857 char *addr_string
= NULL
;
6858 char *exp_string
= NULL
;
6859 char *cond_string
= NULL
;
6860 struct expression
*cond
= NULL
;
6861 struct breakpoint_ops
*ops
= NULL
;
6863 sal
= ada_decode_exception_location (arg
, &addr_string
, &exp_string
,
6864 &cond_string
, &cond
, &ops
);
6865 create_ada_exception_breakpoint (sal
, addr_string
, exp_string
,
6866 cond_string
, cond
, ops
, tempflag
,
6870 /* Implement the "catch assert" command. */
6873 catch_assert_command (char *arg
, int tempflag
, int from_tty
)
6875 struct symtab_and_line sal
;
6876 char *addr_string
= NULL
;
6877 struct breakpoint_ops
*ops
= NULL
;
6879 sal
= ada_decode_assert_location (arg
, &addr_string
, &ops
);
6880 create_ada_exception_breakpoint (sal
, addr_string
, NULL
, NULL
, NULL
, ops
,
6881 tempflag
, from_tty
);
6884 /* Cover routine to allow wrapping target_enable_exception_catchpoints
6885 inside a catch_errors */
6888 cover_target_enable_exception_callback (void *arg
)
6890 args_for_catchpoint_enable
*args
= arg
;
6891 struct symtab_and_line
*sal
;
6892 sal
= target_enable_exception_callback (args
->kind
, args
->enable_p
);
6895 else if (sal
== (struct symtab_and_line
*) -1)
6898 return 1; /*is valid */
6902 catch_command_1 (char *arg
, int tempflag
, int from_tty
)
6905 /* The first argument may be an event name, such as "start" or "load".
6906 If so, then handle it as such. If it doesn't match an event name,
6907 then attempt to interpret it as an exception name. (This latter is
6908 the v4.16-and-earlier GDB meaning of the "catch" command.)
6910 First, try to find the bounds of what might be an event name. */
6911 char *arg1_start
= arg
;
6915 if (arg1_start
== NULL
)
6917 /* Old behaviour was to use pre-v-4.16 syntax */
6918 /* catch_throw_command_1 (arg1_start, tempflag, from_tty); */
6920 /* Now, this is not allowed */
6921 error (_("Catch requires an event name."));
6924 arg1_end
= ep_find_event_name_end (arg1_start
);
6925 if (arg1_end
== NULL
)
6926 error (_("catch requires an event"));
6927 arg1_length
= arg1_end
+ 1 - arg1_start
;
6929 /* Try to match what we found against known event names. */
6930 if (strncmp (arg1_start
, "signal", arg1_length
) == 0)
6932 error (_("Catch of signal not yet implemented"));
6934 else if (strncmp (arg1_start
, "catch", arg1_length
) == 0)
6936 catch_exception_command_1 (EX_EVENT_CATCH
, arg1_end
+ 1,
6937 tempflag
, from_tty
);
6939 else if (strncmp (arg1_start
, "throw", arg1_length
) == 0)
6941 catch_exception_command_1 (EX_EVENT_THROW
, arg1_end
+ 1,
6942 tempflag
, from_tty
);
6944 else if (strncmp (arg1_start
, "thread_start", arg1_length
) == 0)
6946 error (_("Catch of thread_start not yet implemented"));
6948 else if (strncmp (arg1_start
, "thread_exit", arg1_length
) == 0)
6950 error (_("Catch of thread_exit not yet implemented"));
6952 else if (strncmp (arg1_start
, "thread_join", arg1_length
) == 0)
6954 error (_("Catch of thread_join not yet implemented"));
6956 else if (strncmp (arg1_start
, "start", arg1_length
) == 0)
6958 error (_("Catch of start not yet implemented"));
6960 else if (strncmp (arg1_start
, "exit", arg1_length
) == 0)
6962 error (_("Catch of exit not yet implemented"));
6964 else if (strncmp (arg1_start
, "fork", arg1_length
) == 0)
6966 catch_fork_command_1 (catch_fork
, arg1_end
+ 1, tempflag
, from_tty
);
6968 else if (strncmp (arg1_start
, "vfork", arg1_length
) == 0)
6970 catch_fork_command_1 (catch_vfork
, arg1_end
+ 1, tempflag
, from_tty
);
6972 else if (strncmp (arg1_start
, "exec", arg1_length
) == 0)
6974 catch_exec_command_1 (arg1_end
+ 1, tempflag
, from_tty
);
6976 else if (strncmp (arg1_start
, "load", arg1_length
) == 0)
6978 catch_load_command_1 (arg1_end
+ 1, tempflag
, from_tty
);
6980 else if (strncmp (arg1_start
, "unload", arg1_length
) == 0)
6982 catch_unload_command_1 (arg1_end
+ 1, tempflag
, from_tty
);
6984 else if (strncmp (arg1_start
, "stop", arg1_length
) == 0)
6986 error (_("Catch of stop not yet implemented"));
6988 else if (strncmp (arg1_start
, "exception", arg1_length
) == 0)
6990 catch_ada_exception_command (arg1_end
+ 1, tempflag
, from_tty
);
6993 else if (strncmp (arg1_start
, "assert", arg1_length
) == 0)
6995 catch_assert_command (arg1_end
+ 1, tempflag
, from_tty
);
6998 /* This doesn't appear to be an event name */
7002 /* Pre-v.4.16 behaviour was to treat the argument
7003 as the name of an exception */
7004 /* catch_throw_command_1 (arg1_start, tempflag, from_tty); */
7005 /* Now this is not allowed */
7006 error (_("Unknown event kind specified for catch"));
7011 /* Used by the gui, could be made a worker for other things. */
7014 set_breakpoint_sal (struct symtab_and_line sal
)
7016 struct breakpoint
*b
;
7017 b
= set_raw_breakpoint (sal
, bp_breakpoint
);
7018 set_breakpoint_count (breakpoint_count
+ 1);
7019 b
->number
= breakpoint_count
;
7025 catch_command (char *arg
, int from_tty
)
7027 catch_command_1 (arg
, 0, from_tty
);
7032 tcatch_command (char *arg
, int from_tty
)
7034 catch_command_1 (arg
, 1, from_tty
);
7037 /* Delete breakpoints by address or line. */
7040 clear_command (char *arg
, int from_tty
)
7042 struct breakpoint
*b
, *tmp
, *prev
, *found
;
7044 struct symtabs_and_lines sals
;
7045 struct symtab_and_line sal
;
7050 sals
= decode_line_spec (arg
, 1);
7055 sals
.sals
= (struct symtab_and_line
*)
7056 xmalloc (sizeof (struct symtab_and_line
));
7057 make_cleanup (xfree
, sals
.sals
);
7058 init_sal (&sal
); /* initialize to zeroes */
7059 sal
.line
= default_breakpoint_line
;
7060 sal
.symtab
= default_breakpoint_symtab
;
7061 sal
.pc
= default_breakpoint_address
;
7062 if (sal
.symtab
== 0)
7063 error (_("No source file specified."));
7071 /* We don't call resolve_sal_pc here. That's not
7072 as bad as it seems, because all existing breakpoints
7073 typically have both file/line and pc set. So, if
7074 clear is given file/line, we can match this to existing
7075 breakpoint without obtaining pc at all.
7077 We only support clearing given the address explicitly
7078 present in breakpoint table. Say, we've set breakpoint
7079 at file:line. There were several PC values for that file:line,
7080 due to optimization, all in one block.
7081 We've picked one PC value. If "clear" is issued with another
7082 PC corresponding to the same file:line, the breakpoint won't
7083 be cleared. We probably can still clear the breakpoint, but
7084 since the other PC value is never presented to user, user
7085 can only find it by guessing, and it does not seem important
7088 /* For each line spec given, delete bps which correspond
7089 to it. Do it in two passes, solely to preserve the current
7090 behavior that from_tty is forced true if we delete more than
7094 for (i
= 0; i
< sals
.nelts
; i
++)
7096 /* If exact pc given, clear bpts at that pc.
7097 If line given (pc == 0), clear all bpts on specified line.
7098 If defaulting, clear all bpts on default line
7101 defaulting sal.pc != 0 tests to do
7106 1 0 <can't happen> */
7111 /* Find all matching breakpoints, remove them from the
7112 breakpoint chain, and add them to the 'found' chain. */
7113 ALL_BREAKPOINTS_SAFE (b
, tmp
)
7116 /* Are we going to delete b? */
7117 if (b
->type
!= bp_none
7118 && b
->type
!= bp_watchpoint
7119 && b
->type
!= bp_hardware_watchpoint
7120 && b
->type
!= bp_read_watchpoint
7121 && b
->type
!= bp_access_watchpoint
)
7123 struct bp_location
*loc
= b
->loc
;
7124 for (; loc
; loc
= loc
->next
)
7126 int pc_match
= sal
.pc
7127 && (loc
->address
== sal
.pc
)
7128 && (!section_is_overlay (loc
->section
)
7129 || loc
->section
== sal
.section
);
7130 int line_match
= ((default_match
|| (0 == sal
.pc
))
7131 && b
->source_file
!= NULL
7132 && sal
.symtab
!= NULL
7133 && strcmp (b
->source_file
, sal
.symtab
->filename
) == 0
7134 && b
->line_number
== sal
.line
);
7135 if (pc_match
|| line_match
)
7145 /* Remove it from breakpoint_chain... */
7146 if (b
== breakpoint_chain
)
7148 /* b is at the head of the list */
7149 breakpoint_chain
= b
->next
;
7153 prev
->next
= b
->next
;
7155 /* And add it to 'found' chain. */
7161 /* Keep b, and keep a pointer to it. */
7166 /* Now go thru the 'found' chain and delete them. */
7170 error (_("No breakpoint at %s."), arg
);
7172 error (_("No breakpoint at this line."));
7176 from_tty
= 1; /* Always report if deleted more than one */
7180 printf_unfiltered (_("Deleted breakpoint "));
7182 printf_unfiltered (_("Deleted breakpoints "));
7184 breakpoints_changed ();
7188 printf_unfiltered ("%d ", found
->number
);
7190 delete_breakpoint (found
);
7194 putchar_unfiltered ('\n');
7197 /* Delete breakpoint in BS if they are `delete' breakpoints and
7198 all breakpoints that are marked for deletion, whether hit or not.
7199 This is called after any breakpoint is hit, or after errors. */
7202 breakpoint_auto_delete (bpstat bs
)
7204 struct breakpoint
*b
, *temp
;
7206 for (; bs
; bs
= bs
->next
)
7207 if (bs
->breakpoint_at
&& bs
->breakpoint_at
->owner
->disposition
== disp_del
7209 delete_breakpoint (bs
->breakpoint_at
->owner
);
7211 ALL_BREAKPOINTS_SAFE (b
, temp
)
7213 if (b
->disposition
== disp_del_at_next_stop
)
7214 delete_breakpoint (b
);
7218 /* Remove locations of breakpoint BPT from
7219 the global list of breakpoint locations. */
7222 unlink_locations_from_global_list (struct breakpoint
*bpt
)
7224 /* This code assumes that the locations
7225 of a breakpoint are found in the global list
7226 in the same order, but not necessary adjacent. */
7227 struct bp_location
**tmp
= &bp_location_chain
;
7228 struct bp_location
*here
= bpt
->loc
;
7233 for (; *tmp
&& here
;)
7237 *tmp
= here
->global_next
;
7242 tmp
= &((*tmp
)->global_next
);
7247 /* Delete a breakpoint and clean up all traces of it in the data
7251 delete_breakpoint (struct breakpoint
*bpt
)
7253 struct breakpoint
*b
;
7255 struct bp_location
*loc
;
7257 gdb_assert (bpt
!= NULL
);
7259 /* Has this bp already been deleted? This can happen because multiple
7260 lists can hold pointers to bp's. bpstat lists are especial culprits.
7262 One example of this happening is a watchpoint's scope bp. When the
7263 scope bp triggers, we notice that the watchpoint is out of scope, and
7264 delete it. We also delete its scope bp. But the scope bp is marked
7265 "auto-deleting", and is already on a bpstat. That bpstat is then
7266 checked for auto-deleting bp's, which are deleted.
7268 A real solution to this problem might involve reference counts in bp's,
7269 and/or giving them pointers back to their referencing bpstat's, and
7270 teaching delete_breakpoint to only free a bp's storage when no more
7271 references were extent. A cheaper bandaid was chosen. */
7272 if (bpt
->type
== bp_none
)
7275 if (deprecated_delete_breakpoint_hook
)
7276 deprecated_delete_breakpoint_hook (bpt
);
7277 breakpoint_delete_event (bpt
->number
);
7279 for (loc
= bpt
->loc
; loc
; loc
= loc
->next
)
7282 remove_breakpoint (loc
, mark_inserted
);
7284 free_valchain (loc
);
7289 if (loc
->function_name
)
7290 xfree (loc
->function_name
);
7293 if (breakpoint_chain
== bpt
)
7294 breakpoint_chain
= bpt
->next
;
7296 /* If we have callback-style exception catchpoints, don't go through
7297 the adjustments to the C++ runtime library etc. if the inferior
7298 isn't actually running. target_enable_exception_callback for a
7299 null target ops vector gives an undesirable error message, so we
7300 check here and avoid it. Since currently (1997-09-17) only HP-UX aCC's
7301 exceptions are supported in this way, it's OK for now. FIXME */
7302 if (ep_is_exception_catchpoint (bpt
) && target_has_execution
)
7304 /* Format possible error msg */
7305 char *message
= xstrprintf ("Error in deleting catchpoint %d:\n",
7307 struct cleanup
*cleanups
= make_cleanup (xfree
, message
);
7308 args_for_catchpoint_enable args
;
7309 args
.kind
= bpt
->type
== bp_catch_catch
?
7310 EX_EVENT_CATCH
: EX_EVENT_THROW
;
7312 catch_errors (cover_target_enable_exception_callback
, &args
,
7313 message
, RETURN_MASK_ALL
);
7314 do_cleanups (cleanups
);
7321 b
->next
= bpt
->next
;
7325 unlink_locations_from_global_list (bpt
);
7327 check_duplicates (bpt
);
7329 if (bpt
->type
!= bp_hardware_watchpoint
7330 && bpt
->type
!= bp_read_watchpoint
7331 && bpt
->type
!= bp_access_watchpoint
7332 && bpt
->type
!= bp_catch_fork
7333 && bpt
->type
!= bp_catch_vfork
7334 && bpt
->type
!= bp_catch_exec
)
7335 for (loc
= bpt
->loc
; loc
; loc
= loc
->next
)
7337 /* If this breakpoint location was inserted, and there is
7338 another breakpoint at the same address, we need to
7339 insert the other breakpoint. */
7342 struct bp_location
*loc2
;
7343 ALL_BP_LOCATIONS (loc2
)
7344 if (loc2
->address
== loc
->address
7345 && loc2
->section
== loc
->section
7347 && loc2
->owner
->enable_state
!= bp_disabled
7349 && !loc2
->shlib_disabled
7350 && loc2
->owner
->enable_state
!= bp_call_disabled
)
7354 /* We should never reach this point if there is a permanent
7355 breakpoint at the same address as the one being deleted.
7356 If there is a permanent breakpoint somewhere, it should
7357 always be the only one inserted. */
7358 if (loc2
->owner
->enable_state
== bp_permanent
)
7359 internal_error (__FILE__
, __LINE__
,
7360 _("another breakpoint was inserted on top of "
7361 "a permanent breakpoint"));
7363 memset (&loc2
->target_info
, 0, sizeof (loc2
->target_info
));
7364 loc2
->target_info
.placed_address
= loc2
->address
;
7365 if (b
->type
== bp_hardware_breakpoint
)
7366 val
= target_insert_hw_breakpoint (&loc2
->target_info
);
7368 val
= target_insert_breakpoint (&loc2
->target_info
);
7370 /* If there was an error in the insert, print a message, then stop execution. */
7373 struct ui_file
*tmp_error_stream
= mem_fileopen ();
7374 make_cleanup_ui_file_delete (tmp_error_stream
);
7377 if (b
->type
== bp_hardware_breakpoint
)
7379 fprintf_unfiltered (tmp_error_stream
,
7380 "Cannot insert hardware breakpoint %d.\n"
7381 "You may have requested too many hardware breakpoints.\n",
7386 fprintf_unfiltered (tmp_error_stream
, "Cannot insert breakpoint %d.\n", b
->number
);
7387 fprintf_filtered (tmp_error_stream
, "Error accessing memory address ");
7388 deprecated_print_address_numeric (loc2
->address
, 1, tmp_error_stream
);
7389 fprintf_filtered (tmp_error_stream
, ": %s.\n",
7390 safe_strerror (val
));
7393 fprintf_unfiltered (tmp_error_stream
,"The same program may be running in another process.");
7394 target_terminal_ours_for_output ();
7395 error_stream(tmp_error_stream
);
7403 free_command_lines (&bpt
->commands
);
7404 if (bpt
->cond_string
!= NULL
)
7405 xfree (bpt
->cond_string
);
7406 if (bpt
->addr_string
!= NULL
)
7407 xfree (bpt
->addr_string
);
7408 if (bpt
->exp
!= NULL
)
7410 if (bpt
->exp_string
!= NULL
)
7411 xfree (bpt
->exp_string
);
7412 if (bpt
->val
!= NULL
)
7413 value_free (bpt
->val
);
7414 if (bpt
->source_file
!= NULL
)
7415 xfree (bpt
->source_file
);
7416 if (bpt
->dll_pathname
!= NULL
)
7417 xfree (bpt
->dll_pathname
);
7418 if (bpt
->triggered_dll_pathname
!= NULL
)
7419 xfree (bpt
->triggered_dll_pathname
);
7420 if (bpt
->exec_pathname
!= NULL
)
7421 xfree (bpt
->exec_pathname
);
7423 /* Be sure no bpstat's are pointing at it after it's been freed. */
7424 /* FIXME, how can we find all bpstat's?
7425 We just check stop_bpstat for now. Note that we cannot just
7426 remove bpstats pointing at bpt from the stop_bpstat list
7427 entirely, as breakpoint commands are associated with the bpstat;
7428 if we remove it here, then the later call to
7429 bpstat_do_actions (&stop_bpstat);
7430 in event-top.c won't do anything, and temporary breakpoints
7431 with commands won't work. */
7432 for (bs
= stop_bpstat
; bs
; bs
= bs
->next
)
7433 if (bs
->breakpoint_at
&& bs
->breakpoint_at
->owner
== bpt
)
7435 bs
->breakpoint_at
= NULL
;
7437 /* bs->commands will be freed later. */
7439 /* On the chance that someone will soon try again to delete this same
7440 bp, we mark it as deleted before freeing its storage. */
7441 bpt
->type
= bp_none
;
7443 for (loc
= bpt
->loc
; loc
;)
7445 struct bp_location
*loc_next
= loc
->next
;
7453 do_delete_breakpoint_cleanup (void *b
)
7455 delete_breakpoint (b
);
7459 make_cleanup_delete_breakpoint (struct breakpoint
*b
)
7461 return make_cleanup (do_delete_breakpoint_cleanup
, b
);
7465 make_exec_cleanup_delete_breakpoint (struct breakpoint
*b
)
7467 return make_exec_cleanup (do_delete_breakpoint_cleanup
, b
);
7471 delete_command (char *arg
, int from_tty
)
7473 struct breakpoint
*b
, *temp
;
7479 int breaks_to_delete
= 0;
7481 /* Delete all breakpoints if no argument.
7482 Do not delete internal or call-dummy breakpoints, these
7483 have to be deleted with an explicit breakpoint number argument. */
7486 if (b
->type
!= bp_call_dummy
&&
7487 b
->type
!= bp_shlib_event
&&
7488 b
->type
!= bp_thread_event
&&
7489 b
->type
!= bp_overlay_event
&&
7492 breaks_to_delete
= 1;
7497 /* Ask user only if there are some breakpoints to delete. */
7499 || (breaks_to_delete
&& query (_("Delete all breakpoints? "))))
7501 ALL_BREAKPOINTS_SAFE (b
, temp
)
7503 if (b
->type
!= bp_call_dummy
&&
7504 b
->type
!= bp_shlib_event
&&
7505 b
->type
!= bp_thread_event
&&
7506 b
->type
!= bp_overlay_event
&&
7508 delete_breakpoint (b
);
7513 map_breakpoint_numbers (arg
, delete_breakpoint
);
7517 all_locations_are_pending (struct bp_location
*loc
)
7519 for (; loc
; loc
= loc
->next
)
7520 if (!loc
->shlib_disabled
)
7526 update_breakpoint_locations (struct breakpoint
*b
,
7527 struct symtabs_and_lines sals
)
7531 struct bp_location
*existing_locations
= b
->loc
;
7533 /* If there's no new locations, and all existing locations
7534 are pending, don't do anything. This optimizes
7535 the common case where all locations are in the same
7536 shared library, that was unloaded. We'd like to
7537 retain the location, so that when the library
7538 is loaded again, we don't loose the enabled/disabled
7539 status of the individual locations. */
7540 if (all_locations_are_pending (existing_locations
) && sals
.nelts
== 0)
7543 unlink_locations_from_global_list (b
);
7546 for (i
= 0; i
< sals
.nelts
; ++i
)
7548 struct bp_location
*new_loc
=
7549 add_location_to_breakpoint (b
, b
->type
, &(sals
.sals
[i
]));
7551 /* Reparse conditions, they might contain references to the
7553 if (b
->cond_string
!= NULL
)
7555 struct gdb_exception e
;
7558 TRY_CATCH (e
, RETURN_MASK_ERROR
)
7560 new_loc
->cond
= parse_exp_1 (&s
, block_for_pc (sals
.sals
[i
].pc
),
7565 warning (_("failed to reevaluate condition for breakpoint %d: %s"),
7566 b
->number
, e
.message
);
7567 new_loc
->enabled
= 0;
7571 if (b
->source_file
!= NULL
)
7572 xfree (b
->source_file
);
7573 if (sals
.sals
[i
].symtab
== NULL
)
7574 b
->source_file
= NULL
;
7577 savestring (sals
.sals
[i
].symtab
->filename
,
7578 strlen (sals
.sals
[i
].symtab
->filename
));
7580 if (b
->line_number
== 0)
7581 b
->line_number
= sals
.sals
[i
].line
;
7584 /* If possible, carry over 'disable' status from existing breakpoints. */
7586 struct bp_location
*e
= existing_locations
;
7587 for (; e
; e
= e
->next
)
7589 if (!e
->enabled
&& e
->function_name
)
7591 struct bp_location
*l
= b
->loc
;
7592 for (; l
; l
= l
->next
)
7593 if (l
->function_name
7594 && strcmp (e
->function_name
, l
->function_name
) == 0)
7603 while (existing_locations
)
7605 struct bp_location
*next
= existing_locations
->next
;
7606 free_bp_location (existing_locations
);
7607 existing_locations
= next
;
7612 /* Reset a breakpoint given it's struct breakpoint * BINT.
7613 The value we return ends up being the return value from catch_errors.
7614 Unused in this case. */
7617 breakpoint_re_set_one (void *bint
)
7619 /* get past catch_errs */
7620 struct breakpoint
*b
= (struct breakpoint
*) bint
;
7624 int *not_found_ptr
= ¬_found
;
7625 struct symtabs_and_lines sals
= {};
7626 struct symtabs_and_lines expanded
;
7628 enum enable_state save_enable
;
7629 struct gdb_exception e
;
7635 warning (_("attempted to reset apparently deleted breakpoint #%d?"),
7639 case bp_hardware_breakpoint
:
7641 case bp_catch_unload
:
7642 if (b
->addr_string
== NULL
)
7644 /* Anything without a string can't be re-set. */
7645 delete_breakpoint (b
);
7649 set_language (b
->language
);
7650 input_radix
= b
->input_radix
;
7652 TRY_CATCH (e
, RETURN_MASK_ERROR
)
7654 sals
= decode_line_1 (&s
, 1, (struct symtab
*) NULL
, 0, (char ***) NULL
,
7659 int not_found_and_ok
= 0;
7660 /* For pending breakpoints, it's expected that parsing
7661 will fail until the right shared library is loaded.
7662 User has already told to create pending breakpoints and
7663 don't need extra messages. If breakpoint is in bp_shlib_disabled
7664 state, then user already saw the message about that breakpoint
7665 being disabled, and don't want to see more errors. */
7667 && (b
->condition_not_parsed
7668 || (b
->loc
&& b
->loc
->shlib_disabled
)
7669 || b
->enable_state
== bp_disabled
))
7670 not_found_and_ok
= 1;
7672 if (!not_found_and_ok
)
7674 /* We surely don't want to warn about the same breakpoint
7675 10 times. One solution, implemented here, is disable
7676 the breakpoint on error. Another solution would be to
7677 have separate 'warning emitted' flag. Since this
7678 happens only when a binary has changed, I don't know
7679 which approach is better. */
7680 b
->enable_state
= bp_disabled
;
7681 throw_exception (e
);
7688 gdb_assert (sals
.nelts
== 1);
7689 resolve_sal_pc (&sals
.sals
[0]);
7690 if (b
->condition_not_parsed
&& s
&& s
[0])
7692 char *cond_string
= 0;
7694 find_condition_and_thread (s
, sals
.sals
[0].pc
,
7695 &cond_string
, &thread
);
7697 b
->cond_string
= cond_string
;
7699 b
->condition_not_parsed
= 0;
7701 expanded
= expand_line_sal_maybe (sals
.sals
[0]);
7702 update_breakpoint_locations (b
, expanded
);
7704 /* Now that this is re-enabled, check_duplicates
7706 check_duplicates (b
);
7712 case bp_hardware_watchpoint
:
7713 case bp_read_watchpoint
:
7714 case bp_access_watchpoint
:
7715 innermost_block
= NULL
;
7716 /* The issue arises of what context to evaluate this in. The
7717 same one as when it was set, but what does that mean when
7718 symbols have been re-read? We could save the filename and
7719 functionname, but if the context is more local than that, the
7720 best we could do would be something like how many levels deep
7721 and which index at that particular level, but that's going to
7722 be less stable than filenames or function names. */
7724 /* So for now, just use a global context. */
7728 /* Avoid re-freeing b->exp if an error during the call to
7729 parse_expression. */
7732 b
->exp
= parse_expression (b
->exp_string
);
7733 b
->exp_valid_block
= innermost_block
;
7734 mark
= value_mark ();
7737 value_free (b
->val
);
7738 /* Avoid re-freeing b->val if an error during the call to
7739 evaluate_expression. */
7742 b
->val
= evaluate_expression (b
->exp
);
7743 release_value (b
->val
);
7744 if (value_lazy (b
->val
) && breakpoint_enabled (b
))
7745 value_fetch_lazy (b
->val
);
7747 if (b
->cond_string
!= NULL
)
7752 xfree (b
->loc
->cond
);
7753 /* Avoid re-freeing b->exp if an error during the call
7755 b
->loc
->cond
= NULL
;
7757 b
->loc
->cond
= parse_exp_1 (&s
, (struct block
*) 0, 0);
7759 if (breakpoint_enabled (b
))
7761 value_free_to_mark (mark
);
7763 case bp_catch_catch
:
7764 case bp_catch_throw
:
7766 /* We needn't really do anything to reset these, since the mask
7767 that requests them is unaffected by e.g., new libraries being
7770 case bp_catch_vfork
:
7775 printf_filtered (_("Deleting unknown breakpoint type %d\n"), b
->type
);
7777 /* Delete longjmp and overlay event breakpoints; they will be
7778 reset later by breakpoint_re_set. */
7780 case bp_longjmp_resume
:
7781 case bp_overlay_event
:
7782 delete_breakpoint (b
);
7785 /* This breakpoint is special, it's set up when the inferior
7786 starts and we really don't want to touch it. */
7787 case bp_shlib_event
:
7789 /* Like bp_shlib_event, this breakpoint type is special.
7790 Once it is set up, we do not want to touch it. */
7791 case bp_thread_event
:
7793 /* Keep temporary breakpoints, which can be encountered when we step
7794 over a dlopen call and SOLIB_ADD is resetting the breakpoints.
7795 Otherwise these should have been blown away via the cleanup chain
7796 or by breakpoint_init_inferior when we rerun the executable. */
7799 case bp_watchpoint_scope
:
7801 case bp_step_resume
:
7808 /* Re-set all breakpoints after symbols have been re-loaded. */
7810 breakpoint_re_set (void)
7812 struct breakpoint
*b
, *temp
;
7813 enum language save_language
;
7814 int save_input_radix
;
7816 save_language
= current_language
->la_language
;
7817 save_input_radix
= input_radix
;
7818 ALL_BREAKPOINTS_SAFE (b
, temp
)
7820 /* Format possible error msg */
7821 char *message
= xstrprintf ("Error in re-setting breakpoint %d: ",
7823 struct cleanup
*cleanups
= make_cleanup (xfree
, message
);
7824 catch_errors (breakpoint_re_set_one
, b
, message
, RETURN_MASK_ALL
);
7825 do_cleanups (cleanups
);
7827 set_language (save_language
);
7828 input_radix
= save_input_radix
;
7830 if (gdbarch_get_longjmp_target_p (current_gdbarch
))
7832 create_longjmp_breakpoint ("longjmp");
7833 create_longjmp_breakpoint ("_longjmp");
7834 create_longjmp_breakpoint ("siglongjmp");
7835 create_longjmp_breakpoint ("_siglongjmp");
7836 create_longjmp_breakpoint (NULL
);
7839 create_overlay_event_breakpoint ("_ovly_debug_event");
7842 /* Reset the thread number of this breakpoint:
7844 - If the breakpoint is for all threads, leave it as-is.
7845 - Else, reset it to the current thread for inferior_ptid. */
7847 breakpoint_re_set_thread (struct breakpoint
*b
)
7849 if (b
->thread
!= -1)
7851 if (in_thread_list (inferior_ptid
))
7852 b
->thread
= pid_to_thread_id (inferior_ptid
);
7856 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
7857 If from_tty is nonzero, it prints a message to that effect,
7858 which ends with a period (no newline). */
7861 set_ignore_count (int bptnum
, int count
, int from_tty
)
7863 struct breakpoint
*b
;
7869 if (b
->number
== bptnum
)
7871 b
->ignore_count
= count
;
7875 printf_filtered (_("Will stop next time breakpoint %d is reached."),
7877 else if (count
== 1)
7878 printf_filtered (_("Will ignore next crossing of breakpoint %d."),
7881 printf_filtered (_("Will ignore next %d crossings of breakpoint %d."),
7884 breakpoints_changed ();
7885 breakpoint_modify_event (b
->number
);
7889 error (_("No breakpoint number %d."), bptnum
);
7892 /* Clear the ignore counts of all breakpoints. */
7894 breakpoint_clear_ignore_counts (void)
7896 struct breakpoint
*b
;
7899 b
->ignore_count
= 0;
7902 /* Command to set ignore-count of breakpoint N to COUNT. */
7905 ignore_command (char *args
, int from_tty
)
7911 error_no_arg (_("a breakpoint number"));
7913 num
= get_number (&p
);
7915 error (_("bad breakpoint number: '%s'"), args
);
7917 error (_("Second argument (specified ignore-count) is missing."));
7919 set_ignore_count (num
,
7920 longest_to_int (value_as_long (parse_and_eval (p
))),
7923 printf_filtered ("\n");
7926 /* Call FUNCTION on each of the breakpoints
7927 whose numbers are given in ARGS. */
7930 map_breakpoint_numbers (char *args
, void (*function
) (struct breakpoint
*))
7935 struct breakpoint
*b
, *tmp
;
7939 error_no_arg (_("one or more breakpoint numbers"));
7946 num
= get_number_or_range (&p1
);
7949 warning (_("bad breakpoint number at or near '%s'"), p
);
7953 ALL_BREAKPOINTS_SAFE (b
, tmp
)
7954 if (b
->number
== num
)
7956 struct breakpoint
*related_breakpoint
= b
->related_breakpoint
;
7959 if (related_breakpoint
)
7960 function (related_breakpoint
);
7964 printf_unfiltered (_("No breakpoint number %d.\n"), num
);
7970 static struct bp_location
*
7971 find_location_by_number (char *number
)
7973 char *dot
= strchr (number
, '.');
7977 struct breakpoint
*b
;
7978 struct bp_location
*loc
;
7983 bp_num
= get_number_or_range (&p1
);
7985 error (_("Bad breakpoint number '%s'"), number
);
7988 if (b
->number
== bp_num
)
7993 if (!b
|| b
->number
!= bp_num
)
7994 error (_("Bad breakpoint number '%s'"), number
);
7997 loc_num
= get_number_or_range (&p1
);
7999 error (_("Bad breakpoint location number '%s'"), number
);
8003 for (;loc_num
&& loc
; --loc_num
, loc
= loc
->next
)
8006 error (_("Bad breakpoint location number '%s'"), dot
+1);
8012 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
8013 If from_tty is nonzero, it prints a message to that effect,
8014 which ends with a period (no newline). */
8017 disable_breakpoint (struct breakpoint
*bpt
)
8019 /* Never disable a watchpoint scope breakpoint; we want to
8020 hit them when we leave scope so we can delete both the
8021 watchpoint and its scope breakpoint at that time. */
8022 if (bpt
->type
== bp_watchpoint_scope
)
8025 /* You can't disable permanent breakpoints. */
8026 if (bpt
->enable_state
== bp_permanent
)
8029 bpt
->enable_state
= bp_disabled
;
8031 check_duplicates (bpt
);
8033 if (deprecated_modify_breakpoint_hook
)
8034 deprecated_modify_breakpoint_hook (bpt
);
8035 breakpoint_modify_event (bpt
->number
);
8039 disable_command (char *args
, int from_tty
)
8041 struct breakpoint
*bpt
;
8043 ALL_BREAKPOINTS (bpt
)
8047 warning (_("attempted to disable apparently deleted breakpoint #%d?"),
8052 case bp_catch_unload
:
8054 case bp_catch_vfork
:
8056 case bp_catch_catch
:
8057 case bp_catch_throw
:
8058 case bp_hardware_breakpoint
:
8060 case bp_hardware_watchpoint
:
8061 case bp_read_watchpoint
:
8062 case bp_access_watchpoint
:
8063 disable_breakpoint (bpt
);
8067 else if (strchr (args
, '.'))
8069 struct bp_location
*loc
= find_location_by_number (args
);
8072 check_duplicates (loc
->owner
);
8075 map_breakpoint_numbers (args
, disable_breakpoint
);
8079 do_enable_breakpoint (struct breakpoint
*bpt
, enum bpdisp disposition
)
8081 int target_resources_ok
, other_type_used
;
8084 if (bpt
->type
== bp_hardware_breakpoint
)
8087 i
= hw_breakpoint_used_count ();
8088 target_resources_ok
=
8089 TARGET_CAN_USE_HARDWARE_WATCHPOINT (bp_hardware_breakpoint
,
8091 if (target_resources_ok
== 0)
8092 error (_("No hardware breakpoint support in the target."));
8093 else if (target_resources_ok
< 0)
8094 error (_("Hardware breakpoints used exceeds limit."));
8097 if (bpt
->enable_state
!= bp_permanent
)
8098 bpt
->enable_state
= bp_enabled
;
8099 bpt
->disposition
= disposition
;
8100 check_duplicates (bpt
);
8101 breakpoints_changed ();
8103 if (bpt
->type
== bp_watchpoint
||
8104 bpt
->type
== bp_hardware_watchpoint
||
8105 bpt
->type
== bp_read_watchpoint
||
8106 bpt
->type
== bp_access_watchpoint
)
8108 struct frame_id saved_frame_id
;
8110 saved_frame_id
= get_frame_id (get_selected_frame (NULL
));
8111 if (bpt
->exp_valid_block
!= NULL
)
8113 struct frame_info
*fr
=
8114 fr
= frame_find_by_id (bpt
->watchpoint_frame
);
8117 printf_filtered (_("\
8118 Cannot enable watchpoint %d because the block in which its expression\n\
8119 is valid is not currently in scope.\n"), bpt
->number
);
8120 bpt
->enable_state
= bp_disabled
;
8126 value_free (bpt
->val
);
8127 mark
= value_mark ();
8128 bpt
->val
= evaluate_expression (bpt
->exp
);
8129 release_value (bpt
->val
);
8130 if (value_lazy (bpt
->val
))
8131 value_fetch_lazy (bpt
->val
);
8133 if (bpt
->type
== bp_hardware_watchpoint
||
8134 bpt
->type
== bp_read_watchpoint
||
8135 bpt
->type
== bp_access_watchpoint
)
8137 int i
= hw_watchpoint_used_count (bpt
->type
, &other_type_used
);
8138 int mem_cnt
= can_use_hardware_watchpoint (bpt
->val
);
8140 /* Hack around 'unused var' error for some targets here */
8141 (void) mem_cnt
, (void) i
;
8142 target_resources_ok
= TARGET_CAN_USE_HARDWARE_WATCHPOINT (
8143 bpt
->type
, i
+ mem_cnt
, other_type_used
);
8144 /* we can consider of type is bp_hardware_watchpoint, convert to
8145 bp_watchpoint in the following condition */
8146 if (target_resources_ok
< 0)
8148 printf_filtered (_("\
8149 Cannot enable watchpoint %d because target watch resources\n\
8150 have been allocated for other watchpoints.\n"), bpt
->number
);
8151 bpt
->enable_state
= bp_disabled
;
8152 value_free_to_mark (mark
);
8157 select_frame (frame_find_by_id (saved_frame_id
));
8158 value_free_to_mark (mark
);
8161 if (deprecated_modify_breakpoint_hook
)
8162 deprecated_modify_breakpoint_hook (bpt
);
8163 breakpoint_modify_event (bpt
->number
);
8168 enable_breakpoint (struct breakpoint
*bpt
)
8170 do_enable_breakpoint (bpt
, bpt
->disposition
);
8173 /* The enable command enables the specified breakpoints (or all defined
8174 breakpoints) so they once again become (or continue to be) effective
8175 in stopping the inferior. */
8178 enable_command (char *args
, int from_tty
)
8180 struct breakpoint
*bpt
;
8182 ALL_BREAKPOINTS (bpt
)
8186 warning (_("attempted to enable apparently deleted breakpoint #%d?"),
8191 case bp_catch_unload
:
8193 case bp_catch_vfork
:
8195 case bp_catch_catch
:
8196 case bp_catch_throw
:
8197 case bp_hardware_breakpoint
:
8199 case bp_hardware_watchpoint
:
8200 case bp_read_watchpoint
:
8201 case bp_access_watchpoint
:
8202 enable_breakpoint (bpt
);
8206 else if (strchr (args
, '.'))
8208 struct bp_location
*loc
= find_location_by_number (args
);
8211 check_duplicates (loc
->owner
);
8214 map_breakpoint_numbers (args
, enable_breakpoint
);
8218 enable_once_breakpoint (struct breakpoint
*bpt
)
8220 do_enable_breakpoint (bpt
, disp_disable
);
8224 enable_once_command (char *args
, int from_tty
)
8226 map_breakpoint_numbers (args
, enable_once_breakpoint
);
8230 enable_delete_breakpoint (struct breakpoint
*bpt
)
8232 do_enable_breakpoint (bpt
, disp_del
);
8236 enable_delete_command (char *args
, int from_tty
)
8238 map_breakpoint_numbers (args
, enable_delete_breakpoint
);
8242 set_breakpoint_cmd (char *args
, int from_tty
)
8247 show_breakpoint_cmd (char *args
, int from_tty
)
8251 /* Use default_breakpoint_'s, or nothing if they aren't valid. */
8253 struct symtabs_and_lines
8254 decode_line_spec_1 (char *string
, int funfirstline
)
8256 struct symtabs_and_lines sals
;
8258 error (_("Empty line specification."));
8259 if (default_breakpoint_valid
)
8260 sals
= decode_line_1 (&string
, funfirstline
,
8261 default_breakpoint_symtab
,
8262 default_breakpoint_line
,
8263 (char ***) NULL
, NULL
);
8265 sals
= decode_line_1 (&string
, funfirstline
,
8266 (struct symtab
*) NULL
, 0, (char ***) NULL
, NULL
);
8268 error (_("Junk at end of line specification: %s"), string
);
8272 /* Create and insert a raw software breakpoint at PC. Return an
8273 identifier, which should be used to remove the breakpoint later.
8274 In general, places which call this should be using something on the
8275 breakpoint chain instead; this function should be eliminated
8279 deprecated_insert_raw_breakpoint (CORE_ADDR pc
)
8281 struct bp_target_info
*bp_tgt
;
8283 bp_tgt
= xmalloc (sizeof (struct bp_target_info
));
8284 memset (bp_tgt
, 0, sizeof (struct bp_target_info
));
8286 bp_tgt
->placed_address
= pc
;
8287 if (target_insert_breakpoint (bp_tgt
) != 0)
8289 /* Could not insert the breakpoint. */
8297 /* Remove a breakpoint BP inserted by deprecated_insert_raw_breakpoint. */
8300 deprecated_remove_raw_breakpoint (void *bp
)
8302 struct bp_target_info
*bp_tgt
= bp
;
8305 ret
= target_remove_breakpoint (bp_tgt
);
8311 /* One (or perhaps two) breakpoints used for software single stepping. */
8313 static void *single_step_breakpoints
[2];
8315 /* Create and insert a breakpoint for software single step. */
8318 insert_single_step_breakpoint (CORE_ADDR next_pc
)
8322 if (single_step_breakpoints
[0] == NULL
)
8323 bpt_p
= &single_step_breakpoints
[0];
8326 gdb_assert (single_step_breakpoints
[1] == NULL
);
8327 bpt_p
= &single_step_breakpoints
[1];
8330 /* NOTE drow/2006-04-11: A future improvement to this function would be
8331 to only create the breakpoints once, and actually put them on the
8332 breakpoint chain. That would let us use set_raw_breakpoint. We could
8333 adjust the addresses each time they were needed. Doing this requires
8334 corresponding changes elsewhere where single step breakpoints are
8335 handled, however. So, for now, we use this. */
8337 *bpt_p
= deprecated_insert_raw_breakpoint (next_pc
);
8339 error (_("Could not insert single-step breakpoint at 0x%s"),
8340 paddr_nz (next_pc
));
8343 /* Remove and delete any breakpoints used for software single step. */
8346 remove_single_step_breakpoints (void)
8348 gdb_assert (single_step_breakpoints
[0] != NULL
);
8350 /* See insert_single_step_breakpoint for more about this deprecated
8352 deprecated_remove_raw_breakpoint (single_step_breakpoints
[0]);
8353 single_step_breakpoints
[0] = NULL
;
8355 if (single_step_breakpoints
[1] != NULL
)
8357 deprecated_remove_raw_breakpoint (single_step_breakpoints
[1]);
8358 single_step_breakpoints
[1] = NULL
;
8362 /* Check whether a software single-step breakpoint is inserted at PC. */
8365 single_step_breakpoint_inserted_here_p (CORE_ADDR pc
)
8369 for (i
= 0; i
< 2; i
++)
8371 struct bp_target_info
*bp_tgt
= single_step_breakpoints
[i
];
8372 if (bp_tgt
&& bp_tgt
->placed_address
== pc
)
8380 /* This help string is used for the break, hbreak, tbreak and thbreak commands.
8381 It is defined as a macro to prevent duplication.
8382 COMMAND should be a string constant containing the name of the command. */
8383 #define BREAK_ARGS_HELP(command) \
8384 command" [LOCATION] [thread THREADNUM] [if CONDITION]\n\
8385 LOCATION may be a line number, function name, or \"*\" and an address.\n\
8386 If a line number is specified, break at start of code for that line.\n\
8387 If a function is specified, break at start of code for that function.\n\
8388 If an address is specified, break at that exact address.\n\
8389 With no LOCATION, uses current execution address of selected stack frame.\n\
8390 This is useful for breaking on return to a stack frame.\n\
8392 THREADNUM is the number from \"info threads\".\n\
8393 CONDITION is a boolean expression.\n\
8395 Multiple breakpoints at one place are permitted, and useful if conditional.\n\
8397 Do \"help breakpoints\" for info on other commands dealing with breakpoints."
8400 _initialize_breakpoint (void)
8402 static struct cmd_list_element
*breakpoint_set_cmdlist
;
8403 static struct cmd_list_element
*breakpoint_show_cmdlist
;
8404 struct cmd_list_element
*c
;
8406 observer_attach_solib_unloaded (disable_breakpoints_in_unloaded_shlib
);
8408 breakpoint_chain
= 0;
8409 /* Don't bother to call set_breakpoint_count. $bpnum isn't useful
8410 before a breakpoint is set. */
8411 breakpoint_count
= 0;
8413 add_com ("ignore", class_breakpoint
, ignore_command
, _("\
8414 Set ignore-count of breakpoint number N to COUNT.\n\
8415 Usage is `ignore N COUNT'."));
8417 add_com_alias ("bc", "ignore", class_breakpoint
, 1);
8419 add_com ("commands", class_breakpoint
, commands_command
, _("\
8420 Set commands to be executed when a breakpoint is hit.\n\
8421 Give breakpoint number as argument after \"commands\".\n\
8422 With no argument, the targeted breakpoint is the last one set.\n\
8423 The commands themselves follow starting on the next line.\n\
8424 Type a line containing \"end\" to indicate the end of them.\n\
8425 Give \"silent\" as the first line to make the breakpoint silent;\n\
8426 then no output is printed when it is hit, except what the commands print."));
8428 add_com ("condition", class_breakpoint
, condition_command
, _("\
8429 Specify breakpoint number N to break only if COND is true.\n\
8430 Usage is `condition N COND', where N is an integer and COND is an\n\
8431 expression to be evaluated whenever breakpoint N is reached."));
8433 c
= add_com ("tbreak", class_breakpoint
, tbreak_command
, _("\
8434 Set a temporary breakpoint.\n\
8435 Like \"break\" except the breakpoint is only temporary,\n\
8436 so it will be deleted when hit. Equivalent to \"break\" followed\n\
8437 by using \"enable delete\" on the breakpoint number.\n\
8439 BREAK_ARGS_HELP ("tbreak")));
8440 set_cmd_completer (c
, location_completer
);
8442 c
= add_com ("hbreak", class_breakpoint
, hbreak_command
, _("\
8443 Set a hardware assisted breakpoint.\n\
8444 Like \"break\" except the breakpoint requires hardware support,\n\
8445 some target hardware may not have this support.\n\
8447 BREAK_ARGS_HELP ("hbreak")));
8448 set_cmd_completer (c
, location_completer
);
8450 c
= add_com ("thbreak", class_breakpoint
, thbreak_command
, _("\
8451 Set a temporary hardware assisted breakpoint.\n\
8452 Like \"hbreak\" except the breakpoint is only temporary,\n\
8453 so it will be deleted when hit.\n\
8455 BREAK_ARGS_HELP ("thbreak")));
8456 set_cmd_completer (c
, location_completer
);
8458 add_prefix_cmd ("enable", class_breakpoint
, enable_command
, _("\
8459 Enable some breakpoints.\n\
8460 Give breakpoint numbers (separated by spaces) as arguments.\n\
8461 With no subcommand, breakpoints are enabled until you command otherwise.\n\
8462 This is used to cancel the effect of the \"disable\" command.\n\
8463 With a subcommand you can enable temporarily."),
8464 &enablelist
, "enable ", 1, &cmdlist
);
8466 add_com ("ab", class_breakpoint
, enable_command
, _("\
8467 Enable some breakpoints.\n\
8468 Give breakpoint numbers (separated by spaces) as arguments.\n\
8469 With no subcommand, breakpoints are enabled until you command otherwise.\n\
8470 This is used to cancel the effect of the \"disable\" command.\n\
8471 With a subcommand you can enable temporarily."));
8473 add_com_alias ("en", "enable", class_breakpoint
, 1);
8475 add_abbrev_prefix_cmd ("breakpoints", class_breakpoint
, enable_command
, _("\
8476 Enable some breakpoints.\n\
8477 Give breakpoint numbers (separated by spaces) as arguments.\n\
8478 This is used to cancel the effect of the \"disable\" command.\n\
8479 May be abbreviated to simply \"enable\".\n"),
8480 &enablebreaklist
, "enable breakpoints ", 1, &enablelist
);
8482 add_cmd ("once", no_class
, enable_once_command
, _("\
8483 Enable breakpoints for one hit. Give breakpoint numbers.\n\
8484 If a breakpoint is hit while enabled in this fashion, it becomes disabled."),
8487 add_cmd ("delete", no_class
, enable_delete_command
, _("\
8488 Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
8489 If a breakpoint is hit while enabled in this fashion, it is deleted."),
8492 add_cmd ("delete", no_class
, enable_delete_command
, _("\
8493 Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
8494 If a breakpoint is hit while enabled in this fashion, it is deleted."),
8497 add_cmd ("once", no_class
, enable_once_command
, _("\
8498 Enable breakpoints for one hit. Give breakpoint numbers.\n\
8499 If a breakpoint is hit while enabled in this fashion, it becomes disabled."),
8502 add_prefix_cmd ("disable", class_breakpoint
, disable_command
, _("\
8503 Disable some breakpoints.\n\
8504 Arguments are breakpoint numbers with spaces in between.\n\
8505 To disable all breakpoints, give no argument.\n\
8506 A disabled breakpoint is not forgotten, but has no effect until reenabled."),
8507 &disablelist
, "disable ", 1, &cmdlist
);
8508 add_com_alias ("dis", "disable", class_breakpoint
, 1);
8509 add_com_alias ("disa", "disable", class_breakpoint
, 1);
8511 add_com ("sb", class_breakpoint
, disable_command
, _("\
8512 Disable some breakpoints.\n\
8513 Arguments are breakpoint numbers with spaces in between.\n\
8514 To disable all breakpoints, give no argument.\n\
8515 A disabled breakpoint is not forgotten, but has no effect until reenabled."));
8517 add_cmd ("breakpoints", class_alias
, disable_command
, _("\
8518 Disable some breakpoints.\n\
8519 Arguments are breakpoint numbers with spaces in between.\n\
8520 To disable all breakpoints, give no argument.\n\
8521 A disabled breakpoint is not forgotten, but has no effect until reenabled.\n\
8522 This command may be abbreviated \"disable\"."),
8525 add_prefix_cmd ("delete", class_breakpoint
, delete_command
, _("\
8526 Delete some breakpoints or auto-display expressions.\n\
8527 Arguments are breakpoint numbers with spaces in between.\n\
8528 To delete all breakpoints, give no argument.\n\
8530 Also a prefix command for deletion of other GDB objects.\n\
8531 The \"unset\" command is also an alias for \"delete\"."),
8532 &deletelist
, "delete ", 1, &cmdlist
);
8533 add_com_alias ("d", "delete", class_breakpoint
, 1);
8534 add_com_alias ("del", "delete", class_breakpoint
, 1);
8536 add_com ("db", class_breakpoint
, delete_command
, _("\
8537 Delete some breakpoints.\n\
8538 Arguments are breakpoint numbers with spaces in between.\n\
8539 To delete all breakpoints, give no argument.\n"));
8541 add_cmd ("breakpoints", class_alias
, delete_command
, _("\
8542 Delete some breakpoints or auto-display expressions.\n\
8543 Arguments are breakpoint numbers with spaces in between.\n\
8544 To delete all breakpoints, give no argument.\n\
8545 This command may be abbreviated \"delete\"."),
8548 add_com ("clear", class_breakpoint
, clear_command
, _("\
8549 Clear breakpoint at specified line or function.\n\
8550 Argument may be line number, function name, or \"*\" and an address.\n\
8551 If line number is specified, all breakpoints in that line are cleared.\n\
8552 If function is specified, breakpoints at beginning of function are cleared.\n\
8553 If an address is specified, breakpoints at that address are cleared.\n\
8555 With no argument, clears all breakpoints in the line that the selected frame\n\
8558 See also the \"delete\" command which clears breakpoints by number."));
8560 c
= add_com ("break", class_breakpoint
, break_command
, _("\
8561 Set breakpoint at specified line or function.\n"
8562 BREAK_ARGS_HELP ("break")));
8563 set_cmd_completer (c
, location_completer
);
8565 add_com_alias ("b", "break", class_run
, 1);
8566 add_com_alias ("br", "break", class_run
, 1);
8567 add_com_alias ("bre", "break", class_run
, 1);
8568 add_com_alias ("brea", "break", class_run
, 1);
8572 add_com_alias ("ba", "break", class_breakpoint
, 1);
8573 add_com_alias ("bu", "ubreak", class_breakpoint
, 1);
8578 add_abbrev_prefix_cmd ("stop", class_breakpoint
, stop_command
, _("\
8579 Break in function/address or break at a line in the current file."),
8580 &stoplist
, "stop ", 1, &cmdlist
);
8581 add_cmd ("in", class_breakpoint
, stopin_command
,
8582 _("Break in function or address."), &stoplist
);
8583 add_cmd ("at", class_breakpoint
, stopat_command
,
8584 _("Break at a line in the current file."), &stoplist
);
8585 add_com ("status", class_info
, breakpoints_info
, _("\
8586 Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
8587 The \"Type\" column indicates one of:\n\
8588 \tbreakpoint - normal breakpoint\n\
8589 \twatchpoint - watchpoint\n\
8590 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
8591 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
8592 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
8593 address and file/line number respectively.\n\
8595 Convenience variable \"$_\" and default examine address for \"x\"\n\
8596 are set to the address of the last breakpoint listed unless the command\n\
8597 is prefixed with \"server \".\n\n\
8598 Convenience variable \"$bpnum\" contains the number of the last\n\
8602 add_info ("breakpoints", breakpoints_info
, _("\
8603 Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
8604 The \"Type\" column indicates one of:\n\
8605 \tbreakpoint - normal breakpoint\n\
8606 \twatchpoint - watchpoint\n\
8607 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
8608 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
8609 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
8610 address and file/line number respectively.\n\
8612 Convenience variable \"$_\" and default examine address for \"x\"\n\
8613 are set to the address of the last breakpoint listed unless the command\n\
8614 is prefixed with \"server \".\n\n\
8615 Convenience variable \"$bpnum\" contains the number of the last\n\
8619 add_com ("lb", class_breakpoint
, breakpoints_info
, _("\
8620 Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
8621 The \"Type\" column indicates one of:\n\
8622 \tbreakpoint - normal breakpoint\n\
8623 \twatchpoint - watchpoint\n\
8624 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
8625 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
8626 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
8627 address and file/line number respectively.\n\
8629 Convenience variable \"$_\" and default examine address for \"x\"\n\
8630 are set to the address of the last breakpoint listed unless the command\n\
8631 is prefixed with \"server \".\n\n\
8632 Convenience variable \"$bpnum\" contains the number of the last\n\
8635 add_cmd ("breakpoints", class_maintenance
, maintenance_info_breakpoints
, _("\
8636 Status of all breakpoints, or breakpoint number NUMBER.\n\
8637 The \"Type\" column indicates one of:\n\
8638 \tbreakpoint - normal breakpoint\n\
8639 \twatchpoint - watchpoint\n\
8640 \tlongjmp - internal breakpoint used to step through longjmp()\n\
8641 \tlongjmp resume - internal breakpoint at the target of longjmp()\n\
8642 \tuntil - internal breakpoint used by the \"until\" command\n\
8643 \tfinish - internal breakpoint used by the \"finish\" command\n\
8644 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
8645 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
8646 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
8647 address and file/line number respectively.\n\
8649 Convenience variable \"$_\" and default examine address for \"x\"\n\
8650 are set to the address of the last breakpoint listed unless the command\n\
8651 is prefixed with \"server \".\n\n\
8652 Convenience variable \"$bpnum\" contains the number of the last\n\
8654 &maintenanceinfolist
);
8656 add_com ("catch", class_breakpoint
, catch_command
, _("\
8657 Set catchpoints to catch events.\n\
8658 Raised signals may be caught:\n\
8659 \tcatch signal - all signals\n\
8660 \tcatch signal <signame> - a particular signal\n\
8661 Raised exceptions may be caught:\n\
8662 \tcatch throw - all exceptions, when thrown\n\
8663 \tcatch throw <exceptname> - a particular exception, when thrown\n\
8664 \tcatch catch - all exceptions, when caught\n\
8665 \tcatch catch <exceptname> - a particular exception, when caught\n\
8666 Thread or process events may be caught:\n\
8667 \tcatch thread_start - any threads, just after creation\n\
8668 \tcatch thread_exit - any threads, just before expiration\n\
8669 \tcatch thread_join - any threads, just after joins\n\
8670 Process events may be caught:\n\
8671 \tcatch start - any processes, just after creation\n\
8672 \tcatch exit - any processes, just before expiration\n\
8673 \tcatch fork - calls to fork()\n\
8674 \tcatch vfork - calls to vfork()\n\
8675 \tcatch exec - calls to exec()\n\
8676 Dynamically-linked library events may be caught:\n\
8677 \tcatch load - loads of any library\n\
8678 \tcatch load <libname> - loads of a particular library\n\
8679 \tcatch unload - unloads of any library\n\
8680 \tcatch unload <libname> - unloads of a particular library\n\
8681 The act of your program's execution stopping may also be caught:\n\
8683 C++ exceptions may be caught:\n\
8684 \tcatch throw - all exceptions, when thrown\n\
8685 \tcatch catch - all exceptions, when caught\n\
8686 Ada exceptions may be caught:\n\
8687 \tcatch exception - all exceptions, when raised\n\
8688 \tcatch exception <name> - a particular exception, when raised\n\
8689 \tcatch exception unhandled - all unhandled exceptions, when raised\n\
8690 \tcatch assert - all failed assertions, when raised\n\
8692 Do \"help set follow-fork-mode\" for info on debugging your program\n\
8693 after a fork or vfork is caught.\n\n\
8694 Do \"help breakpoints\" for info on other commands dealing with breakpoints."));
8696 add_com ("tcatch", class_breakpoint
, tcatch_command
, _("\
8697 Set temporary catchpoints to catch events.\n\
8698 Args like \"catch\" command.\n\
8699 Like \"catch\" except the catchpoint is only temporary,\n\
8700 so it will be deleted when hit. Equivalent to \"catch\" followed\n\
8701 by using \"enable delete\" on the catchpoint number."));
8703 c
= add_com ("watch", class_breakpoint
, watch_command
, _("\
8704 Set a watchpoint for an expression.\n\
8705 A watchpoint stops execution of your program whenever the value of\n\
8706 an expression changes."));
8707 set_cmd_completer (c
, location_completer
);
8709 c
= add_com ("rwatch", class_breakpoint
, rwatch_command
, _("\
8710 Set a read watchpoint for an expression.\n\
8711 A watchpoint stops execution of your program whenever the value of\n\
8712 an expression is read."));
8713 set_cmd_completer (c
, location_completer
);
8715 c
= add_com ("awatch", class_breakpoint
, awatch_command
, _("\
8716 Set a watchpoint for an expression.\n\
8717 A watchpoint stops execution of your program whenever the value of\n\
8718 an expression is either read or written."));
8719 set_cmd_completer (c
, location_completer
);
8721 add_info ("watchpoints", breakpoints_info
,
8722 _("Synonym for ``info breakpoints''."));
8725 /* XXX: cagney/2005-02-23: This should be a boolean, and should
8726 respond to changes - contrary to the description. */
8727 add_setshow_zinteger_cmd ("can-use-hw-watchpoints", class_support
,
8728 &can_use_hw_watchpoints
, _("\
8729 Set debugger's willingness to use watchpoint hardware."), _("\
8730 Show debugger's willingness to use watchpoint hardware."), _("\
8731 If zero, gdb will not use hardware for new watchpoints, even if\n\
8732 such is available. (However, any hardware watchpoints that were\n\
8733 created before setting this to nonzero, will continue to use watchpoint\n\
8736 show_can_use_hw_watchpoints
,
8737 &setlist
, &showlist
);
8739 can_use_hw_watchpoints
= 1;
8741 add_prefix_cmd ("breakpoint", class_maintenance
, set_breakpoint_cmd
, _("\
8742 Breakpoint specific settings\n\
8743 Configure various breakpoint-specific variables such as\n\
8744 pending breakpoint behavior"),
8745 &breakpoint_set_cmdlist
, "set breakpoint ",
8746 0/*allow-unknown*/, &setlist
);
8747 add_prefix_cmd ("breakpoint", class_maintenance
, show_breakpoint_cmd
, _("\
8748 Breakpoint specific settings\n\
8749 Configure various breakpoint-specific variables such as\n\
8750 pending breakpoint behavior"),
8751 &breakpoint_show_cmdlist
, "show breakpoint ",
8752 0/*allow-unknown*/, &showlist
);
8754 add_setshow_auto_boolean_cmd ("pending", no_class
,
8755 &pending_break_support
, _("\
8756 Set debugger's behavior regarding pending breakpoints."), _("\
8757 Show debugger's behavior regarding pending breakpoints."), _("\
8758 If on, an unrecognized breakpoint location will cause gdb to create a\n\
8759 pending breakpoint. If off, an unrecognized breakpoint location results in\n\
8760 an error. If auto, an unrecognized breakpoint location results in a\n\
8761 user-query to see if a pending breakpoint should be created."),
8763 show_pending_break_support
,
8764 &breakpoint_set_cmdlist
,
8765 &breakpoint_show_cmdlist
);
8767 pending_break_support
= AUTO_BOOLEAN_AUTO
;
8769 add_setshow_boolean_cmd ("auto-hw", no_class
,
8770 &automatic_hardware_breakpoints
, _("\
8771 Set automatic usage of hardware breakpoints."), _("\
8772 Show automatic usage of hardware breakpoints."), _("\
8773 If set, the debugger will automatically use hardware breakpoints for\n\
8774 breakpoints set with \"break\" but falling in read-only memory. If not set,\n\
8775 a warning will be emitted for such breakpoints."),
8777 show_automatic_hardware_breakpoints
,
8778 &breakpoint_set_cmdlist
,
8779 &breakpoint_show_cmdlist
);
8781 automatic_hardware_breakpoints
= 1;