1 /* Everything about breakpoints, for GDB.
3 Copyright (C) 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
4 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007
5 Free Software Foundation, Inc.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 51 Franklin Street, Fifth Floor,
22 Boston, MA 02110-1301, USA. */
28 #include "breakpoint.h"
30 #include "expression.h"
36 #include "gdbthread.h"
39 #include "gdb_string.h"
46 #include "completer.h"
49 #include "cli/cli-script.h"
50 #include "gdb_assert.h"
55 #include "exceptions.h"
59 #include "gdb-events.h"
60 #include "mi/mi-common.h"
62 /* Prototypes for local functions. */
64 static void until_break_command_continuation (struct continuation_arg *arg);
66 static void catch_command_1 (char *, int, int);
68 static void enable_delete_command (char *, int);
70 static void enable_delete_breakpoint (struct breakpoint *);
72 static void enable_once_command (char *, int);
74 static void enable_once_breakpoint (struct breakpoint *);
76 static void disable_command (char *, int);
78 static void enable_command (char *, int);
80 static void map_breakpoint_numbers (char *, void (*)(struct breakpoint *));
82 static void ignore_command (char *, int);
84 static int breakpoint_re_set_one (void *);
86 static void clear_command (char *, int);
88 static void catch_command (char *, int);
90 static void watch_command (char *, int);
92 static int can_use_hardware_watchpoint (struct value *);
94 static int break_command_1 (char *, int, int, struct breakpoint *);
96 static void mention (struct breakpoint *);
98 struct breakpoint *set_raw_breakpoint (struct symtab_and_line, enum bptype);
100 static void check_duplicates (struct breakpoint *);
102 static void breakpoint_adjustment_warning (CORE_ADDR, CORE_ADDR, int, int);
104 static CORE_ADDR adjust_breakpoint_address (CORE_ADDR bpaddr,
107 static void describe_other_breakpoints (CORE_ADDR, asection *, int);
109 static void breakpoints_info (char *, int);
111 static void breakpoint_1 (int, int);
113 static bpstat bpstat_alloc (struct breakpoint *, bpstat);
115 static int breakpoint_cond_eval (void *);
117 static void cleanup_executing_breakpoints (void *);
119 static void commands_command (char *, int);
121 static void condition_command (char *, int);
123 static int get_number_trailer (char **, int);
125 void set_breakpoint_count (int);
134 static int remove_breakpoint (struct bp_location *, insertion_state_t);
136 static enum print_stop_action print_it_typical (bpstat);
138 static enum print_stop_action print_bp_stop_message (bpstat bs);
142 enum exception_event_kind kind;
145 args_for_catchpoint_enable;
147 static int watchpoint_check (void *);
149 static int cover_target_enable_exception_callback (void *);
151 static void maintenance_info_breakpoints (char *, int);
153 static void create_longjmp_breakpoint (char *);
155 static void create_overlay_event_breakpoint (char *);
157 static int hw_breakpoint_used_count (void);
159 static int hw_watchpoint_used_count (enum bptype, int *);
161 static void hbreak_command (char *, int);
163 static void thbreak_command (char *, int);
165 static void watch_command_1 (char *, int, int);
167 static void rwatch_command (char *, int);
169 static void awatch_command (char *, int);
171 static void do_enable_breakpoint (struct breakpoint *, enum bpdisp);
173 static void solib_load_unload_1 (char *hookname,
176 char *cond_string, enum bptype bp_kind);
178 static void create_fork_vfork_event_catchpoint (int tempflag,
180 enum bptype bp_kind);
182 static void stop_command (char *arg, int from_tty);
184 static void stopin_command (char *arg, int from_tty);
186 static void stopat_command (char *arg, int from_tty);
188 static char *ep_find_event_name_end (char *arg);
190 static char *ep_parse_optional_if_clause (char **arg);
192 static char *ep_parse_optional_filename (char **arg);
194 static void create_exception_catchpoint (int tempflag, char *cond_string,
195 enum exception_event_kind ex_event,
196 struct symtab_and_line *sal);
198 static void catch_exception_command_1 (enum exception_event_kind ex_event,
199 char *arg, int tempflag, int from_tty);
201 static void tcatch_command (char *arg, int from_tty);
203 static void ep_skip_leading_whitespace (char **s);
205 /* Prototypes for exported functions. */
207 /* If FALSE, gdb will not use hardware support for watchpoints, even
208 if such is available. */
209 static int can_use_hw_watchpoints;
212 show_can_use_hw_watchpoints (struct ui_file *file, int from_tty,
213 struct cmd_list_element *c,
216 fprintf_filtered (file, _("\
217 Debugger's willingness to use watchpoint hardware is %s.\n"),
221 /* If AUTO_BOOLEAN_FALSE, gdb will not attempt to create pending breakpoints.
222 If AUTO_BOOLEAN_TRUE, gdb will automatically create pending breakpoints
223 for unrecognized breakpoint locations.
224 If AUTO_BOOLEAN_AUTO, gdb will query when breakpoints are unrecognized. */
225 static enum auto_boolean pending_break_support;
227 show_pending_break_support (struct ui_file *file, int from_tty,
228 struct cmd_list_element *c,
231 fprintf_filtered (file, _("\
232 Debugger's behavior regarding pending breakpoints is %s.\n"),
236 /* If 1, gdb will automatically use hardware breakpoints for breakpoints
237 set with "break" but falling in read-only memory.
238 If 0, gdb will warn about such breakpoints, but won't automatically
239 use hardware breakpoints. */
240 static int automatic_hardware_breakpoints;
242 show_automatic_hardware_breakpoints (struct ui_file *file, int from_tty,
243 struct cmd_list_element *c,
246 fprintf_filtered (file, _("\
247 Automatic usage of hardware breakpoints is %s.\n"),
252 void _initialize_breakpoint (void);
254 extern int addressprint; /* Print machine addresses? */
256 /* Are we executing breakpoint commands? */
257 static int executing_breakpoint_commands;
259 /* Are overlay event breakpoints enabled? */
260 static int overlay_events_enabled;
262 /* Walk the following statement or block through all breakpoints.
263 ALL_BREAKPOINTS_SAFE does so even if the statment deletes the current
266 #define ALL_BREAKPOINTS(B) for (B = breakpoint_chain; B; B = B->next)
268 #define ALL_BREAKPOINTS_SAFE(B,TMP) \
269 for (B = breakpoint_chain; \
270 B ? (TMP=B->next, 1): 0; \
273 /* Similar iterators for the low-level breakpoints. */
275 #define ALL_BP_LOCATIONS(B) for (B = bp_location_chain; B; B = B->next)
277 #define ALL_BP_LOCATIONS_SAFE(B,TMP) \
278 for (B = bp_location_chain; \
279 B ? (TMP=B->next, 1): 0; \
282 /* True if breakpoint hit counts should be displayed in breakpoint info. */
284 int show_breakpoint_hit_counts = 1;
286 /* Chains of all breakpoints defined. */
288 struct breakpoint *breakpoint_chain;
290 struct bp_location *bp_location_chain;
292 /* Number of last breakpoint made. */
294 int breakpoint_count;
296 /* Pointer to current exception event record */
297 static struct exception_event_record *current_exception_event;
299 /* Indicator of whether exception catchpoints should be nuked between
300 runs of a program. */
301 int deprecated_exception_catchpoints_are_fragile = 0;
303 /* Indicator of when exception catchpoints set-up should be
304 reinitialized -- e.g. when program is re-run. */
305 int deprecated_exception_support_initialized = 0;
307 /* This function returns a pointer to the string representation of the
308 pathname of the dynamically-linked library that has just been
311 This function must be used only when SOLIB_HAVE_LOAD_EVENT is TRUE,
312 or undefined results are guaranteed.
314 This string's contents are only valid immediately after the
315 inferior has stopped in the dynamic linker hook, and becomes
316 invalid as soon as the inferior is continued. Clients should make
317 a copy of this string if they wish to continue the inferior and
318 then access the string. */
320 #ifndef SOLIB_LOADED_LIBRARY_PATHNAME
321 #define SOLIB_LOADED_LIBRARY_PATHNAME(pid) ""
324 /* This function returns a pointer to the string representation of the
325 pathname of the dynamically-linked library that has just been
328 This function must be used only when SOLIB_HAVE_UNLOAD_EVENT is
329 TRUE, or undefined results are guaranteed.
331 This string's contents are only valid immediately after the
332 inferior has stopped in the dynamic linker hook, and becomes
333 invalid as soon as the inferior is continued. Clients should make
334 a copy of this string if they wish to continue the inferior and
335 then access the string. */
337 #ifndef SOLIB_UNLOADED_LIBRARY_PATHNAME
338 #define SOLIB_UNLOADED_LIBRARY_PATHNAME(pid) ""
341 /* This function is called by the "catch load" command. It allows the
342 debugger to be notified by the dynamic linker when a specified
343 library file (or any library file, if filename is NULL) is loaded. */
345 #ifndef SOLIB_CREATE_CATCH_LOAD_HOOK
346 #define SOLIB_CREATE_CATCH_LOAD_HOOK(pid,tempflag,filename,cond_string) \
347 error (_("catch of library loads not yet implemented on this platform"))
350 /* This function is called by the "catch unload" command. It allows
351 the debugger to be notified by the dynamic linker when a specified
352 library file (or any library file, if filename is NULL) is
355 #ifndef SOLIB_CREATE_CATCH_UNLOAD_HOOK
356 #define SOLIB_CREATE_CATCH_UNLOAD_HOOK(pid, tempflag, filename, cond_string) \
357 error (_("catch of library unloads not yet implemented on this platform"))
360 /* Return whether a breakpoint is an active enabled breakpoint. */
362 breakpoint_enabled (struct breakpoint *b)
364 return (b->enable_state == bp_enabled && !b->pending);
367 /* Set breakpoint count to NUM. */
370 set_breakpoint_count (int num)
372 breakpoint_count = num;
373 set_internalvar (lookup_internalvar ("bpnum"),
374 value_from_longest (builtin_type_int, (LONGEST) num));
377 /* Used in run_command to zero the hit count when a new run starts. */
380 clear_breakpoint_hit_counts (void)
382 struct breakpoint *b;
388 /* Default address, symtab and line to put a breakpoint at
389 for "break" command with no arg.
390 if default_breakpoint_valid is zero, the other three are
391 not valid, and "break" with no arg is an error.
393 This set by print_stack_frame, which calls set_default_breakpoint. */
395 int default_breakpoint_valid;
396 CORE_ADDR default_breakpoint_address;
397 struct symtab *default_breakpoint_symtab;
398 int default_breakpoint_line;
400 /* *PP is a string denoting a breakpoint. Get the number of the breakpoint.
401 Advance *PP after the string and any trailing whitespace.
403 Currently the string can either be a number or "$" followed by the name
404 of a convenience variable. Making it an expression wouldn't work well
405 for map_breakpoint_numbers (e.g. "4 + 5 + 6").
407 TRAILER is a character which can be found after the number; most
408 commonly this is `-'. If you don't want a trailer, use \0. */
410 get_number_trailer (char **pp, int trailer)
412 int retval = 0; /* default */
416 /* Empty line means refer to the last breakpoint. */
417 return breakpoint_count;
420 /* Make a copy of the name, so we can null-terminate it
421 to pass to lookup_internalvar(). */
426 while (isalnum (*p) || *p == '_')
428 varname = (char *) alloca (p - start + 1);
429 strncpy (varname, start, p - start);
430 varname[p - start] = '\0';
431 val = value_of_internalvar (lookup_internalvar (varname));
432 if (TYPE_CODE (value_type (val)) == TYPE_CODE_INT)
433 retval = (int) value_as_long (val);
436 printf_filtered (_("Convenience variable must have integer value.\n"));
444 while (*p >= '0' && *p <= '9')
447 /* There is no number here. (e.g. "cond a == b"). */
449 /* Skip non-numeric token */
450 while (*p && !isspace((int) *p))
452 /* Return zero, which caller must interpret as error. */
458 if (!(isspace (*p) || *p == '\0' || *p == trailer))
460 /* Trailing junk: return 0 and let caller print error msg. */
461 while (!(isspace (*p) || *p == '\0' || *p == trailer))
472 /* Like get_number_trailer, but don't allow a trailer. */
474 get_number (char **pp)
476 return get_number_trailer (pp, '\0');
479 /* Parse a number or a range.
480 * A number will be of the form handled by get_number.
481 * A range will be of the form <number1> - <number2>, and
482 * will represent all the integers between number1 and number2,
485 * While processing a range, this fuction is called iteratively;
486 * At each call it will return the next value in the range.
488 * At the beginning of parsing a range, the char pointer PP will
489 * be advanced past <number1> and left pointing at the '-' token.
490 * Subsequent calls will not advance the pointer until the range
491 * is completed. The call that completes the range will advance
492 * pointer PP past <number2>.
496 get_number_or_range (char **pp)
498 static int last_retval, end_value;
499 static char *end_ptr;
500 static int in_range = 0;
504 /* Default case: pp is pointing either to a solo number,
505 or to the first number of a range. */
506 last_retval = get_number_trailer (pp, '-');
511 /* This is the start of a range (<number1> - <number2>).
512 Skip the '-', parse and remember the second number,
513 and also remember the end of the final token. */
517 while (isspace ((int) *end_ptr))
518 end_ptr++; /* skip white space */
519 end_value = get_number (temp);
520 if (end_value < last_retval)
522 error (_("inverted range"));
524 else if (end_value == last_retval)
526 /* degenerate range (number1 == number2). Advance the
527 token pointer so that the range will be treated as a
536 error (_("negative value"));
539 /* pp points to the '-' that betokens a range. All
540 number-parsing has already been done. Return the next
541 integer value (one greater than the saved previous value).
542 Do not advance the token pointer 'pp' until the end of range
545 if (++last_retval == end_value)
547 /* End of range reached; advance token pointer. */
557 /* condition N EXP -- set break condition of breakpoint N to EXP. */
560 condition_command (char *arg, int from_tty)
562 struct breakpoint *b;
567 error_no_arg (_("breakpoint number"));
570 bnum = get_number (&p);
572 error (_("Bad breakpoint argument: '%s'"), arg);
575 if (b->number == bnum)
582 if (b->cond_string != NULL)
583 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));
600 b->cond = parse_exp_1 (&arg, block_for_pc (b->loc->address), 0);
602 error (_("Junk at end of expression"));
605 breakpoints_changed ();
606 breakpoint_modify_event (b->number);
610 error (_("No breakpoint number %d."), bnum);
614 commands_command (char *arg, int from_tty)
616 struct breakpoint *b;
619 struct command_line *l;
621 /* If we allowed this, we would have problems with when to
622 free the storage, if we change the commands currently
625 if (executing_breakpoint_commands)
626 error (_("Can't use the \"commands\" command among a breakpoint's commands."));
629 bnum = get_number (&p);
632 error (_("Unexpected extra arguments following breakpoint number."));
635 if (b->number == bnum)
637 char *tmpbuf = xstrprintf ("Type commands for when breakpoint %d is hit, one per line.",
639 struct cleanup *cleanups = make_cleanup (xfree, tmpbuf);
640 l = read_command_lines (tmpbuf, from_tty);
641 do_cleanups (cleanups);
642 free_command_lines (&b->commands);
644 breakpoints_changed ();
645 breakpoint_modify_event (b->number);
648 error (_("No breakpoint number %d."), bnum);
651 /* Like target_read_memory() but if breakpoints are inserted, return
652 the shadow contents instead of the breakpoints themselves.
654 Read "memory data" from whatever target or inferior we have.
655 Returns zero if successful, errno value if not. EIO is used
656 for address out of bounds. If breakpoints are inserted, returns
657 shadow contents, not the breakpoints themselves. From breakpoint.c. */
660 read_memory_nobpt (CORE_ADDR memaddr, gdb_byte *myaddr, unsigned len)
663 struct bp_location *b;
664 CORE_ADDR bp_addr = 0;
667 if (BREAKPOINT_FROM_PC (&bp_addr, &bp_size) == NULL)
668 /* No breakpoints on this machine. */
669 return target_read_memory (memaddr, myaddr, len);
673 if (b->owner->type == bp_none)
674 warning (_("reading through apparently deleted breakpoint #%d?"),
677 if (b->loc_type != bp_loc_software_breakpoint)
681 /* Addresses and length of the part of the breakpoint that
683 bp_addr = b->target_info.placed_address;
684 bp_size = b->target_info.shadow_len;
686 /* bp isn't valid, or doesn't shadow memory. */
688 if (bp_addr + bp_size <= memaddr)
689 /* The breakpoint is entirely before the chunk of memory we
692 if (bp_addr >= memaddr + len)
693 /* The breakpoint is entirely after the chunk of memory we are
696 /* Copy the breakpoint from the shadow contents, and recurse for
697 the things before and after. */
699 /* Offset within shadow_contents. */
702 if (bp_addr < memaddr)
704 /* Only copy the second part of the breakpoint. */
705 bp_size -= memaddr - bp_addr;
706 bptoffset = memaddr - bp_addr;
710 if (bp_addr + bp_size > memaddr + len)
712 /* Only copy the first part of the breakpoint. */
713 bp_size -= (bp_addr + bp_size) - (memaddr + len);
716 memcpy (myaddr + bp_addr - memaddr,
717 b->target_info.shadow_contents + bptoffset, bp_size);
719 if (bp_addr > memaddr)
721 /* Copy the section of memory before the breakpoint. */
722 status = read_memory_nobpt (memaddr, myaddr, bp_addr - memaddr);
727 if (bp_addr + bp_size < memaddr + len)
729 /* Copy the section of memory after the breakpoint. */
730 status = read_memory_nobpt (bp_addr + bp_size,
731 myaddr + bp_addr + bp_size - memaddr,
732 memaddr + len - (bp_addr + bp_size));
739 /* Nothing overlaps. Just call read_memory_noerr. */
740 return target_read_memory (memaddr, myaddr, len);
744 /* A wrapper function for inserting catchpoints. */
746 insert_catchpoint (struct ui_out *uo, void *args)
748 struct breakpoint *b = (struct breakpoint *) args;
754 target_insert_fork_catchpoint (PIDGET (inferior_ptid));
757 target_insert_vfork_catchpoint (PIDGET (inferior_ptid));
760 target_insert_exec_catchpoint (PIDGET (inferior_ptid));
763 internal_error (__FILE__, __LINE__, _("unknown breakpoint type"));
768 /* Helper routine: free the value chain for a breakpoint (watchpoint). */
771 free_valchain (struct bp_location *b)
776 /* Free the saved value chain. We will construct a new one
777 the next time the watchpoint is inserted. */
778 for (v = b->owner->val_chain; v; v = n)
783 b->owner->val_chain = NULL;
786 /* Insert a low-level "breakpoint" of some type. BPT is the breakpoint.
787 Any error messages are printed to TMP_ERROR_STREAM; and DISABLED_BREAKS,
788 PROCESS_WARNING, and HW_BREAKPOINT_ERROR are used to report problems.
790 NOTE drow/2003-09-09: This routine could be broken down to an object-style
791 method for each breakpoint or catchpoint type. */
793 insert_bp_location (struct bp_location *bpt,
794 struct ui_file *tmp_error_stream,
795 int *disabled_breaks, int *process_warning,
796 int *hw_breakpoint_error)
800 /* Permanent breakpoints cannot be inserted or removed. Disabled
801 breakpoints should not be inserted. */
802 if (!breakpoint_enabled (bpt->owner))
805 if (bpt->inserted || bpt->duplicate)
808 /* Initialize the target-specific information. */
809 memset (&bpt->target_info, 0, sizeof (bpt->target_info));
810 bpt->target_info.placed_address = bpt->address;
812 if (bpt->loc_type == bp_loc_software_breakpoint
813 || bpt->loc_type == bp_loc_hardware_breakpoint)
815 if (bpt->owner->type != bp_hardware_breakpoint)
817 /* If the explicitly specified breakpoint type
818 is not hardware breakpoint, check the memory map to see
819 if the breakpoint address is in read only memory or not.
820 Two important cases are:
821 - location type is not hardware breakpoint, memory
822 is readonly. We change the type of the location to
824 - location type is hardware breakpoint, memory is read-write.
825 This means we've previously made the location hardware one, but
826 then the memory map changed, so we undo.
828 When breakpoints are removed, remove_breakpoints will
829 use location types we've just set here, the only possible
830 problem is that memory map has changed during running program,
831 but it's not going to work anyway with current gdb. */
832 struct mem_region *mr
833 = lookup_mem_region (bpt->target_info.placed_address);
837 if (automatic_hardware_breakpoints)
840 enum bp_loc_type new_type;
842 if (mr->attrib.mode != MEM_RW)
843 new_type = bp_loc_hardware_breakpoint;
845 new_type = bp_loc_software_breakpoint;
847 if (new_type != bpt->loc_type)
850 bpt->loc_type = new_type;
853 fprintf_filtered (gdb_stdout, _("\
854 Note: automatically using hardware breakpoints for read-only addresses.\n"));
859 else if (bpt->loc_type == bp_loc_software_breakpoint
860 && mr->attrib.mode != MEM_RW)
861 warning (_("cannot set software breakpoint at readonly address %s"),
862 paddr (bpt->address));
866 /* First check to see if we have to handle an overlay. */
867 if (overlay_debugging == ovly_off
868 || bpt->section == NULL
869 || !(section_is_overlay (bpt->section)))
871 /* No overlay handling: just set the breakpoint. */
873 if (bpt->loc_type == bp_loc_hardware_breakpoint)
874 val = target_insert_hw_breakpoint (&bpt->target_info);
876 val = target_insert_breakpoint (&bpt->target_info);
880 /* This breakpoint is in an overlay section.
881 Shall we set a breakpoint at the LMA? */
882 if (!overlay_events_enabled)
884 /* Yes -- overlay event support is not active,
885 so we must try to set a breakpoint at the LMA.
886 This will not work for a hardware breakpoint. */
887 if (bpt->loc_type == bp_loc_hardware_breakpoint)
888 warning (_("hardware breakpoint %d not supported in overlay!"),
892 CORE_ADDR addr = overlay_unmapped_address (bpt->address,
894 /* Set a software (trap) breakpoint at the LMA. */
895 bpt->overlay_target_info = bpt->target_info;
896 bpt->overlay_target_info.placed_address = addr;
897 val = target_insert_breakpoint (&bpt->overlay_target_info);
899 fprintf_unfiltered (tmp_error_stream,
900 "Overlay breakpoint %d failed: in ROM?",
904 /* Shall we set a breakpoint at the VMA? */
905 if (section_is_mapped (bpt->section))
907 /* Yes. This overlay section is mapped into memory. */
908 if (bpt->loc_type == bp_loc_hardware_breakpoint)
909 val = target_insert_hw_breakpoint (&bpt->target_info);
911 val = target_insert_breakpoint (&bpt->target_info);
915 /* No. This breakpoint will not be inserted.
916 No error, but do not mark the bp as 'inserted'. */
923 /* Can't set the breakpoint. */
925 #if defined (DISABLE_UNSETTABLE_BREAK)
926 DISABLE_UNSETTABLE_BREAK (bpt->address)
928 solib_address (bpt->address)
932 /* See also: disable_breakpoints_in_shlibs. */
934 bpt->owner->enable_state = bp_shlib_disabled;
935 if (!*disabled_breaks)
937 fprintf_unfiltered (tmp_error_stream,
938 "Cannot insert breakpoint %d.\n",
940 fprintf_unfiltered (tmp_error_stream,
941 "Temporarily disabling shared library breakpoints:\n");
943 *disabled_breaks = 1;
944 fprintf_unfiltered (tmp_error_stream,
945 "breakpoint #%d\n", bpt->owner->number);
949 #ifdef ONE_PROCESS_WRITETEXT
950 *process_warning = 1;
952 if (bpt->loc_type == bp_loc_hardware_breakpoint)
954 *hw_breakpoint_error = 1;
955 fprintf_unfiltered (tmp_error_stream,
956 "Cannot insert hardware breakpoint %d.\n",
961 fprintf_unfiltered (tmp_error_stream,
962 "Cannot insert breakpoint %d.\n",
964 fprintf_filtered (tmp_error_stream,
965 "Error accessing memory address ");
966 deprecated_print_address_numeric (bpt->address, 1, tmp_error_stream);
967 fprintf_filtered (tmp_error_stream, ": %s.\n",
968 safe_strerror (val));
979 else if (bpt->loc_type == bp_loc_hardware_watchpoint
980 /* NOTE drow/2003-09-08: This state only exists for removing
981 watchpoints. It's not clear that it's necessary... */
982 && bpt->owner->disposition != disp_del_at_next_stop)
984 /* FIXME drow/2003-09-08: This code sets multiple hardware watchpoints
985 based on the expression. Ideally this should happen at a higher level,
986 and there should be one bp_location for each computed address we
987 must watch. As soon as a many-to-one mapping is available I'll
990 int within_current_scope;
991 struct value *mark = value_mark ();
993 struct frame_id saved_frame_id;
995 /* Save the current frame's ID so we can restore it after
996 evaluating the watchpoint expression on its own frame. */
997 /* FIXME drow/2003-09-09: It would be nice if evaluate_expression
998 took a frame parameter, so that we didn't have to change the
1000 saved_frame_id = get_frame_id (deprecated_selected_frame);
1002 /* Determine if the watchpoint is within scope. */
1003 if (bpt->owner->exp_valid_block == NULL)
1004 within_current_scope = 1;
1007 struct frame_info *fi;
1008 fi = frame_find_by_id (bpt->owner->watchpoint_frame);
1009 within_current_scope = (fi != NULL);
1010 if (within_current_scope)
1014 if (within_current_scope)
1016 free_valchain (bpt);
1018 /* Evaluate the expression and cut the chain of values
1019 produced off from the value chain.
1021 Make sure the value returned isn't lazy; we use
1022 laziness to determine what memory GDB actually needed
1023 in order to compute the value of the expression. */
1024 v = evaluate_expression (bpt->owner->exp);
1026 value_release_to_mark (mark);
1028 bpt->owner->val_chain = v;
1031 /* Look at each value on the value chain. */
1032 for (; v; v = value_next (v))
1034 /* If it's a memory location, and GDB actually needed
1035 its contents to evaluate the expression, then we
1037 if (VALUE_LVAL (v) == lval_memory
1038 && ! value_lazy (v))
1040 struct type *vtype = check_typedef (value_type (v));
1042 /* We only watch structs and arrays if user asked
1043 for it explicitly, never if they just happen to
1044 appear in the middle of some value chain. */
1045 if (v == bpt->owner->val_chain
1046 || (TYPE_CODE (vtype) != TYPE_CODE_STRUCT
1047 && TYPE_CODE (vtype) != TYPE_CODE_ARRAY))
1052 addr = VALUE_ADDRESS (v) + value_offset (v);
1053 len = TYPE_LENGTH (value_type (v));
1055 if (bpt->owner->type == bp_read_watchpoint)
1057 else if (bpt->owner->type == bp_access_watchpoint)
1060 val = target_insert_watchpoint (addr, len, type);
1063 /* Don't exit the loop, try to insert
1064 every value on the value chain. That's
1065 because we will be removing all the
1066 watches below, and removing a
1067 watchpoint we didn't insert could have
1075 /* Failure to insert a watchpoint on any memory value in the
1076 value chain brings us here. */
1079 remove_breakpoint (bpt, mark_uninserted);
1080 *hw_breakpoint_error = 1;
1081 fprintf_unfiltered (tmp_error_stream,
1082 "Could not insert hardware watchpoint %d.\n",
1083 bpt->owner->number);
1089 printf_filtered (_("\
1090 Hardware watchpoint %d deleted because the program has left the block \n\
1091 in which its expression is valid.\n"),
1092 bpt->owner->number);
1093 if (bpt->owner->related_breakpoint)
1094 bpt->owner->related_breakpoint->disposition = disp_del_at_next_stop;
1095 bpt->owner->disposition = disp_del_at_next_stop;
1098 /* Restore the selected frame. */
1099 select_frame (frame_find_by_id (saved_frame_id));
1104 else if (ep_is_exception_catchpoint (bpt->owner))
1106 /* FIXME drow/2003-09-09: This code sets both a catchpoint and a
1107 breakpoint. Once again, it would be better if this was represented
1108 as two bp_locations. */
1110 /* If we get here, we must have a callback mechanism for exception
1111 events -- with g++ style embedded label support, we insert
1112 ordinary breakpoints and not catchpoints. */
1113 val = target_insert_breakpoint (&bpt->target_info);
1116 /* Couldn't set breakpoint for some reason */
1117 fprintf_unfiltered (tmp_error_stream,
1118 "Cannot insert catchpoint %d; disabling it.\n",
1119 bpt->owner->number);
1120 fprintf_filtered (tmp_error_stream,
1121 "Error accessing memory address ");
1122 deprecated_print_address_numeric (bpt->address, 1, tmp_error_stream);
1123 fprintf_filtered (tmp_error_stream, ": %s.\n",
1124 safe_strerror (val));
1125 bpt->owner->enable_state = bp_disabled;
1129 /* Bp set, now make sure callbacks are enabled */
1130 /* Format possible error msg */
1131 char *message = xstrprintf ("Error inserting catchpoint %d:\n",
1132 bpt->owner->number);
1133 struct cleanup *cleanups = make_cleanup (xfree, message);
1135 args_for_catchpoint_enable args;
1136 args.kind = bpt->owner->type == bp_catch_catch ?
1137 EX_EVENT_CATCH : EX_EVENT_THROW;
1139 val = catch_errors (cover_target_enable_exception_callback,
1140 &args, message, RETURN_MASK_ALL);
1141 do_cleanups (cleanups);
1142 if (val != 0 && val != -1)
1145 /* Check if something went wrong; val == 0 can be ignored */
1148 /* something went wrong */
1149 fprintf_unfiltered (tmp_error_stream,
1150 "Cannot insert catchpoint %d; disabling it.\n",
1151 bpt->owner->number);
1152 bpt->owner->enable_state = bp_disabled;
1159 else if (bpt->owner->type == bp_catch_fork
1160 || bpt->owner->type == bp_catch_vfork
1161 || bpt->owner->type == bp_catch_exec)
1163 struct gdb_exception e = catch_exception (uiout, insert_catchpoint,
1164 bpt->owner, RETURN_MASK_ERROR);
1165 exception_fprintf (gdb_stderr, e, "warning: inserting catchpoint %d: ",
1166 bpt->owner->number);
1168 bpt->owner->enable_state = bp_disabled;
1172 /* We've already printed an error message if there was a problem
1173 inserting this catchpoint, and we've disabled the catchpoint,
1174 so just return success. */
1181 /* insert_breakpoints is used when starting or continuing the program.
1182 remove_breakpoints is used when the program stops.
1183 Both return zero if successful,
1184 or an `errno' value if could not write the inferior. */
1187 insert_breakpoints (void)
1189 struct bp_location *b, *temp;
1190 int return_val = 0; /* return success code. */
1192 int disabled_breaks = 0;
1193 int hw_breakpoint_error = 0;
1194 int process_warning = 0;
1196 struct ui_file *tmp_error_stream = mem_fileopen ();
1197 make_cleanup_ui_file_delete (tmp_error_stream);
1199 /* Explicitly mark the warning -- this will only be printed if
1200 there was an error. */
1201 fprintf_unfiltered (tmp_error_stream, "Warning:\n");
1203 ALL_BP_LOCATIONS_SAFE (b, temp)
1205 /* Permanent breakpoints cannot be inserted or removed. Disabled
1206 breakpoints should not be inserted. */
1207 if (!breakpoint_enabled (b->owner))
1210 /* There is no point inserting thread-specific breakpoints if the
1211 thread no longer exists. */
1212 if (b->owner->thread != -1
1213 && !valid_thread_id (b->owner->thread))
1216 /* FIXME drow/2003-10-07: This code should be pushed elsewhere when
1217 hardware watchpoints are split into multiple loc breakpoints. */
1218 if ((b->loc_type == bp_loc_hardware_watchpoint
1219 || b->owner->type == bp_watchpoint) && !b->owner->val)
1222 val = evaluate_expression (b->owner->exp);
1223 release_value (val);
1224 if (value_lazy (val))
1225 value_fetch_lazy (val);
1226 b->owner->val = val;
1229 val = insert_bp_location (b, tmp_error_stream,
1230 &disabled_breaks, &process_warning,
1231 &hw_breakpoint_error);
1238 /* If a hardware breakpoint or watchpoint was inserted, add a
1239 message about possibly exhausted resources. */
1240 if (hw_breakpoint_error)
1242 fprintf_unfiltered (tmp_error_stream,
1243 "Could not insert hardware breakpoints:\n\
1244 You may have requested too many hardware breakpoints/watchpoints.\n");
1246 #ifdef ONE_PROCESS_WRITETEXT
1247 if (process_warning)
1248 fprintf_unfiltered (tmp_error_stream,
1249 "The same program may be running in another process.");
1251 target_terminal_ours_for_output ();
1252 error_stream (tmp_error_stream);
1258 remove_breakpoints (void)
1260 struct bp_location *b;
1263 ALL_BP_LOCATIONS (b)
1267 val = remove_breakpoint (b, mark_uninserted);
1276 remove_hw_watchpoints (void)
1278 struct bp_location *b;
1281 ALL_BP_LOCATIONS (b)
1283 if (b->inserted && b->loc_type == bp_loc_hardware_watchpoint)
1285 val = remove_breakpoint (b, mark_uninserted);
1294 reattach_breakpoints (int pid)
1296 struct bp_location *b;
1298 struct cleanup *old_chain = save_inferior_ptid ();
1300 /* Set inferior_ptid; remove_breakpoint uses this global. */
1301 inferior_ptid = pid_to_ptid (pid);
1302 ALL_BP_LOCATIONS (b)
1306 remove_breakpoint (b, mark_inserted);
1307 /* Note: since we insert a breakpoint right after removing,
1308 any decisions about automatically using hardware breakpoints
1309 made in insert_bp_location are preserved. */
1310 if (b->loc_type == bp_loc_hardware_breakpoint)
1311 val = target_insert_hw_breakpoint (&b->target_info);
1313 val = target_insert_breakpoint (&b->target_info);
1314 /* FIXME drow/2003-10-07: This doesn't handle any other kinds of
1315 breakpoints. It's wrong for watchpoints, for example. */
1318 do_cleanups (old_chain);
1323 do_cleanups (old_chain);
1328 update_breakpoints_after_exec (void)
1330 struct breakpoint *b;
1331 struct breakpoint *temp;
1333 /* Doing this first prevents the badness of having delete_breakpoint()
1334 write a breakpoint's current "shadow contents" to lift the bp. That
1335 shadow is NOT valid after an exec()! */
1336 mark_breakpoints_out ();
1338 ALL_BREAKPOINTS_SAFE (b, temp)
1340 /* Solib breakpoints must be explicitly reset after an exec(). */
1341 if (b->type == bp_shlib_event)
1343 delete_breakpoint (b);
1347 /* Thread event breakpoints must be set anew after an exec(),
1348 as must overlay event breakpoints. */
1349 if (b->type == bp_thread_event || b->type == bp_overlay_event)
1351 delete_breakpoint (b);
1355 /* Step-resume breakpoints are meaningless after an exec(). */
1356 if (b->type == bp_step_resume)
1358 delete_breakpoint (b);
1362 /* Ditto the sigtramp handler breakpoints. */
1363 if (b->type == bp_through_sigtramp)
1365 delete_breakpoint (b);
1369 /* Ditto the exception-handling catchpoints. */
1370 if ((b->type == bp_catch_catch) || (b->type == bp_catch_throw))
1372 delete_breakpoint (b);
1376 /* Don't delete an exec catchpoint, because else the inferior
1377 won't stop when it ought!
1379 Similarly, we probably ought to keep vfork catchpoints, 'cause
1380 on this target, we may not be able to stop when the vfork is
1381 seen, but only when the subsequent exec is seen. (And because
1382 deleting fork catchpoints here but not vfork catchpoints will
1383 seem mysterious to users, keep those too.)
1385 ??rehrauer: Let's hope that merely clearing out this catchpoint's
1386 target address field, if any, is sufficient to have it be reset
1387 automagically. Certainly on HP-UX that's true.
1389 Jim Blandy <jimb@redhat.com>: Actually, zero is a perfectly
1390 valid code address on some platforms (like the mn10300
1391 simulators). We shouldn't assign any special interpretation to
1392 a breakpoint with a zero address. And in fact, GDB doesn't ---
1393 I can't see what that comment above is talking about. As far
1394 as I can tell, setting the address of a
1395 bp_catch_exec/bp_catch_vfork/bp_catch_fork breakpoint to zero
1396 is meaningless, since those are implemented with HP-UX kernel
1397 hackery, not by storing breakpoint instructions somewhere. */
1398 if ((b->type == bp_catch_exec) ||
1399 (b->type == bp_catch_vfork) ||
1400 (b->type == bp_catch_fork))
1402 b->loc->address = (CORE_ADDR) 0;
1406 /* bp_finish is a special case. The only way we ought to be able
1407 to see one of these when an exec() has happened, is if the user
1408 caught a vfork, and then said "finish". Ordinarily a finish just
1409 carries them to the call-site of the current callee, by setting
1410 a temporary bp there and resuming. But in this case, the finish
1411 will carry them entirely through the vfork & exec.
1413 We don't want to allow a bp_finish to remain inserted now. But
1414 we can't safely delete it, 'cause finish_command has a handle to
1415 the bp on a bpstat, and will later want to delete it. There's a
1416 chance (and I've seen it happen) that if we delete the bp_finish
1417 here, that its storage will get reused by the time finish_command
1418 gets 'round to deleting the "use to be a bp_finish" breakpoint.
1419 We really must allow finish_command to delete a bp_finish.
1421 In the absense of a general solution for the "how do we know
1422 it's safe to delete something others may have handles to?"
1423 problem, what we'll do here is just uninsert the bp_finish, and
1424 let finish_command delete it.
1426 (We know the bp_finish is "doomed" in the sense that it's
1427 momentary, and will be deleted as soon as finish_command sees
1428 the inferior stopped. So it doesn't matter that the bp's
1429 address is probably bogus in the new a.out, unlike e.g., the
1430 solib breakpoints.) */
1432 if (b->type == bp_finish)
1437 /* Without a symbolic address, we have little hope of the
1438 pre-exec() address meaning the same thing in the post-exec()
1440 if (b->addr_string == NULL)
1442 delete_breakpoint (b);
1446 /* If this breakpoint has survived the above battery of checks, then
1447 it must have a symbolic address. Be sure that it gets reevaluated
1448 to a target address, rather than reusing the old evaluation.
1450 Jim Blandy <jimb@redhat.com>: As explained above in the comment
1451 for bp_catch_exec and friends, I'm pretty sure this is entirely
1452 unnecessary. A call to breakpoint_re_set_one always recomputes
1453 the breakpoint's address from scratch, or deletes it if it can't.
1454 So I think this assignment could be deleted without effect. */
1455 b->loc->address = (CORE_ADDR) 0;
1457 /* FIXME what about longjmp breakpoints? Re-create them here? */
1458 create_overlay_event_breakpoint ("_ovly_debug_event");
1462 detach_breakpoints (int pid)
1464 struct bp_location *b;
1466 struct cleanup *old_chain = save_inferior_ptid ();
1468 if (pid == PIDGET (inferior_ptid))
1469 error (_("Cannot detach breakpoints of inferior_ptid"));
1471 /* Set inferior_ptid; remove_breakpoint uses this global. */
1472 inferior_ptid = pid_to_ptid (pid);
1473 ALL_BP_LOCATIONS (b)
1477 val = remove_breakpoint (b, mark_inserted);
1480 do_cleanups (old_chain);
1485 do_cleanups (old_chain);
1490 remove_breakpoint (struct bp_location *b, insertion_state_t is)
1494 if (b->owner->enable_state == bp_permanent)
1495 /* Permanent breakpoints cannot be inserted or removed. */
1498 if (b->owner->type == bp_none)
1499 warning (_("attempted to remove apparently deleted breakpoint #%d?"),
1502 if (b->loc_type == bp_loc_software_breakpoint
1503 || b->loc_type == bp_loc_hardware_breakpoint)
1505 /* "Normal" instruction breakpoint: either the standard
1506 trap-instruction bp (bp_breakpoint), or a
1507 bp_hardware_breakpoint. */
1509 /* First check to see if we have to handle an overlay. */
1510 if (overlay_debugging == ovly_off
1511 || b->section == NULL
1512 || !(section_is_overlay (b->section)))
1514 /* No overlay handling: just remove the breakpoint. */
1516 if (b->loc_type == bp_loc_hardware_breakpoint)
1517 val = target_remove_hw_breakpoint (&b->target_info);
1519 val = target_remove_breakpoint (&b->target_info);
1523 /* This breakpoint is in an overlay section.
1524 Did we set a breakpoint at the LMA? */
1525 if (!overlay_events_enabled)
1527 /* Yes -- overlay event support is not active, so we
1528 should have set a breakpoint at the LMA. Remove it.
1530 /* Ignore any failures: if the LMA is in ROM, we will
1531 have already warned when we failed to insert it. */
1532 if (b->loc_type == bp_loc_hardware_breakpoint)
1533 target_remove_hw_breakpoint (&b->overlay_target_info);
1535 target_remove_breakpoint (&b->overlay_target_info);
1537 /* Did we set a breakpoint at the VMA?
1538 If so, we will have marked the breakpoint 'inserted'. */
1541 /* Yes -- remove it. Previously we did not bother to
1542 remove the breakpoint if the section had been
1543 unmapped, but let's not rely on that being safe. We
1544 don't know what the overlay manager might do. */
1545 if (b->loc_type == bp_loc_hardware_breakpoint)
1546 val = target_remove_hw_breakpoint (&b->target_info);
1548 val = target_remove_breakpoint (&b->target_info);
1552 /* No -- not inserted, so no need to remove. No error. */
1558 b->inserted = (is == mark_inserted);
1560 else if (b->loc_type == bp_loc_hardware_watchpoint
1561 && breakpoint_enabled (b->owner)
1567 b->inserted = (is == mark_inserted);
1568 /* Walk down the saved value chain. */
1569 for (v = b->owner->val_chain; v; v = value_next (v))
1571 /* For each memory reference remove the watchpoint
1573 if (VALUE_LVAL (v) == lval_memory
1574 && ! value_lazy (v))
1576 struct type *vtype = check_typedef (value_type (v));
1578 if (v == b->owner->val_chain
1579 || (TYPE_CODE (vtype) != TYPE_CODE_STRUCT
1580 && TYPE_CODE (vtype) != TYPE_CODE_ARRAY))
1585 addr = VALUE_ADDRESS (v) + value_offset (v);
1586 len = TYPE_LENGTH (value_type (v));
1588 if (b->owner->type == bp_read_watchpoint)
1590 else if (b->owner->type == bp_access_watchpoint)
1593 val = target_remove_watchpoint (addr, len, type);
1600 /* Failure to remove any of the hardware watchpoints comes here. */
1601 if ((is == mark_uninserted) && (b->inserted))
1602 warning (_("Could not remove hardware watchpoint %d."),
1605 else if ((b->owner->type == bp_catch_fork ||
1606 b->owner->type == bp_catch_vfork ||
1607 b->owner->type == bp_catch_exec)
1608 && breakpoint_enabled (b->owner)
1612 switch (b->owner->type)
1615 val = target_remove_fork_catchpoint (PIDGET (inferior_ptid));
1617 case bp_catch_vfork:
1618 val = target_remove_vfork_catchpoint (PIDGET (inferior_ptid));
1621 val = target_remove_exec_catchpoint (PIDGET (inferior_ptid));
1624 warning (_("Internal error, %s line %d."), __FILE__, __LINE__);
1629 b->inserted = (is == mark_inserted);
1631 else if ((b->owner->type == bp_catch_catch ||
1632 b->owner->type == bp_catch_throw)
1633 && breakpoint_enabled (b->owner)
1636 val = target_remove_breakpoint (&b->target_info);
1639 b->inserted = (is == mark_inserted);
1645 /* Clear the "inserted" flag in all breakpoints. */
1648 mark_breakpoints_out (void)
1650 struct bp_location *bpt;
1652 ALL_BP_LOCATIONS (bpt)
1656 /* Clear the "inserted" flag in all breakpoints and delete any
1657 breakpoints which should go away between runs of the program.
1659 Plus other such housekeeping that has to be done for breakpoints
1662 Note: this function gets called at the end of a run (by
1663 generic_mourn_inferior) and when a run begins (by
1664 init_wait_for_inferior). */
1669 breakpoint_init_inferior (enum inf_context context)
1671 struct breakpoint *b, *temp;
1672 struct bp_location *bpt;
1673 static int warning_needed = 0;
1675 ALL_BP_LOCATIONS (bpt)
1678 ALL_BREAKPOINTS_SAFE (b, temp)
1683 case bp_watchpoint_scope:
1685 /* If the call dummy breakpoint is at the entry point it will
1686 cause problems when the inferior is rerun, so we better
1689 Also get rid of scope breakpoints. */
1690 delete_breakpoint (b);
1694 case bp_hardware_watchpoint:
1695 case bp_read_watchpoint:
1696 case bp_access_watchpoint:
1698 /* Likewise for watchpoints on local expressions. */
1699 if (b->exp_valid_block != NULL)
1700 delete_breakpoint (b);
1701 if (context == inf_starting)
1703 /* Reset val field to force reread of starting value
1704 in insert_breakpoints. */
1706 value_free (b->val);
1711 /* Likewise for exception catchpoints in dynamic-linked
1712 executables where required */
1713 if (ep_is_exception_catchpoint (b)
1714 && deprecated_exception_catchpoints_are_fragile)
1717 delete_breakpoint (b);
1723 if (deprecated_exception_catchpoints_are_fragile)
1724 deprecated_exception_support_initialized = 0;
1726 /* Don't issue the warning unless it's really needed... */
1727 if (warning_needed && (context != inf_exited))
1729 warning (_("Exception catchpoints from last run were deleted.\n"
1730 "You must reinsert them explicitly."));
1735 /* breakpoint_here_p (PC) returns non-zero if an enabled breakpoint
1736 exists at PC. It returns ordinary_breakpoint_here if it's an
1737 ordinary breakpoint, or permanent_breakpoint_here if it's a
1738 permanent breakpoint.
1739 - When continuing from a location with an ordinary breakpoint, we
1740 actually single step once before calling insert_breakpoints.
1741 - When continuing from a localion with a permanent breakpoint, we
1742 need to use the `SKIP_PERMANENT_BREAKPOINT' macro, provided by
1743 the target, to advance the PC past the breakpoint. */
1745 enum breakpoint_here
1746 breakpoint_here_p (CORE_ADDR pc)
1748 struct bp_location *bpt;
1749 int any_breakpoint_here = 0;
1751 ALL_BP_LOCATIONS (bpt)
1753 if (bpt->loc_type != bp_loc_software_breakpoint
1754 && bpt->loc_type != bp_loc_hardware_breakpoint)
1757 if ((breakpoint_enabled (bpt->owner)
1758 || bpt->owner->enable_state == bp_permanent)
1759 && bpt->address == pc) /* bp is enabled and matches pc */
1761 if (overlay_debugging
1762 && section_is_overlay (bpt->section)
1763 && !section_is_mapped (bpt->section))
1764 continue; /* unmapped overlay -- can't be a match */
1765 else if (bpt->owner->enable_state == bp_permanent)
1766 return permanent_breakpoint_here;
1768 any_breakpoint_here = 1;
1772 return any_breakpoint_here ? ordinary_breakpoint_here : 0;
1776 /* breakpoint_inserted_here_p (PC) is just like breakpoint_here_p(),
1777 but it only returns true if there is actually a breakpoint inserted
1781 breakpoint_inserted_here_p (CORE_ADDR pc)
1783 struct bp_location *bpt;
1785 ALL_BP_LOCATIONS (bpt)
1787 if (bpt->loc_type != bp_loc_software_breakpoint
1788 && bpt->loc_type != bp_loc_hardware_breakpoint)
1792 && bpt->address == pc) /* bp is inserted and matches pc */
1794 if (overlay_debugging
1795 && section_is_overlay (bpt->section)
1796 && !section_is_mapped (bpt->section))
1797 continue; /* unmapped overlay -- can't be a match */
1806 /* This function returns non-zero iff there is a software breakpoint
1810 software_breakpoint_inserted_here_p (CORE_ADDR pc)
1812 struct bp_location *bpt;
1813 int any_breakpoint_here = 0;
1815 ALL_BP_LOCATIONS (bpt)
1817 if (bpt->loc_type != bp_loc_software_breakpoint)
1820 if ((breakpoint_enabled (bpt->owner)
1821 || bpt->owner->enable_state == bp_permanent)
1823 && bpt->address == pc) /* bp is enabled and matches pc */
1825 if (overlay_debugging
1826 && section_is_overlay (bpt->section)
1827 && !section_is_mapped (bpt->section))
1828 continue; /* unmapped overlay -- can't be a match */
1837 /* breakpoint_thread_match (PC, PTID) returns true if the breakpoint at
1838 PC is valid for process/thread PTID. */
1841 breakpoint_thread_match (CORE_ADDR pc, ptid_t ptid)
1843 struct bp_location *bpt;
1846 thread = pid_to_thread_id (ptid);
1848 ALL_BP_LOCATIONS (bpt)
1850 if (bpt->loc_type != bp_loc_software_breakpoint
1851 && bpt->loc_type != bp_loc_hardware_breakpoint)
1854 if ((breakpoint_enabled (bpt->owner)
1855 || bpt->owner->enable_state == bp_permanent)
1856 && bpt->address == pc
1857 && (bpt->owner->thread == -1 || bpt->owner->thread == thread))
1859 if (overlay_debugging
1860 && section_is_overlay (bpt->section)
1861 && !section_is_mapped (bpt->section))
1862 continue; /* unmapped overlay -- can't be a match */
1872 /* bpstat stuff. External routines' interfaces are documented
1876 ep_is_catchpoint (struct breakpoint *ep)
1879 (ep->type == bp_catch_load)
1880 || (ep->type == bp_catch_unload)
1881 || (ep->type == bp_catch_fork)
1882 || (ep->type == bp_catch_vfork)
1883 || (ep->type == bp_catch_exec)
1884 || (ep->type == bp_catch_catch)
1885 || (ep->type == bp_catch_throw);
1887 /* ??rehrauer: Add more kinds here, as are implemented... */
1891 ep_is_shlib_catchpoint (struct breakpoint *ep)
1894 (ep->type == bp_catch_load)
1895 || (ep->type == bp_catch_unload);
1899 ep_is_exception_catchpoint (struct breakpoint *ep)
1902 (ep->type == bp_catch_catch)
1903 || (ep->type == bp_catch_throw);
1906 /* Clear a bpstat so that it says we are not at any breakpoint.
1907 Also free any storage that is part of a bpstat. */
1910 bpstat_clear (bpstat *bsp)
1921 if (p->old_val != NULL)
1922 value_free (p->old_val);
1923 free_command_lines (&p->commands);
1930 /* Return a copy of a bpstat. Like "bs1 = bs2" but all storage that
1931 is part of the bpstat is copied as well. */
1934 bpstat_copy (bpstat bs)
1938 bpstat retval = NULL;
1943 for (; bs != NULL; bs = bs->next)
1945 tmp = (bpstat) xmalloc (sizeof (*tmp));
1946 memcpy (tmp, bs, sizeof (*tmp));
1947 if (bs->commands != NULL)
1948 tmp->commands = copy_command_lines (bs->commands);
1949 if (bs->old_val != NULL)
1950 tmp->old_val = value_copy (bs->old_val);
1953 /* This is the first thing in the chain. */
1963 /* Find the bpstat associated with this breakpoint */
1966 bpstat_find_breakpoint (bpstat bsp, struct breakpoint *breakpoint)
1971 for (; bsp != NULL; bsp = bsp->next)
1973 if (bsp->breakpoint_at == breakpoint)
1979 /* Find a step_resume breakpoint associated with this bpstat.
1980 (If there are multiple step_resume bp's on the list, this function
1981 will arbitrarily pick one.)
1983 It is an error to use this function if BPSTAT doesn't contain a
1984 step_resume breakpoint.
1986 See wait_for_inferior's use of this function. */
1988 bpstat_find_step_resume_breakpoint (bpstat bsp)
1992 gdb_assert (bsp != NULL);
1994 current_thread = pid_to_thread_id (inferior_ptid);
1996 for (; bsp != NULL; bsp = bsp->next)
1998 if ((bsp->breakpoint_at != NULL) &&
1999 (bsp->breakpoint_at->type == bp_step_resume) &&
2000 (bsp->breakpoint_at->thread == current_thread ||
2001 bsp->breakpoint_at->thread == -1))
2002 return bsp->breakpoint_at;
2005 internal_error (__FILE__, __LINE__, _("No step_resume breakpoint found."));
2009 /* Return the breakpoint number of the first breakpoint we are stopped
2010 at. *BSP upon return is a bpstat which points to the remaining
2011 breakpoints stopped at (but which is not guaranteed to be good for
2012 anything but further calls to bpstat_num).
2013 Return 0 if passed a bpstat which does not indicate any breakpoints. */
2016 bpstat_num (bpstat *bsp)
2018 struct breakpoint *b;
2021 return 0; /* No more breakpoint values */
2024 b = (*bsp)->breakpoint_at;
2025 *bsp = (*bsp)->next;
2027 return -1; /* breakpoint that's been deleted since */
2029 return b->number; /* We have its number */
2033 /* Modify BS so that the actions will not be performed. */
2036 bpstat_clear_actions (bpstat bs)
2038 for (; bs != NULL; bs = bs->next)
2040 free_command_lines (&bs->commands);
2041 if (bs->old_val != NULL)
2043 value_free (bs->old_val);
2049 /* Stub for cleaning up our state if we error-out of a breakpoint command */
2051 cleanup_executing_breakpoints (void *ignore)
2053 executing_breakpoint_commands = 0;
2056 /* Execute all the commands associated with all the breakpoints at this
2057 location. Any of these commands could cause the process to proceed
2058 beyond this point, etc. We look out for such changes by checking
2059 the global "breakpoint_proceeded" after each command. */
2062 bpstat_do_actions (bpstat *bsp)
2065 struct cleanup *old_chain;
2067 /* Avoid endless recursion if a `source' command is contained
2069 if (executing_breakpoint_commands)
2072 executing_breakpoint_commands = 1;
2073 old_chain = make_cleanup (cleanup_executing_breakpoints, 0);
2076 /* Note that (as of this writing), our callers all appear to
2077 be passing us the address of global stop_bpstat. And, if
2078 our calls to execute_control_command cause the inferior to
2079 proceed, that global (and hence, *bsp) will change.
2081 We must be careful to not touch *bsp unless the inferior
2082 has not proceeded. */
2084 /* This pointer will iterate over the list of bpstat's. */
2087 breakpoint_proceeded = 0;
2088 for (; bs != NULL; bs = bs->next)
2090 struct command_line *cmd;
2091 struct cleanup *this_cmd_tree_chain;
2093 /* Take ownership of the BSP's command tree, if it has one.
2095 The command tree could legitimately contain commands like
2096 'step' and 'next', which call clear_proceed_status, which
2097 frees stop_bpstat's command tree. To make sure this doesn't
2098 free the tree we're executing out from under us, we need to
2099 take ownership of the tree ourselves. Since a given bpstat's
2100 commands are only executed once, we don't need to copy it; we
2101 can clear the pointer in the bpstat, and make sure we free
2102 the tree when we're done. */
2105 this_cmd_tree_chain = make_cleanup_free_command_lines (&cmd);
2109 execute_control_command (cmd);
2111 if (breakpoint_proceeded)
2117 /* We can free this command tree now. */
2118 do_cleanups (this_cmd_tree_chain);
2120 if (breakpoint_proceeded)
2121 /* The inferior is proceeded by the command; bomb out now.
2122 The bpstat chain has been blown away by wait_for_inferior.
2123 But since execution has stopped again, there is a new bpstat
2124 to look at, so start over. */
2127 do_cleanups (old_chain);
2130 /* This is the normal print function for a bpstat. In the future,
2131 much of this logic could (should?) be moved to bpstat_stop_status,
2132 by having it set different print_it values.
2134 Current scheme: When we stop, bpstat_print() is called. It loops
2135 through the bpstat list of things causing this stop, calling the
2136 print_bp_stop_message function on each one. The behavior of the
2137 print_bp_stop_message function depends on the print_it field of
2138 bpstat. If such field so indicates, call this function here.
2140 Return values from this routine (ultimately used by bpstat_print()
2141 and normal_stop() to decide what to do):
2142 PRINT_NOTHING: Means we already printed all we needed to print,
2143 don't print anything else.
2144 PRINT_SRC_ONLY: Means we printed something, and we do *not* desire
2145 that something to be followed by a location.
2146 PRINT_SCR_AND_LOC: Means we printed something, and we *do* desire
2147 that something to be followed by a location.
2148 PRINT_UNKNOWN: Means we printed nothing or we need to do some more
2151 static enum print_stop_action
2152 print_it_typical (bpstat bs)
2154 struct cleanup *old_chain, *ui_out_chain;
2155 struct ui_stream *stb;
2156 stb = ui_out_stream_new (uiout);
2157 old_chain = make_cleanup_ui_out_stream_delete (stb);
2158 /* bs->breakpoint_at can be NULL if it was a momentary breakpoint
2159 which has since been deleted. */
2160 if (bs->breakpoint_at == NULL)
2161 return PRINT_UNKNOWN;
2163 switch (bs->breakpoint_at->type)
2166 case bp_hardware_breakpoint:
2167 if (bs->breakpoint_at->loc->address != bs->breakpoint_at->loc->requested_address)
2168 breakpoint_adjustment_warning (bs->breakpoint_at->loc->requested_address,
2169 bs->breakpoint_at->loc->address,
2170 bs->breakpoint_at->number, 1);
2171 annotate_breakpoint (bs->breakpoint_at->number);
2172 ui_out_text (uiout, "\nBreakpoint ");
2173 if (ui_out_is_mi_like_p (uiout))
2174 ui_out_field_string (uiout, "reason",
2175 async_reason_lookup (EXEC_ASYNC_BREAKPOINT_HIT));
2176 ui_out_field_int (uiout, "bkptno", bs->breakpoint_at->number);
2177 ui_out_text (uiout, ", ");
2178 return PRINT_SRC_AND_LOC;
2181 case bp_shlib_event:
2182 /* Did we stop because the user set the stop_on_solib_events
2183 variable? (If so, we report this as a generic, "Stopped due
2184 to shlib event" message.) */
2185 printf_filtered (_("Stopped due to shared library event\n"));
2186 return PRINT_NOTHING;
2189 case bp_thread_event:
2190 /* Not sure how we will get here.
2191 GDB should not stop for these breakpoints. */
2192 printf_filtered (_("Thread Event Breakpoint: gdb should not stop!\n"));
2193 return PRINT_NOTHING;
2196 case bp_overlay_event:
2197 /* By analogy with the thread event, GDB should not stop for these. */
2198 printf_filtered (_("Overlay Event Breakpoint: gdb should not stop!\n"));
2199 return PRINT_NOTHING;
2203 annotate_catchpoint (bs->breakpoint_at->number);
2204 printf_filtered (_("\nCatchpoint %d (loaded %s), "),
2205 bs->breakpoint_at->number,
2206 bs->breakpoint_at->triggered_dll_pathname);
2207 return PRINT_SRC_AND_LOC;
2210 case bp_catch_unload:
2211 annotate_catchpoint (bs->breakpoint_at->number);
2212 printf_filtered (_("\nCatchpoint %d (unloaded %s), "),
2213 bs->breakpoint_at->number,
2214 bs->breakpoint_at->triggered_dll_pathname);
2215 return PRINT_SRC_AND_LOC;
2219 annotate_catchpoint (bs->breakpoint_at->number);
2220 printf_filtered (_("\nCatchpoint %d (forked process %d), "),
2221 bs->breakpoint_at->number,
2222 bs->breakpoint_at->forked_inferior_pid);
2223 return PRINT_SRC_AND_LOC;
2226 case bp_catch_vfork:
2227 annotate_catchpoint (bs->breakpoint_at->number);
2228 printf_filtered (_("\nCatchpoint %d (vforked process %d), "),
2229 bs->breakpoint_at->number,
2230 bs->breakpoint_at->forked_inferior_pid);
2231 return PRINT_SRC_AND_LOC;
2235 annotate_catchpoint (bs->breakpoint_at->number);
2236 printf_filtered (_("\nCatchpoint %d (exec'd %s), "),
2237 bs->breakpoint_at->number,
2238 bs->breakpoint_at->exec_pathname);
2239 return PRINT_SRC_AND_LOC;
2242 case bp_catch_catch:
2243 if (current_exception_event &&
2244 (CURRENT_EXCEPTION_KIND == EX_EVENT_CATCH))
2246 annotate_catchpoint (bs->breakpoint_at->number);
2247 printf_filtered (_("\nCatchpoint %d (exception caught), "),
2248 bs->breakpoint_at->number);
2249 if (CURRENT_EXCEPTION_THROW_PC && CURRENT_EXCEPTION_THROW_LINE)
2250 printf_filtered (_("throw location %s:%d, "),
2251 CURRENT_EXCEPTION_THROW_FILE,
2252 CURRENT_EXCEPTION_THROW_LINE);
2254 printf_filtered (_("throw location unknown, "));
2256 if (CURRENT_EXCEPTION_CATCH_PC && CURRENT_EXCEPTION_CATCH_LINE)
2257 printf_filtered (_("catch location %s:%d\n"),
2258 CURRENT_EXCEPTION_CATCH_FILE,
2259 CURRENT_EXCEPTION_CATCH_LINE);
2261 printf_filtered (_("catch location unknown\n"));
2263 /* don't bother to print location frame info */
2264 return PRINT_SRC_ONLY;
2268 /* really throw, some other bpstat will handle it */
2269 return PRINT_UNKNOWN;
2273 case bp_catch_throw:
2274 if (current_exception_event &&
2275 (CURRENT_EXCEPTION_KIND == EX_EVENT_THROW))
2277 annotate_catchpoint (bs->breakpoint_at->number);
2278 printf_filtered (_("\nCatchpoint %d (exception thrown), "),
2279 bs->breakpoint_at->number);
2280 if (CURRENT_EXCEPTION_THROW_PC && CURRENT_EXCEPTION_THROW_LINE)
2281 printf_filtered (_("throw location %s:%d, "),
2282 CURRENT_EXCEPTION_THROW_FILE,
2283 CURRENT_EXCEPTION_THROW_LINE);
2285 printf_filtered (_("throw location unknown, "));
2287 if (CURRENT_EXCEPTION_CATCH_PC && CURRENT_EXCEPTION_CATCH_LINE)
2288 printf_filtered (_("catch location %s:%d\n"),
2289 CURRENT_EXCEPTION_CATCH_FILE,
2290 CURRENT_EXCEPTION_CATCH_LINE);
2292 printf_filtered (_("catch location unknown\n"));
2294 /* don't bother to print location frame info */
2295 return PRINT_SRC_ONLY;
2299 /* really catch, some other bpstat will handle it */
2300 return PRINT_UNKNOWN;
2305 case bp_hardware_watchpoint:
2306 if (bs->old_val != NULL)
2308 annotate_watchpoint (bs->breakpoint_at->number);
2309 if (ui_out_is_mi_like_p (uiout))
2312 async_reason_lookup (EXEC_ASYNC_WATCHPOINT_TRIGGER));
2313 mention (bs->breakpoint_at);
2314 ui_out_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "value");
2315 ui_out_text (uiout, "\nOld value = ");
2316 value_print (bs->old_val, stb->stream, 0, Val_pretty_default);
2317 ui_out_field_stream (uiout, "old", stb);
2318 ui_out_text (uiout, "\nNew value = ");
2319 value_print (bs->breakpoint_at->val, stb->stream, 0, Val_pretty_default);
2320 ui_out_field_stream (uiout, "new", stb);
2321 do_cleanups (ui_out_chain);
2322 ui_out_text (uiout, "\n");
2323 value_free (bs->old_val);
2326 /* More than one watchpoint may have been triggered. */
2327 return PRINT_UNKNOWN;
2330 case bp_read_watchpoint:
2331 if (ui_out_is_mi_like_p (uiout))
2334 async_reason_lookup (EXEC_ASYNC_READ_WATCHPOINT_TRIGGER));
2335 mention (bs->breakpoint_at);
2336 ui_out_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "value");
2337 ui_out_text (uiout, "\nValue = ");
2338 value_print (bs->breakpoint_at->val, stb->stream, 0, Val_pretty_default);
2339 ui_out_field_stream (uiout, "value", stb);
2340 do_cleanups (ui_out_chain);
2341 ui_out_text (uiout, "\n");
2342 return PRINT_UNKNOWN;
2345 case bp_access_watchpoint:
2346 if (bs->old_val != NULL)
2348 annotate_watchpoint (bs->breakpoint_at->number);
2349 if (ui_out_is_mi_like_p (uiout))
2352 async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER));
2353 mention (bs->breakpoint_at);
2354 ui_out_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "value");
2355 ui_out_text (uiout, "\nOld value = ");
2356 value_print (bs->old_val, stb->stream, 0, Val_pretty_default);
2357 ui_out_field_stream (uiout, "old", stb);
2358 value_free (bs->old_val);
2360 ui_out_text (uiout, "\nNew value = ");
2364 mention (bs->breakpoint_at);
2365 if (ui_out_is_mi_like_p (uiout))
2368 async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER));
2369 ui_out_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "value");
2370 ui_out_text (uiout, "\nValue = ");
2372 value_print (bs->breakpoint_at->val, stb->stream, 0,Val_pretty_default);
2373 ui_out_field_stream (uiout, "new", stb);
2374 do_cleanups (ui_out_chain);
2375 ui_out_text (uiout, "\n");
2376 return PRINT_UNKNOWN;
2379 /* Fall through, we don't deal with these types of breakpoints
2383 if (ui_out_is_mi_like_p (uiout))
2386 async_reason_lookup (EXEC_ASYNC_FUNCTION_FINISHED));
2387 return PRINT_UNKNOWN;
2391 if (ui_out_is_mi_like_p (uiout))
2394 async_reason_lookup (EXEC_ASYNC_LOCATION_REACHED));
2395 return PRINT_UNKNOWN;
2400 case bp_longjmp_resume:
2401 case bp_step_resume:
2402 case bp_through_sigtramp:
2403 case bp_watchpoint_scope:
2406 return PRINT_UNKNOWN;
2410 /* Generic routine for printing messages indicating why we
2411 stopped. The behavior of this function depends on the value
2412 'print_it' in the bpstat structure. Under some circumstances we
2413 may decide not to print anything here and delegate the task to
2416 static enum print_stop_action
2417 print_bp_stop_message (bpstat bs)
2419 switch (bs->print_it)
2422 /* Nothing should be printed for this bpstat entry. */
2423 return PRINT_UNKNOWN;
2427 /* We still want to print the frame, but we already printed the
2428 relevant messages. */
2429 return PRINT_SRC_AND_LOC;
2432 case print_it_normal:
2433 /* Normal case. Call the breakpoint's print_it method, or
2434 print_it_typical. */
2435 if (bs->breakpoint_at != NULL && bs->breakpoint_at->ops != NULL
2436 && bs->breakpoint_at->ops->print_it != NULL)
2437 return bs->breakpoint_at->ops->print_it (bs->breakpoint_at);
2439 return print_it_typical (bs);
2443 internal_error (__FILE__, __LINE__,
2444 _("print_bp_stop_message: unrecognized enum value"));
2449 /* Print a message indicating what happened. This is called from
2450 normal_stop(). The input to this routine is the head of the bpstat
2451 list - a list of the eventpoints that caused this stop. This
2452 routine calls the generic print routine for printing a message
2453 about reasons for stopping. This will print (for example) the
2454 "Breakpoint n," part of the output. The return value of this
2457 PRINT_UNKNOWN: Means we printed nothing
2458 PRINT_SRC_AND_LOC: Means we printed something, and expect subsequent
2459 code to print the location. An example is
2460 "Breakpoint 1, " which should be followed by
2462 PRINT_SRC_ONLY: Means we printed something, but there is no need
2463 to also print the location part of the message.
2464 An example is the catch/throw messages, which
2465 don't require a location appended to the end.
2466 PRINT_NOTHING: We have done some printing and we don't need any
2467 further info to be printed.*/
2469 enum print_stop_action
2470 bpstat_print (bpstat bs)
2474 /* Maybe another breakpoint in the chain caused us to stop.
2475 (Currently all watchpoints go on the bpstat whether hit or not.
2476 That probably could (should) be changed, provided care is taken
2477 with respect to bpstat_explains_signal). */
2478 for (; bs; bs = bs->next)
2480 val = print_bp_stop_message (bs);
2481 if (val == PRINT_SRC_ONLY
2482 || val == PRINT_SRC_AND_LOC
2483 || val == PRINT_NOTHING)
2487 /* We reached the end of the chain, or we got a null BS to start
2488 with and nothing was printed. */
2489 return PRINT_UNKNOWN;
2492 /* Evaluate the expression EXP and return 1 if value is zero.
2493 This is used inside a catch_errors to evaluate the breakpoint condition.
2494 The argument is a "struct expression *" that has been cast to char * to
2495 make it pass through catch_errors. */
2498 breakpoint_cond_eval (void *exp)
2500 struct value *mark = value_mark ();
2501 int i = !value_true (evaluate_expression ((struct expression *) exp));
2502 value_free_to_mark (mark);
2506 /* Allocate a new bpstat and chain it to the current one. */
2509 bpstat_alloc (struct breakpoint *b, bpstat cbs /* Current "bs" value */ )
2513 bs = (bpstat) xmalloc (sizeof (*bs));
2515 bs->breakpoint_at = b;
2516 /* If the condition is false, etc., don't do the commands. */
2517 bs->commands = NULL;
2519 bs->print_it = print_it_normal;
2523 /* Possible return values for watchpoint_check (this can't be an enum
2524 because of check_errors). */
2525 /* The watchpoint has been deleted. */
2526 #define WP_DELETED 1
2527 /* The value has changed. */
2528 #define WP_VALUE_CHANGED 2
2529 /* The value has not changed. */
2530 #define WP_VALUE_NOT_CHANGED 3
2532 #define BP_TEMPFLAG 1
2533 #define BP_HARDWAREFLAG 2
2535 /* Check watchpoint condition. */
2538 watchpoint_check (void *p)
2540 bpstat bs = (bpstat) p;
2541 struct breakpoint *b;
2542 struct frame_info *fr;
2543 int within_current_scope;
2545 b = bs->breakpoint_at;
2547 if (b->exp_valid_block == NULL)
2548 within_current_scope = 1;
2551 /* There is no current frame at this moment. If we're going to have
2552 any chance of handling watchpoints on local variables, we'll need
2553 the frame chain (so we can determine if we're in scope). */
2554 reinit_frame_cache ();
2555 fr = frame_find_by_id (b->watchpoint_frame);
2556 within_current_scope = (fr != NULL);
2558 /* If we've gotten confused in the unwinder, we might have
2559 returned a frame that can't describe this variable. */
2560 if (within_current_scope
2561 && block_function (b->exp_valid_block) != get_frame_function (fr))
2562 within_current_scope = 0;
2564 /* in_function_epilogue_p() returns a non-zero value if we're still
2565 in the function but the stack frame has already been invalidated.
2566 Since we can't rely on the values of local variables after the
2567 stack has been destroyed, we are treating the watchpoint in that
2568 state as `not changed' without further checking.
2570 vinschen/2003-09-04: The former implementation left out the case
2571 that the watchpoint frame couldn't be found by frame_find_by_id()
2572 because the current PC is currently in an epilogue. Calling
2573 gdbarch_in_function_epilogue_p() also when fr == NULL fixes that. */
2574 if ((!within_current_scope || fr == get_current_frame ())
2575 && gdbarch_in_function_epilogue_p (current_gdbarch, read_pc ()))
2576 return WP_VALUE_NOT_CHANGED;
2577 if (fr && within_current_scope)
2578 /* If we end up stopping, the current frame will get selected
2579 in normal_stop. So this call to select_frame won't affect
2584 if (within_current_scope)
2586 /* We use value_{,free_to_}mark because it could be a
2587 *long* time before we return to the command level and
2588 call free_all_values. We can't call free_all_values because
2589 we might be in the middle of evaluating a function call. */
2591 struct value *mark = value_mark ();
2592 struct value *new_val = evaluate_expression (bs->breakpoint_at->exp);
2593 if (!value_equal (b->val, new_val))
2595 release_value (new_val);
2596 value_free_to_mark (mark);
2597 bs->old_val = b->val;
2599 /* We will stop here */
2600 return WP_VALUE_CHANGED;
2604 /* Nothing changed, don't do anything. */
2605 value_free_to_mark (mark);
2606 /* We won't stop here */
2607 return WP_VALUE_NOT_CHANGED;
2612 /* This seems like the only logical thing to do because
2613 if we temporarily ignored the watchpoint, then when
2614 we reenter the block in which it is valid it contains
2615 garbage (in the case of a function, it may have two
2616 garbage values, one before and one after the prologue).
2617 So we can't even detect the first assignment to it and
2618 watch after that (since the garbage may or may not equal
2619 the first value assigned). */
2620 /* We print all the stop information in print_it_typical(), but
2621 in this case, by the time we call print_it_typical() this bp
2622 will be deleted already. So we have no choice but print the
2623 information here. */
2624 if (ui_out_is_mi_like_p (uiout))
2626 (uiout, "reason", async_reason_lookup (EXEC_ASYNC_WATCHPOINT_SCOPE));
2627 ui_out_text (uiout, "\nWatchpoint ");
2628 ui_out_field_int (uiout, "wpnum", bs->breakpoint_at->number);
2629 ui_out_text (uiout, " deleted because the program has left the block in\n\
2630 which its expression is valid.\n");
2632 if (b->related_breakpoint)
2633 b->related_breakpoint->disposition = disp_del_at_next_stop;
2634 b->disposition = disp_del_at_next_stop;
2640 /* Get a bpstat associated with having just stopped at address
2641 BP_ADDR in thread PTID. STOPPED_BY_WATCHPOINT is 1 if the
2642 target thinks we stopped due to a hardware watchpoint, 0 if we
2643 know we did not trigger a hardware watchpoint, and -1 if we do not know. */
2645 /* Determine whether we stopped at a breakpoint, etc, or whether we
2646 don't understand this stop. Result is a chain of bpstat's such that:
2648 if we don't understand the stop, the result is a null pointer.
2650 if we understand why we stopped, the result is not null.
2652 Each element of the chain refers to a particular breakpoint or
2653 watchpoint at which we have stopped. (We may have stopped for
2654 several reasons concurrently.)
2656 Each element of the chain has valid next, breakpoint_at,
2657 commands, FIXME??? fields. */
2660 bpstat_stop_status (CORE_ADDR bp_addr, ptid_t ptid, int stopped_by_watchpoint)
2662 struct breakpoint *b, *temp;
2663 /* True if we've hit a breakpoint (as opposed to a watchpoint). */
2664 int real_breakpoint = 0;
2665 /* Root of the chain of bpstat's */
2666 struct bpstats root_bs[1];
2667 /* Pointer to the last thing in the chain currently. */
2668 bpstat bs = root_bs;
2669 int thread_id = pid_to_thread_id (ptid);
2671 ALL_BREAKPOINTS_SAFE (b, temp)
2673 if (!breakpoint_enabled (b) && b->enable_state != bp_permanent)
2676 if (b->type != bp_watchpoint
2677 && b->type != bp_hardware_watchpoint
2678 && b->type != bp_read_watchpoint
2679 && b->type != bp_access_watchpoint
2680 && b->type != bp_hardware_breakpoint
2681 && b->type != bp_catch_fork
2682 && b->type != bp_catch_vfork
2683 && b->type != bp_catch_exec
2684 && b->type != bp_catch_catch
2685 && b->type != bp_catch_throw) /* a non-watchpoint bp */
2687 if (b->loc->address != bp_addr) /* address doesn't match */
2689 if (overlay_debugging /* unmapped overlay section */
2690 && section_is_overlay (b->loc->section)
2691 && !section_is_mapped (b->loc->section))
2695 /* Continuable hardware watchpoints are treated as non-existent if the
2696 reason we stopped wasn't a hardware watchpoint (we didn't stop on
2697 some data address). Otherwise gdb won't stop on a break instruction
2698 in the code (not from a breakpoint) when a hardware watchpoint has
2701 if ((b->type == bp_hardware_watchpoint
2702 || b->type == bp_read_watchpoint
2703 || b->type == bp_access_watchpoint)
2704 && !stopped_by_watchpoint)
2707 if (b->type == bp_hardware_breakpoint)
2709 if (b->loc->address != bp_addr)
2711 if (overlay_debugging /* unmapped overlay section */
2712 && section_is_overlay (b->loc->section)
2713 && !section_is_mapped (b->loc->section))
2717 /* Is this a catchpoint of a load or unload? If so, did we
2718 get a load or unload of the specified library? If not,
2720 if ((b->type == bp_catch_load)
2721 #if defined(SOLIB_HAVE_LOAD_EVENT)
2722 && (!SOLIB_HAVE_LOAD_EVENT (PIDGET (inferior_ptid))
2723 || ((b->dll_pathname != NULL)
2724 && (strcmp (b->dll_pathname,
2725 SOLIB_LOADED_LIBRARY_PATHNAME (
2726 PIDGET (inferior_ptid)))
2732 if ((b->type == bp_catch_unload)
2733 #if defined(SOLIB_HAVE_UNLOAD_EVENT)
2734 && (!SOLIB_HAVE_UNLOAD_EVENT (PIDGET (inferior_ptid))
2735 || ((b->dll_pathname != NULL)
2736 && (strcmp (b->dll_pathname,
2737 SOLIB_UNLOADED_LIBRARY_PATHNAME (
2738 PIDGET (inferior_ptid)))
2744 if ((b->type == bp_catch_fork)
2745 && !inferior_has_forked (PIDGET (inferior_ptid),
2746 &b->forked_inferior_pid))
2749 if ((b->type == bp_catch_vfork)
2750 && !inferior_has_vforked (PIDGET (inferior_ptid),
2751 &b->forked_inferior_pid))
2754 if ((b->type == bp_catch_exec)
2755 && !inferior_has_execd (PIDGET (inferior_ptid), &b->exec_pathname))
2758 if (ep_is_exception_catchpoint (b) &&
2759 !(current_exception_event = target_get_current_exception_event ()))
2762 /* Come here if it's a watchpoint, or if the break address matches */
2764 bs = bpstat_alloc (b, bs); /* Alloc a bpstat to explain stop */
2766 /* Watchpoints may change this, if not found to have triggered. */
2770 if (b->type == bp_watchpoint ||
2771 b->type == bp_hardware_watchpoint)
2773 char *message = xstrprintf ("Error evaluating expression for watchpoint %d\n",
2775 struct cleanup *cleanups = make_cleanup (xfree, message);
2776 int e = catch_errors (watchpoint_check, bs, message,
2778 do_cleanups (cleanups);
2782 /* We've already printed what needs to be printed. */
2783 /* Actually this is superfluous, because by the time we
2784 call print_it_typical() the wp will be already deleted,
2785 and the function will return immediately. */
2786 bs->print_it = print_it_done;
2789 case WP_VALUE_CHANGED:
2793 case WP_VALUE_NOT_CHANGED:
2795 bs->print_it = print_it_noop;
2802 /* Error from catch_errors. */
2803 printf_filtered (_("Watchpoint %d deleted.\n"), b->number);
2804 if (b->related_breakpoint)
2805 b->related_breakpoint->disposition = disp_del_at_next_stop;
2806 b->disposition = disp_del_at_next_stop;
2807 /* We've already printed what needs to be printed. */
2808 bs->print_it = print_it_done;
2814 else if (b->type == bp_read_watchpoint ||
2815 b->type == bp_access_watchpoint)
2821 if (!target_stopped_data_address (¤t_target, &addr))
2823 for (v = b->val_chain; v; v = value_next (v))
2825 if (VALUE_LVAL (v) == lval_memory
2826 && ! value_lazy (v))
2828 struct type *vtype = check_typedef (value_type (v));
2830 if (v == b->val_chain
2831 || (TYPE_CODE (vtype) != TYPE_CODE_STRUCT
2832 && TYPE_CODE (vtype) != TYPE_CODE_ARRAY))
2836 vaddr = VALUE_ADDRESS (v) + value_offset (v);
2837 /* Exact match not required. Within range is
2839 if (addr >= vaddr &&
2840 addr < vaddr + TYPE_LENGTH (value_type (v)))
2847 char *message = xstrprintf ("Error evaluating expression for watchpoint %d\n",
2849 struct cleanup *cleanups = make_cleanup (xfree, message);
2850 int e = catch_errors (watchpoint_check, bs, message,
2852 do_cleanups (cleanups);
2856 /* We've already printed what needs to be printed. */
2857 bs->print_it = print_it_done;
2860 case WP_VALUE_CHANGED:
2861 if (b->type == bp_read_watchpoint)
2863 /* Don't stop: read watchpoints shouldn't fire if
2864 the value has changed. This is for targets
2865 which cannot set read-only watchpoints. */
2866 bs->print_it = print_it_noop;
2872 case WP_VALUE_NOT_CHANGED:
2879 /* Error from catch_errors. */
2880 printf_filtered (_("Watchpoint %d deleted.\n"), b->number);
2881 if (b->related_breakpoint)
2882 b->related_breakpoint->disposition = disp_del_at_next_stop;
2883 b->disposition = disp_del_at_next_stop;
2884 /* We've already printed what needs to be printed. */
2885 bs->print_it = print_it_done;
2889 else /* found == 0 */
2891 /* This is a case where some watchpoint(s) triggered,
2892 but not at the address of this watchpoint (FOUND
2893 was left zero). So don't print anything for this
2895 bs->print_it = print_it_noop;
2902 /* By definition, an encountered breakpoint is a triggered
2906 real_breakpoint = 1;
2909 if (frame_id_p (b->frame_id)
2910 && !frame_id_eq (b->frame_id, get_frame_id (get_current_frame ())))
2914 int value_is_zero = 0;
2918 /* Need to select the frame, with all that implies
2919 so that the conditions will have the right context. */
2920 select_frame (get_current_frame ());
2922 = catch_errors (breakpoint_cond_eval, (b->cond),
2923 "Error in testing breakpoint condition:\n",
2925 /* FIXME-someday, should give breakpoint # */
2928 if (b->cond && value_is_zero)
2931 /* Don't consider this a hit. */
2934 else if (b->thread != -1 && b->thread != thread_id)
2937 /* Don't consider this a hit. */
2940 else if (b->ignore_count > 0)
2943 annotate_ignore_count_change ();
2948 /* We will stop here */
2949 if (b->disposition == disp_disable)
2950 b->enable_state = bp_disabled;
2953 bs->commands = b->commands;
2955 (strcmp ("silent", bs->commands->line) == 0
2956 || (xdb_commands && strcmp ("Q", bs->commands->line) == 0)))
2958 bs->commands = bs->commands->next;
2961 bs->commands = copy_command_lines (bs->commands);
2964 /* Print nothing for this entry if we dont stop or if we dont print. */
2965 if (bs->stop == 0 || bs->print == 0)
2966 bs->print_it = print_it_noop;
2969 bs->next = NULL; /* Terminate the chain */
2970 bs = root_bs->next; /* Re-grab the head of the chain */
2972 /* The value of a hardware watchpoint hasn't changed, but the
2973 intermediate memory locations we are watching may have. */
2974 if (bs && !bs->stop &&
2975 (bs->breakpoint_at->type == bp_hardware_watchpoint ||
2976 bs->breakpoint_at->type == bp_read_watchpoint ||
2977 bs->breakpoint_at->type == bp_access_watchpoint))
2979 remove_breakpoints ();
2980 insert_breakpoints ();
2985 /* Tell what to do about this bpstat. */
2987 bpstat_what (bpstat bs)
2989 /* Classify each bpstat as one of the following. */
2992 /* This bpstat element has no effect on the main_action. */
2995 /* There was a watchpoint, stop but don't print. */
2998 /* There was a watchpoint, stop and print. */
3001 /* There was a breakpoint but we're not stopping. */
3004 /* There was a breakpoint, stop but don't print. */
3007 /* There was a breakpoint, stop and print. */
3010 /* We hit the longjmp breakpoint. */
3013 /* We hit the longjmp_resume breakpoint. */
3016 /* We hit the step_resume breakpoint. */
3019 /* We hit the through_sigtramp breakpoint. */
3022 /* We hit the shared library event breakpoint. */
3025 /* We caught a shared library event. */
3028 /* This is just used to count how many enums there are. */
3032 /* Here is the table which drives this routine. So that we can
3033 format it pretty, we define some abbreviations for the
3034 enum bpstat_what codes. */
3035 #define kc BPSTAT_WHAT_KEEP_CHECKING
3036 #define ss BPSTAT_WHAT_STOP_SILENT
3037 #define sn BPSTAT_WHAT_STOP_NOISY
3038 #define sgl BPSTAT_WHAT_SINGLE
3039 #define slr BPSTAT_WHAT_SET_LONGJMP_RESUME
3040 #define clr BPSTAT_WHAT_CLEAR_LONGJMP_RESUME
3041 #define clrs BPSTAT_WHAT_CLEAR_LONGJMP_RESUME_SINGLE
3042 #define sr BPSTAT_WHAT_STEP_RESUME
3043 #define ts BPSTAT_WHAT_THROUGH_SIGTRAMP
3044 #define shl BPSTAT_WHAT_CHECK_SHLIBS
3045 #define shlr BPSTAT_WHAT_CHECK_SHLIBS_RESUME_FROM_HOOK
3047 /* "Can't happen." Might want to print an error message.
3048 abort() is not out of the question, but chances are GDB is just
3049 a bit confused, not unusable. */
3050 #define err BPSTAT_WHAT_STOP_NOISY
3052 /* Given an old action and a class, come up with a new action. */
3053 /* One interesting property of this table is that wp_silent is the same
3054 as bp_silent and wp_noisy is the same as bp_noisy. That is because
3055 after stopping, the check for whether to step over a breakpoint
3056 (BPSTAT_WHAT_SINGLE type stuff) is handled in proceed() without
3057 reference to how we stopped. We retain separate wp_silent and
3058 bp_silent codes in case we want to change that someday.
3060 Another possibly interesting property of this table is that
3061 there's a partial ordering, priority-like, of the actions. Once
3062 you've decided that some action is appropriate, you'll never go
3063 back and decide something of a lower priority is better. The
3066 kc < clr sgl shl shlr slr sn sr ss ts
3067 sgl < clrs shl shlr slr sn sr ss ts
3068 slr < err shl shlr sn sr ss ts
3069 clr < clrs err shl shlr sn sr ss ts
3070 clrs < err shl shlr sn sr ss ts
3071 ss < shl shlr sn sr ts
3078 What I think this means is that we don't need a damned table
3079 here. If you just put the rows and columns in the right order,
3080 it'd look awfully regular. We could simply walk the bpstat list
3081 and choose the highest priority action we find, with a little
3082 logic to handle the 'err' cases, and the CLEAR_LONGJMP_RESUME/
3083 CLEAR_LONGJMP_RESUME_SINGLE distinction (which breakpoint.h says
3084 is messy anyway). */
3086 /* step_resume entries: a step resume breakpoint overrides another
3087 breakpoint of signal handling (see comment in wait_for_inferior
3088 at where we set the step_resume breakpoint). */
3089 /* We handle the through_sigtramp_breakpoint the same way; having both
3090 one of those and a step_resume_breakpoint is probably very rare (?). */
3092 static const enum bpstat_what_main_action
3093 table[(int) class_last][(int) BPSTAT_WHAT_LAST] =
3096 /* kc ss sn sgl slr clr clrs sr ts shl shlr
3099 {kc, ss, sn, sgl, slr, clr, clrs, sr, ts, shl, shlr},
3101 {ss, ss, sn, ss, ss, ss, ss, sr, ts, shl, shlr},
3103 {sn, sn, sn, sn, sn, sn, sn, sr, ts, shl, shlr},
3105 {sgl, ss, sn, sgl, slr, clrs, clrs, sr, ts, shl, shlr},
3107 {ss, ss, sn, ss, ss, ss, ss, sr, ts, shl, shlr},
3109 {sn, sn, sn, sn, sn, sn, sn, sr, ts, shl, shlr},
3111 {slr, ss, sn, slr, slr, err, err, sr, ts, shl, shlr},
3113 {clr, ss, sn, clrs, err, err, err, sr, ts, shl, shlr},
3115 {sr, sr, sr, sr, sr, sr, sr, sr, ts, shl, shlr},
3117 {ts, ts, ts, ts, ts, ts, ts, ts, ts, shl, shlr},
3119 {shl, shl, shl, shl, shl, shl, shl, shl, ts, shl, shlr},
3121 {shlr, shlr, shlr, shlr, shlr, shlr, shlr, shlr, ts, shlr, shlr}
3136 enum bpstat_what_main_action current_action = BPSTAT_WHAT_KEEP_CHECKING;
3137 struct bpstat_what retval;
3139 retval.call_dummy = 0;
3140 for (; bs != NULL; bs = bs->next)
3142 enum class bs_class = no_effect;
3143 if (bs->breakpoint_at == NULL)
3144 /* I suspect this can happen if it was a momentary breakpoint
3145 which has since been deleted. */
3147 switch (bs->breakpoint_at->type)
3153 case bp_hardware_breakpoint:
3159 bs_class = bp_noisy;
3161 bs_class = bp_silent;
3164 bs_class = bp_nostop;
3167 case bp_hardware_watchpoint:
3168 case bp_read_watchpoint:
3169 case bp_access_watchpoint:
3173 bs_class = wp_noisy;
3175 bs_class = wp_silent;
3178 /* There was a watchpoint, but we're not stopping.
3179 This requires no further action. */
3180 bs_class = no_effect;
3183 bs_class = long_jump;
3185 case bp_longjmp_resume:
3186 bs_class = long_resume;
3188 case bp_step_resume:
3191 bs_class = step_resume;
3194 /* It is for the wrong frame. */
3195 bs_class = bp_nostop;
3197 case bp_through_sigtramp:
3198 bs_class = through_sig;
3200 case bp_watchpoint_scope:
3201 bs_class = bp_nostop;
3203 case bp_shlib_event:
3204 bs_class = shlib_event;
3206 case bp_thread_event:
3207 case bp_overlay_event:
3208 bs_class = bp_nostop;
3211 case bp_catch_unload:
3212 /* Only if this catchpoint triggered should we cause the
3213 step-out-of-dld behaviour. Otherwise, we ignore this
3216 bs_class = catch_shlib_event;
3218 bs_class = no_effect;
3221 case bp_catch_vfork:
3226 bs_class = bp_noisy;
3228 bs_class = bp_silent;
3231 /* There was a catchpoint, but we're not stopping.
3232 This requires no further action. */
3233 bs_class = no_effect;
3235 case bp_catch_catch:
3236 if (!bs->stop || CURRENT_EXCEPTION_KIND != EX_EVENT_CATCH)
3237 bs_class = bp_nostop;
3239 bs_class = bs->print ? bp_noisy : bp_silent;
3241 case bp_catch_throw:
3242 if (!bs->stop || CURRENT_EXCEPTION_KIND != EX_EVENT_THROW)
3243 bs_class = bp_nostop;
3245 bs_class = bs->print ? bp_noisy : bp_silent;
3248 /* Make sure the action is stop (silent or noisy),
3249 so infrun.c pops the dummy frame. */
3250 bs_class = bp_silent;
3251 retval.call_dummy = 1;
3254 current_action = table[(int) bs_class][(int) current_action];
3256 retval.main_action = current_action;
3260 /* Nonzero if we should step constantly (e.g. watchpoints on machines
3261 without hardware support). This isn't related to a specific bpstat,
3262 just to things like whether watchpoints are set. */
3265 bpstat_should_step (void)
3267 struct breakpoint *b;
3269 if (breakpoint_enabled (b) && b->type == bp_watchpoint)
3274 /* Nonzero if there are enabled hardware watchpoints. */
3276 bpstat_have_active_hw_watchpoints (void)
3278 struct bp_location *bpt;
3279 ALL_BP_LOCATIONS (bpt)
3280 if (breakpoint_enabled (bpt->owner)
3282 && bpt->loc_type == bp_loc_hardware_watchpoint)
3288 /* Given a bpstat that records zero or more triggered eventpoints, this
3289 function returns another bpstat which contains only the catchpoints
3290 on that first list, if any. */
3292 bpstat_get_triggered_catchpoints (bpstat ep_list, bpstat *cp_list)
3294 struct bpstats root_bs[1];
3295 bpstat bs = root_bs;
3296 struct breakpoint *ep;
3299 bpstat_clear (cp_list);
3300 root_bs->next = NULL;
3302 for (; ep_list != NULL; ep_list = ep_list->next)
3304 /* Is this eventpoint a catchpoint? If not, ignore it. */
3305 ep = ep_list->breakpoint_at;
3308 if ((ep->type != bp_catch_load) &&
3309 (ep->type != bp_catch_unload) &&
3310 (ep->type != bp_catch_catch) &&
3311 (ep->type != bp_catch_throw))
3312 /* pai: (temp) ADD fork/vfork here!! */
3315 /* Yes; add it to the list. */
3316 bs = bpstat_alloc (ep, bs);
3321 #if defined(SOLIB_ADD)
3322 /* Also, for each triggered catchpoint, tag it with the name of
3323 the library that caused this trigger. (We copy the name now,
3324 because it's only guaranteed to be available NOW, when the
3325 catchpoint triggers. Clients who may wish to know the name
3326 later must get it from the catchpoint itself.) */
3327 if (ep->triggered_dll_pathname != NULL)
3328 xfree (ep->triggered_dll_pathname);
3329 if (ep->type == bp_catch_load)
3330 dll_pathname = SOLIB_LOADED_LIBRARY_PATHNAME (
3331 PIDGET (inferior_ptid));
3333 dll_pathname = SOLIB_UNLOADED_LIBRARY_PATHNAME (
3334 PIDGET (inferior_ptid));
3336 dll_pathname = NULL;
3340 ep->triggered_dll_pathname = (char *)
3341 xmalloc (strlen (dll_pathname) + 1);
3342 strcpy (ep->triggered_dll_pathname, dll_pathname);
3345 ep->triggered_dll_pathname = NULL;
3351 /* Print B to gdb_stdout. */
3353 print_one_breakpoint (struct breakpoint *b,
3354 CORE_ADDR *last_addr)
3356 struct command_line *l;
3358 struct ep_type_description
3363 static struct ep_type_description bptypes[] =
3365 {bp_none, "?deleted?"},
3366 {bp_breakpoint, "breakpoint"},
3367 {bp_hardware_breakpoint, "hw breakpoint"},
3368 {bp_until, "until"},
3369 {bp_finish, "finish"},
3370 {bp_watchpoint, "watchpoint"},
3371 {bp_hardware_watchpoint, "hw watchpoint"},
3372 {bp_read_watchpoint, "read watchpoint"},
3373 {bp_access_watchpoint, "acc watchpoint"},
3374 {bp_longjmp, "longjmp"},
3375 {bp_longjmp_resume, "longjmp resume"},
3376 {bp_step_resume, "step resume"},
3377 {bp_through_sigtramp, "sigtramp"},
3378 {bp_watchpoint_scope, "watchpoint scope"},
3379 {bp_call_dummy, "call dummy"},
3380 {bp_shlib_event, "shlib events"},
3381 {bp_thread_event, "thread events"},
3382 {bp_overlay_event, "overlay events"},
3383 {bp_catch_load, "catch load"},
3384 {bp_catch_unload, "catch unload"},
3385 {bp_catch_fork, "catch fork"},
3386 {bp_catch_vfork, "catch vfork"},
3387 {bp_catch_exec, "catch exec"},
3388 {bp_catch_catch, "catch catch"},
3389 {bp_catch_throw, "catch throw"}
3392 static char *bpdisps[] =
3393 {"del", "dstp", "dis", "keep"};
3394 static char bpenables[] = "nynny";
3395 char wrap_indent[80];
3396 struct ui_stream *stb = ui_out_stream_new (uiout);
3397 struct cleanup *old_chain = make_cleanup_ui_out_stream_delete (stb);
3398 struct cleanup *bkpt_chain;
3401 bkpt_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "bkpt");
3405 ui_out_field_int (uiout, "number", b->number);
3409 if (((int) b->type > (sizeof (bptypes) / sizeof (bptypes[0])))
3410 || ((int) b->type != bptypes[(int) b->type].type))
3411 internal_error (__FILE__, __LINE__,
3412 _("bptypes table does not describe type #%d."),
3414 ui_out_field_string (uiout, "type", bptypes[(int) b->type].description);
3418 ui_out_field_string (uiout, "disp", bpdisps[(int) b->disposition]);
3422 ui_out_field_fmt (uiout, "enabled", "%c", bpenables[(int) b->enable_state]);
3423 ui_out_spaces (uiout, 2);
3426 strcpy (wrap_indent, " ");
3429 if (TARGET_ADDR_BIT <= 32)
3430 strcat (wrap_indent, " ");
3432 strcat (wrap_indent, " ");
3435 if (b->ops != NULL && b->ops->print_one != NULL)
3436 b->ops->print_one (b, last_addr);
3441 internal_error (__FILE__, __LINE__,
3442 _("print_one_breakpoint: bp_none encountered\n"));
3446 case bp_hardware_watchpoint:
3447 case bp_read_watchpoint:
3448 case bp_access_watchpoint:
3449 /* Field 4, the address, is omitted (which makes the columns
3450 not line up too nicely with the headers, but the effect
3451 is relatively readable). */
3453 ui_out_field_skip (uiout, "addr");
3455 print_expression (b->exp, stb->stream);
3456 ui_out_field_stream (uiout, "what", stb);
3460 case bp_catch_unload:
3461 /* Field 4, the address, is omitted (which makes the columns
3462 not line up too nicely with the headers, but the effect
3463 is relatively readable). */
3465 ui_out_field_skip (uiout, "addr");
3467 if (b->dll_pathname == NULL)
3469 ui_out_field_string (uiout, "what", "<any library>");
3470 ui_out_spaces (uiout, 1);
3474 ui_out_text (uiout, "library \"");
3475 ui_out_field_string (uiout, "what", b->dll_pathname);
3476 ui_out_text (uiout, "\" ");
3481 case bp_catch_vfork:
3482 /* Field 4, the address, is omitted (which makes the columns
3483 not line up too nicely with the headers, but the effect
3484 is relatively readable). */
3486 ui_out_field_skip (uiout, "addr");
3488 if (b->forked_inferior_pid != 0)
3490 ui_out_text (uiout, "process ");
3491 ui_out_field_int (uiout, "what", b->forked_inferior_pid);
3492 ui_out_spaces (uiout, 1);
3497 /* Field 4, the address, is omitted (which makes the columns
3498 not line up too nicely with the headers, but the effect
3499 is relatively readable). */
3501 ui_out_field_skip (uiout, "addr");
3503 if (b->exec_pathname != NULL)
3505 ui_out_text (uiout, "program \"");
3506 ui_out_field_string (uiout, "what", b->exec_pathname);
3507 ui_out_text (uiout, "\" ");
3511 case bp_catch_catch:
3512 /* Field 4, the address, is omitted (which makes the columns
3513 not line up too nicely with the headers, but the effect
3514 is relatively readable). */
3516 ui_out_field_skip (uiout, "addr");
3518 ui_out_field_string (uiout, "what", "exception catch");
3519 ui_out_spaces (uiout, 1);
3522 case bp_catch_throw:
3523 /* Field 4, the address, is omitted (which makes the columns
3524 not line up too nicely with the headers, but the effect
3525 is relatively readable). */
3527 ui_out_field_skip (uiout, "addr");
3529 ui_out_field_string (uiout, "what", "exception throw");
3530 ui_out_spaces (uiout, 1);
3534 case bp_hardware_breakpoint:
3538 case bp_longjmp_resume:
3539 case bp_step_resume:
3540 case bp_through_sigtramp:
3541 case bp_watchpoint_scope:
3543 case bp_shlib_event:
3544 case bp_thread_event:
3545 case bp_overlay_event:
3550 ui_out_field_string (uiout, "addr", "<PENDING>");
3552 ui_out_field_core_addr (uiout, "addr", b->loc->address);
3555 *last_addr = b->loc->address;
3558 sym = find_pc_sect_function (b->loc->address, b->loc->section);
3561 ui_out_text (uiout, "in ");
3562 ui_out_field_string (uiout, "func",
3563 SYMBOL_PRINT_NAME (sym));
3564 ui_out_wrap_hint (uiout, wrap_indent);
3565 ui_out_text (uiout, " at ");
3567 ui_out_field_string (uiout, "file", b->source_file);
3568 ui_out_text (uiout, ":");
3570 if (ui_out_is_mi_like_p (uiout))
3572 struct symtab_and_line sal = find_pc_line (b->loc->address, 0);
3573 char *fullname = symtab_to_fullname (sal.symtab);
3576 ui_out_field_string (uiout, "fullname", fullname);
3579 ui_out_field_int (uiout, "line", b->line_number);
3581 else if (b->pending)
3583 ui_out_field_string (uiout, "pending", b->addr_string);
3587 print_address_symbolic (b->loc->address, stb->stream, demangle, "");
3588 ui_out_field_stream (uiout, "at", stb);
3593 if (b->thread != -1)
3595 /* FIXME: This seems to be redundant and lost here; see the
3596 "stop only in" line a little further down. */
3597 ui_out_text (uiout, " thread ");
3598 ui_out_field_int (uiout, "thread", b->thread);
3601 ui_out_text (uiout, "\n");
3603 if (frame_id_p (b->frame_id))
3606 ui_out_text (uiout, "\tstop only in stack frame at ");
3607 /* FIXME: cagney/2002-12-01: Shouldn't be poeking around inside
3609 ui_out_field_core_addr (uiout, "frame", b->frame_id.stack_addr);
3610 ui_out_text (uiout, "\n");
3613 if (b->cond && !ada_exception_catchpoint_p (b))
3615 /* We do not print the condition for Ada exception catchpoints
3616 because the condition is an internal implementation detail
3617 that we do not want to expose to the user. */
3619 ui_out_text (uiout, "\tstop only if ");
3620 print_expression (b->cond, stb->stream);
3621 ui_out_field_stream (uiout, "cond", stb);
3622 ui_out_text (uiout, "\n");
3625 if (b->pending && b->cond_string)
3628 ui_out_text (uiout, "\tstop only if ");
3629 ui_out_field_string (uiout, "cond", b->cond_string);
3630 ui_out_text (uiout, "\n");
3633 if (b->thread != -1)
3635 /* FIXME should make an annotation for this */
3636 ui_out_text (uiout, "\tstop only in thread ");
3637 ui_out_field_int (uiout, "thread", b->thread);
3638 ui_out_text (uiout, "\n");
3641 if (show_breakpoint_hit_counts && b->hit_count)
3643 /* FIXME should make an annotation for this */
3644 if (ep_is_catchpoint (b))
3645 ui_out_text (uiout, "\tcatchpoint");
3647 ui_out_text (uiout, "\tbreakpoint");
3648 ui_out_text (uiout, " already hit ");
3649 ui_out_field_int (uiout, "times", b->hit_count);
3650 if (b->hit_count == 1)
3651 ui_out_text (uiout, " time\n");
3653 ui_out_text (uiout, " times\n");
3656 /* Output the count also if it is zero, but only if this is
3657 mi. FIXME: Should have a better test for this. */
3658 if (ui_out_is_mi_like_p (uiout))
3659 if (show_breakpoint_hit_counts && b->hit_count == 0)
3660 ui_out_field_int (uiout, "times", b->hit_count);
3662 if (b->ignore_count)
3665 ui_out_text (uiout, "\tignore next ");
3666 ui_out_field_int (uiout, "ignore", b->ignore_count);
3667 ui_out_text (uiout, " hits\n");
3670 if ((l = b->commands))
3672 struct cleanup *script_chain;
3675 script_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "script");
3676 print_command_lines (uiout, l, 4);
3677 do_cleanups (script_chain);
3679 do_cleanups (bkpt_chain);
3680 do_cleanups (old_chain);
3683 struct captured_breakpoint_query_args
3689 do_captured_breakpoint_query (struct ui_out *uiout, void *data)
3691 struct captured_breakpoint_query_args *args = data;
3692 struct breakpoint *b;
3693 CORE_ADDR dummy_addr = 0;
3696 if (args->bnum == b->number)
3698 print_one_breakpoint (b, &dummy_addr);
3706 gdb_breakpoint_query (struct ui_out *uiout, int bnum, char **error_message)
3708 struct captured_breakpoint_query_args args;
3710 /* For the moment we don't trust print_one_breakpoint() to not throw
3712 return catch_exceptions_with_msg (uiout, do_captured_breakpoint_query, &args,
3713 error_message, RETURN_MASK_ALL);
3716 /* Return non-zero if B is user settable (breakpoints, watchpoints,
3717 catchpoints, et.al.). */
3720 user_settable_breakpoint (const struct breakpoint *b)
3722 return (b->type == bp_breakpoint
3723 || b->type == bp_catch_load
3724 || b->type == bp_catch_unload
3725 || b->type == bp_catch_fork
3726 || b->type == bp_catch_vfork
3727 || b->type == bp_catch_exec
3728 || b->type == bp_catch_catch
3729 || b->type == bp_catch_throw
3730 || b->type == bp_hardware_breakpoint
3731 || b->type == bp_watchpoint
3732 || b->type == bp_read_watchpoint
3733 || b->type == bp_access_watchpoint
3734 || b->type == bp_hardware_watchpoint);
3737 /* Print information on user settable breakpoint (watchpoint, etc)
3738 number BNUM. If BNUM is -1 print all user settable breakpoints.
3739 If ALLFLAG is non-zero, include non- user settable breakpoints. */
3742 breakpoint_1 (int bnum, int allflag)
3744 struct breakpoint *b;
3745 CORE_ADDR last_addr = (CORE_ADDR) -1;
3746 int nr_printable_breakpoints;
3747 struct cleanup *bkpttbl_chain;
3749 /* Compute the number of rows in the table. */
3750 nr_printable_breakpoints = 0;
3753 || bnum == b->number)
3755 if (allflag || user_settable_breakpoint (b))
3756 nr_printable_breakpoints++;
3761 = make_cleanup_ui_out_table_begin_end (uiout, 6, nr_printable_breakpoints,
3765 = make_cleanup_ui_out_table_begin_end (uiout, 5, nr_printable_breakpoints,
3768 if (nr_printable_breakpoints > 0)
3769 annotate_breakpoints_headers ();
3770 if (nr_printable_breakpoints > 0)
3772 ui_out_table_header (uiout, 3, ui_left, "number", "Num"); /* 1 */
3773 if (nr_printable_breakpoints > 0)
3775 ui_out_table_header (uiout, 14, ui_left, "type", "Type"); /* 2 */
3776 if (nr_printable_breakpoints > 0)
3778 ui_out_table_header (uiout, 4, ui_left, "disp", "Disp"); /* 3 */
3779 if (nr_printable_breakpoints > 0)
3781 ui_out_table_header (uiout, 3, ui_left, "enabled", "Enb"); /* 4 */
3784 if (nr_printable_breakpoints > 0)
3786 if (TARGET_ADDR_BIT <= 32)
3787 ui_out_table_header (uiout, 10, ui_left, "addr", "Address");/* 5 */
3789 ui_out_table_header (uiout, 18, ui_left, "addr", "Address");/* 5 */
3791 if (nr_printable_breakpoints > 0)
3793 ui_out_table_header (uiout, 40, ui_noalign, "what", "What"); /* 6 */
3794 ui_out_table_body (uiout);
3795 if (nr_printable_breakpoints > 0)
3796 annotate_breakpoints_table ();
3800 || bnum == b->number)
3802 /* We only print out user settable breakpoints unless the
3804 if (allflag || user_settable_breakpoint (b))
3805 print_one_breakpoint (b, &last_addr);
3808 do_cleanups (bkpttbl_chain);
3810 if (nr_printable_breakpoints == 0)
3813 ui_out_message (uiout, 0, "No breakpoints or watchpoints.\n");
3815 ui_out_message (uiout, 0, "No breakpoint or watchpoint number %d.\n",
3820 /* Compare against (CORE_ADDR)-1 in case some compiler decides
3821 that a comparison of an unsigned with -1 is always false. */
3822 if (last_addr != (CORE_ADDR) -1)
3823 set_next_address (last_addr);
3826 /* FIXME? Should this be moved up so that it is only called when
3827 there have been breakpoints? */
3828 annotate_breakpoints_table_end ();
3832 breakpoints_info (char *bnum_exp, int from_tty)
3837 bnum = parse_and_eval_long (bnum_exp);
3839 breakpoint_1 (bnum, 0);
3843 maintenance_info_breakpoints (char *bnum_exp, int from_tty)
3848 bnum = parse_and_eval_long (bnum_exp);
3850 breakpoint_1 (bnum, 1);
3853 /* Print a message describing any breakpoints set at PC. */
3856 describe_other_breakpoints (CORE_ADDR pc, asection *section, int thread)
3859 struct breakpoint *b;
3862 if (b->loc->address == pc) /* address match / overlay match */
3863 if (!b->pending && (!overlay_debugging || b->loc->section == section))
3868 printf_filtered (_("Note: breakpoint "));
3869 else /* if (others == ???) */
3870 printf_filtered (_("Note: breakpoints "));
3872 if (b->loc->address == pc) /* address match / overlay match */
3873 if (!b->pending && (!overlay_debugging || b->loc->section == section))
3876 printf_filtered ("%d", b->number);
3877 if (b->thread == -1 && thread != -1)
3878 printf_filtered (" (all threads)");
3879 else if (b->thread != -1)
3880 printf_filtered (" (thread %d)", b->thread);
3881 printf_filtered ("%s%s ",
3882 ((b->enable_state == bp_disabled ||
3883 b->enable_state == bp_shlib_disabled ||
3884 b->enable_state == bp_call_disabled)
3886 : b->enable_state == bp_permanent
3890 : ((others == 1) ? " and" : ""));
3892 printf_filtered (_("also set at pc "));
3893 deprecated_print_address_numeric (pc, 1, gdb_stdout);
3894 printf_filtered (".\n");
3898 /* Set the default place to put a breakpoint
3899 for the `break' command with no arguments. */
3902 set_default_breakpoint (int valid, CORE_ADDR addr, struct symtab *symtab,
3905 default_breakpoint_valid = valid;
3906 default_breakpoint_address = addr;
3907 default_breakpoint_symtab = symtab;
3908 default_breakpoint_line = line;
3911 /* Return true iff it is meaningful to use the address member of
3912 BPT. For some breakpoint types, the address member is irrelevant
3913 and it makes no sense to attempt to compare it to other addresses
3914 (or use it for any other purpose either).
3916 More specifically, each of the following breakpoint types will always
3917 have a zero valued address and we don't want check_duplicates() to mark
3918 breakpoints of any of these types to be a duplicate of an actual
3919 breakpoint at address zero:
3922 bp_hardware_watchpoint
3924 bp_access_watchpoint
3931 breakpoint_address_is_meaningful (struct breakpoint *bpt)
3933 enum bptype type = bpt->type;
3935 return (type != bp_watchpoint
3936 && type != bp_hardware_watchpoint
3937 && type != bp_read_watchpoint
3938 && type != bp_access_watchpoint
3939 && type != bp_catch_exec
3940 && type != bp_longjmp_resume
3941 && type != bp_catch_fork
3942 && type != bp_catch_vfork);
3945 /* Rescan breakpoints at the same address and section as BPT,
3946 marking the first one as "first" and any others as "duplicates".
3947 This is so that the bpt instruction is only inserted once.
3948 If we have a permanent breakpoint at the same place as BPT, make
3949 that one the official one, and the rest as duplicates. */
3952 check_duplicates (struct breakpoint *bpt)
3954 struct bp_location *b;
3956 struct bp_location *perm_bp = 0;
3957 CORE_ADDR address = bpt->loc->address;
3958 asection *section = bpt->loc->section;
3960 if (! breakpoint_address_is_meaningful (bpt))
3963 ALL_BP_LOCATIONS (b)
3964 if (b->owner->enable_state != bp_disabled
3965 && b->owner->enable_state != bp_shlib_disabled
3966 && !b->owner->pending
3967 && b->owner->enable_state != bp_call_disabled
3968 && b->address == address /* address / overlay match */
3969 && (!overlay_debugging || b->section == section)
3970 && breakpoint_address_is_meaningful (b->owner))
3972 /* Have we found a permanent breakpoint? */
3973 if (b->owner->enable_state == bp_permanent)
3980 b->duplicate = count > 1;
3983 /* If we found a permanent breakpoint at this address, go over the
3984 list again and declare all the other breakpoints there to be the
3988 perm_bp->duplicate = 0;
3990 /* Permanent breakpoint should always be inserted. */
3991 if (! perm_bp->inserted)
3992 internal_error (__FILE__, __LINE__,
3993 _("allegedly permanent breakpoint is not "
3994 "actually inserted"));
3996 ALL_BP_LOCATIONS (b)
3999 if (b->owner->enable_state != bp_disabled
4000 && b->owner->enable_state != bp_shlib_disabled
4001 && !b->owner->pending
4002 && b->owner->enable_state != bp_call_disabled
4003 && b->address == address /* address / overlay match */
4004 && (!overlay_debugging || b->section == section)
4005 && breakpoint_address_is_meaningful (b->owner))
4008 internal_error (__FILE__, __LINE__,
4009 _("another breakpoint was inserted on top of "
4010 "a permanent breakpoint"));
4019 breakpoint_adjustment_warning (CORE_ADDR from_addr, CORE_ADDR to_addr,
4020 int bnum, int have_bnum)
4025 strcpy (astr1, hex_string_custom ((unsigned long) from_addr, 8));
4026 strcpy (astr2, hex_string_custom ((unsigned long) to_addr, 8));
4028 warning (_("Breakpoint %d address previously adjusted from %s to %s."),
4029 bnum, astr1, astr2);
4031 warning (_("Breakpoint address adjusted from %s to %s."), astr1, astr2);
4034 /* Adjust a breakpoint's address to account for architectural constraints
4035 on breakpoint placement. Return the adjusted address. Note: Very
4036 few targets require this kind of adjustment. For most targets,
4037 this function is simply the identity function. */
4040 adjust_breakpoint_address (CORE_ADDR bpaddr, enum bptype bptype)
4042 if (!gdbarch_adjust_breakpoint_address_p (current_gdbarch))
4044 /* Very few targets need any kind of breakpoint adjustment. */
4047 else if (bptype == bp_watchpoint
4048 || bptype == bp_hardware_watchpoint
4049 || bptype == bp_read_watchpoint
4050 || bptype == bp_access_watchpoint
4051 || bptype == bp_catch_fork
4052 || bptype == bp_catch_vfork
4053 || bptype == bp_catch_exec)
4055 /* Watchpoints and the various bp_catch_* eventpoints should not
4056 have their addresses modified. */
4061 CORE_ADDR adjusted_bpaddr;
4063 /* Some targets have architectural constraints on the placement
4064 of breakpoint instructions. Obtain the adjusted address. */
4065 adjusted_bpaddr = gdbarch_adjust_breakpoint_address (current_gdbarch,
4068 /* An adjusted breakpoint address can significantly alter
4069 a user's expectations. Print a warning if an adjustment
4071 if (adjusted_bpaddr != bpaddr)
4072 breakpoint_adjustment_warning (bpaddr, adjusted_bpaddr, 0, 0);
4074 return adjusted_bpaddr;
4078 /* Allocate a struct bp_location. */
4080 static struct bp_location *
4081 allocate_bp_location (struct breakpoint *bpt, enum bptype bp_type)
4083 struct bp_location *loc, *loc_p;
4085 loc = xmalloc (sizeof (struct bp_location));
4086 memset (loc, 0, sizeof (*loc));
4096 case bp_longjmp_resume:
4097 case bp_step_resume:
4098 case bp_through_sigtramp:
4099 case bp_watchpoint_scope:
4101 case bp_shlib_event:
4102 case bp_thread_event:
4103 case bp_overlay_event:
4105 case bp_catch_unload:
4106 loc->loc_type = bp_loc_software_breakpoint;
4108 case bp_hardware_breakpoint:
4109 loc->loc_type = bp_loc_hardware_breakpoint;
4111 case bp_hardware_watchpoint:
4112 case bp_read_watchpoint:
4113 case bp_access_watchpoint:
4114 loc->loc_type = bp_loc_hardware_watchpoint;
4118 case bp_catch_vfork:
4120 case bp_catch_catch:
4121 case bp_catch_throw:
4122 loc->loc_type = bp_loc_other;
4125 internal_error (__FILE__, __LINE__, _("unknown breakpoint type"));
4128 /* Add this breakpoint to the end of the chain. */
4130 loc_p = bp_location_chain;
4132 bp_location_chain = loc;
4136 loc_p = loc_p->next;
4143 /* set_raw_breakpoint() is a low level routine for allocating and
4144 partially initializing a breakpoint of type BPTYPE. The newly
4145 created breakpoint's address, section, source file name, and line
4146 number are provided by SAL. The newly created and partially
4147 initialized breakpoint is added to the breakpoint chain and
4148 is also returned as the value of this function.
4150 It is expected that the caller will complete the initialization of
4151 the newly created breakpoint struct as well as output any status
4152 information regarding the creation of a new breakpoint. In
4153 particular, set_raw_breakpoint() does NOT set the breakpoint
4154 number! Care should be taken to not allow an error() to occur
4155 prior to completing the initialization of the breakpoint. If this
4156 should happen, a bogus breakpoint will be left on the chain. */
4159 set_raw_breakpoint (struct symtab_and_line sal, enum bptype bptype)
4161 struct breakpoint *b, *b1;
4163 b = (struct breakpoint *) xmalloc (sizeof (struct breakpoint));
4164 memset (b, 0, sizeof (*b));
4165 b->loc = allocate_bp_location (b, bptype);
4166 b->loc->requested_address = sal.pc;
4167 b->loc->address = adjust_breakpoint_address (b->loc->requested_address,
4169 if (sal.symtab == NULL)
4170 b->source_file = NULL;
4172 b->source_file = savestring (sal.symtab->filename,
4173 strlen (sal.symtab->filename));
4174 b->loc->section = sal.section;
4176 b->language = current_language->la_language;
4177 b->input_radix = input_radix;
4179 b->line_number = sal.line;
4180 b->enable_state = bp_enabled;
4183 b->ignore_count = 0;
4185 b->frame_id = null_frame_id;
4186 b->dll_pathname = NULL;
4187 b->triggered_dll_pathname = NULL;
4188 b->forked_inferior_pid = 0;
4189 b->exec_pathname = NULL;
4193 /* Add this breakpoint to the end of the chain
4194 so that a list of breakpoints will come out in order
4195 of increasing numbers. */
4197 b1 = breakpoint_chain;
4199 breakpoint_chain = b;
4207 check_duplicates (b);
4208 breakpoints_changed ();
4214 /* Note that the breakpoint object B describes a permanent breakpoint
4215 instruction, hard-wired into the inferior's code. */
4217 make_breakpoint_permanent (struct breakpoint *b)
4219 b->enable_state = bp_permanent;
4221 /* By definition, permanent breakpoints are already present in the code. */
4222 b->loc->inserted = 1;
4225 static struct breakpoint *
4226 create_internal_breakpoint (CORE_ADDR address, enum bptype type)
4228 static int internal_breakpoint_number = -1;
4229 struct symtab_and_line sal;
4230 struct breakpoint *b;
4232 init_sal (&sal); /* initialize to zeroes */
4235 sal.section = find_pc_overlay (sal.pc);
4237 b = set_raw_breakpoint (sal, type);
4238 b->number = internal_breakpoint_number--;
4239 b->disposition = disp_donttouch;
4246 create_longjmp_breakpoint (char *func_name)
4248 struct breakpoint *b;
4249 struct minimal_symbol *m;
4251 if (func_name == NULL)
4252 b = create_internal_breakpoint (0, bp_longjmp_resume);
4255 if ((m = lookup_minimal_symbol_text (func_name, NULL)) == NULL)
4258 b = create_internal_breakpoint (SYMBOL_VALUE_ADDRESS (m), bp_longjmp);
4261 b->enable_state = bp_disabled;
4264 b->addr_string = xstrdup (func_name);
4267 /* Call this routine when stepping and nexting to enable a breakpoint
4268 if we do a longjmp(). When we hit that breakpoint, call
4269 set_longjmp_resume_breakpoint() to figure out where we are going. */
4272 enable_longjmp_breakpoint (void)
4274 struct breakpoint *b;
4277 if (b->type == bp_longjmp)
4279 b->enable_state = bp_enabled;
4280 check_duplicates (b);
4285 disable_longjmp_breakpoint (void)
4287 struct breakpoint *b;
4290 if (b->type == bp_longjmp
4291 || b->type == bp_longjmp_resume)
4293 b->enable_state = bp_disabled;
4294 check_duplicates (b);
4299 create_overlay_event_breakpoint (char *func_name)
4301 struct breakpoint *b;
4302 struct minimal_symbol *m;
4304 if ((m = lookup_minimal_symbol_text (func_name, NULL)) == NULL)
4307 b = create_internal_breakpoint (SYMBOL_VALUE_ADDRESS (m),
4309 b->addr_string = xstrdup (func_name);
4311 if (overlay_debugging == ovly_auto)
4313 b->enable_state = bp_enabled;
4314 overlay_events_enabled = 1;
4318 b->enable_state = bp_disabled;
4319 overlay_events_enabled = 0;
4324 enable_overlay_breakpoints (void)
4326 struct breakpoint *b;
4329 if (b->type == bp_overlay_event)
4331 b->enable_state = bp_enabled;
4332 check_duplicates (b);
4333 overlay_events_enabled = 1;
4338 disable_overlay_breakpoints (void)
4340 struct breakpoint *b;
4343 if (b->type == bp_overlay_event)
4345 b->enable_state = bp_disabled;
4346 check_duplicates (b);
4347 overlay_events_enabled = 0;
4352 create_thread_event_breakpoint (CORE_ADDR address)
4354 struct breakpoint *b;
4356 b = create_internal_breakpoint (address, bp_thread_event);
4358 b->enable_state = bp_enabled;
4359 /* addr_string has to be used or breakpoint_re_set will delete me. */
4360 b->addr_string = xstrprintf ("*0x%s", paddr (b->loc->address));
4366 remove_thread_event_breakpoints (void)
4368 struct breakpoint *b, *temp;
4370 ALL_BREAKPOINTS_SAFE (b, temp)
4371 if (b->type == bp_thread_event)
4372 delete_breakpoint (b);
4375 struct captured_parse_breakpoint_args
4378 struct symtabs_and_lines *sals_p;
4379 char ***addr_string_p;
4383 struct lang_and_radix
4389 /* Cleanup helper routine to restore the current language and
4392 do_restore_lang_radix_cleanup (void *old)
4394 struct lang_and_radix *p = old;
4395 set_language (p->lang);
4396 input_radix = p->radix;
4399 /* Try and resolve a pending breakpoint. */
4401 resolve_pending_breakpoint (struct breakpoint *b)
4403 /* Try and reparse the breakpoint in case the shared library
4405 struct symtabs_and_lines sals;
4406 struct symtab_and_line pending_sal;
4407 char **cond_string = (char **) NULL;
4408 char *copy_arg = b->addr_string;
4413 struct ui_file *old_gdb_stderr;
4414 struct lang_and_radix old_lr;
4415 struct cleanup *old_chain;
4417 /* Set language, input-radix, then reissue breakpoint command.
4418 Ensure the language and input-radix are restored afterwards. */
4419 old_lr.lang = current_language->la_language;
4420 old_lr.radix = input_radix;
4421 old_chain = make_cleanup (do_restore_lang_radix_cleanup, &old_lr);
4423 set_language (b->language);
4424 input_radix = b->input_radix;
4425 rc = break_command_1 (b->addr_string, b->flag, b->from_tty, b);
4427 if (rc == GDB_RC_OK)
4428 /* Pending breakpoint has been resolved. */
4429 printf_filtered (_("Pending breakpoint \"%s\" resolved\n"), b->addr_string);
4431 do_cleanups (old_chain);
4436 remove_solib_event_breakpoints (void)
4438 struct breakpoint *b, *temp;
4440 ALL_BREAKPOINTS_SAFE (b, temp)
4441 if (b->type == bp_shlib_event)
4442 delete_breakpoint (b);
4446 create_solib_event_breakpoint (CORE_ADDR address)
4448 struct breakpoint *b;
4450 b = create_internal_breakpoint (address, bp_shlib_event);
4454 /* Disable any breakpoints that are on code in shared libraries. Only
4455 apply to enabled breakpoints, disabled ones can just stay disabled. */
4458 disable_breakpoints_in_shlibs (int silent)
4460 struct breakpoint *b;
4461 int disabled_shlib_breaks = 0;
4463 /* See also: insert_breakpoints, under DISABLE_UNSETTABLE_BREAK. */
4466 if (((b->type == bp_breakpoint) || (b->type == bp_hardware_breakpoint))
4467 && breakpoint_enabled (b) && !b->loc->duplicate
4469 && PC_SOLIB (b->loc->address)
4471 && solib_address (b->loc->address)
4475 b->enable_state = bp_shlib_disabled;
4478 if (!disabled_shlib_breaks)
4480 target_terminal_ours_for_output ();
4481 warning (_("Temporarily disabling shared library breakpoints:"));
4483 disabled_shlib_breaks = 1;
4484 warning (_("breakpoint #%d "), b->number);
4490 /* Disable any breakpoints that are in in an unloaded shared library. Only
4491 apply to enabled breakpoints, disabled ones can just stay disabled. */
4494 disable_breakpoints_in_unloaded_shlib (struct so_list *solib)
4496 struct breakpoint *b;
4497 int disabled_shlib_breaks = 0;
4499 /* See also: insert_breakpoints, under DISABLE_UNSETTABLE_BREAK. */
4502 if ((b->loc->loc_type == bp_loc_hardware_breakpoint
4503 || b->loc->loc_type == bp_loc_software_breakpoint)
4504 && breakpoint_enabled (b) && !b->loc->duplicate)
4507 char *so_name = PC_SOLIB (b->loc->address);
4509 char *so_name = solib_address (b->loc->address);
4511 if (so_name && !strcmp (so_name, solib->so_name))
4513 b->enable_state = bp_shlib_disabled;
4514 /* At this point, we cannot rely on remove_breakpoint
4515 succeeding so we must mark the breakpoint as not inserted
4516 to prevent future errors occurring in remove_breakpoints. */
4517 b->loc->inserted = 0;
4518 if (!disabled_shlib_breaks)
4520 target_terminal_ours_for_output ();
4521 warning (_("Temporarily disabling breakpoints for unloaded shared library \"%s\""),
4524 disabled_shlib_breaks = 1;
4530 /* Try to reenable any breakpoints in shared libraries. */
4532 re_enable_breakpoints_in_shlibs (void)
4534 struct breakpoint *b, *tmp;
4536 ALL_BREAKPOINTS_SAFE (b, tmp)
4538 if (b->enable_state == bp_shlib_disabled)
4543 /* Do not reenable the breakpoint if the shared library is
4544 still not mapped in. */
4546 lib = PC_SOLIB (b->loc->address);
4548 lib = solib_address (b->loc->address);
4550 if (lib != NULL && target_read_memory (b->loc->address, buf, 1) == 0)
4551 b->enable_state = bp_enabled;
4553 else if (b->pending && (b->enable_state == bp_enabled))
4555 if (resolve_pending_breakpoint (b) == GDB_RC_OK)
4556 delete_breakpoint (b);
4562 solib_load_unload_1 (char *hookname, int tempflag, char *dll_pathname,
4563 char *cond_string, enum bptype bp_kind)
4565 struct breakpoint *b;
4566 struct symtabs_and_lines sals;
4567 struct cleanup *old_chain;
4568 struct cleanup *canonical_strings_chain = NULL;
4569 char *addr_start = hookname;
4570 char *addr_end = NULL;
4571 char **canonical = (char **) NULL;
4572 int thread = -1; /* All threads. */
4574 /* Set a breakpoint on the specified hook. */
4575 sals = decode_line_1 (&hookname, 1, (struct symtab *) NULL,
4576 0, &canonical, NULL);
4577 addr_end = hookname;
4579 if (sals.nelts == 0)
4581 warning (_("Unable to set a breakpoint on dynamic linker callback.\n"
4582 "Suggest linking with /opt/langtools/lib/end.o.\n"
4583 "GDB will be unable to track shl_load/shl_unload calls."));
4586 if (sals.nelts != 1)
4588 warning (_("Unable to set unique breakpoint on dynamic linker callback.\n"
4589 "GDB will be unable to track shl_load/shl_unload calls."));
4593 /* Make sure that all storage allocated in decode_line_1 gets freed
4594 in case the following errors out. */
4595 old_chain = make_cleanup (xfree, sals.sals);
4596 if (canonical != (char **) NULL)
4598 make_cleanup (xfree, canonical);
4599 canonical_strings_chain = make_cleanup (null_cleanup, 0);
4600 if (canonical[0] != NULL)
4601 make_cleanup (xfree, canonical[0]);
4604 resolve_sal_pc (&sals.sals[0]);
4606 /* Remove the canonical strings from the cleanup, they are needed below. */
4607 if (canonical != (char **) NULL)
4608 discard_cleanups (canonical_strings_chain);
4610 b = set_raw_breakpoint (sals.sals[0], bp_kind);
4611 set_breakpoint_count (breakpoint_count + 1);
4612 b->number = breakpoint_count;
4614 b->cond_string = (cond_string == NULL) ?
4615 NULL : savestring (cond_string, strlen (cond_string));
4618 if (canonical != (char **) NULL && canonical[0] != NULL)
4619 b->addr_string = canonical[0];
4620 else if (addr_start)
4621 b->addr_string = savestring (addr_start, addr_end - addr_start);
4623 b->enable_state = bp_enabled;
4624 b->disposition = tempflag ? disp_del : disp_donttouch;
4626 if (dll_pathname == NULL)
4627 b->dll_pathname = NULL;
4630 b->dll_pathname = (char *) xmalloc (strlen (dll_pathname) + 1);
4631 strcpy (b->dll_pathname, dll_pathname);
4635 do_cleanups (old_chain);
4639 create_solib_load_event_breakpoint (char *hookname, int tempflag,
4640 char *dll_pathname, char *cond_string)
4642 solib_load_unload_1 (hookname, tempflag, dll_pathname,
4643 cond_string, bp_catch_load);
4647 create_solib_unload_event_breakpoint (char *hookname, int tempflag,
4648 char *dll_pathname, char *cond_string)
4650 solib_load_unload_1 (hookname, tempflag, dll_pathname,
4651 cond_string, bp_catch_unload);
4655 create_fork_vfork_event_catchpoint (int tempflag, char *cond_string,
4656 enum bptype bp_kind)
4658 struct symtab_and_line sal;
4659 struct breakpoint *b;
4660 int thread = -1; /* All threads. */
4667 b = set_raw_breakpoint (sal, bp_kind);
4668 set_breakpoint_count (breakpoint_count + 1);
4669 b->number = breakpoint_count;
4671 b->cond_string = (cond_string == NULL) ?
4672 NULL : savestring (cond_string, strlen (cond_string));
4674 b->addr_string = NULL;
4675 b->enable_state = bp_enabled;
4676 b->disposition = tempflag ? disp_del : disp_donttouch;
4677 b->forked_inferior_pid = 0;
4683 create_fork_event_catchpoint (int tempflag, char *cond_string)
4685 create_fork_vfork_event_catchpoint (tempflag, cond_string, bp_catch_fork);
4689 create_vfork_event_catchpoint (int tempflag, char *cond_string)
4691 create_fork_vfork_event_catchpoint (tempflag, cond_string, bp_catch_vfork);
4695 create_exec_event_catchpoint (int tempflag, char *cond_string)
4697 struct symtab_and_line sal;
4698 struct breakpoint *b;
4699 int thread = -1; /* All threads. */
4706 b = set_raw_breakpoint (sal, bp_catch_exec);
4707 set_breakpoint_count (breakpoint_count + 1);
4708 b->number = breakpoint_count;
4710 b->cond_string = (cond_string == NULL) ?
4711 NULL : savestring (cond_string, strlen (cond_string));
4713 b->addr_string = NULL;
4714 b->enable_state = bp_enabled;
4715 b->disposition = tempflag ? disp_del : disp_donttouch;
4721 hw_breakpoint_used_count (void)
4723 struct breakpoint *b;
4728 if (b->type == bp_hardware_breakpoint && b->enable_state == bp_enabled)
4736 hw_watchpoint_used_count (enum bptype type, int *other_type_used)
4738 struct breakpoint *b;
4741 *other_type_used = 0;
4744 if (breakpoint_enabled (b))
4746 if (b->type == type)
4748 else if ((b->type == bp_hardware_watchpoint ||
4749 b->type == bp_read_watchpoint ||
4750 b->type == bp_access_watchpoint))
4751 *other_type_used = 1;
4757 /* Call this after hitting the longjmp() breakpoint. Use this to set
4758 a new breakpoint at the target of the jmp_buf.
4760 FIXME - This ought to be done by setting a temporary breakpoint
4761 that gets deleted automatically... */
4764 set_longjmp_resume_breakpoint (CORE_ADDR pc, struct frame_id frame_id)
4766 struct breakpoint *b;
4769 if (b->type == bp_longjmp_resume)
4771 b->loc->requested_address = pc;
4772 b->loc->address = adjust_breakpoint_address (b->loc->requested_address,
4774 b->enable_state = bp_enabled;
4775 b->frame_id = frame_id;
4776 check_duplicates (b);
4782 disable_watchpoints_before_interactive_call_start (void)
4784 struct breakpoint *b;
4788 if (((b->type == bp_watchpoint)
4789 || (b->type == bp_hardware_watchpoint)
4790 || (b->type == bp_read_watchpoint)
4791 || (b->type == bp_access_watchpoint)
4792 || ep_is_exception_catchpoint (b))
4793 && breakpoint_enabled (b))
4795 b->enable_state = bp_call_disabled;
4796 check_duplicates (b);
4802 enable_watchpoints_after_interactive_call_stop (void)
4804 struct breakpoint *b;
4808 if (((b->type == bp_watchpoint)
4809 || (b->type == bp_hardware_watchpoint)
4810 || (b->type == bp_read_watchpoint)
4811 || (b->type == bp_access_watchpoint)
4812 || ep_is_exception_catchpoint (b))
4813 && (b->enable_state == bp_call_disabled))
4815 b->enable_state = bp_enabled;
4816 check_duplicates (b);
4822 /* Set a breakpoint that will evaporate an end of command
4823 at address specified by SAL.
4824 Restrict it to frame FRAME if FRAME is nonzero. */
4827 set_momentary_breakpoint (struct symtab_and_line sal, struct frame_id frame_id,
4830 struct breakpoint *b;
4831 b = set_raw_breakpoint (sal, type);
4832 b->enable_state = bp_enabled;
4833 b->disposition = disp_donttouch;
4834 b->frame_id = frame_id;
4836 /* If we're debugging a multi-threaded program, then we
4837 want momentary breakpoints to be active in only a
4838 single thread of control. */
4839 if (in_thread_list (inferior_ptid))
4840 b->thread = pid_to_thread_id (inferior_ptid);
4846 /* Tell the user we have just set a breakpoint B. */
4849 mention (struct breakpoint *b)
4852 struct cleanup *old_chain, *ui_out_chain;
4853 struct ui_stream *stb;
4855 stb = ui_out_stream_new (uiout);
4856 old_chain = make_cleanup_ui_out_stream_delete (stb);
4858 /* FIXME: This is misplaced; mention() is called by things (like
4859 hitting a watchpoint) other than breakpoint creation. It should
4860 be possible to clean this up and at the same time replace the
4861 random calls to breakpoint_changed with this hook, as has already
4862 been done for deprecated_delete_breakpoint_hook and so on. */
4863 if (deprecated_create_breakpoint_hook)
4864 deprecated_create_breakpoint_hook (b);
4865 breakpoint_create_event (b->number);
4867 if (b->ops != NULL && b->ops->print_mention != NULL)
4868 b->ops->print_mention (b);
4873 printf_filtered (_("(apparently deleted?) Eventpoint %d: "), b->number);
4876 ui_out_text (uiout, "Watchpoint ");
4877 ui_out_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "wpt");
4878 ui_out_field_int (uiout, "number", b->number);
4879 ui_out_text (uiout, ": ");
4880 print_expression (b->exp, stb->stream);
4881 ui_out_field_stream (uiout, "exp", stb);
4882 do_cleanups (ui_out_chain);
4884 case bp_hardware_watchpoint:
4885 ui_out_text (uiout, "Hardware watchpoint ");
4886 ui_out_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "wpt");
4887 ui_out_field_int (uiout, "number", b->number);
4888 ui_out_text (uiout, ": ");
4889 print_expression (b->exp, stb->stream);
4890 ui_out_field_stream (uiout, "exp", stb);
4891 do_cleanups (ui_out_chain);
4893 case bp_read_watchpoint:
4894 ui_out_text (uiout, "Hardware read watchpoint ");
4895 ui_out_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "hw-rwpt");
4896 ui_out_field_int (uiout, "number", b->number);
4897 ui_out_text (uiout, ": ");
4898 print_expression (b->exp, stb->stream);
4899 ui_out_field_stream (uiout, "exp", stb);
4900 do_cleanups (ui_out_chain);
4902 case bp_access_watchpoint:
4903 ui_out_text (uiout, "Hardware access (read/write) watchpoint ");
4904 ui_out_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "hw-awpt");
4905 ui_out_field_int (uiout, "number", b->number);
4906 ui_out_text (uiout, ": ");
4907 print_expression (b->exp, stb->stream);
4908 ui_out_field_stream (uiout, "exp", stb);
4909 do_cleanups (ui_out_chain);
4912 if (ui_out_is_mi_like_p (uiout))
4917 printf_filtered (_("Breakpoint %d"), b->number);
4920 case bp_hardware_breakpoint:
4921 if (ui_out_is_mi_like_p (uiout))
4926 printf_filtered (_("Hardware assisted breakpoint %d"), b->number);
4930 case bp_catch_unload:
4931 printf_filtered (_("Catchpoint %d (%s %s)"),
4933 (b->type == bp_catch_load) ? "load" : "unload",
4934 (b->dll_pathname != NULL) ?
4935 b->dll_pathname : "<any library>");
4938 case bp_catch_vfork:
4939 printf_filtered (_("Catchpoint %d (%s)"),
4941 (b->type == bp_catch_fork) ? "fork" : "vfork");
4944 printf_filtered (_("Catchpoint %d (exec)"),
4947 case bp_catch_catch:
4948 case bp_catch_throw:
4949 printf_filtered (_("Catchpoint %d (%s)"),
4951 (b->type == bp_catch_catch) ? "catch" : "throw");
4957 case bp_longjmp_resume:
4958 case bp_step_resume:
4959 case bp_through_sigtramp:
4961 case bp_watchpoint_scope:
4962 case bp_shlib_event:
4963 case bp_thread_event:
4964 case bp_overlay_event:
4970 /* i18n: cagney/2005-02-11: Below needs to be merged into a
4974 printf_filtered (_(" (%s) pending."), b->addr_string);
4978 if (addressprint || b->source_file == NULL)
4980 printf_filtered (" at ");
4981 deprecated_print_address_numeric (b->loc->address, 1, gdb_stdout);
4984 printf_filtered (": file %s, line %d.",
4985 b->source_file, b->line_number);
4988 do_cleanups (old_chain);
4989 if (ui_out_is_mi_like_p (uiout))
4991 printf_filtered ("\n");
4995 /* Add SALS.nelts breakpoints to the breakpoint table. For each
4996 SALS.sal[i] breakpoint, include the corresponding ADDR_STRING[i],
4997 COND[i] and COND_STRING[i] values.
4999 The parameter PENDING_BP points to a pending breakpoint that is
5000 the basis of the breakpoints currently being created. The pending
5001 breakpoint may contain a separate condition string or commands
5002 that were added after the initial pending breakpoint was created.
5004 NOTE: If the function succeeds, the caller is expected to cleanup
5005 the arrays ADDR_STRING, COND_STRING, COND and SALS (but not the
5006 array contents). If the function fails (error() is called), the
5007 caller is expected to cleanups both the ADDR_STRING, COND_STRING,
5008 COND and SALS arrays and each of those arrays contents. */
5011 create_breakpoints (struct symtabs_and_lines sals, char **addr_string,
5012 struct expression **cond, char **cond_string,
5013 enum bptype type, enum bpdisp disposition,
5014 int thread, int ignore_count, int from_tty,
5015 struct breakpoint *pending_bp)
5017 if (type == bp_hardware_breakpoint)
5019 int i = hw_breakpoint_used_count ();
5020 int target_resources_ok =
5021 TARGET_CAN_USE_HARDWARE_WATCHPOINT (bp_hardware_breakpoint,
5023 if (target_resources_ok == 0)
5024 error (_("No hardware breakpoint support in the target."));
5025 else if (target_resources_ok < 0)
5026 error (_("Hardware breakpoints used exceeds limit."));
5029 /* Now set all the breakpoints. */
5032 for (i = 0; i < sals.nelts; i++)
5034 struct breakpoint *b;
5035 struct symtab_and_line sal = sals.sals[i];
5038 describe_other_breakpoints (sal.pc, sal.section, thread);
5040 b = set_raw_breakpoint (sal, type);
5041 set_breakpoint_count (breakpoint_count + 1);
5042 b->number = breakpoint_count;
5046 b->addr_string = addr_string[i];
5048 /* addr_string has to be used or breakpoint_re_set will delete
5050 b->addr_string = xstrprintf ("*0x%s", paddr (b->loc->address));
5051 b->cond_string = cond_string[i];
5052 b->ignore_count = ignore_count;
5053 b->enable_state = bp_enabled;
5054 b->disposition = disposition;
5055 /* If resolving a pending breakpoint, a check must be made to see if
5056 the user has specified a new condition or commands for the
5057 breakpoint. A new condition will override any condition that was
5058 initially specified with the initial breakpoint command. */
5062 if (pending_bp->cond_string)
5064 arg = pending_bp->cond_string;
5065 b->cond_string = savestring (arg, strlen (arg));
5066 b->cond = parse_exp_1 (&arg, block_for_pc (b->loc->address), 0);
5068 error (_("Junk at end of pending breakpoint condition expression"));
5070 /* If there are commands associated with the breakpoint, they should
5072 if (pending_bp->commands)
5073 b->commands = copy_command_lines (pending_bp->commands);
5075 /* We have to copy over the ignore_count and thread as well. */
5076 b->ignore_count = pending_bp->ignore_count;
5077 b->thread = pending_bp->thread;
5084 /* Parse ARG which is assumed to be a SAL specification possibly
5085 followed by conditionals. On return, SALS contains an array of SAL
5086 addresses found. ADDR_STRING contains a vector of (canonical)
5087 address strings. ARG points to the end of the SAL. */
5090 parse_breakpoint_sals (char **address,
5091 struct symtabs_and_lines *sals,
5092 char ***addr_string,
5095 char *addr_start = *address;
5096 *addr_string = NULL;
5097 /* If no arg given, or if first arg is 'if ', use the default
5099 if ((*address) == NULL
5100 || (strncmp ((*address), "if", 2) == 0 && isspace ((*address)[2])))
5102 if (default_breakpoint_valid)
5104 struct symtab_and_line sal;
5105 init_sal (&sal); /* initialize to zeroes */
5106 sals->sals = (struct symtab_and_line *)
5107 xmalloc (sizeof (struct symtab_and_line));
5108 sal.pc = default_breakpoint_address;
5109 sal.line = default_breakpoint_line;
5110 sal.symtab = default_breakpoint_symtab;
5111 sal.section = find_pc_overlay (sal.pc);
5112 sals->sals[0] = sal;
5116 error (_("No default breakpoint address now."));
5120 /* Force almost all breakpoints to be in terms of the
5121 current_source_symtab (which is decode_line_1's default). This
5122 should produce the results we want almost all of the time while
5123 leaving default_breakpoint_* alone.
5124 ObjC: However, don't match an Objective-C method name which
5125 may have a '+' or '-' succeeded by a '[' */
5127 struct symtab_and_line cursal = get_current_source_symtab_and_line ();
5129 if (default_breakpoint_valid
5131 || ((strchr ("+-", (*address)[0]) != NULL)
5132 && ((*address)[1] != '['))))
5133 *sals = decode_line_1 (address, 1, default_breakpoint_symtab,
5134 default_breakpoint_line, addr_string,
5137 *sals = decode_line_1 (address, 1, (struct symtab *) NULL, 0,
5138 addr_string, not_found_ptr);
5140 /* For any SAL that didn't have a canonical string, fill one in. */
5141 if (sals->nelts > 0 && *addr_string == NULL)
5142 *addr_string = xcalloc (sals->nelts, sizeof (char **));
5143 if (addr_start != (*address))
5146 for (i = 0; i < sals->nelts; i++)
5148 /* Add the string if not present. */
5149 if ((*addr_string)[i] == NULL)
5150 (*addr_string)[i] = savestring (addr_start, (*address) - addr_start);
5156 /* Convert each SAL into a real PC. Verify that the PC can be
5157 inserted as a breakpoint. If it can't throw an error. */
5160 breakpoint_sals_to_pc (struct symtabs_and_lines *sals,
5164 for (i = 0; i < sals->nelts; i++)
5166 resolve_sal_pc (&sals->sals[i]);
5168 /* It's possible for the PC to be nonzero, but still an illegal
5169 value on some targets.
5171 For example, on HP-UX if you start gdb, and before running the
5172 inferior you try to set a breakpoint on a shared library function
5173 "foo" where the inferior doesn't call "foo" directly but does
5174 pass its address to another function call, then we do find a
5175 minimal symbol for the "foo", but it's address is invalid.
5176 (Appears to be an index into a table that the loader sets up
5177 when the inferior is run.)
5179 Give the target a chance to bless sals.sals[i].pc before we
5180 try to make a breakpoint for it. */
5181 #ifdef DEPRECATED_PC_REQUIRES_RUN_BEFORE_USE
5182 if (DEPRECATED_PC_REQUIRES_RUN_BEFORE_USE (sals->sals[i].pc))
5184 if (address == NULL)
5185 error (_("Cannot break without a running program."));
5187 error (_("Cannot break on %s without a running program."),
5195 do_captured_parse_breakpoint (struct ui_out *ui, void *data)
5197 struct captured_parse_breakpoint_args *args = data;
5199 parse_breakpoint_sals (args->arg_p, args->sals_p, args->addr_string_p,
5200 args->not_found_ptr);
5203 /* Set a breakpoint according to ARG (function, linenum or *address)
5204 flag: first bit : 0 non-temporary, 1 temporary.
5205 second bit : 0 normal breakpoint, 1 hardware breakpoint.
5207 PENDING_BP is non-NULL when this function is being called to resolve
5208 a pending breakpoint. */
5211 break_command_1 (char *arg, int flag, int from_tty, struct breakpoint *pending_bp)
5213 struct gdb_exception e;
5214 int tempflag, hardwareflag;
5215 struct symtabs_and_lines sals;
5216 struct expression **cond = 0;
5217 struct symtab_and_line pending_sal;
5218 char **cond_string = (char **) NULL;
5221 char *addr_start = arg;
5223 struct cleanup *old_chain;
5224 struct cleanup *breakpoint_chain = NULL;
5225 struct captured_parse_breakpoint_args parse_args;
5229 int ignore_count = 0;
5232 hardwareflag = flag & BP_HARDWAREFLAG;
5233 tempflag = flag & BP_TEMPFLAG;
5239 parse_args.arg_p = &arg;
5240 parse_args.sals_p = &sals;
5241 parse_args.addr_string_p = &addr_string;
5242 parse_args.not_found_ptr = ¬_found;
5244 e = catch_exception (uiout, do_captured_parse_breakpoint,
5245 &parse_args, RETURN_MASK_ALL);
5247 /* If caller is interested in rc value from parse, set value. */
5251 exception_print (gdb_stderr, e);
5256 case NOT_FOUND_ERROR:
5257 /* If called to resolve pending breakpoint, just return
5262 exception_print (gdb_stderr, e);
5264 /* If pending breakpoint support is turned off, throw
5267 if (pending_break_support == AUTO_BOOLEAN_FALSE)
5268 deprecated_throw_reason (RETURN_ERROR);
5270 /* If pending breakpoint support is auto query and the user
5271 selects no, then simply return the error code. */
5272 if (pending_break_support == AUTO_BOOLEAN_AUTO &&
5273 !nquery ("Make breakpoint pending on future shared library load? "))
5276 /* At this point, either the user was queried about setting
5277 a pending breakpoint and selected yes, or pending
5278 breakpoint behavior is on and thus a pending breakpoint
5279 is defaulted on behalf of the user. */
5280 copy_arg = xstrdup (addr_start);
5281 addr_string = ©_arg;
5283 sals.sals = &pending_sal;
5288 exception_print (gdb_stderr, e);
5296 /* Create a chain of things that always need to be cleaned up. */
5297 old_chain = make_cleanup (null_cleanup, 0);
5301 /* Make sure that all storage allocated to SALS gets freed. */
5302 make_cleanup (xfree, sals.sals);
5304 /* Cleanup the addr_string array but not its contents. */
5305 make_cleanup (xfree, addr_string);
5308 /* Allocate space for all the cond expressions. */
5309 cond = xcalloc (sals.nelts, sizeof (struct expression *));
5310 make_cleanup (xfree, cond);
5312 /* Allocate space for all the cond strings. */
5313 cond_string = xcalloc (sals.nelts, sizeof (char **));
5314 make_cleanup (xfree, cond_string);
5316 /* ----------------------------- SNIP -----------------------------
5317 Anything added to the cleanup chain beyond this point is assumed
5318 to be part of a breakpoint. If the breakpoint create succeeds
5319 then the memory is not reclaimed. */
5320 breakpoint_chain = make_cleanup (null_cleanup, 0);
5322 /* Mark the contents of the addr_string for cleanup. These go on
5323 the breakpoint_chain and only occure if the breakpoint create
5325 for (i = 0; i < sals.nelts; i++)
5327 if (addr_string[i] != NULL)
5328 make_cleanup (xfree, addr_string[i]);
5331 /* Resolve all line numbers to PC's and verify that the addresses
5332 are ok for the target. */
5334 breakpoint_sals_to_pc (&sals, addr_start);
5336 /* Verify that condition can be parsed, before setting any
5337 breakpoints. Allocate a separate condition expression for each
5339 thread = -1; /* No specific thread yet */
5342 for (i = 0; i < sals.nelts; i++)
5349 char *cond_start = NULL;
5350 char *cond_end = NULL;
5351 while (*tok == ' ' || *tok == '\t')
5356 while (*end_tok != ' ' && *end_tok != '\t' && *end_tok != '\000')
5359 toklen = end_tok - tok;
5361 if (toklen >= 1 && strncmp (tok, "if", toklen) == 0)
5363 tok = cond_start = end_tok + 1;
5364 cond[i] = parse_exp_1 (&tok, block_for_pc (sals.sals[i].pc),
5366 make_cleanup (xfree, cond[i]);
5368 cond_string[i] = savestring (cond_start,
5369 cond_end - cond_start);
5370 make_cleanup (xfree, cond_string[i]);
5372 else if (toklen >= 1 && strncmp (tok, "thread", toklen) == 0)
5378 thread = strtol (tok, &tok, 0);
5380 error (_("Junk after thread keyword."));
5381 if (!valid_thread_id (thread))
5382 error (_("Unknown thread %d."), thread);
5385 error (_("Junk at end of arguments."));
5388 create_breakpoints (sals, addr_string, cond, cond_string,
5389 hardwareflag ? bp_hardware_breakpoint
5391 tempflag ? disp_del : disp_donttouch,
5392 thread, ignore_count, from_tty,
5397 struct symtab_and_line sal;
5398 struct breakpoint *b;
5403 make_cleanup (xfree, copy_arg);
5405 b = set_raw_breakpoint (sal, hardwareflag ? bp_hardware_breakpoint
5407 set_breakpoint_count (breakpoint_count + 1);
5408 b->number = breakpoint_count;
5411 b->addr_string = *addr_string;
5412 b->cond_string = *cond_string;
5413 b->ignore_count = ignore_count;
5415 b->disposition = tempflag ? disp_del : disp_donttouch;
5416 b->from_tty = from_tty;
5422 warning (_("Multiple breakpoints were set.\n"
5423 "Use the \"delete\" command to delete unwanted breakpoints."));
5424 /* That's it. Discard the cleanups for data inserted into the
5426 discard_cleanups (breakpoint_chain);
5427 /* But cleanup everything else. */
5428 do_cleanups (old_chain);
5433 /* Set a breakpoint of TYPE/DISPOSITION according to ARG (function,
5434 linenum or *address) with COND and IGNORE_COUNT. */
5436 struct captured_breakpoint_args
5447 do_captured_breakpoint (struct ui_out *uiout, void *data)
5449 struct captured_breakpoint_args *args = data;
5450 struct symtabs_and_lines sals;
5451 struct expression **cond;
5452 struct cleanup *old_chain;
5453 struct cleanup *breakpoint_chain = NULL;
5460 /* Parse the source and lines spec. Delay check that the expression
5461 didn't contain trailing garbage until after cleanups are in
5465 address_end = args->address;
5467 parse_breakpoint_sals (&address_end, &sals, &addr_string, 0);
5472 /* Create a chain of things at always need to be cleaned up. */
5473 old_chain = make_cleanup (null_cleanup, 0);
5475 /* Always have a addr_string array, even if it is empty. */
5476 make_cleanup (xfree, addr_string);
5478 /* Make sure that all storage allocated to SALS gets freed. */
5479 make_cleanup (xfree, sals.sals);
5481 /* Allocate space for all the cond expressions. */
5482 cond = xcalloc (sals.nelts, sizeof (struct expression *));
5483 make_cleanup (xfree, cond);
5485 /* Allocate space for all the cond strings. */
5486 cond_string = xcalloc (sals.nelts, sizeof (char **));
5487 make_cleanup (xfree, cond_string);
5489 /* ----------------------------- SNIP -----------------------------
5490 Anything added to the cleanup chain beyond this point is assumed
5491 to be part of a breakpoint. If the breakpoint create goes
5492 through then that memory is not cleaned up. */
5493 breakpoint_chain = make_cleanup (null_cleanup, 0);
5495 /* Mark the contents of the addr_string for cleanup. These go on
5496 the breakpoint_chain and only occure if the breakpoint create
5498 for (i = 0; i < sals.nelts; i++)
5500 if (addr_string[i] != NULL)
5501 make_cleanup (xfree, addr_string[i]);
5504 /* Wait until now before checking for garbage at the end of the
5505 address. That way cleanups can take care of freeing any
5507 if (*address_end != '\0')
5508 error (_("Garbage %s following breakpoint address"), address_end);
5510 /* Resolve all line numbers to PC's. */
5511 breakpoint_sals_to_pc (&sals, args->address);
5513 /* Verify that conditions can be parsed, before setting any
5515 for (i = 0; i < sals.nelts; i++)
5517 if (args->condition != NULL)
5519 char *tok = args->condition;
5520 cond[i] = parse_exp_1 (&tok, block_for_pc (sals.sals[i].pc), 0);
5522 error (_("Garbage %s follows condition"), tok);
5523 make_cleanup (xfree, cond[i]);
5524 cond_string[i] = xstrdup (args->condition);
5528 create_breakpoints (sals, addr_string, cond, cond_string,
5529 args->hardwareflag ? bp_hardware_breakpoint : bp_breakpoint,
5530 args->tempflag ? disp_del : disp_donttouch,
5531 args->thread, args->ignore_count, 0/*from-tty*/,
5532 NULL/*pending_bp*/);
5534 /* That's it. Discard the cleanups for data inserted into the
5536 discard_cleanups (breakpoint_chain);
5537 /* But cleanup everything else. */
5538 do_cleanups (old_chain);
5543 gdb_breakpoint (char *address, char *condition,
5544 int hardwareflag, int tempflag,
5545 int thread, int ignore_count,
5546 char **error_message)
5548 struct captured_breakpoint_args args;
5549 args.address = address;
5550 args.condition = condition;
5551 args.hardwareflag = hardwareflag;
5552 args.tempflag = tempflag;
5553 args.thread = thread;
5554 args.ignore_count = ignore_count;
5555 return catch_exceptions_with_msg (uiout, do_captured_breakpoint, &args,
5556 error_message, RETURN_MASK_ALL);
5560 /* Helper function for break_command_1 and disassemble_command. */
5563 resolve_sal_pc (struct symtab_and_line *sal)
5567 if (sal->pc == 0 && sal->symtab != NULL)
5569 if (!find_line_pc (sal->symtab, sal->line, &pc))
5570 error (_("No line %d in file \"%s\"."),
5571 sal->line, sal->symtab->filename);
5575 if (sal->section == 0 && sal->symtab != NULL)
5577 struct blockvector *bv;
5582 bv = blockvector_for_pc_sect (sal->pc, 0, &index, sal->symtab);
5585 b = BLOCKVECTOR_BLOCK (bv, index);
5586 sym = block_function (b);
5589 fixup_symbol_section (sym, sal->symtab->objfile);
5590 sal->section = SYMBOL_BFD_SECTION (sym);
5594 /* It really is worthwhile to have the section, so we'll just
5595 have to look harder. This case can be executed if we have
5596 line numbers but no functions (as can happen in assembly
5599 struct minimal_symbol *msym;
5601 msym = lookup_minimal_symbol_by_pc (sal->pc);
5603 sal->section = SYMBOL_BFD_SECTION (msym);
5610 break_command (char *arg, int from_tty)
5612 break_command_1 (arg, 0, from_tty, NULL);
5616 tbreak_command (char *arg, int from_tty)
5618 break_command_1 (arg, BP_TEMPFLAG, from_tty, NULL);
5622 hbreak_command (char *arg, int from_tty)
5624 break_command_1 (arg, BP_HARDWAREFLAG, from_tty, NULL);
5628 thbreak_command (char *arg, int from_tty)
5630 break_command_1 (arg, (BP_TEMPFLAG | BP_HARDWAREFLAG), from_tty, NULL);
5634 stop_command (char *arg, int from_tty)
5636 printf_filtered (_("Specify the type of breakpoint to set.\n\
5637 Usage: stop in <function | address>\n\
5638 stop at <line>\n"));
5642 stopin_command (char *arg, int from_tty)
5646 if (arg == (char *) NULL)
5648 else if (*arg != '*')
5653 /* look for a ':'. If this is a line number specification, then
5654 say it is bad, otherwise, it should be an address or
5655 function/method name */
5656 while (*argptr && !hasColon)
5658 hasColon = (*argptr == ':');
5663 badInput = (*argptr != ':'); /* Not a class::method */
5665 badInput = isdigit (*arg); /* a simple line number */
5669 printf_filtered (_("Usage: stop in <function | address>\n"));
5671 break_command_1 (arg, 0, from_tty, NULL);
5675 stopat_command (char *arg, int from_tty)
5679 if (arg == (char *) NULL || *arg == '*') /* no line number */
5686 /* look for a ':'. If there is a '::' then get out, otherwise
5687 it is probably a line number. */
5688 while (*argptr && !hasColon)
5690 hasColon = (*argptr == ':');
5695 badInput = (*argptr == ':'); /* we have class::method */
5697 badInput = !isdigit (*arg); /* not a line number */
5701 printf_filtered (_("Usage: stop at <line>\n"));
5703 break_command_1 (arg, 0, from_tty, NULL);
5706 /* accessflag: hw_write: watch write,
5707 hw_read: watch read,
5708 hw_access: watch access (read or write) */
5710 watch_command_1 (char *arg, int accessflag, int from_tty)
5712 struct breakpoint *b;
5713 struct symtab_and_line sal;
5714 struct expression *exp;
5715 struct block *exp_valid_block;
5716 struct value *val, *mark;
5717 struct frame_info *frame;
5718 struct frame_info *prev_frame = NULL;
5719 char *exp_start = NULL;
5720 char *exp_end = NULL;
5721 char *tok, *end_tok;
5723 char *cond_start = NULL;
5724 char *cond_end = NULL;
5725 struct expression *cond = NULL;
5726 int i, other_type_used, target_resources_ok = 0;
5727 enum bptype bp_type;
5730 init_sal (&sal); /* initialize to zeroes */
5732 /* Parse arguments. */
5733 innermost_block = NULL;
5735 exp = parse_exp_1 (&arg, 0, 0);
5737 exp_valid_block = innermost_block;
5738 mark = value_mark ();
5739 val = evaluate_expression (exp);
5740 release_value (val);
5741 if (value_lazy (val))
5742 value_fetch_lazy (val);
5745 while (*tok == ' ' || *tok == '\t')
5749 while (*end_tok != ' ' && *end_tok != '\t' && *end_tok != '\000')
5752 toklen = end_tok - tok;
5753 if (toklen >= 1 && strncmp (tok, "if", toklen) == 0)
5755 tok = cond_start = end_tok + 1;
5756 cond = parse_exp_1 (&tok, 0, 0);
5760 error (_("Junk at end of command."));
5762 if (accessflag == hw_read)
5763 bp_type = bp_read_watchpoint;
5764 else if (accessflag == hw_access)
5765 bp_type = bp_access_watchpoint;
5767 bp_type = bp_hardware_watchpoint;
5769 mem_cnt = can_use_hardware_watchpoint (val);
5770 if (mem_cnt == 0 && bp_type != bp_hardware_watchpoint)
5771 error (_("Expression cannot be implemented with read/access watchpoint."));
5774 i = hw_watchpoint_used_count (bp_type, &other_type_used);
5775 target_resources_ok =
5776 TARGET_CAN_USE_HARDWARE_WATCHPOINT (bp_type, i + mem_cnt,
5778 if (target_resources_ok == 0 && bp_type != bp_hardware_watchpoint)
5779 error (_("Target does not support this type of hardware watchpoint."));
5781 if (target_resources_ok < 0 && bp_type != bp_hardware_watchpoint)
5782 error (_("Target can only support one kind of HW watchpoint at a time."));
5785 #if defined(HPUXHPPA)
5786 /* On HP-UX if you set a h/w
5787 watchpoint before the "run" command, the inferior dies with a e.g.,
5788 SIGILL once you start it. I initially believed this was due to a
5789 bad interaction between page protection traps and the initial
5790 startup sequence by the dynamic linker.
5792 However, I tried avoiding that by having HP-UX's implementation of
5793 TARGET_CAN_USE_HW_WATCHPOINT return FALSE if there was no inferior_ptid
5794 yet, which forced slow watches before a "run" or "attach", and it
5795 still fails somewhere in the startup code.
5797 Until I figure out what's happening, I'm disallowing watches altogether
5798 before the "run" or "attach" command. We'll tell the user they must
5799 set watches after getting the program started. */
5800 if (!target_has_execution)
5802 warning (_("can't do that without a running program; try \"break main\"), \"run\" first");
5805 #endif /* HPUXHPPA */
5807 /* Change the type of breakpoint to an ordinary watchpoint if a hardware
5808 watchpoint could not be set. */
5809 if (!mem_cnt || target_resources_ok <= 0)
5810 bp_type = bp_watchpoint;
5812 /* Now set up the breakpoint. */
5813 b = set_raw_breakpoint (sal, bp_type);
5814 set_breakpoint_count (breakpoint_count + 1);
5815 b->number = breakpoint_count;
5816 b->disposition = disp_donttouch;
5818 b->exp_valid_block = exp_valid_block;
5819 b->exp_string = savestring (exp_start, exp_end - exp_start);
5823 b->cond_string = savestring (cond_start, cond_end - cond_start);
5827 frame = block_innermost_frame (exp_valid_block);
5830 prev_frame = get_prev_frame (frame);
5831 b->watchpoint_frame = get_frame_id (frame);
5835 memset (&b->watchpoint_frame, 0, sizeof (b->watchpoint_frame));
5838 /* If the expression is "local", then set up a "watchpoint scope"
5839 breakpoint at the point where we've left the scope of the watchpoint
5841 if (innermost_block)
5845 struct breakpoint *scope_breakpoint;
5846 scope_breakpoint = create_internal_breakpoint (get_frame_pc (prev_frame),
5847 bp_watchpoint_scope);
5849 scope_breakpoint->enable_state = bp_enabled;
5851 /* Automatically delete the breakpoint when it hits. */
5852 scope_breakpoint->disposition = disp_del;
5854 /* Only break in the proper frame (help with recursion). */
5855 scope_breakpoint->frame_id = get_frame_id (prev_frame);
5857 /* Set the address at which we will stop. */
5858 scope_breakpoint->loc->requested_address
5859 = get_frame_pc (prev_frame);
5860 scope_breakpoint->loc->address
5861 = adjust_breakpoint_address (scope_breakpoint->loc->requested_address,
5862 scope_breakpoint->type);
5864 /* The scope breakpoint is related to the watchpoint. We
5865 will need to act on them together. */
5866 b->related_breakpoint = scope_breakpoint;
5869 value_free_to_mark (mark);
5873 /* Return count of locations need to be watched and can be handled
5874 in hardware. If the watchpoint can not be handled
5875 in hardware return zero. */
5878 can_use_hardware_watchpoint (struct value *v)
5880 int found_memory_cnt = 0;
5881 struct value *head = v;
5883 /* Did the user specifically forbid us to use hardware watchpoints? */
5884 if (!can_use_hw_watchpoints)
5887 /* Make sure that the value of the expression depends only upon
5888 memory contents, and values computed from them within GDB. If we
5889 find any register references or function calls, we can't use a
5890 hardware watchpoint.
5892 The idea here is that evaluating an expression generates a series
5893 of values, one holding the value of every subexpression. (The
5894 expression a*b+c has five subexpressions: a, b, a*b, c, and
5895 a*b+c.) GDB's values hold almost enough information to establish
5896 the criteria given above --- they identify memory lvalues,
5897 register lvalues, computed values, etcetera. So we can evaluate
5898 the expression, and then scan the chain of values that leaves
5899 behind to decide whether we can detect any possible change to the
5900 expression's final value using only hardware watchpoints.
5902 However, I don't think that the values returned by inferior
5903 function calls are special in any way. So this function may not
5904 notice that an expression involving an inferior function call
5905 can't be watched with hardware watchpoints. FIXME. */
5906 for (; v; v = value_next (v))
5908 if (VALUE_LVAL (v) == lval_memory)
5911 /* A lazy memory lvalue is one that GDB never needed to fetch;
5912 we either just used its address (e.g., `a' in `a.b') or
5913 we never needed it at all (e.g., `a' in `a,b'). */
5917 /* Ahh, memory we actually used! Check if we can cover
5918 it with hardware watchpoints. */
5919 struct type *vtype = check_typedef (value_type (v));
5921 /* We only watch structs and arrays if user asked for it
5922 explicitly, never if they just happen to appear in a
5923 middle of some value chain. */
5925 || (TYPE_CODE (vtype) != TYPE_CODE_STRUCT
5926 && TYPE_CODE (vtype) != TYPE_CODE_ARRAY))
5928 CORE_ADDR vaddr = VALUE_ADDRESS (v) + value_offset (v);
5929 int len = TYPE_LENGTH (value_type (v));
5931 if (!TARGET_REGION_OK_FOR_HW_WATCHPOINT (vaddr, len))
5938 else if (VALUE_LVAL (v) != not_lval
5939 && deprecated_value_modifiable (v) == 0)
5940 return 0; /* ??? What does this represent? */
5941 else if (VALUE_LVAL (v) == lval_register)
5942 return 0; /* cannot watch a register with a HW watchpoint */
5945 /* The expression itself looks suitable for using a hardware
5946 watchpoint, but give the target machine a chance to reject it. */
5947 return found_memory_cnt;
5951 watch_command_wrapper (char *arg, int from_tty)
5953 watch_command (arg, from_tty);
5957 watch_command (char *arg, int from_tty)
5959 watch_command_1 (arg, hw_write, from_tty);
5963 rwatch_command_wrapper (char *arg, int from_tty)
5965 rwatch_command (arg, from_tty);
5969 rwatch_command (char *arg, int from_tty)
5971 watch_command_1 (arg, hw_read, from_tty);
5975 awatch_command_wrapper (char *arg, int from_tty)
5977 awatch_command (arg, from_tty);
5981 awatch_command (char *arg, int from_tty)
5983 watch_command_1 (arg, hw_access, from_tty);
5987 /* Helper routines for the until_command routine in infcmd.c. Here
5988 because it uses the mechanisms of breakpoints. */
5990 /* This function is called by fetch_inferior_event via the
5991 cmd_continuation pointer, to complete the until command. It takes
5992 care of cleaning up the temporary breakpoints set up by the until
5995 until_break_command_continuation (struct continuation_arg *arg)
5997 struct cleanup *cleanups;
5999 cleanups = (struct cleanup *) arg->data.pointer;
6000 do_exec_cleanups (cleanups);
6004 until_break_command (char *arg, int from_tty, int anywhere)
6006 struct symtabs_and_lines sals;
6007 struct symtab_and_line sal;
6008 struct frame_info *prev_frame = get_prev_frame (deprecated_selected_frame);
6009 struct breakpoint *breakpoint;
6010 struct cleanup *old_chain;
6011 struct continuation_arg *arg1;
6014 clear_proceed_status ();
6016 /* Set a breakpoint where the user wants it and at return from
6019 if (default_breakpoint_valid)
6020 sals = decode_line_1 (&arg, 1, default_breakpoint_symtab,
6021 default_breakpoint_line, (char ***) NULL, NULL);
6023 sals = decode_line_1 (&arg, 1, (struct symtab *) NULL,
6024 0, (char ***) NULL, NULL);
6026 if (sals.nelts != 1)
6027 error (_("Couldn't get information on specified line."));
6030 xfree (sals.sals); /* malloc'd, so freed */
6033 error (_("Junk at end of arguments."));
6035 resolve_sal_pc (&sal);
6038 /* If the user told us to continue until a specified location,
6039 we don't specify a frame at which we need to stop. */
6040 breakpoint = set_momentary_breakpoint (sal, null_frame_id, bp_until);
6042 /* Otherwise, specify the current frame, because we want to stop only
6043 at the very same frame. */
6044 breakpoint = set_momentary_breakpoint (sal,
6045 get_frame_id (deprecated_selected_frame),
6048 if (!target_can_async_p ())
6049 old_chain = make_cleanup_delete_breakpoint (breakpoint);
6051 old_chain = make_exec_cleanup_delete_breakpoint (breakpoint);
6053 /* If we are running asynchronously, and the target supports async
6054 execution, we are not waiting for the target to stop, in the call
6055 tp proceed, below. This means that we cannot delete the
6056 brekpoints until the target has actually stopped. The only place
6057 where we get a chance to do that is in fetch_inferior_event, so
6058 we must set things up for that. */
6060 if (target_can_async_p ())
6062 /* In this case the arg for the continuation is just the point
6063 in the exec_cleanups chain from where to start doing
6064 cleanups, because all the continuation does is the cleanups in
6065 the exec_cleanup_chain. */
6067 (struct continuation_arg *) xmalloc (sizeof (struct continuation_arg));
6069 arg1->data.pointer = old_chain;
6071 add_continuation (until_break_command_continuation, arg1);
6074 /* Keep within the current frame, or in frames called by the current
6078 sal = find_pc_line (get_frame_pc (prev_frame), 0);
6079 sal.pc = get_frame_pc (prev_frame);
6080 breakpoint = set_momentary_breakpoint (sal, get_frame_id (prev_frame),
6082 if (!target_can_async_p ())
6083 make_cleanup_delete_breakpoint (breakpoint);
6085 make_exec_cleanup_delete_breakpoint (breakpoint);
6088 proceed (-1, TARGET_SIGNAL_DEFAULT, 0);
6089 /* Do the cleanups now, anly if we are not running asynchronously,
6090 of if we are, but the target is still synchronous. */
6091 if (!target_can_async_p ())
6092 do_cleanups (old_chain);
6096 ep_skip_leading_whitespace (char **s)
6098 if ((s == NULL) || (*s == NULL))
6100 while (isspace (**s))
6104 /* This function examines a string, and attempts to find a token
6105 that might be an event name in the leading characters. If a
6106 possible match is found, a pointer to the last character of
6107 the token is returned. Else, NULL is returned. */
6110 ep_find_event_name_end (char *arg)
6113 char *event_name_end = NULL;
6115 /* If we could depend upon the presense of strrpbrk, we'd use that... */
6119 /* We break out of the loop when we find a token delimiter.
6120 Basically, we're looking for alphanumerics and underscores;
6121 anything else delimites the token. */
6124 if (!isalnum (*s) && (*s != '_'))
6130 return event_name_end;
6134 /* This function attempts to parse an optional "if <cond>" clause
6135 from the arg string. If one is not found, it returns NULL.
6137 Else, it returns a pointer to the condition string. (It does not
6138 attempt to evaluate the string against a particular block.) And,
6139 it updates arg to point to the first character following the parsed
6140 if clause in the arg string. */
6143 ep_parse_optional_if_clause (char **arg)
6147 if (((*arg)[0] != 'i') || ((*arg)[1] != 'f') || !isspace ((*arg)[2]))
6150 /* Skip the "if" keyword. */
6153 /* Skip any extra leading whitespace, and record the start of the
6154 condition string. */
6155 ep_skip_leading_whitespace (arg);
6158 /* Assume that the condition occupies the remainder of the arg string. */
6159 (*arg) += strlen (cond_string);
6164 /* This function attempts to parse an optional filename from the arg
6165 string. If one is not found, it returns NULL.
6167 Else, it returns a pointer to the parsed filename. (This function
6168 makes no attempt to verify that a file of that name exists, or is
6169 accessible.) And, it updates arg to point to the first character
6170 following the parsed filename in the arg string.
6172 Note that clients needing to preserve the returned filename for
6173 future access should copy it to their own buffers. */
6175 ep_parse_optional_filename (char **arg)
6177 static char filename[1024];
6182 if ((*arg_p == '\0') || isspace (*arg_p))
6200 /* Commands to deal with catching events, such as signals, exceptions,
6201 process start/exit, etc. */
6205 catch_fork, catch_vfork
6210 catch_fork_command_1 (catch_fork_kind fork_kind, char *arg, int tempflag,
6213 char *cond_string = NULL;
6215 ep_skip_leading_whitespace (&arg);
6217 /* The allowed syntax is:
6219 catch [v]fork if <cond>
6221 First, check if there's an if clause. */
6222 cond_string = ep_parse_optional_if_clause (&arg);
6224 if ((*arg != '\0') && !isspace (*arg))
6225 error (_("Junk at end of arguments."));
6227 /* If this target supports it, create a fork or vfork catchpoint
6228 and enable reporting of such events. */
6232 create_fork_event_catchpoint (tempflag, cond_string);
6235 create_vfork_event_catchpoint (tempflag, cond_string);
6238 error (_("unsupported or unknown fork kind; cannot catch it"));
6244 catch_exec_command_1 (char *arg, int tempflag, int from_tty)
6246 char *cond_string = NULL;
6248 ep_skip_leading_whitespace (&arg);
6250 /* The allowed syntax is:
6252 catch exec if <cond>
6254 First, check if there's an if clause. */
6255 cond_string = ep_parse_optional_if_clause (&arg);
6257 if ((*arg != '\0') && !isspace (*arg))
6258 error (_("Junk at end of arguments."));
6260 /* If this target supports it, create an exec catchpoint
6261 and enable reporting of such events. */
6262 create_exec_event_catchpoint (tempflag, cond_string);
6266 catch_load_command_1 (char *arg, int tempflag, int from_tty)
6268 char *dll_pathname = NULL;
6269 char *cond_string = NULL;
6271 ep_skip_leading_whitespace (&arg);
6273 /* The allowed syntax is:
6275 catch load if <cond>
6276 catch load <filename>
6277 catch load <filename> if <cond>
6279 The user is not allowed to specify the <filename> after an
6282 We'll ignore the pathological case of a file named "if".
6284 First, check if there's an if clause. If so, then there
6285 cannot be a filename. */
6286 cond_string = ep_parse_optional_if_clause (&arg);
6288 /* If there was an if clause, then there cannot be a filename.
6289 Else, there might be a filename and an if clause. */
6290 if (cond_string == NULL)
6292 dll_pathname = ep_parse_optional_filename (&arg);
6293 ep_skip_leading_whitespace (&arg);
6294 cond_string = ep_parse_optional_if_clause (&arg);
6297 if ((*arg != '\0') && !isspace (*arg))
6298 error (_("Junk at end of arguments."));
6300 /* Create a load breakpoint that only triggers when a load of
6301 the specified dll (or any dll, if no pathname was specified)
6303 SOLIB_CREATE_CATCH_LOAD_HOOK (PIDGET (inferior_ptid), tempflag,
6304 dll_pathname, cond_string);
6308 catch_unload_command_1 (char *arg, int tempflag, int from_tty)
6310 char *dll_pathname = NULL;
6311 char *cond_string = NULL;
6313 ep_skip_leading_whitespace (&arg);
6315 /* The allowed syntax is:
6317 catch unload if <cond>
6318 catch unload <filename>
6319 catch unload <filename> if <cond>
6321 The user is not allowed to specify the <filename> after an
6324 We'll ignore the pathological case of a file named "if".
6326 First, check if there's an if clause. If so, then there
6327 cannot be a filename. */
6328 cond_string = ep_parse_optional_if_clause (&arg);
6330 /* If there was an if clause, then there cannot be a filename.
6331 Else, there might be a filename and an if clause. */
6332 if (cond_string == NULL)
6334 dll_pathname = ep_parse_optional_filename (&arg);
6335 ep_skip_leading_whitespace (&arg);
6336 cond_string = ep_parse_optional_if_clause (&arg);
6339 if ((*arg != '\0') && !isspace (*arg))
6340 error (_("Junk at end of arguments."));
6342 /* Create an unload breakpoint that only triggers when an unload of
6343 the specified dll (or any dll, if no pathname was specified)
6345 SOLIB_CREATE_CATCH_UNLOAD_HOOK (PIDGET (inferior_ptid), tempflag,
6346 dll_pathname, cond_string);
6349 /* Commands to deal with catching exceptions. */
6351 /* Set a breakpoint at the specified callback routine for an
6352 exception event callback */
6355 create_exception_catchpoint (int tempflag, char *cond_string,
6356 enum exception_event_kind ex_event,
6357 struct symtab_and_line *sal)
6359 struct breakpoint *b;
6360 int thread = -1; /* All threads. */
6363 if (!sal) /* no exception support? */
6368 case EX_EVENT_THROW:
6369 bptype = bp_catch_throw;
6371 case EX_EVENT_CATCH:
6372 bptype = bp_catch_catch;
6374 default: /* error condition */
6375 error (_("Internal error -- invalid catchpoint kind"));
6378 b = set_raw_breakpoint (*sal, bptype);
6379 set_breakpoint_count (breakpoint_count + 1);
6380 b->number = breakpoint_count;
6382 b->cond_string = (cond_string == NULL) ?
6383 NULL : savestring (cond_string, strlen (cond_string));
6385 b->addr_string = NULL;
6386 b->enable_state = bp_enabled;
6387 b->disposition = tempflag ? disp_del : disp_donttouch;
6391 static enum print_stop_action
6392 print_exception_catchpoint (struct breakpoint *b)
6394 annotate_catchpoint (b->number);
6396 if (strstr (b->addr_string, "throw") != NULL)
6397 printf_filtered (_("\nCatchpoint %d (exception thrown)\n"),
6400 printf_filtered (_("\nCatchpoint %d (exception caught)\n"),
6403 return PRINT_SRC_AND_LOC;
6407 print_one_exception_catchpoint (struct breakpoint *b, CORE_ADDR *last_addr)
6412 ui_out_field_core_addr (uiout, "addr", b->loc->address);
6415 *last_addr = b->loc->address;
6416 if (strstr (b->addr_string, "throw") != NULL)
6417 ui_out_field_string (uiout, "what", "exception throw");
6419 ui_out_field_string (uiout, "what", "exception catch");
6423 print_mention_exception_catchpoint (struct breakpoint *b)
6425 if (strstr (b->addr_string, "throw") != NULL)
6426 printf_filtered (_("Catchpoint %d (throw)"), b->number);
6428 printf_filtered (_("Catchpoint %d (catch)"), b->number);
6431 static struct breakpoint_ops gnu_v3_exception_catchpoint_ops = {
6432 print_exception_catchpoint,
6433 print_one_exception_catchpoint,
6434 print_mention_exception_catchpoint
6438 handle_gnu_v3_exceptions (int tempflag, char *cond_string,
6439 enum exception_event_kind ex_event, int from_tty)
6441 char *trigger_func_name, *nameptr;
6442 struct symtabs_and_lines sals;
6443 struct breakpoint *b;
6445 if (ex_event == EX_EVENT_CATCH)
6446 trigger_func_name = xstrdup ("__cxa_begin_catch");
6448 trigger_func_name = xstrdup ("__cxa_throw");
6450 nameptr = trigger_func_name;
6451 sals = decode_line_1 (&nameptr, 1, NULL, 0, NULL, NULL);
6452 if (sals.nelts == 0)
6454 xfree (trigger_func_name);
6458 b = set_raw_breakpoint (sals.sals[0], bp_breakpoint);
6459 set_breakpoint_count (breakpoint_count + 1);
6460 b->number = breakpoint_count;
6462 b->cond_string = (cond_string == NULL) ?
6463 NULL : savestring (cond_string, strlen (cond_string));
6465 b->addr_string = trigger_func_name;
6466 b->enable_state = bp_enabled;
6467 b->disposition = tempflag ? disp_del : disp_donttouch;
6468 b->ops = &gnu_v3_exception_catchpoint_ops;
6475 /* Deal with "catch catch" and "catch throw" commands */
6478 catch_exception_command_1 (enum exception_event_kind ex_event, char *arg,
6479 int tempflag, int from_tty)
6481 char *cond_string = NULL;
6482 struct symtab_and_line *sal = NULL;
6484 ep_skip_leading_whitespace (&arg);
6486 cond_string = ep_parse_optional_if_clause (&arg);
6488 if ((*arg != '\0') && !isspace (*arg))
6489 error (_("Junk at end of arguments."));
6491 if ((ex_event != EX_EVENT_THROW) &&
6492 (ex_event != EX_EVENT_CATCH))
6493 error (_("Unsupported or unknown exception event; cannot catch it"));
6495 if (handle_gnu_v3_exceptions (tempflag, cond_string, ex_event, from_tty))
6498 /* See if we can find a callback routine */
6499 sal = target_enable_exception_callback (ex_event, 1);
6503 /* We have callbacks from the runtime system for exceptions.
6504 Set a breakpoint on the sal found, if no errors */
6505 if (sal != (struct symtab_and_line *) -1)
6506 create_exception_catchpoint (tempflag, cond_string, ex_event, sal);
6508 return; /* something went wrong with setting up callbacks */
6511 warning (_("Unsupported with this platform/compiler combination."));
6514 /* Create a breakpoint struct for Ada exception catchpoints. */
6517 create_ada_exception_breakpoint (struct symtab_and_line sal,
6521 struct expression *cond,
6522 struct breakpoint_ops *ops,
6526 struct breakpoint *b;
6530 describe_other_breakpoints (sal.pc, sal.section, -1);
6531 /* FIXME: brobecker/2006-12-28: Actually, re-implement a special
6532 version for exception catchpoints, because two catchpoints
6533 used for different exception names will use the same address.
6534 In this case, a "breakpoint ... also set at..." warning is
6535 unproductive. Besides. the warning phrasing is also a bit
6536 inapropriate, we should use the word catchpoint, and tell
6537 the user what type of catchpoint it is. The above is good
6538 enough for now, though. */
6541 b = set_raw_breakpoint (sal, bp_breakpoint);
6542 set_breakpoint_count (breakpoint_count + 1);
6544 b->enable_state = bp_enabled;
6545 b->disposition = tempflag ? disp_del : disp_donttouch;
6546 b->number = breakpoint_count;
6547 b->ignore_count = 0;
6549 b->addr_string = addr_string;
6550 b->language = language_ada;
6551 b->cond_string = cond_string;
6552 b->exp_string = exp_string;
6555 b->from_tty = from_tty;
6560 /* Implement the "catch exception" command. */
6563 catch_ada_exception_command (char *arg, int tempflag, int from_tty)
6565 struct symtab_and_line sal;
6567 char *addr_string = NULL;
6568 char *exp_string = NULL;
6569 char *cond_string = NULL;
6570 struct expression *cond = NULL;
6571 struct breakpoint_ops *ops = NULL;
6573 sal = ada_decode_exception_location (arg, &addr_string, &exp_string,
6574 &cond_string, &cond, &ops);
6575 create_ada_exception_breakpoint (sal, addr_string, exp_string,
6576 cond_string, cond, ops, tempflag,
6580 /* Implement the "catch assert" command. */
6583 catch_assert_command (char *arg, int tempflag, int from_tty)
6585 struct symtab_and_line sal;
6586 char *addr_string = NULL;
6587 struct breakpoint_ops *ops = NULL;
6589 sal = ada_decode_assert_location (arg, &addr_string, &ops);
6590 create_ada_exception_breakpoint (sal, addr_string, NULL, NULL, NULL, ops,
6591 tempflag, from_tty);
6594 /* Cover routine to allow wrapping target_enable_exception_catchpoints
6595 inside a catch_errors */
6598 cover_target_enable_exception_callback (void *arg)
6600 args_for_catchpoint_enable *args = arg;
6601 struct symtab_and_line *sal;
6602 sal = target_enable_exception_callback (args->kind, args->enable_p);
6605 else if (sal == (struct symtab_and_line *) -1)
6608 return 1; /*is valid */
6612 catch_command_1 (char *arg, int tempflag, int from_tty)
6615 /* The first argument may be an event name, such as "start" or "load".
6616 If so, then handle it as such. If it doesn't match an event name,
6617 then attempt to interpret it as an exception name. (This latter is
6618 the v4.16-and-earlier GDB meaning of the "catch" command.)
6620 First, try to find the bounds of what might be an event name. */
6621 char *arg1_start = arg;
6625 if (arg1_start == NULL)
6627 /* Old behaviour was to use pre-v-4.16 syntax */
6628 /* catch_throw_command_1 (arg1_start, tempflag, from_tty); */
6630 /* Now, this is not allowed */
6631 error (_("Catch requires an event name."));
6634 arg1_end = ep_find_event_name_end (arg1_start);
6635 if (arg1_end == NULL)
6636 error (_("catch requires an event"));
6637 arg1_length = arg1_end + 1 - arg1_start;
6639 /* Try to match what we found against known event names. */
6640 if (strncmp (arg1_start, "signal", arg1_length) == 0)
6642 error (_("Catch of signal not yet implemented"));
6644 else if (strncmp (arg1_start, "catch", arg1_length) == 0)
6646 catch_exception_command_1 (EX_EVENT_CATCH, arg1_end + 1,
6647 tempflag, from_tty);
6649 else if (strncmp (arg1_start, "throw", arg1_length) == 0)
6651 catch_exception_command_1 (EX_EVENT_THROW, arg1_end + 1,
6652 tempflag, from_tty);
6654 else if (strncmp (arg1_start, "thread_start", arg1_length) == 0)
6656 error (_("Catch of thread_start not yet implemented"));
6658 else if (strncmp (arg1_start, "thread_exit", arg1_length) == 0)
6660 error (_("Catch of thread_exit not yet implemented"));
6662 else if (strncmp (arg1_start, "thread_join", arg1_length) == 0)
6664 error (_("Catch of thread_join not yet implemented"));
6666 else if (strncmp (arg1_start, "start", arg1_length) == 0)
6668 error (_("Catch of start not yet implemented"));
6670 else if (strncmp (arg1_start, "exit", arg1_length) == 0)
6672 error (_("Catch of exit not yet implemented"));
6674 else if (strncmp (arg1_start, "fork", arg1_length) == 0)
6676 catch_fork_command_1 (catch_fork, arg1_end + 1, tempflag, from_tty);
6678 else if (strncmp (arg1_start, "vfork", arg1_length) == 0)
6680 catch_fork_command_1 (catch_vfork, arg1_end + 1, tempflag, from_tty);
6682 else if (strncmp (arg1_start, "exec", arg1_length) == 0)
6684 catch_exec_command_1 (arg1_end + 1, tempflag, from_tty);
6686 else if (strncmp (arg1_start, "load", arg1_length) == 0)
6688 catch_load_command_1 (arg1_end + 1, tempflag, from_tty);
6690 else if (strncmp (arg1_start, "unload", arg1_length) == 0)
6692 catch_unload_command_1 (arg1_end + 1, tempflag, from_tty);
6694 else if (strncmp (arg1_start, "stop", arg1_length) == 0)
6696 error (_("Catch of stop not yet implemented"));
6698 else if (strncmp (arg1_start, "exception", arg1_length) == 0)
6700 catch_ada_exception_command (arg1_end + 1, tempflag, from_tty);
6703 else if (strncmp (arg1_start, "assert", arg1_length) == 0)
6705 catch_assert_command (arg1_end + 1, tempflag, from_tty);
6708 /* This doesn't appear to be an event name */
6712 /* Pre-v.4.16 behaviour was to treat the argument
6713 as the name of an exception */
6714 /* catch_throw_command_1 (arg1_start, tempflag, from_tty); */
6715 /* Now this is not allowed */
6716 error (_("Unknown event kind specified for catch"));
6721 /* Used by the gui, could be made a worker for other things. */
6724 set_breakpoint_sal (struct symtab_and_line sal)
6726 struct breakpoint *b;
6727 b = set_raw_breakpoint (sal, bp_breakpoint);
6728 set_breakpoint_count (breakpoint_count + 1);
6729 b->number = breakpoint_count;
6736 catch_command (char *arg, int from_tty)
6738 catch_command_1 (arg, 0, from_tty);
6743 tcatch_command (char *arg, int from_tty)
6745 catch_command_1 (arg, 1, from_tty);
6748 /* Delete breakpoints by address or line. */
6751 clear_command (char *arg, int from_tty)
6753 struct breakpoint *b, *tmp, *prev, *found;
6755 struct symtabs_and_lines sals;
6756 struct symtab_and_line sal;
6761 sals = decode_line_spec (arg, 1);
6766 sals.sals = (struct symtab_and_line *)
6767 xmalloc (sizeof (struct symtab_and_line));
6768 make_cleanup (xfree, sals.sals);
6769 init_sal (&sal); /* initialize to zeroes */
6770 sal.line = default_breakpoint_line;
6771 sal.symtab = default_breakpoint_symtab;
6772 sal.pc = default_breakpoint_address;
6773 if (sal.symtab == 0)
6774 error (_("No source file specified."));
6782 /* For each line spec given, delete bps which correspond
6783 to it. Do it in two passes, solely to preserve the current
6784 behavior that from_tty is forced true if we delete more than
6788 for (i = 0; i < sals.nelts; i++)
6790 /* If exact pc given, clear bpts at that pc.
6791 If line given (pc == 0), clear all bpts on specified line.
6792 If defaulting, clear all bpts on default line
6795 defaulting sal.pc != 0 tests to do
6800 1 0 <can't happen> */
6805 /* Find all matching breakpoints, remove them from the
6806 breakpoint chain, and add them to the 'found' chain. */
6807 ALL_BREAKPOINTS_SAFE (b, tmp)
6809 /* Are we going to delete b? */
6810 if (b->type != bp_none
6811 && b->type != bp_watchpoint
6812 && b->type != bp_hardware_watchpoint
6813 && b->type != bp_read_watchpoint
6814 && b->type != bp_access_watchpoint
6815 /* Not if b is a watchpoint of any sort... */
6816 && (((sal.pc && (b->loc->address == sal.pc))
6817 && (!section_is_overlay (b->loc->section)
6818 || b->loc->section == sal.section))
6819 /* Yes, if sal.pc matches b (modulo overlays). */
6820 || ((default_match || (0 == sal.pc))
6821 && b->source_file != NULL
6822 && sal.symtab != NULL
6823 && strcmp (b->source_file, sal.symtab->filename) == 0
6824 && b->line_number == sal.line)))
6825 /* Yes, if sal source file and line matches b. */
6827 /* Remove it from breakpoint_chain... */
6828 if (b == breakpoint_chain)
6830 /* b is at the head of the list */
6831 breakpoint_chain = b->next;
6835 prev->next = b->next;
6837 /* And add it to 'found' chain. */
6843 /* Keep b, and keep a pointer to it. */
6848 /* Now go thru the 'found' chain and delete them. */
6852 error (_("No breakpoint at %s."), arg);
6854 error (_("No breakpoint at this line."));
6858 from_tty = 1; /* Always report if deleted more than one */
6862 printf_unfiltered (_("Deleted breakpoint "));
6864 printf_unfiltered (_("Deleted breakpoints "));
6866 breakpoints_changed ();
6870 printf_unfiltered ("%d ", found->number);
6872 delete_breakpoint (found);
6876 putchar_unfiltered ('\n');
6879 /* Delete breakpoint in BS if they are `delete' breakpoints and
6880 all breakpoints that are marked for deletion, whether hit or not.
6881 This is called after any breakpoint is hit, or after errors. */
6884 breakpoint_auto_delete (bpstat bs)
6886 struct breakpoint *b, *temp;
6888 for (; bs; bs = bs->next)
6889 if (bs->breakpoint_at && bs->breakpoint_at->disposition == disp_del
6891 delete_breakpoint (bs->breakpoint_at);
6893 ALL_BREAKPOINTS_SAFE (b, temp)
6895 if (b->disposition == disp_del_at_next_stop)
6896 delete_breakpoint (b);
6900 /* Delete a breakpoint and clean up all traces of it in the data
6904 delete_breakpoint (struct breakpoint *bpt)
6906 struct breakpoint *b;
6908 struct bp_location *loc;
6910 gdb_assert (bpt != NULL);
6912 /* Has this bp already been deleted? This can happen because multiple
6913 lists can hold pointers to bp's. bpstat lists are especial culprits.
6915 One example of this happening is a watchpoint's scope bp. When the
6916 scope bp triggers, we notice that the watchpoint is out of scope, and
6917 delete it. We also delete its scope bp. But the scope bp is marked
6918 "auto-deleting", and is already on a bpstat. That bpstat is then
6919 checked for auto-deleting bp's, which are deleted.
6921 A real solution to this problem might involve reference counts in bp's,
6922 and/or giving them pointers back to their referencing bpstat's, and
6923 teaching delete_breakpoint to only free a bp's storage when no more
6924 references were extent. A cheaper bandaid was chosen. */
6925 if (bpt->type == bp_none)
6928 if (deprecated_delete_breakpoint_hook)
6929 deprecated_delete_breakpoint_hook (bpt);
6930 breakpoint_delete_event (bpt->number);
6932 if (bpt->loc->inserted)
6933 remove_breakpoint (bpt->loc, mark_inserted);
6935 free_valchain (bpt->loc);
6937 if (breakpoint_chain == bpt)
6938 breakpoint_chain = bpt->next;
6940 if (bp_location_chain == bpt->loc)
6941 bp_location_chain = bpt->loc->next;
6943 /* If we have callback-style exception catchpoints, don't go through
6944 the adjustments to the C++ runtime library etc. if the inferior
6945 isn't actually running. target_enable_exception_callback for a
6946 null target ops vector gives an undesirable error message, so we
6947 check here and avoid it. Since currently (1997-09-17) only HP-UX aCC's
6948 exceptions are supported in this way, it's OK for now. FIXME */
6949 if (ep_is_exception_catchpoint (bpt) && target_has_execution)
6951 /* Format possible error msg */
6952 char *message = xstrprintf ("Error in deleting catchpoint %d:\n",
6954 struct cleanup *cleanups = make_cleanup (xfree, message);
6955 args_for_catchpoint_enable args;
6956 args.kind = bpt->type == bp_catch_catch ?
6957 EX_EVENT_CATCH : EX_EVENT_THROW;
6959 catch_errors (cover_target_enable_exception_callback, &args,
6960 message, RETURN_MASK_ALL);
6961 do_cleanups (cleanups);
6968 b->next = bpt->next;
6972 ALL_BP_LOCATIONS (loc)
6973 if (loc->next == bpt->loc)
6975 loc->next = bpt->loc->next;
6979 check_duplicates (bpt);
6980 /* If this breakpoint was inserted, and there is another breakpoint
6981 at the same address, we need to insert the other breakpoint. */
6982 if (bpt->loc->inserted
6983 && bpt->type != bp_hardware_watchpoint
6984 && bpt->type != bp_read_watchpoint
6985 && bpt->type != bp_access_watchpoint
6986 && bpt->type != bp_catch_fork
6987 && bpt->type != bp_catch_vfork
6988 && bpt->type != bp_catch_exec)
6991 if (b->loc->address == bpt->loc->address
6992 && b->loc->section == bpt->loc->section
6993 && !b->loc->duplicate
6994 && b->enable_state != bp_disabled
6995 && b->enable_state != bp_shlib_disabled
6997 && b->enable_state != bp_call_disabled)
7001 /* We should never reach this point if there is a permanent
7002 breakpoint at the same address as the one being deleted.
7003 If there is a permanent breakpoint somewhere, it should
7004 always be the only one inserted. */
7005 if (b->enable_state == bp_permanent)
7006 internal_error (__FILE__, __LINE__,
7007 _("another breakpoint was inserted on top of "
7008 "a permanent breakpoint"));
7010 memset (&b->loc->target_info, 0, sizeof (b->loc->target_info));
7011 b->loc->target_info.placed_address = b->loc->address;
7012 if (b->type == bp_hardware_breakpoint)
7013 val = target_insert_hw_breakpoint (&b->loc->target_info);
7015 val = target_insert_breakpoint (&b->loc->target_info);
7017 /* If there was an error in the insert, print a message, then stop execution. */
7020 struct ui_file *tmp_error_stream = mem_fileopen ();
7021 make_cleanup_ui_file_delete (tmp_error_stream);
7024 if (b->type == bp_hardware_breakpoint)
7026 fprintf_unfiltered (tmp_error_stream,
7027 "Cannot insert hardware breakpoint %d.\n"
7028 "You may have requested too many hardware breakpoints.\n",
7033 fprintf_unfiltered (tmp_error_stream, "Cannot insert breakpoint %d.\n", b->number);
7034 fprintf_filtered (tmp_error_stream, "Error accessing memory address ");
7035 deprecated_print_address_numeric (b->loc->address, 1, tmp_error_stream);
7036 fprintf_filtered (tmp_error_stream, ": %s.\n",
7037 safe_strerror (val));
7040 fprintf_unfiltered (tmp_error_stream,"The same program may be running in another process.");
7041 target_terminal_ours_for_output ();
7042 error_stream(tmp_error_stream);
7045 b->loc->inserted = 1;
7049 free_command_lines (&bpt->commands);
7052 if (bpt->cond_string != NULL)
7053 xfree (bpt->cond_string);
7054 if (bpt->addr_string != NULL)
7055 xfree (bpt->addr_string);
7056 if (bpt->exp != NULL)
7058 if (bpt->exp_string != NULL)
7059 xfree (bpt->exp_string);
7060 if (bpt->val != NULL)
7061 value_free (bpt->val);
7062 if (bpt->source_file != NULL)
7063 xfree (bpt->source_file);
7064 if (bpt->dll_pathname != NULL)
7065 xfree (bpt->dll_pathname);
7066 if (bpt->triggered_dll_pathname != NULL)
7067 xfree (bpt->triggered_dll_pathname);
7068 if (bpt->exec_pathname != NULL)
7069 xfree (bpt->exec_pathname);
7071 /* Be sure no bpstat's are pointing at it after it's been freed. */
7072 /* FIXME, how can we find all bpstat's?
7073 We just check stop_bpstat for now. */
7074 for (bs = stop_bpstat; bs; bs = bs->next)
7075 if (bs->breakpoint_at == bpt)
7077 bs->breakpoint_at = NULL;
7079 /* bs->commands will be freed later. */
7081 /* On the chance that someone will soon try again to delete this same
7082 bp, we mark it as deleted before freeing its storage. */
7083 bpt->type = bp_none;
7090 do_delete_breakpoint_cleanup (void *b)
7092 delete_breakpoint (b);
7096 make_cleanup_delete_breakpoint (struct breakpoint *b)
7098 return make_cleanup (do_delete_breakpoint_cleanup, b);
7102 make_exec_cleanup_delete_breakpoint (struct breakpoint *b)
7104 return make_exec_cleanup (do_delete_breakpoint_cleanup, b);
7108 delete_command (char *arg, int from_tty)
7110 struct breakpoint *b, *temp;
7116 int breaks_to_delete = 0;
7118 /* Delete all breakpoints if no argument.
7119 Do not delete internal or call-dummy breakpoints, these
7120 have to be deleted with an explicit breakpoint number argument. */
7123 if (b->type != bp_call_dummy &&
7124 b->type != bp_shlib_event &&
7125 b->type != bp_thread_event &&
7126 b->type != bp_overlay_event &&
7129 breaks_to_delete = 1;
7134 /* Ask user only if there are some breakpoints to delete. */
7136 || (breaks_to_delete && query (_("Delete all breakpoints? "))))
7138 ALL_BREAKPOINTS_SAFE (b, temp)
7140 if (b->type != bp_call_dummy &&
7141 b->type != bp_shlib_event &&
7142 b->type != bp_thread_event &&
7143 b->type != bp_overlay_event &&
7145 delete_breakpoint (b);
7150 map_breakpoint_numbers (arg, delete_breakpoint);
7153 /* Reset a breakpoint given it's struct breakpoint * BINT.
7154 The value we return ends up being the return value from catch_errors.
7155 Unused in this case. */
7158 breakpoint_re_set_one (void *bint)
7160 /* get past catch_errs */
7161 struct breakpoint *b = (struct breakpoint *) bint;
7165 int *not_found_ptr = NULL;
7166 struct symtabs_and_lines sals;
7168 enum enable_state save_enable;
7173 warning (_("attempted to reset apparently deleted breakpoint #%d?"),
7177 case bp_hardware_breakpoint:
7179 case bp_catch_unload:
7180 if (b->addr_string == NULL)
7182 /* Anything without a string can't be re-set. */
7183 delete_breakpoint (b);
7186 /* HACK: cagney/2001-11-11: kettenis/2001-11-11: MarkK wrote:
7188 ``And a hack it is, although Apple's Darwin version of GDB
7189 contains an almost identical hack to implement a "future
7190 break" command. It seems to work in many real world cases,
7191 but it is easy to come up with a test case where the patch
7192 doesn't help at all.''
7194 ``It seems that the way GDB implements breakpoints - in -
7195 shared - libraries was designed for a.out shared library
7196 systems (SunOS 4) where shared libraries were loaded at a
7197 fixed address in memory. Since ELF shared libraries can (and
7198 will) be loaded at any address in memory, things break.
7199 Fixing this is not trivial. Therefore, I'm not sure whether
7200 we should add this hack to the branch only. I cannot
7201 guarantee that things will be fixed on the trunk in the near
7204 In case we have a problem, disable this breakpoint. We'll
7205 restore its status if we succeed. Don't disable a
7206 shlib_disabled breakpoint though. There's a fair chance we
7207 can't re-set it if the shared library it's in hasn't been
7213 save_enable = b->enable_state;
7214 if (b->enable_state != bp_shlib_disabled)
7215 b->enable_state = bp_disabled;
7217 /* If resetting a shlib-disabled breakpoint, we don't want to
7218 see an error message if it is not found since we will expect
7219 this to occur until the shared library is finally reloaded.
7220 We accomplish this by giving decode_line_1 a pointer to use
7221 for silent notification that the symbol is not found. */
7222 not_found_ptr = ¬_found;
7224 set_language (b->language);
7225 input_radix = b->input_radix;
7227 sals = decode_line_1 (&s, 1, (struct symtab *) NULL, 0, (char ***) NULL,
7229 for (i = 0; i < sals.nelts; i++)
7231 resolve_sal_pc (&sals.sals[i]);
7233 /* Reparse conditions, they might contain references to the
7235 if (b->cond_string != NULL)
7241 /* Avoid re-freeing b->exp if an error during the call
7245 b->cond = parse_exp_1 (&s, block_for_pc (sals.sals[i].pc), 0);
7248 /* We need to re-set the breakpoint if the address changes... */
7249 if (b->loc->address != sals.sals[i].pc
7250 /* ...or new and old breakpoints both have source files, and
7251 the source file name or the line number changes... */
7252 || (b->source_file != NULL
7253 && sals.sals[i].symtab != NULL
7254 && (strcmp (b->source_file, sals.sals[i].symtab->filename) != 0
7255 || b->line_number != sals.sals[i].line)
7257 /* ...or we switch between having a source file and not having
7259 || ((b->source_file == NULL) != (sals.sals[i].symtab == NULL))
7262 if (b->source_file != NULL)
7263 xfree (b->source_file);
7264 if (sals.sals[i].symtab == NULL)
7265 b->source_file = NULL;
7268 savestring (sals.sals[i].symtab->filename,
7269 strlen (sals.sals[i].symtab->filename));
7270 b->line_number = sals.sals[i].line;
7271 b->loc->requested_address = sals.sals[i].pc;
7273 = adjust_breakpoint_address (b->loc->requested_address,
7276 /* Used to check for duplicates here, but that can
7277 cause trouble, as it doesn't check for disabled
7282 /* Might be better to do this just once per breakpoint_re_set,
7283 rather than once for every breakpoint. */
7284 breakpoints_changed ();
7286 b->loc->section = sals.sals[i].section;
7287 b->enable_state = save_enable; /* Restore it, this worked. */
7290 /* Now that this is re-enabled, check_duplicates
7292 check_duplicates (b);
7299 case bp_hardware_watchpoint:
7300 case bp_read_watchpoint:
7301 case bp_access_watchpoint:
7302 innermost_block = NULL;
7303 /* The issue arises of what context to evaluate this in. The
7304 same one as when it was set, but what does that mean when
7305 symbols have been re-read? We could save the filename and
7306 functionname, but if the context is more local than that, the
7307 best we could do would be something like how many levels deep
7308 and which index at that particular level, but that's going to
7309 be less stable than filenames or function names. */
7311 /* So for now, just use a global context. */
7315 /* Avoid re-freeing b->exp if an error during the call to
7316 parse_expression. */
7319 b->exp = parse_expression (b->exp_string);
7320 b->exp_valid_block = innermost_block;
7321 mark = value_mark ();
7324 value_free (b->val);
7325 /* Avoid re-freeing b->val if an error during the call to
7326 evaluate_expression. */
7329 b->val = evaluate_expression (b->exp);
7330 release_value (b->val);
7331 if (value_lazy (b->val) && breakpoint_enabled (b))
7332 value_fetch_lazy (b->val);
7334 if (b->cond_string != NULL)
7340 /* Avoid re-freeing b->exp if an error during the call
7344 b->cond = parse_exp_1 (&s, (struct block *) 0, 0);
7346 if (breakpoint_enabled (b))
7348 value_free_to_mark (mark);
7350 case bp_catch_catch:
7351 case bp_catch_throw:
7353 /* We needn't really do anything to reset these, since the mask
7354 that requests them is unaffected by e.g., new libraries being
7357 case bp_catch_vfork:
7362 printf_filtered (_("Deleting unknown breakpoint type %d\n"), b->type);
7364 /* Delete longjmp and overlay event breakpoints; they will be
7365 reset later by breakpoint_re_set. */
7367 case bp_longjmp_resume:
7368 case bp_overlay_event:
7369 delete_breakpoint (b);
7372 /* This breakpoint is special, it's set up when the inferior
7373 starts and we really don't want to touch it. */
7374 case bp_shlib_event:
7376 /* Like bp_shlib_event, this breakpoint type is special.
7377 Once it is set up, we do not want to touch it. */
7378 case bp_thread_event:
7380 /* Keep temporary breakpoints, which can be encountered when we step
7381 over a dlopen call and SOLIB_ADD is resetting the breakpoints.
7382 Otherwise these should have been blown away via the cleanup chain
7383 or by breakpoint_init_inferior when we rerun the executable. */
7386 case bp_watchpoint_scope:
7388 case bp_step_resume:
7395 /* Re-set all breakpoints after symbols have been re-loaded. */
7397 breakpoint_re_set (void)
7399 struct breakpoint *b, *temp;
7400 enum language save_language;
7401 int save_input_radix;
7403 save_language = current_language->la_language;
7404 save_input_radix = input_radix;
7405 ALL_BREAKPOINTS_SAFE (b, temp)
7407 /* Format possible error msg */
7408 char *message = xstrprintf ("Error in re-setting breakpoint %d:\n",
7410 struct cleanup *cleanups = make_cleanup (xfree, message);
7411 catch_errors (breakpoint_re_set_one, b, message, RETURN_MASK_ALL);
7412 do_cleanups (cleanups);
7414 set_language (save_language);
7415 input_radix = save_input_radix;
7417 if (GET_LONGJMP_TARGET_P ())
7419 create_longjmp_breakpoint ("longjmp");
7420 create_longjmp_breakpoint ("_longjmp");
7421 create_longjmp_breakpoint ("siglongjmp");
7422 create_longjmp_breakpoint ("_siglongjmp");
7423 create_longjmp_breakpoint (NULL);
7426 create_overlay_event_breakpoint ("_ovly_debug_event");
7429 /* Reset the thread number of this breakpoint:
7431 - If the breakpoint is for all threads, leave it as-is.
7432 - Else, reset it to the current thread for inferior_ptid. */
7434 breakpoint_re_set_thread (struct breakpoint *b)
7436 if (b->thread != -1)
7438 if (in_thread_list (inferior_ptid))
7439 b->thread = pid_to_thread_id (inferior_ptid);
7443 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
7444 If from_tty is nonzero, it prints a message to that effect,
7445 which ends with a period (no newline). */
7448 set_ignore_count (int bptnum, int count, int from_tty)
7450 struct breakpoint *b;
7456 if (b->number == bptnum)
7458 b->ignore_count = count;
7462 printf_filtered (_("Will stop next time breakpoint %d is reached."),
7464 else if (count == 1)
7465 printf_filtered (_("Will ignore next crossing of breakpoint %d."),
7468 printf_filtered (_("Will ignore next %d crossings of breakpoint %d."),
7471 breakpoints_changed ();
7472 breakpoint_modify_event (b->number);
7476 error (_("No breakpoint number %d."), bptnum);
7479 /* Clear the ignore counts of all breakpoints. */
7481 breakpoint_clear_ignore_counts (void)
7483 struct breakpoint *b;
7486 b->ignore_count = 0;
7489 /* Command to set ignore-count of breakpoint N to COUNT. */
7492 ignore_command (char *args, int from_tty)
7498 error_no_arg (_("a breakpoint number"));
7500 num = get_number (&p);
7502 error (_("bad breakpoint number: '%s'"), args);
7504 error (_("Second argument (specified ignore-count) is missing."));
7506 set_ignore_count (num,
7507 longest_to_int (value_as_long (parse_and_eval (p))),
7510 printf_filtered ("\n");
7513 /* Call FUNCTION on each of the breakpoints
7514 whose numbers are given in ARGS. */
7517 map_breakpoint_numbers (char *args, void (*function) (struct breakpoint *))
7522 struct breakpoint *b, *tmp;
7526 error_no_arg (_("one or more breakpoint numbers"));
7533 num = get_number_or_range (&p1);
7536 warning (_("bad breakpoint number at or near '%s'"), p);
7540 ALL_BREAKPOINTS_SAFE (b, tmp)
7541 if (b->number == num)
7543 struct breakpoint *related_breakpoint = b->related_breakpoint;
7546 if (related_breakpoint)
7547 function (related_breakpoint);
7551 printf_unfiltered (_("No breakpoint number %d.\n"), num);
7557 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
7558 If from_tty is nonzero, it prints a message to that effect,
7559 which ends with a period (no newline). */
7562 disable_breakpoint (struct breakpoint *bpt)
7564 /* Never disable a watchpoint scope breakpoint; we want to
7565 hit them when we leave scope so we can delete both the
7566 watchpoint and its scope breakpoint at that time. */
7567 if (bpt->type == bp_watchpoint_scope)
7570 /* You can't disable permanent breakpoints. */
7571 if (bpt->enable_state == bp_permanent)
7574 bpt->enable_state = bp_disabled;
7576 check_duplicates (bpt);
7578 if (deprecated_modify_breakpoint_hook)
7579 deprecated_modify_breakpoint_hook (bpt);
7580 breakpoint_modify_event (bpt->number);
7584 disable_command (char *args, int from_tty)
7586 struct breakpoint *bpt;
7588 ALL_BREAKPOINTS (bpt)
7592 warning (_("attempted to disable apparently deleted breakpoint #%d?"),
7597 case bp_catch_unload:
7599 case bp_catch_vfork:
7601 case bp_catch_catch:
7602 case bp_catch_throw:
7603 case bp_hardware_breakpoint:
7605 case bp_hardware_watchpoint:
7606 case bp_read_watchpoint:
7607 case bp_access_watchpoint:
7608 disable_breakpoint (bpt);
7613 map_breakpoint_numbers (args, disable_breakpoint);
7617 do_enable_breakpoint (struct breakpoint *bpt, enum bpdisp disposition)
7619 int target_resources_ok, other_type_used;
7622 if (bpt->type == bp_hardware_breakpoint)
7625 i = hw_breakpoint_used_count ();
7626 target_resources_ok =
7627 TARGET_CAN_USE_HARDWARE_WATCHPOINT (bp_hardware_breakpoint,
7629 if (target_resources_ok == 0)
7630 error (_("No hardware breakpoint support in the target."));
7631 else if (target_resources_ok < 0)
7632 error (_("Hardware breakpoints used exceeds limit."));
7637 if (bpt->enable_state != bp_enabled)
7639 /* When enabling a pending breakpoint, we need to check if the breakpoint
7640 is resolvable since shared libraries could have been loaded
7641 after the breakpoint was disabled. */
7642 breakpoints_changed ();
7643 if (resolve_pending_breakpoint (bpt) == GDB_RC_OK)
7645 delete_breakpoint (bpt);
7648 bpt->enable_state = bp_enabled;
7649 bpt->disposition = disposition;
7652 else /* Not a pending breakpoint. */
7654 if (bpt->enable_state != bp_permanent)
7655 bpt->enable_state = bp_enabled;
7656 bpt->disposition = disposition;
7657 check_duplicates (bpt);
7658 breakpoints_changed ();
7660 if (bpt->type == bp_watchpoint ||
7661 bpt->type == bp_hardware_watchpoint ||
7662 bpt->type == bp_read_watchpoint ||
7663 bpt->type == bp_access_watchpoint)
7665 struct frame_id saved_frame_id;
7667 saved_frame_id = get_frame_id (get_selected_frame (NULL));
7668 if (bpt->exp_valid_block != NULL)
7670 struct frame_info *fr =
7671 fr = frame_find_by_id (bpt->watchpoint_frame);
7674 printf_filtered (_("\
7675 Cannot enable watchpoint %d because the block in which its expression\n\
7676 is valid is not currently in scope.\n"), bpt->number);
7677 bpt->enable_state = bp_disabled;
7683 value_free (bpt->val);
7684 mark = value_mark ();
7685 bpt->val = evaluate_expression (bpt->exp);
7686 release_value (bpt->val);
7687 if (value_lazy (bpt->val))
7688 value_fetch_lazy (bpt->val);
7690 if (bpt->type == bp_hardware_watchpoint ||
7691 bpt->type == bp_read_watchpoint ||
7692 bpt->type == bp_access_watchpoint)
7694 int i = hw_watchpoint_used_count (bpt->type, &other_type_used);
7695 int mem_cnt = can_use_hardware_watchpoint (bpt->val);
7697 /* Hack around 'unused var' error for some targets here */
7698 (void) mem_cnt, (void) i;
7699 target_resources_ok = TARGET_CAN_USE_HARDWARE_WATCHPOINT (
7700 bpt->type, i + mem_cnt, other_type_used);
7701 /* we can consider of type is bp_hardware_watchpoint, convert to
7702 bp_watchpoint in the following condition */
7703 if (target_resources_ok < 0)
7705 printf_filtered (_("\
7706 Cannot enable watchpoint %d because target watch resources\n\
7707 have been allocated for other watchpoints.\n"), bpt->number);
7708 bpt->enable_state = bp_disabled;
7709 value_free_to_mark (mark);
7714 select_frame (frame_find_by_id (saved_frame_id));
7715 value_free_to_mark (mark);
7719 if (deprecated_modify_breakpoint_hook)
7720 deprecated_modify_breakpoint_hook (bpt);
7721 breakpoint_modify_event (bpt->number);
7725 enable_breakpoint (struct breakpoint *bpt)
7727 do_enable_breakpoint (bpt, bpt->disposition);
7730 /* The enable command enables the specified breakpoints (or all defined
7731 breakpoints) so they once again become (or continue to be) effective
7732 in stopping the inferior. */
7735 enable_command (char *args, int from_tty)
7737 struct breakpoint *bpt;
7739 ALL_BREAKPOINTS (bpt)
7743 warning (_("attempted to enable apparently deleted breakpoint #%d?"),
7748 case bp_catch_unload:
7750 case bp_catch_vfork:
7752 case bp_catch_catch:
7753 case bp_catch_throw:
7754 case bp_hardware_breakpoint:
7756 case bp_hardware_watchpoint:
7757 case bp_read_watchpoint:
7758 case bp_access_watchpoint:
7759 enable_breakpoint (bpt);
7764 map_breakpoint_numbers (args, enable_breakpoint);
7768 enable_once_breakpoint (struct breakpoint *bpt)
7770 do_enable_breakpoint (bpt, disp_disable);
7774 enable_once_command (char *args, int from_tty)
7776 map_breakpoint_numbers (args, enable_once_breakpoint);
7780 enable_delete_breakpoint (struct breakpoint *bpt)
7782 do_enable_breakpoint (bpt, disp_del);
7786 enable_delete_command (char *args, int from_tty)
7788 map_breakpoint_numbers (args, enable_delete_breakpoint);
7792 set_breakpoint_cmd (char *args, int from_tty)
7797 show_breakpoint_cmd (char *args, int from_tty)
7801 /* Use default_breakpoint_'s, or nothing if they aren't valid. */
7803 struct symtabs_and_lines
7804 decode_line_spec_1 (char *string, int funfirstline)
7806 struct symtabs_and_lines sals;
7808 error (_("Empty line specification."));
7809 if (default_breakpoint_valid)
7810 sals = decode_line_1 (&string, funfirstline,
7811 default_breakpoint_symtab,
7812 default_breakpoint_line,
7813 (char ***) NULL, NULL);
7815 sals = decode_line_1 (&string, funfirstline,
7816 (struct symtab *) NULL, 0, (char ***) NULL, NULL);
7818 error (_("Junk at end of line specification: %s"), string);
7822 /* Create and insert a raw software breakpoint at PC. Return an
7823 identifier, which should be used to remove the breakpoint later.
7824 In general, places which call this should be using something on the
7825 breakpoint chain instead; this function should be eliminated
7829 deprecated_insert_raw_breakpoint (CORE_ADDR pc)
7831 struct bp_target_info *bp_tgt;
7833 bp_tgt = xmalloc (sizeof (struct bp_target_info));
7834 memset (bp_tgt, 0, sizeof (struct bp_target_info));
7836 bp_tgt->placed_address = pc;
7837 if (target_insert_breakpoint (bp_tgt) != 0)
7839 /* Could not insert the breakpoint. */
7847 /* Remove a breakpoint BP inserted by deprecated_insert_raw_breakpoint. */
7850 deprecated_remove_raw_breakpoint (void *bp)
7852 struct bp_target_info *bp_tgt = bp;
7855 ret = target_remove_breakpoint (bp_tgt);
7861 /* One (or perhaps two) breakpoints used for software single stepping. */
7863 static void *single_step_breakpoints[2];
7865 /* Create and insert a breakpoint for software single step. */
7868 insert_single_step_breakpoint (CORE_ADDR next_pc)
7872 if (single_step_breakpoints[0] == NULL)
7873 bpt_p = &single_step_breakpoints[0];
7876 gdb_assert (single_step_breakpoints[1] == NULL);
7877 bpt_p = &single_step_breakpoints[1];
7880 /* NOTE drow/2006-04-11: A future improvement to this function would be
7881 to only create the breakpoints once, and actually put them on the
7882 breakpoint chain. That would let us use set_raw_breakpoint. We could
7883 adjust the addresses each time they were needed. Doing this requires
7884 corresponding changes elsewhere where single step breakpoints are
7885 handled, however. So, for now, we use this. */
7887 *bpt_p = deprecated_insert_raw_breakpoint (next_pc);
7889 error (_("Could not insert single-step breakpoint at 0x%s"),
7890 paddr_nz (next_pc));
7893 /* Remove and delete any breakpoints used for software single step. */
7896 remove_single_step_breakpoints (void)
7898 gdb_assert (single_step_breakpoints[0] != NULL);
7900 /* See insert_single_step_breakpoint for more about this deprecated
7902 deprecated_remove_raw_breakpoint (single_step_breakpoints[0]);
7903 single_step_breakpoints[0] = NULL;
7905 if (single_step_breakpoints[1] != NULL)
7907 deprecated_remove_raw_breakpoint (single_step_breakpoints[1]);
7908 single_step_breakpoints[1] = NULL;
7913 /* This help string is used for the break, hbreak, tbreak and thbreak commands.
7914 It is defined as a macro to prevent duplication.
7915 COMMAND should be a string constant containing the name of the command. */
7916 #define BREAK_ARGS_HELP(command) \
7917 command" [LOCATION] [thread THREADNUM] [if CONDITION]\n\
7918 LOCATION may be a line number, function name, or \"*\" and an address.\n\
7919 If a line number is specified, break at start of code for that line.\n\
7920 If a function is specified, break at start of code for that function.\n\
7921 If an address is specified, break at that exact address.\n\
7922 With no LOCATION, uses current execution address of selected stack frame.\n\
7923 This is useful for breaking on return to a stack frame.\n\
7925 THREADNUM is the number from \"info threads\".\n\
7926 CONDITION is a boolean expression.\n\
7928 Multiple breakpoints at one place are permitted, and useful if conditional.\n\
7930 Do \"help breakpoints\" for info on other commands dealing with breakpoints."
7933 _initialize_breakpoint (void)
7935 static struct cmd_list_element *breakpoint_set_cmdlist;
7936 static struct cmd_list_element *breakpoint_show_cmdlist;
7937 struct cmd_list_element *c;
7939 observer_attach_solib_unloaded (disable_breakpoints_in_unloaded_shlib);
7941 breakpoint_chain = 0;
7942 /* Don't bother to call set_breakpoint_count. $bpnum isn't useful
7943 before a breakpoint is set. */
7944 breakpoint_count = 0;
7946 add_com ("ignore", class_breakpoint, ignore_command, _("\
7947 Set ignore-count of breakpoint number N to COUNT.\n\
7948 Usage is `ignore N COUNT'."));
7950 add_com_alias ("bc", "ignore", class_breakpoint, 1);
7952 add_com ("commands", class_breakpoint, commands_command, _("\
7953 Set commands to be executed when a breakpoint is hit.\n\
7954 Give breakpoint number as argument after \"commands\".\n\
7955 With no argument, the targeted breakpoint is the last one set.\n\
7956 The commands themselves follow starting on the next line.\n\
7957 Type a line containing \"end\" to indicate the end of them.\n\
7958 Give \"silent\" as the first line to make the breakpoint silent;\n\
7959 then no output is printed when it is hit, except what the commands print."));
7961 add_com ("condition", class_breakpoint, condition_command, _("\
7962 Specify breakpoint number N to break only if COND is true.\n\
7963 Usage is `condition N COND', where N is an integer and COND is an\n\
7964 expression to be evaluated whenever breakpoint N is reached."));
7966 c = add_com ("tbreak", class_breakpoint, tbreak_command, _("\
7967 Set a temporary breakpoint.\n\
7968 Like \"break\" except the breakpoint is only temporary,\n\
7969 so it will be deleted when hit. Equivalent to \"break\" followed\n\
7970 by using \"enable delete\" on the breakpoint number.\n\
7972 BREAK_ARGS_HELP ("tbreak")));
7973 set_cmd_completer (c, location_completer);
7975 c = add_com ("hbreak", class_breakpoint, hbreak_command, _("\
7976 Set a hardware assisted breakpoint.\n\
7977 Like \"break\" except the breakpoint requires hardware support,\n\
7978 some target hardware may not have this support.\n\
7980 BREAK_ARGS_HELP ("hbreak")));
7981 set_cmd_completer (c, location_completer);
7983 c = add_com ("thbreak", class_breakpoint, thbreak_command, _("\
7984 Set a temporary hardware assisted breakpoint.\n\
7985 Like \"hbreak\" except the breakpoint is only temporary,\n\
7986 so it will be deleted when hit.\n\
7988 BREAK_ARGS_HELP ("thbreak")));
7989 set_cmd_completer (c, location_completer);
7991 add_prefix_cmd ("enable", class_breakpoint, enable_command, _("\
7992 Enable some breakpoints.\n\
7993 Give breakpoint numbers (separated by spaces) as arguments.\n\
7994 With no subcommand, breakpoints are enabled until you command otherwise.\n\
7995 This is used to cancel the effect of the \"disable\" command.\n\
7996 With a subcommand you can enable temporarily."),
7997 &enablelist, "enable ", 1, &cmdlist);
7999 add_com ("ab", class_breakpoint, enable_command, _("\
8000 Enable some breakpoints.\n\
8001 Give breakpoint numbers (separated by spaces) as arguments.\n\
8002 With no subcommand, breakpoints are enabled until you command otherwise.\n\
8003 This is used to cancel the effect of the \"disable\" command.\n\
8004 With a subcommand you can enable temporarily."));
8006 add_com_alias ("en", "enable", class_breakpoint, 1);
8008 add_abbrev_prefix_cmd ("breakpoints", class_breakpoint, enable_command, _("\
8009 Enable some breakpoints.\n\
8010 Give breakpoint numbers (separated by spaces) as arguments.\n\
8011 This is used to cancel the effect of the \"disable\" command.\n\
8012 May be abbreviated to simply \"enable\".\n"),
8013 &enablebreaklist, "enable breakpoints ", 1, &enablelist);
8015 add_cmd ("once", no_class, enable_once_command, _("\
8016 Enable breakpoints for one hit. Give breakpoint numbers.\n\
8017 If a breakpoint is hit while enabled in this fashion, it becomes disabled."),
8020 add_cmd ("delete", no_class, enable_delete_command, _("\
8021 Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
8022 If a breakpoint is hit while enabled in this fashion, it is deleted."),
8025 add_cmd ("delete", no_class, enable_delete_command, _("\
8026 Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
8027 If a breakpoint is hit while enabled in this fashion, it is deleted."),
8030 add_cmd ("once", no_class, enable_once_command, _("\
8031 Enable breakpoints for one hit. Give breakpoint numbers.\n\
8032 If a breakpoint is hit while enabled in this fashion, it becomes disabled."),
8035 add_prefix_cmd ("disable", class_breakpoint, disable_command, _("\
8036 Disable some breakpoints.\n\
8037 Arguments are breakpoint numbers with spaces in between.\n\
8038 To disable all breakpoints, give no argument.\n\
8039 A disabled breakpoint is not forgotten, but has no effect until reenabled."),
8040 &disablelist, "disable ", 1, &cmdlist);
8041 add_com_alias ("dis", "disable", class_breakpoint, 1);
8042 add_com_alias ("disa", "disable", class_breakpoint, 1);
8044 add_com ("sb", class_breakpoint, disable_command, _("\
8045 Disable some breakpoints.\n\
8046 Arguments are breakpoint numbers with spaces in between.\n\
8047 To disable all breakpoints, give no argument.\n\
8048 A disabled breakpoint is not forgotten, but has no effect until reenabled."));
8050 add_cmd ("breakpoints", class_alias, disable_command, _("\
8051 Disable some breakpoints.\n\
8052 Arguments are breakpoint numbers with spaces in between.\n\
8053 To disable all breakpoints, give no argument.\n\
8054 A disabled breakpoint is not forgotten, but has no effect until reenabled.\n\
8055 This command may be abbreviated \"disable\"."),
8058 add_prefix_cmd ("delete", class_breakpoint, delete_command, _("\
8059 Delete some breakpoints or auto-display expressions.\n\
8060 Arguments are breakpoint numbers with spaces in between.\n\
8061 To delete all breakpoints, give no argument.\n\
8063 Also a prefix command for deletion of other GDB objects.\n\
8064 The \"unset\" command is also an alias for \"delete\"."),
8065 &deletelist, "delete ", 1, &cmdlist);
8066 add_com_alias ("d", "delete", class_breakpoint, 1);
8067 add_com_alias ("del", "delete", class_breakpoint, 1);
8069 add_com ("db", class_breakpoint, delete_command, _("\
8070 Delete some breakpoints.\n\
8071 Arguments are breakpoint numbers with spaces in between.\n\
8072 To delete all breakpoints, give no argument.\n"));
8074 add_cmd ("breakpoints", class_alias, delete_command, _("\
8075 Delete some breakpoints or auto-display expressions.\n\
8076 Arguments are breakpoint numbers with spaces in between.\n\
8077 To delete all breakpoints, give no argument.\n\
8078 This command may be abbreviated \"delete\"."),
8081 add_com ("clear", class_breakpoint, clear_command, _("\
8082 Clear breakpoint at specified line or function.\n\
8083 Argument may be line number, function name, or \"*\" and an address.\n\
8084 If line number is specified, all breakpoints in that line are cleared.\n\
8085 If function is specified, breakpoints at beginning of function are cleared.\n\
8086 If an address is specified, breakpoints at that address are cleared.\n\
8088 With no argument, clears all breakpoints in the line that the selected frame\n\
8091 See also the \"delete\" command which clears breakpoints by number."));
8093 c = add_com ("break", class_breakpoint, break_command, _("\
8094 Set breakpoint at specified line or function.\n"
8095 BREAK_ARGS_HELP ("break")));
8096 set_cmd_completer (c, location_completer);
8098 add_com_alias ("b", "break", class_run, 1);
8099 add_com_alias ("br", "break", class_run, 1);
8100 add_com_alias ("bre", "break", class_run, 1);
8101 add_com_alias ("brea", "break", class_run, 1);
8105 add_com_alias ("ba", "break", class_breakpoint, 1);
8106 add_com_alias ("bu", "ubreak", class_breakpoint, 1);
8111 add_abbrev_prefix_cmd ("stop", class_breakpoint, stop_command, _("\
8112 Break in function/address or break at a line in the current file."),
8113 &stoplist, "stop ", 1, &cmdlist);
8114 add_cmd ("in", class_breakpoint, stopin_command,
8115 _("Break in function or address."), &stoplist);
8116 add_cmd ("at", class_breakpoint, stopat_command,
8117 _("Break at a line in the current file."), &stoplist);
8118 add_com ("status", class_info, breakpoints_info, _("\
8119 Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
8120 The \"Type\" column indicates one of:\n\
8121 \tbreakpoint - normal breakpoint\n\
8122 \twatchpoint - watchpoint\n\
8123 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
8124 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
8125 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
8126 address and file/line number respectively.\n\
8128 Convenience variable \"$_\" and default examine address for \"x\"\n\
8129 are set to the address of the last breakpoint listed.\n\n\
8130 Convenience variable \"$bpnum\" contains the number of the last\n\
8134 add_info ("breakpoints", breakpoints_info, _("\
8135 Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
8136 The \"Type\" column indicates one of:\n\
8137 \tbreakpoint - normal breakpoint\n\
8138 \twatchpoint - watchpoint\n\
8139 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
8140 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
8141 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
8142 address and file/line number respectively.\n\
8144 Convenience variable \"$_\" and default examine address for \"x\"\n\
8145 are set to the address of the last breakpoint listed.\n\n\
8146 Convenience variable \"$bpnum\" contains the number of the last\n\
8150 add_com ("lb", class_breakpoint, breakpoints_info, _("\
8151 Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
8152 The \"Type\" column indicates one of:\n\
8153 \tbreakpoint - normal breakpoint\n\
8154 \twatchpoint - watchpoint\n\
8155 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
8156 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
8157 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
8158 address and file/line number respectively.\n\
8160 Convenience variable \"$_\" and default examine address for \"x\"\n\
8161 are set to the address of the last breakpoint listed.\n\n\
8162 Convenience variable \"$bpnum\" contains the number of the last\n\
8165 add_cmd ("breakpoints", class_maintenance, maintenance_info_breakpoints, _("\
8166 Status of all breakpoints, or breakpoint number NUMBER.\n\
8167 The \"Type\" column indicates one of:\n\
8168 \tbreakpoint - normal breakpoint\n\
8169 \twatchpoint - watchpoint\n\
8170 \tlongjmp - internal breakpoint used to step through longjmp()\n\
8171 \tlongjmp resume - internal breakpoint at the target of longjmp()\n\
8172 \tuntil - internal breakpoint used by the \"until\" command\n\
8173 \tfinish - internal breakpoint used by the \"finish\" command\n\
8174 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
8175 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
8176 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
8177 address and file/line number respectively.\n\
8179 Convenience variable \"$_\" and default examine address for \"x\"\n\
8180 are set to the address of the last breakpoint listed.\n\
8182 Convenience variable \"$bpnum\" contains the number of the last\n\
8184 &maintenanceinfolist);
8186 add_com ("catch", class_breakpoint, catch_command, _("\
8187 Set catchpoints to catch events.\n\
8188 Raised signals may be caught:\n\
8189 \tcatch signal - all signals\n\
8190 \tcatch signal <signame> - a particular signal\n\
8191 Raised exceptions may be caught:\n\
8192 \tcatch throw - all exceptions, when thrown\n\
8193 \tcatch throw <exceptname> - a particular exception, when thrown\n\
8194 \tcatch catch - all exceptions, when caught\n\
8195 \tcatch catch <exceptname> - a particular exception, when caught\n\
8196 Thread or process events may be caught:\n\
8197 \tcatch thread_start - any threads, just after creation\n\
8198 \tcatch thread_exit - any threads, just before expiration\n\
8199 \tcatch thread_join - any threads, just after joins\n\
8200 Process events may be caught:\n\
8201 \tcatch start - any processes, just after creation\n\
8202 \tcatch exit - any processes, just before expiration\n\
8203 \tcatch fork - calls to fork()\n\
8204 \tcatch vfork - calls to vfork()\n\
8205 \tcatch exec - calls to exec()\n\
8206 Dynamically-linked library events may be caught:\n\
8207 \tcatch load - loads of any library\n\
8208 \tcatch load <libname> - loads of a particular library\n\
8209 \tcatch unload - unloads of any library\n\
8210 \tcatch unload <libname> - unloads of a particular library\n\
8211 The act of your program's execution stopping may also be caught:\n\
8213 C++ exceptions may be caught:\n\
8214 \tcatch throw - all exceptions, when thrown\n\
8215 \tcatch catch - all exceptions, when caught\n\
8216 Ada exceptions may be caught:\n\
8217 \tcatch exception - all exceptions, when raised\n\
8218 \tcatch exception <name> - a particular exception, when raised\n\
8219 \tcatch exception unhandled - all unhandled exceptions, when raised\n\
8220 \tcatch assert - all failed assertions, when raised\n\
8222 Do \"help set follow-fork-mode\" for info on debugging your program\n\
8223 after a fork or vfork is caught.\n\n\
8224 Do \"help breakpoints\" for info on other commands dealing with breakpoints."));
8226 add_com ("tcatch", class_breakpoint, tcatch_command, _("\
8227 Set temporary catchpoints to catch events.\n\
8228 Args like \"catch\" command.\n\
8229 Like \"catch\" except the catchpoint is only temporary,\n\
8230 so it will be deleted when hit. Equivalent to \"catch\" followed\n\
8231 by using \"enable delete\" on the catchpoint number."));
8233 c = add_com ("watch", class_breakpoint, watch_command, _("\
8234 Set a watchpoint for an expression.\n\
8235 A watchpoint stops execution of your program whenever the value of\n\
8236 an expression changes."));
8237 set_cmd_completer (c, location_completer);
8239 c = add_com ("rwatch", class_breakpoint, rwatch_command, _("\
8240 Set a read watchpoint for an expression.\n\
8241 A watchpoint stops execution of your program whenever the value of\n\
8242 an expression is read."));
8243 set_cmd_completer (c, location_completer);
8245 c = add_com ("awatch", class_breakpoint, awatch_command, _("\
8246 Set a watchpoint for an expression.\n\
8247 A watchpoint stops execution of your program whenever the value of\n\
8248 an expression is either read or written."));
8249 set_cmd_completer (c, location_completer);
8251 add_info ("watchpoints", breakpoints_info,
8252 _("Synonym for ``info breakpoints''."));
8255 /* XXX: cagney/2005-02-23: This should be a boolean, and should
8256 respond to changes - contrary to the description. */
8257 add_setshow_zinteger_cmd ("can-use-hw-watchpoints", class_support,
8258 &can_use_hw_watchpoints, _("\
8259 Set debugger's willingness to use watchpoint hardware."), _("\
8260 Show debugger's willingness to use watchpoint hardware."), _("\
8261 If zero, gdb will not use hardware for new watchpoints, even if\n\
8262 such is available. (However, any hardware watchpoints that were\n\
8263 created before setting this to nonzero, will continue to use watchpoint\n\
8266 show_can_use_hw_watchpoints,
8267 &setlist, &showlist);
8269 can_use_hw_watchpoints = 1;
8271 add_prefix_cmd ("breakpoint", class_maintenance, set_breakpoint_cmd, _("\
8272 Breakpoint specific settings\n\
8273 Configure various breakpoint-specific variables such as\n\
8274 pending breakpoint behavior"),
8275 &breakpoint_set_cmdlist, "set breakpoint ",
8276 0/*allow-unknown*/, &setlist);
8277 add_prefix_cmd ("breakpoint", class_maintenance, show_breakpoint_cmd, _("\
8278 Breakpoint specific settings\n\
8279 Configure various breakpoint-specific variables such as\n\
8280 pending breakpoint behavior"),
8281 &breakpoint_show_cmdlist, "show breakpoint ",
8282 0/*allow-unknown*/, &showlist);
8284 add_setshow_auto_boolean_cmd ("pending", no_class,
8285 &pending_break_support, _("\
8286 Set debugger's behavior regarding pending breakpoints."), _("\
8287 Show debugger's behavior regarding pending breakpoints."), _("\
8288 If on, an unrecognized breakpoint location will cause gdb to create a\n\
8289 pending breakpoint. If off, an unrecognized breakpoint location results in\n\
8290 an error. If auto, an unrecognized breakpoint location results in a\n\
8291 user-query to see if a pending breakpoint should be created."),
8293 show_pending_break_support,
8294 &breakpoint_set_cmdlist,
8295 &breakpoint_show_cmdlist);
8297 pending_break_support = AUTO_BOOLEAN_AUTO;
8299 add_setshow_boolean_cmd ("auto-hw", no_class,
8300 &automatic_hardware_breakpoints, _("\
8301 Set automatic usage of hardware breakpoints."), _("\
8302 Show automatic usage of hardware breakpoints."), _("\
8303 If set, the debugger will automatically use hardware breakpoints for\n\
8304 breakpoints set with \"break\" but falling in read-only memory. If not set,\n\
8305 a warning will be emitted for such breakpoints."),
8307 show_automatic_hardware_breakpoints,
8308 &breakpoint_set_cmdlist,
8309 &breakpoint_show_cmdlist);
8311 automatic_hardware_breakpoints = 1;