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 first DEPRECATED_PC_IN_SIGTRAMP where we set the step_resume
3037 /* We handle the through_sigtramp_breakpoint the same way; having both
3038 one of those and a step_resume_breakpoint is probably very rare (?). */
3040 static const enum bpstat_what_main_action
3041 table[(int) class_last][(int) BPSTAT_WHAT_LAST] =
3044 /* kc ss sn sgl slr clr clrs sr ts shl shlr
3047 {kc, ss, sn, sgl, slr, clr, clrs, sr, ts, shl, shlr},
3049 {ss, ss, sn, ss, ss, ss, ss, sr, ts, shl, shlr},
3051 {sn, sn, sn, sn, sn, sn, sn, sr, ts, shl, shlr},
3053 {sgl, ss, sn, sgl, slr, clrs, clrs, sr, ts, shl, shlr},
3055 {ss, ss, sn, ss, ss, ss, ss, sr, ts, shl, shlr},
3057 {sn, sn, sn, sn, sn, sn, sn, sr, ts, shl, shlr},
3059 {slr, ss, sn, slr, slr, err, err, sr, ts, shl, shlr},
3061 {clr, ss, sn, clrs, err, err, err, sr, ts, shl, shlr},
3063 {sr, sr, sr, sr, sr, sr, sr, sr, ts, shl, shlr},
3065 {ts, ts, ts, ts, ts, ts, ts, ts, ts, shl, shlr},
3067 {shl, shl, shl, shl, shl, shl, shl, shl, ts, shl, shlr},
3069 {shlr, shlr, shlr, shlr, shlr, shlr, shlr, shlr, ts, shlr, shlr}
3084 enum bpstat_what_main_action current_action = BPSTAT_WHAT_KEEP_CHECKING;
3085 struct bpstat_what retval;
3087 retval.call_dummy = 0;
3088 for (; bs != NULL; bs = bs->next)
3090 enum class bs_class = no_effect;
3091 if (bs->breakpoint_at == NULL)
3092 /* I suspect this can happen if it was a momentary breakpoint
3093 which has since been deleted. */
3095 switch (bs->breakpoint_at->type)
3101 case bp_hardware_breakpoint:
3107 bs_class = bp_noisy;
3109 bs_class = bp_silent;
3112 bs_class = bp_nostop;
3115 case bp_hardware_watchpoint:
3116 case bp_read_watchpoint:
3117 case bp_access_watchpoint:
3121 bs_class = wp_noisy;
3123 bs_class = wp_silent;
3126 /* There was a watchpoint, but we're not stopping.
3127 This requires no further action. */
3128 bs_class = no_effect;
3131 bs_class = long_jump;
3133 case bp_longjmp_resume:
3134 bs_class = long_resume;
3136 case bp_step_resume:
3139 bs_class = step_resume;
3142 /* It is for the wrong frame. */
3143 bs_class = bp_nostop;
3145 case bp_through_sigtramp:
3146 bs_class = through_sig;
3148 case bp_watchpoint_scope:
3149 bs_class = bp_nostop;
3151 case bp_shlib_event:
3152 bs_class = shlib_event;
3154 case bp_thread_event:
3155 case bp_overlay_event:
3156 bs_class = bp_nostop;
3159 case bp_catch_unload:
3160 /* Only if this catchpoint triggered should we cause the
3161 step-out-of-dld behaviour. Otherwise, we ignore this
3164 bs_class = catch_shlib_event;
3166 bs_class = no_effect;
3169 case bp_catch_vfork:
3174 bs_class = bp_noisy;
3176 bs_class = bp_silent;
3179 /* There was a catchpoint, but we're not stopping.
3180 This requires no further action. */
3181 bs_class = no_effect;
3183 case bp_catch_catch:
3184 if (!bs->stop || CURRENT_EXCEPTION_KIND != EX_EVENT_CATCH)
3185 bs_class = bp_nostop;
3187 bs_class = bs->print ? bp_noisy : bp_silent;
3189 case bp_catch_throw:
3190 if (!bs->stop || CURRENT_EXCEPTION_KIND != EX_EVENT_THROW)
3191 bs_class = bp_nostop;
3193 bs_class = bs->print ? bp_noisy : bp_silent;
3196 /* Make sure the action is stop (silent or noisy),
3197 so infrun.c pops the dummy frame. */
3198 bs_class = bp_silent;
3199 retval.call_dummy = 1;
3202 current_action = table[(int) bs_class][(int) current_action];
3204 retval.main_action = current_action;
3208 /* Nonzero if we should step constantly (e.g. watchpoints on machines
3209 without hardware support). This isn't related to a specific bpstat,
3210 just to things like whether watchpoints are set. */
3213 bpstat_should_step (void)
3215 struct breakpoint *b;
3217 if (breakpoint_enabled (b) && b->type == bp_watchpoint)
3222 /* Nonzero if there are enabled hardware watchpoints. */
3224 bpstat_have_active_hw_watchpoints (void)
3226 struct bp_location *bpt;
3227 ALL_BP_LOCATIONS (bpt)
3228 if (breakpoint_enabled (bpt->owner)
3230 && bpt->loc_type == bp_loc_hardware_watchpoint)
3236 /* Given a bpstat that records zero or more triggered eventpoints, this
3237 function returns another bpstat which contains only the catchpoints
3238 on that first list, if any. */
3240 bpstat_get_triggered_catchpoints (bpstat ep_list, bpstat *cp_list)
3242 struct bpstats root_bs[1];
3243 bpstat bs = root_bs;
3244 struct breakpoint *ep;
3247 bpstat_clear (cp_list);
3248 root_bs->next = NULL;
3250 for (; ep_list != NULL; ep_list = ep_list->next)
3252 /* Is this eventpoint a catchpoint? If not, ignore it. */
3253 ep = ep_list->breakpoint_at;
3256 if ((ep->type != bp_catch_load) &&
3257 (ep->type != bp_catch_unload) &&
3258 (ep->type != bp_catch_catch) &&
3259 (ep->type != bp_catch_throw))
3260 /* pai: (temp) ADD fork/vfork here!! */
3263 /* Yes; add it to the list. */
3264 bs = bpstat_alloc (ep, bs);
3269 #if defined(SOLIB_ADD)
3270 /* Also, for each triggered catchpoint, tag it with the name of
3271 the library that caused this trigger. (We copy the name now,
3272 because it's only guaranteed to be available NOW, when the
3273 catchpoint triggers. Clients who may wish to know the name
3274 later must get it from the catchpoint itself.) */
3275 if (ep->triggered_dll_pathname != NULL)
3276 xfree (ep->triggered_dll_pathname);
3277 if (ep->type == bp_catch_load)
3278 dll_pathname = SOLIB_LOADED_LIBRARY_PATHNAME (
3279 PIDGET (inferior_ptid));
3281 dll_pathname = SOLIB_UNLOADED_LIBRARY_PATHNAME (
3282 PIDGET (inferior_ptid));
3284 dll_pathname = NULL;
3288 ep->triggered_dll_pathname = (char *)
3289 xmalloc (strlen (dll_pathname) + 1);
3290 strcpy (ep->triggered_dll_pathname, dll_pathname);
3293 ep->triggered_dll_pathname = NULL;
3299 /* Print B to gdb_stdout. */
3301 print_one_breakpoint (struct breakpoint *b,
3302 CORE_ADDR *last_addr)
3304 struct command_line *l;
3306 struct ep_type_description
3311 static struct ep_type_description bptypes[] =
3313 {bp_none, "?deleted?"},
3314 {bp_breakpoint, "breakpoint"},
3315 {bp_hardware_breakpoint, "hw breakpoint"},
3316 {bp_until, "until"},
3317 {bp_finish, "finish"},
3318 {bp_watchpoint, "watchpoint"},
3319 {bp_hardware_watchpoint, "hw watchpoint"},
3320 {bp_read_watchpoint, "read watchpoint"},
3321 {bp_access_watchpoint, "acc watchpoint"},
3322 {bp_longjmp, "longjmp"},
3323 {bp_longjmp_resume, "longjmp resume"},
3324 {bp_step_resume, "step resume"},
3325 {bp_through_sigtramp, "sigtramp"},
3326 {bp_watchpoint_scope, "watchpoint scope"},
3327 {bp_call_dummy, "call dummy"},
3328 {bp_shlib_event, "shlib events"},
3329 {bp_thread_event, "thread events"},
3330 {bp_overlay_event, "overlay events"},
3331 {bp_catch_load, "catch load"},
3332 {bp_catch_unload, "catch unload"},
3333 {bp_catch_fork, "catch fork"},
3334 {bp_catch_vfork, "catch vfork"},
3335 {bp_catch_exec, "catch exec"},
3336 {bp_catch_catch, "catch catch"},
3337 {bp_catch_throw, "catch throw"}
3340 static char *bpdisps[] =
3341 {"del", "dstp", "dis", "keep"};
3342 static char bpenables[] = "nynny";
3343 char wrap_indent[80];
3344 struct ui_stream *stb = ui_out_stream_new (uiout);
3345 struct cleanup *old_chain = make_cleanup_ui_out_stream_delete (stb);
3346 struct cleanup *bkpt_chain;
3349 bkpt_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "bkpt");
3353 ui_out_field_int (uiout, "number", b->number);
3357 if (((int) b->type > (sizeof (bptypes) / sizeof (bptypes[0])))
3358 || ((int) b->type != bptypes[(int) b->type].type))
3359 internal_error (__FILE__, __LINE__,
3360 "bptypes table does not describe type #%d.",
3362 ui_out_field_string (uiout, "type", bptypes[(int) b->type].description);
3366 ui_out_field_string (uiout, "disp", bpdisps[(int) b->disposition]);
3370 ui_out_field_fmt (uiout, "enabled", "%c", bpenables[(int) b->enable_state]);
3371 ui_out_spaces (uiout, 2);
3374 strcpy (wrap_indent, " ");
3377 if (TARGET_ADDR_BIT <= 32)
3378 strcat (wrap_indent, " ");
3380 strcat (wrap_indent, " ");
3383 if (b->ops != NULL && b->ops->print_one != NULL)
3384 b->ops->print_one (b, last_addr);
3389 internal_error (__FILE__, __LINE__,
3390 "print_one_breakpoint: bp_none encountered\n");
3394 case bp_hardware_watchpoint:
3395 case bp_read_watchpoint:
3396 case bp_access_watchpoint:
3397 /* Field 4, the address, is omitted (which makes the columns
3398 not line up too nicely with the headers, but the effect
3399 is relatively readable). */
3401 ui_out_field_skip (uiout, "addr");
3403 print_expression (b->exp, stb->stream);
3404 ui_out_field_stream (uiout, "what", stb);
3408 case bp_catch_unload:
3409 /* Field 4, the address, is omitted (which makes the columns
3410 not line up too nicely with the headers, but the effect
3411 is relatively readable). */
3413 ui_out_field_skip (uiout, "addr");
3415 if (b->dll_pathname == NULL)
3417 ui_out_field_string (uiout, "what", "<any library>");
3418 ui_out_spaces (uiout, 1);
3422 ui_out_text (uiout, "library \"");
3423 ui_out_field_string (uiout, "what", b->dll_pathname);
3424 ui_out_text (uiout, "\" ");
3429 case bp_catch_vfork:
3430 /* Field 4, the address, is omitted (which makes the columns
3431 not line up too nicely with the headers, but the effect
3432 is relatively readable). */
3434 ui_out_field_skip (uiout, "addr");
3436 if (b->forked_inferior_pid != 0)
3438 ui_out_text (uiout, "process ");
3439 ui_out_field_int (uiout, "what", b->forked_inferior_pid);
3440 ui_out_spaces (uiout, 1);
3444 /* Field 4, the address, is omitted (which makes the columns
3445 not line up too nicely with the headers, but the effect
3446 is relatively readable). */
3448 ui_out_field_skip (uiout, "addr");
3450 if (b->exec_pathname != NULL)
3452 ui_out_text (uiout, "program \"");
3453 ui_out_field_string (uiout, "what", b->exec_pathname);
3454 ui_out_text (uiout, "\" ");
3458 case bp_catch_catch:
3459 /* Field 4, the address, is omitted (which makes the columns
3460 not line up too nicely with the headers, but the effect
3461 is relatively readable). */
3463 ui_out_field_skip (uiout, "addr");
3465 ui_out_field_string (uiout, "what", "exception catch");
3466 ui_out_spaces (uiout, 1);
3469 case bp_catch_throw:
3470 /* Field 4, the address, is omitted (which makes the columns
3471 not line up too nicely with the headers, but the effect
3472 is relatively readable). */
3474 ui_out_field_skip (uiout, "addr");
3476 ui_out_field_string (uiout, "what", "exception throw");
3477 ui_out_spaces (uiout, 1);
3481 case bp_hardware_breakpoint:
3485 case bp_longjmp_resume:
3486 case bp_step_resume:
3487 case bp_through_sigtramp:
3488 case bp_watchpoint_scope:
3490 case bp_shlib_event:
3491 case bp_thread_event:
3492 case bp_overlay_event:
3497 ui_out_field_string (uiout, "addr", "<PENDING>");
3499 ui_out_field_core_addr (uiout, "addr", b->loc->address);
3502 *last_addr = b->loc->address;
3505 sym = find_pc_sect_function (b->loc->address, b->loc->section);
3508 ui_out_text (uiout, "in ");
3509 ui_out_field_string (uiout, "func",
3510 SYMBOL_PRINT_NAME (sym));
3511 ui_out_wrap_hint (uiout, wrap_indent);
3512 ui_out_text (uiout, " at ");
3514 ui_out_field_string (uiout, "file", b->source_file);
3515 ui_out_text (uiout, ":");
3516 ui_out_field_int (uiout, "line", b->line_number);
3518 else if (b->pending)
3520 ui_out_field_string (uiout, "pending", b->addr_string);
3524 print_address_symbolic (b->loc->address, stb->stream, demangle, "");
3525 ui_out_field_stream (uiout, "at", stb);
3530 if (b->thread != -1)
3532 /* FIXME: This seems to be redundant and lost here; see the
3533 "stop only in" line a little further down. */
3534 ui_out_text (uiout, " thread ");
3535 ui_out_field_int (uiout, "thread", b->thread);
3538 ui_out_text (uiout, "\n");
3540 if (frame_id_p (b->frame_id))
3543 ui_out_text (uiout, "\tstop only in stack frame at ");
3544 /* FIXME: cagney/2002-12-01: Shouldn't be poeking around inside
3546 ui_out_field_core_addr (uiout, "frame", b->frame_id.stack_addr);
3547 ui_out_text (uiout, "\n");
3553 ui_out_text (uiout, "\tstop only if ");
3554 print_expression (b->cond, stb->stream);
3555 ui_out_field_stream (uiout, "cond", stb);
3556 ui_out_text (uiout, "\n");
3559 if (b->pending && b->cond_string)
3562 ui_out_text (uiout, "\tstop only if ");
3563 ui_out_field_string (uiout, "cond", b->cond_string);
3564 ui_out_text (uiout, "\n");
3567 if (b->thread != -1)
3569 /* FIXME should make an annotation for this */
3570 ui_out_text (uiout, "\tstop only in thread ");
3571 ui_out_field_int (uiout, "thread", b->thread);
3572 ui_out_text (uiout, "\n");
3575 if (show_breakpoint_hit_counts && b->hit_count)
3577 /* FIXME should make an annotation for this */
3578 if (ep_is_catchpoint (b))
3579 ui_out_text (uiout, "\tcatchpoint");
3581 ui_out_text (uiout, "\tbreakpoint");
3582 ui_out_text (uiout, " already hit ");
3583 ui_out_field_int (uiout, "times", b->hit_count);
3584 if (b->hit_count == 1)
3585 ui_out_text (uiout, " time\n");
3587 ui_out_text (uiout, " times\n");
3590 /* Output the count also if it is zero, but only if this is
3591 mi. FIXME: Should have a better test for this. */
3592 if (ui_out_is_mi_like_p (uiout))
3593 if (show_breakpoint_hit_counts && b->hit_count == 0)
3594 ui_out_field_int (uiout, "times", b->hit_count);
3596 if (b->ignore_count)
3599 ui_out_text (uiout, "\tignore next ");
3600 ui_out_field_int (uiout, "ignore", b->ignore_count);
3601 ui_out_text (uiout, " hits\n");
3604 if ((l = b->commands))
3606 struct cleanup *script_chain;
3609 script_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "script");
3610 print_command_lines (uiout, l, 4);
3611 do_cleanups (script_chain);
3613 do_cleanups (bkpt_chain);
3614 do_cleanups (old_chain);
3617 struct captured_breakpoint_query_args
3623 do_captured_breakpoint_query (struct ui_out *uiout, void *data)
3625 struct captured_breakpoint_query_args *args = data;
3626 struct breakpoint *b;
3627 CORE_ADDR dummy_addr = 0;
3630 if (args->bnum == b->number)
3632 print_one_breakpoint (b, &dummy_addr);
3640 gdb_breakpoint_query (struct ui_out *uiout, int bnum)
3642 struct captured_breakpoint_query_args args;
3644 /* For the moment we don't trust print_one_breakpoint() to not throw
3646 return catch_exceptions (uiout, do_captured_breakpoint_query, &args,
3647 NULL, RETURN_MASK_ALL);
3650 /* Return non-zero if B is user settable (breakpoints, watchpoints,
3651 catchpoints, et.al.). */
3654 user_settable_breakpoint (const struct breakpoint *b)
3656 return (b->type == bp_breakpoint
3657 || b->type == bp_catch_load
3658 || b->type == bp_catch_unload
3659 || b->type == bp_catch_fork
3660 || b->type == bp_catch_vfork
3661 || b->type == bp_catch_exec
3662 || b->type == bp_catch_catch
3663 || b->type == bp_catch_throw
3664 || b->type == bp_hardware_breakpoint
3665 || b->type == bp_watchpoint
3666 || b->type == bp_read_watchpoint
3667 || b->type == bp_access_watchpoint
3668 || b->type == bp_hardware_watchpoint);
3671 /* Print information on user settable breakpoint (watchpoint, etc)
3672 number BNUM. If BNUM is -1 print all user settable breakpoints.
3673 If ALLFLAG is non-zero, include non- user settable breakpoints. */
3676 breakpoint_1 (int bnum, int allflag)
3678 struct breakpoint *b;
3679 CORE_ADDR last_addr = (CORE_ADDR) -1;
3680 int nr_printable_breakpoints;
3681 struct cleanup *bkpttbl_chain;
3683 /* Compute the number of rows in the table. */
3684 nr_printable_breakpoints = 0;
3687 || bnum == b->number)
3689 if (allflag || user_settable_breakpoint (b))
3690 nr_printable_breakpoints++;
3695 = make_cleanup_ui_out_table_begin_end (uiout, 6, nr_printable_breakpoints,
3699 = make_cleanup_ui_out_table_begin_end (uiout, 5, nr_printable_breakpoints,
3702 if (nr_printable_breakpoints > 0)
3703 annotate_breakpoints_headers ();
3704 if (nr_printable_breakpoints > 0)
3706 ui_out_table_header (uiout, 3, ui_left, "number", "Num"); /* 1 */
3707 if (nr_printable_breakpoints > 0)
3709 ui_out_table_header (uiout, 14, ui_left, "type", "Type"); /* 2 */
3710 if (nr_printable_breakpoints > 0)
3712 ui_out_table_header (uiout, 4, ui_left, "disp", "Disp"); /* 3 */
3713 if (nr_printable_breakpoints > 0)
3715 ui_out_table_header (uiout, 3, ui_left, "enabled", "Enb"); /* 4 */
3718 if (nr_printable_breakpoints > 0)
3720 if (TARGET_ADDR_BIT <= 32)
3721 ui_out_table_header (uiout, 10, ui_left, "addr", "Address");/* 5 */
3723 ui_out_table_header (uiout, 18, ui_left, "addr", "Address");/* 5 */
3725 if (nr_printable_breakpoints > 0)
3727 ui_out_table_header (uiout, 40, ui_noalign, "what", "What"); /* 6 */
3728 ui_out_table_body (uiout);
3729 if (nr_printable_breakpoints > 0)
3730 annotate_breakpoints_table ();
3734 || bnum == b->number)
3736 /* We only print out user settable breakpoints unless the
3738 if (allflag || user_settable_breakpoint (b))
3739 print_one_breakpoint (b, &last_addr);
3742 do_cleanups (bkpttbl_chain);
3744 if (nr_printable_breakpoints == 0)
3747 ui_out_message (uiout, 0, "No breakpoints or watchpoints.\n");
3749 ui_out_message (uiout, 0, "No breakpoint or watchpoint number %d.\n",
3754 /* Compare against (CORE_ADDR)-1 in case some compiler decides
3755 that a comparison of an unsigned with -1 is always false. */
3756 if (last_addr != (CORE_ADDR) -1)
3757 set_next_address (last_addr);
3760 /* FIXME? Should this be moved up so that it is only called when
3761 there have been breakpoints? */
3762 annotate_breakpoints_table_end ();
3766 breakpoints_info (char *bnum_exp, int from_tty)
3771 bnum = parse_and_eval_long (bnum_exp);
3773 breakpoint_1 (bnum, 0);
3777 maintenance_info_breakpoints (char *bnum_exp, int from_tty)
3782 bnum = parse_and_eval_long (bnum_exp);
3784 breakpoint_1 (bnum, 1);
3787 /* Print a message describing any breakpoints set at PC. */
3790 describe_other_breakpoints (CORE_ADDR pc, asection *section)
3793 struct breakpoint *b;
3796 if (b->loc->address == pc) /* address match / overlay match */
3797 if (!b->pending && (!overlay_debugging || b->loc->section == section))
3801 printf_filtered ("Note: breakpoint%s ", (others > 1) ? "s" : "");
3803 if (b->loc->address == pc) /* address match / overlay match */
3804 if (!b->pending && (!overlay_debugging || b->loc->section == section))
3807 printf_filtered ("%d%s%s ",
3809 ((b->enable_state == bp_disabled ||
3810 b->enable_state == bp_shlib_disabled ||
3811 b->enable_state == bp_call_disabled)
3813 : b->enable_state == bp_permanent
3817 : ((others == 1) ? " and" : ""));
3819 printf_filtered ("also set at pc ");
3820 print_address_numeric (pc, 1, gdb_stdout);
3821 printf_filtered (".\n");
3825 /* Set the default place to put a breakpoint
3826 for the `break' command with no arguments. */
3829 set_default_breakpoint (int valid, CORE_ADDR addr, struct symtab *symtab,
3832 default_breakpoint_valid = valid;
3833 default_breakpoint_address = addr;
3834 default_breakpoint_symtab = symtab;
3835 default_breakpoint_line = line;
3838 /* Return true iff it is meaningful to use the address member of
3839 BPT. For some breakpoint types, the address member is irrelevant
3840 and it makes no sense to attempt to compare it to other addresses
3841 (or use it for any other purpose either).
3843 More specifically, each of the following breakpoint types will always
3844 have a zero valued address and we don't want check_duplicates() to mark
3845 breakpoints of any of these types to be a duplicate of an actual
3846 breakpoint at address zero:
3849 bp_hardware_watchpoint
3851 bp_access_watchpoint
3858 breakpoint_address_is_meaningful (struct breakpoint *bpt)
3860 enum bptype type = bpt->type;
3862 return (type != bp_watchpoint
3863 && type != bp_hardware_watchpoint
3864 && type != bp_read_watchpoint
3865 && type != bp_access_watchpoint
3866 && type != bp_catch_exec
3867 && type != bp_longjmp_resume
3868 && type != bp_catch_fork
3869 && type != bp_catch_vfork);
3872 /* Rescan breakpoints at the same address and section as BPT,
3873 marking the first one as "first" and any others as "duplicates".
3874 This is so that the bpt instruction is only inserted once.
3875 If we have a permanent breakpoint at the same place as BPT, make
3876 that one the official one, and the rest as duplicates. */
3879 check_duplicates (struct breakpoint *bpt)
3881 struct bp_location *b;
3883 struct bp_location *perm_bp = 0;
3884 CORE_ADDR address = bpt->loc->address;
3885 asection *section = bpt->loc->section;
3887 if (! breakpoint_address_is_meaningful (bpt))
3890 ALL_BP_LOCATIONS (b)
3891 if (b->owner->enable_state != bp_disabled
3892 && b->owner->enable_state != bp_shlib_disabled
3893 && !b->owner->pending
3894 && b->owner->enable_state != bp_call_disabled
3895 && b->address == address /* address / overlay match */
3896 && (!overlay_debugging || b->section == section)
3897 && breakpoint_address_is_meaningful (b->owner))
3899 /* Have we found a permanent breakpoint? */
3900 if (b->owner->enable_state == bp_permanent)
3907 b->duplicate = count > 1;
3910 /* If we found a permanent breakpoint at this address, go over the
3911 list again and declare all the other breakpoints there to be the
3915 perm_bp->duplicate = 0;
3917 /* Permanent breakpoint should always be inserted. */
3918 if (! perm_bp->inserted)
3919 internal_error (__FILE__, __LINE__,
3920 "allegedly permanent breakpoint is not "
3921 "actually inserted");
3923 ALL_BP_LOCATIONS (b)
3926 if (b->owner->enable_state != bp_disabled
3927 && b->owner->enable_state != bp_shlib_disabled
3928 && !b->owner->pending
3929 && b->owner->enable_state != bp_call_disabled
3930 && b->address == address /* address / overlay match */
3931 && (!overlay_debugging || b->section == section)
3932 && breakpoint_address_is_meaningful (b->owner))
3935 internal_error (__FILE__, __LINE__,
3936 "another breakpoint was inserted on top of "
3937 "a permanent breakpoint");
3946 breakpoint_adjustment_warning (CORE_ADDR from_addr, CORE_ADDR to_addr,
3947 int bnum, int have_bnum)
3952 strcpy (astr1, local_hex_string_custom ((unsigned long) from_addr, "08l"));
3953 strcpy (astr2, local_hex_string_custom ((unsigned long) to_addr, "08l"));
3955 warning ("Breakpoint %d address previously adjusted from %s to %s.",
3956 bnum, astr1, astr2);
3958 warning ("Breakpoint address adjusted from %s to %s.", astr1, astr2);
3961 /* Adjust a breakpoint's address to account for architectural constraints
3962 on breakpoint placement. Return the adjusted address. Note: Very
3963 few targets require this kind of adjustment. For most targets,
3964 this function is simply the identity function. */
3967 adjust_breakpoint_address (CORE_ADDR bpaddr, enum bptype bptype)
3969 if (!gdbarch_adjust_breakpoint_address_p (current_gdbarch))
3971 /* Very few targets need any kind of breakpoint adjustment. */
3974 else if (bptype == bp_watchpoint
3975 || bptype == bp_hardware_watchpoint
3976 || bptype == bp_read_watchpoint
3977 || bptype == bp_access_watchpoint
3978 || bptype == bp_catch_fork
3979 || bptype == bp_catch_vfork
3980 || bptype == bp_catch_exec)
3982 /* Watchpoints and the various bp_catch_* eventpoints should not
3983 have their addresses modified. */
3988 CORE_ADDR adjusted_bpaddr;
3990 /* Some targets have architectural constraints on the placement
3991 of breakpoint instructions. Obtain the adjusted address. */
3992 adjusted_bpaddr = gdbarch_adjust_breakpoint_address (current_gdbarch,
3995 /* An adjusted breakpoint address can significantly alter
3996 a user's expectations. Print a warning if an adjustment
3998 if (adjusted_bpaddr != bpaddr)
3999 breakpoint_adjustment_warning (bpaddr, adjusted_bpaddr, 0, 0);
4001 return adjusted_bpaddr;
4005 /* Allocate a struct bp_location. */
4007 static struct bp_location *
4008 allocate_bp_location (struct breakpoint *bpt, enum bptype bp_type)
4010 struct bp_location *loc, *loc_p;
4012 loc = xmalloc (sizeof (struct bp_location));
4013 memset (loc, 0, sizeof (*loc));
4023 case bp_longjmp_resume:
4024 case bp_step_resume:
4025 case bp_through_sigtramp:
4026 case bp_watchpoint_scope:
4028 case bp_shlib_event:
4029 case bp_thread_event:
4030 case bp_overlay_event:
4032 case bp_catch_unload:
4033 loc->loc_type = bp_loc_software_breakpoint;
4035 case bp_hardware_breakpoint:
4036 loc->loc_type = bp_loc_hardware_breakpoint;
4038 case bp_hardware_watchpoint:
4039 case bp_read_watchpoint:
4040 case bp_access_watchpoint:
4041 loc->loc_type = bp_loc_hardware_watchpoint;
4045 case bp_catch_vfork:
4047 case bp_catch_catch:
4048 case bp_catch_throw:
4049 loc->loc_type = bp_loc_other;
4052 internal_error (__FILE__, __LINE__, "unknown breakpoint type");
4055 /* Add this breakpoint to the end of the chain. */
4057 loc_p = bp_location_chain;
4059 bp_location_chain = loc;
4063 loc_p = loc_p->next;
4070 /* set_raw_breakpoint() is a low level routine for allocating and
4071 partially initializing a breakpoint of type BPTYPE. The newly
4072 created breakpoint's address, section, source file name, and line
4073 number are provided by SAL. The newly created and partially
4074 initialized breakpoint is added to the breakpoint chain and
4075 is also returned as the value of this function.
4077 It is expected that the caller will complete the initialization of
4078 the newly created breakpoint struct as well as output any status
4079 information regarding the creation of a new breakpoint. In
4080 particular, set_raw_breakpoint() does NOT set the breakpoint
4081 number! Care should be taken to not allow an error() to occur
4082 prior to completing the initialization of the breakpoint. If this
4083 should happen, a bogus breakpoint will be left on the chain. */
4086 set_raw_breakpoint (struct symtab_and_line sal, enum bptype bptype)
4088 struct breakpoint *b, *b1;
4090 b = (struct breakpoint *) xmalloc (sizeof (struct breakpoint));
4091 memset (b, 0, sizeof (*b));
4092 b->loc = allocate_bp_location (b, bptype);
4093 b->loc->requested_address = sal.pc;
4094 b->loc->address = adjust_breakpoint_address (b->loc->requested_address,
4096 if (sal.symtab == NULL)
4097 b->source_file = NULL;
4099 b->source_file = savestring (sal.symtab->filename,
4100 strlen (sal.symtab->filename));
4101 b->loc->section = sal.section;
4103 b->language = current_language->la_language;
4104 b->input_radix = input_radix;
4106 b->line_number = sal.line;
4107 b->enable_state = bp_enabled;
4110 b->ignore_count = 0;
4112 b->frame_id = null_frame_id;
4113 b->dll_pathname = NULL;
4114 b->triggered_dll_pathname = NULL;
4115 b->forked_inferior_pid = 0;
4116 b->exec_pathname = NULL;
4120 /* Add this breakpoint to the end of the chain
4121 so that a list of breakpoints will come out in order
4122 of increasing numbers. */
4124 b1 = breakpoint_chain;
4126 breakpoint_chain = b;
4134 check_duplicates (b);
4135 breakpoints_changed ();
4141 /* Note that the breakpoint object B describes a permanent breakpoint
4142 instruction, hard-wired into the inferior's code. */
4144 make_breakpoint_permanent (struct breakpoint *b)
4146 b->enable_state = bp_permanent;
4148 /* By definition, permanent breakpoints are already present in the code. */
4149 b->loc->inserted = 1;
4152 static struct breakpoint *
4153 create_internal_breakpoint (CORE_ADDR address, enum bptype type)
4155 static int internal_breakpoint_number = -1;
4156 struct symtab_and_line sal;
4157 struct breakpoint *b;
4159 init_sal (&sal); /* initialize to zeroes */
4162 sal.section = find_pc_overlay (sal.pc);
4164 b = set_raw_breakpoint (sal, type);
4165 b->number = internal_breakpoint_number--;
4166 b->disposition = disp_donttouch;
4173 create_longjmp_breakpoint (char *func_name)
4175 struct breakpoint *b;
4176 struct minimal_symbol *m;
4178 if (func_name == NULL)
4179 b = create_internal_breakpoint (0, bp_longjmp_resume);
4182 if ((m = lookup_minimal_symbol_text (func_name, NULL)) == NULL)
4185 b = create_internal_breakpoint (SYMBOL_VALUE_ADDRESS (m), bp_longjmp);
4188 b->enable_state = bp_disabled;
4191 b->addr_string = xstrdup (func_name);
4194 /* Call this routine when stepping and nexting to enable a breakpoint
4195 if we do a longjmp(). When we hit that breakpoint, call
4196 set_longjmp_resume_breakpoint() to figure out where we are going. */
4199 enable_longjmp_breakpoint (void)
4201 struct breakpoint *b;
4204 if (b->type == bp_longjmp)
4206 b->enable_state = bp_enabled;
4207 check_duplicates (b);
4212 disable_longjmp_breakpoint (void)
4214 struct breakpoint *b;
4217 if (b->type == bp_longjmp
4218 || b->type == bp_longjmp_resume)
4220 b->enable_state = bp_disabled;
4221 check_duplicates (b);
4226 create_overlay_event_breakpoint (char *func_name)
4228 struct breakpoint *b;
4229 struct minimal_symbol *m;
4231 if ((m = lookup_minimal_symbol_text (func_name, NULL)) == NULL)
4234 b = create_internal_breakpoint (SYMBOL_VALUE_ADDRESS (m),
4236 b->addr_string = xstrdup (func_name);
4238 if (overlay_debugging == ovly_auto)
4240 b->enable_state = bp_enabled;
4241 overlay_events_enabled = 1;
4245 b->enable_state = bp_disabled;
4246 overlay_events_enabled = 0;
4251 enable_overlay_breakpoints (void)
4253 struct breakpoint *b;
4256 if (b->type == bp_overlay_event)
4258 b->enable_state = bp_enabled;
4259 check_duplicates (b);
4260 overlay_events_enabled = 1;
4265 disable_overlay_breakpoints (void)
4267 struct breakpoint *b;
4270 if (b->type == bp_overlay_event)
4272 b->enable_state = bp_disabled;
4273 check_duplicates (b);
4274 overlay_events_enabled = 0;
4279 create_thread_event_breakpoint (CORE_ADDR address)
4281 struct breakpoint *b;
4283 b = create_internal_breakpoint (address, bp_thread_event);
4285 b->enable_state = bp_enabled;
4286 /* addr_string has to be used or breakpoint_re_set will delete me. */
4287 xasprintf (&b->addr_string, "*0x%s", paddr (b->loc->address));
4293 remove_thread_event_breakpoints (void)
4295 struct breakpoint *b, *temp;
4297 ALL_BREAKPOINTS_SAFE (b, temp)
4298 if (b->type == bp_thread_event)
4299 delete_breakpoint (b);
4302 struct captured_parse_breakpoint_args
4305 struct symtabs_and_lines *sals_p;
4306 char ***addr_string_p;
4310 struct lang_and_radix
4316 /* Cleanup helper routine to restore the current language and
4319 do_restore_lang_radix_cleanup (void *old)
4321 struct lang_and_radix *p = old;
4322 set_language (p->lang);
4323 input_radix = p->radix;
4326 /* Try and resolve a pending breakpoint. */
4328 resolve_pending_breakpoint (struct breakpoint *b)
4330 /* Try and reparse the breakpoint in case the shared library
4332 struct symtabs_and_lines sals;
4333 struct symtab_and_line pending_sal;
4334 char **cond_string = (char **) NULL;
4335 char *copy_arg = b->addr_string;
4340 struct ui_file *old_gdb_stderr;
4341 struct lang_and_radix old_lr;
4342 struct cleanup *old_chain;
4344 /* Set language, input-radix, then reissue breakpoint command.
4345 Ensure the language and input-radix are restored afterwards. */
4346 old_lr.lang = current_language->la_language;
4347 old_lr.radix = input_radix;
4348 old_chain = make_cleanup (do_restore_lang_radix_cleanup, &old_lr);
4350 set_language (b->language);
4351 input_radix = b->input_radix;
4352 rc = break_command_1 (b->addr_string, b->flag, b->from_tty, b);
4354 if (rc == GDB_RC_OK)
4355 /* Pending breakpoint has been resolved. */
4356 printf_filtered ("Pending breakpoint \"%s\" resolved\n", b->addr_string);
4358 do_cleanups (old_chain);
4364 remove_solib_event_breakpoints (void)
4366 struct breakpoint *b, *temp;
4368 ALL_BREAKPOINTS_SAFE (b, temp)
4369 if (b->type == bp_shlib_event)
4370 delete_breakpoint (b);
4374 create_solib_event_breakpoint (CORE_ADDR address)
4376 struct breakpoint *b;
4378 b = create_internal_breakpoint (address, bp_shlib_event);
4382 /* Disable any breakpoints that are on code in shared libraries. Only
4383 apply to enabled breakpoints, disabled ones can just stay disabled. */
4386 disable_breakpoints_in_shlibs (int silent)
4388 struct breakpoint *b;
4389 int disabled_shlib_breaks = 0;
4391 /* See also: insert_breakpoints, under DISABLE_UNSETTABLE_BREAK. */
4394 #if defined (PC_SOLIB)
4395 if (((b->type == bp_breakpoint) ||
4396 (b->type == bp_hardware_breakpoint)) &&
4397 breakpoint_enabled (b) &&
4398 !b->loc->duplicate &&
4399 PC_SOLIB (b->loc->address))
4401 b->enable_state = bp_shlib_disabled;
4404 if (!disabled_shlib_breaks)
4406 target_terminal_ours_for_output ();
4407 warning ("Temporarily disabling shared library breakpoints:");
4409 disabled_shlib_breaks = 1;
4410 warning ("breakpoint #%d ", b->number);
4417 /* Try to reenable any breakpoints in shared libraries. */
4419 re_enable_breakpoints_in_shlibs (void)
4421 struct breakpoint *b, *tmp;
4423 ALL_BREAKPOINTS_SAFE (b, tmp)
4425 if (b->enable_state == bp_shlib_disabled)
4429 /* Do not reenable the breakpoint if the shared library
4430 is still not mapped in. */
4431 lib = PC_SOLIB (b->loc->address);
4432 if (lib != NULL && target_read_memory (b->loc->address, buf, 1) == 0)
4433 b->enable_state = bp_enabled;
4435 else if (b->pending && (b->enable_state == bp_enabled))
4437 if (resolve_pending_breakpoint (b) == GDB_RC_OK)
4438 delete_breakpoint (b);
4446 solib_load_unload_1 (char *hookname, int tempflag, char *dll_pathname,
4447 char *cond_string, enum bptype bp_kind)
4449 struct breakpoint *b;
4450 struct symtabs_and_lines sals;
4451 struct cleanup *old_chain;
4452 struct cleanup *canonical_strings_chain = NULL;
4453 char *addr_start = hookname;
4454 char *addr_end = NULL;
4455 char **canonical = (char **) NULL;
4456 int thread = -1; /* All threads. */
4458 /* Set a breakpoint on the specified hook. */
4459 sals = decode_line_1 (&hookname, 1, (struct symtab *) NULL, 0, &canonical, NULL);
4460 addr_end = hookname;
4462 if (sals.nelts == 0)
4464 warning ("Unable to set a breakpoint on dynamic linker callback.");
4465 warning ("Suggest linking with /opt/langtools/lib/end.o.");
4466 warning ("GDB will be unable to track shl_load/shl_unload calls");
4469 if (sals.nelts != 1)
4471 warning ("Unable to set unique breakpoint on dynamic linker callback.");
4472 warning ("GDB will be unable to track shl_load/shl_unload calls");
4476 /* Make sure that all storage allocated in decode_line_1 gets freed
4477 in case the following errors out. */
4478 old_chain = make_cleanup (xfree, sals.sals);
4479 if (canonical != (char **) NULL)
4481 make_cleanup (xfree, canonical);
4482 canonical_strings_chain = make_cleanup (null_cleanup, 0);
4483 if (canonical[0] != NULL)
4484 make_cleanup (xfree, canonical[0]);
4487 resolve_sal_pc (&sals.sals[0]);
4489 /* Remove the canonical strings from the cleanup, they are needed below. */
4490 if (canonical != (char **) NULL)
4491 discard_cleanups (canonical_strings_chain);
4493 b = set_raw_breakpoint (sals.sals[0], bp_kind);
4494 set_breakpoint_count (breakpoint_count + 1);
4495 b->number = breakpoint_count;
4497 b->cond_string = (cond_string == NULL) ?
4498 NULL : savestring (cond_string, strlen (cond_string));
4501 if (canonical != (char **) NULL && canonical[0] != NULL)
4502 b->addr_string = canonical[0];
4503 else if (addr_start)
4504 b->addr_string = savestring (addr_start, addr_end - addr_start);
4506 b->enable_state = bp_enabled;
4507 b->disposition = tempflag ? disp_del : disp_donttouch;
4509 if (dll_pathname == NULL)
4510 b->dll_pathname = NULL;
4513 b->dll_pathname = (char *) xmalloc (strlen (dll_pathname) + 1);
4514 strcpy (b->dll_pathname, dll_pathname);
4518 do_cleanups (old_chain);
4522 create_solib_load_event_breakpoint (char *hookname, int tempflag,
4523 char *dll_pathname, char *cond_string)
4525 solib_load_unload_1 (hookname, tempflag, dll_pathname,
4526 cond_string, bp_catch_load);
4530 create_solib_unload_event_breakpoint (char *hookname, int tempflag,
4531 char *dll_pathname, char *cond_string)
4533 solib_load_unload_1 (hookname,tempflag, dll_pathname,
4534 cond_string, bp_catch_unload);
4538 create_fork_vfork_event_catchpoint (int tempflag, char *cond_string,
4539 enum bptype bp_kind)
4541 struct symtab_and_line sal;
4542 struct breakpoint *b;
4543 int thread = -1; /* All threads. */
4550 b = set_raw_breakpoint (sal, bp_kind);
4551 set_breakpoint_count (breakpoint_count + 1);
4552 b->number = breakpoint_count;
4554 b->cond_string = (cond_string == NULL) ?
4555 NULL : savestring (cond_string, strlen (cond_string));
4557 b->addr_string = NULL;
4558 b->enable_state = bp_enabled;
4559 b->disposition = tempflag ? disp_del : disp_donttouch;
4560 b->forked_inferior_pid = 0;
4566 create_fork_event_catchpoint (int tempflag, char *cond_string)
4568 create_fork_vfork_event_catchpoint (tempflag, cond_string, bp_catch_fork);
4572 create_vfork_event_catchpoint (int tempflag, char *cond_string)
4574 create_fork_vfork_event_catchpoint (tempflag, cond_string, bp_catch_vfork);
4578 create_exec_event_catchpoint (int tempflag, char *cond_string)
4580 struct symtab_and_line sal;
4581 struct breakpoint *b;
4582 int thread = -1; /* All threads. */
4589 b = set_raw_breakpoint (sal, bp_catch_exec);
4590 set_breakpoint_count (breakpoint_count + 1);
4591 b->number = breakpoint_count;
4593 b->cond_string = (cond_string == NULL) ?
4594 NULL : savestring (cond_string, strlen (cond_string));
4596 b->addr_string = NULL;
4597 b->enable_state = bp_enabled;
4598 b->disposition = tempflag ? disp_del : disp_donttouch;
4604 hw_breakpoint_used_count (void)
4606 struct breakpoint *b;
4611 if (b->type == bp_hardware_breakpoint && b->enable_state == bp_enabled)
4619 hw_watchpoint_used_count (enum bptype type, int *other_type_used)
4621 struct breakpoint *b;
4624 *other_type_used = 0;
4627 if (breakpoint_enabled (b))
4629 if (b->type == type)
4631 else if ((b->type == bp_hardware_watchpoint ||
4632 b->type == bp_read_watchpoint ||
4633 b->type == bp_access_watchpoint))
4634 *other_type_used = 1;
4640 /* Call this after hitting the longjmp() breakpoint. Use this to set
4641 a new breakpoint at the target of the jmp_buf.
4643 FIXME - This ought to be done by setting a temporary breakpoint
4644 that gets deleted automatically... */
4647 set_longjmp_resume_breakpoint (CORE_ADDR pc, struct frame_id frame_id)
4649 struct breakpoint *b;
4652 if (b->type == bp_longjmp_resume)
4654 b->loc->requested_address = pc;
4655 b->loc->address = adjust_breakpoint_address (b->loc->requested_address,
4657 b->enable_state = bp_enabled;
4658 b->frame_id = frame_id;
4659 check_duplicates (b);
4665 disable_watchpoints_before_interactive_call_start (void)
4667 struct breakpoint *b;
4671 if (((b->type == bp_watchpoint)
4672 || (b->type == bp_hardware_watchpoint)
4673 || (b->type == bp_read_watchpoint)
4674 || (b->type == bp_access_watchpoint)
4675 || ep_is_exception_catchpoint (b))
4676 && breakpoint_enabled (b))
4678 b->enable_state = bp_call_disabled;
4679 check_duplicates (b);
4685 enable_watchpoints_after_interactive_call_stop (void)
4687 struct breakpoint *b;
4691 if (((b->type == bp_watchpoint)
4692 || (b->type == bp_hardware_watchpoint)
4693 || (b->type == bp_read_watchpoint)
4694 || (b->type == bp_access_watchpoint)
4695 || ep_is_exception_catchpoint (b))
4696 && (b->enable_state == bp_call_disabled))
4698 b->enable_state = bp_enabled;
4699 check_duplicates (b);
4705 /* Set a breakpoint that will evaporate an end of command
4706 at address specified by SAL.
4707 Restrict it to frame FRAME if FRAME is nonzero. */
4710 set_momentary_breakpoint (struct symtab_and_line sal, struct frame_id frame_id,
4713 struct breakpoint *b;
4714 b = set_raw_breakpoint (sal, type);
4715 b->enable_state = bp_enabled;
4716 b->disposition = disp_donttouch;
4717 b->frame_id = frame_id;
4719 /* If we're debugging a multi-threaded program, then we
4720 want momentary breakpoints to be active in only a
4721 single thread of control. */
4722 if (in_thread_list (inferior_ptid))
4723 b->thread = pid_to_thread_id (inferior_ptid);
4729 /* Tell the user we have just set a breakpoint B. */
4732 mention (struct breakpoint *b)
4735 struct cleanup *old_chain, *ui_out_chain;
4736 struct ui_stream *stb;
4738 stb = ui_out_stream_new (uiout);
4739 old_chain = make_cleanup_ui_out_stream_delete (stb);
4741 /* FIXME: This is misplaced; mention() is called by things (like
4742 hitting a watchpoint) other than breakpoint creation. It should
4743 be possible to clean this up and at the same time replace the
4744 random calls to breakpoint_changed with this hook, as has already
4745 been done for deprecated_delete_breakpoint_hook and so on. */
4746 if (deprecated_create_breakpoint_hook)
4747 deprecated_create_breakpoint_hook (b);
4748 breakpoint_create_event (b->number);
4750 if (b->ops != NULL && b->ops->print_mention != NULL)
4751 b->ops->print_mention (b);
4756 printf_filtered ("(apparently deleted?) Eventpoint %d: ", b->number);
4759 ui_out_text (uiout, "Watchpoint ");
4760 ui_out_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "wpt");
4761 ui_out_field_int (uiout, "number", b->number);
4762 ui_out_text (uiout, ": ");
4763 print_expression (b->exp, stb->stream);
4764 ui_out_field_stream (uiout, "exp", stb);
4765 do_cleanups (ui_out_chain);
4767 case bp_hardware_watchpoint:
4768 ui_out_text (uiout, "Hardware watchpoint ");
4769 ui_out_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "wpt");
4770 ui_out_field_int (uiout, "number", b->number);
4771 ui_out_text (uiout, ": ");
4772 print_expression (b->exp, stb->stream);
4773 ui_out_field_stream (uiout, "exp", stb);
4774 do_cleanups (ui_out_chain);
4776 case bp_read_watchpoint:
4777 ui_out_text (uiout, "Hardware read watchpoint ");
4778 ui_out_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "hw-rwpt");
4779 ui_out_field_int (uiout, "number", b->number);
4780 ui_out_text (uiout, ": ");
4781 print_expression (b->exp, stb->stream);
4782 ui_out_field_stream (uiout, "exp", stb);
4783 do_cleanups (ui_out_chain);
4785 case bp_access_watchpoint:
4786 ui_out_text (uiout, "Hardware access (read/write) watchpoint ");
4787 ui_out_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "hw-awpt");
4788 ui_out_field_int (uiout, "number", b->number);
4789 ui_out_text (uiout, ": ");
4790 print_expression (b->exp, stb->stream);
4791 ui_out_field_stream (uiout, "exp", stb);
4792 do_cleanups (ui_out_chain);
4795 if (ui_out_is_mi_like_p (uiout))
4800 printf_filtered ("Breakpoint %d", b->number);
4803 case bp_hardware_breakpoint:
4804 if (ui_out_is_mi_like_p (uiout))
4809 printf_filtered ("Hardware assisted breakpoint %d", b->number);
4813 case bp_catch_unload:
4814 printf_filtered ("Catchpoint %d (%s %s)",
4816 (b->type == bp_catch_load) ? "load" : "unload",
4817 (b->dll_pathname != NULL) ?
4818 b->dll_pathname : "<any library>");
4821 case bp_catch_vfork:
4822 printf_filtered ("Catchpoint %d (%s)",
4824 (b->type == bp_catch_fork) ? "fork" : "vfork");
4827 printf_filtered ("Catchpoint %d (exec)",
4830 case bp_catch_catch:
4831 case bp_catch_throw:
4832 printf_filtered ("Catchpoint %d (%s)",
4834 (b->type == bp_catch_catch) ? "catch" : "throw");
4840 case bp_longjmp_resume:
4841 case bp_step_resume:
4842 case bp_through_sigtramp:
4844 case bp_watchpoint_scope:
4845 case bp_shlib_event:
4846 case bp_thread_event:
4847 case bp_overlay_event:
4855 printf_filtered (" (%s) pending.", b->addr_string);
4859 if (addressprint || b->source_file == NULL)
4861 printf_filtered (" at ");
4862 print_address_numeric (b->loc->address, 1, gdb_stdout);
4865 printf_filtered (": file %s, line %d.",
4866 b->source_file, b->line_number);
4869 do_cleanups (old_chain);
4870 if (ui_out_is_mi_like_p (uiout))
4872 printf_filtered ("\n");
4876 /* Add SALS.nelts breakpoints to the breakpoint table. For each
4877 SALS.sal[i] breakpoint, include the corresponding ADDR_STRING[i],
4878 COND[i] and COND_STRING[i] values.
4880 The parameter PENDING_BP points to a pending breakpoint that is
4881 the basis of the breakpoints currently being created. The pending
4882 breakpoint may contain a separate condition string or commands
4883 that were added after the initial pending breakpoint was created.
4885 NOTE: If the function succeeds, the caller is expected to cleanup
4886 the arrays ADDR_STRING, COND_STRING, COND and SALS (but not the
4887 array contents). If the function fails (error() is called), the
4888 caller is expected to cleanups both the ADDR_STRING, COND_STRING,
4889 COND and SALS arrays and each of those arrays contents. */
4892 create_breakpoints (struct symtabs_and_lines sals, char **addr_string,
4893 struct expression **cond, char **cond_string,
4894 enum bptype type, enum bpdisp disposition,
4895 int thread, int ignore_count, int from_tty,
4896 struct breakpoint *pending_bp)
4898 if (type == bp_hardware_breakpoint)
4900 int i = hw_breakpoint_used_count ();
4901 int target_resources_ok =
4902 TARGET_CAN_USE_HARDWARE_WATCHPOINT (bp_hardware_breakpoint,
4904 if (target_resources_ok == 0)
4905 error ("No hardware breakpoint support in the target.");
4906 else if (target_resources_ok < 0)
4907 error ("Hardware breakpoints used exceeds limit.");
4910 /* Now set all the breakpoints. */
4913 for (i = 0; i < sals.nelts; i++)
4915 struct breakpoint *b;
4916 struct symtab_and_line sal = sals.sals[i];
4919 describe_other_breakpoints (sal.pc, sal.section);
4921 b = set_raw_breakpoint (sal, type);
4922 set_breakpoint_count (breakpoint_count + 1);
4923 b->number = breakpoint_count;
4927 b->addr_string = addr_string[i];
4929 /* addr_string has to be used or breakpoint_re_set will delete
4931 xasprintf (&b->addr_string, "*0x%s", paddr (b->loc->address));
4932 b->cond_string = cond_string[i];
4933 b->ignore_count = ignore_count;
4934 b->enable_state = bp_enabled;
4935 b->disposition = disposition;
4936 /* If resolving a pending breakpoint, a check must be made to see if
4937 the user has specified a new condition or commands for the
4938 breakpoint. A new condition will override any condition that was
4939 initially specified with the initial breakpoint command. */
4943 if (pending_bp->cond_string)
4945 arg = pending_bp->cond_string;
4946 b->cond_string = savestring (arg, strlen (arg));
4947 b->cond = parse_exp_1 (&arg, block_for_pc (b->loc->address), 0);
4949 error ("Junk at end of pending breakpoint condition expression");
4951 /* If there are commands associated with the breakpoint, they should
4953 if (pending_bp->commands)
4954 b->commands = copy_command_lines (pending_bp->commands);
4961 /* Parse ARG which is assumed to be a SAL specification possibly
4962 followed by conditionals. On return, SALS contains an array of SAL
4963 addresses found. ADDR_STRING contains a vector of (canonical)
4964 address strings. ARG points to the end of the SAL. */
4967 parse_breakpoint_sals (char **address,
4968 struct symtabs_and_lines *sals,
4969 char ***addr_string,
4972 char *addr_start = *address;
4973 *addr_string = NULL;
4974 /* If no arg given, or if first arg is 'if ', use the default
4976 if ((*address) == NULL
4977 || (strncmp ((*address), "if", 2) == 0 && isspace ((*address)[2])))
4979 if (default_breakpoint_valid)
4981 struct symtab_and_line sal;
4982 init_sal (&sal); /* initialize to zeroes */
4983 sals->sals = (struct symtab_and_line *)
4984 xmalloc (sizeof (struct symtab_and_line));
4985 sal.pc = default_breakpoint_address;
4986 sal.line = default_breakpoint_line;
4987 sal.symtab = default_breakpoint_symtab;
4988 sal.section = find_pc_overlay (sal.pc);
4989 sals->sals[0] = sal;
4993 error ("No default breakpoint address now.");
4997 /* Force almost all breakpoints to be in terms of the
4998 current_source_symtab (which is decode_line_1's default). This
4999 should produce the results we want almost all of the time while
5000 leaving default_breakpoint_* alone.
5001 ObjC: However, don't match an Objective-C method name which
5002 may have a '+' or '-' succeeded by a '[' */
5004 struct symtab_and_line cursal = get_current_source_symtab_and_line ();
5006 if (default_breakpoint_valid
5008 || ((strchr ("+-", (*address)[0]) != NULL)
5009 && ((*address)[1] != '['))))
5010 *sals = decode_line_1 (address, 1, default_breakpoint_symtab,
5011 default_breakpoint_line, addr_string,
5014 *sals = decode_line_1 (address, 1, (struct symtab *) NULL, 0,
5015 addr_string, not_found_ptr);
5017 /* For any SAL that didn't have a canonical string, fill one in. */
5018 if (sals->nelts > 0 && *addr_string == NULL)
5019 *addr_string = xcalloc (sals->nelts, sizeof (char **));
5020 if (addr_start != (*address))
5023 for (i = 0; i < sals->nelts; i++)
5025 /* Add the string if not present. */
5026 if ((*addr_string)[i] == NULL)
5027 (*addr_string)[i] = savestring (addr_start, (*address) - addr_start);
5033 /* Convert each SAL into a real PC. Verify that the PC can be
5034 inserted as a breakpoint. If it can't throw an error. */
5037 breakpoint_sals_to_pc (struct symtabs_and_lines *sals,
5041 for (i = 0; i < sals->nelts; i++)
5043 resolve_sal_pc (&sals->sals[i]);
5045 /* It's possible for the PC to be nonzero, but still an illegal
5046 value on some targets.
5048 For example, on HP-UX if you start gdb, and before running the
5049 inferior you try to set a breakpoint on a shared library function
5050 "foo" where the inferior doesn't call "foo" directly but does
5051 pass its address to another function call, then we do find a
5052 minimal symbol for the "foo", but it's address is invalid.
5053 (Appears to be an index into a table that the loader sets up
5054 when the inferior is run.)
5056 Give the target a chance to bless sals.sals[i].pc before we
5057 try to make a breakpoint for it. */
5058 if (PC_REQUIRES_RUN_BEFORE_USE (sals->sals[i].pc))
5060 if (address == NULL)
5061 error ("Cannot break without a running program.");
5063 error ("Cannot break on %s without a running program.",
5070 do_captured_parse_breakpoint (struct ui_out *ui, void *data)
5072 struct captured_parse_breakpoint_args *args = data;
5074 parse_breakpoint_sals (args->arg_p, args->sals_p, args->addr_string_p,
5075 args->not_found_ptr);
5080 /* Set a breakpoint according to ARG (function, linenum or *address)
5081 flag: first bit : 0 non-temporary, 1 temporary.
5082 second bit : 0 normal breakpoint, 1 hardware breakpoint.
5084 PENDING_BP is non-NULL when this function is being called to resolve
5085 a pending breakpoint. */
5088 break_command_1 (char *arg, int flag, int from_tty, struct breakpoint *pending_bp)
5090 int tempflag, hardwareflag;
5091 struct symtabs_and_lines sals;
5092 struct expression **cond = 0;
5093 struct symtab_and_line pending_sal;
5094 char **cond_string = (char **) NULL;
5097 char *addr_start = arg;
5099 struct cleanup *old_chain;
5100 struct cleanup *breakpoint_chain = NULL;
5101 struct captured_parse_breakpoint_args parse_args;
5105 int ignore_count = 0;
5108 hardwareflag = flag & BP_HARDWAREFLAG;
5109 tempflag = flag & BP_TEMPFLAG;
5115 parse_args.arg_p = &arg;
5116 parse_args.sals_p = &sals;
5117 parse_args.addr_string_p = &addr_string;
5118 parse_args.not_found_ptr = ¬_found;
5120 rc = catch_exceptions_with_msg (uiout, do_captured_parse_breakpoint,
5121 &parse_args, NULL, &err_msg,
5124 /* If caller is interested in rc value from parse, set value. */
5126 if (rc != GDB_RC_OK)
5128 /* Check for file or function not found. */
5131 /* If called to resolve pending breakpoint, just return error code. */
5135 error_output_message (NULL, err_msg);
5138 /* If pending breakpoint support is turned off, throw error. */
5140 if (pending_break_support == AUTO_BOOLEAN_FALSE)
5141 throw_exception (RETURN_ERROR);
5143 /* If pending breakpoint support is auto query and the user selects
5144 no, then simply return the error code. */
5145 if (pending_break_support == AUTO_BOOLEAN_AUTO &&
5146 !nquery ("Make breakpoint pending on future shared library load? "))
5149 /* At this point, either the user was queried about setting a
5150 pending breakpoint and selected yes, or pending breakpoint
5151 behavior is on and thus a pending breakpoint is defaulted
5152 on behalf of the user. */
5153 copy_arg = xstrdup (addr_start);
5154 addr_string = ©_arg;
5156 sals.sals = &pending_sal;
5163 else if (!sals.nelts)
5166 /* Create a chain of things that always need to be cleaned up. */
5167 old_chain = make_cleanup (null_cleanup, 0);
5171 /* Make sure that all storage allocated to SALS gets freed. */
5172 make_cleanup (xfree, sals.sals);
5174 /* Cleanup the addr_string array but not its contents. */
5175 make_cleanup (xfree, addr_string);
5178 /* Allocate space for all the cond expressions. */
5179 cond = xcalloc (sals.nelts, sizeof (struct expression *));
5180 make_cleanup (xfree, cond);
5182 /* Allocate space for all the cond strings. */
5183 cond_string = xcalloc (sals.nelts, sizeof (char **));
5184 make_cleanup (xfree, cond_string);
5186 /* ----------------------------- SNIP -----------------------------
5187 Anything added to the cleanup chain beyond this point is assumed
5188 to be part of a breakpoint. If the breakpoint create succeeds
5189 then the memory is not reclaimed. */
5190 breakpoint_chain = make_cleanup (null_cleanup, 0);
5192 /* Mark the contents of the addr_string for cleanup. These go on
5193 the breakpoint_chain and only occure if the breakpoint create
5195 for (i = 0; i < sals.nelts; i++)
5197 if (addr_string[i] != NULL)
5198 make_cleanup (xfree, addr_string[i]);
5201 /* Resolve all line numbers to PC's and verify that the addresses
5202 are ok for the target. */
5204 breakpoint_sals_to_pc (&sals, addr_start);
5206 /* Verify that condition can be parsed, before setting any
5207 breakpoints. Allocate a separate condition expression for each
5209 thread = -1; /* No specific thread yet */
5212 for (i = 0; i < sals.nelts; i++)
5219 char *cond_start = NULL;
5220 char *cond_end = NULL;
5221 while (*tok == ' ' || *tok == '\t')
5226 while (*end_tok != ' ' && *end_tok != '\t' && *end_tok != '\000')
5229 toklen = end_tok - tok;
5231 if (toklen >= 1 && strncmp (tok, "if", toklen) == 0)
5233 tok = cond_start = end_tok + 1;
5234 cond[i] = parse_exp_1 (&tok, block_for_pc (sals.sals[i].pc),
5236 make_cleanup (xfree, cond[i]);
5238 cond_string[i] = savestring (cond_start,
5239 cond_end - cond_start);
5240 make_cleanup (xfree, cond_string[i]);
5242 else if (toklen >= 1 && strncmp (tok, "thread", toklen) == 0)
5248 thread = strtol (tok, &tok, 0);
5250 error ("Junk after thread keyword.");
5251 if (!valid_thread_id (thread))
5252 error ("Unknown thread %d\n", thread);
5255 error ("Junk at end of arguments.");
5258 create_breakpoints (sals, addr_string, cond, cond_string,
5259 hardwareflag ? bp_hardware_breakpoint
5261 tempflag ? disp_del : disp_donttouch,
5262 thread, ignore_count, from_tty,
5267 struct symtab_and_line sal;
5268 struct breakpoint *b;
5273 make_cleanup (xfree, copy_arg);
5275 b = set_raw_breakpoint (sal, hardwareflag ? bp_hardware_breakpoint
5277 set_breakpoint_count (breakpoint_count + 1);
5278 b->number = breakpoint_count;
5281 b->addr_string = *addr_string;
5282 b->cond_string = *cond_string;
5283 b->ignore_count = ignore_count;
5285 b->disposition = tempflag ? disp_del : disp_donttouch;
5286 b->from_tty = from_tty;
5293 warning ("Multiple breakpoints were set.");
5294 warning ("Use the \"delete\" command to delete unwanted breakpoints.");
5296 /* That's it. Discard the cleanups for data inserted into the
5298 discard_cleanups (breakpoint_chain);
5299 /* But cleanup everything else. */
5300 do_cleanups (old_chain);
5305 /* Set a breakpoint of TYPE/DISPOSITION according to ARG (function,
5306 linenum or *address) with COND and IGNORE_COUNT. */
5308 struct captured_breakpoint_args
5319 do_captured_breakpoint (void *data)
5321 struct captured_breakpoint_args *args = data;
5322 struct symtabs_and_lines sals;
5323 struct expression **cond;
5324 struct cleanup *old_chain;
5325 struct cleanup *breakpoint_chain = NULL;
5332 /* Parse the source and lines spec. Delay check that the expression
5333 didn't contain trailing garbage until after cleanups are in
5337 address_end = args->address;
5339 parse_breakpoint_sals (&address_end, &sals, &addr_string, 0);
5344 /* Create a chain of things at always need to be cleaned up. */
5345 old_chain = make_cleanup (null_cleanup, 0);
5347 /* Always have a addr_string array, even if it is empty. */
5348 make_cleanup (xfree, addr_string);
5350 /* Make sure that all storage allocated to SALS gets freed. */
5351 make_cleanup (xfree, sals.sals);
5353 /* Allocate space for all the cond expressions. */
5354 cond = xcalloc (sals.nelts, sizeof (struct expression *));
5355 make_cleanup (xfree, cond);
5357 /* Allocate space for all the cond strings. */
5358 cond_string = xcalloc (sals.nelts, sizeof (char **));
5359 make_cleanup (xfree, cond_string);
5361 /* ----------------------------- SNIP -----------------------------
5362 Anything added to the cleanup chain beyond this point is assumed
5363 to be part of a breakpoint. If the breakpoint create goes
5364 through then that memory is not cleaned up. */
5365 breakpoint_chain = make_cleanup (null_cleanup, 0);
5367 /* Mark the contents of the addr_string for cleanup. These go on
5368 the breakpoint_chain and only occure if the breakpoint create
5370 for (i = 0; i < sals.nelts; i++)
5372 if (addr_string[i] != NULL)
5373 make_cleanup (xfree, addr_string[i]);
5376 /* Wait until now before checking for garbage at the end of the
5377 address. That way cleanups can take care of freeing any
5379 if (*address_end != '\0')
5380 error ("Garbage %s following breakpoint address", address_end);
5382 /* Resolve all line numbers to PC's. */
5383 breakpoint_sals_to_pc (&sals, args->address);
5385 /* Verify that conditions can be parsed, before setting any
5387 for (i = 0; i < sals.nelts; i++)
5389 if (args->condition != NULL)
5391 char *tok = args->condition;
5392 cond[i] = parse_exp_1 (&tok, block_for_pc (sals.sals[i].pc), 0);
5394 error ("Garbage %s follows condition", tok);
5395 make_cleanup (xfree, cond[i]);
5396 cond_string[i] = xstrdup (args->condition);
5400 create_breakpoints (sals, addr_string, cond, cond_string,
5401 args->hardwareflag ? bp_hardware_breakpoint : bp_breakpoint,
5402 args->tempflag ? disp_del : disp_donttouch,
5403 args->thread, args->ignore_count, 0/*from-tty*/,
5404 NULL/*pending_bp*/);
5406 /* That's it. Discard the cleanups for data inserted into the
5408 discard_cleanups (breakpoint_chain);
5409 /* But cleanup everything else. */
5410 do_cleanups (old_chain);
5415 gdb_breakpoint (char *address, char *condition,
5416 int hardwareflag, int tempflag,
5417 int thread, int ignore_count)
5419 struct captured_breakpoint_args args;
5420 args.address = address;
5421 args.condition = condition;
5422 args.hardwareflag = hardwareflag;
5423 args.tempflag = tempflag;
5424 args.thread = thread;
5425 args.ignore_count = ignore_count;
5426 return catch_errors (do_captured_breakpoint, &args,
5427 NULL, RETURN_MASK_ALL);
5432 break_at_finish_at_depth_command_1 (char *arg, int flag, int from_tty)
5434 struct frame_info *frame;
5435 CORE_ADDR low, high, selected_pc = 0;
5436 char *extra_args = NULL;
5438 int extra_args_len = 0, if_arg = 0;
5441 (arg[0] == 'i' && arg[1] == 'f' && (arg[2] == ' ' || arg[2] == '\t')))
5444 if (default_breakpoint_valid)
5446 if (deprecated_selected_frame)
5448 selected_pc = get_frame_pc (deprecated_selected_frame);
5453 error ("No selected frame.");
5456 error ("No default breakpoint address now.");
5460 extra_args = strchr (arg, ' ');
5464 extra_args_len = strlen (extra_args);
5465 level_arg = (char *) xmalloc (extra_args - arg);
5466 strncpy (level_arg, arg, extra_args - arg - 1);
5467 level_arg[extra_args - arg - 1] = '\0';
5471 level_arg = (char *) xmalloc (strlen (arg) + 1);
5472 strcpy (level_arg, arg);
5475 frame = parse_frame_specification (level_arg);
5477 selected_pc = get_frame_pc (frame);
5484 extra_args_len = strlen (arg);
5489 if (find_pc_partial_function (selected_pc, (char **) NULL, &low, &high))
5493 addr_string = xstrprintf ("*0x%s %s", paddr_nz (high), extra_args);
5495 addr_string = xstrprintf ("*0x%s", paddr_nz (high));
5496 break_command_1 (addr_string, flag, from_tty, NULL);
5497 xfree (addr_string);
5500 error ("No function contains the specified address");
5503 error ("Unable to set breakpoint at procedure exit");
5508 break_at_finish_command_1 (char *arg, int flag, int from_tty)
5510 char *addr_string, *break_string, *beg_addr_string;
5511 CORE_ADDR low, high;
5512 struct symtabs_and_lines sals;
5513 struct symtab_and_line sal;
5514 struct cleanup *old_chain;
5515 char *extra_args = NULL;
5516 int extra_args_len = 0;
5520 (arg[0] == 'i' && arg[1] == 'f' && (arg[2] == ' ' || arg[2] == '\t')))
5522 if (default_breakpoint_valid)
5524 if (deprecated_selected_frame)
5526 addr_string = xstrprintf ("*0x%s",
5527 paddr_nz (get_frame_pc (deprecated_selected_frame)));
5532 error ("No selected frame.");
5535 error ("No default breakpoint address now.");
5539 addr_string = (char *) xmalloc (strlen (arg) + 1);
5540 strcpy (addr_string, arg);
5546 extra_args_len = strlen (arg);
5550 /* get the stuff after the function name or address */
5551 extra_args = strchr (arg, ' ');
5555 extra_args_len = strlen (extra_args);
5562 beg_addr_string = addr_string;
5563 sals = decode_line_1 (&addr_string, 1, (struct symtab *) NULL, 0,
5564 (char ***) NULL, NULL);
5566 xfree (beg_addr_string);
5567 old_chain = make_cleanup (xfree, sals.sals);
5568 for (i = 0; (i < sals.nelts); i++)
5571 if (find_pc_partial_function (sal.pc, (char **) NULL, &low, &high))
5575 break_string = xstrprintf ("*0x%s %s", paddr_nz (high),
5578 break_string = xstrprintf ("*0x%s", paddr_nz (high));
5579 break_command_1 (break_string, flag, from_tty, NULL);
5580 xfree (break_string);
5583 error ("No function contains the specified address");
5587 warning ("Multiple breakpoints were set.\n");
5588 warning ("Use the \"delete\" command to delete unwanted breakpoints.");
5590 do_cleanups (old_chain);
5594 /* Helper function for break_command_1 and disassemble_command. */
5597 resolve_sal_pc (struct symtab_and_line *sal)
5601 if (sal->pc == 0 && sal->symtab != NULL)
5603 if (!find_line_pc (sal->symtab, sal->line, &pc))
5604 error ("No line %d in file \"%s\".",
5605 sal->line, sal->symtab->filename);
5609 if (sal->section == 0 && sal->symtab != NULL)
5611 struct blockvector *bv;
5616 bv = blockvector_for_pc_sect (sal->pc, 0, &index, sal->symtab);
5619 b = BLOCKVECTOR_BLOCK (bv, index);
5620 sym = block_function (b);
5623 fixup_symbol_section (sym, sal->symtab->objfile);
5624 sal->section = SYMBOL_BFD_SECTION (sym);
5628 /* It really is worthwhile to have the section, so we'll just
5629 have to look harder. This case can be executed if we have
5630 line numbers but no functions (as can happen in assembly
5633 struct minimal_symbol *msym;
5635 msym = lookup_minimal_symbol_by_pc (sal->pc);
5637 sal->section = SYMBOL_BFD_SECTION (msym);
5644 break_command (char *arg, int from_tty)
5646 break_command_1 (arg, 0, from_tty, NULL);
5650 break_at_finish_command (char *arg, int from_tty)
5652 break_at_finish_command_1 (arg, 0, from_tty);
5656 break_at_finish_at_depth_command (char *arg, int from_tty)
5658 break_at_finish_at_depth_command_1 (arg, 0, from_tty);
5662 tbreak_command (char *arg, int from_tty)
5664 break_command_1 (arg, BP_TEMPFLAG, from_tty, NULL);
5668 tbreak_at_finish_command (char *arg, int from_tty)
5670 break_at_finish_command_1 (arg, BP_TEMPFLAG, from_tty);
5674 hbreak_command (char *arg, int from_tty)
5676 break_command_1 (arg, BP_HARDWAREFLAG, from_tty, NULL);
5680 thbreak_command (char *arg, int from_tty)
5682 break_command_1 (arg, (BP_TEMPFLAG | BP_HARDWAREFLAG), from_tty, NULL);
5686 stop_command (char *arg, int from_tty)
5688 printf_filtered ("Specify the type of breakpoint to set.\n\
5689 Usage: stop in <function | address>\n\
5694 stopin_command (char *arg, int from_tty)
5698 if (arg == (char *) NULL)
5700 else if (*arg != '*')
5705 /* look for a ':'. If this is a line number specification, then
5706 say it is bad, otherwise, it should be an address or
5707 function/method name */
5708 while (*argptr && !hasColon)
5710 hasColon = (*argptr == ':');
5715 badInput = (*argptr != ':'); /* Not a class::method */
5717 badInput = isdigit (*arg); /* a simple line number */
5721 printf_filtered ("Usage: stop in <function | address>\n");
5723 break_command_1 (arg, 0, from_tty, NULL);
5727 stopat_command (char *arg, int from_tty)
5731 if (arg == (char *) NULL || *arg == '*') /* no line number */
5738 /* look for a ':'. If there is a '::' then get out, otherwise
5739 it is probably a line number. */
5740 while (*argptr && !hasColon)
5742 hasColon = (*argptr == ':');
5747 badInput = (*argptr == ':'); /* we have class::method */
5749 badInput = !isdigit (*arg); /* not a line number */
5753 printf_filtered ("Usage: stop at <line>\n");
5755 break_command_1 (arg, 0, from_tty, NULL);
5758 /* accessflag: hw_write: watch write,
5759 hw_read: watch read,
5760 hw_access: watch access (read or write) */
5762 watch_command_1 (char *arg, int accessflag, int from_tty)
5764 struct breakpoint *b;
5765 struct symtab_and_line sal;
5766 struct expression *exp;
5767 struct block *exp_valid_block;
5768 struct value *val, *mark;
5769 struct frame_info *frame;
5770 struct frame_info *prev_frame = NULL;
5771 char *exp_start = NULL;
5772 char *exp_end = NULL;
5773 char *tok, *end_tok;
5775 char *cond_start = NULL;
5776 char *cond_end = NULL;
5777 struct expression *cond = NULL;
5778 int i, other_type_used, target_resources_ok = 0;
5779 enum bptype bp_type;
5782 init_sal (&sal); /* initialize to zeroes */
5784 /* Parse arguments. */
5785 innermost_block = NULL;
5787 exp = parse_exp_1 (&arg, 0, 0);
5789 exp_valid_block = innermost_block;
5790 mark = value_mark ();
5791 val = evaluate_expression (exp);
5792 release_value (val);
5793 if (VALUE_LAZY (val))
5794 value_fetch_lazy (val);
5797 while (*tok == ' ' || *tok == '\t')
5801 while (*end_tok != ' ' && *end_tok != '\t' && *end_tok != '\000')
5804 toklen = end_tok - tok;
5805 if (toklen >= 1 && strncmp (tok, "if", toklen) == 0)
5807 tok = cond_start = end_tok + 1;
5808 cond = parse_exp_1 (&tok, 0, 0);
5812 error ("Junk at end of command.");
5814 if (accessflag == hw_read)
5815 bp_type = bp_read_watchpoint;
5816 else if (accessflag == hw_access)
5817 bp_type = bp_access_watchpoint;
5819 bp_type = bp_hardware_watchpoint;
5821 mem_cnt = can_use_hardware_watchpoint (val);
5822 if (mem_cnt == 0 && bp_type != bp_hardware_watchpoint)
5823 error ("Expression cannot be implemented with read/access watchpoint.");
5826 i = hw_watchpoint_used_count (bp_type, &other_type_used);
5827 target_resources_ok =
5828 TARGET_CAN_USE_HARDWARE_WATCHPOINT (bp_type, i + mem_cnt,
5830 if (target_resources_ok == 0 && bp_type != bp_hardware_watchpoint)
5831 error ("Target does not support this type of hardware watchpoint.");
5833 if (target_resources_ok < 0 && bp_type != bp_hardware_watchpoint)
5834 error ("Target can only support one kind of HW watchpoint at a time.");
5837 #if defined(HPUXHPPA)
5838 /* On HP-UX if you set a h/w
5839 watchpoint before the "run" command, the inferior dies with a e.g.,
5840 SIGILL once you start it. I initially believed this was due to a
5841 bad interaction between page protection traps and the initial
5842 startup sequence by the dynamic linker.
5844 However, I tried avoiding that by having HP-UX's implementation of
5845 TARGET_CAN_USE_HW_WATCHPOINT return FALSE if there was no inferior_ptid
5846 yet, which forced slow watches before a "run" or "attach", and it
5847 still fails somewhere in the startup code.
5849 Until I figure out what's happening, I'm disallowing watches altogether
5850 before the "run" or "attach" command. We'll tell the user they must
5851 set watches after getting the program started. */
5852 if (!target_has_execution)
5854 warning ("can't do that without a running program; try \"break main\", \"run\" first");
5857 #endif /* HPUXHPPA */
5859 /* Change the type of breakpoint to an ordinary watchpoint if a hardware
5860 watchpoint could not be set. */
5861 if (!mem_cnt || target_resources_ok <= 0)
5862 bp_type = bp_watchpoint;
5864 /* Now set up the breakpoint. */
5865 b = set_raw_breakpoint (sal, bp_type);
5866 set_breakpoint_count (breakpoint_count + 1);
5867 b->number = breakpoint_count;
5868 b->disposition = disp_donttouch;
5870 b->exp_valid_block = exp_valid_block;
5871 b->exp_string = savestring (exp_start, exp_end - exp_start);
5875 b->cond_string = savestring (cond_start, cond_end - cond_start);
5879 frame = block_innermost_frame (exp_valid_block);
5882 prev_frame = get_prev_frame (frame);
5883 b->watchpoint_frame = get_frame_id (frame);
5887 memset (&b->watchpoint_frame, 0, sizeof (b->watchpoint_frame));
5890 /* If the expression is "local", then set up a "watchpoint scope"
5891 breakpoint at the point where we've left the scope of the watchpoint
5893 if (innermost_block)
5897 struct breakpoint *scope_breakpoint;
5898 scope_breakpoint = create_internal_breakpoint (get_frame_pc (prev_frame),
5899 bp_watchpoint_scope);
5901 scope_breakpoint->enable_state = bp_enabled;
5903 /* Automatically delete the breakpoint when it hits. */
5904 scope_breakpoint->disposition = disp_del;
5906 /* Only break in the proper frame (help with recursion). */
5907 scope_breakpoint->frame_id = get_frame_id (prev_frame);
5909 /* Set the address at which we will stop. */
5910 scope_breakpoint->loc->requested_address
5911 = get_frame_pc (prev_frame);
5912 scope_breakpoint->loc->address
5913 = adjust_breakpoint_address (scope_breakpoint->loc->requested_address,
5914 scope_breakpoint->type);
5916 /* The scope breakpoint is related to the watchpoint. We
5917 will need to act on them together. */
5918 b->related_breakpoint = scope_breakpoint;
5921 value_free_to_mark (mark);
5925 /* Return count of locations need to be watched and can be handled
5926 in hardware. If the watchpoint can not be handled
5927 in hardware return zero. */
5929 #if !defined(TARGET_REGION_OK_FOR_HW_WATCHPOINT)
5930 #define TARGET_REGION_OK_FOR_HW_WATCHPOINT(ADDR,LEN) \
5931 (TARGET_REGION_SIZE_OK_FOR_HW_WATCHPOINT(LEN))
5935 can_use_hardware_watchpoint (struct value *v)
5937 int found_memory_cnt = 0;
5938 struct value *head = v;
5940 /* Did the user specifically forbid us to use hardware watchpoints? */
5941 if (!can_use_hw_watchpoints)
5944 /* Make sure that the value of the expression depends only upon
5945 memory contents, and values computed from them within GDB. If we
5946 find any register references or function calls, we can't use a
5947 hardware watchpoint.
5949 The idea here is that evaluating an expression generates a series
5950 of values, one holding the value of every subexpression. (The
5951 expression a*b+c has five subexpressions: a, b, a*b, c, and
5952 a*b+c.) GDB's values hold almost enough information to establish
5953 the criteria given above --- they identify memory lvalues,
5954 register lvalues, computed values, etcetera. So we can evaluate
5955 the expression, and then scan the chain of values that leaves
5956 behind to decide whether we can detect any possible change to the
5957 expression's final value using only hardware watchpoints.
5959 However, I don't think that the values returned by inferior
5960 function calls are special in any way. So this function may not
5961 notice that an expression involving an inferior function call
5962 can't be watched with hardware watchpoints. FIXME. */
5963 for (; v; v = v->next)
5965 if (VALUE_LVAL (v) == lval_memory)
5968 /* A lazy memory lvalue is one that GDB never needed to fetch;
5969 we either just used its address (e.g., `a' in `a.b') or
5970 we never needed it at all (e.g., `a' in `a,b'). */
5974 /* Ahh, memory we actually used! Check if we can cover
5975 it with hardware watchpoints. */
5976 struct type *vtype = check_typedef (VALUE_TYPE (v));
5978 /* We only watch structs and arrays if user asked for it
5979 explicitly, never if they just happen to appear in a
5980 middle of some value chain. */
5982 || (TYPE_CODE (vtype) != TYPE_CODE_STRUCT
5983 && TYPE_CODE (vtype) != TYPE_CODE_ARRAY))
5985 CORE_ADDR vaddr = VALUE_ADDRESS (v) + VALUE_OFFSET (v);
5986 int len = TYPE_LENGTH (VALUE_TYPE (v));
5988 if (!TARGET_REGION_OK_FOR_HW_WATCHPOINT (vaddr, len))
5995 else if (v->lval != not_lval && v->modifiable == 0)
5996 return 0; /* ??? What does this represent? */
5997 else if (v->lval == lval_register)
5998 return 0; /* cannot watch a register with a HW watchpoint */
6001 /* The expression itself looks suitable for using a hardware
6002 watchpoint, but give the target machine a chance to reject it. */
6003 return found_memory_cnt;
6007 watch_command_wrapper (char *arg, int from_tty)
6009 watch_command (arg, from_tty);
6013 watch_command (char *arg, int from_tty)
6015 watch_command_1 (arg, hw_write, from_tty);
6019 rwatch_command_wrapper (char *arg, int from_tty)
6021 rwatch_command (arg, from_tty);
6025 rwatch_command (char *arg, int from_tty)
6027 watch_command_1 (arg, hw_read, from_tty);
6031 awatch_command_wrapper (char *arg, int from_tty)
6033 awatch_command (arg, from_tty);
6037 awatch_command (char *arg, int from_tty)
6039 watch_command_1 (arg, hw_access, from_tty);
6043 /* Helper routines for the until_command routine in infcmd.c. Here
6044 because it uses the mechanisms of breakpoints. */
6046 /* This function is called by fetch_inferior_event via the
6047 cmd_continuation pointer, to complete the until command. It takes
6048 care of cleaning up the temporary breakpoints set up by the until
6051 until_break_command_continuation (struct continuation_arg *arg)
6053 struct cleanup *cleanups;
6055 cleanups = (struct cleanup *) arg->data.pointer;
6056 do_exec_cleanups (cleanups);
6060 until_break_command (char *arg, int from_tty, int anywhere)
6062 struct symtabs_and_lines sals;
6063 struct symtab_and_line sal;
6064 struct frame_info *prev_frame = get_prev_frame (deprecated_selected_frame);
6065 struct breakpoint *breakpoint;
6066 struct cleanup *old_chain;
6067 struct continuation_arg *arg1;
6070 clear_proceed_status ();
6072 /* Set a breakpoint where the user wants it and at return from
6075 if (default_breakpoint_valid)
6076 sals = decode_line_1 (&arg, 1, default_breakpoint_symtab,
6077 default_breakpoint_line, (char ***) NULL, NULL);
6079 sals = decode_line_1 (&arg, 1, (struct symtab *) NULL,
6080 0, (char ***) NULL, NULL);
6082 if (sals.nelts != 1)
6083 error ("Couldn't get information on specified line.");
6086 xfree (sals.sals); /* malloc'd, so freed */
6089 error ("Junk at end of arguments.");
6091 resolve_sal_pc (&sal);
6094 /* If the user told us to continue until a specified location,
6095 we don't specify a frame at which we need to stop. */
6096 breakpoint = set_momentary_breakpoint (sal, null_frame_id, bp_until);
6098 /* Otherwise, specify the current frame, because we want to stop only
6099 at the very same frame. */
6100 breakpoint = set_momentary_breakpoint (sal,
6101 get_frame_id (deprecated_selected_frame),
6104 if (!event_loop_p || !target_can_async_p ())
6105 old_chain = make_cleanup_delete_breakpoint (breakpoint);
6107 old_chain = make_exec_cleanup_delete_breakpoint (breakpoint);
6109 /* If we are running asynchronously, and the target supports async
6110 execution, we are not waiting for the target to stop, in the call
6111 tp proceed, below. This means that we cannot delete the
6112 brekpoints until the target has actually stopped. The only place
6113 where we get a chance to do that is in fetch_inferior_event, so
6114 we must set things up for that. */
6116 if (event_loop_p && target_can_async_p ())
6118 /* In this case the arg for the continuation is just the point
6119 in the exec_cleanups chain from where to start doing
6120 cleanups, because all the continuation does is the cleanups in
6121 the exec_cleanup_chain. */
6123 (struct continuation_arg *) xmalloc (sizeof (struct continuation_arg));
6125 arg1->data.pointer = old_chain;
6127 add_continuation (until_break_command_continuation, arg1);
6130 /* Keep within the current frame, or in frames called by the current
6134 sal = find_pc_line (get_frame_pc (prev_frame), 0);
6135 sal.pc = get_frame_pc (prev_frame);
6136 breakpoint = set_momentary_breakpoint (sal, get_frame_id (prev_frame),
6138 if (!event_loop_p || !target_can_async_p ())
6139 make_cleanup_delete_breakpoint (breakpoint);
6141 make_exec_cleanup_delete_breakpoint (breakpoint);
6144 proceed (-1, TARGET_SIGNAL_DEFAULT, 0);
6145 /* Do the cleanups now, anly if we are not running asynchronously,
6146 of if we are, but the target is still synchronous. */
6147 if (!event_loop_p || !target_can_async_p ())
6148 do_cleanups (old_chain);
6152 ep_skip_leading_whitespace (char **s)
6154 if ((s == NULL) || (*s == NULL))
6156 while (isspace (**s))
6160 /* This function examines a string, and attempts to find a token
6161 that might be an event name in the leading characters. If a
6162 possible match is found, a pointer to the last character of
6163 the token is returned. Else, NULL is returned. */
6166 ep_find_event_name_end (char *arg)
6169 char *event_name_end = NULL;
6171 /* If we could depend upon the presense of strrpbrk, we'd use that... */
6175 /* We break out of the loop when we find a token delimiter.
6176 Basically, we're looking for alphanumerics and underscores;
6177 anything else delimites the token. */
6180 if (!isalnum (*s) && (*s != '_'))
6186 return event_name_end;
6190 /* This function attempts to parse an optional "if <cond>" clause
6191 from the arg string. If one is not found, it returns NULL.
6193 Else, it returns a pointer to the condition string. (It does not
6194 attempt to evaluate the string against a particular block.) And,
6195 it updates arg to point to the first character following the parsed
6196 if clause in the arg string. */
6199 ep_parse_optional_if_clause (char **arg)
6203 if (((*arg)[0] != 'i') || ((*arg)[1] != 'f') || !isspace ((*arg)[2]))
6206 /* Skip the "if" keyword. */
6209 /* Skip any extra leading whitespace, and record the start of the
6210 condition string. */
6211 ep_skip_leading_whitespace (arg);
6214 /* Assume that the condition occupies the remainder of the arg string. */
6215 (*arg) += strlen (cond_string);
6220 /* This function attempts to parse an optional filename from the arg
6221 string. If one is not found, it returns NULL.
6223 Else, it returns a pointer to the parsed filename. (This function
6224 makes no attempt to verify that a file of that name exists, or is
6225 accessible.) And, it updates arg to point to the first character
6226 following the parsed filename in the arg string.
6228 Note that clients needing to preserve the returned filename for
6229 future access should copy it to their own buffers. */
6231 ep_parse_optional_filename (char **arg)
6233 static char filename[1024];
6238 if ((*arg_p == '\0') || isspace (*arg_p))
6256 /* Commands to deal with catching events, such as signals, exceptions,
6257 process start/exit, etc. */
6261 catch_fork, catch_vfork
6266 catch_fork_command_1 (catch_fork_kind fork_kind, char *arg, int tempflag,
6269 char *cond_string = NULL;
6271 ep_skip_leading_whitespace (&arg);
6273 /* The allowed syntax is:
6275 catch [v]fork if <cond>
6277 First, check if there's an if clause. */
6278 cond_string = ep_parse_optional_if_clause (&arg);
6280 if ((*arg != '\0') && !isspace (*arg))
6281 error ("Junk at end of arguments.");
6283 /* If this target supports it, create a fork or vfork catchpoint
6284 and enable reporting of such events. */
6288 create_fork_event_catchpoint (tempflag, cond_string);
6291 create_vfork_event_catchpoint (tempflag, cond_string);
6294 error ("unsupported or unknown fork kind; cannot catch it");
6300 catch_exec_command_1 (char *arg, int tempflag, int from_tty)
6302 char *cond_string = NULL;
6304 ep_skip_leading_whitespace (&arg);
6306 /* The allowed syntax is:
6308 catch exec if <cond>
6310 First, check if there's an if clause. */
6311 cond_string = ep_parse_optional_if_clause (&arg);
6313 if ((*arg != '\0') && !isspace (*arg))
6314 error ("Junk at end of arguments.");
6316 /* If this target supports it, create an exec catchpoint
6317 and enable reporting of such events. */
6318 create_exec_event_catchpoint (tempflag, cond_string);
6322 catch_load_command_1 (char *arg, int tempflag, int from_tty)
6324 char *dll_pathname = NULL;
6325 char *cond_string = NULL;
6327 ep_skip_leading_whitespace (&arg);
6329 /* The allowed syntax is:
6331 catch load if <cond>
6332 catch load <filename>
6333 catch load <filename> if <cond>
6335 The user is not allowed to specify the <filename> after an
6338 We'll ignore the pathological case of a file named "if".
6340 First, check if there's an if clause. If so, then there
6341 cannot be a filename. */
6342 cond_string = ep_parse_optional_if_clause (&arg);
6344 /* If there was an if clause, then there cannot be a filename.
6345 Else, there might be a filename and an if clause. */
6346 if (cond_string == NULL)
6348 dll_pathname = ep_parse_optional_filename (&arg);
6349 ep_skip_leading_whitespace (&arg);
6350 cond_string = ep_parse_optional_if_clause (&arg);
6353 if ((*arg != '\0') && !isspace (*arg))
6354 error ("Junk at end of arguments.");
6356 /* Create a load breakpoint that only triggers when a load of
6357 the specified dll (or any dll, if no pathname was specified)
6359 SOLIB_CREATE_CATCH_LOAD_HOOK (PIDGET (inferior_ptid), tempflag,
6360 dll_pathname, cond_string);
6364 catch_unload_command_1 (char *arg, int tempflag, int from_tty)
6366 char *dll_pathname = NULL;
6367 char *cond_string = NULL;
6369 ep_skip_leading_whitespace (&arg);
6371 /* The allowed syntax is:
6373 catch unload if <cond>
6374 catch unload <filename>
6375 catch unload <filename> if <cond>
6377 The user is not allowed to specify the <filename> after an
6380 We'll ignore the pathological case of a file named "if".
6382 First, check if there's an if clause. If so, then there
6383 cannot be a filename. */
6384 cond_string = ep_parse_optional_if_clause (&arg);
6386 /* If there was an if clause, then there cannot be a filename.
6387 Else, there might be a filename and an if clause. */
6388 if (cond_string == NULL)
6390 dll_pathname = ep_parse_optional_filename (&arg);
6391 ep_skip_leading_whitespace (&arg);
6392 cond_string = ep_parse_optional_if_clause (&arg);
6395 if ((*arg != '\0') && !isspace (*arg))
6396 error ("Junk at end of arguments.");
6398 /* Create an unload breakpoint that only triggers when an unload of
6399 the specified dll (or any dll, if no pathname was specified)
6401 SOLIB_CREATE_CATCH_UNLOAD_HOOK (PIDGET (inferior_ptid), tempflag,
6402 dll_pathname, cond_string);
6405 /* Commands to deal with catching exceptions. */
6407 /* Set a breakpoint at the specified callback routine for an
6408 exception event callback */
6411 create_exception_catchpoint (int tempflag, char *cond_string,
6412 enum exception_event_kind ex_event,
6413 struct symtab_and_line *sal)
6415 struct breakpoint *b;
6416 int thread = -1; /* All threads. */
6419 if (!sal) /* no exception support? */
6424 case EX_EVENT_THROW:
6425 bptype = bp_catch_throw;
6427 case EX_EVENT_CATCH:
6428 bptype = bp_catch_catch;
6430 default: /* error condition */
6431 error ("Internal error -- invalid catchpoint kind");
6434 b = set_raw_breakpoint (*sal, bptype);
6435 set_breakpoint_count (breakpoint_count + 1);
6436 b->number = breakpoint_count;
6438 b->cond_string = (cond_string == NULL) ?
6439 NULL : savestring (cond_string, strlen (cond_string));
6441 b->addr_string = NULL;
6442 b->enable_state = bp_enabled;
6443 b->disposition = tempflag ? disp_del : disp_donttouch;
6447 static enum print_stop_action
6448 print_exception_catchpoint (struct breakpoint *b)
6450 annotate_catchpoint (b->number);
6452 if (strstr (b->addr_string, "throw") != NULL)
6453 printf_filtered ("\nCatchpoint %d (exception thrown)\n",
6456 printf_filtered ("\nCatchpoint %d (exception caught)\n",
6459 return PRINT_SRC_AND_LOC;
6463 print_one_exception_catchpoint (struct breakpoint *b, CORE_ADDR *last_addr)
6468 ui_out_field_core_addr (uiout, "addr", b->loc->address);
6471 *last_addr = b->loc->address;
6472 if (strstr (b->addr_string, "throw") != NULL)
6473 ui_out_field_string (uiout, "what", "exception throw");
6475 ui_out_field_string (uiout, "what", "exception catch");
6479 print_mention_exception_catchpoint (struct breakpoint *b)
6481 if (strstr (b->addr_string, "throw") != NULL)
6482 printf_filtered ("Catchpoint %d (throw)", b->number);
6484 printf_filtered ("Catchpoint %d (catch)", b->number);
6487 static struct breakpoint_ops gnu_v3_exception_catchpoint_ops = {
6488 print_exception_catchpoint,
6489 print_one_exception_catchpoint,
6490 print_mention_exception_catchpoint
6494 handle_gnu_v3_exceptions (int tempflag, char *cond_string,
6495 enum exception_event_kind ex_event, int from_tty)
6497 char *trigger_func_name, *nameptr;
6498 struct symtabs_and_lines sals;
6499 struct breakpoint *b;
6501 if (ex_event == EX_EVENT_CATCH)
6502 trigger_func_name = xstrdup ("__cxa_begin_catch");
6504 trigger_func_name = xstrdup ("__cxa_throw");
6506 nameptr = trigger_func_name;
6507 sals = decode_line_1 (&nameptr, 1, NULL, 0, NULL, NULL);
6508 if (sals.nelts == 0)
6510 xfree (trigger_func_name);
6514 b = set_raw_breakpoint (sals.sals[0], bp_breakpoint);
6515 set_breakpoint_count (breakpoint_count + 1);
6516 b->number = breakpoint_count;
6518 b->cond_string = (cond_string == NULL) ?
6519 NULL : savestring (cond_string, strlen (cond_string));
6521 b->addr_string = trigger_func_name;
6522 b->enable_state = bp_enabled;
6523 b->disposition = tempflag ? disp_del : disp_donttouch;
6524 b->ops = &gnu_v3_exception_catchpoint_ops;
6531 /* Deal with "catch catch" and "catch throw" commands */
6534 catch_exception_command_1 (enum exception_event_kind ex_event, char *arg,
6535 int tempflag, int from_tty)
6537 char *cond_string = NULL;
6538 struct symtab_and_line *sal = NULL;
6540 ep_skip_leading_whitespace (&arg);
6542 cond_string = ep_parse_optional_if_clause (&arg);
6544 if ((*arg != '\0') && !isspace (*arg))
6545 error ("Junk at end of arguments.");
6547 if ((ex_event != EX_EVENT_THROW) &&
6548 (ex_event != EX_EVENT_CATCH))
6549 error ("Unsupported or unknown exception event; cannot catch it");
6551 if (handle_gnu_v3_exceptions (tempflag, cond_string, ex_event, from_tty))
6554 /* See if we can find a callback routine */
6555 sal = target_enable_exception_callback (ex_event, 1);
6559 /* We have callbacks from the runtime system for exceptions.
6560 Set a breakpoint on the sal found, if no errors */
6561 if (sal != (struct symtab_and_line *) -1)
6562 create_exception_catchpoint (tempflag, cond_string, ex_event, sal);
6564 return; /* something went wrong with setting up callbacks */
6567 warning ("Unsupported with this platform/compiler combination.");
6570 /* Cover routine to allow wrapping target_enable_exception_catchpoints
6571 inside a catch_errors */
6574 cover_target_enable_exception_callback (void *arg)
6576 args_for_catchpoint_enable *args = arg;
6577 struct symtab_and_line *sal;
6578 sal = target_enable_exception_callback (args->kind, args->enable_p);
6581 else if (sal == (struct symtab_and_line *) -1)
6584 return 1; /*is valid */
6588 catch_command_1 (char *arg, int tempflag, int from_tty)
6591 /* The first argument may be an event name, such as "start" or "load".
6592 If so, then handle it as such. If it doesn't match an event name,
6593 then attempt to interpret it as an exception name. (This latter is
6594 the v4.16-and-earlier GDB meaning of the "catch" command.)
6596 First, try to find the bounds of what might be an event name. */
6597 char *arg1_start = arg;
6601 if (arg1_start == NULL)
6603 /* Old behaviour was to use pre-v-4.16 syntax */
6604 /* catch_throw_command_1 (arg1_start, tempflag, from_tty); */
6606 /* Now, this is not allowed */
6607 error ("Catch requires an event name.");
6610 arg1_end = ep_find_event_name_end (arg1_start);
6611 if (arg1_end == NULL)
6612 error ("catch requires an event");
6613 arg1_length = arg1_end + 1 - arg1_start;
6615 /* Try to match what we found against known event names. */
6616 if (strncmp (arg1_start, "signal", arg1_length) == 0)
6618 error ("Catch of signal not yet implemented");
6620 else if (strncmp (arg1_start, "catch", arg1_length) == 0)
6622 catch_exception_command_1 (EX_EVENT_CATCH, arg1_end + 1,
6623 tempflag, from_tty);
6625 else if (strncmp (arg1_start, "throw", arg1_length) == 0)
6627 catch_exception_command_1 (EX_EVENT_THROW, arg1_end + 1,
6628 tempflag, from_tty);
6630 else if (strncmp (arg1_start, "thread_start", arg1_length) == 0)
6632 error ("Catch of thread_start not yet implemented");
6634 else if (strncmp (arg1_start, "thread_exit", arg1_length) == 0)
6636 error ("Catch of thread_exit not yet implemented");
6638 else if (strncmp (arg1_start, "thread_join", arg1_length) == 0)
6640 error ("Catch of thread_join not yet implemented");
6642 else if (strncmp (arg1_start, "start", arg1_length) == 0)
6644 error ("Catch of start not yet implemented");
6646 else if (strncmp (arg1_start, "exit", arg1_length) == 0)
6648 error ("Catch of exit not yet implemented");
6650 else if (strncmp (arg1_start, "fork", arg1_length) == 0)
6652 catch_fork_command_1 (catch_fork, arg1_end + 1, tempflag, from_tty);
6654 else if (strncmp (arg1_start, "vfork", arg1_length) == 0)
6656 catch_fork_command_1 (catch_vfork, arg1_end + 1, tempflag, from_tty);
6658 else if (strncmp (arg1_start, "exec", arg1_length) == 0)
6660 catch_exec_command_1 (arg1_end + 1, tempflag, from_tty);
6662 else if (strncmp (arg1_start, "load", arg1_length) == 0)
6664 catch_load_command_1 (arg1_end + 1, tempflag, from_tty);
6666 else if (strncmp (arg1_start, "unload", arg1_length) == 0)
6668 catch_unload_command_1 (arg1_end + 1, tempflag, from_tty);
6670 else if (strncmp (arg1_start, "stop", arg1_length) == 0)
6672 error ("Catch of stop not yet implemented");
6675 /* This doesn't appear to be an event name */
6679 /* Pre-v.4.16 behaviour was to treat the argument
6680 as the name of an exception */
6681 /* catch_throw_command_1 (arg1_start, tempflag, from_tty); */
6682 /* Now this is not allowed */
6683 error ("Unknown event kind specified for catch");
6688 /* Used by the gui, could be made a worker for other things. */
6691 set_breakpoint_sal (struct symtab_and_line sal)
6693 struct breakpoint *b;
6694 b = set_raw_breakpoint (sal, bp_breakpoint);
6695 set_breakpoint_count (breakpoint_count + 1);
6696 b->number = breakpoint_count;
6703 catch_command (char *arg, int from_tty)
6705 catch_command_1 (arg, 0, from_tty);
6710 tcatch_command (char *arg, int from_tty)
6712 catch_command_1 (arg, 1, from_tty);
6715 /* Delete breakpoints by address or line. */
6718 clear_command (char *arg, int from_tty)
6720 struct breakpoint *b, *tmp, *prev, *found;
6722 struct symtabs_and_lines sals;
6723 struct symtab_and_line sal;
6728 sals = decode_line_spec (arg, 1);
6733 sals.sals = (struct symtab_and_line *)
6734 xmalloc (sizeof (struct symtab_and_line));
6735 make_cleanup (xfree, sals.sals);
6736 init_sal (&sal); /* initialize to zeroes */
6737 sal.line = default_breakpoint_line;
6738 sal.symtab = default_breakpoint_symtab;
6739 sal.pc = default_breakpoint_address;
6740 if (sal.symtab == 0)
6741 error ("No source file specified.");
6749 /* For each line spec given, delete bps which correspond
6750 to it. Do it in two passes, solely to preserve the current
6751 behavior that from_tty is forced true if we delete more than
6755 for (i = 0; i < sals.nelts; i++)
6757 /* If exact pc given, clear bpts at that pc.
6758 If line given (pc == 0), clear all bpts on specified line.
6759 If defaulting, clear all bpts on default line
6762 defaulting sal.pc != 0 tests to do
6767 1 0 <can't happen> */
6772 /* Find all matching breakpoints, remove them from the
6773 breakpoint chain, and add them to the 'found' chain. */
6774 ALL_BREAKPOINTS_SAFE (b, tmp)
6776 /* Are we going to delete b? */
6777 if (b->type != bp_none
6778 && b->type != bp_watchpoint
6779 && b->type != bp_hardware_watchpoint
6780 && b->type != bp_read_watchpoint
6781 && b->type != bp_access_watchpoint
6782 /* Not if b is a watchpoint of any sort... */
6783 && (((sal.pc && (b->loc->address == sal.pc))
6784 && (!section_is_overlay (b->loc->section)
6785 || b->loc->section == sal.section))
6786 /* Yes, if sal.pc matches b (modulo overlays). */
6787 || ((default_match || (0 == sal.pc))
6788 && b->source_file != NULL
6789 && sal.symtab != NULL
6790 && strcmp (b->source_file, sal.symtab->filename) == 0
6791 && b->line_number == sal.line)))
6792 /* Yes, if sal source file and line matches b. */
6794 /* Remove it from breakpoint_chain... */
6795 if (b == breakpoint_chain)
6797 /* b is at the head of the list */
6798 breakpoint_chain = b->next;
6802 prev->next = b->next;
6804 /* And add it to 'found' chain. */
6810 /* Keep b, and keep a pointer to it. */
6815 /* Now go thru the 'found' chain and delete them. */
6819 error ("No breakpoint at %s.", arg);
6821 error ("No breakpoint at this line.");
6825 from_tty = 1; /* Always report if deleted more than one */
6827 printf_unfiltered ("Deleted breakpoint%s ", found->next ? "s" : "");
6828 breakpoints_changed ();
6832 printf_unfiltered ("%d ", found->number);
6834 delete_breakpoint (found);
6838 putchar_unfiltered ('\n');
6841 /* Delete breakpoint in BS if they are `delete' breakpoints and
6842 all breakpoints that are marked for deletion, whether hit or not.
6843 This is called after any breakpoint is hit, or after errors. */
6846 breakpoint_auto_delete (bpstat bs)
6848 struct breakpoint *b, *temp;
6850 for (; bs; bs = bs->next)
6851 if (bs->breakpoint_at && bs->breakpoint_at->disposition == disp_del
6853 delete_breakpoint (bs->breakpoint_at);
6855 ALL_BREAKPOINTS_SAFE (b, temp)
6857 if (b->disposition == disp_del_at_next_stop)
6858 delete_breakpoint (b);
6862 /* Delete a breakpoint and clean up all traces of it in the data
6866 delete_breakpoint (struct breakpoint *bpt)
6868 struct breakpoint *b;
6870 struct bp_location *loc;
6873 error ("Internal error (attempted to delete a NULL breakpoint)");
6876 /* Has this bp already been deleted? This can happen because multiple
6877 lists can hold pointers to bp's. bpstat lists are especial culprits.
6879 One example of this happening is a watchpoint's scope bp. When the
6880 scope bp triggers, we notice that the watchpoint is out of scope, and
6881 delete it. We also delete its scope bp. But the scope bp is marked
6882 "auto-deleting", and is already on a bpstat. That bpstat is then
6883 checked for auto-deleting bp's, which are deleted.
6885 A real solution to this problem might involve reference counts in bp's,
6886 and/or giving them pointers back to their referencing bpstat's, and
6887 teaching delete_breakpoint to only free a bp's storage when no more
6888 references were extent. A cheaper bandaid was chosen. */
6889 if (bpt->type == bp_none)
6892 if (deprecated_delete_breakpoint_hook)
6893 deprecated_delete_breakpoint_hook (bpt);
6894 breakpoint_delete_event (bpt->number);
6896 if (bpt->loc->inserted)
6897 remove_breakpoint (bpt->loc, mark_inserted);
6899 free_valchain (bpt->loc);
6901 if (breakpoint_chain == bpt)
6902 breakpoint_chain = bpt->next;
6904 if (bp_location_chain == bpt->loc)
6905 bp_location_chain = bpt->loc->next;
6907 /* If we have callback-style exception catchpoints, don't go through
6908 the adjustments to the C++ runtime library etc. if the inferior
6909 isn't actually running. target_enable_exception_callback for a
6910 null target ops vector gives an undesirable error message, so we
6911 check here and avoid it. Since currently (1997-09-17) only HP-UX aCC's
6912 exceptions are supported in this way, it's OK for now. FIXME */
6913 if (ep_is_exception_catchpoint (bpt) && target_has_execution)
6915 /* Format possible error msg */
6916 char *message = xstrprintf ("Error in deleting catchpoint %d:\n",
6918 struct cleanup *cleanups = make_cleanup (xfree, message);
6919 args_for_catchpoint_enable args;
6920 args.kind = bpt->type == bp_catch_catch ?
6921 EX_EVENT_CATCH : EX_EVENT_THROW;
6923 catch_errors (cover_target_enable_exception_callback, &args,
6924 message, RETURN_MASK_ALL);
6925 do_cleanups (cleanups);
6932 b->next = bpt->next;
6936 ALL_BP_LOCATIONS (loc)
6937 if (loc->next == bpt->loc)
6939 loc->next = bpt->loc->next;
6943 check_duplicates (bpt);
6944 /* If this breakpoint was inserted, and there is another breakpoint
6945 at the same address, we need to insert the other breakpoint. */
6946 if (bpt->loc->inserted
6947 && bpt->type != bp_hardware_watchpoint
6948 && bpt->type != bp_read_watchpoint
6949 && bpt->type != bp_access_watchpoint
6950 && bpt->type != bp_catch_fork
6951 && bpt->type != bp_catch_vfork
6952 && bpt->type != bp_catch_exec)
6955 if (b->loc->address == bpt->loc->address
6956 && b->loc->section == bpt->loc->section
6957 && !b->loc->duplicate
6958 && b->enable_state != bp_disabled
6959 && b->enable_state != bp_shlib_disabled
6961 && b->enable_state != bp_call_disabled)
6965 /* We should never reach this point if there is a permanent
6966 breakpoint at the same address as the one being deleted.
6967 If there is a permanent breakpoint somewhere, it should
6968 always be the only one inserted. */
6969 if (b->enable_state == bp_permanent)
6970 internal_error (__FILE__, __LINE__,
6971 "another breakpoint was inserted on top of "
6972 "a permanent breakpoint");
6974 if (b->type == bp_hardware_breakpoint)
6975 val = target_insert_hw_breakpoint (b->loc->address, b->loc->shadow_contents);
6977 val = target_insert_breakpoint (b->loc->address, b->loc->shadow_contents);
6979 /* If there was an error in the insert, print a message, then stop execution. */
6982 struct ui_file *tmp_error_stream = mem_fileopen ();
6983 make_cleanup_ui_file_delete (tmp_error_stream);
6986 if (b->type == bp_hardware_breakpoint)
6988 fprintf_unfiltered (tmp_error_stream,
6989 "Cannot insert hardware breakpoint %d.\n"
6990 "You may have requested too many hardware breakpoints.\n",
6995 fprintf_unfiltered (tmp_error_stream, "Cannot insert breakpoint %d.\n", b->number);
6996 fprintf_filtered (tmp_error_stream, "Error accessing memory address ");
6997 print_address_numeric (b->loc->address, 1, tmp_error_stream);
6998 fprintf_filtered (tmp_error_stream, ": %s.\n",
6999 safe_strerror (val));
7002 fprintf_unfiltered (tmp_error_stream,"The same program may be running in another process.");
7003 target_terminal_ours_for_output ();
7004 error_stream(tmp_error_stream);
7007 b->loc->inserted = 1;
7011 free_command_lines (&bpt->commands);
7014 if (bpt->cond_string != NULL)
7015 xfree (bpt->cond_string);
7016 if (bpt->addr_string != NULL)
7017 xfree (bpt->addr_string);
7018 if (bpt->exp != NULL)
7020 if (bpt->exp_string != NULL)
7021 xfree (bpt->exp_string);
7022 if (bpt->val != NULL)
7023 value_free (bpt->val);
7024 if (bpt->source_file != NULL)
7025 xfree (bpt->source_file);
7026 if (bpt->dll_pathname != NULL)
7027 xfree (bpt->dll_pathname);
7028 if (bpt->triggered_dll_pathname != NULL)
7029 xfree (bpt->triggered_dll_pathname);
7030 if (bpt->exec_pathname != NULL)
7031 xfree (bpt->exec_pathname);
7033 /* Be sure no bpstat's are pointing at it after it's been freed. */
7034 /* FIXME, how can we find all bpstat's?
7035 We just check stop_bpstat for now. */
7036 for (bs = stop_bpstat; bs; bs = bs->next)
7037 if (bs->breakpoint_at == bpt)
7039 bs->breakpoint_at = NULL;
7041 /* bs->commands will be freed later. */
7043 /* On the chance that someone will soon try again to delete this same
7044 bp, we mark it as deleted before freeing its storage. */
7045 bpt->type = bp_none;
7052 do_delete_breakpoint_cleanup (void *b)
7054 delete_breakpoint (b);
7058 make_cleanup_delete_breakpoint (struct breakpoint *b)
7060 return make_cleanup (do_delete_breakpoint_cleanup, b);
7064 make_exec_cleanup_delete_breakpoint (struct breakpoint *b)
7066 return make_exec_cleanup (do_delete_breakpoint_cleanup, b);
7070 delete_command (char *arg, int from_tty)
7072 struct breakpoint *b, *temp;
7078 int breaks_to_delete = 0;
7080 /* Delete all breakpoints if no argument.
7081 Do not delete internal or call-dummy breakpoints, these
7082 have to be deleted with an explicit breakpoint number argument. */
7085 if (b->type != bp_call_dummy &&
7086 b->type != bp_shlib_event &&
7087 b->type != bp_thread_event &&
7088 b->type != bp_overlay_event &&
7090 breaks_to_delete = 1;
7093 /* Ask user only if there are some breakpoints to delete. */
7095 || (breaks_to_delete && query ("Delete all breakpoints? ")))
7097 ALL_BREAKPOINTS_SAFE (b, temp)
7099 if (b->type != bp_call_dummy &&
7100 b->type != bp_shlib_event &&
7101 b->type != bp_thread_event &&
7102 b->type != bp_overlay_event &&
7104 delete_breakpoint (b);
7109 map_breakpoint_numbers (arg, delete_breakpoint);
7112 /* Reset a breakpoint given it's struct breakpoint * BINT.
7113 The value we return ends up being the return value from catch_errors.
7114 Unused in this case. */
7117 breakpoint_re_set_one (void *bint)
7119 /* get past catch_errs */
7120 struct breakpoint *b = (struct breakpoint *) bint;
7123 struct symtabs_and_lines sals;
7125 enum enable_state save_enable;
7130 warning ("attempted to reset apparently deleted breakpoint #%d?",
7134 case bp_hardware_breakpoint:
7136 case bp_catch_unload:
7137 if (b->addr_string == NULL)
7139 /* Anything without a string can't be re-set. */
7140 delete_breakpoint (b);
7143 /* HACK: cagney/2001-11-11: kettenis/2001-11-11: MarkK wrote:
7145 ``And a hack it is, although Apple's Darwin version of GDB
7146 contains an almost identical hack to implement a "future
7147 break" command. It seems to work in many real world cases,
7148 but it is easy to come up with a test case where the patch
7149 doesn't help at all.''
7151 ``It seems that the way GDB implements breakpoints - in -
7152 shared - libraries was designed for a.out shared library
7153 systems (SunOS 4) where shared libraries were loaded at a
7154 fixed address in memory. Since ELF shared libraries can (and
7155 will) be loaded at any address in memory, things break.
7156 Fixing this is not trivial. Therefore, I'm not sure whether
7157 we should add this hack to the branch only. I cannot
7158 guarantee that things will be fixed on the trunk in the near
7161 In case we have a problem, disable this breakpoint. We'll
7162 restore its status if we succeed. Don't disable a
7163 shlib_disabled breakpoint though. There's a fair chance we
7164 can't re-set it if the shared library it's in hasn't been
7170 save_enable = b->enable_state;
7171 if (b->enable_state != bp_shlib_disabled)
7172 b->enable_state = bp_disabled;
7174 set_language (b->language);
7175 input_radix = b->input_radix;
7177 sals = decode_line_1 (&s, 1, (struct symtab *) NULL, 0, (char ***) NULL, NULL);
7178 for (i = 0; i < sals.nelts; i++)
7180 resolve_sal_pc (&sals.sals[i]);
7182 /* Reparse conditions, they might contain references to the
7184 if (b->cond_string != NULL)
7190 /* Avoid re-freeing b->exp if an error during the call
7194 b->cond = parse_exp_1 (&s, block_for_pc (sals.sals[i].pc), 0);
7197 /* We need to re-set the breakpoint if the address changes... */
7198 if (b->loc->address != sals.sals[i].pc
7199 /* ...or new and old breakpoints both have source files, and
7200 the source file name or the line number changes... */
7201 || (b->source_file != NULL
7202 && sals.sals[i].symtab != NULL
7203 && (strcmp (b->source_file, sals.sals[i].symtab->filename) != 0
7204 || b->line_number != sals.sals[i].line)
7206 /* ...or we switch between having a source file and not having
7208 || ((b->source_file == NULL) != (sals.sals[i].symtab == NULL))
7211 if (b->source_file != NULL)
7212 xfree (b->source_file);
7213 if (sals.sals[i].symtab == NULL)
7214 b->source_file = NULL;
7217 savestring (sals.sals[i].symtab->filename,
7218 strlen (sals.sals[i].symtab->filename));
7219 b->line_number = sals.sals[i].line;
7220 b->loc->requested_address = sals.sals[i].pc;
7222 = adjust_breakpoint_address (b->loc->requested_address,
7225 /* Used to check for duplicates here, but that can
7226 cause trouble, as it doesn't check for disabled
7231 /* Might be better to do this just once per breakpoint_re_set,
7232 rather than once for every breakpoint. */
7233 breakpoints_changed ();
7235 b->loc->section = sals.sals[i].section;
7236 b->enable_state = save_enable; /* Restore it, this worked. */
7239 /* Now that this is re-enabled, check_duplicates
7241 check_duplicates (b);
7248 case bp_hardware_watchpoint:
7249 case bp_read_watchpoint:
7250 case bp_access_watchpoint:
7251 innermost_block = NULL;
7252 /* The issue arises of what context to evaluate this in. The
7253 same one as when it was set, but what does that mean when
7254 symbols have been re-read? We could save the filename and
7255 functionname, but if the context is more local than that, the
7256 best we could do would be something like how many levels deep
7257 and which index at that particular level, but that's going to
7258 be less stable than filenames or function names. */
7260 /* So for now, just use a global context. */
7264 /* Avoid re-freeing b->exp if an error during the call to
7265 parse_expression. */
7268 b->exp = parse_expression (b->exp_string);
7269 b->exp_valid_block = innermost_block;
7270 mark = value_mark ();
7273 value_free (b->val);
7274 /* Avoid re-freeing b->val if an error during the call to
7275 evaluate_expression. */
7278 b->val = evaluate_expression (b->exp);
7279 release_value (b->val);
7280 if (VALUE_LAZY (b->val) && breakpoint_enabled (b))
7281 value_fetch_lazy (b->val);
7283 if (b->cond_string != NULL)
7289 /* Avoid re-freeing b->exp if an error during the call
7293 b->cond = parse_exp_1 (&s, (struct block *) 0, 0);
7295 if (breakpoint_enabled (b))
7297 value_free_to_mark (mark);
7299 case bp_catch_catch:
7300 case bp_catch_throw:
7302 /* We needn't really do anything to reset these, since the mask
7303 that requests them is unaffected by e.g., new libraries being
7306 case bp_catch_vfork:
7311 printf_filtered ("Deleting unknown breakpoint type %d\n", b->type);
7313 /* Delete longjmp and overlay event breakpoints; they will be
7314 reset later by breakpoint_re_set. */
7316 case bp_longjmp_resume:
7317 case bp_overlay_event:
7318 delete_breakpoint (b);
7321 /* This breakpoint is special, it's set up when the inferior
7322 starts and we really don't want to touch it. */
7323 case bp_shlib_event:
7325 /* Like bp_shlib_event, this breakpoint type is special.
7326 Once it is set up, we do not want to touch it. */
7327 case bp_thread_event:
7329 /* Keep temporary breakpoints, which can be encountered when we step
7330 over a dlopen call and SOLIB_ADD is resetting the breakpoints.
7331 Otherwise these should have been blown away via the cleanup chain
7332 or by breakpoint_init_inferior when we rerun the executable. */
7335 case bp_watchpoint_scope:
7337 case bp_step_resume:
7344 /* Re-set all breakpoints after symbols have been re-loaded. */
7346 breakpoint_re_set (void)
7348 struct breakpoint *b, *temp;
7349 enum language save_language;
7350 int save_input_radix;
7352 save_language = current_language->la_language;
7353 save_input_radix = input_radix;
7354 ALL_BREAKPOINTS_SAFE (b, temp)
7356 /* Format possible error msg */
7357 char *message = xstrprintf ("Error in re-setting breakpoint %d:\n",
7359 struct cleanup *cleanups = make_cleanup (xfree, message);
7360 catch_errors (breakpoint_re_set_one, b, message, RETURN_MASK_ALL);
7361 do_cleanups (cleanups);
7363 set_language (save_language);
7364 input_radix = save_input_radix;
7366 if (GET_LONGJMP_TARGET_P ())
7368 create_longjmp_breakpoint ("longjmp");
7369 create_longjmp_breakpoint ("_longjmp");
7370 create_longjmp_breakpoint ("siglongjmp");
7371 create_longjmp_breakpoint ("_siglongjmp");
7372 create_longjmp_breakpoint (NULL);
7375 create_overlay_event_breakpoint ("_ovly_debug_event");
7378 /* Reset the thread number of this breakpoint:
7380 - If the breakpoint is for all threads, leave it as-is.
7381 - Else, reset it to the current thread for inferior_ptid. */
7383 breakpoint_re_set_thread (struct breakpoint *b)
7385 if (b->thread != -1)
7387 if (in_thread_list (inferior_ptid))
7388 b->thread = pid_to_thread_id (inferior_ptid);
7392 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
7393 If from_tty is nonzero, it prints a message to that effect,
7394 which ends with a period (no newline). */
7397 set_ignore_count (int bptnum, int count, int from_tty)
7399 struct breakpoint *b;
7405 if (b->number == bptnum)
7407 b->ignore_count = count;
7411 printf_filtered ("Will stop next time breakpoint %d is reached.",
7413 else if (count == 1)
7414 printf_filtered ("Will ignore next crossing of breakpoint %d.",
7417 printf_filtered ("Will ignore next %d crossings of breakpoint %d.",
7420 breakpoints_changed ();
7421 breakpoint_modify_event (b->number);
7425 error ("No breakpoint number %d.", bptnum);
7428 /* Clear the ignore counts of all breakpoints. */
7430 breakpoint_clear_ignore_counts (void)
7432 struct breakpoint *b;
7435 b->ignore_count = 0;
7438 /* Command to set ignore-count of breakpoint N to COUNT. */
7441 ignore_command (char *args, int from_tty)
7447 error_no_arg ("a breakpoint number");
7449 num = get_number (&p);
7451 error ("bad breakpoint number: '%s'", args);
7453 error ("Second argument (specified ignore-count) is missing.");
7455 set_ignore_count (num,
7456 longest_to_int (value_as_long (parse_and_eval (p))),
7459 printf_filtered ("\n");
7462 /* Call FUNCTION on each of the breakpoints
7463 whose numbers are given in ARGS. */
7466 map_breakpoint_numbers (char *args, void (*function) (struct breakpoint *))
7471 struct breakpoint *b, *tmp;
7475 error_no_arg ("one or more breakpoint numbers");
7482 num = get_number_or_range (&p1);
7485 warning ("bad breakpoint number at or near '%s'", p);
7489 ALL_BREAKPOINTS_SAFE (b, tmp)
7490 if (b->number == num)
7492 struct breakpoint *related_breakpoint = b->related_breakpoint;
7495 if (related_breakpoint)
7496 function (related_breakpoint);
7500 printf_unfiltered ("No breakpoint number %d.\n", num);
7506 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
7507 If from_tty is nonzero, it prints a message to that effect,
7508 which ends with a period (no newline). */
7511 disable_breakpoint (struct breakpoint *bpt)
7513 /* Never disable a watchpoint scope breakpoint; we want to
7514 hit them when we leave scope so we can delete both the
7515 watchpoint and its scope breakpoint at that time. */
7516 if (bpt->type == bp_watchpoint_scope)
7519 /* You can't disable permanent breakpoints. */
7520 if (bpt->enable_state == bp_permanent)
7523 bpt->enable_state = bp_disabled;
7525 check_duplicates (bpt);
7527 if (deprecated_modify_breakpoint_hook)
7528 deprecated_modify_breakpoint_hook (bpt);
7529 breakpoint_modify_event (bpt->number);
7533 disable_command (char *args, int from_tty)
7535 struct breakpoint *bpt;
7537 ALL_BREAKPOINTS (bpt)
7541 warning ("attempted to disable apparently deleted breakpoint #%d?",
7546 case bp_catch_unload:
7548 case bp_catch_vfork:
7550 case bp_catch_catch:
7551 case bp_catch_throw:
7552 case bp_hardware_breakpoint:
7554 case bp_hardware_watchpoint:
7555 case bp_read_watchpoint:
7556 case bp_access_watchpoint:
7557 disable_breakpoint (bpt);
7562 map_breakpoint_numbers (args, disable_breakpoint);
7566 do_enable_breakpoint (struct breakpoint *bpt, enum bpdisp disposition)
7568 struct frame_info *save_selected_frame = NULL;
7569 int save_selected_frame_level = -1;
7570 int target_resources_ok, other_type_used;
7573 if (bpt->type == bp_hardware_breakpoint)
7576 i = hw_breakpoint_used_count ();
7577 target_resources_ok =
7578 TARGET_CAN_USE_HARDWARE_WATCHPOINT (bp_hardware_breakpoint,
7580 if (target_resources_ok == 0)
7581 error ("No hardware breakpoint support in the target.");
7582 else if (target_resources_ok < 0)
7583 error ("Hardware breakpoints used exceeds limit.");
7588 if (bpt->enable_state != bp_enabled)
7590 /* When enabling a pending breakpoint, we need to check if the breakpoint
7591 is resolvable since shared libraries could have been loaded
7592 after the breakpoint was disabled. */
7593 breakpoints_changed ();
7594 if (resolve_pending_breakpoint (bpt) == GDB_RC_OK)
7596 delete_breakpoint (bpt);
7599 bpt->enable_state = bp_enabled;
7600 bpt->disposition = disposition;
7603 else /* Not a pending breakpoint. */
7605 if (bpt->enable_state != bp_permanent)
7606 bpt->enable_state = bp_enabled;
7607 bpt->disposition = disposition;
7608 check_duplicates (bpt);
7609 breakpoints_changed ();
7611 if (bpt->type == bp_watchpoint ||
7612 bpt->type == bp_hardware_watchpoint ||
7613 bpt->type == bp_read_watchpoint ||
7614 bpt->type == bp_access_watchpoint)
7616 if (bpt->exp_valid_block != NULL)
7618 struct frame_info *fr =
7619 fr = frame_find_by_id (bpt->watchpoint_frame);
7623 Cannot enable watchpoint %d because the block in which its expression\n\
7624 is valid is not currently in scope.\n", bpt->number);
7625 bpt->enable_state = bp_disabled;
7629 save_selected_frame = deprecated_selected_frame;
7630 save_selected_frame_level = frame_relative_level (deprecated_selected_frame);
7634 value_free (bpt->val);
7635 mark = value_mark ();
7636 bpt->val = evaluate_expression (bpt->exp);
7637 release_value (bpt->val);
7638 if (VALUE_LAZY (bpt->val))
7639 value_fetch_lazy (bpt->val);
7641 if (bpt->type == bp_hardware_watchpoint ||
7642 bpt->type == bp_read_watchpoint ||
7643 bpt->type == bp_access_watchpoint)
7645 int i = hw_watchpoint_used_count (bpt->type, &other_type_used);
7646 int mem_cnt = can_use_hardware_watchpoint (bpt->val);
7648 /* Hack around 'unused var' error for some targets here */
7650 target_resources_ok = TARGET_CAN_USE_HARDWARE_WATCHPOINT (
7651 bpt->type, i + mem_cnt, other_type_used);
7652 /* we can consider of type is bp_hardware_watchpoint, convert to
7653 bp_watchpoint in the following condition */
7654 if (target_resources_ok < 0)
7657 Cannot enable watchpoint %d because target watch resources\n\
7658 have been allocated for other watchpoints.\n", bpt->number);
7659 bpt->enable_state = bp_disabled;
7660 value_free_to_mark (mark);
7665 if (save_selected_frame_level >= 0)
7666 select_frame (save_selected_frame);
7667 value_free_to_mark (mark);
7671 if (deprecated_modify_breakpoint_hook)
7672 deprecated_modify_breakpoint_hook (bpt);
7673 breakpoint_modify_event (bpt->number);
7677 enable_breakpoint (struct breakpoint *bpt)
7679 do_enable_breakpoint (bpt, bpt->disposition);
7682 /* The enable command enables the specified breakpoints (or all defined
7683 breakpoints) so they once again become (or continue to be) effective
7684 in stopping the inferior. */
7687 enable_command (char *args, int from_tty)
7689 struct breakpoint *bpt;
7691 ALL_BREAKPOINTS (bpt)
7695 warning ("attempted to enable apparently deleted breakpoint #%d?",
7700 case bp_catch_unload:
7702 case bp_catch_vfork:
7704 case bp_catch_catch:
7705 case bp_catch_throw:
7706 case bp_hardware_breakpoint:
7708 case bp_hardware_watchpoint:
7709 case bp_read_watchpoint:
7710 case bp_access_watchpoint:
7711 enable_breakpoint (bpt);
7716 map_breakpoint_numbers (args, enable_breakpoint);
7720 enable_once_breakpoint (struct breakpoint *bpt)
7722 do_enable_breakpoint (bpt, disp_disable);
7726 enable_once_command (char *args, int from_tty)
7728 map_breakpoint_numbers (args, enable_once_breakpoint);
7732 enable_delete_breakpoint (struct breakpoint *bpt)
7734 do_enable_breakpoint (bpt, disp_del);
7738 enable_delete_command (char *args, int from_tty)
7740 map_breakpoint_numbers (args, enable_delete_breakpoint);
7744 set_breakpoint_cmd (char *args, int from_tty)
7749 show_breakpoint_cmd (char *args, int from_tty)
7753 /* Use default_breakpoint_'s, or nothing if they aren't valid. */
7755 struct symtabs_and_lines
7756 decode_line_spec_1 (char *string, int funfirstline)
7758 struct symtabs_and_lines sals;
7760 error ("Empty line specification.");
7761 if (default_breakpoint_valid)
7762 sals = decode_line_1 (&string, funfirstline,
7763 default_breakpoint_symtab,
7764 default_breakpoint_line,
7765 (char ***) NULL, NULL);
7767 sals = decode_line_1 (&string, funfirstline,
7768 (struct symtab *) NULL, 0, (char ***) NULL, NULL);
7770 error ("Junk at end of line specification: %s", string);
7775 _initialize_breakpoint (void)
7777 static struct cmd_list_element *breakpoint_set_cmdlist;
7778 static struct cmd_list_element *breakpoint_show_cmdlist;
7779 struct cmd_list_element *c;
7781 breakpoint_chain = 0;
7782 /* Don't bother to call set_breakpoint_count. $bpnum isn't useful
7783 before a breakpoint is set. */
7784 breakpoint_count = 0;
7786 add_com ("ignore", class_breakpoint, ignore_command,
7787 "Set ignore-count of breakpoint number N to COUNT.\n\
7788 Usage is `ignore N COUNT'.");
7790 add_com_alias ("bc", "ignore", class_breakpoint, 1);
7792 add_com ("commands", class_breakpoint, commands_command,
7793 "Set commands to be executed when a breakpoint is hit.\n\
7794 Give breakpoint number as argument after \"commands\".\n\
7795 With no argument, the targeted breakpoint is the last one set.\n\
7796 The commands themselves follow starting on the next line.\n\
7797 Type a line containing \"end\" to indicate the end of them.\n\
7798 Give \"silent\" as the first line to make the breakpoint silent;\n\
7799 then no output is printed when it is hit, except what the commands print.");
7801 add_com ("condition", class_breakpoint, condition_command,
7802 "Specify breakpoint number N to break only if COND is true.\n\
7803 Usage is `condition N COND', where N is an integer and COND is an\n\
7804 expression to be evaluated whenever breakpoint N is reached.");
7806 c = add_com ("tbreak", class_breakpoint, tbreak_command,
7807 "Set a temporary breakpoint. Args like \"break\" command.\n\
7808 Like \"break\" except the breakpoint is only temporary,\n\
7809 so it will be deleted when hit. Equivalent to \"break\" followed\n\
7810 by using \"enable delete\" on the breakpoint number.");
7811 set_cmd_completer (c, location_completer);
7813 c = add_com ("hbreak", class_breakpoint, hbreak_command,
7814 "Set a hardware assisted breakpoint. Args like \"break\" command.\n\
7815 Like \"break\" except the breakpoint requires hardware support,\n\
7816 some target hardware may not have this support.");
7817 set_cmd_completer (c, location_completer);
7819 c = add_com ("thbreak", class_breakpoint, thbreak_command,
7820 "Set a temporary hardware assisted breakpoint. Args like \"break\" command.\n\
7821 Like \"hbreak\" except the breakpoint is only temporary,\n\
7822 so it will be deleted when hit.");
7823 set_cmd_completer (c, location_completer);
7825 add_prefix_cmd ("enable", class_breakpoint, enable_command,
7826 "Enable some breakpoints.\n\
7827 Give breakpoint numbers (separated by spaces) as arguments.\n\
7828 With no subcommand, breakpoints are enabled until you command otherwise.\n\
7829 This is used to cancel the effect of the \"disable\" command.\n\
7830 With a subcommand you can enable temporarily.",
7831 &enablelist, "enable ", 1, &cmdlist);
7833 add_com ("ab", class_breakpoint, enable_command,
7834 "Enable some breakpoints.\n\
7835 Give breakpoint numbers (separated by spaces) as arguments.\n\
7836 With no subcommand, breakpoints are enabled until you command otherwise.\n\
7837 This is used to cancel the effect of the \"disable\" command.\n\
7838 With a subcommand you can enable temporarily.");
7840 add_com_alias ("en", "enable", class_breakpoint, 1);
7842 add_abbrev_prefix_cmd ("breakpoints", class_breakpoint, enable_command,
7843 "Enable some breakpoints.\n\
7844 Give breakpoint numbers (separated by spaces) as arguments.\n\
7845 This is used to cancel the effect of the \"disable\" command.\n\
7846 May be abbreviated to simply \"enable\".\n",
7847 &enablebreaklist, "enable breakpoints ", 1, &enablelist);
7849 add_cmd ("once", no_class, enable_once_command,
7850 "Enable breakpoints for one hit. Give breakpoint numbers.\n\
7851 If a breakpoint is hit while enabled in this fashion, it becomes disabled.",
7854 add_cmd ("delete", no_class, enable_delete_command,
7855 "Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
7856 If a breakpoint is hit while enabled in this fashion, it is deleted.",
7859 add_cmd ("delete", no_class, enable_delete_command,
7860 "Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
7861 If a breakpoint is hit while enabled in this fashion, it is deleted.",
7864 add_cmd ("once", no_class, enable_once_command,
7865 "Enable breakpoints for one hit. Give breakpoint numbers.\n\
7866 If a breakpoint is hit while enabled in this fashion, it becomes disabled.",
7869 add_prefix_cmd ("disable", class_breakpoint, disable_command,
7870 "Disable some breakpoints.\n\
7871 Arguments are breakpoint numbers with spaces in between.\n\
7872 To disable all breakpoints, give no argument.\n\
7873 A disabled breakpoint is not forgotten, but has no effect until reenabled.",
7874 &disablelist, "disable ", 1, &cmdlist);
7875 add_com_alias ("dis", "disable", class_breakpoint, 1);
7876 add_com_alias ("disa", "disable", class_breakpoint, 1);
7878 add_com ("sb", class_breakpoint, disable_command,
7879 "Disable some breakpoints.\n\
7880 Arguments are breakpoint numbers with spaces in between.\n\
7881 To disable all breakpoints, give no argument.\n\
7882 A disabled breakpoint is not forgotten, but has no effect until reenabled.");
7884 add_cmd ("breakpoints", class_alias, disable_command,
7885 "Disable some breakpoints.\n\
7886 Arguments are breakpoint numbers with spaces in between.\n\
7887 To disable all breakpoints, give no argument.\n\
7888 A disabled breakpoint is not forgotten, but has no effect until reenabled.\n\
7889 This command may be abbreviated \"disable\".",
7892 add_prefix_cmd ("delete", class_breakpoint, delete_command,
7893 "Delete some breakpoints or auto-display expressions.\n\
7894 Arguments are breakpoint numbers with spaces in between.\n\
7895 To delete all breakpoints, give no argument.\n\
7897 Also a prefix command for deletion of other GDB objects.\n\
7898 The \"unset\" command is also an alias for \"delete\".",
7899 &deletelist, "delete ", 1, &cmdlist);
7900 add_com_alias ("d", "delete", class_breakpoint, 1);
7902 add_com ("db", class_breakpoint, delete_command,
7903 "Delete some breakpoints.\n\
7904 Arguments are breakpoint numbers with spaces in between.\n\
7905 To delete all breakpoints, give no argument.\n");
7907 add_cmd ("breakpoints", class_alias, delete_command,
7908 "Delete some breakpoints or auto-display expressions.\n\
7909 Arguments are breakpoint numbers with spaces in between.\n\
7910 To delete all breakpoints, give no argument.\n\
7911 This command may be abbreviated \"delete\".",
7914 add_com ("clear", class_breakpoint, clear_command,
7915 concat ("Clear breakpoint at specified line or function.\n\
7916 Argument may be line number, function name, or \"*\" and an address.\n\
7917 If line number is specified, all breakpoints in that line are cleared.\n\
7918 If function is specified, breakpoints at beginning of function are cleared.\n\
7919 If an address is specified, breakpoints at that address are cleared.\n\n",
7920 "With no argument, clears all breakpoints in the line that the selected frame\n\
7923 See also the \"delete\" command which clears breakpoints by number.", NULL));
7925 c = add_com ("break", class_breakpoint, break_command,
7926 concat ("Set breakpoint at specified line or function.\n\
7927 Argument may be line number, function name, or \"*\" and an address.\n\
7928 If line number is specified, break at start of code for that line.\n\
7929 If function is specified, break at start of code for that function.\n\
7930 If an address is specified, break at that exact address.\n",
7931 "With no arg, uses current execution address of selected stack frame.\n\
7932 This is useful for breaking on return to a stack frame.\n\
7934 Multiple breakpoints at one place are permitted, and useful if conditional.\n\
7936 Do \"help breakpoints\" for info on other commands dealing with breakpoints.", NULL));
7937 set_cmd_completer (c, location_completer);
7939 add_com_alias ("b", "break", class_run, 1);
7940 add_com_alias ("br", "break", class_run, 1);
7941 add_com_alias ("bre", "break", class_run, 1);
7942 add_com_alias ("brea", "break", class_run, 1);
7946 add_com_alias ("ba", "break", class_breakpoint, 1);
7947 add_com_alias ("bu", "ubreak", class_breakpoint, 1);
7952 add_abbrev_prefix_cmd ("stop", class_breakpoint, stop_command,
7953 "Break in function/address or break at a line in the current file.",
7954 &stoplist, "stop ", 1, &cmdlist);
7955 add_cmd ("in", class_breakpoint, stopin_command,
7956 "Break in function or address.\n", &stoplist);
7957 add_cmd ("at", class_breakpoint, stopat_command,
7958 "Break at a line in the current file.\n", &stoplist);
7959 add_com ("status", class_info, breakpoints_info,
7960 concat ("Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
7961 The \"Type\" column indicates one of:\n\
7962 \tbreakpoint - normal breakpoint\n\
7963 \twatchpoint - watchpoint\n\
7964 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
7965 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
7966 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
7967 address and file/line number respectively.\n\n",
7968 "Convenience variable \"$_\" and default examine address for \"x\"\n\
7969 are set to the address of the last breakpoint listed.\n\n\
7970 Convenience variable \"$bpnum\" contains the number of the last\n\
7971 breakpoint set.", NULL));
7974 add_info ("breakpoints", breakpoints_info,
7975 concat ("Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
7976 The \"Type\" column indicates one of:\n\
7977 \tbreakpoint - normal breakpoint\n\
7978 \twatchpoint - watchpoint\n\
7979 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
7980 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
7981 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
7982 address and file/line number respectively.\n\n",
7983 "Convenience variable \"$_\" and default examine address for \"x\"\n\
7984 are set to the address of the last breakpoint listed.\n\n\
7985 Convenience variable \"$bpnum\" contains the number of the last\n\
7986 breakpoint set.", NULL));
7989 add_com ("lb", class_breakpoint, breakpoints_info,
7990 concat ("Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
7991 The \"Type\" column indicates one of:\n\
7992 \tbreakpoint - normal breakpoint\n\
7993 \twatchpoint - watchpoint\n\
7994 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
7995 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
7996 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
7997 address and file/line number respectively.\n\n",
7998 "Convenience variable \"$_\" and default examine address for \"x\"\n\
7999 are set to the address of the last breakpoint listed.\n\n\
8000 Convenience variable \"$bpnum\" contains the number of the last\n\
8001 breakpoint set.", NULL));
8003 add_cmd ("breakpoints", class_maintenance, maintenance_info_breakpoints,
8004 concat ("Status of all breakpoints, or breakpoint number NUMBER.\n\
8005 The \"Type\" column indicates one of:\n\
8006 \tbreakpoint - normal breakpoint\n\
8007 \twatchpoint - watchpoint\n\
8008 \tlongjmp - internal breakpoint used to step through longjmp()\n\
8009 \tlongjmp resume - internal breakpoint at the target of longjmp()\n\
8010 \tuntil - internal breakpoint used by the \"until\" command\n\
8011 \tfinish - internal breakpoint used by the \"finish\" command\n",
8012 "The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
8013 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
8014 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
8015 address and file/line number respectively.\n\n",
8016 "Convenience variable \"$_\" and default examine address for \"x\"\n\
8017 are set to the address of the last breakpoint listed.\n\n\
8018 Convenience variable \"$bpnum\" contains the number of the last\n\
8019 breakpoint set.", NULL),
8020 &maintenanceinfolist);
8022 add_com ("catch", class_breakpoint, catch_command,
8023 "Set catchpoints to catch events.\n\
8024 Raised signals may be caught:\n\
8025 \tcatch signal - all signals\n\
8026 \tcatch signal <signame> - a particular signal\n\
8027 Raised exceptions may be caught:\n\
8028 \tcatch throw - all exceptions, when thrown\n\
8029 \tcatch throw <exceptname> - a particular exception, when thrown\n\
8030 \tcatch catch - all exceptions, when caught\n\
8031 \tcatch catch <exceptname> - a particular exception, when caught\n\
8032 Thread or process events may be caught:\n\
8033 \tcatch thread_start - any threads, just after creation\n\
8034 \tcatch thread_exit - any threads, just before expiration\n\
8035 \tcatch thread_join - any threads, just after joins\n\
8036 Process events may be caught:\n\
8037 \tcatch start - any processes, just after creation\n\
8038 \tcatch exit - any processes, just before expiration\n\
8039 \tcatch fork - calls to fork()\n\
8040 \tcatch vfork - calls to vfork()\n\
8041 \tcatch exec - calls to exec()\n\
8042 Dynamically-linked library events may be caught:\n\
8043 \tcatch load - loads of any library\n\
8044 \tcatch load <libname> - loads of a particular library\n\
8045 \tcatch unload - unloads of any library\n\
8046 \tcatch unload <libname> - unloads of a particular library\n\
8047 The act of your program's execution stopping may also be caught:\n\
8049 C++ exceptions may be caught:\n\
8050 \tcatch throw - all exceptions, when thrown\n\
8051 \tcatch catch - all exceptions, when caught\n\
8053 Do \"help set follow-fork-mode\" for info on debugging your program\n\
8054 after a fork or vfork is caught.\n\n\
8055 Do \"help breakpoints\" for info on other commands dealing with breakpoints.");
8057 add_com ("tcatch", class_breakpoint, tcatch_command,
8058 "Set temporary catchpoints to catch events.\n\
8059 Args like \"catch\" command.\n\
8060 Like \"catch\" except the catchpoint is only temporary,\n\
8061 so it will be deleted when hit. Equivalent to \"catch\" followed\n\
8062 by using \"enable delete\" on the catchpoint number.");
8064 c = add_com ("watch", class_breakpoint, watch_command,
8065 "Set a watchpoint for an expression.\n\
8066 A watchpoint stops execution of your program whenever the value of\n\
8067 an expression changes.");
8068 set_cmd_completer (c, location_completer);
8070 c = add_com ("rwatch", class_breakpoint, rwatch_command,
8071 "Set a read watchpoint for an expression.\n\
8072 A watchpoint stops execution of your program whenever the value of\n\
8073 an expression is read.");
8074 set_cmd_completer (c, location_completer);
8076 c = add_com ("awatch", class_breakpoint, awatch_command,
8077 "Set a watchpoint for an expression.\n\
8078 A watchpoint stops execution of your program whenever the value of\n\
8079 an expression is either read or written.");
8080 set_cmd_completer (c, location_completer);
8082 add_info ("watchpoints", breakpoints_info,
8083 "Synonym for ``info breakpoints''.");
8086 c = add_set_cmd ("can-use-hw-watchpoints", class_support, var_zinteger,
8087 (char *) &can_use_hw_watchpoints,
8088 "Set debugger's willingness to use watchpoint hardware.\n\
8089 If zero, gdb will not use hardware for new watchpoints, even if\n\
8090 such is available. (However, any hardware watchpoints that were\n\
8091 created before setting this to nonzero, will continue to use watchpoint\n\
8094 add_show_from_set (c, &showlist);
8096 can_use_hw_watchpoints = 1;
8098 add_prefix_cmd ("breakpoint", class_maintenance, set_breakpoint_cmd, "\
8099 Breakpoint specific settings\n\
8100 Configure various breakpoint-specific variables such as\n\
8101 pending breakpoint behavior",
8102 &breakpoint_set_cmdlist, "set breakpoint ",
8103 0/*allow-unknown*/, &setlist);
8104 add_prefix_cmd ("breakpoint", class_maintenance, show_breakpoint_cmd, "\
8105 Breakpoint specific settings\n\
8106 Configure various breakpoint-specific variables such as\n\
8107 pending breakpoint behavior",
8108 &breakpoint_show_cmdlist, "show breakpoint ",
8109 0/*allow-unknown*/, &showlist);
8111 add_setshow_auto_boolean_cmd ("pending", no_class, &pending_break_support, "\
8112 Set debugger's behavior regarding pending breakpoints.\n\
8113 If on, an unrecognized breakpoint location will cause gdb to create a\n\
8114 pending breakpoint. If off, an unrecognized breakpoint location results in\n\
8115 an error. If auto, an unrecognized breakpoint location results in a\n\
8116 user-query to see if a pending breakpoint should be created.","\
8117 Show debugger's behavior regarding pending breakpoints.\n\
8118 If on, an unrecognized breakpoint location will cause gdb to create a\n\
8119 pending breakpoint. If off, an unrecognized breakpoint location results in\n\
8120 an error. If auto, an unrecognized breakpoint location results in a\n\
8121 user-query to see if a pending breakpoint should be created.",
8123 &breakpoint_set_cmdlist,
8124 &breakpoint_show_cmdlist);
8126 pending_break_support = AUTO_BOOLEAN_AUTO;