1 /* Everything about breakpoints, for GDB.
3 Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994,
4 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004
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., 59 Temple Place - Suite 330,
22 Boston, MA 02111-1307, 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"
53 #include "gdb-events.h"
55 /* Prototypes for local functions. */
57 static void until_break_command_continuation (struct continuation_arg *arg);
59 static void catch_command_1 (char *, int, int);
61 static void enable_delete_command (char *, int);
63 static void enable_delete_breakpoint (struct breakpoint *);
65 static void enable_once_command (char *, int);
67 static void enable_once_breakpoint (struct breakpoint *);
69 static void disable_command (char *, int);
71 static void enable_command (char *, int);
73 static void map_breakpoint_numbers (char *, void (*)(struct breakpoint *));
75 static void ignore_command (char *, int);
77 static int breakpoint_re_set_one (void *);
79 static void clear_command (char *, int);
81 static void catch_command (char *, int);
83 static void watch_command (char *, int);
85 static int can_use_hardware_watchpoint (struct value *);
87 extern void break_at_finish_command (char *, int);
88 extern void break_at_finish_at_depth_command (char *, int);
90 extern void tbreak_at_finish_command (char *, int);
92 static int break_command_1 (char *, int, int, struct breakpoint *);
94 static void mention (struct breakpoint *);
96 struct breakpoint *set_raw_breakpoint (struct symtab_and_line, enum bptype);
98 static void check_duplicates (struct breakpoint *);
100 static void breakpoint_adjustment_warning (CORE_ADDR, CORE_ADDR, int, int);
102 static CORE_ADDR adjust_breakpoint_address (CORE_ADDR bpaddr,
105 static void describe_other_breakpoints (CORE_ADDR, asection *);
107 static void breakpoints_info (char *, int);
109 static void breakpoint_1 (int, int);
111 static bpstat bpstat_alloc (struct breakpoint *, bpstat);
113 static int breakpoint_cond_eval (void *);
115 static void cleanup_executing_breakpoints (void *);
117 static void commands_command (char *, int);
119 static void condition_command (char *, int);
121 static int get_number_trailer (char **, int);
123 static int do_captured_parse_breakpoint (struct ui_out *, void *);
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 break_at_finish_at_depth_command_1 (char *arg,
183 int flag, int from_tty);
185 static void break_at_finish_command_1 (char *arg, int flag, int from_tty);
187 static void stop_command (char *arg, int from_tty);
189 static void stopin_command (char *arg, int from_tty);
191 static void stopat_command (char *arg, int from_tty);
193 static char *ep_find_event_name_end (char *arg);
195 static char *ep_parse_optional_if_clause (char **arg);
197 static char *ep_parse_optional_filename (char **arg);
199 static void create_exception_catchpoint (int tempflag, char *cond_string,
200 enum exception_event_kind ex_event,
201 struct symtab_and_line *sal);
203 static void catch_exception_command_1 (enum exception_event_kind ex_event,
204 char *arg, int tempflag, int from_tty);
206 static void tcatch_command (char *arg, int from_tty);
208 static void ep_skip_leading_whitespace (char **s);
210 /* Prototypes for exported functions. */
212 /* If FALSE, gdb will not use hardware support for watchpoints, even
213 if such is available. */
214 static int can_use_hw_watchpoints;
216 /* If AUTO_BOOLEAN_FALSE, gdb will not attempt to create pending breakpoints.
217 If AUTO_BOOLEAN_TRUE, gdb will automatically create pending breakpoints
218 for unrecognized breakpoint locations.
219 If AUTO_BOOLEAN_AUTO, gdb will query when breakpoints are unrecognized. */
220 static enum auto_boolean pending_break_support;
222 void _initialize_breakpoint (void);
224 extern int addressprint; /* Print machine addresses? */
226 /* Are we executing breakpoint commands? */
227 static int executing_breakpoint_commands;
229 /* Are overlay event breakpoints enabled? */
230 static int overlay_events_enabled;
232 /* Walk the following statement or block through all breakpoints.
233 ALL_BREAKPOINTS_SAFE does so even if the statment deletes the current
236 #define ALL_BREAKPOINTS(B) for (B = breakpoint_chain; B; B = B->next)
238 #define ALL_BREAKPOINTS_SAFE(B,TMP) \
239 for (B = breakpoint_chain; \
240 B ? (TMP=B->next, 1): 0; \
243 /* Similar iterators for the low-level breakpoints. */
245 #define ALL_BP_LOCATIONS(B) for (B = bp_location_chain; B; B = B->next)
247 #define ALL_BP_LOCATIONS_SAFE(B,TMP) \
248 for (B = bp_location_chain; \
249 B ? (TMP=B->next, 1): 0; \
252 /* True if breakpoint hit counts should be displayed in breakpoint info. */
254 int show_breakpoint_hit_counts = 1;
256 /* Chains of all breakpoints defined. */
258 struct breakpoint *breakpoint_chain;
260 struct bp_location *bp_location_chain;
262 /* Number of last breakpoint made. */
264 int breakpoint_count;
266 /* Pointer to current exception event record */
267 static struct exception_event_record *current_exception_event;
269 /* Indicator of whether exception catchpoints should be nuked between
270 runs of a program. */
271 int deprecated_exception_catchpoints_are_fragile = 0;
273 /* Indicator of when exception catchpoints set-up should be
274 reinitialized -- e.g. when program is re-run. */
275 int deprecated_exception_support_initialized = 0;
277 /* This function returns a pointer to the string representation of the
278 pathname of the dynamically-linked library that has just been
281 This function must be used only when SOLIB_HAVE_LOAD_EVENT is TRUE,
282 or undefined results are guaranteed.
284 This string's contents are only valid immediately after the
285 inferior has stopped in the dynamic linker hook, and becomes
286 invalid as soon as the inferior is continued. Clients should make
287 a copy of this string if they wish to continue the inferior and
288 then access the string. */
290 #ifndef SOLIB_LOADED_LIBRARY_PATHNAME
291 #define SOLIB_LOADED_LIBRARY_PATHNAME(pid) ""
294 /* This function returns a pointer to the string representation of the
295 pathname of the dynamically-linked library that has just been
298 This function must be used only when SOLIB_HAVE_UNLOAD_EVENT is
299 TRUE, or undefined results are guaranteed.
301 This string's contents are only valid immediately after the
302 inferior has stopped in the dynamic linker hook, and becomes
303 invalid as soon as the inferior is continued. Clients should make
304 a copy of this string if they wish to continue the inferior and
305 then access the string. */
307 #ifndef SOLIB_UNLOADED_LIBRARY_PATHNAME
308 #define SOLIB_UNLOADED_LIBRARY_PATHNAME(pid) ""
311 /* This function is called by the "catch load" command. It allows the
312 debugger to be notified by the dynamic linker when a specified
313 library file (or any library file, if filename is NULL) is loaded. */
315 #ifndef SOLIB_CREATE_CATCH_LOAD_HOOK
316 #define SOLIB_CREATE_CATCH_LOAD_HOOK(pid,tempflag,filename,cond_string) \
317 error ("catch of library loads not yet implemented on this platform")
320 /* This function is called by the "catch unload" command. It allows
321 the debugger to be notified by the dynamic linker when a specified
322 library file (or any library file, if filename is NULL) is
325 #ifndef SOLIB_CREATE_CATCH_UNLOAD_HOOK
326 #define SOLIB_CREATE_CATCH_UNLOAD_HOOK(pid,tempflag,filename,cond_string) \
327 error ("catch of library unloads not yet implemented on this platform")
330 /* Return whether a breakpoint is an active enabled breakpoint. */
332 breakpoint_enabled (struct breakpoint *b)
334 return (b->enable_state == bp_enabled && !b->pending);
337 /* Set breakpoint count to NUM. */
340 set_breakpoint_count (int num)
342 breakpoint_count = num;
343 set_internalvar (lookup_internalvar ("bpnum"),
344 value_from_longest (builtin_type_int, (LONGEST) num));
347 /* Used in run_command to zero the hit count when a new run starts. */
350 clear_breakpoint_hit_counts (void)
352 struct breakpoint *b;
358 /* Default address, symtab and line to put a breakpoint at
359 for "break" command with no arg.
360 if default_breakpoint_valid is zero, the other three are
361 not valid, and "break" with no arg is an error.
363 This set by print_stack_frame, which calls set_default_breakpoint. */
365 int default_breakpoint_valid;
366 CORE_ADDR default_breakpoint_address;
367 struct symtab *default_breakpoint_symtab;
368 int default_breakpoint_line;
370 /* *PP is a string denoting a breakpoint. Get the number of the breakpoint.
371 Advance *PP after the string and any trailing whitespace.
373 Currently the string can either be a number or "$" followed by the name
374 of a convenience variable. Making it an expression wouldn't work well
375 for map_breakpoint_numbers (e.g. "4 + 5 + 6").
377 TRAILER is a character which can be found after the number; most
378 commonly this is `-'. If you don't want a trailer, use \0. */
380 get_number_trailer (char **pp, int trailer)
382 int retval = 0; /* default */
386 /* Empty line means refer to the last breakpoint. */
387 return breakpoint_count;
390 /* Make a copy of the name, so we can null-terminate it
391 to pass to lookup_internalvar(). */
396 while (isalnum (*p) || *p == '_')
398 varname = (char *) alloca (p - start + 1);
399 strncpy (varname, start, p - start);
400 varname[p - start] = '\0';
401 val = value_of_internalvar (lookup_internalvar (varname));
402 if (TYPE_CODE (VALUE_TYPE (val)) == TYPE_CODE_INT)
403 retval = (int) value_as_long (val);
406 printf_filtered ("Convenience variable must have integer value.\n");
414 while (*p >= '0' && *p <= '9')
417 /* There is no number here. (e.g. "cond a == b"). */
419 /* Skip non-numeric token */
420 while (*p && !isspace((int) *p))
422 /* Return zero, which caller must interpret as error. */
428 if (!(isspace (*p) || *p == '\0' || *p == trailer))
430 /* Trailing junk: return 0 and let caller print error msg. */
431 while (!(isspace (*p) || *p == '\0' || *p == trailer))
442 /* Like get_number_trailer, but don't allow a trailer. */
444 get_number (char **pp)
446 return get_number_trailer (pp, '\0');
449 /* Parse a number or a range.
450 * A number will be of the form handled by get_number.
451 * A range will be of the form <number1> - <number2>, and
452 * will represent all the integers between number1 and number2,
455 * While processing a range, this fuction is called iteratively;
456 * At each call it will return the next value in the range.
458 * At the beginning of parsing a range, the char pointer PP will
459 * be advanced past <number1> and left pointing at the '-' token.
460 * Subsequent calls will not advance the pointer until the range
461 * is completed. The call that completes the range will advance
462 * pointer PP past <number2>.
466 get_number_or_range (char **pp)
468 static int last_retval, end_value;
469 static char *end_ptr;
470 static int in_range = 0;
474 /* Default case: pp is pointing either to a solo number,
475 or to the first number of a range. */
476 last_retval = get_number_trailer (pp, '-');
481 /* This is the start of a range (<number1> - <number2>).
482 Skip the '-', parse and remember the second number,
483 and also remember the end of the final token. */
487 while (isspace ((int) *end_ptr))
488 end_ptr++; /* skip white space */
489 end_value = get_number (temp);
490 if (end_value < last_retval)
492 error ("inverted range");
494 else if (end_value == last_retval)
496 /* degenerate range (number1 == number2). Advance the
497 token pointer so that the range will be treated as a
506 error ("negative value");
509 /* pp points to the '-' that betokens a range. All
510 number-parsing has already been done. Return the next
511 integer value (one greater than the saved previous value).
512 Do not advance the token pointer 'pp' until the end of range
515 if (++last_retval == end_value)
517 /* End of range reached; advance token pointer. */
527 /* condition N EXP -- set break condition of breakpoint N to EXP. */
530 condition_command (char *arg, int from_tty)
532 struct breakpoint *b;
537 error_no_arg ("breakpoint number");
540 bnum = get_number (&p);
542 error ("Bad breakpoint argument: '%s'", arg);
545 if (b->number == bnum)
552 if (b->cond_string != NULL)
553 xfree (b->cond_string);
558 b->cond_string = NULL;
560 printf_filtered ("Breakpoint %d now unconditional.\n", bnum);
565 /* I don't know if it matters whether this is the string the user
566 typed in or the decompiled expression. */
567 b->cond_string = savestring (arg, strlen (arg));
570 b->cond = parse_exp_1 (&arg, block_for_pc (b->loc->address), 0);
572 error ("Junk at end of expression");
575 breakpoints_changed ();
576 breakpoint_modify_event (b->number);
580 error ("No breakpoint number %d.", bnum);
584 commands_command (char *arg, int from_tty)
586 struct breakpoint *b;
589 struct command_line *l;
591 /* If we allowed this, we would have problems with when to
592 free the storage, if we change the commands currently
595 if (executing_breakpoint_commands)
596 error ("Can't use the \"commands\" command among a breakpoint's commands.");
599 bnum = get_number (&p);
602 error ("Unexpected extra arguments following breakpoint number.");
605 if (b->number == bnum)
607 char *tmpbuf = xstrprintf ("Type commands for when breakpoint %d is hit, one per line.",
609 struct cleanup *cleanups = make_cleanup (xfree, tmpbuf);
610 l = read_command_lines (tmpbuf, from_tty);
611 do_cleanups (cleanups);
612 free_command_lines (&b->commands);
614 breakpoints_changed ();
615 breakpoint_modify_event (b->number);
618 error ("No breakpoint number %d.", bnum);
621 /* Like target_read_memory() but if breakpoints are inserted, return
622 the shadow contents instead of the breakpoints themselves.
624 Read "memory data" from whatever target or inferior we have.
625 Returns zero if successful, errno value if not. EIO is used
626 for address out of bounds. If breakpoints are inserted, returns
627 shadow contents, not the breakpoints themselves. From breakpoint.c. */
630 read_memory_nobpt (CORE_ADDR memaddr, char *myaddr, unsigned len)
633 struct bp_location *b;
634 CORE_ADDR bp_addr = 0;
637 if (BREAKPOINT_FROM_PC (&bp_addr, &bp_size) == NULL)
638 /* No breakpoints on this machine. */
639 return target_read_memory (memaddr, myaddr, len);
643 if (b->owner->type == bp_none)
644 warning ("reading through apparently deleted breakpoint #%d?",
647 if (b->loc_type != bp_loc_software_breakpoint)
651 /* Addresses and length of the part of the breakpoint that
653 /* XXXX The m68k, sh and h8300 have different local and remote
654 breakpoint values. BREAKPOINT_FROM_PC still manages to
655 correctly determine the breakpoints memory address and size
656 for these targets. */
657 bp_addr = b->address;
659 if (BREAKPOINT_FROM_PC (&bp_addr, &bp_size) == NULL)
664 if (bp_addr + bp_size <= memaddr)
665 /* The breakpoint is entirely before the chunk of memory we
668 if (bp_addr >= memaddr + len)
669 /* The breakpoint is entirely after the chunk of memory we are
672 /* Copy the breakpoint from the shadow contents, and recurse for
673 the things before and after. */
675 /* Offset within shadow_contents. */
678 if (bp_addr < memaddr)
680 /* Only copy the second part of the breakpoint. */
681 bp_size -= memaddr - bp_addr;
682 bptoffset = memaddr - bp_addr;
686 if (bp_addr + bp_size > memaddr + len)
688 /* Only copy the first part of the breakpoint. */
689 bp_size -= (bp_addr + bp_size) - (memaddr + len);
692 memcpy (myaddr + bp_addr - memaddr,
693 b->shadow_contents + bptoffset, bp_size);
695 if (bp_addr > memaddr)
697 /* Copy the section of memory before the breakpoint. */
698 status = read_memory_nobpt (memaddr, myaddr, bp_addr - memaddr);
703 if (bp_addr + bp_size < memaddr + len)
705 /* Copy the section of memory after the breakpoint. */
706 status = read_memory_nobpt (bp_addr + bp_size,
707 myaddr + bp_addr + bp_size - memaddr,
708 memaddr + len - (bp_addr + bp_size));
715 /* Nothing overlaps. Just call read_memory_noerr. */
716 return target_read_memory (memaddr, myaddr, len);
720 /* A wrapper function for inserting catchpoints. */
722 insert_catchpoint (struct ui_out *uo, void *args)
724 struct breakpoint *b = (struct breakpoint *) args;
730 val = target_insert_fork_catchpoint (PIDGET (inferior_ptid));
733 val = target_insert_vfork_catchpoint (PIDGET (inferior_ptid));
736 val = target_insert_exec_catchpoint (PIDGET (inferior_ptid));
739 internal_error (__FILE__, __LINE__, "unknown breakpoint type");
744 throw_exception (RETURN_ERROR);
749 /* Helper routine: free the value chain for a breakpoint (watchpoint). */
751 static void free_valchain (struct bp_location *b)
756 /* Free the saved value chain. We will construct a new one
757 the next time the watchpoint is inserted. */
758 for (v = b->owner->val_chain; v; v = n)
763 b->owner->val_chain = NULL;
766 /* Insert a low-level "breakpoint" of some type. BPT is the breakpoint.
767 Any error messages are printed to TMP_ERROR_STREAM; and DISABLED_BREAKS,
768 PROCESS_WARNING, and HW_BREAKPOINT_ERROR are used to report problems.
770 NOTE drow/2003-09-09: This routine could be broken down to an object-style
771 method for each breakpoint or catchpoint type. */
773 insert_bp_location (struct bp_location *bpt,
774 struct ui_file *tmp_error_stream,
775 int *disabled_breaks, int *process_warning,
776 int *hw_breakpoint_error)
780 /* Permanent breakpoints cannot be inserted or removed. Disabled
781 breakpoints should not be inserted. */
782 if (!breakpoint_enabled (bpt->owner))
785 if (bpt->inserted || bpt->duplicate)
788 if (bpt->loc_type == bp_loc_software_breakpoint
789 || bpt->loc_type == bp_loc_hardware_breakpoint)
791 /* First check to see if we have to handle an overlay. */
792 if (overlay_debugging == ovly_off
793 || bpt->section == NULL
794 || !(section_is_overlay (bpt->section)))
796 /* No overlay handling: just set the breakpoint. */
798 if (bpt->loc_type == bp_loc_hardware_breakpoint)
799 val = target_insert_hw_breakpoint (bpt->address,
800 bpt->shadow_contents);
802 val = target_insert_breakpoint (bpt->address,
803 bpt->shadow_contents);
807 /* This breakpoint is in an overlay section.
808 Shall we set a breakpoint at the LMA? */
809 if (!overlay_events_enabled)
811 /* Yes -- overlay event support is not active,
812 so we must try to set a breakpoint at the LMA.
813 This will not work for a hardware breakpoint. */
814 if (bpt->loc_type == bp_loc_hardware_breakpoint)
815 warning ("hardware breakpoint %d not supported in overlay!\n",
819 CORE_ADDR addr = overlay_unmapped_address (bpt->address,
821 /* Set a software (trap) breakpoint at the LMA. */
822 val = target_insert_breakpoint (addr, bpt->shadow_contents);
824 fprintf_unfiltered (tmp_error_stream,
825 "Overlay breakpoint %d failed: in ROM?",
829 /* Shall we set a breakpoint at the VMA? */
830 if (section_is_mapped (bpt->section))
832 /* Yes. This overlay section is mapped into memory. */
833 if (bpt->loc_type == bp_loc_hardware_breakpoint)
834 val = target_insert_hw_breakpoint (bpt->address,
835 bpt->shadow_contents);
837 val = target_insert_breakpoint (bpt->address,
838 bpt->shadow_contents);
842 /* No. This breakpoint will not be inserted.
843 No error, but do not mark the bp as 'inserted'. */
850 /* Can't set the breakpoint. */
851 #if defined (DISABLE_UNSETTABLE_BREAK)
852 if (DISABLE_UNSETTABLE_BREAK (bpt->address))
854 /* See also: disable_breakpoints_in_shlibs. */
856 bpt->owner->enable_state = bp_shlib_disabled;
857 if (!*disabled_breaks)
859 fprintf_unfiltered (tmp_error_stream,
860 "Cannot insert breakpoint %d.\n",
862 fprintf_unfiltered (tmp_error_stream,
863 "Temporarily disabling shared library breakpoints:\n");
865 *disabled_breaks = 1;
866 fprintf_unfiltered (tmp_error_stream,
867 "breakpoint #%d\n", bpt->owner->number);
872 #ifdef ONE_PROCESS_WRITETEXT
873 *process_warning = 1;
875 if (bpt->loc_type == bp_loc_hardware_breakpoint)
877 *hw_breakpoint_error = 1;
878 fprintf_unfiltered (tmp_error_stream,
879 "Cannot insert hardware breakpoint %d.\n",
884 fprintf_unfiltered (tmp_error_stream,
885 "Cannot insert breakpoint %d.\n",
887 fprintf_filtered (tmp_error_stream,
888 "Error accessing memory address ");
889 print_address_numeric (bpt->address, 1, tmp_error_stream);
890 fprintf_filtered (tmp_error_stream, ": %s.\n",
891 safe_strerror (val));
902 else if (bpt->loc_type == bp_loc_hardware_watchpoint
903 /* NOTE drow/2003-09-08: This state only exists for removing
904 watchpoints. It's not clear that it's necessary... */
905 && bpt->owner->disposition != disp_del_at_next_stop)
907 /* FIXME drow/2003-09-08: This code sets multiple hardware watchpoints
908 based on the expression. Ideally this should happen at a higher level,
909 and there should be one bp_location for each computed address we
910 must watch. As soon as a many-to-one mapping is available I'll
913 struct frame_info *saved_frame;
914 int saved_level, within_current_scope;
915 struct value *mark = value_mark ();
918 /* Save the current frame and level so we can restore it after
919 evaluating the watchpoint expression on its own frame. */
920 /* FIXME drow/2003-09-09: It would be nice if evaluate_expression
921 took a frame parameter, so that we didn't have to change the
923 saved_frame = deprecated_selected_frame;
924 saved_level = frame_relative_level (deprecated_selected_frame);
926 /* Determine if the watchpoint is within scope. */
927 if (bpt->owner->exp_valid_block == NULL)
928 within_current_scope = 1;
931 struct frame_info *fi;
932 fi = frame_find_by_id (bpt->owner->watchpoint_frame);
933 within_current_scope = (fi != NULL);
934 if (within_current_scope)
938 if (within_current_scope)
942 /* Evaluate the expression and cut the chain of values
943 produced off from the value chain.
945 Make sure the value returned isn't lazy; we use
946 laziness to determine what memory GDB actually needed
947 in order to compute the value of the expression. */
948 v = evaluate_expression (bpt->owner->exp);
950 value_release_to_mark (mark);
952 bpt->owner->val_chain = v;
955 /* Look at each value on the value chain. */
956 for (; v; v = v->next)
958 /* If it's a memory location, and GDB actually needed
959 its contents to evaluate the expression, then we
961 if (VALUE_LVAL (v) == lval_memory
964 struct type *vtype = check_typedef (VALUE_TYPE (v));
966 /* We only watch structs and arrays if user asked
967 for it explicitly, never if they just happen to
968 appear in the middle of some value chain. */
969 if (v == bpt->owner->val_chain
970 || (TYPE_CODE (vtype) != TYPE_CODE_STRUCT
971 && TYPE_CODE (vtype) != TYPE_CODE_ARRAY))
976 addr = VALUE_ADDRESS (v) + VALUE_OFFSET (v);
977 len = TYPE_LENGTH (VALUE_TYPE (v));
979 if (bpt->owner->type == bp_read_watchpoint)
981 else if (bpt->owner->type == bp_access_watchpoint)
984 val = target_insert_watchpoint (addr, len, type);
987 /* Don't exit the loop, try to insert
988 every value on the value chain. That's
989 because we will be removing all the
990 watches below, and removing a
991 watchpoint we didn't insert could have
999 /* Failure to insert a watchpoint on any memory value in the
1000 value chain brings us here. */
1003 remove_breakpoint (bpt, mark_uninserted);
1004 *hw_breakpoint_error = 1;
1005 fprintf_unfiltered (tmp_error_stream,
1006 "Could not insert hardware watchpoint %d.\n",
1007 bpt->owner->number);
1013 printf_filtered ("Hardware watchpoint %d deleted ", bpt->owner->number);
1014 printf_filtered ("because the program has left the block \n");
1015 printf_filtered ("in which its expression is valid.\n");
1016 if (bpt->owner->related_breakpoint)
1017 bpt->owner->related_breakpoint->disposition = disp_del_at_next_stop;
1018 bpt->owner->disposition = disp_del_at_next_stop;
1021 /* Restore the frame and level. */
1022 if (saved_frame != deprecated_selected_frame
1023 || saved_level != frame_relative_level (deprecated_selected_frame))
1024 select_frame (saved_frame);
1029 else if (ep_is_exception_catchpoint (bpt->owner))
1031 /* FIXME drow/2003-09-09: This code sets both a catchpoint and a
1032 breakpoint. Once again, it would be better if this was represented
1033 as two bp_locations. */
1035 /* If we get here, we must have a callback mechanism for exception
1036 events -- with g++ style embedded label support, we insert
1037 ordinary breakpoints and not catchpoints. */
1038 val = target_insert_breakpoint (bpt->address, bpt->shadow_contents);
1041 /* Couldn't set breakpoint for some reason */
1042 fprintf_unfiltered (tmp_error_stream,
1043 "Cannot insert catchpoint %d; disabling it.\n",
1044 bpt->owner->number);
1045 fprintf_filtered (tmp_error_stream,
1046 "Error accessing memory address ");
1047 print_address_numeric (bpt->address, 1, tmp_error_stream);
1048 fprintf_filtered (tmp_error_stream, ": %s.\n",
1049 safe_strerror (val));
1050 bpt->owner->enable_state = bp_disabled;
1054 /* Bp set, now make sure callbacks are enabled */
1055 /* Format possible error msg */
1056 char *message = xstrprintf ("Error inserting catchpoint %d:\n",
1057 bpt->owner->number);
1058 struct cleanup *cleanups = make_cleanup (xfree, message);
1060 args_for_catchpoint_enable args;
1061 args.kind = bpt->owner->type == bp_catch_catch ?
1062 EX_EVENT_CATCH : EX_EVENT_THROW;
1064 val = catch_errors (cover_target_enable_exception_callback,
1065 &args, message, RETURN_MASK_ALL);
1066 do_cleanups (cleanups);
1067 if (val != 0 && val != -1)
1070 /* Check if something went wrong; val == 0 can be ignored */
1073 /* something went wrong */
1074 fprintf_unfiltered (tmp_error_stream,
1075 "Cannot insert catchpoint %d; disabling it.\n",
1076 bpt->owner->number);
1077 bpt->owner->enable_state = bp_disabled;
1084 else if (bpt->owner->type == bp_catch_fork
1085 || bpt->owner->type == bp_catch_vfork
1086 || bpt->owner->type == bp_catch_exec)
1088 char *prefix = xstrprintf ("warning: inserting catchpoint %d: ",
1089 bpt->owner->number);
1090 struct cleanup *cleanups = make_cleanup (xfree, prefix);
1091 val = catch_exceptions (uiout, insert_catchpoint, bpt->owner, prefix,
1093 do_cleanups (cleanups);
1095 bpt->owner->enable_state = bp_disabled;
1099 /* We've already printed an error message if there was a problem
1100 inserting this catchpoint, and we've disabled the catchpoint,
1101 so just return success. */
1108 /* insert_breakpoints is used when starting or continuing the program.
1109 remove_breakpoints is used when the program stops.
1110 Both return zero if successful,
1111 or an `errno' value if could not write the inferior. */
1114 insert_breakpoints (void)
1116 struct bp_location *b, *temp;
1117 int return_val = 0; /* return success code. */
1119 int disabled_breaks = 0;
1120 int hw_breakpoint_error = 0;
1121 int process_warning = 0;
1123 struct ui_file *tmp_error_stream = mem_fileopen ();
1124 make_cleanup_ui_file_delete (tmp_error_stream);
1126 /* Explicitly mark the warning -- this will only be printed if
1127 there was an error. */
1128 fprintf_unfiltered (tmp_error_stream, "Warning:\n");
1130 ALL_BP_LOCATIONS_SAFE (b, temp)
1132 /* Permanent breakpoints cannot be inserted or removed. Disabled
1133 breakpoints should not be inserted. */
1134 if (!breakpoint_enabled (b->owner))
1137 /* FIXME drow/2003-10-07: This code should be pushed elsewhere when
1138 hardware watchpoints are split into multiple loc breakpoints. */
1139 if ((b->loc_type == bp_loc_hardware_watchpoint
1140 || b->owner->type == bp_watchpoint) && !b->owner->val)
1143 val = evaluate_expression (b->owner->exp);
1144 release_value (val);
1145 if (VALUE_LAZY (val))
1146 value_fetch_lazy (val);
1147 b->owner->val = val;
1150 val = insert_bp_location (b, tmp_error_stream,
1151 &disabled_breaks, &process_warning,
1152 &hw_breakpoint_error);
1159 /* If a hardware breakpoint or watchpoint was inserted, add a
1160 message about possibly exhausted resources. */
1161 if (hw_breakpoint_error)
1163 fprintf_unfiltered (tmp_error_stream,
1164 "Could not insert hardware breakpoints:\n\
1165 You may have requested too many hardware breakpoints/watchpoints.\n");
1167 #ifdef ONE_PROCESS_WRITETEXT
1168 if (process_warning)
1169 fprintf_unfiltered (tmp_error_stream,
1170 "The same program may be running in another process.");
1172 target_terminal_ours_for_output ();
1173 error_stream (tmp_error_stream);
1179 remove_breakpoints (void)
1181 struct bp_location *b;
1184 ALL_BP_LOCATIONS (b)
1188 val = remove_breakpoint (b, mark_uninserted);
1197 remove_hw_watchpoints (void)
1199 struct bp_location *b;
1202 ALL_BP_LOCATIONS (b)
1204 if (b->inserted && b->loc_type == bp_loc_hardware_watchpoint)
1206 val = remove_breakpoint (b, mark_uninserted);
1215 reattach_breakpoints (int pid)
1217 struct bp_location *b;
1219 struct cleanup *old_chain = save_inferior_ptid ();
1221 /* Set inferior_ptid; remove_breakpoint uses this global. */
1222 inferior_ptid = pid_to_ptid (pid);
1223 ALL_BP_LOCATIONS (b)
1227 remove_breakpoint (b, mark_inserted);
1228 if (b->loc_type == bp_loc_hardware_breakpoint)
1229 val = target_insert_hw_breakpoint (b->address, b->shadow_contents);
1231 val = target_insert_breakpoint (b->address, b->shadow_contents);
1232 /* FIXME drow/2003-10-07: This doesn't handle any other kinds of
1233 breakpoints. It's wrong for watchpoints, for example. */
1236 do_cleanups (old_chain);
1241 do_cleanups (old_chain);
1246 update_breakpoints_after_exec (void)
1248 struct breakpoint *b;
1249 struct breakpoint *temp;
1251 /* Doing this first prevents the badness of having delete_breakpoint()
1252 write a breakpoint's current "shadow contents" to lift the bp. That
1253 shadow is NOT valid after an exec()! */
1254 mark_breakpoints_out ();
1256 ALL_BREAKPOINTS_SAFE (b, temp)
1258 /* Solib breakpoints must be explicitly reset after an exec(). */
1259 if (b->type == bp_shlib_event)
1261 delete_breakpoint (b);
1265 /* Thread event breakpoints must be set anew after an exec(),
1266 as must overlay event breakpoints. */
1267 if (b->type == bp_thread_event || b->type == bp_overlay_event)
1269 delete_breakpoint (b);
1273 /* Step-resume breakpoints are meaningless after an exec(). */
1274 if (b->type == bp_step_resume)
1276 delete_breakpoint (b);
1280 /* Ditto the sigtramp handler breakpoints. */
1281 if (b->type == bp_through_sigtramp)
1283 delete_breakpoint (b);
1287 /* Ditto the exception-handling catchpoints. */
1288 if ((b->type == bp_catch_catch) || (b->type == bp_catch_throw))
1290 delete_breakpoint (b);
1294 /* Don't delete an exec catchpoint, because else the inferior
1295 won't stop when it ought!
1297 Similarly, we probably ought to keep vfork catchpoints, 'cause
1298 on this target, we may not be able to stop when the vfork is
1299 seen, but only when the subsequent exec is seen. (And because
1300 deleting fork catchpoints here but not vfork catchpoints will
1301 seem mysterious to users, keep those too.)
1303 ??rehrauer: Let's hope that merely clearing out this catchpoint's
1304 target address field, if any, is sufficient to have it be reset
1305 automagically. Certainly on HP-UX that's true.
1307 Jim Blandy <jimb@redhat.com>: Actually, zero is a perfectly
1308 valid code address on some platforms (like the mn10300
1309 simulators). We shouldn't assign any special interpretation to
1310 a breakpoint with a zero address. And in fact, GDB doesn't ---
1311 I can't see what that comment above is talking about. As far
1312 as I can tell, setting the address of a
1313 bp_catch_exec/bp_catch_vfork/bp_catch_fork breakpoint to zero
1314 is meaningless, since those are implemented with HP-UX kernel
1315 hackery, not by storing breakpoint instructions somewhere. */
1316 if ((b->type == bp_catch_exec) ||
1317 (b->type == bp_catch_vfork) ||
1318 (b->type == bp_catch_fork))
1320 b->loc->address = (CORE_ADDR) NULL;
1324 /* bp_finish is a special case. The only way we ought to be able
1325 to see one of these when an exec() has happened, is if the user
1326 caught a vfork, and then said "finish". Ordinarily a finish just
1327 carries them to the call-site of the current callee, by setting
1328 a temporary bp there and resuming. But in this case, the finish
1329 will carry them entirely through the vfork & exec.
1331 We don't want to allow a bp_finish to remain inserted now. But
1332 we can't safely delete it, 'cause finish_command has a handle to
1333 the bp on a bpstat, and will later want to delete it. There's a
1334 chance (and I've seen it happen) that if we delete the bp_finish
1335 here, that its storage will get reused by the time finish_command
1336 gets 'round to deleting the "use to be a bp_finish" breakpoint.
1337 We really must allow finish_command to delete a bp_finish.
1339 In the absense of a general solution for the "how do we know
1340 it's safe to delete something others may have handles to?"
1341 problem, what we'll do here is just uninsert the bp_finish, and
1342 let finish_command delete it.
1344 (We know the bp_finish is "doomed" in the sense that it's
1345 momentary, and will be deleted as soon as finish_command sees
1346 the inferior stopped. So it doesn't matter that the bp's
1347 address is probably bogus in the new a.out, unlike e.g., the
1348 solib breakpoints.) */
1350 if (b->type == bp_finish)
1355 /* Without a symbolic address, we have little hope of the
1356 pre-exec() address meaning the same thing in the post-exec()
1358 if (b->addr_string == NULL)
1360 delete_breakpoint (b);
1364 /* If this breakpoint has survived the above battery of checks, then
1365 it must have a symbolic address. Be sure that it gets reevaluated
1366 to a target address, rather than reusing the old evaluation.
1368 Jim Blandy <jimb@redhat.com>: As explained above in the comment
1369 for bp_catch_exec and friends, I'm pretty sure this is entirely
1370 unnecessary. A call to breakpoint_re_set_one always recomputes
1371 the breakpoint's address from scratch, or deletes it if it can't.
1372 So I think this assignment could be deleted without effect. */
1373 b->loc->address = (CORE_ADDR) NULL;
1375 /* FIXME what about longjmp breakpoints? Re-create them here? */
1376 create_overlay_event_breakpoint ("_ovly_debug_event");
1380 detach_breakpoints (int pid)
1382 struct bp_location *b;
1384 struct cleanup *old_chain = save_inferior_ptid ();
1386 if (pid == PIDGET (inferior_ptid))
1387 error ("Cannot detach breakpoints of inferior_ptid");
1389 /* Set inferior_ptid; remove_breakpoint uses this global. */
1390 inferior_ptid = pid_to_ptid (pid);
1391 ALL_BP_LOCATIONS (b)
1395 val = remove_breakpoint (b, mark_inserted);
1398 do_cleanups (old_chain);
1403 do_cleanups (old_chain);
1408 remove_breakpoint (struct bp_location *b, insertion_state_t is)
1412 if (b->owner->enable_state == bp_permanent)
1413 /* Permanent breakpoints cannot be inserted or removed. */
1416 if (b->owner->type == bp_none)
1417 warning ("attempted to remove apparently deleted breakpoint #%d?",
1420 if (b->loc_type == bp_loc_software_breakpoint
1421 || b->loc_type == bp_loc_hardware_breakpoint)
1423 /* "Normal" instruction breakpoint: either the standard
1424 trap-instruction bp (bp_breakpoint), or a
1425 bp_hardware_breakpoint. */
1427 /* First check to see if we have to handle an overlay. */
1428 if (overlay_debugging == ovly_off
1429 || b->section == NULL
1430 || !(section_is_overlay (b->section)))
1432 /* No overlay handling: just remove the breakpoint. */
1434 if (b->loc_type == bp_loc_hardware_breakpoint)
1435 val = target_remove_hw_breakpoint (b->address,
1436 b->shadow_contents);
1438 val = target_remove_breakpoint (b->address, b->shadow_contents);
1442 /* This breakpoint is in an overlay section.
1443 Did we set a breakpoint at the LMA? */
1444 if (!overlay_events_enabled)
1446 /* Yes -- overlay event support is not active, so we
1447 should have set a breakpoint at the LMA. Remove it.
1449 CORE_ADDR addr = overlay_unmapped_address (b->address,
1451 /* Ignore any failures: if the LMA is in ROM, we will
1452 have already warned when we failed to insert it. */
1453 if (b->loc_type == bp_loc_hardware_breakpoint)
1454 target_remove_hw_breakpoint (addr, b->shadow_contents);
1456 target_remove_breakpoint (addr, b->shadow_contents);
1458 /* Did we set a breakpoint at the VMA?
1459 If so, we will have marked the breakpoint 'inserted'. */
1462 /* Yes -- remove it. Previously we did not bother to
1463 remove the breakpoint if the section had been
1464 unmapped, but let's not rely on that being safe. We
1465 don't know what the overlay manager might do. */
1466 if (b->loc_type == bp_loc_hardware_breakpoint)
1467 val = target_remove_hw_breakpoint (b->address,
1468 b->shadow_contents);
1470 val = target_remove_breakpoint (b->address,
1471 b->shadow_contents);
1475 /* No -- not inserted, so no need to remove. No error. */
1481 b->inserted = (is == mark_inserted);
1483 else if (b->loc_type == bp_loc_hardware_watchpoint
1484 && breakpoint_enabled (b->owner)
1490 b->inserted = (is == mark_inserted);
1491 /* Walk down the saved value chain. */
1492 for (v = b->owner->val_chain; v; v = v->next)
1494 /* For each memory reference remove the watchpoint
1496 if (VALUE_LVAL (v) == lval_memory
1497 && ! VALUE_LAZY (v))
1499 struct type *vtype = check_typedef (VALUE_TYPE (v));
1501 if (v == b->owner->val_chain
1502 || (TYPE_CODE (vtype) != TYPE_CODE_STRUCT
1503 && TYPE_CODE (vtype) != TYPE_CODE_ARRAY))
1508 addr = VALUE_ADDRESS (v) + VALUE_OFFSET (v);
1509 len = TYPE_LENGTH (VALUE_TYPE (v));
1511 if (b->owner->type == bp_read_watchpoint)
1513 else if (b->owner->type == bp_access_watchpoint)
1516 val = target_remove_watchpoint (addr, len, type);
1523 /* Failure to remove any of the hardware watchpoints comes here. */
1524 if ((is == mark_uninserted) && (b->inserted))
1525 warning ("Could not remove hardware watchpoint %d.",
1528 else if ((b->owner->type == bp_catch_fork ||
1529 b->owner->type == bp_catch_vfork ||
1530 b->owner->type == bp_catch_exec)
1531 && breakpoint_enabled (b->owner)
1535 switch (b->owner->type)
1538 val = target_remove_fork_catchpoint (PIDGET (inferior_ptid));
1540 case bp_catch_vfork:
1541 val = target_remove_vfork_catchpoint (PIDGET (inferior_ptid));
1544 val = target_remove_exec_catchpoint (PIDGET (inferior_ptid));
1547 warning ("Internal error, %s line %d.", __FILE__, __LINE__);
1552 b->inserted = (is == mark_inserted);
1554 else if ((b->owner->type == bp_catch_catch ||
1555 b->owner->type == bp_catch_throw)
1556 && breakpoint_enabled (b->owner)
1560 val = target_remove_breakpoint (b->address, b->shadow_contents);
1563 b->inserted = (is == mark_inserted);
1565 else if (ep_is_exception_catchpoint (b->owner)
1566 && b->inserted /* sometimes previous insert doesn't happen */
1567 && breakpoint_enabled (b->owner)
1571 val = target_remove_breakpoint (b->address, b->shadow_contents);
1575 b->inserted = (is == mark_inserted);
1581 /* Clear the "inserted" flag in all breakpoints. */
1584 mark_breakpoints_out (void)
1586 struct bp_location *bpt;
1588 ALL_BP_LOCATIONS (bpt)
1592 /* Clear the "inserted" flag in all breakpoints and delete any
1593 breakpoints which should go away between runs of the program.
1595 Plus other such housekeeping that has to be done for breakpoints
1598 Note: this function gets called at the end of a run (by
1599 generic_mourn_inferior) and when a run begins (by
1600 init_wait_for_inferior). */
1605 breakpoint_init_inferior (enum inf_context context)
1607 struct breakpoint *b, *temp;
1608 struct bp_location *bpt;
1609 static int warning_needed = 0;
1611 ALL_BP_LOCATIONS (bpt)
1614 ALL_BREAKPOINTS_SAFE (b, temp)
1619 case bp_watchpoint_scope:
1621 /* If the call dummy breakpoint is at the entry point it will
1622 cause problems when the inferior is rerun, so we better
1625 Also get rid of scope breakpoints. */
1626 delete_breakpoint (b);
1630 case bp_hardware_watchpoint:
1631 case bp_read_watchpoint:
1632 case bp_access_watchpoint:
1634 /* Likewise for watchpoints on local expressions. */
1635 if (b->exp_valid_block != NULL)
1636 delete_breakpoint (b);
1637 if (context == inf_starting)
1639 /* Reset val field to force reread of starting value
1640 in insert_breakpoints. */
1642 value_free (b->val);
1647 /* Likewise for exception catchpoints in dynamic-linked
1648 executables where required */
1649 if (ep_is_exception_catchpoint (b)
1650 && deprecated_exception_catchpoints_are_fragile)
1653 delete_breakpoint (b);
1659 if (deprecated_exception_catchpoints_are_fragile)
1660 deprecated_exception_support_initialized = 0;
1662 /* Don't issue the warning unless it's really needed... */
1663 if (warning_needed && (context != inf_exited))
1665 warning ("Exception catchpoints from last run were deleted.");
1666 warning ("You must reinsert them explicitly.");
1671 /* breakpoint_here_p (PC) returns non-zero if an enabled breakpoint
1672 exists at PC. It returns ordinary_breakpoint_here if it's an
1673 ordinary breakpoint, or permanent_breakpoint_here if it's a
1674 permanent breakpoint.
1675 - When continuing from a location with an ordinary breakpoint, we
1676 actually single step once before calling insert_breakpoints.
1677 - When continuing from a localion with a permanent breakpoint, we
1678 need to use the `SKIP_PERMANENT_BREAKPOINT' macro, provided by
1679 the target, to advance the PC past the breakpoint. */
1681 enum breakpoint_here
1682 breakpoint_here_p (CORE_ADDR pc)
1684 struct bp_location *bpt;
1685 int any_breakpoint_here = 0;
1687 ALL_BP_LOCATIONS (bpt)
1689 if (bpt->loc_type != bp_loc_software_breakpoint
1690 && bpt->loc_type != bp_loc_hardware_breakpoint)
1693 if ((breakpoint_enabled (bpt->owner)
1694 || bpt->owner->enable_state == bp_permanent)
1695 && bpt->address == pc) /* bp is enabled and matches pc */
1697 if (overlay_debugging
1698 && section_is_overlay (bpt->section)
1699 && !section_is_mapped (bpt->section))
1700 continue; /* unmapped overlay -- can't be a match */
1701 else if (bpt->owner->enable_state == bp_permanent)
1702 return permanent_breakpoint_here;
1704 any_breakpoint_here = 1;
1708 return any_breakpoint_here ? ordinary_breakpoint_here : 0;
1712 /* breakpoint_inserted_here_p (PC) is just like breakpoint_here_p(),
1713 but it only returns true if there is actually a breakpoint inserted
1717 breakpoint_inserted_here_p (CORE_ADDR pc)
1719 struct bp_location *bpt;
1721 ALL_BP_LOCATIONS (bpt)
1723 if (bpt->loc_type != bp_loc_software_breakpoint
1724 && bpt->loc_type != bp_loc_hardware_breakpoint)
1728 && bpt->address == pc) /* bp is inserted and matches pc */
1730 if (overlay_debugging
1731 && section_is_overlay (bpt->section)
1732 && !section_is_mapped (bpt->section))
1733 continue; /* unmapped overlay -- can't be a match */
1742 /* This function returns non-zero iff there is a software breakpoint
1746 software_breakpoint_inserted_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)
1756 if ((breakpoint_enabled (bpt->owner)
1757 || 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 */
1773 /* Return nonzero if FRAME is a dummy frame. We can't use
1774 DEPRECATED_PC_IN_CALL_DUMMY because figuring out the saved SP would
1775 take too much time, at least using frame_register() on the 68k.
1776 This means that for this function to work right a port must use the
1777 bp_call_dummy breakpoint. */
1780 deprecated_frame_in_dummy (struct frame_info *frame)
1782 struct breakpoint *b;
1784 /* This function is used by two files: get_frame_type(), after first
1785 checking that !DEPRECATED_USE_GENERIC_DUMMY_FRAMES; and
1786 sparc-tdep.c, which doesn't yet use generic dummy frames anyway. */
1787 gdb_assert (!DEPRECATED_USE_GENERIC_DUMMY_FRAMES);
1791 if (b->type == bp_call_dummy
1792 && frame_id_eq (b->frame_id, get_frame_id (frame))
1793 /* We need to check the PC as well as the frame on the sparc,
1794 for signals.exp in the testsuite. */
1795 && (get_frame_pc (frame)
1797 - DEPRECATED_SIZEOF_CALL_DUMMY_WORDS / sizeof (LONGEST) * DEPRECATED_REGISTER_SIZE))
1798 && get_frame_pc (frame) <= b->loc->address)
1804 /* breakpoint_thread_match (PC, PTID) returns true if the breakpoint at
1805 PC is valid for process/thread PTID. */
1808 breakpoint_thread_match (CORE_ADDR pc, ptid_t ptid)
1810 struct bp_location *bpt;
1813 thread = pid_to_thread_id (ptid);
1815 ALL_BP_LOCATIONS (bpt)
1817 if (bpt->loc_type != bp_loc_software_breakpoint
1818 && bpt->loc_type != bp_loc_hardware_breakpoint)
1821 if ((breakpoint_enabled (bpt->owner)
1822 || bpt->owner->enable_state == bp_permanent)
1823 && bpt->address == pc
1824 && (bpt->owner->thread == -1 || bpt->owner->thread == thread))
1826 if (overlay_debugging
1827 && section_is_overlay (bpt->section)
1828 && !section_is_mapped (bpt->section))
1829 continue; /* unmapped overlay -- can't be a match */
1839 /* bpstat stuff. External routines' interfaces are documented
1843 ep_is_catchpoint (struct breakpoint *ep)
1846 (ep->type == bp_catch_load)
1847 || (ep->type == bp_catch_unload)
1848 || (ep->type == bp_catch_fork)
1849 || (ep->type == bp_catch_vfork)
1850 || (ep->type == bp_catch_exec)
1851 || (ep->type == bp_catch_catch)
1852 || (ep->type == bp_catch_throw);
1854 /* ??rehrauer: Add more kinds here, as are implemented... */
1858 ep_is_shlib_catchpoint (struct breakpoint *ep)
1861 (ep->type == bp_catch_load)
1862 || (ep->type == bp_catch_unload);
1866 ep_is_exception_catchpoint (struct breakpoint *ep)
1869 (ep->type == bp_catch_catch)
1870 || (ep->type == bp_catch_throw);
1873 /* Clear a bpstat so that it says we are not at any breakpoint.
1874 Also free any storage that is part of a bpstat. */
1877 bpstat_clear (bpstat *bsp)
1888 if (p->old_val != NULL)
1889 value_free (p->old_val);
1890 free_command_lines (&p->commands);
1897 /* Return a copy of a bpstat. Like "bs1 = bs2" but all storage that
1898 is part of the bpstat is copied as well. */
1901 bpstat_copy (bpstat bs)
1905 bpstat retval = NULL;
1910 for (; bs != NULL; bs = bs->next)
1912 tmp = (bpstat) xmalloc (sizeof (*tmp));
1913 memcpy (tmp, bs, sizeof (*tmp));
1914 if (bs->commands != NULL)
1915 tmp->commands = copy_command_lines (bs->commands);
1916 if (bs->old_val != NULL)
1917 tmp->old_val = value_copy (bs->old_val);
1920 /* This is the first thing in the chain. */
1930 /* Find the bpstat associated with this breakpoint */
1933 bpstat_find_breakpoint (bpstat bsp, struct breakpoint *breakpoint)
1938 for (; bsp != NULL; bsp = bsp->next)
1940 if (bsp->breakpoint_at == breakpoint)
1946 /* Find a step_resume breakpoint associated with this bpstat.
1947 (If there are multiple step_resume bp's on the list, this function
1948 will arbitrarily pick one.)
1950 It is an error to use this function if BPSTAT doesn't contain a
1951 step_resume breakpoint.
1953 See wait_for_inferior's use of this function. */
1955 bpstat_find_step_resume_breakpoint (bpstat bsp)
1960 error ("Internal error (bpstat_find_step_resume_breakpoint)");
1962 current_thread = pid_to_thread_id (inferior_ptid);
1964 for (; bsp != NULL; bsp = bsp->next)
1966 if ((bsp->breakpoint_at != NULL) &&
1967 (bsp->breakpoint_at->type == bp_step_resume) &&
1968 (bsp->breakpoint_at->thread == current_thread ||
1969 bsp->breakpoint_at->thread == -1))
1970 return bsp->breakpoint_at;
1973 error ("Internal error (no step_resume breakpoint found)");
1977 /* Return the breakpoint number of the first breakpoint we are stopped
1978 at. *BSP upon return is a bpstat which points to the remaining
1979 breakpoints stopped at (but which is not guaranteed to be good for
1980 anything but further calls to bpstat_num).
1981 Return 0 if passed a bpstat which does not indicate any breakpoints. */
1984 bpstat_num (bpstat *bsp)
1986 struct breakpoint *b;
1989 return 0; /* No more breakpoint values */
1992 b = (*bsp)->breakpoint_at;
1993 *bsp = (*bsp)->next;
1995 return -1; /* breakpoint that's been deleted since */
1997 return b->number; /* We have its number */
2001 /* Modify BS so that the actions will not be performed. */
2004 bpstat_clear_actions (bpstat bs)
2006 for (; bs != NULL; bs = bs->next)
2008 free_command_lines (&bs->commands);
2009 if (bs->old_val != NULL)
2011 value_free (bs->old_val);
2017 /* Stub for cleaning up our state if we error-out of a breakpoint command */
2019 cleanup_executing_breakpoints (void *ignore)
2021 executing_breakpoint_commands = 0;
2024 /* Execute all the commands associated with all the breakpoints at this
2025 location. Any of these commands could cause the process to proceed
2026 beyond this point, etc. We look out for such changes by checking
2027 the global "breakpoint_proceeded" after each command. */
2030 bpstat_do_actions (bpstat *bsp)
2033 struct cleanup *old_chain;
2035 /* Avoid endless recursion if a `source' command is contained
2037 if (executing_breakpoint_commands)
2040 executing_breakpoint_commands = 1;
2041 old_chain = make_cleanup (cleanup_executing_breakpoints, 0);
2044 /* Note that (as of this writing), our callers all appear to
2045 be passing us the address of global stop_bpstat. And, if
2046 our calls to execute_control_command cause the inferior to
2047 proceed, that global (and hence, *bsp) will change.
2049 We must be careful to not touch *bsp unless the inferior
2050 has not proceeded. */
2052 /* This pointer will iterate over the list of bpstat's. */
2055 breakpoint_proceeded = 0;
2056 for (; bs != NULL; bs = bs->next)
2058 struct command_line *cmd;
2059 struct cleanup *this_cmd_tree_chain;
2061 /* Take ownership of the BSP's command tree, if it has one.
2063 The command tree could legitimately contain commands like
2064 'step' and 'next', which call clear_proceed_status, which
2065 frees stop_bpstat's command tree. To make sure this doesn't
2066 free the tree we're executing out from under us, we need to
2067 take ownership of the tree ourselves. Since a given bpstat's
2068 commands are only executed once, we don't need to copy it; we
2069 can clear the pointer in the bpstat, and make sure we free
2070 the tree when we're done. */
2073 this_cmd_tree_chain = make_cleanup_free_command_lines (&cmd);
2077 execute_control_command (cmd);
2079 if (breakpoint_proceeded)
2085 /* We can free this command tree now. */
2086 do_cleanups (this_cmd_tree_chain);
2088 if (breakpoint_proceeded)
2089 /* The inferior is proceeded by the command; bomb out now.
2090 The bpstat chain has been blown away by wait_for_inferior.
2091 But since execution has stopped again, there is a new bpstat
2092 to look at, so start over. */
2095 do_cleanups (old_chain);
2098 /* This is the normal print function for a bpstat. In the future,
2099 much of this logic could (should?) be moved to bpstat_stop_status,
2100 by having it set different print_it values.
2102 Current scheme: When we stop, bpstat_print() is called. It loops
2103 through the bpstat list of things causing this stop, calling the
2104 print_bp_stop_message function on each one. The behavior of the
2105 print_bp_stop_message function depends on the print_it field of
2106 bpstat. If such field so indicates, call this function here.
2108 Return values from this routine (ultimately used by bpstat_print()
2109 and normal_stop() to decide what to do):
2110 PRINT_NOTHING: Means we already printed all we needed to print,
2111 don't print anything else.
2112 PRINT_SRC_ONLY: Means we printed something, and we do *not* desire
2113 that something to be followed by a location.
2114 PRINT_SCR_AND_LOC: Means we printed something, and we *do* desire
2115 that something to be followed by a location.
2116 PRINT_UNKNOWN: Means we printed nothing or we need to do some more
2119 static enum print_stop_action
2120 print_it_typical (bpstat bs)
2122 struct cleanup *old_chain, *ui_out_chain;
2123 struct ui_stream *stb;
2124 stb = ui_out_stream_new (uiout);
2125 old_chain = make_cleanup_ui_out_stream_delete (stb);
2126 /* bs->breakpoint_at can be NULL if it was a momentary breakpoint
2127 which has since been deleted. */
2128 if (bs->breakpoint_at == NULL)
2129 return PRINT_UNKNOWN;
2131 switch (bs->breakpoint_at->type)
2134 case bp_hardware_breakpoint:
2135 if (bs->breakpoint_at->loc->address != bs->breakpoint_at->loc->requested_address)
2136 breakpoint_adjustment_warning (bs->breakpoint_at->loc->requested_address,
2137 bs->breakpoint_at->loc->address,
2138 bs->breakpoint_at->number, 1);
2139 annotate_breakpoint (bs->breakpoint_at->number);
2140 ui_out_text (uiout, "\nBreakpoint ");
2141 if (ui_out_is_mi_like_p (uiout))
2142 ui_out_field_string (uiout, "reason", "breakpoint-hit");
2143 ui_out_field_int (uiout, "bkptno", bs->breakpoint_at->number);
2144 ui_out_text (uiout, ", ");
2145 return PRINT_SRC_AND_LOC;
2148 case bp_shlib_event:
2149 /* Did we stop because the user set the stop_on_solib_events
2150 variable? (If so, we report this as a generic, "Stopped due
2151 to shlib event" message.) */
2152 printf_filtered ("Stopped due to shared library event\n");
2153 return PRINT_NOTHING;
2156 case bp_thread_event:
2157 /* Not sure how we will get here.
2158 GDB should not stop for these breakpoints. */
2159 printf_filtered ("Thread Event Breakpoint: gdb should not stop!\n");
2160 return PRINT_NOTHING;
2163 case bp_overlay_event:
2164 /* By analogy with the thread event, GDB should not stop for these. */
2165 printf_filtered ("Overlay Event Breakpoint: gdb should not stop!\n");
2166 return PRINT_NOTHING;
2170 annotate_catchpoint (bs->breakpoint_at->number);
2171 printf_filtered ("\nCatchpoint %d (", bs->breakpoint_at->number);
2172 printf_filtered ("loaded");
2173 printf_filtered (" %s), ", bs->breakpoint_at->triggered_dll_pathname);
2174 return PRINT_SRC_AND_LOC;
2177 case bp_catch_unload:
2178 annotate_catchpoint (bs->breakpoint_at->number);
2179 printf_filtered ("\nCatchpoint %d (", bs->breakpoint_at->number);
2180 printf_filtered ("unloaded");
2181 printf_filtered (" %s), ", bs->breakpoint_at->triggered_dll_pathname);
2182 return PRINT_SRC_AND_LOC;
2186 annotate_catchpoint (bs->breakpoint_at->number);
2187 printf_filtered ("\nCatchpoint %d (", bs->breakpoint_at->number);
2188 printf_filtered ("forked");
2189 printf_filtered (" process %d), ",
2190 bs->breakpoint_at->forked_inferior_pid);
2191 return PRINT_SRC_AND_LOC;
2194 case bp_catch_vfork:
2195 annotate_catchpoint (bs->breakpoint_at->number);
2196 printf_filtered ("\nCatchpoint %d (", bs->breakpoint_at->number);
2197 printf_filtered ("vforked");
2198 printf_filtered (" process %d), ",
2199 bs->breakpoint_at->forked_inferior_pid);
2200 return PRINT_SRC_AND_LOC;
2204 annotate_catchpoint (bs->breakpoint_at->number);
2205 printf_filtered ("\nCatchpoint %d (exec'd %s), ",
2206 bs->breakpoint_at->number,
2207 bs->breakpoint_at->exec_pathname);
2208 return PRINT_SRC_AND_LOC;
2211 case bp_catch_catch:
2212 if (current_exception_event &&
2213 (CURRENT_EXCEPTION_KIND == EX_EVENT_CATCH))
2215 annotate_catchpoint (bs->breakpoint_at->number);
2216 printf_filtered ("\nCatchpoint %d (exception caught), ",
2217 bs->breakpoint_at->number);
2218 printf_filtered ("throw location ");
2219 if (CURRENT_EXCEPTION_THROW_PC && CURRENT_EXCEPTION_THROW_LINE)
2220 printf_filtered ("%s:%d",
2221 CURRENT_EXCEPTION_THROW_FILE,
2222 CURRENT_EXCEPTION_THROW_LINE);
2224 printf_filtered ("unknown");
2226 printf_filtered (", catch location ");
2227 if (CURRENT_EXCEPTION_CATCH_PC && CURRENT_EXCEPTION_CATCH_LINE)
2228 printf_filtered ("%s:%d",
2229 CURRENT_EXCEPTION_CATCH_FILE,
2230 CURRENT_EXCEPTION_CATCH_LINE);
2232 printf_filtered ("unknown");
2234 printf_filtered ("\n");
2235 /* don't bother to print location frame info */
2236 return PRINT_SRC_ONLY;
2240 /* really throw, some other bpstat will handle it */
2241 return PRINT_UNKNOWN;
2245 case bp_catch_throw:
2246 if (current_exception_event &&
2247 (CURRENT_EXCEPTION_KIND == EX_EVENT_THROW))
2249 annotate_catchpoint (bs->breakpoint_at->number);
2250 printf_filtered ("\nCatchpoint %d (exception thrown), ",
2251 bs->breakpoint_at->number);
2252 printf_filtered ("throw location ");
2253 if (CURRENT_EXCEPTION_THROW_PC && CURRENT_EXCEPTION_THROW_LINE)
2254 printf_filtered ("%s:%d",
2255 CURRENT_EXCEPTION_THROW_FILE,
2256 CURRENT_EXCEPTION_THROW_LINE);
2258 printf_filtered ("unknown");
2260 printf_filtered (", catch location ");
2261 if (CURRENT_EXCEPTION_CATCH_PC && CURRENT_EXCEPTION_CATCH_LINE)
2262 printf_filtered ("%s:%d",
2263 CURRENT_EXCEPTION_CATCH_FILE,
2264 CURRENT_EXCEPTION_CATCH_LINE);
2266 printf_filtered ("unknown");
2268 printf_filtered ("\n");
2269 /* don't bother to print location frame info */
2270 return PRINT_SRC_ONLY;
2274 /* really catch, some other bpstat will handle it */
2275 return PRINT_UNKNOWN;
2280 case bp_hardware_watchpoint:
2281 if (bs->old_val != NULL)
2283 annotate_watchpoint (bs->breakpoint_at->number);
2284 if (ui_out_is_mi_like_p (uiout))
2285 ui_out_field_string (uiout, "reason", "watchpoint-trigger");
2286 mention (bs->breakpoint_at);
2287 ui_out_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "value");
2288 ui_out_text (uiout, "\nOld value = ");
2289 value_print (bs->old_val, stb->stream, 0, Val_pretty_default);
2290 ui_out_field_stream (uiout, "old", stb);
2291 ui_out_text (uiout, "\nNew value = ");
2292 value_print (bs->breakpoint_at->val, stb->stream, 0, Val_pretty_default);
2293 ui_out_field_stream (uiout, "new", stb);
2294 do_cleanups (ui_out_chain);
2295 ui_out_text (uiout, "\n");
2296 value_free (bs->old_val);
2299 /* More than one watchpoint may have been triggered. */
2300 return PRINT_UNKNOWN;
2303 case bp_read_watchpoint:
2304 if (ui_out_is_mi_like_p (uiout))
2305 ui_out_field_string (uiout, "reason", "read-watchpoint-trigger");
2306 mention (bs->breakpoint_at);
2307 ui_out_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "value");
2308 ui_out_text (uiout, "\nValue = ");
2309 value_print (bs->breakpoint_at->val, stb->stream, 0, Val_pretty_default);
2310 ui_out_field_stream (uiout, "value", stb);
2311 do_cleanups (ui_out_chain);
2312 ui_out_text (uiout, "\n");
2313 return PRINT_UNKNOWN;
2316 case bp_access_watchpoint:
2317 if (bs->old_val != NULL)
2319 annotate_watchpoint (bs->breakpoint_at->number);
2320 if (ui_out_is_mi_like_p (uiout))
2321 ui_out_field_string (uiout, "reason", "access-watchpoint-trigger");
2322 mention (bs->breakpoint_at);
2323 ui_out_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "value");
2324 ui_out_text (uiout, "\nOld value = ");
2325 value_print (bs->old_val, stb->stream, 0, Val_pretty_default);
2326 ui_out_field_stream (uiout, "old", stb);
2327 value_free (bs->old_val);
2329 ui_out_text (uiout, "\nNew value = ");
2333 mention (bs->breakpoint_at);
2334 if (ui_out_is_mi_like_p (uiout))
2335 ui_out_field_string (uiout, "reason", "access-watchpoint-trigger");
2336 ui_out_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "value");
2337 ui_out_text (uiout, "\nValue = ");
2339 value_print (bs->breakpoint_at->val, stb->stream, 0,Val_pretty_default);
2340 ui_out_field_stream (uiout, "new", stb);
2341 do_cleanups (ui_out_chain);
2342 ui_out_text (uiout, "\n");
2343 return PRINT_UNKNOWN;
2346 /* Fall through, we don't deal with these types of breakpoints
2350 if (ui_out_is_mi_like_p (uiout))
2351 ui_out_field_string (uiout, "reason", "function-finished");
2352 return PRINT_UNKNOWN;
2356 if (ui_out_is_mi_like_p (uiout))
2357 ui_out_field_string (uiout, "reason", "location-reached");
2358 return PRINT_UNKNOWN;
2363 case bp_longjmp_resume:
2364 case bp_step_resume:
2365 case bp_through_sigtramp:
2366 case bp_watchpoint_scope:
2369 return PRINT_UNKNOWN;
2373 /* Generic routine for printing messages indicating why we
2374 stopped. The behavior of this function depends on the value
2375 'print_it' in the bpstat structure. Under some circumstances we
2376 may decide not to print anything here and delegate the task to
2379 static enum print_stop_action
2380 print_bp_stop_message (bpstat bs)
2382 switch (bs->print_it)
2385 /* Nothing should be printed for this bpstat entry. */
2386 return PRINT_UNKNOWN;
2390 /* We still want to print the frame, but we already printed the
2391 relevant messages. */
2392 return PRINT_SRC_AND_LOC;
2395 case print_it_normal:
2396 /* Normal case. Call the breakpoint's print_it method, or
2397 print_it_typical. */
2398 if (bs->breakpoint_at != NULL && bs->breakpoint_at->ops != NULL
2399 && bs->breakpoint_at->ops->print_it != NULL)
2400 return bs->breakpoint_at->ops->print_it (bs->breakpoint_at);
2402 return print_it_typical (bs);
2406 internal_error (__FILE__, __LINE__,
2407 "print_bp_stop_message: unrecognized enum value");
2412 /* Print a message indicating what happened. This is called from
2413 normal_stop(). The input to this routine is the head of the bpstat
2414 list - a list of the eventpoints that caused this stop. This
2415 routine calls the generic print routine for printing a message
2416 about reasons for stopping. This will print (for example) the
2417 "Breakpoint n," part of the output. The return value of this
2420 PRINT_UNKNOWN: Means we printed nothing
2421 PRINT_SRC_AND_LOC: Means we printed something, and expect subsequent
2422 code to print the location. An example is
2423 "Breakpoint 1, " which should be followed by
2425 PRINT_SRC_ONLY: Means we printed something, but there is no need
2426 to also print the location part of the message.
2427 An example is the catch/throw messages, which
2428 don't require a location appended to the end.
2429 PRINT_NOTHING: We have done some printing and we don't need any
2430 further info to be printed.*/
2432 enum print_stop_action
2433 bpstat_print (bpstat bs)
2437 /* Maybe another breakpoint in the chain caused us to stop.
2438 (Currently all watchpoints go on the bpstat whether hit or not.
2439 That probably could (should) be changed, provided care is taken
2440 with respect to bpstat_explains_signal). */
2441 for (; bs; bs = bs->next)
2443 val = print_bp_stop_message (bs);
2444 if (val == PRINT_SRC_ONLY
2445 || val == PRINT_SRC_AND_LOC
2446 || val == PRINT_NOTHING)
2450 /* We reached the end of the chain, or we got a null BS to start
2451 with and nothing was printed. */
2452 return PRINT_UNKNOWN;
2455 /* Evaluate the expression EXP and return 1 if value is zero.
2456 This is used inside a catch_errors to evaluate the breakpoint condition.
2457 The argument is a "struct expression *" that has been cast to char * to
2458 make it pass through catch_errors. */
2461 breakpoint_cond_eval (void *exp)
2463 struct value *mark = value_mark ();
2464 int i = !value_true (evaluate_expression ((struct expression *) exp));
2465 value_free_to_mark (mark);
2469 /* Allocate a new bpstat and chain it to the current one. */
2472 bpstat_alloc (struct breakpoint *b, bpstat cbs /* Current "bs" value */ )
2476 bs = (bpstat) xmalloc (sizeof (*bs));
2478 bs->breakpoint_at = b;
2479 /* If the condition is false, etc., don't do the commands. */
2480 bs->commands = NULL;
2482 bs->print_it = print_it_normal;
2486 /* Possible return values for watchpoint_check (this can't be an enum
2487 because of check_errors). */
2488 /* The watchpoint has been deleted. */
2489 #define WP_DELETED 1
2490 /* The value has changed. */
2491 #define WP_VALUE_CHANGED 2
2492 /* The value has not changed. */
2493 #define WP_VALUE_NOT_CHANGED 3
2495 #define BP_TEMPFLAG 1
2496 #define BP_HARDWAREFLAG 2
2498 /* Check watchpoint condition. */
2501 watchpoint_check (void *p)
2503 bpstat bs = (bpstat) p;
2504 struct breakpoint *b;
2505 struct frame_info *fr;
2506 int within_current_scope;
2508 b = bs->breakpoint_at;
2510 if (b->exp_valid_block == NULL)
2511 within_current_scope = 1;
2514 /* There is no current frame at this moment. If we're going to have
2515 any chance of handling watchpoints on local variables, we'll need
2516 the frame chain (so we can determine if we're in scope). */
2517 reinit_frame_cache ();
2518 fr = frame_find_by_id (b->watchpoint_frame);
2519 within_current_scope = (fr != NULL);
2520 /* in_function_epilogue_p() returns a non-zero value if we're still
2521 in the function but the stack frame has already been invalidated.
2522 Since we can't rely on the values of local variables after the
2523 stack has been destroyed, we are treating the watchpoint in that
2524 state as `not changed' without further checking.
2526 vinschen/2003-09-04: The former implementation left out the case
2527 that the watchpoint frame couldn't be found by frame_find_by_id()
2528 because the current PC is currently in an epilogue. Calling
2529 gdbarch_in_function_epilogue_p() also when fr == NULL fixes that. */
2530 if ((!within_current_scope || fr == get_current_frame ())
2531 && gdbarch_in_function_epilogue_p (current_gdbarch, read_pc ()))
2532 return WP_VALUE_NOT_CHANGED;
2533 if (fr && within_current_scope)
2534 /* If we end up stopping, the current frame will get selected
2535 in normal_stop. So this call to select_frame won't affect
2540 if (within_current_scope)
2542 /* We use value_{,free_to_}mark because it could be a
2543 *long* time before we return to the command level and
2544 call free_all_values. We can't call free_all_values because
2545 we might be in the middle of evaluating a function call. */
2547 struct value *mark = value_mark ();
2548 struct value *new_val = evaluate_expression (bs->breakpoint_at->exp);
2549 if (!value_equal (b->val, new_val))
2551 release_value (new_val);
2552 value_free_to_mark (mark);
2553 bs->old_val = b->val;
2555 /* We will stop here */
2556 return WP_VALUE_CHANGED;
2560 /* Nothing changed, don't do anything. */
2561 value_free_to_mark (mark);
2562 /* We won't stop here */
2563 return WP_VALUE_NOT_CHANGED;
2568 /* This seems like the only logical thing to do because
2569 if we temporarily ignored the watchpoint, then when
2570 we reenter the block in which it is valid it contains
2571 garbage (in the case of a function, it may have two
2572 garbage values, one before and one after the prologue).
2573 So we can't even detect the first assignment to it and
2574 watch after that (since the garbage may or may not equal
2575 the first value assigned). */
2576 /* We print all the stop information in print_it_typical(), but
2577 in this case, by the time we call print_it_typical() this bp
2578 will be deleted already. So we have no choice but print the
2579 information here. */
2580 if (ui_out_is_mi_like_p (uiout))
2581 ui_out_field_string (uiout, "reason", "watchpoint-scope");
2582 ui_out_text (uiout, "\nWatchpoint ");
2583 ui_out_field_int (uiout, "wpnum", bs->breakpoint_at->number);
2584 ui_out_text (uiout, " deleted because the program has left the block in\n\
2585 which its expression is valid.\n");
2587 if (b->related_breakpoint)
2588 b->related_breakpoint->disposition = disp_del_at_next_stop;
2589 b->disposition = disp_del_at_next_stop;
2595 /* Get a bpstat associated with having just stopped at address
2598 /* Determine whether we stopped at a breakpoint, etc, or whether we
2599 don't understand this stop. Result is a chain of bpstat's such that:
2601 if we don't understand the stop, the result is a null pointer.
2603 if we understand why we stopped, the result is not null.
2605 Each element of the chain refers to a particular breakpoint or
2606 watchpoint at which we have stopped. (We may have stopped for
2607 several reasons concurrently.)
2609 Each element of the chain has valid next, breakpoint_at,
2610 commands, FIXME??? fields. */
2613 bpstat_stop_status (CORE_ADDR bp_addr, ptid_t ptid)
2615 struct breakpoint *b, *temp;
2616 /* True if we've hit a breakpoint (as opposed to a watchpoint). */
2617 int real_breakpoint = 0;
2618 /* Root of the chain of bpstat's */
2619 struct bpstats root_bs[1];
2620 /* Pointer to the last thing in the chain currently. */
2621 bpstat bs = root_bs;
2622 int thread_id = pid_to_thread_id (ptid);
2624 ALL_BREAKPOINTS_SAFE (b, temp)
2626 if (!breakpoint_enabled (b) && b->enable_state != bp_permanent)
2629 /* Hardware watchpoints are treated as non-existent if the reason we
2630 stopped wasn't a hardware watchpoint (we didn't stop on some data
2631 address). Otherwise gdb won't stop on a break instruction in the code
2632 (not from a breakpoint) when a hardware watchpoint has been defined. */
2633 if (b->type != bp_watchpoint
2634 && !((b->type == bp_hardware_watchpoint
2635 || b->type == bp_read_watchpoint
2636 || b->type == bp_access_watchpoint)
2637 && target_stopped_data_address () != 0)
2638 && b->type != bp_hardware_breakpoint
2639 && b->type != bp_catch_fork
2640 && b->type != bp_catch_vfork
2641 && b->type != bp_catch_exec
2642 && b->type != bp_catch_catch
2643 && b->type != bp_catch_throw) /* a non-watchpoint bp */
2645 if (b->loc->address != bp_addr) /* address doesn't match */
2647 if (overlay_debugging /* unmapped overlay section */
2648 && section_is_overlay (b->loc->section)
2649 && !section_is_mapped (b->loc->section))
2653 if (b->type == bp_hardware_breakpoint)
2655 if (b->loc->address != bp_addr)
2657 if (overlay_debugging /* unmapped overlay section */
2658 && section_is_overlay (b->loc->section)
2659 && !section_is_mapped (b->loc->section))
2663 /* Is this a catchpoint of a load or unload? If so, did we
2664 get a load or unload of the specified library? If not,
2666 if ((b->type == bp_catch_load)
2667 #if defined(SOLIB_HAVE_LOAD_EVENT)
2668 && (!SOLIB_HAVE_LOAD_EVENT (PIDGET (inferior_ptid))
2669 || ((b->dll_pathname != NULL)
2670 && (strcmp (b->dll_pathname,
2671 SOLIB_LOADED_LIBRARY_PATHNAME (
2672 PIDGET (inferior_ptid)))
2678 if ((b->type == bp_catch_unload)
2679 #if defined(SOLIB_HAVE_UNLOAD_EVENT)
2680 && (!SOLIB_HAVE_UNLOAD_EVENT (PIDGET (inferior_ptid))
2681 || ((b->dll_pathname != NULL)
2682 && (strcmp (b->dll_pathname,
2683 SOLIB_UNLOADED_LIBRARY_PATHNAME (
2684 PIDGET (inferior_ptid)))
2690 if ((b->type == bp_catch_fork)
2691 && !inferior_has_forked (PIDGET (inferior_ptid),
2692 &b->forked_inferior_pid))
2695 if ((b->type == bp_catch_vfork)
2696 && !inferior_has_vforked (PIDGET (inferior_ptid),
2697 &b->forked_inferior_pid))
2700 if ((b->type == bp_catch_exec)
2701 && !inferior_has_execd (PIDGET (inferior_ptid), &b->exec_pathname))
2704 if (ep_is_exception_catchpoint (b) &&
2705 !(current_exception_event = target_get_current_exception_event ()))
2708 /* Come here if it's a watchpoint, or if the break address matches */
2710 bs = bpstat_alloc (b, bs); /* Alloc a bpstat to explain stop */
2712 /* Watchpoints may change this, if not found to have triggered. */
2716 if (b->type == bp_watchpoint ||
2717 b->type == bp_hardware_watchpoint)
2719 char *message = xstrprintf ("Error evaluating expression for watchpoint %d\n",
2721 struct cleanup *cleanups = make_cleanup (xfree, message);
2722 int e = catch_errors (watchpoint_check, bs, message,
2724 do_cleanups (cleanups);
2728 /* We've already printed what needs to be printed. */
2729 /* Actually this is superfluous, because by the time we
2730 call print_it_typical() the wp will be already deleted,
2731 and the function will return immediately. */
2732 bs->print_it = print_it_done;
2735 case WP_VALUE_CHANGED:
2739 case WP_VALUE_NOT_CHANGED:
2741 bs->print_it = print_it_noop;
2748 /* Error from catch_errors. */
2749 printf_filtered ("Watchpoint %d deleted.\n", b->number);
2750 if (b->related_breakpoint)
2751 b->related_breakpoint->disposition = disp_del_at_next_stop;
2752 b->disposition = disp_del_at_next_stop;
2753 /* We've already printed what needs to be printed. */
2754 bs->print_it = print_it_done;
2760 else if (b->type == bp_read_watchpoint ||
2761 b->type == bp_access_watchpoint)
2767 addr = target_stopped_data_address ();
2770 for (v = b->val_chain; v; v = v->next)
2772 if (VALUE_LVAL (v) == lval_memory
2773 && ! VALUE_LAZY (v))
2775 struct type *vtype = check_typedef (VALUE_TYPE (v));
2777 if (v == b->val_chain
2778 || (TYPE_CODE (vtype) != TYPE_CODE_STRUCT
2779 && TYPE_CODE (vtype) != TYPE_CODE_ARRAY))
2783 vaddr = VALUE_ADDRESS (v) + VALUE_OFFSET (v);
2784 /* Exact match not required. Within range is
2786 if (addr >= vaddr &&
2787 addr < vaddr + TYPE_LENGTH (VALUE_TYPE (v)))
2794 char *message = xstrprintf ("Error evaluating expression for watchpoint %d\n",
2796 struct cleanup *cleanups = make_cleanup (xfree, message);
2797 int e = catch_errors (watchpoint_check, bs, message,
2799 do_cleanups (cleanups);
2803 /* We've already printed what needs to be printed. */
2804 bs->print_it = print_it_done;
2807 case WP_VALUE_CHANGED:
2808 if (b->type == bp_read_watchpoint)
2810 /* Don't stop: read watchpoints shouldn't fire if
2811 the value has changed. This is for targets
2812 which cannot set read-only watchpoints. */
2813 bs->print_it = print_it_noop;
2819 case WP_VALUE_NOT_CHANGED:
2826 /* Error from catch_errors. */
2827 printf_filtered ("Watchpoint %d deleted.\n", b->number);
2828 if (b->related_breakpoint)
2829 b->related_breakpoint->disposition = disp_del_at_next_stop;
2830 b->disposition = disp_del_at_next_stop;
2831 /* We've already printed what needs to be printed. */
2832 bs->print_it = print_it_done;
2836 else /* found == 0 */
2838 /* This is a case where some watchpoint(s) triggered,
2839 but not at the address of this watchpoint (FOUND
2840 was left zero). So don't print anything for this
2842 bs->print_it = print_it_noop;
2849 /* By definition, an encountered breakpoint is a triggered
2853 real_breakpoint = 1;
2856 if (frame_id_p (b->frame_id)
2857 && !frame_id_eq (b->frame_id, get_frame_id (get_current_frame ())))
2861 int value_is_zero = 0;
2865 /* Need to select the frame, with all that implies
2866 so that the conditions will have the right context. */
2867 select_frame (get_current_frame ());
2869 = catch_errors (breakpoint_cond_eval, (b->cond),
2870 "Error in testing breakpoint condition:\n",
2872 /* FIXME-someday, should give breakpoint # */
2875 if (b->cond && value_is_zero)
2878 /* Don't consider this a hit. */
2881 else if (b->thread != -1 && b->thread != thread_id)
2884 /* Don't consider this a hit. */
2887 else if (b->ignore_count > 0)
2890 annotate_ignore_count_change ();
2895 /* We will stop here */
2896 if (b->disposition == disp_disable)
2897 b->enable_state = bp_disabled;
2900 bs->commands = b->commands;
2902 (strcmp ("silent", bs->commands->line) == 0
2903 || (xdb_commands && strcmp ("Q", bs->commands->line) == 0)))
2905 bs->commands = bs->commands->next;
2908 bs->commands = copy_command_lines (bs->commands);
2911 /* Print nothing for this entry if we dont stop or if we dont print. */
2912 if (bs->stop == 0 || bs->print == 0)
2913 bs->print_it = print_it_noop;
2916 bs->next = NULL; /* Terminate the chain */
2917 bs = root_bs->next; /* Re-grab the head of the chain */
2919 /* The value of a hardware watchpoint hasn't changed, but the
2920 intermediate memory locations we are watching may have. */
2921 if (bs && !bs->stop &&
2922 (bs->breakpoint_at->type == bp_hardware_watchpoint ||
2923 bs->breakpoint_at->type == bp_read_watchpoint ||
2924 bs->breakpoint_at->type == bp_access_watchpoint))
2926 remove_breakpoints ();
2927 insert_breakpoints ();
2932 /* Tell what to do about this bpstat. */
2934 bpstat_what (bpstat bs)
2936 /* Classify each bpstat as one of the following. */
2939 /* This bpstat element has no effect on the main_action. */
2942 /* There was a watchpoint, stop but don't print. */
2945 /* There was a watchpoint, stop and print. */
2948 /* There was a breakpoint but we're not stopping. */
2951 /* There was a breakpoint, stop but don't print. */
2954 /* There was a breakpoint, stop and print. */
2957 /* We hit the longjmp breakpoint. */
2960 /* We hit the longjmp_resume breakpoint. */
2963 /* We hit the step_resume breakpoint. */
2966 /* We hit the through_sigtramp breakpoint. */
2969 /* We hit the shared library event breakpoint. */
2972 /* We caught a shared library event. */
2975 /* This is just used to count how many enums there are. */
2979 /* Here is the table which drives this routine. So that we can
2980 format it pretty, we define some abbreviations for the
2981 enum bpstat_what codes. */
2982 #define kc BPSTAT_WHAT_KEEP_CHECKING
2983 #define ss BPSTAT_WHAT_STOP_SILENT
2984 #define sn BPSTAT_WHAT_STOP_NOISY
2985 #define sgl BPSTAT_WHAT_SINGLE
2986 #define slr BPSTAT_WHAT_SET_LONGJMP_RESUME
2987 #define clr BPSTAT_WHAT_CLEAR_LONGJMP_RESUME
2988 #define clrs BPSTAT_WHAT_CLEAR_LONGJMP_RESUME_SINGLE
2989 #define sr BPSTAT_WHAT_STEP_RESUME
2990 #define ts BPSTAT_WHAT_THROUGH_SIGTRAMP
2991 #define shl BPSTAT_WHAT_CHECK_SHLIBS
2992 #define shlr BPSTAT_WHAT_CHECK_SHLIBS_RESUME_FROM_HOOK
2994 /* "Can't happen." Might want to print an error message.
2995 abort() is not out of the question, but chances are GDB is just
2996 a bit confused, not unusable. */
2997 #define err BPSTAT_WHAT_STOP_NOISY
2999 /* Given an old action and a class, come up with a new action. */
3000 /* One interesting property of this table is that wp_silent is the same
3001 as bp_silent and wp_noisy is the same as bp_noisy. That is because
3002 after stopping, the check for whether to step over a breakpoint
3003 (BPSTAT_WHAT_SINGLE type stuff) is handled in proceed() without
3004 reference to how we stopped. We retain separate wp_silent and
3005 bp_silent codes in case we want to change that someday.
3007 Another possibly interesting property of this table is that
3008 there's a partial ordering, priority-like, of the actions. Once
3009 you've decided that some action is appropriate, you'll never go
3010 back and decide something of a lower priority is better. The
3013 kc < clr sgl shl shlr slr sn sr ss ts
3014 sgl < clrs shl shlr slr sn sr ss ts
3015 slr < err shl shlr sn sr ss ts
3016 clr < clrs err shl shlr sn sr ss ts
3017 clrs < err shl shlr sn sr ss ts
3018 ss < shl shlr sn sr ts
3025 What I think this means is that we don't need a damned table
3026 here. If you just put the rows and columns in the right order,
3027 it'd look awfully regular. We could simply walk the bpstat list
3028 and choose the highest priority action we find, with a little
3029 logic to handle the 'err' cases, and the CLEAR_LONGJMP_RESUME/
3030 CLEAR_LONGJMP_RESUME_SINGLE distinction (which breakpoint.h says
3031 is messy anyway). */
3033 /* step_resume entries: a step resume breakpoint overrides another
3034 breakpoint of signal handling (see comment in wait_for_inferior
3035 at where we set the step_resume breakpoint). */
3036 /* We handle the through_sigtramp_breakpoint the same way; having both
3037 one of those and a step_resume_breakpoint is probably very rare (?). */
3039 static const enum bpstat_what_main_action
3040 table[(int) class_last][(int) BPSTAT_WHAT_LAST] =
3043 /* kc ss sn sgl slr clr clrs sr ts shl shlr
3046 {kc, ss, sn, sgl, slr, clr, clrs, sr, ts, shl, shlr},
3048 {ss, ss, sn, ss, ss, ss, ss, sr, ts, shl, shlr},
3050 {sn, sn, sn, sn, sn, sn, sn, sr, ts, shl, shlr},
3052 {sgl, ss, sn, sgl, slr, clrs, clrs, sr, ts, shl, shlr},
3054 {ss, ss, sn, ss, ss, ss, ss, sr, ts, shl, shlr},
3056 {sn, sn, sn, sn, sn, sn, sn, sr, ts, shl, shlr},
3058 {slr, ss, sn, slr, slr, err, err, sr, ts, shl, shlr},
3060 {clr, ss, sn, clrs, err, err, err, sr, ts, shl, shlr},
3062 {sr, sr, sr, sr, sr, sr, sr, sr, ts, shl, shlr},
3064 {ts, ts, ts, ts, ts, ts, ts, ts, ts, shl, shlr},
3066 {shl, shl, shl, shl, shl, shl, shl, shl, ts, shl, shlr},
3068 {shlr, shlr, shlr, shlr, shlr, shlr, shlr, shlr, ts, shlr, shlr}
3083 enum bpstat_what_main_action current_action = BPSTAT_WHAT_KEEP_CHECKING;
3084 struct bpstat_what retval;
3086 retval.call_dummy = 0;
3087 for (; bs != NULL; bs = bs->next)
3089 enum class bs_class = no_effect;
3090 if (bs->breakpoint_at == NULL)
3091 /* I suspect this can happen if it was a momentary breakpoint
3092 which has since been deleted. */
3094 switch (bs->breakpoint_at->type)
3100 case bp_hardware_breakpoint:
3106 bs_class = bp_noisy;
3108 bs_class = bp_silent;
3111 bs_class = bp_nostop;
3114 case bp_hardware_watchpoint:
3115 case bp_read_watchpoint:
3116 case bp_access_watchpoint:
3120 bs_class = wp_noisy;
3122 bs_class = wp_silent;
3125 /* There was a watchpoint, but we're not stopping.
3126 This requires no further action. */
3127 bs_class = no_effect;
3130 bs_class = long_jump;
3132 case bp_longjmp_resume:
3133 bs_class = long_resume;
3135 case bp_step_resume:
3138 bs_class = step_resume;
3141 /* It is for the wrong frame. */
3142 bs_class = bp_nostop;
3144 case bp_through_sigtramp:
3145 bs_class = through_sig;
3147 case bp_watchpoint_scope:
3148 bs_class = bp_nostop;
3150 case bp_shlib_event:
3151 bs_class = shlib_event;
3153 case bp_thread_event:
3154 case bp_overlay_event:
3155 bs_class = bp_nostop;
3158 case bp_catch_unload:
3159 /* Only if this catchpoint triggered should we cause the
3160 step-out-of-dld behaviour. Otherwise, we ignore this
3163 bs_class = catch_shlib_event;
3165 bs_class = no_effect;
3168 case bp_catch_vfork:
3173 bs_class = bp_noisy;
3175 bs_class = bp_silent;
3178 /* There was a catchpoint, but we're not stopping.
3179 This requires no further action. */
3180 bs_class = no_effect;
3182 case bp_catch_catch:
3183 if (!bs->stop || CURRENT_EXCEPTION_KIND != EX_EVENT_CATCH)
3184 bs_class = bp_nostop;
3186 bs_class = bs->print ? bp_noisy : bp_silent;
3188 case bp_catch_throw:
3189 if (!bs->stop || CURRENT_EXCEPTION_KIND != EX_EVENT_THROW)
3190 bs_class = bp_nostop;
3192 bs_class = bs->print ? bp_noisy : bp_silent;
3195 /* Make sure the action is stop (silent or noisy),
3196 so infrun.c pops the dummy frame. */
3197 bs_class = bp_silent;
3198 retval.call_dummy = 1;
3201 current_action = table[(int) bs_class][(int) current_action];
3203 retval.main_action = current_action;
3207 /* Nonzero if we should step constantly (e.g. watchpoints on machines
3208 without hardware support). This isn't related to a specific bpstat,
3209 just to things like whether watchpoints are set. */
3212 bpstat_should_step (void)
3214 struct breakpoint *b;
3216 if (breakpoint_enabled (b) && b->type == bp_watchpoint)
3221 /* Nonzero if there are enabled hardware watchpoints. */
3223 bpstat_have_active_hw_watchpoints (void)
3225 struct bp_location *bpt;
3226 ALL_BP_LOCATIONS (bpt)
3227 if (breakpoint_enabled (bpt->owner)
3229 && bpt->loc_type == bp_loc_hardware_watchpoint)
3235 /* Given a bpstat that records zero or more triggered eventpoints, this
3236 function returns another bpstat which contains only the catchpoints
3237 on that first list, if any. */
3239 bpstat_get_triggered_catchpoints (bpstat ep_list, bpstat *cp_list)
3241 struct bpstats root_bs[1];
3242 bpstat bs = root_bs;
3243 struct breakpoint *ep;
3246 bpstat_clear (cp_list);
3247 root_bs->next = NULL;
3249 for (; ep_list != NULL; ep_list = ep_list->next)
3251 /* Is this eventpoint a catchpoint? If not, ignore it. */
3252 ep = ep_list->breakpoint_at;
3255 if ((ep->type != bp_catch_load) &&
3256 (ep->type != bp_catch_unload) &&
3257 (ep->type != bp_catch_catch) &&
3258 (ep->type != bp_catch_throw))
3259 /* pai: (temp) ADD fork/vfork here!! */
3262 /* Yes; add it to the list. */
3263 bs = bpstat_alloc (ep, bs);
3268 #if defined(SOLIB_ADD)
3269 /* Also, for each triggered catchpoint, tag it with the name of
3270 the library that caused this trigger. (We copy the name now,
3271 because it's only guaranteed to be available NOW, when the
3272 catchpoint triggers. Clients who may wish to know the name
3273 later must get it from the catchpoint itself.) */
3274 if (ep->triggered_dll_pathname != NULL)
3275 xfree (ep->triggered_dll_pathname);
3276 if (ep->type == bp_catch_load)
3277 dll_pathname = SOLIB_LOADED_LIBRARY_PATHNAME (
3278 PIDGET (inferior_ptid));
3280 dll_pathname = SOLIB_UNLOADED_LIBRARY_PATHNAME (
3281 PIDGET (inferior_ptid));
3283 dll_pathname = NULL;
3287 ep->triggered_dll_pathname = (char *)
3288 xmalloc (strlen (dll_pathname) + 1);
3289 strcpy (ep->triggered_dll_pathname, dll_pathname);
3292 ep->triggered_dll_pathname = NULL;
3298 /* Print B to gdb_stdout. */
3300 print_one_breakpoint (struct breakpoint *b,
3301 CORE_ADDR *last_addr)
3303 struct command_line *l;
3305 struct ep_type_description
3310 static struct ep_type_description bptypes[] =
3312 {bp_none, "?deleted?"},
3313 {bp_breakpoint, "breakpoint"},
3314 {bp_hardware_breakpoint, "hw breakpoint"},
3315 {bp_until, "until"},
3316 {bp_finish, "finish"},
3317 {bp_watchpoint, "watchpoint"},
3318 {bp_hardware_watchpoint, "hw watchpoint"},
3319 {bp_read_watchpoint, "read watchpoint"},
3320 {bp_access_watchpoint, "acc watchpoint"},
3321 {bp_longjmp, "longjmp"},
3322 {bp_longjmp_resume, "longjmp resume"},
3323 {bp_step_resume, "step resume"},
3324 {bp_through_sigtramp, "sigtramp"},
3325 {bp_watchpoint_scope, "watchpoint scope"},
3326 {bp_call_dummy, "call dummy"},
3327 {bp_shlib_event, "shlib events"},
3328 {bp_thread_event, "thread events"},
3329 {bp_overlay_event, "overlay events"},
3330 {bp_catch_load, "catch load"},
3331 {bp_catch_unload, "catch unload"},
3332 {bp_catch_fork, "catch fork"},
3333 {bp_catch_vfork, "catch vfork"},
3334 {bp_catch_exec, "catch exec"},
3335 {bp_catch_catch, "catch catch"},
3336 {bp_catch_throw, "catch throw"}
3339 static char *bpdisps[] =
3340 {"del", "dstp", "dis", "keep"};
3341 static char bpenables[] = "nynny";
3342 char wrap_indent[80];
3343 struct ui_stream *stb = ui_out_stream_new (uiout);
3344 struct cleanup *old_chain = make_cleanup_ui_out_stream_delete (stb);
3345 struct cleanup *bkpt_chain;
3348 bkpt_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "bkpt");
3352 ui_out_field_int (uiout, "number", b->number);
3356 if (((int) b->type > (sizeof (bptypes) / sizeof (bptypes[0])))
3357 || ((int) b->type != bptypes[(int) b->type].type))
3358 internal_error (__FILE__, __LINE__,
3359 "bptypes table does not describe type #%d.",
3361 ui_out_field_string (uiout, "type", bptypes[(int) b->type].description);
3365 ui_out_field_string (uiout, "disp", bpdisps[(int) b->disposition]);
3369 ui_out_field_fmt (uiout, "enabled", "%c", bpenables[(int) b->enable_state]);
3370 ui_out_spaces (uiout, 2);
3373 strcpy (wrap_indent, " ");
3376 if (TARGET_ADDR_BIT <= 32)
3377 strcat (wrap_indent, " ");
3379 strcat (wrap_indent, " ");
3382 if (b->ops != NULL && b->ops->print_one != NULL)
3383 b->ops->print_one (b, last_addr);
3388 internal_error (__FILE__, __LINE__,
3389 "print_one_breakpoint: bp_none encountered\n");
3393 case bp_hardware_watchpoint:
3394 case bp_read_watchpoint:
3395 case bp_access_watchpoint:
3396 /* Field 4, the address, is omitted (which makes the columns
3397 not line up too nicely with the headers, but the effect
3398 is relatively readable). */
3400 ui_out_field_skip (uiout, "addr");
3402 print_expression (b->exp, stb->stream);
3403 ui_out_field_stream (uiout, "what", stb);
3407 case bp_catch_unload:
3408 /* Field 4, the address, is omitted (which makes the columns
3409 not line up too nicely with the headers, but the effect
3410 is relatively readable). */
3412 ui_out_field_skip (uiout, "addr");
3414 if (b->dll_pathname == NULL)
3416 ui_out_field_string (uiout, "what", "<any library>");
3417 ui_out_spaces (uiout, 1);
3421 ui_out_text (uiout, "library \"");
3422 ui_out_field_string (uiout, "what", b->dll_pathname);
3423 ui_out_text (uiout, "\" ");
3428 case bp_catch_vfork:
3429 /* Field 4, the address, is omitted (which makes the columns
3430 not line up too nicely with the headers, but the effect
3431 is relatively readable). */
3433 ui_out_field_skip (uiout, "addr");
3435 if (b->forked_inferior_pid != 0)
3437 ui_out_text (uiout, "process ");
3438 ui_out_field_int (uiout, "what", b->forked_inferior_pid);
3439 ui_out_spaces (uiout, 1);
3443 /* Field 4, the address, is omitted (which makes the columns
3444 not line up too nicely with the headers, but the effect
3445 is relatively readable). */
3447 ui_out_field_skip (uiout, "addr");
3449 if (b->exec_pathname != NULL)
3451 ui_out_text (uiout, "program \"");
3452 ui_out_field_string (uiout, "what", b->exec_pathname);
3453 ui_out_text (uiout, "\" ");
3457 case bp_catch_catch:
3458 /* Field 4, the address, is omitted (which makes the columns
3459 not line up too nicely with the headers, but the effect
3460 is relatively readable). */
3462 ui_out_field_skip (uiout, "addr");
3464 ui_out_field_string (uiout, "what", "exception catch");
3465 ui_out_spaces (uiout, 1);
3468 case bp_catch_throw:
3469 /* Field 4, the address, is omitted (which makes the columns
3470 not line up too nicely with the headers, but the effect
3471 is relatively readable). */
3473 ui_out_field_skip (uiout, "addr");
3475 ui_out_field_string (uiout, "what", "exception throw");
3476 ui_out_spaces (uiout, 1);
3480 case bp_hardware_breakpoint:
3484 case bp_longjmp_resume:
3485 case bp_step_resume:
3486 case bp_through_sigtramp:
3487 case bp_watchpoint_scope:
3489 case bp_shlib_event:
3490 case bp_thread_event:
3491 case bp_overlay_event:
3496 ui_out_field_string (uiout, "addr", "<PENDING>");
3498 ui_out_field_core_addr (uiout, "addr", b->loc->address);
3501 *last_addr = b->loc->address;
3504 sym = find_pc_sect_function (b->loc->address, b->loc->section);
3507 ui_out_text (uiout, "in ");
3508 ui_out_field_string (uiout, "func",
3509 SYMBOL_PRINT_NAME (sym));
3510 ui_out_wrap_hint (uiout, wrap_indent);
3511 ui_out_text (uiout, " at ");
3513 ui_out_field_string (uiout, "file", b->source_file);
3514 ui_out_text (uiout, ":");
3515 ui_out_field_int (uiout, "line", b->line_number);
3517 else if (b->pending)
3519 ui_out_field_string (uiout, "pending", b->addr_string);
3523 print_address_symbolic (b->loc->address, stb->stream, demangle, "");
3524 ui_out_field_stream (uiout, "at", stb);
3529 if (b->thread != -1)
3531 /* FIXME: This seems to be redundant and lost here; see the
3532 "stop only in" line a little further down. */
3533 ui_out_text (uiout, " thread ");
3534 ui_out_field_int (uiout, "thread", b->thread);
3537 ui_out_text (uiout, "\n");
3539 if (frame_id_p (b->frame_id))
3542 ui_out_text (uiout, "\tstop only in stack frame at ");
3543 /* FIXME: cagney/2002-12-01: Shouldn't be poeking around inside
3545 ui_out_field_core_addr (uiout, "frame", b->frame_id.stack_addr);
3546 ui_out_text (uiout, "\n");
3552 ui_out_text (uiout, "\tstop only if ");
3553 print_expression (b->cond, stb->stream);
3554 ui_out_field_stream (uiout, "cond", stb);
3555 ui_out_text (uiout, "\n");
3558 if (b->pending && b->cond_string)
3561 ui_out_text (uiout, "\tstop only if ");
3562 ui_out_field_string (uiout, "cond", b->cond_string);
3563 ui_out_text (uiout, "\n");
3566 if (b->thread != -1)
3568 /* FIXME should make an annotation for this */
3569 ui_out_text (uiout, "\tstop only in thread ");
3570 ui_out_field_int (uiout, "thread", b->thread);
3571 ui_out_text (uiout, "\n");
3574 if (show_breakpoint_hit_counts && b->hit_count)
3576 /* FIXME should make an annotation for this */
3577 if (ep_is_catchpoint (b))
3578 ui_out_text (uiout, "\tcatchpoint");
3580 ui_out_text (uiout, "\tbreakpoint");
3581 ui_out_text (uiout, " already hit ");
3582 ui_out_field_int (uiout, "times", b->hit_count);
3583 if (b->hit_count == 1)
3584 ui_out_text (uiout, " time\n");
3586 ui_out_text (uiout, " times\n");
3589 /* Output the count also if it is zero, but only if this is
3590 mi. FIXME: Should have a better test for this. */
3591 if (ui_out_is_mi_like_p (uiout))
3592 if (show_breakpoint_hit_counts && b->hit_count == 0)
3593 ui_out_field_int (uiout, "times", b->hit_count);
3595 if (b->ignore_count)
3598 ui_out_text (uiout, "\tignore next ");
3599 ui_out_field_int (uiout, "ignore", b->ignore_count);
3600 ui_out_text (uiout, " hits\n");
3603 if ((l = b->commands))
3605 struct cleanup *script_chain;
3608 script_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "script");
3609 print_command_lines (uiout, l, 4);
3610 do_cleanups (script_chain);
3612 do_cleanups (bkpt_chain);
3613 do_cleanups (old_chain);
3616 struct captured_breakpoint_query_args
3622 do_captured_breakpoint_query (struct ui_out *uiout, void *data)
3624 struct captured_breakpoint_query_args *args = data;
3625 struct breakpoint *b;
3626 CORE_ADDR dummy_addr = 0;
3629 if (args->bnum == b->number)
3631 print_one_breakpoint (b, &dummy_addr);
3639 gdb_breakpoint_query (struct ui_out *uiout, int bnum)
3641 struct captured_breakpoint_query_args args;
3643 /* For the moment we don't trust print_one_breakpoint() to not throw
3645 return catch_exceptions (uiout, do_captured_breakpoint_query, &args,
3646 NULL, RETURN_MASK_ALL);
3649 /* Return non-zero if B is user settable (breakpoints, watchpoints,
3650 catchpoints, et.al.). */
3653 user_settable_breakpoint (const struct breakpoint *b)
3655 return (b->type == bp_breakpoint
3656 || b->type == bp_catch_load
3657 || b->type == bp_catch_unload
3658 || b->type == bp_catch_fork
3659 || b->type == bp_catch_vfork
3660 || b->type == bp_catch_exec
3661 || b->type == bp_catch_catch
3662 || b->type == bp_catch_throw
3663 || b->type == bp_hardware_breakpoint
3664 || b->type == bp_watchpoint
3665 || b->type == bp_read_watchpoint
3666 || b->type == bp_access_watchpoint
3667 || b->type == bp_hardware_watchpoint);
3670 /* Print information on user settable breakpoint (watchpoint, etc)
3671 number BNUM. If BNUM is -1 print all user settable breakpoints.
3672 If ALLFLAG is non-zero, include non- user settable breakpoints. */
3675 breakpoint_1 (int bnum, int allflag)
3677 struct breakpoint *b;
3678 CORE_ADDR last_addr = (CORE_ADDR) -1;
3679 int nr_printable_breakpoints;
3680 struct cleanup *bkpttbl_chain;
3682 /* Compute the number of rows in the table. */
3683 nr_printable_breakpoints = 0;
3686 || bnum == b->number)
3688 if (allflag || user_settable_breakpoint (b))
3689 nr_printable_breakpoints++;
3694 = make_cleanup_ui_out_table_begin_end (uiout, 6, nr_printable_breakpoints,
3698 = make_cleanup_ui_out_table_begin_end (uiout, 5, nr_printable_breakpoints,
3701 if (nr_printable_breakpoints > 0)
3702 annotate_breakpoints_headers ();
3703 if (nr_printable_breakpoints > 0)
3705 ui_out_table_header (uiout, 3, ui_left, "number", "Num"); /* 1 */
3706 if (nr_printable_breakpoints > 0)
3708 ui_out_table_header (uiout, 14, ui_left, "type", "Type"); /* 2 */
3709 if (nr_printable_breakpoints > 0)
3711 ui_out_table_header (uiout, 4, ui_left, "disp", "Disp"); /* 3 */
3712 if (nr_printable_breakpoints > 0)
3714 ui_out_table_header (uiout, 3, ui_left, "enabled", "Enb"); /* 4 */
3717 if (nr_printable_breakpoints > 0)
3719 if (TARGET_ADDR_BIT <= 32)
3720 ui_out_table_header (uiout, 10, ui_left, "addr", "Address");/* 5 */
3722 ui_out_table_header (uiout, 18, ui_left, "addr", "Address");/* 5 */
3724 if (nr_printable_breakpoints > 0)
3726 ui_out_table_header (uiout, 40, ui_noalign, "what", "What"); /* 6 */
3727 ui_out_table_body (uiout);
3728 if (nr_printable_breakpoints > 0)
3729 annotate_breakpoints_table ();
3733 || bnum == b->number)
3735 /* We only print out user settable breakpoints unless the
3737 if (allflag || user_settable_breakpoint (b))
3738 print_one_breakpoint (b, &last_addr);
3741 do_cleanups (bkpttbl_chain);
3743 if (nr_printable_breakpoints == 0)
3746 ui_out_message (uiout, 0, "No breakpoints or watchpoints.\n");
3748 ui_out_message (uiout, 0, "No breakpoint or watchpoint number %d.\n",
3753 /* Compare against (CORE_ADDR)-1 in case some compiler decides
3754 that a comparison of an unsigned with -1 is always false. */
3755 if (last_addr != (CORE_ADDR) -1)
3756 set_next_address (last_addr);
3759 /* FIXME? Should this be moved up so that it is only called when
3760 there have been breakpoints? */
3761 annotate_breakpoints_table_end ();
3765 breakpoints_info (char *bnum_exp, int from_tty)
3770 bnum = parse_and_eval_long (bnum_exp);
3772 breakpoint_1 (bnum, 0);
3776 maintenance_info_breakpoints (char *bnum_exp, int from_tty)
3781 bnum = parse_and_eval_long (bnum_exp);
3783 breakpoint_1 (bnum, 1);
3786 /* Print a message describing any breakpoints set at PC. */
3789 describe_other_breakpoints (CORE_ADDR pc, asection *section)
3792 struct breakpoint *b;
3795 if (b->loc->address == pc) /* address match / overlay match */
3796 if (!b->pending && (!overlay_debugging || b->loc->section == section))
3800 printf_filtered ("Note: breakpoint%s ", (others > 1) ? "s" : "");
3802 if (b->loc->address == pc) /* address match / overlay match */
3803 if (!b->pending && (!overlay_debugging || b->loc->section == section))
3806 printf_filtered ("%d%s%s ",
3808 ((b->enable_state == bp_disabled ||
3809 b->enable_state == bp_shlib_disabled ||
3810 b->enable_state == bp_call_disabled)
3812 : b->enable_state == bp_permanent
3816 : ((others == 1) ? " and" : ""));
3818 printf_filtered ("also set at pc ");
3819 print_address_numeric (pc, 1, gdb_stdout);
3820 printf_filtered (".\n");
3824 /* Set the default place to put a breakpoint
3825 for the `break' command with no arguments. */
3828 set_default_breakpoint (int valid, CORE_ADDR addr, struct symtab *symtab,
3831 default_breakpoint_valid = valid;
3832 default_breakpoint_address = addr;
3833 default_breakpoint_symtab = symtab;
3834 default_breakpoint_line = line;
3837 /* Return true iff it is meaningful to use the address member of
3838 BPT. For some breakpoint types, the address member is irrelevant
3839 and it makes no sense to attempt to compare it to other addresses
3840 (or use it for any other purpose either).
3842 More specifically, each of the following breakpoint types will always
3843 have a zero valued address and we don't want check_duplicates() to mark
3844 breakpoints of any of these types to be a duplicate of an actual
3845 breakpoint at address zero:
3848 bp_hardware_watchpoint
3850 bp_access_watchpoint
3857 breakpoint_address_is_meaningful (struct breakpoint *bpt)
3859 enum bptype type = bpt->type;
3861 return (type != bp_watchpoint
3862 && type != bp_hardware_watchpoint
3863 && type != bp_read_watchpoint
3864 && type != bp_access_watchpoint
3865 && type != bp_catch_exec
3866 && type != bp_longjmp_resume
3867 && type != bp_catch_fork
3868 && type != bp_catch_vfork);
3871 /* Rescan breakpoints at the same address and section as BPT,
3872 marking the first one as "first" and any others as "duplicates".
3873 This is so that the bpt instruction is only inserted once.
3874 If we have a permanent breakpoint at the same place as BPT, make
3875 that one the official one, and the rest as duplicates. */
3878 check_duplicates (struct breakpoint *bpt)
3880 struct bp_location *b;
3882 struct bp_location *perm_bp = 0;
3883 CORE_ADDR address = bpt->loc->address;
3884 asection *section = bpt->loc->section;
3886 if (! breakpoint_address_is_meaningful (bpt))
3889 ALL_BP_LOCATIONS (b)
3890 if (b->owner->enable_state != bp_disabled
3891 && b->owner->enable_state != bp_shlib_disabled
3892 && !b->owner->pending
3893 && b->owner->enable_state != bp_call_disabled
3894 && b->address == address /* address / overlay match */
3895 && (!overlay_debugging || b->section == section)
3896 && breakpoint_address_is_meaningful (b->owner))
3898 /* Have we found a permanent breakpoint? */
3899 if (b->owner->enable_state == bp_permanent)
3906 b->duplicate = count > 1;
3909 /* If we found a permanent breakpoint at this address, go over the
3910 list again and declare all the other breakpoints there to be the
3914 perm_bp->duplicate = 0;
3916 /* Permanent breakpoint should always be inserted. */
3917 if (! perm_bp->inserted)
3918 internal_error (__FILE__, __LINE__,
3919 "allegedly permanent breakpoint is not "
3920 "actually inserted");
3922 ALL_BP_LOCATIONS (b)
3925 if (b->owner->enable_state != bp_disabled
3926 && b->owner->enable_state != bp_shlib_disabled
3927 && !b->owner->pending
3928 && b->owner->enable_state != bp_call_disabled
3929 && b->address == address /* address / overlay match */
3930 && (!overlay_debugging || b->section == section)
3931 && breakpoint_address_is_meaningful (b->owner))
3934 internal_error (__FILE__, __LINE__,
3935 "another breakpoint was inserted on top of "
3936 "a permanent breakpoint");
3945 breakpoint_adjustment_warning (CORE_ADDR from_addr, CORE_ADDR to_addr,
3946 int bnum, int have_bnum)
3951 strcpy (astr1, local_hex_string_custom ((unsigned long) from_addr, "08l"));
3952 strcpy (astr2, local_hex_string_custom ((unsigned long) to_addr, "08l"));
3954 warning ("Breakpoint %d address previously adjusted from %s to %s.",
3955 bnum, astr1, astr2);
3957 warning ("Breakpoint address adjusted from %s to %s.", astr1, astr2);
3960 /* Adjust a breakpoint's address to account for architectural constraints
3961 on breakpoint placement. Return the adjusted address. Note: Very
3962 few targets require this kind of adjustment. For most targets,
3963 this function is simply the identity function. */
3966 adjust_breakpoint_address (CORE_ADDR bpaddr, enum bptype bptype)
3968 if (!gdbarch_adjust_breakpoint_address_p (current_gdbarch))
3970 /* Very few targets need any kind of breakpoint adjustment. */
3973 else if (bptype == bp_watchpoint
3974 || bptype == bp_hardware_watchpoint
3975 || bptype == bp_read_watchpoint
3976 || bptype == bp_access_watchpoint
3977 || bptype == bp_catch_fork
3978 || bptype == bp_catch_vfork
3979 || bptype == bp_catch_exec)
3981 /* Watchpoints and the various bp_catch_* eventpoints should not
3982 have their addresses modified. */
3987 CORE_ADDR adjusted_bpaddr;
3989 /* Some targets have architectural constraints on the placement
3990 of breakpoint instructions. Obtain the adjusted address. */
3991 adjusted_bpaddr = gdbarch_adjust_breakpoint_address (current_gdbarch,
3994 /* An adjusted breakpoint address can significantly alter
3995 a user's expectations. Print a warning if an adjustment
3997 if (adjusted_bpaddr != bpaddr)
3998 breakpoint_adjustment_warning (bpaddr, adjusted_bpaddr, 0, 0);
4000 return adjusted_bpaddr;
4004 /* Allocate a struct bp_location. */
4006 static struct bp_location *
4007 allocate_bp_location (struct breakpoint *bpt, enum bptype bp_type)
4009 struct bp_location *loc, *loc_p;
4011 loc = xmalloc (sizeof (struct bp_location));
4012 memset (loc, 0, sizeof (*loc));
4022 case bp_longjmp_resume:
4023 case bp_step_resume:
4024 case bp_through_sigtramp:
4025 case bp_watchpoint_scope:
4027 case bp_shlib_event:
4028 case bp_thread_event:
4029 case bp_overlay_event:
4031 case bp_catch_unload:
4032 loc->loc_type = bp_loc_software_breakpoint;
4034 case bp_hardware_breakpoint:
4035 loc->loc_type = bp_loc_hardware_breakpoint;
4037 case bp_hardware_watchpoint:
4038 case bp_read_watchpoint:
4039 case bp_access_watchpoint:
4040 loc->loc_type = bp_loc_hardware_watchpoint;
4044 case bp_catch_vfork:
4046 case bp_catch_catch:
4047 case bp_catch_throw:
4048 loc->loc_type = bp_loc_other;
4051 internal_error (__FILE__, __LINE__, "unknown breakpoint type");
4054 /* Add this breakpoint to the end of the chain. */
4056 loc_p = bp_location_chain;
4058 bp_location_chain = loc;
4062 loc_p = loc_p->next;
4069 /* set_raw_breakpoint() is a low level routine for allocating and
4070 partially initializing a breakpoint of type BPTYPE. The newly
4071 created breakpoint's address, section, source file name, and line
4072 number are provided by SAL. The newly created and partially
4073 initialized breakpoint is added to the breakpoint chain and
4074 is also returned as the value of this function.
4076 It is expected that the caller will complete the initialization of
4077 the newly created breakpoint struct as well as output any status
4078 information regarding the creation of a new breakpoint. In
4079 particular, set_raw_breakpoint() does NOT set the breakpoint
4080 number! Care should be taken to not allow an error() to occur
4081 prior to completing the initialization of the breakpoint. If this
4082 should happen, a bogus breakpoint will be left on the chain. */
4085 set_raw_breakpoint (struct symtab_and_line sal, enum bptype bptype)
4087 struct breakpoint *b, *b1;
4089 b = (struct breakpoint *) xmalloc (sizeof (struct breakpoint));
4090 memset (b, 0, sizeof (*b));
4091 b->loc = allocate_bp_location (b, bptype);
4092 b->loc->requested_address = sal.pc;
4093 b->loc->address = adjust_breakpoint_address (b->loc->requested_address,
4095 if (sal.symtab == NULL)
4096 b->source_file = NULL;
4098 b->source_file = savestring (sal.symtab->filename,
4099 strlen (sal.symtab->filename));
4100 b->loc->section = sal.section;
4102 b->language = current_language->la_language;
4103 b->input_radix = input_radix;
4105 b->line_number = sal.line;
4106 b->enable_state = bp_enabled;
4109 b->ignore_count = 0;
4111 b->frame_id = null_frame_id;
4112 b->dll_pathname = NULL;
4113 b->triggered_dll_pathname = NULL;
4114 b->forked_inferior_pid = 0;
4115 b->exec_pathname = NULL;
4119 /* Add this breakpoint to the end of the chain
4120 so that a list of breakpoints will come out in order
4121 of increasing numbers. */
4123 b1 = breakpoint_chain;
4125 breakpoint_chain = b;
4133 check_duplicates (b);
4134 breakpoints_changed ();
4140 /* Note that the breakpoint object B describes a permanent breakpoint
4141 instruction, hard-wired into the inferior's code. */
4143 make_breakpoint_permanent (struct breakpoint *b)
4145 b->enable_state = bp_permanent;
4147 /* By definition, permanent breakpoints are already present in the code. */
4148 b->loc->inserted = 1;
4151 static struct breakpoint *
4152 create_internal_breakpoint (CORE_ADDR address, enum bptype type)
4154 static int internal_breakpoint_number = -1;
4155 struct symtab_and_line sal;
4156 struct breakpoint *b;
4158 init_sal (&sal); /* initialize to zeroes */
4161 sal.section = find_pc_overlay (sal.pc);
4163 b = set_raw_breakpoint (sal, type);
4164 b->number = internal_breakpoint_number--;
4165 b->disposition = disp_donttouch;
4172 create_longjmp_breakpoint (char *func_name)
4174 struct breakpoint *b;
4175 struct minimal_symbol *m;
4177 if (func_name == NULL)
4178 b = create_internal_breakpoint (0, bp_longjmp_resume);
4181 if ((m = lookup_minimal_symbol_text (func_name, NULL)) == NULL)
4184 b = create_internal_breakpoint (SYMBOL_VALUE_ADDRESS (m), bp_longjmp);
4187 b->enable_state = bp_disabled;
4190 b->addr_string = xstrdup (func_name);
4193 /* Call this routine when stepping and nexting to enable a breakpoint
4194 if we do a longjmp(). When we hit that breakpoint, call
4195 set_longjmp_resume_breakpoint() to figure out where we are going. */
4198 enable_longjmp_breakpoint (void)
4200 struct breakpoint *b;
4203 if (b->type == bp_longjmp)
4205 b->enable_state = bp_enabled;
4206 check_duplicates (b);
4211 disable_longjmp_breakpoint (void)
4213 struct breakpoint *b;
4216 if (b->type == bp_longjmp
4217 || b->type == bp_longjmp_resume)
4219 b->enable_state = bp_disabled;
4220 check_duplicates (b);
4225 create_overlay_event_breakpoint (char *func_name)
4227 struct breakpoint *b;
4228 struct minimal_symbol *m;
4230 if ((m = lookup_minimal_symbol_text (func_name, NULL)) == NULL)
4233 b = create_internal_breakpoint (SYMBOL_VALUE_ADDRESS (m),
4235 b->addr_string = xstrdup (func_name);
4237 if (overlay_debugging == ovly_auto)
4239 b->enable_state = bp_enabled;
4240 overlay_events_enabled = 1;
4244 b->enable_state = bp_disabled;
4245 overlay_events_enabled = 0;
4250 enable_overlay_breakpoints (void)
4252 struct breakpoint *b;
4255 if (b->type == bp_overlay_event)
4257 b->enable_state = bp_enabled;
4258 check_duplicates (b);
4259 overlay_events_enabled = 1;
4264 disable_overlay_breakpoints (void)
4266 struct breakpoint *b;
4269 if (b->type == bp_overlay_event)
4271 b->enable_state = bp_disabled;
4272 check_duplicates (b);
4273 overlay_events_enabled = 0;
4278 create_thread_event_breakpoint (CORE_ADDR address)
4280 struct breakpoint *b;
4282 b = create_internal_breakpoint (address, bp_thread_event);
4284 b->enable_state = bp_enabled;
4285 /* addr_string has to be used or breakpoint_re_set will delete me. */
4286 xasprintf (&b->addr_string, "*0x%s", paddr (b->loc->address));
4292 remove_thread_event_breakpoints (void)
4294 struct breakpoint *b, *temp;
4296 ALL_BREAKPOINTS_SAFE (b, temp)
4297 if (b->type == bp_thread_event)
4298 delete_breakpoint (b);
4301 struct captured_parse_breakpoint_args
4304 struct symtabs_and_lines *sals_p;
4305 char ***addr_string_p;
4309 struct lang_and_radix
4315 /* Cleanup helper routine to restore the current language and
4318 do_restore_lang_radix_cleanup (void *old)
4320 struct lang_and_radix *p = old;
4321 set_language (p->lang);
4322 input_radix = p->radix;
4325 /* Try and resolve a pending breakpoint. */
4327 resolve_pending_breakpoint (struct breakpoint *b)
4329 /* Try and reparse the breakpoint in case the shared library
4331 struct symtabs_and_lines sals;
4332 struct symtab_and_line pending_sal;
4333 char **cond_string = (char **) NULL;
4334 char *copy_arg = b->addr_string;
4339 struct ui_file *old_gdb_stderr;
4340 struct lang_and_radix old_lr;
4341 struct cleanup *old_chain;
4343 /* Set language, input-radix, then reissue breakpoint command.
4344 Ensure the language and input-radix are restored afterwards. */
4345 old_lr.lang = current_language->la_language;
4346 old_lr.radix = input_radix;
4347 old_chain = make_cleanup (do_restore_lang_radix_cleanup, &old_lr);
4349 set_language (b->language);
4350 input_radix = b->input_radix;
4351 rc = break_command_1 (b->addr_string, b->flag, b->from_tty, b);
4353 if (rc == GDB_RC_OK)
4354 /* Pending breakpoint has been resolved. */
4355 printf_filtered ("Pending breakpoint \"%s\" resolved\n", b->addr_string);
4357 do_cleanups (old_chain);
4363 remove_solib_event_breakpoints (void)
4365 struct breakpoint *b, *temp;
4367 ALL_BREAKPOINTS_SAFE (b, temp)
4368 if (b->type == bp_shlib_event)
4369 delete_breakpoint (b);
4373 create_solib_event_breakpoint (CORE_ADDR address)
4375 struct breakpoint *b;
4377 b = create_internal_breakpoint (address, bp_shlib_event);
4381 /* Disable any breakpoints that are on code in shared libraries. Only
4382 apply to enabled breakpoints, disabled ones can just stay disabled. */
4385 disable_breakpoints_in_shlibs (int silent)
4387 struct breakpoint *b;
4388 int disabled_shlib_breaks = 0;
4390 /* See also: insert_breakpoints, under DISABLE_UNSETTABLE_BREAK. */
4393 #if defined (PC_SOLIB)
4394 if (((b->type == bp_breakpoint) ||
4395 (b->type == bp_hardware_breakpoint)) &&
4396 breakpoint_enabled (b) &&
4397 !b->loc->duplicate &&
4398 PC_SOLIB (b->loc->address))
4400 b->enable_state = bp_shlib_disabled;
4403 if (!disabled_shlib_breaks)
4405 target_terminal_ours_for_output ();
4406 warning ("Temporarily disabling shared library breakpoints:");
4408 disabled_shlib_breaks = 1;
4409 warning ("breakpoint #%d ", b->number);
4416 /* Try to reenable any breakpoints in shared libraries. */
4418 re_enable_breakpoints_in_shlibs (void)
4420 struct breakpoint *b, *tmp;
4422 ALL_BREAKPOINTS_SAFE (b, tmp)
4424 if (b->enable_state == bp_shlib_disabled)
4428 /* Do not reenable the breakpoint if the shared library
4429 is still not mapped in. */
4430 lib = PC_SOLIB (b->loc->address);
4431 if (lib != NULL && target_read_memory (b->loc->address, buf, 1) == 0)
4432 b->enable_state = bp_enabled;
4434 else if (b->pending && (b->enable_state == bp_enabled))
4436 if (resolve_pending_breakpoint (b) == GDB_RC_OK)
4437 delete_breakpoint (b);
4445 solib_load_unload_1 (char *hookname, int tempflag, char *dll_pathname,
4446 char *cond_string, enum bptype bp_kind)
4448 struct breakpoint *b;
4449 struct symtabs_and_lines sals;
4450 struct cleanup *old_chain;
4451 struct cleanup *canonical_strings_chain = NULL;
4452 char *addr_start = hookname;
4453 char *addr_end = NULL;
4454 char **canonical = (char **) NULL;
4455 int thread = -1; /* All threads. */
4457 /* Set a breakpoint on the specified hook. */
4458 sals = decode_line_1 (&hookname, 1, (struct symtab *) NULL, 0, &canonical, NULL);
4459 addr_end = hookname;
4461 if (sals.nelts == 0)
4463 warning ("Unable to set a breakpoint on dynamic linker callback.");
4464 warning ("Suggest linking with /opt/langtools/lib/end.o.");
4465 warning ("GDB will be unable to track shl_load/shl_unload calls");
4468 if (sals.nelts != 1)
4470 warning ("Unable to set unique breakpoint on dynamic linker callback.");
4471 warning ("GDB will be unable to track shl_load/shl_unload calls");
4475 /* Make sure that all storage allocated in decode_line_1 gets freed
4476 in case the following errors out. */
4477 old_chain = make_cleanup (xfree, sals.sals);
4478 if (canonical != (char **) NULL)
4480 make_cleanup (xfree, canonical);
4481 canonical_strings_chain = make_cleanup (null_cleanup, 0);
4482 if (canonical[0] != NULL)
4483 make_cleanup (xfree, canonical[0]);
4486 resolve_sal_pc (&sals.sals[0]);
4488 /* Remove the canonical strings from the cleanup, they are needed below. */
4489 if (canonical != (char **) NULL)
4490 discard_cleanups (canonical_strings_chain);
4492 b = set_raw_breakpoint (sals.sals[0], bp_kind);
4493 set_breakpoint_count (breakpoint_count + 1);
4494 b->number = breakpoint_count;
4496 b->cond_string = (cond_string == NULL) ?
4497 NULL : savestring (cond_string, strlen (cond_string));
4500 if (canonical != (char **) NULL && canonical[0] != NULL)
4501 b->addr_string = canonical[0];
4502 else if (addr_start)
4503 b->addr_string = savestring (addr_start, addr_end - addr_start);
4505 b->enable_state = bp_enabled;
4506 b->disposition = tempflag ? disp_del : disp_donttouch;
4508 if (dll_pathname == NULL)
4509 b->dll_pathname = NULL;
4512 b->dll_pathname = (char *) xmalloc (strlen (dll_pathname) + 1);
4513 strcpy (b->dll_pathname, dll_pathname);
4517 do_cleanups (old_chain);
4521 create_solib_load_event_breakpoint (char *hookname, int tempflag,
4522 char *dll_pathname, char *cond_string)
4524 solib_load_unload_1 (hookname, tempflag, dll_pathname,
4525 cond_string, bp_catch_load);
4529 create_solib_unload_event_breakpoint (char *hookname, int tempflag,
4530 char *dll_pathname, char *cond_string)
4532 solib_load_unload_1 (hookname,tempflag, dll_pathname,
4533 cond_string, bp_catch_unload);
4537 create_fork_vfork_event_catchpoint (int tempflag, char *cond_string,
4538 enum bptype bp_kind)
4540 struct symtab_and_line sal;
4541 struct breakpoint *b;
4542 int thread = -1; /* All threads. */
4549 b = set_raw_breakpoint (sal, bp_kind);
4550 set_breakpoint_count (breakpoint_count + 1);
4551 b->number = breakpoint_count;
4553 b->cond_string = (cond_string == NULL) ?
4554 NULL : savestring (cond_string, strlen (cond_string));
4556 b->addr_string = NULL;
4557 b->enable_state = bp_enabled;
4558 b->disposition = tempflag ? disp_del : disp_donttouch;
4559 b->forked_inferior_pid = 0;
4565 create_fork_event_catchpoint (int tempflag, char *cond_string)
4567 create_fork_vfork_event_catchpoint (tempflag, cond_string, bp_catch_fork);
4571 create_vfork_event_catchpoint (int tempflag, char *cond_string)
4573 create_fork_vfork_event_catchpoint (tempflag, cond_string, bp_catch_vfork);
4577 create_exec_event_catchpoint (int tempflag, char *cond_string)
4579 struct symtab_and_line sal;
4580 struct breakpoint *b;
4581 int thread = -1; /* All threads. */
4588 b = set_raw_breakpoint (sal, bp_catch_exec);
4589 set_breakpoint_count (breakpoint_count + 1);
4590 b->number = breakpoint_count;
4592 b->cond_string = (cond_string == NULL) ?
4593 NULL : savestring (cond_string, strlen (cond_string));
4595 b->addr_string = NULL;
4596 b->enable_state = bp_enabled;
4597 b->disposition = tempflag ? disp_del : disp_donttouch;
4603 hw_breakpoint_used_count (void)
4605 struct breakpoint *b;
4610 if (b->type == bp_hardware_breakpoint && b->enable_state == bp_enabled)
4618 hw_watchpoint_used_count (enum bptype type, int *other_type_used)
4620 struct breakpoint *b;
4623 *other_type_used = 0;
4626 if (breakpoint_enabled (b))
4628 if (b->type == type)
4630 else if ((b->type == bp_hardware_watchpoint ||
4631 b->type == bp_read_watchpoint ||
4632 b->type == bp_access_watchpoint))
4633 *other_type_used = 1;
4639 /* Call this after hitting the longjmp() breakpoint. Use this to set
4640 a new breakpoint at the target of the jmp_buf.
4642 FIXME - This ought to be done by setting a temporary breakpoint
4643 that gets deleted automatically... */
4646 set_longjmp_resume_breakpoint (CORE_ADDR pc, struct frame_id frame_id)
4648 struct breakpoint *b;
4651 if (b->type == bp_longjmp_resume)
4653 b->loc->requested_address = pc;
4654 b->loc->address = adjust_breakpoint_address (b->loc->requested_address,
4656 b->enable_state = bp_enabled;
4657 b->frame_id = frame_id;
4658 check_duplicates (b);
4664 disable_watchpoints_before_interactive_call_start (void)
4666 struct breakpoint *b;
4670 if (((b->type == bp_watchpoint)
4671 || (b->type == bp_hardware_watchpoint)
4672 || (b->type == bp_read_watchpoint)
4673 || (b->type == bp_access_watchpoint)
4674 || ep_is_exception_catchpoint (b))
4675 && breakpoint_enabled (b))
4677 b->enable_state = bp_call_disabled;
4678 check_duplicates (b);
4684 enable_watchpoints_after_interactive_call_stop (void)
4686 struct breakpoint *b;
4690 if (((b->type == bp_watchpoint)
4691 || (b->type == bp_hardware_watchpoint)
4692 || (b->type == bp_read_watchpoint)
4693 || (b->type == bp_access_watchpoint)
4694 || ep_is_exception_catchpoint (b))
4695 && (b->enable_state == bp_call_disabled))
4697 b->enable_state = bp_enabled;
4698 check_duplicates (b);
4704 /* Set a breakpoint that will evaporate an end of command
4705 at address specified by SAL.
4706 Restrict it to frame FRAME if FRAME is nonzero. */
4709 set_momentary_breakpoint (struct symtab_and_line sal, struct frame_id frame_id,
4712 struct breakpoint *b;
4713 b = set_raw_breakpoint (sal, type);
4714 b->enable_state = bp_enabled;
4715 b->disposition = disp_donttouch;
4716 b->frame_id = frame_id;
4718 /* If we're debugging a multi-threaded program, then we
4719 want momentary breakpoints to be active in only a
4720 single thread of control. */
4721 if (in_thread_list (inferior_ptid))
4722 b->thread = pid_to_thread_id (inferior_ptid);
4728 /* Tell the user we have just set a breakpoint B. */
4731 mention (struct breakpoint *b)
4734 struct cleanup *old_chain, *ui_out_chain;
4735 struct ui_stream *stb;
4737 stb = ui_out_stream_new (uiout);
4738 old_chain = make_cleanup_ui_out_stream_delete (stb);
4740 /* FIXME: This is misplaced; mention() is called by things (like
4741 hitting a watchpoint) other than breakpoint creation. It should
4742 be possible to clean this up and at the same time replace the
4743 random calls to breakpoint_changed with this hook, as has already
4744 been done for deprecated_delete_breakpoint_hook and so on. */
4745 if (deprecated_create_breakpoint_hook)
4746 deprecated_create_breakpoint_hook (b);
4747 breakpoint_create_event (b->number);
4749 if (b->ops != NULL && b->ops->print_mention != NULL)
4750 b->ops->print_mention (b);
4755 printf_filtered ("(apparently deleted?) Eventpoint %d: ", b->number);
4758 ui_out_text (uiout, "Watchpoint ");
4759 ui_out_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "wpt");
4760 ui_out_field_int (uiout, "number", b->number);
4761 ui_out_text (uiout, ": ");
4762 print_expression (b->exp, stb->stream);
4763 ui_out_field_stream (uiout, "exp", stb);
4764 do_cleanups (ui_out_chain);
4766 case bp_hardware_watchpoint:
4767 ui_out_text (uiout, "Hardware watchpoint ");
4768 ui_out_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "wpt");
4769 ui_out_field_int (uiout, "number", b->number);
4770 ui_out_text (uiout, ": ");
4771 print_expression (b->exp, stb->stream);
4772 ui_out_field_stream (uiout, "exp", stb);
4773 do_cleanups (ui_out_chain);
4775 case bp_read_watchpoint:
4776 ui_out_text (uiout, "Hardware read watchpoint ");
4777 ui_out_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "hw-rwpt");
4778 ui_out_field_int (uiout, "number", b->number);
4779 ui_out_text (uiout, ": ");
4780 print_expression (b->exp, stb->stream);
4781 ui_out_field_stream (uiout, "exp", stb);
4782 do_cleanups (ui_out_chain);
4784 case bp_access_watchpoint:
4785 ui_out_text (uiout, "Hardware access (read/write) watchpoint ");
4786 ui_out_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "hw-awpt");
4787 ui_out_field_int (uiout, "number", b->number);
4788 ui_out_text (uiout, ": ");
4789 print_expression (b->exp, stb->stream);
4790 ui_out_field_stream (uiout, "exp", stb);
4791 do_cleanups (ui_out_chain);
4794 if (ui_out_is_mi_like_p (uiout))
4799 printf_filtered ("Breakpoint %d", b->number);
4802 case bp_hardware_breakpoint:
4803 if (ui_out_is_mi_like_p (uiout))
4808 printf_filtered ("Hardware assisted breakpoint %d", b->number);
4812 case bp_catch_unload:
4813 printf_filtered ("Catchpoint %d (%s %s)",
4815 (b->type == bp_catch_load) ? "load" : "unload",
4816 (b->dll_pathname != NULL) ?
4817 b->dll_pathname : "<any library>");
4820 case bp_catch_vfork:
4821 printf_filtered ("Catchpoint %d (%s)",
4823 (b->type == bp_catch_fork) ? "fork" : "vfork");
4826 printf_filtered ("Catchpoint %d (exec)",
4829 case bp_catch_catch:
4830 case bp_catch_throw:
4831 printf_filtered ("Catchpoint %d (%s)",
4833 (b->type == bp_catch_catch) ? "catch" : "throw");
4839 case bp_longjmp_resume:
4840 case bp_step_resume:
4841 case bp_through_sigtramp:
4843 case bp_watchpoint_scope:
4844 case bp_shlib_event:
4845 case bp_thread_event:
4846 case bp_overlay_event:
4854 printf_filtered (" (%s) pending.", b->addr_string);
4858 if (addressprint || b->source_file == NULL)
4860 printf_filtered (" at ");
4861 print_address_numeric (b->loc->address, 1, gdb_stdout);
4864 printf_filtered (": file %s, line %d.",
4865 b->source_file, b->line_number);
4868 do_cleanups (old_chain);
4869 if (ui_out_is_mi_like_p (uiout))
4871 printf_filtered ("\n");
4875 /* Add SALS.nelts breakpoints to the breakpoint table. For each
4876 SALS.sal[i] breakpoint, include the corresponding ADDR_STRING[i],
4877 COND[i] and COND_STRING[i] values.
4879 The parameter PENDING_BP points to a pending breakpoint that is
4880 the basis of the breakpoints currently being created. The pending
4881 breakpoint may contain a separate condition string or commands
4882 that were added after the initial pending breakpoint was created.
4884 NOTE: If the function succeeds, the caller is expected to cleanup
4885 the arrays ADDR_STRING, COND_STRING, COND and SALS (but not the
4886 array contents). If the function fails (error() is called), the
4887 caller is expected to cleanups both the ADDR_STRING, COND_STRING,
4888 COND and SALS arrays and each of those arrays contents. */
4891 create_breakpoints (struct symtabs_and_lines sals, char **addr_string,
4892 struct expression **cond, char **cond_string,
4893 enum bptype type, enum bpdisp disposition,
4894 int thread, int ignore_count, int from_tty,
4895 struct breakpoint *pending_bp)
4897 if (type == bp_hardware_breakpoint)
4899 int i = hw_breakpoint_used_count ();
4900 int target_resources_ok =
4901 TARGET_CAN_USE_HARDWARE_WATCHPOINT (bp_hardware_breakpoint,
4903 if (target_resources_ok == 0)
4904 error ("No hardware breakpoint support in the target.");
4905 else if (target_resources_ok < 0)
4906 error ("Hardware breakpoints used exceeds limit.");
4909 /* Now set all the breakpoints. */
4912 for (i = 0; i < sals.nelts; i++)
4914 struct breakpoint *b;
4915 struct symtab_and_line sal = sals.sals[i];
4918 describe_other_breakpoints (sal.pc, sal.section);
4920 b = set_raw_breakpoint (sal, type);
4921 set_breakpoint_count (breakpoint_count + 1);
4922 b->number = breakpoint_count;
4926 b->addr_string = addr_string[i];
4928 /* addr_string has to be used or breakpoint_re_set will delete
4930 xasprintf (&b->addr_string, "*0x%s", paddr (b->loc->address));
4931 b->cond_string = cond_string[i];
4932 b->ignore_count = ignore_count;
4933 b->enable_state = bp_enabled;
4934 b->disposition = disposition;
4935 /* If resolving a pending breakpoint, a check must be made to see if
4936 the user has specified a new condition or commands for the
4937 breakpoint. A new condition will override any condition that was
4938 initially specified with the initial breakpoint command. */
4942 if (pending_bp->cond_string)
4944 arg = pending_bp->cond_string;
4945 b->cond_string = savestring (arg, strlen (arg));
4946 b->cond = parse_exp_1 (&arg, block_for_pc (b->loc->address), 0);
4948 error ("Junk at end of pending breakpoint condition expression");
4950 /* If there are commands associated with the breakpoint, they should
4952 if (pending_bp->commands)
4953 b->commands = copy_command_lines (pending_bp->commands);
4960 /* Parse ARG which is assumed to be a SAL specification possibly
4961 followed by conditionals. On return, SALS contains an array of SAL
4962 addresses found. ADDR_STRING contains a vector of (canonical)
4963 address strings. ARG points to the end of the SAL. */
4966 parse_breakpoint_sals (char **address,
4967 struct symtabs_and_lines *sals,
4968 char ***addr_string,
4971 char *addr_start = *address;
4972 *addr_string = NULL;
4973 /* If no arg given, or if first arg is 'if ', use the default
4975 if ((*address) == NULL
4976 || (strncmp ((*address), "if", 2) == 0 && isspace ((*address)[2])))
4978 if (default_breakpoint_valid)
4980 struct symtab_and_line sal;
4981 init_sal (&sal); /* initialize to zeroes */
4982 sals->sals = (struct symtab_and_line *)
4983 xmalloc (sizeof (struct symtab_and_line));
4984 sal.pc = default_breakpoint_address;
4985 sal.line = default_breakpoint_line;
4986 sal.symtab = default_breakpoint_symtab;
4987 sal.section = find_pc_overlay (sal.pc);
4988 sals->sals[0] = sal;
4992 error ("No default breakpoint address now.");
4996 /* Force almost all breakpoints to be in terms of the
4997 current_source_symtab (which is decode_line_1's default). This
4998 should produce the results we want almost all of the time while
4999 leaving default_breakpoint_* alone.
5000 ObjC: However, don't match an Objective-C method name which
5001 may have a '+' or '-' succeeded by a '[' */
5003 struct symtab_and_line cursal = get_current_source_symtab_and_line ();
5005 if (default_breakpoint_valid
5007 || ((strchr ("+-", (*address)[0]) != NULL)
5008 && ((*address)[1] != '['))))
5009 *sals = decode_line_1 (address, 1, default_breakpoint_symtab,
5010 default_breakpoint_line, addr_string,
5013 *sals = decode_line_1 (address, 1, (struct symtab *) NULL, 0,
5014 addr_string, not_found_ptr);
5016 /* For any SAL that didn't have a canonical string, fill one in. */
5017 if (sals->nelts > 0 && *addr_string == NULL)
5018 *addr_string = xcalloc (sals->nelts, sizeof (char **));
5019 if (addr_start != (*address))
5022 for (i = 0; i < sals->nelts; i++)
5024 /* Add the string if not present. */
5025 if ((*addr_string)[i] == NULL)
5026 (*addr_string)[i] = savestring (addr_start, (*address) - addr_start);
5032 /* Convert each SAL into a real PC. Verify that the PC can be
5033 inserted as a breakpoint. If it can't throw an error. */
5036 breakpoint_sals_to_pc (struct symtabs_and_lines *sals,
5040 for (i = 0; i < sals->nelts; i++)
5042 resolve_sal_pc (&sals->sals[i]);
5044 /* It's possible for the PC to be nonzero, but still an illegal
5045 value on some targets.
5047 For example, on HP-UX if you start gdb, and before running the
5048 inferior you try to set a breakpoint on a shared library function
5049 "foo" where the inferior doesn't call "foo" directly but does
5050 pass its address to another function call, then we do find a
5051 minimal symbol for the "foo", but it's address is invalid.
5052 (Appears to be an index into a table that the loader sets up
5053 when the inferior is run.)
5055 Give the target a chance to bless sals.sals[i].pc before we
5056 try to make a breakpoint for it. */
5057 if (PC_REQUIRES_RUN_BEFORE_USE (sals->sals[i].pc))
5059 if (address == NULL)
5060 error ("Cannot break without a running program.");
5062 error ("Cannot break on %s without a running program.",
5069 do_captured_parse_breakpoint (struct ui_out *ui, void *data)
5071 struct captured_parse_breakpoint_args *args = data;
5073 parse_breakpoint_sals (args->arg_p, args->sals_p, args->addr_string_p,
5074 args->not_found_ptr);
5079 /* Set a breakpoint according to ARG (function, linenum or *address)
5080 flag: first bit : 0 non-temporary, 1 temporary.
5081 second bit : 0 normal breakpoint, 1 hardware breakpoint.
5083 PENDING_BP is non-NULL when this function is being called to resolve
5084 a pending breakpoint. */
5087 break_command_1 (char *arg, int flag, int from_tty, struct breakpoint *pending_bp)
5089 int tempflag, hardwareflag;
5090 struct symtabs_and_lines sals;
5091 struct expression **cond = 0;
5092 struct symtab_and_line pending_sal;
5093 char **cond_string = (char **) NULL;
5096 char *addr_start = arg;
5098 struct cleanup *old_chain;
5099 struct cleanup *breakpoint_chain = NULL;
5100 struct captured_parse_breakpoint_args parse_args;
5104 int ignore_count = 0;
5107 hardwareflag = flag & BP_HARDWAREFLAG;
5108 tempflag = flag & BP_TEMPFLAG;
5114 parse_args.arg_p = &arg;
5115 parse_args.sals_p = &sals;
5116 parse_args.addr_string_p = &addr_string;
5117 parse_args.not_found_ptr = ¬_found;
5119 rc = catch_exceptions_with_msg (uiout, do_captured_parse_breakpoint,
5120 &parse_args, NULL, &err_msg,
5123 /* If caller is interested in rc value from parse, set value. */
5125 if (rc != GDB_RC_OK)
5127 /* Check for file or function not found. */
5130 /* If called to resolve pending breakpoint, just return error code. */
5134 error_output_message (NULL, err_msg);
5137 /* If pending breakpoint support is turned off, throw error. */
5139 if (pending_break_support == AUTO_BOOLEAN_FALSE)
5140 throw_exception (RETURN_ERROR);
5142 /* If pending breakpoint support is auto query and the user selects
5143 no, then simply return the error code. */
5144 if (pending_break_support == AUTO_BOOLEAN_AUTO &&
5145 !nquery ("Make breakpoint pending on future shared library load? "))
5148 /* At this point, either the user was queried about setting a
5149 pending breakpoint and selected yes, or pending breakpoint
5150 behavior is on and thus a pending breakpoint is defaulted
5151 on behalf of the user. */
5152 copy_arg = xstrdup (addr_start);
5153 addr_string = ©_arg;
5155 sals.sals = &pending_sal;
5162 else if (!sals.nelts)
5165 /* Create a chain of things that always need to be cleaned up. */
5166 old_chain = make_cleanup (null_cleanup, 0);
5170 /* Make sure that all storage allocated to SALS gets freed. */
5171 make_cleanup (xfree, sals.sals);
5173 /* Cleanup the addr_string array but not its contents. */
5174 make_cleanup (xfree, addr_string);
5177 /* Allocate space for all the cond expressions. */
5178 cond = xcalloc (sals.nelts, sizeof (struct expression *));
5179 make_cleanup (xfree, cond);
5181 /* Allocate space for all the cond strings. */
5182 cond_string = xcalloc (sals.nelts, sizeof (char **));
5183 make_cleanup (xfree, cond_string);
5185 /* ----------------------------- SNIP -----------------------------
5186 Anything added to the cleanup chain beyond this point is assumed
5187 to be part of a breakpoint. If the breakpoint create succeeds
5188 then the memory is not reclaimed. */
5189 breakpoint_chain = make_cleanup (null_cleanup, 0);
5191 /* Mark the contents of the addr_string for cleanup. These go on
5192 the breakpoint_chain and only occure if the breakpoint create
5194 for (i = 0; i < sals.nelts; i++)
5196 if (addr_string[i] != NULL)
5197 make_cleanup (xfree, addr_string[i]);
5200 /* Resolve all line numbers to PC's and verify that the addresses
5201 are ok for the target. */
5203 breakpoint_sals_to_pc (&sals, addr_start);
5205 /* Verify that condition can be parsed, before setting any
5206 breakpoints. Allocate a separate condition expression for each
5208 thread = -1; /* No specific thread yet */
5211 for (i = 0; i < sals.nelts; i++)
5218 char *cond_start = NULL;
5219 char *cond_end = NULL;
5220 while (*tok == ' ' || *tok == '\t')
5225 while (*end_tok != ' ' && *end_tok != '\t' && *end_tok != '\000')
5228 toklen = end_tok - tok;
5230 if (toklen >= 1 && strncmp (tok, "if", toklen) == 0)
5232 tok = cond_start = end_tok + 1;
5233 cond[i] = parse_exp_1 (&tok, block_for_pc (sals.sals[i].pc),
5235 make_cleanup (xfree, cond[i]);
5237 cond_string[i] = savestring (cond_start,
5238 cond_end - cond_start);
5239 make_cleanup (xfree, cond_string[i]);
5241 else if (toklen >= 1 && strncmp (tok, "thread", toklen) == 0)
5247 thread = strtol (tok, &tok, 0);
5249 error ("Junk after thread keyword.");
5250 if (!valid_thread_id (thread))
5251 error ("Unknown thread %d\n", thread);
5254 error ("Junk at end of arguments.");
5257 create_breakpoints (sals, addr_string, cond, cond_string,
5258 hardwareflag ? bp_hardware_breakpoint
5260 tempflag ? disp_del : disp_donttouch,
5261 thread, ignore_count, from_tty,
5266 struct symtab_and_line sal;
5267 struct breakpoint *b;
5272 make_cleanup (xfree, copy_arg);
5274 b = set_raw_breakpoint (sal, hardwareflag ? bp_hardware_breakpoint
5276 set_breakpoint_count (breakpoint_count + 1);
5277 b->number = breakpoint_count;
5280 b->addr_string = *addr_string;
5281 b->cond_string = *cond_string;
5282 b->ignore_count = ignore_count;
5284 b->disposition = tempflag ? disp_del : disp_donttouch;
5285 b->from_tty = from_tty;
5292 warning ("Multiple breakpoints were set.");
5293 warning ("Use the \"delete\" command to delete unwanted breakpoints.");
5295 /* That's it. Discard the cleanups for data inserted into the
5297 discard_cleanups (breakpoint_chain);
5298 /* But cleanup everything else. */
5299 do_cleanups (old_chain);
5304 /* Set a breakpoint of TYPE/DISPOSITION according to ARG (function,
5305 linenum or *address) with COND and IGNORE_COUNT. */
5307 struct captured_breakpoint_args
5318 do_captured_breakpoint (void *data)
5320 struct captured_breakpoint_args *args = data;
5321 struct symtabs_and_lines sals;
5322 struct expression **cond;
5323 struct cleanup *old_chain;
5324 struct cleanup *breakpoint_chain = NULL;
5331 /* Parse the source and lines spec. Delay check that the expression
5332 didn't contain trailing garbage until after cleanups are in
5336 address_end = args->address;
5338 parse_breakpoint_sals (&address_end, &sals, &addr_string, 0);
5343 /* Create a chain of things at always need to be cleaned up. */
5344 old_chain = make_cleanup (null_cleanup, 0);
5346 /* Always have a addr_string array, even if it is empty. */
5347 make_cleanup (xfree, addr_string);
5349 /* Make sure that all storage allocated to SALS gets freed. */
5350 make_cleanup (xfree, sals.sals);
5352 /* Allocate space for all the cond expressions. */
5353 cond = xcalloc (sals.nelts, sizeof (struct expression *));
5354 make_cleanup (xfree, cond);
5356 /* Allocate space for all the cond strings. */
5357 cond_string = xcalloc (sals.nelts, sizeof (char **));
5358 make_cleanup (xfree, cond_string);
5360 /* ----------------------------- SNIP -----------------------------
5361 Anything added to the cleanup chain beyond this point is assumed
5362 to be part of a breakpoint. If the breakpoint create goes
5363 through then that memory is not cleaned up. */
5364 breakpoint_chain = make_cleanup (null_cleanup, 0);
5366 /* Mark the contents of the addr_string for cleanup. These go on
5367 the breakpoint_chain and only occure if the breakpoint create
5369 for (i = 0; i < sals.nelts; i++)
5371 if (addr_string[i] != NULL)
5372 make_cleanup (xfree, addr_string[i]);
5375 /* Wait until now before checking for garbage at the end of the
5376 address. That way cleanups can take care of freeing any
5378 if (*address_end != '\0')
5379 error ("Garbage %s following breakpoint address", address_end);
5381 /* Resolve all line numbers to PC's. */
5382 breakpoint_sals_to_pc (&sals, args->address);
5384 /* Verify that conditions can be parsed, before setting any
5386 for (i = 0; i < sals.nelts; i++)
5388 if (args->condition != NULL)
5390 char *tok = args->condition;
5391 cond[i] = parse_exp_1 (&tok, block_for_pc (sals.sals[i].pc), 0);
5393 error ("Garbage %s follows condition", tok);
5394 make_cleanup (xfree, cond[i]);
5395 cond_string[i] = xstrdup (args->condition);
5399 create_breakpoints (sals, addr_string, cond, cond_string,
5400 args->hardwareflag ? bp_hardware_breakpoint : bp_breakpoint,
5401 args->tempflag ? disp_del : disp_donttouch,
5402 args->thread, args->ignore_count, 0/*from-tty*/,
5403 NULL/*pending_bp*/);
5405 /* That's it. Discard the cleanups for data inserted into the
5407 discard_cleanups (breakpoint_chain);
5408 /* But cleanup everything else. */
5409 do_cleanups (old_chain);
5414 gdb_breakpoint (char *address, char *condition,
5415 int hardwareflag, int tempflag,
5416 int thread, int ignore_count)
5418 struct captured_breakpoint_args args;
5419 args.address = address;
5420 args.condition = condition;
5421 args.hardwareflag = hardwareflag;
5422 args.tempflag = tempflag;
5423 args.thread = thread;
5424 args.ignore_count = ignore_count;
5425 return catch_errors (do_captured_breakpoint, &args,
5426 NULL, RETURN_MASK_ALL);
5431 break_at_finish_at_depth_command_1 (char *arg, int flag, int from_tty)
5433 struct frame_info *frame;
5434 CORE_ADDR low, high, selected_pc = 0;
5435 char *extra_args = NULL;
5437 int extra_args_len = 0, if_arg = 0;
5440 (arg[0] == 'i' && arg[1] == 'f' && (arg[2] == ' ' || arg[2] == '\t')))
5443 if (default_breakpoint_valid)
5445 if (deprecated_selected_frame)
5447 selected_pc = get_frame_pc (deprecated_selected_frame);
5452 error ("No selected frame.");
5455 error ("No default breakpoint address now.");
5459 extra_args = strchr (arg, ' ');
5463 extra_args_len = strlen (extra_args);
5464 level_arg = (char *) xmalloc (extra_args - arg);
5465 strncpy (level_arg, arg, extra_args - arg - 1);
5466 level_arg[extra_args - arg - 1] = '\0';
5470 level_arg = (char *) xmalloc (strlen (arg) + 1);
5471 strcpy (level_arg, arg);
5474 frame = parse_frame_specification (level_arg);
5476 selected_pc = get_frame_pc (frame);
5483 extra_args_len = strlen (arg);
5488 if (find_pc_partial_function (selected_pc, (char **) NULL, &low, &high))
5492 addr_string = xstrprintf ("*0x%s %s", paddr_nz (high), extra_args);
5494 addr_string = xstrprintf ("*0x%s", paddr_nz (high));
5495 break_command_1 (addr_string, flag, from_tty, NULL);
5496 xfree (addr_string);
5499 error ("No function contains the specified address");
5502 error ("Unable to set breakpoint at procedure exit");
5507 break_at_finish_command_1 (char *arg, int flag, int from_tty)
5509 char *addr_string, *break_string, *beg_addr_string;
5510 CORE_ADDR low, high;
5511 struct symtabs_and_lines sals;
5512 struct symtab_and_line sal;
5513 struct cleanup *old_chain;
5514 char *extra_args = NULL;
5515 int extra_args_len = 0;
5519 (arg[0] == 'i' && arg[1] == 'f' && (arg[2] == ' ' || arg[2] == '\t')))
5521 if (default_breakpoint_valid)
5523 if (deprecated_selected_frame)
5525 addr_string = xstrprintf ("*0x%s",
5526 paddr_nz (get_frame_pc (deprecated_selected_frame)));
5531 error ("No selected frame.");
5534 error ("No default breakpoint address now.");
5538 addr_string = (char *) xmalloc (strlen (arg) + 1);
5539 strcpy (addr_string, arg);
5545 extra_args_len = strlen (arg);
5549 /* get the stuff after the function name or address */
5550 extra_args = strchr (arg, ' ');
5554 extra_args_len = strlen (extra_args);
5561 beg_addr_string = addr_string;
5562 sals = decode_line_1 (&addr_string, 1, (struct symtab *) NULL, 0,
5563 (char ***) NULL, NULL);
5565 xfree (beg_addr_string);
5566 old_chain = make_cleanup (xfree, sals.sals);
5567 for (i = 0; (i < sals.nelts); i++)
5570 if (find_pc_partial_function (sal.pc, (char **) NULL, &low, &high))
5574 break_string = xstrprintf ("*0x%s %s", paddr_nz (high),
5577 break_string = xstrprintf ("*0x%s", paddr_nz (high));
5578 break_command_1 (break_string, flag, from_tty, NULL);
5579 xfree (break_string);
5582 error ("No function contains the specified address");
5586 warning ("Multiple breakpoints were set.\n");
5587 warning ("Use the \"delete\" command to delete unwanted breakpoints.");
5589 do_cleanups (old_chain);
5593 /* Helper function for break_command_1 and disassemble_command. */
5596 resolve_sal_pc (struct symtab_and_line *sal)
5600 if (sal->pc == 0 && sal->symtab != NULL)
5602 if (!find_line_pc (sal->symtab, sal->line, &pc))
5603 error ("No line %d in file \"%s\".",
5604 sal->line, sal->symtab->filename);
5608 if (sal->section == 0 && sal->symtab != NULL)
5610 struct blockvector *bv;
5615 bv = blockvector_for_pc_sect (sal->pc, 0, &index, sal->symtab);
5618 b = BLOCKVECTOR_BLOCK (bv, index);
5619 sym = block_function (b);
5622 fixup_symbol_section (sym, sal->symtab->objfile);
5623 sal->section = SYMBOL_BFD_SECTION (sym);
5627 /* It really is worthwhile to have the section, so we'll just
5628 have to look harder. This case can be executed if we have
5629 line numbers but no functions (as can happen in assembly
5632 struct minimal_symbol *msym;
5634 msym = lookup_minimal_symbol_by_pc (sal->pc);
5636 sal->section = SYMBOL_BFD_SECTION (msym);
5643 break_command (char *arg, int from_tty)
5645 break_command_1 (arg, 0, from_tty, NULL);
5649 break_at_finish_command (char *arg, int from_tty)
5651 break_at_finish_command_1 (arg, 0, from_tty);
5655 break_at_finish_at_depth_command (char *arg, int from_tty)
5657 break_at_finish_at_depth_command_1 (arg, 0, from_tty);
5661 tbreak_command (char *arg, int from_tty)
5663 break_command_1 (arg, BP_TEMPFLAG, from_tty, NULL);
5667 tbreak_at_finish_command (char *arg, int from_tty)
5669 break_at_finish_command_1 (arg, BP_TEMPFLAG, from_tty);
5673 hbreak_command (char *arg, int from_tty)
5675 break_command_1 (arg, BP_HARDWAREFLAG, from_tty, NULL);
5679 thbreak_command (char *arg, int from_tty)
5681 break_command_1 (arg, (BP_TEMPFLAG | BP_HARDWAREFLAG), from_tty, NULL);
5685 stop_command (char *arg, int from_tty)
5687 printf_filtered ("Specify the type of breakpoint to set.\n\
5688 Usage: stop in <function | address>\n\
5693 stopin_command (char *arg, int from_tty)
5697 if (arg == (char *) NULL)
5699 else if (*arg != '*')
5704 /* look for a ':'. If this is a line number specification, then
5705 say it is bad, otherwise, it should be an address or
5706 function/method name */
5707 while (*argptr && !hasColon)
5709 hasColon = (*argptr == ':');
5714 badInput = (*argptr != ':'); /* Not a class::method */
5716 badInput = isdigit (*arg); /* a simple line number */
5720 printf_filtered ("Usage: stop in <function | address>\n");
5722 break_command_1 (arg, 0, from_tty, NULL);
5726 stopat_command (char *arg, int from_tty)
5730 if (arg == (char *) NULL || *arg == '*') /* no line number */
5737 /* look for a ':'. If there is a '::' then get out, otherwise
5738 it is probably a line number. */
5739 while (*argptr && !hasColon)
5741 hasColon = (*argptr == ':');
5746 badInput = (*argptr == ':'); /* we have class::method */
5748 badInput = !isdigit (*arg); /* not a line number */
5752 printf_filtered ("Usage: stop at <line>\n");
5754 break_command_1 (arg, 0, from_tty, NULL);
5757 /* accessflag: hw_write: watch write,
5758 hw_read: watch read,
5759 hw_access: watch access (read or write) */
5761 watch_command_1 (char *arg, int accessflag, int from_tty)
5763 struct breakpoint *b;
5764 struct symtab_and_line sal;
5765 struct expression *exp;
5766 struct block *exp_valid_block;
5767 struct value *val, *mark;
5768 struct frame_info *frame;
5769 struct frame_info *prev_frame = NULL;
5770 char *exp_start = NULL;
5771 char *exp_end = NULL;
5772 char *tok, *end_tok;
5774 char *cond_start = NULL;
5775 char *cond_end = NULL;
5776 struct expression *cond = NULL;
5777 int i, other_type_used, target_resources_ok = 0;
5778 enum bptype bp_type;
5781 init_sal (&sal); /* initialize to zeroes */
5783 /* Parse arguments. */
5784 innermost_block = NULL;
5786 exp = parse_exp_1 (&arg, 0, 0);
5788 exp_valid_block = innermost_block;
5789 mark = value_mark ();
5790 val = evaluate_expression (exp);
5791 release_value (val);
5792 if (VALUE_LAZY (val))
5793 value_fetch_lazy (val);
5796 while (*tok == ' ' || *tok == '\t')
5800 while (*end_tok != ' ' && *end_tok != '\t' && *end_tok != '\000')
5803 toklen = end_tok - tok;
5804 if (toklen >= 1 && strncmp (tok, "if", toklen) == 0)
5806 tok = cond_start = end_tok + 1;
5807 cond = parse_exp_1 (&tok, 0, 0);
5811 error ("Junk at end of command.");
5813 if (accessflag == hw_read)
5814 bp_type = bp_read_watchpoint;
5815 else if (accessflag == hw_access)
5816 bp_type = bp_access_watchpoint;
5818 bp_type = bp_hardware_watchpoint;
5820 mem_cnt = can_use_hardware_watchpoint (val);
5821 if (mem_cnt == 0 && bp_type != bp_hardware_watchpoint)
5822 error ("Expression cannot be implemented with read/access watchpoint.");
5825 i = hw_watchpoint_used_count (bp_type, &other_type_used);
5826 target_resources_ok =
5827 TARGET_CAN_USE_HARDWARE_WATCHPOINT (bp_type, i + mem_cnt,
5829 if (target_resources_ok == 0 && bp_type != bp_hardware_watchpoint)
5830 error ("Target does not support this type of hardware watchpoint.");
5832 if (target_resources_ok < 0 && bp_type != bp_hardware_watchpoint)
5833 error ("Target can only support one kind of HW watchpoint at a time.");
5836 #if defined(HPUXHPPA)
5837 /* On HP-UX if you set a h/w
5838 watchpoint before the "run" command, the inferior dies with a e.g.,
5839 SIGILL once you start it. I initially believed this was due to a
5840 bad interaction between page protection traps and the initial
5841 startup sequence by the dynamic linker.
5843 However, I tried avoiding that by having HP-UX's implementation of
5844 TARGET_CAN_USE_HW_WATCHPOINT return FALSE if there was no inferior_ptid
5845 yet, which forced slow watches before a "run" or "attach", and it
5846 still fails somewhere in the startup code.
5848 Until I figure out what's happening, I'm disallowing watches altogether
5849 before the "run" or "attach" command. We'll tell the user they must
5850 set watches after getting the program started. */
5851 if (!target_has_execution)
5853 warning ("can't do that without a running program; try \"break main\", \"run\" first");
5856 #endif /* HPUXHPPA */
5858 /* Change the type of breakpoint to an ordinary watchpoint if a hardware
5859 watchpoint could not be set. */
5860 if (!mem_cnt || target_resources_ok <= 0)
5861 bp_type = bp_watchpoint;
5863 /* Now set up the breakpoint. */
5864 b = set_raw_breakpoint (sal, bp_type);
5865 set_breakpoint_count (breakpoint_count + 1);
5866 b->number = breakpoint_count;
5867 b->disposition = disp_donttouch;
5869 b->exp_valid_block = exp_valid_block;
5870 b->exp_string = savestring (exp_start, exp_end - exp_start);
5874 b->cond_string = savestring (cond_start, cond_end - cond_start);
5878 frame = block_innermost_frame (exp_valid_block);
5881 prev_frame = get_prev_frame (frame);
5882 b->watchpoint_frame = get_frame_id (frame);
5886 memset (&b->watchpoint_frame, 0, sizeof (b->watchpoint_frame));
5889 /* If the expression is "local", then set up a "watchpoint scope"
5890 breakpoint at the point where we've left the scope of the watchpoint
5892 if (innermost_block)
5896 struct breakpoint *scope_breakpoint;
5897 scope_breakpoint = create_internal_breakpoint (get_frame_pc (prev_frame),
5898 bp_watchpoint_scope);
5900 scope_breakpoint->enable_state = bp_enabled;
5902 /* Automatically delete the breakpoint when it hits. */
5903 scope_breakpoint->disposition = disp_del;
5905 /* Only break in the proper frame (help with recursion). */
5906 scope_breakpoint->frame_id = get_frame_id (prev_frame);
5908 /* Set the address at which we will stop. */
5909 scope_breakpoint->loc->requested_address
5910 = get_frame_pc (prev_frame);
5911 scope_breakpoint->loc->address
5912 = adjust_breakpoint_address (scope_breakpoint->loc->requested_address,
5913 scope_breakpoint->type);
5915 /* The scope breakpoint is related to the watchpoint. We
5916 will need to act on them together. */
5917 b->related_breakpoint = scope_breakpoint;
5920 value_free_to_mark (mark);
5924 /* Return count of locations need to be watched and can be handled
5925 in hardware. If the watchpoint can not be handled
5926 in hardware return zero. */
5928 #if !defined(TARGET_REGION_OK_FOR_HW_WATCHPOINT)
5929 #define TARGET_REGION_OK_FOR_HW_WATCHPOINT(ADDR,LEN) \
5930 (TARGET_REGION_SIZE_OK_FOR_HW_WATCHPOINT(LEN))
5934 can_use_hardware_watchpoint (struct value *v)
5936 int found_memory_cnt = 0;
5937 struct value *head = v;
5939 /* Did the user specifically forbid us to use hardware watchpoints? */
5940 if (!can_use_hw_watchpoints)
5943 /* Make sure that the value of the expression depends only upon
5944 memory contents, and values computed from them within GDB. If we
5945 find any register references or function calls, we can't use a
5946 hardware watchpoint.
5948 The idea here is that evaluating an expression generates a series
5949 of values, one holding the value of every subexpression. (The
5950 expression a*b+c has five subexpressions: a, b, a*b, c, and
5951 a*b+c.) GDB's values hold almost enough information to establish
5952 the criteria given above --- they identify memory lvalues,
5953 register lvalues, computed values, etcetera. So we can evaluate
5954 the expression, and then scan the chain of values that leaves
5955 behind to decide whether we can detect any possible change to the
5956 expression's final value using only hardware watchpoints.
5958 However, I don't think that the values returned by inferior
5959 function calls are special in any way. So this function may not
5960 notice that an expression involving an inferior function call
5961 can't be watched with hardware watchpoints. FIXME. */
5962 for (; v; v = v->next)
5964 if (VALUE_LVAL (v) == lval_memory)
5967 /* A lazy memory lvalue is one that GDB never needed to fetch;
5968 we either just used its address (e.g., `a' in `a.b') or
5969 we never needed it at all (e.g., `a' in `a,b'). */
5973 /* Ahh, memory we actually used! Check if we can cover
5974 it with hardware watchpoints. */
5975 struct type *vtype = check_typedef (VALUE_TYPE (v));
5977 /* We only watch structs and arrays if user asked for it
5978 explicitly, never if they just happen to appear in a
5979 middle of some value chain. */
5981 || (TYPE_CODE (vtype) != TYPE_CODE_STRUCT
5982 && TYPE_CODE (vtype) != TYPE_CODE_ARRAY))
5984 CORE_ADDR vaddr = VALUE_ADDRESS (v) + VALUE_OFFSET (v);
5985 int len = TYPE_LENGTH (VALUE_TYPE (v));
5987 if (!TARGET_REGION_OK_FOR_HW_WATCHPOINT (vaddr, len))
5994 else if (v->lval != not_lval && v->modifiable == 0)
5995 return 0; /* ??? What does this represent? */
5996 else if (v->lval == lval_register)
5997 return 0; /* cannot watch a register with a HW watchpoint */
6000 /* The expression itself looks suitable for using a hardware
6001 watchpoint, but give the target machine a chance to reject it. */
6002 return found_memory_cnt;
6006 watch_command_wrapper (char *arg, int from_tty)
6008 watch_command (arg, from_tty);
6012 watch_command (char *arg, int from_tty)
6014 watch_command_1 (arg, hw_write, from_tty);
6018 rwatch_command_wrapper (char *arg, int from_tty)
6020 rwatch_command (arg, from_tty);
6024 rwatch_command (char *arg, int from_tty)
6026 watch_command_1 (arg, hw_read, from_tty);
6030 awatch_command_wrapper (char *arg, int from_tty)
6032 awatch_command (arg, from_tty);
6036 awatch_command (char *arg, int from_tty)
6038 watch_command_1 (arg, hw_access, from_tty);
6042 /* Helper routines for the until_command routine in infcmd.c. Here
6043 because it uses the mechanisms of breakpoints. */
6045 /* This function is called by fetch_inferior_event via the
6046 cmd_continuation pointer, to complete the until command. It takes
6047 care of cleaning up the temporary breakpoints set up by the until
6050 until_break_command_continuation (struct continuation_arg *arg)
6052 struct cleanup *cleanups;
6054 cleanups = (struct cleanup *) arg->data.pointer;
6055 do_exec_cleanups (cleanups);
6059 until_break_command (char *arg, int from_tty, int anywhere)
6061 struct symtabs_and_lines sals;
6062 struct symtab_and_line sal;
6063 struct frame_info *prev_frame = get_prev_frame (deprecated_selected_frame);
6064 struct breakpoint *breakpoint;
6065 struct cleanup *old_chain;
6066 struct continuation_arg *arg1;
6069 clear_proceed_status ();
6071 /* Set a breakpoint where the user wants it and at return from
6074 if (default_breakpoint_valid)
6075 sals = decode_line_1 (&arg, 1, default_breakpoint_symtab,
6076 default_breakpoint_line, (char ***) NULL, NULL);
6078 sals = decode_line_1 (&arg, 1, (struct symtab *) NULL,
6079 0, (char ***) NULL, NULL);
6081 if (sals.nelts != 1)
6082 error ("Couldn't get information on specified line.");
6085 xfree (sals.sals); /* malloc'd, so freed */
6088 error ("Junk at end of arguments.");
6090 resolve_sal_pc (&sal);
6093 /* If the user told us to continue until a specified location,
6094 we don't specify a frame at which we need to stop. */
6095 breakpoint = set_momentary_breakpoint (sal, null_frame_id, bp_until);
6097 /* Otherwise, specify the current frame, because we want to stop only
6098 at the very same frame. */
6099 breakpoint = set_momentary_breakpoint (sal,
6100 get_frame_id (deprecated_selected_frame),
6103 if (!event_loop_p || !target_can_async_p ())
6104 old_chain = make_cleanup_delete_breakpoint (breakpoint);
6106 old_chain = make_exec_cleanup_delete_breakpoint (breakpoint);
6108 /* If we are running asynchronously, and the target supports async
6109 execution, we are not waiting for the target to stop, in the call
6110 tp proceed, below. This means that we cannot delete the
6111 brekpoints until the target has actually stopped. The only place
6112 where we get a chance to do that is in fetch_inferior_event, so
6113 we must set things up for that. */
6115 if (event_loop_p && target_can_async_p ())
6117 /* In this case the arg for the continuation is just the point
6118 in the exec_cleanups chain from where to start doing
6119 cleanups, because all the continuation does is the cleanups in
6120 the exec_cleanup_chain. */
6122 (struct continuation_arg *) xmalloc (sizeof (struct continuation_arg));
6124 arg1->data.pointer = old_chain;
6126 add_continuation (until_break_command_continuation, arg1);
6129 /* Keep within the current frame, or in frames called by the current
6133 sal = find_pc_line (get_frame_pc (prev_frame), 0);
6134 sal.pc = get_frame_pc (prev_frame);
6135 breakpoint = set_momentary_breakpoint (sal, get_frame_id (prev_frame),
6137 if (!event_loop_p || !target_can_async_p ())
6138 make_cleanup_delete_breakpoint (breakpoint);
6140 make_exec_cleanup_delete_breakpoint (breakpoint);
6143 proceed (-1, TARGET_SIGNAL_DEFAULT, 0);
6144 /* Do the cleanups now, anly if we are not running asynchronously,
6145 of if we are, but the target is still synchronous. */
6146 if (!event_loop_p || !target_can_async_p ())
6147 do_cleanups (old_chain);
6151 ep_skip_leading_whitespace (char **s)
6153 if ((s == NULL) || (*s == NULL))
6155 while (isspace (**s))
6159 /* This function examines a string, and attempts to find a token
6160 that might be an event name in the leading characters. If a
6161 possible match is found, a pointer to the last character of
6162 the token is returned. Else, NULL is returned. */
6165 ep_find_event_name_end (char *arg)
6168 char *event_name_end = NULL;
6170 /* If we could depend upon the presense of strrpbrk, we'd use that... */
6174 /* We break out of the loop when we find a token delimiter.
6175 Basically, we're looking for alphanumerics and underscores;
6176 anything else delimites the token. */
6179 if (!isalnum (*s) && (*s != '_'))
6185 return event_name_end;
6189 /* This function attempts to parse an optional "if <cond>" clause
6190 from the arg string. If one is not found, it returns NULL.
6192 Else, it returns a pointer to the condition string. (It does not
6193 attempt to evaluate the string against a particular block.) And,
6194 it updates arg to point to the first character following the parsed
6195 if clause in the arg string. */
6198 ep_parse_optional_if_clause (char **arg)
6202 if (((*arg)[0] != 'i') || ((*arg)[1] != 'f') || !isspace ((*arg)[2]))
6205 /* Skip the "if" keyword. */
6208 /* Skip any extra leading whitespace, and record the start of the
6209 condition string. */
6210 ep_skip_leading_whitespace (arg);
6213 /* Assume that the condition occupies the remainder of the arg string. */
6214 (*arg) += strlen (cond_string);
6219 /* This function attempts to parse an optional filename from the arg
6220 string. If one is not found, it returns NULL.
6222 Else, it returns a pointer to the parsed filename. (This function
6223 makes no attempt to verify that a file of that name exists, or is
6224 accessible.) And, it updates arg to point to the first character
6225 following the parsed filename in the arg string.
6227 Note that clients needing to preserve the returned filename for
6228 future access should copy it to their own buffers. */
6230 ep_parse_optional_filename (char **arg)
6232 static char filename[1024];
6237 if ((*arg_p == '\0') || isspace (*arg_p))
6255 /* Commands to deal with catching events, such as signals, exceptions,
6256 process start/exit, etc. */
6260 catch_fork, catch_vfork
6265 catch_fork_command_1 (catch_fork_kind fork_kind, char *arg, int tempflag,
6268 char *cond_string = NULL;
6270 ep_skip_leading_whitespace (&arg);
6272 /* The allowed syntax is:
6274 catch [v]fork if <cond>
6276 First, check if there's an if clause. */
6277 cond_string = ep_parse_optional_if_clause (&arg);
6279 if ((*arg != '\0') && !isspace (*arg))
6280 error ("Junk at end of arguments.");
6282 /* If this target supports it, create a fork or vfork catchpoint
6283 and enable reporting of such events. */
6287 create_fork_event_catchpoint (tempflag, cond_string);
6290 create_vfork_event_catchpoint (tempflag, cond_string);
6293 error ("unsupported or unknown fork kind; cannot catch it");
6299 catch_exec_command_1 (char *arg, int tempflag, int from_tty)
6301 char *cond_string = NULL;
6303 ep_skip_leading_whitespace (&arg);
6305 /* The allowed syntax is:
6307 catch exec if <cond>
6309 First, check if there's an if clause. */
6310 cond_string = ep_parse_optional_if_clause (&arg);
6312 if ((*arg != '\0') && !isspace (*arg))
6313 error ("Junk at end of arguments.");
6315 /* If this target supports it, create an exec catchpoint
6316 and enable reporting of such events. */
6317 create_exec_event_catchpoint (tempflag, cond_string);
6321 catch_load_command_1 (char *arg, int tempflag, int from_tty)
6323 char *dll_pathname = NULL;
6324 char *cond_string = NULL;
6326 ep_skip_leading_whitespace (&arg);
6328 /* The allowed syntax is:
6330 catch load if <cond>
6331 catch load <filename>
6332 catch load <filename> if <cond>
6334 The user is not allowed to specify the <filename> after an
6337 We'll ignore the pathological case of a file named "if".
6339 First, check if there's an if clause. If so, then there
6340 cannot be a filename. */
6341 cond_string = ep_parse_optional_if_clause (&arg);
6343 /* If there was an if clause, then there cannot be a filename.
6344 Else, there might be a filename and an if clause. */
6345 if (cond_string == NULL)
6347 dll_pathname = ep_parse_optional_filename (&arg);
6348 ep_skip_leading_whitespace (&arg);
6349 cond_string = ep_parse_optional_if_clause (&arg);
6352 if ((*arg != '\0') && !isspace (*arg))
6353 error ("Junk at end of arguments.");
6355 /* Create a load breakpoint that only triggers when a load of
6356 the specified dll (or any dll, if no pathname was specified)
6358 SOLIB_CREATE_CATCH_LOAD_HOOK (PIDGET (inferior_ptid), tempflag,
6359 dll_pathname, cond_string);
6363 catch_unload_command_1 (char *arg, int tempflag, int from_tty)
6365 char *dll_pathname = NULL;
6366 char *cond_string = NULL;
6368 ep_skip_leading_whitespace (&arg);
6370 /* The allowed syntax is:
6372 catch unload if <cond>
6373 catch unload <filename>
6374 catch unload <filename> if <cond>
6376 The user is not allowed to specify the <filename> after an
6379 We'll ignore the pathological case of a file named "if".
6381 First, check if there's an if clause. If so, then there
6382 cannot be a filename. */
6383 cond_string = ep_parse_optional_if_clause (&arg);
6385 /* If there was an if clause, then there cannot be a filename.
6386 Else, there might be a filename and an if clause. */
6387 if (cond_string == NULL)
6389 dll_pathname = ep_parse_optional_filename (&arg);
6390 ep_skip_leading_whitespace (&arg);
6391 cond_string = ep_parse_optional_if_clause (&arg);
6394 if ((*arg != '\0') && !isspace (*arg))
6395 error ("Junk at end of arguments.");
6397 /* Create an unload breakpoint that only triggers when an unload of
6398 the specified dll (or any dll, if no pathname was specified)
6400 SOLIB_CREATE_CATCH_UNLOAD_HOOK (PIDGET (inferior_ptid), tempflag,
6401 dll_pathname, cond_string);
6404 /* Commands to deal with catching exceptions. */
6406 /* Set a breakpoint at the specified callback routine for an
6407 exception event callback */
6410 create_exception_catchpoint (int tempflag, char *cond_string,
6411 enum exception_event_kind ex_event,
6412 struct symtab_and_line *sal)
6414 struct breakpoint *b;
6415 int thread = -1; /* All threads. */
6418 if (!sal) /* no exception support? */
6423 case EX_EVENT_THROW:
6424 bptype = bp_catch_throw;
6426 case EX_EVENT_CATCH:
6427 bptype = bp_catch_catch;
6429 default: /* error condition */
6430 error ("Internal error -- invalid catchpoint kind");
6433 b = set_raw_breakpoint (*sal, bptype);
6434 set_breakpoint_count (breakpoint_count + 1);
6435 b->number = breakpoint_count;
6437 b->cond_string = (cond_string == NULL) ?
6438 NULL : savestring (cond_string, strlen (cond_string));
6440 b->addr_string = NULL;
6441 b->enable_state = bp_enabled;
6442 b->disposition = tempflag ? disp_del : disp_donttouch;
6446 static enum print_stop_action
6447 print_exception_catchpoint (struct breakpoint *b)
6449 annotate_catchpoint (b->number);
6451 if (strstr (b->addr_string, "throw") != NULL)
6452 printf_filtered ("\nCatchpoint %d (exception thrown)\n",
6455 printf_filtered ("\nCatchpoint %d (exception caught)\n",
6458 return PRINT_SRC_AND_LOC;
6462 print_one_exception_catchpoint (struct breakpoint *b, CORE_ADDR *last_addr)
6467 ui_out_field_core_addr (uiout, "addr", b->loc->address);
6470 *last_addr = b->loc->address;
6471 if (strstr (b->addr_string, "throw") != NULL)
6472 ui_out_field_string (uiout, "what", "exception throw");
6474 ui_out_field_string (uiout, "what", "exception catch");
6478 print_mention_exception_catchpoint (struct breakpoint *b)
6480 if (strstr (b->addr_string, "throw") != NULL)
6481 printf_filtered ("Catchpoint %d (throw)", b->number);
6483 printf_filtered ("Catchpoint %d (catch)", b->number);
6486 static struct breakpoint_ops gnu_v3_exception_catchpoint_ops = {
6487 print_exception_catchpoint,
6488 print_one_exception_catchpoint,
6489 print_mention_exception_catchpoint
6493 handle_gnu_v3_exceptions (int tempflag, char *cond_string,
6494 enum exception_event_kind ex_event, int from_tty)
6496 char *trigger_func_name, *nameptr;
6497 struct symtabs_and_lines sals;
6498 struct breakpoint *b;
6500 if (ex_event == EX_EVENT_CATCH)
6501 trigger_func_name = xstrdup ("__cxa_begin_catch");
6503 trigger_func_name = xstrdup ("__cxa_throw");
6505 nameptr = trigger_func_name;
6506 sals = decode_line_1 (&nameptr, 1, NULL, 0, NULL, NULL);
6507 if (sals.nelts == 0)
6509 xfree (trigger_func_name);
6513 b = set_raw_breakpoint (sals.sals[0], bp_breakpoint);
6514 set_breakpoint_count (breakpoint_count + 1);
6515 b->number = breakpoint_count;
6517 b->cond_string = (cond_string == NULL) ?
6518 NULL : savestring (cond_string, strlen (cond_string));
6520 b->addr_string = trigger_func_name;
6521 b->enable_state = bp_enabled;
6522 b->disposition = tempflag ? disp_del : disp_donttouch;
6523 b->ops = &gnu_v3_exception_catchpoint_ops;
6530 /* Deal with "catch catch" and "catch throw" commands */
6533 catch_exception_command_1 (enum exception_event_kind ex_event, char *arg,
6534 int tempflag, int from_tty)
6536 char *cond_string = NULL;
6537 struct symtab_and_line *sal = NULL;
6539 ep_skip_leading_whitespace (&arg);
6541 cond_string = ep_parse_optional_if_clause (&arg);
6543 if ((*arg != '\0') && !isspace (*arg))
6544 error ("Junk at end of arguments.");
6546 if ((ex_event != EX_EVENT_THROW) &&
6547 (ex_event != EX_EVENT_CATCH))
6548 error ("Unsupported or unknown exception event; cannot catch it");
6550 if (handle_gnu_v3_exceptions (tempflag, cond_string, ex_event, from_tty))
6553 /* See if we can find a callback routine */
6554 sal = target_enable_exception_callback (ex_event, 1);
6558 /* We have callbacks from the runtime system for exceptions.
6559 Set a breakpoint on the sal found, if no errors */
6560 if (sal != (struct symtab_and_line *) -1)
6561 create_exception_catchpoint (tempflag, cond_string, ex_event, sal);
6563 return; /* something went wrong with setting up callbacks */
6566 warning ("Unsupported with this platform/compiler combination.");
6569 /* Cover routine to allow wrapping target_enable_exception_catchpoints
6570 inside a catch_errors */
6573 cover_target_enable_exception_callback (void *arg)
6575 args_for_catchpoint_enable *args = arg;
6576 struct symtab_and_line *sal;
6577 sal = target_enable_exception_callback (args->kind, args->enable_p);
6580 else if (sal == (struct symtab_and_line *) -1)
6583 return 1; /*is valid */
6587 catch_command_1 (char *arg, int tempflag, int from_tty)
6590 /* The first argument may be an event name, such as "start" or "load".
6591 If so, then handle it as such. If it doesn't match an event name,
6592 then attempt to interpret it as an exception name. (This latter is
6593 the v4.16-and-earlier GDB meaning of the "catch" command.)
6595 First, try to find the bounds of what might be an event name. */
6596 char *arg1_start = arg;
6600 if (arg1_start == NULL)
6602 /* Old behaviour was to use pre-v-4.16 syntax */
6603 /* catch_throw_command_1 (arg1_start, tempflag, from_tty); */
6605 /* Now, this is not allowed */
6606 error ("Catch requires an event name.");
6609 arg1_end = ep_find_event_name_end (arg1_start);
6610 if (arg1_end == NULL)
6611 error ("catch requires an event");
6612 arg1_length = arg1_end + 1 - arg1_start;
6614 /* Try to match what we found against known event names. */
6615 if (strncmp (arg1_start, "signal", arg1_length) == 0)
6617 error ("Catch of signal not yet implemented");
6619 else if (strncmp (arg1_start, "catch", arg1_length) == 0)
6621 catch_exception_command_1 (EX_EVENT_CATCH, arg1_end + 1,
6622 tempflag, from_tty);
6624 else if (strncmp (arg1_start, "throw", arg1_length) == 0)
6626 catch_exception_command_1 (EX_EVENT_THROW, arg1_end + 1,
6627 tempflag, from_tty);
6629 else if (strncmp (arg1_start, "thread_start", arg1_length) == 0)
6631 error ("Catch of thread_start not yet implemented");
6633 else if (strncmp (arg1_start, "thread_exit", arg1_length) == 0)
6635 error ("Catch of thread_exit not yet implemented");
6637 else if (strncmp (arg1_start, "thread_join", arg1_length) == 0)
6639 error ("Catch of thread_join not yet implemented");
6641 else if (strncmp (arg1_start, "start", arg1_length) == 0)
6643 error ("Catch of start not yet implemented");
6645 else if (strncmp (arg1_start, "exit", arg1_length) == 0)
6647 error ("Catch of exit not yet implemented");
6649 else if (strncmp (arg1_start, "fork", arg1_length) == 0)
6651 catch_fork_command_1 (catch_fork, arg1_end + 1, tempflag, from_tty);
6653 else if (strncmp (arg1_start, "vfork", arg1_length) == 0)
6655 catch_fork_command_1 (catch_vfork, arg1_end + 1, tempflag, from_tty);
6657 else if (strncmp (arg1_start, "exec", arg1_length) == 0)
6659 catch_exec_command_1 (arg1_end + 1, tempflag, from_tty);
6661 else if (strncmp (arg1_start, "load", arg1_length) == 0)
6663 catch_load_command_1 (arg1_end + 1, tempflag, from_tty);
6665 else if (strncmp (arg1_start, "unload", arg1_length) == 0)
6667 catch_unload_command_1 (arg1_end + 1, tempflag, from_tty);
6669 else if (strncmp (arg1_start, "stop", arg1_length) == 0)
6671 error ("Catch of stop not yet implemented");
6674 /* This doesn't appear to be an event name */
6678 /* Pre-v.4.16 behaviour was to treat the argument
6679 as the name of an exception */
6680 /* catch_throw_command_1 (arg1_start, tempflag, from_tty); */
6681 /* Now this is not allowed */
6682 error ("Unknown event kind specified for catch");
6687 /* Used by the gui, could be made a worker for other things. */
6690 set_breakpoint_sal (struct symtab_and_line sal)
6692 struct breakpoint *b;
6693 b = set_raw_breakpoint (sal, bp_breakpoint);
6694 set_breakpoint_count (breakpoint_count + 1);
6695 b->number = breakpoint_count;
6702 catch_command (char *arg, int from_tty)
6704 catch_command_1 (arg, 0, from_tty);
6709 tcatch_command (char *arg, int from_tty)
6711 catch_command_1 (arg, 1, from_tty);
6714 /* Delete breakpoints by address or line. */
6717 clear_command (char *arg, int from_tty)
6719 struct breakpoint *b, *tmp, *prev, *found;
6721 struct symtabs_and_lines sals;
6722 struct symtab_and_line sal;
6727 sals = decode_line_spec (arg, 1);
6732 sals.sals = (struct symtab_and_line *)
6733 xmalloc (sizeof (struct symtab_and_line));
6734 make_cleanup (xfree, sals.sals);
6735 init_sal (&sal); /* initialize to zeroes */
6736 sal.line = default_breakpoint_line;
6737 sal.symtab = default_breakpoint_symtab;
6738 sal.pc = default_breakpoint_address;
6739 if (sal.symtab == 0)
6740 error ("No source file specified.");
6748 /* For each line spec given, delete bps which correspond
6749 to it. Do it in two passes, solely to preserve the current
6750 behavior that from_tty is forced true if we delete more than
6754 for (i = 0; i < sals.nelts; i++)
6756 /* If exact pc given, clear bpts at that pc.
6757 If line given (pc == 0), clear all bpts on specified line.
6758 If defaulting, clear all bpts on default line
6761 defaulting sal.pc != 0 tests to do
6766 1 0 <can't happen> */
6771 /* Find all matching breakpoints, remove them from the
6772 breakpoint chain, and add them to the 'found' chain. */
6773 ALL_BREAKPOINTS_SAFE (b, tmp)
6775 /* Are we going to delete b? */
6776 if (b->type != bp_none
6777 && b->type != bp_watchpoint
6778 && b->type != bp_hardware_watchpoint
6779 && b->type != bp_read_watchpoint
6780 && b->type != bp_access_watchpoint
6781 /* Not if b is a watchpoint of any sort... */
6782 && (((sal.pc && (b->loc->address == sal.pc))
6783 && (!section_is_overlay (b->loc->section)
6784 || b->loc->section == sal.section))
6785 /* Yes, if sal.pc matches b (modulo overlays). */
6786 || ((default_match || (0 == sal.pc))
6787 && b->source_file != NULL
6788 && sal.symtab != NULL
6789 && strcmp (b->source_file, sal.symtab->filename) == 0
6790 && b->line_number == sal.line)))
6791 /* Yes, if sal source file and line matches b. */
6793 /* Remove it from breakpoint_chain... */
6794 if (b == breakpoint_chain)
6796 /* b is at the head of the list */
6797 breakpoint_chain = b->next;
6801 prev->next = b->next;
6803 /* And add it to 'found' chain. */
6809 /* Keep b, and keep a pointer to it. */
6814 /* Now go thru the 'found' chain and delete them. */
6818 error ("No breakpoint at %s.", arg);
6820 error ("No breakpoint at this line.");
6824 from_tty = 1; /* Always report if deleted more than one */
6826 printf_unfiltered ("Deleted breakpoint%s ", found->next ? "s" : "");
6827 breakpoints_changed ();
6831 printf_unfiltered ("%d ", found->number);
6833 delete_breakpoint (found);
6837 putchar_unfiltered ('\n');
6840 /* Delete breakpoint in BS if they are `delete' breakpoints and
6841 all breakpoints that are marked for deletion, whether hit or not.
6842 This is called after any breakpoint is hit, or after errors. */
6845 breakpoint_auto_delete (bpstat bs)
6847 struct breakpoint *b, *temp;
6849 for (; bs; bs = bs->next)
6850 if (bs->breakpoint_at && bs->breakpoint_at->disposition == disp_del
6852 delete_breakpoint (bs->breakpoint_at);
6854 ALL_BREAKPOINTS_SAFE (b, temp)
6856 if (b->disposition == disp_del_at_next_stop)
6857 delete_breakpoint (b);
6861 /* Delete a breakpoint and clean up all traces of it in the data
6865 delete_breakpoint (struct breakpoint *bpt)
6867 struct breakpoint *b;
6869 struct bp_location *loc;
6872 error ("Internal error (attempted to delete a NULL breakpoint)");
6875 /* Has this bp already been deleted? This can happen because multiple
6876 lists can hold pointers to bp's. bpstat lists are especial culprits.
6878 One example of this happening is a watchpoint's scope bp. When the
6879 scope bp triggers, we notice that the watchpoint is out of scope, and
6880 delete it. We also delete its scope bp. But the scope bp is marked
6881 "auto-deleting", and is already on a bpstat. That bpstat is then
6882 checked for auto-deleting bp's, which are deleted.
6884 A real solution to this problem might involve reference counts in bp's,
6885 and/or giving them pointers back to their referencing bpstat's, and
6886 teaching delete_breakpoint to only free a bp's storage when no more
6887 references were extent. A cheaper bandaid was chosen. */
6888 if (bpt->type == bp_none)
6891 if (deprecated_delete_breakpoint_hook)
6892 deprecated_delete_breakpoint_hook (bpt);
6893 breakpoint_delete_event (bpt->number);
6895 if (bpt->loc->inserted)
6896 remove_breakpoint (bpt->loc, mark_inserted);
6898 free_valchain (bpt->loc);
6900 if (breakpoint_chain == bpt)
6901 breakpoint_chain = bpt->next;
6903 if (bp_location_chain == bpt->loc)
6904 bp_location_chain = bpt->loc->next;
6906 /* If we have callback-style exception catchpoints, don't go through
6907 the adjustments to the C++ runtime library etc. if the inferior
6908 isn't actually running. target_enable_exception_callback for a
6909 null target ops vector gives an undesirable error message, so we
6910 check here and avoid it. Since currently (1997-09-17) only HP-UX aCC's
6911 exceptions are supported in this way, it's OK for now. FIXME */
6912 if (ep_is_exception_catchpoint (bpt) && target_has_execution)
6914 /* Format possible error msg */
6915 char *message = xstrprintf ("Error in deleting catchpoint %d:\n",
6917 struct cleanup *cleanups = make_cleanup (xfree, message);
6918 args_for_catchpoint_enable args;
6919 args.kind = bpt->type == bp_catch_catch ?
6920 EX_EVENT_CATCH : EX_EVENT_THROW;
6922 catch_errors (cover_target_enable_exception_callback, &args,
6923 message, RETURN_MASK_ALL);
6924 do_cleanups (cleanups);
6931 b->next = bpt->next;
6935 ALL_BP_LOCATIONS (loc)
6936 if (loc->next == bpt->loc)
6938 loc->next = bpt->loc->next;
6942 check_duplicates (bpt);
6943 /* If this breakpoint was inserted, and there is another breakpoint
6944 at the same address, we need to insert the other breakpoint. */
6945 if (bpt->loc->inserted
6946 && bpt->type != bp_hardware_watchpoint
6947 && bpt->type != bp_read_watchpoint
6948 && bpt->type != bp_access_watchpoint
6949 && bpt->type != bp_catch_fork
6950 && bpt->type != bp_catch_vfork
6951 && bpt->type != bp_catch_exec)
6954 if (b->loc->address == bpt->loc->address
6955 && b->loc->section == bpt->loc->section
6956 && !b->loc->duplicate
6957 && b->enable_state != bp_disabled
6958 && b->enable_state != bp_shlib_disabled
6960 && b->enable_state != bp_call_disabled)
6964 /* We should never reach this point if there is a permanent
6965 breakpoint at the same address as the one being deleted.
6966 If there is a permanent breakpoint somewhere, it should
6967 always be the only one inserted. */
6968 if (b->enable_state == bp_permanent)
6969 internal_error (__FILE__, __LINE__,
6970 "another breakpoint was inserted on top of "
6971 "a permanent breakpoint");
6973 if (b->type == bp_hardware_breakpoint)
6974 val = target_insert_hw_breakpoint (b->loc->address, b->loc->shadow_contents);
6976 val = target_insert_breakpoint (b->loc->address, b->loc->shadow_contents);
6978 /* If there was an error in the insert, print a message, then stop execution. */
6981 struct ui_file *tmp_error_stream = mem_fileopen ();
6982 make_cleanup_ui_file_delete (tmp_error_stream);
6985 if (b->type == bp_hardware_breakpoint)
6987 fprintf_unfiltered (tmp_error_stream,
6988 "Cannot insert hardware breakpoint %d.\n"
6989 "You may have requested too many hardware breakpoints.\n",
6994 fprintf_unfiltered (tmp_error_stream, "Cannot insert breakpoint %d.\n", b->number);
6995 fprintf_filtered (tmp_error_stream, "Error accessing memory address ");
6996 print_address_numeric (b->loc->address, 1, tmp_error_stream);
6997 fprintf_filtered (tmp_error_stream, ": %s.\n",
6998 safe_strerror (val));
7001 fprintf_unfiltered (tmp_error_stream,"The same program may be running in another process.");
7002 target_terminal_ours_for_output ();
7003 error_stream(tmp_error_stream);
7006 b->loc->inserted = 1;
7010 free_command_lines (&bpt->commands);
7013 if (bpt->cond_string != NULL)
7014 xfree (bpt->cond_string);
7015 if (bpt->addr_string != NULL)
7016 xfree (bpt->addr_string);
7017 if (bpt->exp != NULL)
7019 if (bpt->exp_string != NULL)
7020 xfree (bpt->exp_string);
7021 if (bpt->val != NULL)
7022 value_free (bpt->val);
7023 if (bpt->source_file != NULL)
7024 xfree (bpt->source_file);
7025 if (bpt->dll_pathname != NULL)
7026 xfree (bpt->dll_pathname);
7027 if (bpt->triggered_dll_pathname != NULL)
7028 xfree (bpt->triggered_dll_pathname);
7029 if (bpt->exec_pathname != NULL)
7030 xfree (bpt->exec_pathname);
7032 /* Be sure no bpstat's are pointing at it after it's been freed. */
7033 /* FIXME, how can we find all bpstat's?
7034 We just check stop_bpstat for now. */
7035 for (bs = stop_bpstat; bs; bs = bs->next)
7036 if (bs->breakpoint_at == bpt)
7038 bs->breakpoint_at = NULL;
7040 /* bs->commands will be freed later. */
7042 /* On the chance that someone will soon try again to delete this same
7043 bp, we mark it as deleted before freeing its storage. */
7044 bpt->type = bp_none;
7051 do_delete_breakpoint_cleanup (void *b)
7053 delete_breakpoint (b);
7057 make_cleanup_delete_breakpoint (struct breakpoint *b)
7059 return make_cleanup (do_delete_breakpoint_cleanup, b);
7063 make_exec_cleanup_delete_breakpoint (struct breakpoint *b)
7065 return make_exec_cleanup (do_delete_breakpoint_cleanup, b);
7069 delete_command (char *arg, int from_tty)
7071 struct breakpoint *b, *temp;
7077 int breaks_to_delete = 0;
7079 /* Delete all breakpoints if no argument.
7080 Do not delete internal or call-dummy breakpoints, these
7081 have to be deleted with an explicit breakpoint number argument. */
7084 if (b->type != bp_call_dummy &&
7085 b->type != bp_shlib_event &&
7086 b->type != bp_thread_event &&
7087 b->type != bp_overlay_event &&
7089 breaks_to_delete = 1;
7092 /* Ask user only if there are some breakpoints to delete. */
7094 || (breaks_to_delete && query ("Delete all breakpoints? ")))
7096 ALL_BREAKPOINTS_SAFE (b, temp)
7098 if (b->type != bp_call_dummy &&
7099 b->type != bp_shlib_event &&
7100 b->type != bp_thread_event &&
7101 b->type != bp_overlay_event &&
7103 delete_breakpoint (b);
7108 map_breakpoint_numbers (arg, delete_breakpoint);
7111 /* Reset a breakpoint given it's struct breakpoint * BINT.
7112 The value we return ends up being the return value from catch_errors.
7113 Unused in this case. */
7116 breakpoint_re_set_one (void *bint)
7118 /* get past catch_errs */
7119 struct breakpoint *b = (struct breakpoint *) bint;
7122 struct symtabs_and_lines sals;
7124 enum enable_state save_enable;
7129 warning ("attempted to reset apparently deleted breakpoint #%d?",
7133 case bp_hardware_breakpoint:
7135 case bp_catch_unload:
7136 if (b->addr_string == NULL)
7138 /* Anything without a string can't be re-set. */
7139 delete_breakpoint (b);
7142 /* HACK: cagney/2001-11-11: kettenis/2001-11-11: MarkK wrote:
7144 ``And a hack it is, although Apple's Darwin version of GDB
7145 contains an almost identical hack to implement a "future
7146 break" command. It seems to work in many real world cases,
7147 but it is easy to come up with a test case where the patch
7148 doesn't help at all.''
7150 ``It seems that the way GDB implements breakpoints - in -
7151 shared - libraries was designed for a.out shared library
7152 systems (SunOS 4) where shared libraries were loaded at a
7153 fixed address in memory. Since ELF shared libraries can (and
7154 will) be loaded at any address in memory, things break.
7155 Fixing this is not trivial. Therefore, I'm not sure whether
7156 we should add this hack to the branch only. I cannot
7157 guarantee that things will be fixed on the trunk in the near
7160 In case we have a problem, disable this breakpoint. We'll
7161 restore its status if we succeed. Don't disable a
7162 shlib_disabled breakpoint though. There's a fair chance we
7163 can't re-set it if the shared library it's in hasn't been
7169 save_enable = b->enable_state;
7170 if (b->enable_state != bp_shlib_disabled)
7171 b->enable_state = bp_disabled;
7173 set_language (b->language);
7174 input_radix = b->input_radix;
7176 sals = decode_line_1 (&s, 1, (struct symtab *) NULL, 0, (char ***) NULL, NULL);
7177 for (i = 0; i < sals.nelts; i++)
7179 resolve_sal_pc (&sals.sals[i]);
7181 /* Reparse conditions, they might contain references to the
7183 if (b->cond_string != NULL)
7189 /* Avoid re-freeing b->exp if an error during the call
7193 b->cond = parse_exp_1 (&s, block_for_pc (sals.sals[i].pc), 0);
7196 /* We need to re-set the breakpoint if the address changes... */
7197 if (b->loc->address != sals.sals[i].pc
7198 /* ...or new and old breakpoints both have source files, and
7199 the source file name or the line number changes... */
7200 || (b->source_file != NULL
7201 && sals.sals[i].symtab != NULL
7202 && (strcmp (b->source_file, sals.sals[i].symtab->filename) != 0
7203 || b->line_number != sals.sals[i].line)
7205 /* ...or we switch between having a source file and not having
7207 || ((b->source_file == NULL) != (sals.sals[i].symtab == NULL))
7210 if (b->source_file != NULL)
7211 xfree (b->source_file);
7212 if (sals.sals[i].symtab == NULL)
7213 b->source_file = NULL;
7216 savestring (sals.sals[i].symtab->filename,
7217 strlen (sals.sals[i].symtab->filename));
7218 b->line_number = sals.sals[i].line;
7219 b->loc->requested_address = sals.sals[i].pc;
7221 = adjust_breakpoint_address (b->loc->requested_address,
7224 /* Used to check for duplicates here, but that can
7225 cause trouble, as it doesn't check for disabled
7230 /* Might be better to do this just once per breakpoint_re_set,
7231 rather than once for every breakpoint. */
7232 breakpoints_changed ();
7234 b->loc->section = sals.sals[i].section;
7235 b->enable_state = save_enable; /* Restore it, this worked. */
7238 /* Now that this is re-enabled, check_duplicates
7240 check_duplicates (b);
7247 case bp_hardware_watchpoint:
7248 case bp_read_watchpoint:
7249 case bp_access_watchpoint:
7250 innermost_block = NULL;
7251 /* The issue arises of what context to evaluate this in. The
7252 same one as when it was set, but what does that mean when
7253 symbols have been re-read? We could save the filename and
7254 functionname, but if the context is more local than that, the
7255 best we could do would be something like how many levels deep
7256 and which index at that particular level, but that's going to
7257 be less stable than filenames or function names. */
7259 /* So for now, just use a global context. */
7263 /* Avoid re-freeing b->exp if an error during the call to
7264 parse_expression. */
7267 b->exp = parse_expression (b->exp_string);
7268 b->exp_valid_block = innermost_block;
7269 mark = value_mark ();
7272 value_free (b->val);
7273 /* Avoid re-freeing b->val if an error during the call to
7274 evaluate_expression. */
7277 b->val = evaluate_expression (b->exp);
7278 release_value (b->val);
7279 if (VALUE_LAZY (b->val) && breakpoint_enabled (b))
7280 value_fetch_lazy (b->val);
7282 if (b->cond_string != NULL)
7288 /* Avoid re-freeing b->exp if an error during the call
7292 b->cond = parse_exp_1 (&s, (struct block *) 0, 0);
7294 if (breakpoint_enabled (b))
7296 value_free_to_mark (mark);
7298 case bp_catch_catch:
7299 case bp_catch_throw:
7301 /* We needn't really do anything to reset these, since the mask
7302 that requests them is unaffected by e.g., new libraries being
7305 case bp_catch_vfork:
7310 printf_filtered ("Deleting unknown breakpoint type %d\n", b->type);
7312 /* Delete longjmp and overlay event breakpoints; they will be
7313 reset later by breakpoint_re_set. */
7315 case bp_longjmp_resume:
7316 case bp_overlay_event:
7317 delete_breakpoint (b);
7320 /* This breakpoint is special, it's set up when the inferior
7321 starts and we really don't want to touch it. */
7322 case bp_shlib_event:
7324 /* Like bp_shlib_event, this breakpoint type is special.
7325 Once it is set up, we do not want to touch it. */
7326 case bp_thread_event:
7328 /* Keep temporary breakpoints, which can be encountered when we step
7329 over a dlopen call and SOLIB_ADD is resetting the breakpoints.
7330 Otherwise these should have been blown away via the cleanup chain
7331 or by breakpoint_init_inferior when we rerun the executable. */
7334 case bp_watchpoint_scope:
7336 case bp_step_resume:
7343 /* Re-set all breakpoints after symbols have been re-loaded. */
7345 breakpoint_re_set (void)
7347 struct breakpoint *b, *temp;
7348 enum language save_language;
7349 int save_input_radix;
7351 save_language = current_language->la_language;
7352 save_input_radix = input_radix;
7353 ALL_BREAKPOINTS_SAFE (b, temp)
7355 /* Format possible error msg */
7356 char *message = xstrprintf ("Error in re-setting breakpoint %d:\n",
7358 struct cleanup *cleanups = make_cleanup (xfree, message);
7359 catch_errors (breakpoint_re_set_one, b, message, RETURN_MASK_ALL);
7360 do_cleanups (cleanups);
7362 set_language (save_language);
7363 input_radix = save_input_radix;
7365 if (GET_LONGJMP_TARGET_P ())
7367 create_longjmp_breakpoint ("longjmp");
7368 create_longjmp_breakpoint ("_longjmp");
7369 create_longjmp_breakpoint ("siglongjmp");
7370 create_longjmp_breakpoint ("_siglongjmp");
7371 create_longjmp_breakpoint (NULL);
7374 create_overlay_event_breakpoint ("_ovly_debug_event");
7377 /* Reset the thread number of this breakpoint:
7379 - If the breakpoint is for all threads, leave it as-is.
7380 - Else, reset it to the current thread for inferior_ptid. */
7382 breakpoint_re_set_thread (struct breakpoint *b)
7384 if (b->thread != -1)
7386 if (in_thread_list (inferior_ptid))
7387 b->thread = pid_to_thread_id (inferior_ptid);
7391 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
7392 If from_tty is nonzero, it prints a message to that effect,
7393 which ends with a period (no newline). */
7396 set_ignore_count (int bptnum, int count, int from_tty)
7398 struct breakpoint *b;
7404 if (b->number == bptnum)
7406 b->ignore_count = count;
7410 printf_filtered ("Will stop next time breakpoint %d is reached.",
7412 else if (count == 1)
7413 printf_filtered ("Will ignore next crossing of breakpoint %d.",
7416 printf_filtered ("Will ignore next %d crossings of breakpoint %d.",
7419 breakpoints_changed ();
7420 breakpoint_modify_event (b->number);
7424 error ("No breakpoint number %d.", bptnum);
7427 /* Clear the ignore counts of all breakpoints. */
7429 breakpoint_clear_ignore_counts (void)
7431 struct breakpoint *b;
7434 b->ignore_count = 0;
7437 /* Command to set ignore-count of breakpoint N to COUNT. */
7440 ignore_command (char *args, int from_tty)
7446 error_no_arg ("a breakpoint number");
7448 num = get_number (&p);
7450 error ("bad breakpoint number: '%s'", args);
7452 error ("Second argument (specified ignore-count) is missing.");
7454 set_ignore_count (num,
7455 longest_to_int (value_as_long (parse_and_eval (p))),
7458 printf_filtered ("\n");
7461 /* Call FUNCTION on each of the breakpoints
7462 whose numbers are given in ARGS. */
7465 map_breakpoint_numbers (char *args, void (*function) (struct breakpoint *))
7470 struct breakpoint *b, *tmp;
7474 error_no_arg ("one or more breakpoint numbers");
7481 num = get_number_or_range (&p1);
7484 warning ("bad breakpoint number at or near '%s'", p);
7488 ALL_BREAKPOINTS_SAFE (b, tmp)
7489 if (b->number == num)
7491 struct breakpoint *related_breakpoint = b->related_breakpoint;
7494 if (related_breakpoint)
7495 function (related_breakpoint);
7499 printf_unfiltered ("No breakpoint number %d.\n", num);
7505 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
7506 If from_tty is nonzero, it prints a message to that effect,
7507 which ends with a period (no newline). */
7510 disable_breakpoint (struct breakpoint *bpt)
7512 /* Never disable a watchpoint scope breakpoint; we want to
7513 hit them when we leave scope so we can delete both the
7514 watchpoint and its scope breakpoint at that time. */
7515 if (bpt->type == bp_watchpoint_scope)
7518 /* You can't disable permanent breakpoints. */
7519 if (bpt->enable_state == bp_permanent)
7522 bpt->enable_state = bp_disabled;
7524 check_duplicates (bpt);
7526 if (deprecated_modify_breakpoint_hook)
7527 deprecated_modify_breakpoint_hook (bpt);
7528 breakpoint_modify_event (bpt->number);
7532 disable_command (char *args, int from_tty)
7534 struct breakpoint *bpt;
7536 ALL_BREAKPOINTS (bpt)
7540 warning ("attempted to disable apparently deleted breakpoint #%d?",
7545 case bp_catch_unload:
7547 case bp_catch_vfork:
7549 case bp_catch_catch:
7550 case bp_catch_throw:
7551 case bp_hardware_breakpoint:
7553 case bp_hardware_watchpoint:
7554 case bp_read_watchpoint:
7555 case bp_access_watchpoint:
7556 disable_breakpoint (bpt);
7561 map_breakpoint_numbers (args, disable_breakpoint);
7565 do_enable_breakpoint (struct breakpoint *bpt, enum bpdisp disposition)
7567 struct frame_info *save_selected_frame = NULL;
7568 int save_selected_frame_level = -1;
7569 int target_resources_ok, other_type_used;
7572 if (bpt->type == bp_hardware_breakpoint)
7575 i = hw_breakpoint_used_count ();
7576 target_resources_ok =
7577 TARGET_CAN_USE_HARDWARE_WATCHPOINT (bp_hardware_breakpoint,
7579 if (target_resources_ok == 0)
7580 error ("No hardware breakpoint support in the target.");
7581 else if (target_resources_ok < 0)
7582 error ("Hardware breakpoints used exceeds limit.");
7587 if (bpt->enable_state != bp_enabled)
7589 /* When enabling a pending breakpoint, we need to check if the breakpoint
7590 is resolvable since shared libraries could have been loaded
7591 after the breakpoint was disabled. */
7592 breakpoints_changed ();
7593 if (resolve_pending_breakpoint (bpt) == GDB_RC_OK)
7595 delete_breakpoint (bpt);
7598 bpt->enable_state = bp_enabled;
7599 bpt->disposition = disposition;
7602 else /* Not a pending breakpoint. */
7604 if (bpt->enable_state != bp_permanent)
7605 bpt->enable_state = bp_enabled;
7606 bpt->disposition = disposition;
7607 check_duplicates (bpt);
7608 breakpoints_changed ();
7610 if (bpt->type == bp_watchpoint ||
7611 bpt->type == bp_hardware_watchpoint ||
7612 bpt->type == bp_read_watchpoint ||
7613 bpt->type == bp_access_watchpoint)
7615 if (bpt->exp_valid_block != NULL)
7617 struct frame_info *fr =
7618 fr = frame_find_by_id (bpt->watchpoint_frame);
7622 Cannot enable watchpoint %d because the block in which its expression\n\
7623 is valid is not currently in scope.\n", bpt->number);
7624 bpt->enable_state = bp_disabled;
7628 save_selected_frame = deprecated_selected_frame;
7629 save_selected_frame_level = frame_relative_level (deprecated_selected_frame);
7633 value_free (bpt->val);
7634 mark = value_mark ();
7635 bpt->val = evaluate_expression (bpt->exp);
7636 release_value (bpt->val);
7637 if (VALUE_LAZY (bpt->val))
7638 value_fetch_lazy (bpt->val);
7640 if (bpt->type == bp_hardware_watchpoint ||
7641 bpt->type == bp_read_watchpoint ||
7642 bpt->type == bp_access_watchpoint)
7644 int i = hw_watchpoint_used_count (bpt->type, &other_type_used);
7645 int mem_cnt = can_use_hardware_watchpoint (bpt->val);
7647 /* Hack around 'unused var' error for some targets here */
7649 target_resources_ok = TARGET_CAN_USE_HARDWARE_WATCHPOINT (
7650 bpt->type, i + mem_cnt, other_type_used);
7651 /* we can consider of type is bp_hardware_watchpoint, convert to
7652 bp_watchpoint in the following condition */
7653 if (target_resources_ok < 0)
7656 Cannot enable watchpoint %d because target watch resources\n\
7657 have been allocated for other watchpoints.\n", bpt->number);
7658 bpt->enable_state = bp_disabled;
7659 value_free_to_mark (mark);
7664 if (save_selected_frame_level >= 0)
7665 select_frame (save_selected_frame);
7666 value_free_to_mark (mark);
7670 if (deprecated_modify_breakpoint_hook)
7671 deprecated_modify_breakpoint_hook (bpt);
7672 breakpoint_modify_event (bpt->number);
7676 enable_breakpoint (struct breakpoint *bpt)
7678 do_enable_breakpoint (bpt, bpt->disposition);
7681 /* The enable command enables the specified breakpoints (or all defined
7682 breakpoints) so they once again become (or continue to be) effective
7683 in stopping the inferior. */
7686 enable_command (char *args, int from_tty)
7688 struct breakpoint *bpt;
7690 ALL_BREAKPOINTS (bpt)
7694 warning ("attempted to enable apparently deleted breakpoint #%d?",
7699 case bp_catch_unload:
7701 case bp_catch_vfork:
7703 case bp_catch_catch:
7704 case bp_catch_throw:
7705 case bp_hardware_breakpoint:
7707 case bp_hardware_watchpoint:
7708 case bp_read_watchpoint:
7709 case bp_access_watchpoint:
7710 enable_breakpoint (bpt);
7715 map_breakpoint_numbers (args, enable_breakpoint);
7719 enable_once_breakpoint (struct breakpoint *bpt)
7721 do_enable_breakpoint (bpt, disp_disable);
7725 enable_once_command (char *args, int from_tty)
7727 map_breakpoint_numbers (args, enable_once_breakpoint);
7731 enable_delete_breakpoint (struct breakpoint *bpt)
7733 do_enable_breakpoint (bpt, disp_del);
7737 enable_delete_command (char *args, int from_tty)
7739 map_breakpoint_numbers (args, enable_delete_breakpoint);
7743 set_breakpoint_cmd (char *args, int from_tty)
7748 show_breakpoint_cmd (char *args, int from_tty)
7752 /* Use default_breakpoint_'s, or nothing if they aren't valid. */
7754 struct symtabs_and_lines
7755 decode_line_spec_1 (char *string, int funfirstline)
7757 struct symtabs_and_lines sals;
7759 error ("Empty line specification.");
7760 if (default_breakpoint_valid)
7761 sals = decode_line_1 (&string, funfirstline,
7762 default_breakpoint_symtab,
7763 default_breakpoint_line,
7764 (char ***) NULL, NULL);
7766 sals = decode_line_1 (&string, funfirstline,
7767 (struct symtab *) NULL, 0, (char ***) NULL, NULL);
7769 error ("Junk at end of line specification: %s", string);
7774 _initialize_breakpoint (void)
7776 static struct cmd_list_element *breakpoint_set_cmdlist;
7777 static struct cmd_list_element *breakpoint_show_cmdlist;
7778 struct cmd_list_element *c;
7780 breakpoint_chain = 0;
7781 /* Don't bother to call set_breakpoint_count. $bpnum isn't useful
7782 before a breakpoint is set. */
7783 breakpoint_count = 0;
7785 add_com ("ignore", class_breakpoint, ignore_command,
7786 "Set ignore-count of breakpoint number N to COUNT.\n\
7787 Usage is `ignore N COUNT'.");
7789 add_com_alias ("bc", "ignore", class_breakpoint, 1);
7791 add_com ("commands", class_breakpoint, commands_command,
7792 "Set commands to be executed when a breakpoint is hit.\n\
7793 Give breakpoint number as argument after \"commands\".\n\
7794 With no argument, the targeted breakpoint is the last one set.\n\
7795 The commands themselves follow starting on the next line.\n\
7796 Type a line containing \"end\" to indicate the end of them.\n\
7797 Give \"silent\" as the first line to make the breakpoint silent;\n\
7798 then no output is printed when it is hit, except what the commands print.");
7800 add_com ("condition", class_breakpoint, condition_command,
7801 "Specify breakpoint number N to break only if COND is true.\n\
7802 Usage is `condition N COND', where N is an integer and COND is an\n\
7803 expression to be evaluated whenever breakpoint N is reached.");
7805 c = add_com ("tbreak", class_breakpoint, tbreak_command,
7806 "Set a temporary breakpoint. Args like \"break\" command.\n\
7807 Like \"break\" except the breakpoint is only temporary,\n\
7808 so it will be deleted when hit. Equivalent to \"break\" followed\n\
7809 by using \"enable delete\" on the breakpoint number.");
7810 set_cmd_completer (c, location_completer);
7812 c = add_com ("hbreak", class_breakpoint, hbreak_command,
7813 "Set a hardware assisted breakpoint. Args like \"break\" command.\n\
7814 Like \"break\" except the breakpoint requires hardware support,\n\
7815 some target hardware may not have this support.");
7816 set_cmd_completer (c, location_completer);
7818 c = add_com ("thbreak", class_breakpoint, thbreak_command,
7819 "Set a temporary hardware assisted breakpoint. Args like \"break\" command.\n\
7820 Like \"hbreak\" except the breakpoint is only temporary,\n\
7821 so it will be deleted when hit.");
7822 set_cmd_completer (c, location_completer);
7824 add_prefix_cmd ("enable", class_breakpoint, enable_command,
7825 "Enable some breakpoints.\n\
7826 Give breakpoint numbers (separated by spaces) as arguments.\n\
7827 With no subcommand, breakpoints are enabled until you command otherwise.\n\
7828 This is used to cancel the effect of the \"disable\" command.\n\
7829 With a subcommand you can enable temporarily.",
7830 &enablelist, "enable ", 1, &cmdlist);
7832 add_com ("ab", class_breakpoint, enable_command,
7833 "Enable some breakpoints.\n\
7834 Give breakpoint numbers (separated by spaces) as arguments.\n\
7835 With no subcommand, breakpoints are enabled until you command otherwise.\n\
7836 This is used to cancel the effect of the \"disable\" command.\n\
7837 With a subcommand you can enable temporarily.");
7839 add_com_alias ("en", "enable", class_breakpoint, 1);
7841 add_abbrev_prefix_cmd ("breakpoints", class_breakpoint, enable_command,
7842 "Enable some breakpoints.\n\
7843 Give breakpoint numbers (separated by spaces) as arguments.\n\
7844 This is used to cancel the effect of the \"disable\" command.\n\
7845 May be abbreviated to simply \"enable\".\n",
7846 &enablebreaklist, "enable breakpoints ", 1, &enablelist);
7848 add_cmd ("once", no_class, enable_once_command,
7849 "Enable breakpoints for one hit. Give breakpoint numbers.\n\
7850 If a breakpoint is hit while enabled in this fashion, it becomes disabled.",
7853 add_cmd ("delete", no_class, enable_delete_command,
7854 "Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
7855 If a breakpoint is hit while enabled in this fashion, it is deleted.",
7858 add_cmd ("delete", no_class, enable_delete_command,
7859 "Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
7860 If a breakpoint is hit while enabled in this fashion, it is deleted.",
7863 add_cmd ("once", no_class, enable_once_command,
7864 "Enable breakpoints for one hit. Give breakpoint numbers.\n\
7865 If a breakpoint is hit while enabled in this fashion, it becomes disabled.",
7868 add_prefix_cmd ("disable", class_breakpoint, disable_command,
7869 "Disable some breakpoints.\n\
7870 Arguments are breakpoint numbers with spaces in between.\n\
7871 To disable all breakpoints, give no argument.\n\
7872 A disabled breakpoint is not forgotten, but has no effect until reenabled.",
7873 &disablelist, "disable ", 1, &cmdlist);
7874 add_com_alias ("dis", "disable", class_breakpoint, 1);
7875 add_com_alias ("disa", "disable", class_breakpoint, 1);
7877 add_com ("sb", class_breakpoint, disable_command,
7878 "Disable some breakpoints.\n\
7879 Arguments are breakpoint numbers with spaces in between.\n\
7880 To disable all breakpoints, give no argument.\n\
7881 A disabled breakpoint is not forgotten, but has no effect until reenabled.");
7883 add_cmd ("breakpoints", class_alias, disable_command,
7884 "Disable some breakpoints.\n\
7885 Arguments are breakpoint numbers with spaces in between.\n\
7886 To disable all breakpoints, give no argument.\n\
7887 A disabled breakpoint is not forgotten, but has no effect until reenabled.\n\
7888 This command may be abbreviated \"disable\".",
7891 add_prefix_cmd ("delete", class_breakpoint, delete_command,
7892 "Delete some breakpoints or auto-display expressions.\n\
7893 Arguments are breakpoint numbers with spaces in between.\n\
7894 To delete all breakpoints, give no argument.\n\
7896 Also a prefix command for deletion of other GDB objects.\n\
7897 The \"unset\" command is also an alias for \"delete\".",
7898 &deletelist, "delete ", 1, &cmdlist);
7899 add_com_alias ("d", "delete", class_breakpoint, 1);
7901 add_com ("db", class_breakpoint, delete_command,
7902 "Delete some breakpoints.\n\
7903 Arguments are breakpoint numbers with spaces in between.\n\
7904 To delete all breakpoints, give no argument.\n");
7906 add_cmd ("breakpoints", class_alias, delete_command,
7907 "Delete some breakpoints or auto-display expressions.\n\
7908 Arguments are breakpoint numbers with spaces in between.\n\
7909 To delete all breakpoints, give no argument.\n\
7910 This command may be abbreviated \"delete\".",
7913 add_com ("clear", class_breakpoint, clear_command,
7914 concat ("Clear breakpoint at specified line or function.\n\
7915 Argument may be line number, function name, or \"*\" and an address.\n\
7916 If line number is specified, all breakpoints in that line are cleared.\n\
7917 If function is specified, breakpoints at beginning of function are cleared.\n\
7918 If an address is specified, breakpoints at that address are cleared.\n\n",
7919 "With no argument, clears all breakpoints in the line that the selected frame\n\
7922 See also the \"delete\" command which clears breakpoints by number.", NULL));
7924 c = add_com ("break", class_breakpoint, break_command,
7925 concat ("Set breakpoint at specified line or function.\n\
7926 Argument may be line number, function name, or \"*\" and an address.\n\
7927 If line number is specified, break at start of code for that line.\n\
7928 If function is specified, break at start of code for that function.\n\
7929 If an address is specified, break at that exact address.\n",
7930 "With no arg, uses current execution address of selected stack frame.\n\
7931 This is useful for breaking on return to a stack frame.\n\
7933 Multiple breakpoints at one place are permitted, and useful if conditional.\n\
7935 Do \"help breakpoints\" for info on other commands dealing with breakpoints.", NULL));
7936 set_cmd_completer (c, location_completer);
7938 add_com_alias ("b", "break", class_run, 1);
7939 add_com_alias ("br", "break", class_run, 1);
7940 add_com_alias ("bre", "break", class_run, 1);
7941 add_com_alias ("brea", "break", class_run, 1);
7945 add_com_alias ("ba", "break", class_breakpoint, 1);
7946 add_com_alias ("bu", "ubreak", class_breakpoint, 1);
7951 add_abbrev_prefix_cmd ("stop", class_breakpoint, stop_command,
7952 "Break in function/address or break at a line in the current file.",
7953 &stoplist, "stop ", 1, &cmdlist);
7954 add_cmd ("in", class_breakpoint, stopin_command,
7955 "Break in function or address.\n", &stoplist);
7956 add_cmd ("at", class_breakpoint, stopat_command,
7957 "Break at a line in the current file.\n", &stoplist);
7958 add_com ("status", class_info, breakpoints_info,
7959 concat ("Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
7960 The \"Type\" column indicates one of:\n\
7961 \tbreakpoint - normal breakpoint\n\
7962 \twatchpoint - watchpoint\n\
7963 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
7964 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
7965 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
7966 address and file/line number respectively.\n\n",
7967 "Convenience variable \"$_\" and default examine address for \"x\"\n\
7968 are set to the address of the last breakpoint listed.\n\n\
7969 Convenience variable \"$bpnum\" contains the number of the last\n\
7970 breakpoint set.", NULL));
7973 add_info ("breakpoints", breakpoints_info,
7974 concat ("Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
7975 The \"Type\" column indicates one of:\n\
7976 \tbreakpoint - normal breakpoint\n\
7977 \twatchpoint - watchpoint\n\
7978 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
7979 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
7980 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
7981 address and file/line number respectively.\n\n",
7982 "Convenience variable \"$_\" and default examine address for \"x\"\n\
7983 are set to the address of the last breakpoint listed.\n\n\
7984 Convenience variable \"$bpnum\" contains the number of the last\n\
7985 breakpoint set.", NULL));
7988 add_com ("lb", class_breakpoint, breakpoints_info,
7989 concat ("Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
7990 The \"Type\" column indicates one of:\n\
7991 \tbreakpoint - normal breakpoint\n\
7992 \twatchpoint - watchpoint\n\
7993 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
7994 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
7995 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
7996 address and file/line number respectively.\n\n",
7997 "Convenience variable \"$_\" and default examine address for \"x\"\n\
7998 are set to the address of the last breakpoint listed.\n\n\
7999 Convenience variable \"$bpnum\" contains the number of the last\n\
8000 breakpoint set.", NULL));
8002 add_cmd ("breakpoints", class_maintenance, maintenance_info_breakpoints,
8003 concat ("Status of all breakpoints, or breakpoint number NUMBER.\n\
8004 The \"Type\" column indicates one of:\n\
8005 \tbreakpoint - normal breakpoint\n\
8006 \twatchpoint - watchpoint\n\
8007 \tlongjmp - internal breakpoint used to step through longjmp()\n\
8008 \tlongjmp resume - internal breakpoint at the target of longjmp()\n\
8009 \tuntil - internal breakpoint used by the \"until\" command\n\
8010 \tfinish - internal breakpoint used by the \"finish\" command\n",
8011 "The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
8012 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
8013 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
8014 address and file/line number respectively.\n\n",
8015 "Convenience variable \"$_\" and default examine address for \"x\"\n\
8016 are set to the address of the last breakpoint listed.\n\n\
8017 Convenience variable \"$bpnum\" contains the number of the last\n\
8018 breakpoint set.", NULL),
8019 &maintenanceinfolist);
8021 add_com ("catch", class_breakpoint, catch_command,
8022 "Set catchpoints to catch events.\n\
8023 Raised signals may be caught:\n\
8024 \tcatch signal - all signals\n\
8025 \tcatch signal <signame> - a particular signal\n\
8026 Raised exceptions may be caught:\n\
8027 \tcatch throw - all exceptions, when thrown\n\
8028 \tcatch throw <exceptname> - a particular exception, when thrown\n\
8029 \tcatch catch - all exceptions, when caught\n\
8030 \tcatch catch <exceptname> - a particular exception, when caught\n\
8031 Thread or process events may be caught:\n\
8032 \tcatch thread_start - any threads, just after creation\n\
8033 \tcatch thread_exit - any threads, just before expiration\n\
8034 \tcatch thread_join - any threads, just after joins\n\
8035 Process events may be caught:\n\
8036 \tcatch start - any processes, just after creation\n\
8037 \tcatch exit - any processes, just before expiration\n\
8038 \tcatch fork - calls to fork()\n\
8039 \tcatch vfork - calls to vfork()\n\
8040 \tcatch exec - calls to exec()\n\
8041 Dynamically-linked library events may be caught:\n\
8042 \tcatch load - loads of any library\n\
8043 \tcatch load <libname> - loads of a particular library\n\
8044 \tcatch unload - unloads of any library\n\
8045 \tcatch unload <libname> - unloads of a particular library\n\
8046 The act of your program's execution stopping may also be caught:\n\
8048 C++ exceptions may be caught:\n\
8049 \tcatch throw - all exceptions, when thrown\n\
8050 \tcatch catch - all exceptions, when caught\n\
8052 Do \"help set follow-fork-mode\" for info on debugging your program\n\
8053 after a fork or vfork is caught.\n\n\
8054 Do \"help breakpoints\" for info on other commands dealing with breakpoints.");
8056 add_com ("tcatch", class_breakpoint, tcatch_command,
8057 "Set temporary catchpoints to catch events.\n\
8058 Args like \"catch\" command.\n\
8059 Like \"catch\" except the catchpoint is only temporary,\n\
8060 so it will be deleted when hit. Equivalent to \"catch\" followed\n\
8061 by using \"enable delete\" on the catchpoint number.");
8063 c = add_com ("watch", class_breakpoint, watch_command,
8064 "Set a watchpoint for an expression.\n\
8065 A watchpoint stops execution of your program whenever the value of\n\
8066 an expression changes.");
8067 set_cmd_completer (c, location_completer);
8069 c = add_com ("rwatch", class_breakpoint, rwatch_command,
8070 "Set a read watchpoint for an expression.\n\
8071 A watchpoint stops execution of your program whenever the value of\n\
8072 an expression is read.");
8073 set_cmd_completer (c, location_completer);
8075 c = add_com ("awatch", class_breakpoint, awatch_command,
8076 "Set a watchpoint for an expression.\n\
8077 A watchpoint stops execution of your program whenever the value of\n\
8078 an expression is either read or written.");
8079 set_cmd_completer (c, location_completer);
8081 add_info ("watchpoints", breakpoints_info,
8082 "Synonym for ``info breakpoints''.");
8085 c = add_set_cmd ("can-use-hw-watchpoints", class_support, var_zinteger,
8086 (char *) &can_use_hw_watchpoints,
8087 "Set debugger's willingness to use watchpoint hardware.\n\
8088 If zero, gdb will not use hardware for new watchpoints, even if\n\
8089 such is available. (However, any hardware watchpoints that were\n\
8090 created before setting this to nonzero, will continue to use watchpoint\n\
8093 add_show_from_set (c, &showlist);
8095 can_use_hw_watchpoints = 1;
8097 add_prefix_cmd ("breakpoint", class_maintenance, set_breakpoint_cmd, "\
8098 Breakpoint specific settings\n\
8099 Configure various breakpoint-specific variables such as\n\
8100 pending breakpoint behavior",
8101 &breakpoint_set_cmdlist, "set breakpoint ",
8102 0/*allow-unknown*/, &setlist);
8103 add_prefix_cmd ("breakpoint", class_maintenance, show_breakpoint_cmd, "\
8104 Breakpoint specific settings\n\
8105 Configure various breakpoint-specific variables such as\n\
8106 pending breakpoint behavior",
8107 &breakpoint_show_cmdlist, "show breakpoint ",
8108 0/*allow-unknown*/, &showlist);
8110 add_setshow_auto_boolean_cmd ("pending", no_class, &pending_break_support, "\
8111 Set debugger's behavior regarding pending breakpoints.\n\
8112 If on, an unrecognized breakpoint location will cause gdb to create a\n\
8113 pending breakpoint. If off, an unrecognized breakpoint location results in\n\
8114 an error. If auto, an unrecognized breakpoint location results in a\n\
8115 user-query to see if a pending breakpoint should be created.","\
8116 Show debugger's behavior regarding pending breakpoints.\n\
8117 If on, an unrecognized breakpoint location will cause gdb to create a\n\
8118 pending breakpoint. If off, an unrecognized breakpoint location results in\n\
8119 an error. If auto, an unrecognized breakpoint location results in a\n\
8120 user-query to see if a pending breakpoint should be created.",
8122 &breakpoint_set_cmdlist,
8123 &breakpoint_show_cmdlist);
8125 pending_break_support = AUTO_BOOLEAN_AUTO;