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);
104 static void describe_other_breakpoints (CORE_ADDR, asection *);
106 static void breakpoints_info (char *, int);
108 static void breakpoint_1 (int, int);
110 static bpstat bpstat_alloc (struct breakpoint *, bpstat);
112 static int breakpoint_cond_eval (void *);
114 static void cleanup_executing_breakpoints (void *);
116 static void commands_command (char *, int);
118 static void condition_command (char *, int);
120 static int get_number_trailer (char **, int);
122 static int do_captured_parse_breakpoint (struct ui_out *, void *);
124 void set_breakpoint_count (int);
133 static int remove_breakpoint (struct bp_location *, insertion_state_t);
135 static enum print_stop_action print_it_typical (bpstat);
137 static enum print_stop_action print_bp_stop_message (bpstat bs);
141 enum exception_event_kind kind;
144 args_for_catchpoint_enable;
146 static int watchpoint_check (void *);
148 static int cover_target_enable_exception_callback (void *);
150 static void maintenance_info_breakpoints (char *, int);
152 static void create_longjmp_breakpoint (char *);
154 static void create_overlay_event_breakpoint (char *);
156 static int hw_breakpoint_used_count (void);
158 static int hw_watchpoint_used_count (enum bptype, int *);
160 static void hbreak_command (char *, int);
162 static void thbreak_command (char *, int);
164 static void watch_command_1 (char *, int, int);
166 static void rwatch_command (char *, int);
168 static void awatch_command (char *, int);
170 static void do_enable_breakpoint (struct breakpoint *, enum bpdisp);
172 static void solib_load_unload_1 (char *hookname,
175 char *cond_string, enum bptype bp_kind);
177 static void create_fork_vfork_event_catchpoint (int tempflag,
179 enum bptype bp_kind);
181 static void break_at_finish_at_depth_command_1 (char *arg,
182 int flag, int from_tty);
184 static void break_at_finish_command_1 (char *arg, int flag, int from_tty);
186 static void stop_command (char *arg, int from_tty);
188 static void stopin_command (char *arg, int from_tty);
190 static void stopat_command (char *arg, int from_tty);
192 static char *ep_find_event_name_end (char *arg);
194 static char *ep_parse_optional_if_clause (char **arg);
196 static char *ep_parse_optional_filename (char **arg);
198 static void create_exception_catchpoint (int tempflag, char *cond_string,
199 enum exception_event_kind ex_event,
200 struct symtab_and_line *sal);
202 static void catch_exception_command_1 (enum exception_event_kind ex_event,
203 char *arg, int tempflag, int from_tty);
205 static void tcatch_command (char *arg, int from_tty);
207 static void ep_skip_leading_whitespace (char **s);
209 /* Prototypes for exported functions. */
211 /* If FALSE, gdb will not use hardware support for watchpoints, even
212 if such is available. */
213 static int can_use_hw_watchpoints;
215 /* If AUTO_BOOLEAN_FALSE, gdb will not attempt to create pending breakpoints.
216 If AUTO_BOOLEAN_TRUE, gdb will automatically create pending breakpoints
217 for unrecognized breakpoint locations.
218 If AUTO_BOOLEAN_AUTO, gdb will query when breakpoints are unrecognized. */
219 static enum auto_boolean pending_break_support;
221 void _initialize_breakpoint (void);
223 extern int addressprint; /* Print machine addresses? */
225 /* Are we executing breakpoint commands? */
226 static int executing_breakpoint_commands;
228 /* Are overlay event breakpoints enabled? */
229 static int overlay_events_enabled;
231 /* Walk the following statement or block through all breakpoints.
232 ALL_BREAKPOINTS_SAFE does so even if the statment deletes the current
235 #define ALL_BREAKPOINTS(B) for (B = breakpoint_chain; B; B = B->next)
237 #define ALL_BREAKPOINTS_SAFE(B,TMP) \
238 for (B = breakpoint_chain; \
239 B ? (TMP=B->next, 1): 0; \
242 /* Similar iterators for the low-level breakpoints. */
244 #define ALL_BP_LOCATIONS(B) for (B = bp_location_chain; B; B = B->next)
246 #define ALL_BP_LOCATIONS_SAFE(B,TMP) \
247 for (B = bp_location_chain; \
248 B ? (TMP=B->next, 1): 0; \
251 /* True if breakpoint hit counts should be displayed in breakpoint info. */
253 int show_breakpoint_hit_counts = 1;
255 /* Chains of all breakpoints defined. */
257 struct breakpoint *breakpoint_chain;
259 struct bp_location *bp_location_chain;
261 /* Number of last breakpoint made. */
263 int breakpoint_count;
265 /* Pointer to current exception event record */
266 static struct exception_event_record *current_exception_event;
268 /* Indicator of whether exception catchpoints should be nuked
269 between runs of a program */
270 int exception_catchpoints_are_fragile = 0;
272 /* Indicator of when exception catchpoints set-up should be
273 reinitialized -- e.g. when program is re-run */
274 int exception_support_initialized = 0;
276 /* This function returns a pointer to the string representation of the
277 pathname of the dynamically-linked library that has just been
280 This function must be used only when SOLIB_HAVE_LOAD_EVENT is TRUE,
281 or undefined results are guaranteed.
283 This string's contents are only valid immediately after the
284 inferior has stopped in the dynamic linker hook, and becomes
285 invalid as soon as the inferior is continued. Clients should make
286 a copy of this string if they wish to continue the inferior and
287 then access the string. */
289 #ifndef SOLIB_LOADED_LIBRARY_PATHNAME
290 #define SOLIB_LOADED_LIBRARY_PATHNAME(pid) ""
293 /* This function returns a pointer to the string representation of the
294 pathname of the dynamically-linked library that has just been
297 This function must be used only when SOLIB_HAVE_UNLOAD_EVENT is
298 TRUE, or undefined results are guaranteed.
300 This string's contents are only valid immediately after the
301 inferior has stopped in the dynamic linker hook, and becomes
302 invalid as soon as the inferior is continued. Clients should make
303 a copy of this string if they wish to continue the inferior and
304 then access the string. */
306 #ifndef SOLIB_UNLOADED_LIBRARY_PATHNAME
307 #define SOLIB_UNLOADED_LIBRARY_PATHNAME(pid) ""
310 /* This function is called by the "catch load" command. It allows the
311 debugger to be notified by the dynamic linker when a specified
312 library file (or any library file, if filename is NULL) is loaded. */
314 #ifndef SOLIB_CREATE_CATCH_LOAD_HOOK
315 #define SOLIB_CREATE_CATCH_LOAD_HOOK(pid,tempflag,filename,cond_string) \
316 error ("catch of library loads not yet implemented on this platform")
319 /* This function is called by the "catch unload" command. It allows
320 the debugger to be notified by the dynamic linker when a specified
321 library file (or any library file, if filename is NULL) is
324 #ifndef SOLIB_CREATE_CATCH_UNLOAD_HOOK
325 #define SOLIB_CREATE_CATCH_UNLOAD_HOOK(pid,tempflag,filename,cond_string) \
326 error ("catch of library unloads not yet implemented on this platform")
329 /* Return whether a breakpoint is an active enabled breakpoint. */
331 breakpoint_enabled (struct breakpoint *b)
333 return (b->enable_state == bp_enabled && !b->pending);
336 /* Set breakpoint count to NUM. */
339 set_breakpoint_count (int num)
341 breakpoint_count = num;
342 set_internalvar (lookup_internalvar ("bpnum"),
343 value_from_longest (builtin_type_int, (LONGEST) num));
346 /* Used in run_command to zero the hit count when a new run starts. */
349 clear_breakpoint_hit_counts (void)
351 struct breakpoint *b;
357 /* Default address, symtab and line to put a breakpoint at
358 for "break" command with no arg.
359 if default_breakpoint_valid is zero, the other three are
360 not valid, and "break" with no arg is an error.
362 This set by print_stack_frame, which calls set_default_breakpoint. */
364 int default_breakpoint_valid;
365 CORE_ADDR default_breakpoint_address;
366 struct symtab *default_breakpoint_symtab;
367 int default_breakpoint_line;
369 /* *PP is a string denoting a breakpoint. Get the number of the breakpoint.
370 Advance *PP after the string and any trailing whitespace.
372 Currently the string can either be a number or "$" followed by the name
373 of a convenience variable. Making it an expression wouldn't work well
374 for map_breakpoint_numbers (e.g. "4 + 5 + 6").
376 TRAILER is a character which can be found after the number; most
377 commonly this is `-'. If you don't want a trailer, use \0. */
379 get_number_trailer (char **pp, int trailer)
381 int retval = 0; /* default */
385 /* Empty line means refer to the last breakpoint. */
386 return breakpoint_count;
389 /* Make a copy of the name, so we can null-terminate it
390 to pass to lookup_internalvar(). */
395 while (isalnum (*p) || *p == '_')
397 varname = (char *) alloca (p - start + 1);
398 strncpy (varname, start, p - start);
399 varname[p - start] = '\0';
400 val = value_of_internalvar (lookup_internalvar (varname));
401 if (TYPE_CODE (VALUE_TYPE (val)) == TYPE_CODE_INT)
402 retval = (int) value_as_long (val);
405 printf_filtered ("Convenience variable must have integer value.\n");
413 while (*p >= '0' && *p <= '9')
416 /* There is no number here. (e.g. "cond a == b"). */
418 /* Skip non-numeric token */
419 while (*p && !isspace((int) *p))
421 /* Return zero, which caller must interpret as error. */
427 if (!(isspace (*p) || *p == '\0' || *p == trailer))
429 /* Trailing junk: return 0 and let caller print error msg. */
430 while (!(isspace (*p) || *p == '\0' || *p == trailer))
441 /* Like get_number_trailer, but don't allow a trailer. */
443 get_number (char **pp)
445 return get_number_trailer (pp, '\0');
448 /* Parse a number or a range.
449 * A number will be of the form handled by get_number.
450 * A range will be of the form <number1> - <number2>, and
451 * will represent all the integers between number1 and number2,
454 * While processing a range, this fuction is called iteratively;
455 * At each call it will return the next value in the range.
457 * At the beginning of parsing a range, the char pointer PP will
458 * be advanced past <number1> and left pointing at the '-' token.
459 * Subsequent calls will not advance the pointer until the range
460 * is completed. The call that completes the range will advance
461 * pointer PP past <number2>.
465 get_number_or_range (char **pp)
467 static int last_retval, end_value;
468 static char *end_ptr;
469 static int in_range = 0;
473 /* Default case: pp is pointing either to a solo number,
474 or to the first number of a range. */
475 last_retval = get_number_trailer (pp, '-');
480 /* This is the start of a range (<number1> - <number2>).
481 Skip the '-', parse and remember the second number,
482 and also remember the end of the final token. */
486 while (isspace ((int) *end_ptr))
487 end_ptr++; /* skip white space */
488 end_value = get_number (temp);
489 if (end_value < last_retval)
491 error ("inverted range");
493 else if (end_value == last_retval)
495 /* degenerate range (number1 == number2). Advance the
496 token pointer so that the range will be treated as a
505 error ("negative value");
508 /* pp points to the '-' that betokens a range. All
509 number-parsing has already been done. Return the next
510 integer value (one greater than the saved previous value).
511 Do not advance the token pointer 'pp' until the end of range
514 if (++last_retval == end_value)
516 /* End of range reached; advance token pointer. */
526 /* condition N EXP -- set break condition of breakpoint N to EXP. */
529 condition_command (char *arg, int from_tty)
531 struct breakpoint *b;
536 error_no_arg ("breakpoint number");
539 bnum = get_number (&p);
541 error ("Bad breakpoint argument: '%s'", arg);
544 if (b->number == bnum)
551 if (b->cond_string != NULL)
552 xfree (b->cond_string);
557 b->cond_string = NULL;
559 printf_filtered ("Breakpoint %d now unconditional.\n", bnum);
564 /* I don't know if it matters whether this is the string the user
565 typed in or the decompiled expression. */
566 b->cond_string = savestring (arg, strlen (arg));
569 b->cond = parse_exp_1 (&arg, block_for_pc (b->loc->address), 0);
571 error ("Junk at end of expression");
574 breakpoints_changed ();
575 breakpoint_modify_event (b->number);
579 error ("No breakpoint number %d.", bnum);
583 commands_command (char *arg, int from_tty)
585 struct breakpoint *b;
588 struct command_line *l;
590 /* If we allowed this, we would have problems with when to
591 free the storage, if we change the commands currently
594 if (executing_breakpoint_commands)
595 error ("Can't use the \"commands\" command among a breakpoint's commands.");
598 bnum = get_number (&p);
601 error ("Unexpected extra arguments following breakpoint number.");
604 if (b->number == bnum)
606 char *tmpbuf = xstrprintf ("Type commands for when breakpoint %d is hit, one per line.",
608 struct cleanup *cleanups = make_cleanup (xfree, tmpbuf);
609 l = read_command_lines (tmpbuf, from_tty);
610 do_cleanups (cleanups);
611 free_command_lines (&b->commands);
613 breakpoints_changed ();
614 breakpoint_modify_event (b->number);
617 error ("No breakpoint number %d.", bnum);
620 /* Like target_read_memory() but if breakpoints are inserted, return
621 the shadow contents instead of the breakpoints themselves.
623 Read "memory data" from whatever target or inferior we have.
624 Returns zero if successful, errno value if not. EIO is used
625 for address out of bounds. If breakpoints are inserted, returns
626 shadow contents, not the breakpoints themselves. From breakpoint.c. */
629 read_memory_nobpt (CORE_ADDR memaddr, char *myaddr, unsigned len)
632 struct bp_location *b;
633 CORE_ADDR bp_addr = 0;
636 if (BREAKPOINT_FROM_PC (&bp_addr, &bp_size) == NULL)
637 /* No breakpoints on this machine. */
638 return target_read_memory (memaddr, myaddr, len);
642 if (b->owner->type == bp_none)
643 warning ("reading through apparently deleted breakpoint #%d?",
646 if (b->loc_type != bp_loc_software_breakpoint)
650 /* Addresses and length of the part of the breakpoint that
652 /* XXXX The m68k, sh and h8300 have different local and remote
653 breakpoint values. BREAKPOINT_FROM_PC still manages to
654 correctly determine the breakpoints memory address and size
655 for these targets. */
656 bp_addr = b->address;
658 if (BREAKPOINT_FROM_PC (&bp_addr, &bp_size) == NULL)
663 if (bp_addr + bp_size <= memaddr)
664 /* The breakpoint is entirely before the chunk of memory we
667 if (bp_addr >= memaddr + len)
668 /* The breakpoint is entirely after the chunk of memory we are
671 /* Copy the breakpoint from the shadow contents, and recurse for
672 the things before and after. */
674 /* Offset within shadow_contents. */
677 if (bp_addr < memaddr)
679 /* Only copy the second part of the breakpoint. */
680 bp_size -= memaddr - bp_addr;
681 bptoffset = memaddr - bp_addr;
685 if (bp_addr + bp_size > memaddr + len)
687 /* Only copy the first part of the breakpoint. */
688 bp_size -= (bp_addr + bp_size) - (memaddr + len);
691 memcpy (myaddr + bp_addr - memaddr,
692 b->shadow_contents + bptoffset, bp_size);
694 if (bp_addr > memaddr)
696 /* Copy the section of memory before the breakpoint. */
697 status = read_memory_nobpt (memaddr, myaddr, bp_addr - memaddr);
702 if (bp_addr + bp_size < memaddr + len)
704 /* Copy the section of memory after the breakpoint. */
705 status = read_memory_nobpt (bp_addr + bp_size,
706 myaddr + bp_addr + bp_size - memaddr,
707 memaddr + len - (bp_addr + bp_size));
714 /* Nothing overlaps. Just call read_memory_noerr. */
715 return target_read_memory (memaddr, myaddr, len);
719 /* A wrapper function for inserting catchpoints. */
721 insert_catchpoint (struct ui_out *uo, void *args)
723 struct breakpoint *b = (struct breakpoint *) args;
729 val = target_insert_fork_catchpoint (PIDGET (inferior_ptid));
732 val = target_insert_vfork_catchpoint (PIDGET (inferior_ptid));
735 val = target_insert_exec_catchpoint (PIDGET (inferior_ptid));
738 internal_error (__FILE__, __LINE__, "unknown breakpoint type");
743 throw_exception (RETURN_ERROR);
748 /* Insert a low-level "breakpoint" of some type. BPT is the breakpoint.
749 Any error messages are printed to TMP_ERROR_STREAM; and DISABLED_BREAKS,
750 PROCESS_WARNING, and HW_BREAKPOINT_ERROR are used to report problems.
752 NOTE drow/2003-09-09: This routine could be broken down to an object-style
753 method for each breakpoint or catchpoint type. */
755 insert_bp_location (struct bp_location *bpt,
756 struct ui_file *tmp_error_stream,
757 int *disabled_breaks, int *process_warning,
758 int *hw_breakpoint_error)
762 /* Permanent breakpoints cannot be inserted or removed. Disabled
763 breakpoints should not be inserted. */
764 if (!breakpoint_enabled (bpt->owner))
767 if (bpt->inserted || bpt->duplicate)
770 if (bpt->loc_type == bp_loc_software_breakpoint
771 || bpt->loc_type == bp_loc_hardware_breakpoint)
773 /* First check to see if we have to handle an overlay. */
774 if (overlay_debugging == ovly_off
775 || bpt->section == NULL
776 || !(section_is_overlay (bpt->section)))
778 /* No overlay handling: just set the breakpoint. */
780 if (bpt->loc_type == bp_loc_hardware_breakpoint)
781 val = target_insert_hw_breakpoint (bpt->address,
782 bpt->shadow_contents);
784 val = target_insert_breakpoint (bpt->address,
785 bpt->shadow_contents);
789 /* This breakpoint is in an overlay section.
790 Shall we set a breakpoint at the LMA? */
791 if (!overlay_events_enabled)
793 /* Yes -- overlay event support is not active,
794 so we must try to set a breakpoint at the LMA.
795 This will not work for a hardware breakpoint. */
796 if (bpt->loc_type == bp_loc_hardware_breakpoint)
797 warning ("hardware breakpoint %d not supported in overlay!\n",
801 CORE_ADDR addr = overlay_unmapped_address (bpt->address,
803 /* Set a software (trap) breakpoint at the LMA. */
804 val = target_insert_breakpoint (addr, bpt->shadow_contents);
806 fprintf_unfiltered (tmp_error_stream,
807 "Overlay breakpoint %d failed: in ROM?",
811 /* Shall we set a breakpoint at the VMA? */
812 if (section_is_mapped (bpt->section))
814 /* Yes. This overlay section is mapped into memory. */
815 if (bpt->loc_type == bp_loc_hardware_breakpoint)
816 val = target_insert_hw_breakpoint (bpt->address,
817 bpt->shadow_contents);
819 val = target_insert_breakpoint (bpt->address,
820 bpt->shadow_contents);
824 /* No. This breakpoint will not be inserted.
825 No error, but do not mark the bp as 'inserted'. */
832 /* Can't set the breakpoint. */
833 #if defined (DISABLE_UNSETTABLE_BREAK)
834 if (DISABLE_UNSETTABLE_BREAK (bpt->address))
836 /* See also: disable_breakpoints_in_shlibs. */
838 bpt->owner->enable_state = bp_shlib_disabled;
839 if (!*disabled_breaks)
841 fprintf_unfiltered (tmp_error_stream,
842 "Cannot insert breakpoint %d.\n",
844 fprintf_unfiltered (tmp_error_stream,
845 "Temporarily disabling shared library breakpoints:\n");
847 *disabled_breaks = 1;
848 fprintf_unfiltered (tmp_error_stream,
849 "breakpoint #%d\n", bpt->owner->number);
854 #ifdef ONE_PROCESS_WRITETEXT
855 *process_warning = 1;
857 if (bpt->loc_type == bp_loc_hardware_breakpoint)
859 *hw_breakpoint_error = 1;
860 fprintf_unfiltered (tmp_error_stream,
861 "Cannot insert hardware breakpoint %d.\n",
866 fprintf_unfiltered (tmp_error_stream,
867 "Cannot insert breakpoint %d.\n",
869 fprintf_filtered (tmp_error_stream,
870 "Error accessing memory address ");
871 print_address_numeric (bpt->address, 1, tmp_error_stream);
872 fprintf_filtered (tmp_error_stream, ": %s.\n",
873 safe_strerror (val));
884 else if (bpt->loc_type == bp_loc_hardware_watchpoint
885 /* NOTE drow/2003-09-08: This state only exists for removing
886 watchpoints. It's not clear that it's necessary... */
887 && bpt->owner->disposition != disp_del_at_next_stop)
889 /* FIXME drow/2003-09-08: This code sets multiple hardware watchpoints
890 based on the expression. Ideally this should happen at a higher level,
891 and there should be one bp_location for each computed address we
892 must watch. As soon as a many-to-one mapping is available I'll
895 struct frame_info *saved_frame;
896 int saved_level, within_current_scope;
897 struct value *mark = value_mark ();
900 /* Save the current frame and level so we can restore it after
901 evaluating the watchpoint expression on its own frame. */
902 /* FIXME drow/2003-09-09: It would be nice if evaluate_expression
903 took a frame parameter, so that we didn't have to change the
905 saved_frame = deprecated_selected_frame;
906 saved_level = frame_relative_level (deprecated_selected_frame);
908 /* Determine if the watchpoint is within scope. */
909 if (bpt->owner->exp_valid_block == NULL)
910 within_current_scope = 1;
913 struct frame_info *fi;
914 fi = frame_find_by_id (bpt->owner->watchpoint_frame);
915 within_current_scope = (fi != NULL);
916 if (within_current_scope)
920 if (within_current_scope)
922 /* Evaluate the expression and cut the chain of values
923 produced off from the value chain.
925 Make sure the value returned isn't lazy; we use
926 laziness to determine what memory GDB actually needed
927 in order to compute the value of the expression. */
928 v = evaluate_expression (bpt->owner->exp);
930 value_release_to_mark (mark);
932 bpt->owner->val_chain = v;
935 /* Look at each value on the value chain. */
936 for (; v; v = v->next)
938 /* If it's a memory location, and GDB actually needed
939 its contents to evaluate the expression, then we
941 if (VALUE_LVAL (v) == lval_memory
944 struct type *vtype = check_typedef (VALUE_TYPE (v));
946 /* We only watch structs and arrays if user asked
947 for it explicitly, never if they just happen to
948 appear in the middle of some value chain. */
949 if (v == bpt->owner->val_chain
950 || (TYPE_CODE (vtype) != TYPE_CODE_STRUCT
951 && TYPE_CODE (vtype) != TYPE_CODE_ARRAY))
956 addr = VALUE_ADDRESS (v) + VALUE_OFFSET (v);
957 len = TYPE_LENGTH (VALUE_TYPE (v));
959 if (bpt->owner->type == bp_read_watchpoint)
961 else if (bpt->owner->type == bp_access_watchpoint)
964 val = target_insert_watchpoint (addr, len, type);
967 /* Don't exit the loop, try to insert
968 every value on the value chain. That's
969 because we will be removing all the
970 watches below, and removing a
971 watchpoint we didn't insert could have
979 /* Failure to insert a watchpoint on any memory value in the
980 value chain brings us here. */
983 remove_breakpoint (bpt, mark_uninserted);
984 *hw_breakpoint_error = 1;
985 fprintf_unfiltered (tmp_error_stream,
986 "Could not insert hardware watchpoint %d.\n",
993 printf_filtered ("Hardware watchpoint %d deleted ", bpt->owner->number);
994 printf_filtered ("because the program has left the block \n");
995 printf_filtered ("in which its expression is valid.\n");
996 if (bpt->owner->related_breakpoint)
997 bpt->owner->related_breakpoint->disposition = disp_del_at_next_stop;
998 bpt->owner->disposition = disp_del_at_next_stop;
1001 /* Restore the frame and level. */
1002 if (saved_frame != deprecated_selected_frame
1003 || saved_level != frame_relative_level (deprecated_selected_frame))
1004 select_frame (saved_frame);
1009 else if (ep_is_exception_catchpoint (bpt->owner))
1011 /* FIXME drow/2003-09-09: This code sets both a catchpoint and a
1012 breakpoint. Once again, it would be better if this was represented
1013 as two bp_locations. */
1015 /* If we get here, we must have a callback mechanism for exception
1016 events -- with g++ style embedded label support, we insert
1017 ordinary breakpoints and not catchpoints. */
1018 val = target_insert_breakpoint (bpt->address, bpt->shadow_contents);
1021 /* Couldn't set breakpoint for some reason */
1022 fprintf_unfiltered (tmp_error_stream,
1023 "Cannot insert catchpoint %d; disabling it.\n",
1024 bpt->owner->number);
1025 fprintf_filtered (tmp_error_stream,
1026 "Error accessing memory address ");
1027 print_address_numeric (bpt->address, 1, tmp_error_stream);
1028 fprintf_filtered (tmp_error_stream, ": %s.\n",
1029 safe_strerror (val));
1030 bpt->owner->enable_state = bp_disabled;
1034 /* Bp set, now make sure callbacks are enabled */
1035 /* Format possible error msg */
1036 char *message = xstrprintf ("Error inserting catchpoint %d:\n",
1037 bpt->owner->number);
1038 struct cleanup *cleanups = make_cleanup (xfree, message);
1040 args_for_catchpoint_enable args;
1041 args.kind = bpt->owner->type == bp_catch_catch ?
1042 EX_EVENT_CATCH : EX_EVENT_THROW;
1044 val = catch_errors (cover_target_enable_exception_callback,
1045 &args, message, RETURN_MASK_ALL);
1046 do_cleanups (cleanups);
1047 if (val != 0 && val != -1)
1050 /* Check if something went wrong; val == 0 can be ignored */
1053 /* something went wrong */
1054 fprintf_unfiltered (tmp_error_stream,
1055 "Cannot insert catchpoint %d; disabling it.\n",
1056 bpt->owner->number);
1057 bpt->owner->enable_state = bp_disabled;
1064 else if (bpt->owner->type == bp_catch_fork
1065 || bpt->owner->type == bp_catch_vfork
1066 || bpt->owner->type == bp_catch_exec)
1068 char *prefix = xstrprintf ("warning: inserting catchpoint %d: ",
1069 bpt->owner->number);
1070 struct cleanup *cleanups = make_cleanup (xfree, prefix);
1071 val = catch_exceptions (uiout, insert_catchpoint, bpt->owner, prefix,
1073 do_cleanups (cleanups);
1075 bpt->owner->enable_state = bp_disabled;
1079 /* We've already printed an error message if there was a problem
1080 inserting this catchpoint, and we've disabled the catchpoint,
1081 so just return success. */
1088 /* insert_breakpoints is used when starting or continuing the program.
1089 remove_breakpoints is used when the program stops.
1090 Both return zero if successful,
1091 or an `errno' value if could not write the inferior. */
1094 insert_breakpoints (void)
1096 struct bp_location *b, *temp;
1097 int return_val = 0; /* return success code. */
1099 int disabled_breaks = 0;
1100 int hw_breakpoint_error = 0;
1101 int process_warning = 0;
1103 struct ui_file *tmp_error_stream = mem_fileopen ();
1104 make_cleanup_ui_file_delete (tmp_error_stream);
1106 /* Explicitly mark the warning -- this will only be printed if
1107 there was an error. */
1108 fprintf_unfiltered (tmp_error_stream, "Warning:\n");
1110 ALL_BP_LOCATIONS_SAFE (b, temp)
1112 /* Permanent breakpoints cannot be inserted or removed. Disabled
1113 breakpoints should not be inserted. */
1114 if (!breakpoint_enabled (b->owner))
1117 /* FIXME drow/2003-10-07: This code should be pushed elsewhere when
1118 hardware watchpoints are split into multiple loc breakpoints. */
1119 if ((b->loc_type == bp_loc_hardware_watchpoint
1120 || b->owner->type == bp_watchpoint) && !b->owner->val)
1123 val = evaluate_expression (b->owner->exp);
1124 release_value (val);
1125 if (VALUE_LAZY (val))
1126 value_fetch_lazy (val);
1127 b->owner->val = val;
1130 val = insert_bp_location (b, tmp_error_stream,
1131 &disabled_breaks, &process_warning,
1132 &hw_breakpoint_error);
1139 /* If a hardware breakpoint or watchpoint was inserted, add a
1140 message about possibly exhausted resources. */
1141 if (hw_breakpoint_error)
1143 fprintf_unfiltered (tmp_error_stream,
1144 "Could not insert hardware breakpoints:\n\
1145 You may have requested too many hardware breakpoints/watchpoints.\n");
1147 #ifdef ONE_PROCESS_WRITETEXT
1148 if (process_warning)
1149 fprintf_unfiltered (tmp_error_stream,
1150 "The same program may be running in another process.");
1152 target_terminal_ours_for_output ();
1153 error_stream (tmp_error_stream);
1159 remove_breakpoints (void)
1161 struct bp_location *b;
1164 ALL_BP_LOCATIONS (b)
1168 val = remove_breakpoint (b, mark_uninserted);
1177 remove_hw_watchpoints (void)
1179 struct bp_location *b;
1182 ALL_BP_LOCATIONS (b)
1184 if (b->inserted && b->loc_type == bp_loc_hardware_watchpoint)
1186 val = remove_breakpoint (b, mark_uninserted);
1195 reattach_breakpoints (int pid)
1197 struct bp_location *b;
1199 struct cleanup *old_chain = save_inferior_ptid ();
1201 /* Set inferior_ptid; remove_breakpoint uses this global. */
1202 inferior_ptid = pid_to_ptid (pid);
1203 ALL_BP_LOCATIONS (b)
1207 remove_breakpoint (b, mark_inserted);
1208 if (b->loc_type == bp_loc_hardware_breakpoint)
1209 val = target_insert_hw_breakpoint (b->address, b->shadow_contents);
1211 val = target_insert_breakpoint (b->address, b->shadow_contents);
1212 /* FIXME drow/2003-10-07: This doesn't handle any other kinds of
1213 breakpoints. It's wrong for watchpoints, for example. */
1216 do_cleanups (old_chain);
1221 do_cleanups (old_chain);
1226 update_breakpoints_after_exec (void)
1228 struct breakpoint *b;
1229 struct breakpoint *temp;
1231 /* Doing this first prevents the badness of having delete_breakpoint()
1232 write a breakpoint's current "shadow contents" to lift the bp. That
1233 shadow is NOT valid after an exec()! */
1234 mark_breakpoints_out ();
1236 ALL_BREAKPOINTS_SAFE (b, temp)
1238 /* Solib breakpoints must be explicitly reset after an exec(). */
1239 if (b->type == bp_shlib_event)
1241 delete_breakpoint (b);
1245 /* Thread event breakpoints must be set anew after an exec(),
1246 as must overlay event breakpoints. */
1247 if (b->type == bp_thread_event || b->type == bp_overlay_event)
1249 delete_breakpoint (b);
1253 /* Step-resume breakpoints are meaningless after an exec(). */
1254 if (b->type == bp_step_resume)
1256 delete_breakpoint (b);
1260 /* Ditto the sigtramp handler breakpoints. */
1261 if (b->type == bp_through_sigtramp)
1263 delete_breakpoint (b);
1267 /* Ditto the exception-handling catchpoints. */
1268 if ((b->type == bp_catch_catch) || (b->type == bp_catch_throw))
1270 delete_breakpoint (b);
1274 /* Don't delete an exec catchpoint, because else the inferior
1275 won't stop when it ought!
1277 Similarly, we probably ought to keep vfork catchpoints, 'cause
1278 on this target, we may not be able to stop when the vfork is
1279 seen, but only when the subsequent exec is seen. (And because
1280 deleting fork catchpoints here but not vfork catchpoints will
1281 seem mysterious to users, keep those too.)
1283 ??rehrauer: Let's hope that merely clearing out this catchpoint's
1284 target address field, if any, is sufficient to have it be reset
1285 automagically. Certainly on HP-UX that's true.
1287 Jim Blandy <jimb@redhat.com>: Actually, zero is a perfectly
1288 valid code address on some platforms (like the mn10300
1289 simulators). We shouldn't assign any special interpretation to
1290 a breakpoint with a zero address. And in fact, GDB doesn't ---
1291 I can't see what that comment above is talking about. As far
1292 as I can tell, setting the address of a
1293 bp_catch_exec/bp_catch_vfork/bp_catch_fork breakpoint to zero
1294 is meaningless, since those are implemented with HP-UX kernel
1295 hackery, not by storing breakpoint instructions somewhere. */
1296 if ((b->type == bp_catch_exec) ||
1297 (b->type == bp_catch_vfork) ||
1298 (b->type == bp_catch_fork))
1300 b->loc->address = (CORE_ADDR) NULL;
1304 /* bp_finish is a special case. The only way we ought to be able
1305 to see one of these when an exec() has happened, is if the user
1306 caught a vfork, and then said "finish". Ordinarily a finish just
1307 carries them to the call-site of the current callee, by setting
1308 a temporary bp there and resuming. But in this case, the finish
1309 will carry them entirely through the vfork & exec.
1311 We don't want to allow a bp_finish to remain inserted now. But
1312 we can't safely delete it, 'cause finish_command has a handle to
1313 the bp on a bpstat, and will later want to delete it. There's a
1314 chance (and I've seen it happen) that if we delete the bp_finish
1315 here, that its storage will get reused by the time finish_command
1316 gets 'round to deleting the "use to be a bp_finish" breakpoint.
1317 We really must allow finish_command to delete a bp_finish.
1319 In the absense of a general solution for the "how do we know
1320 it's safe to delete something others may have handles to?"
1321 problem, what we'll do here is just uninsert the bp_finish, and
1322 let finish_command delete it.
1324 (We know the bp_finish is "doomed" in the sense that it's
1325 momentary, and will be deleted as soon as finish_command sees
1326 the inferior stopped. So it doesn't matter that the bp's
1327 address is probably bogus in the new a.out, unlike e.g., the
1328 solib breakpoints.) */
1330 if (b->type == bp_finish)
1335 /* Without a symbolic address, we have little hope of the
1336 pre-exec() address meaning the same thing in the post-exec()
1338 if (b->addr_string == NULL)
1340 delete_breakpoint (b);
1344 /* If this breakpoint has survived the above battery of checks, then
1345 it must have a symbolic address. Be sure that it gets reevaluated
1346 to a target address, rather than reusing the old evaluation.
1348 Jim Blandy <jimb@redhat.com>: As explained above in the comment
1349 for bp_catch_exec and friends, I'm pretty sure this is entirely
1350 unnecessary. A call to breakpoint_re_set_one always recomputes
1351 the breakpoint's address from scratch, or deletes it if it can't.
1352 So I think this assignment could be deleted without effect. */
1353 b->loc->address = (CORE_ADDR) NULL;
1355 /* FIXME what about longjmp breakpoints? Re-create them here? */
1356 create_overlay_event_breakpoint ("_ovly_debug_event");
1360 detach_breakpoints (int pid)
1362 struct bp_location *b;
1364 struct cleanup *old_chain = save_inferior_ptid ();
1366 if (pid == PIDGET (inferior_ptid))
1367 error ("Cannot detach breakpoints of inferior_ptid");
1369 /* Set inferior_ptid; remove_breakpoint uses this global. */
1370 inferior_ptid = pid_to_ptid (pid);
1371 ALL_BP_LOCATIONS (b)
1375 val = remove_breakpoint (b, mark_inserted);
1378 do_cleanups (old_chain);
1383 do_cleanups (old_chain);
1388 remove_breakpoint (struct bp_location *b, insertion_state_t is)
1392 if (b->owner->enable_state == bp_permanent)
1393 /* Permanent breakpoints cannot be inserted or removed. */
1396 if (b->owner->type == bp_none)
1397 warning ("attempted to remove apparently deleted breakpoint #%d?",
1400 if (b->loc_type == bp_loc_software_breakpoint
1401 || b->loc_type == bp_loc_hardware_breakpoint)
1403 /* "Normal" instruction breakpoint: either the standard
1404 trap-instruction bp (bp_breakpoint), or a
1405 bp_hardware_breakpoint. */
1407 /* First check to see if we have to handle an overlay. */
1408 if (overlay_debugging == ovly_off
1409 || b->section == NULL
1410 || !(section_is_overlay (b->section)))
1412 /* No overlay handling: just remove the breakpoint. */
1414 if (b->loc_type == bp_loc_hardware_breakpoint)
1415 val = target_remove_hw_breakpoint (b->address,
1416 b->shadow_contents);
1418 val = target_remove_breakpoint (b->address, b->shadow_contents);
1422 /* This breakpoint is in an overlay section.
1423 Did we set a breakpoint at the LMA? */
1424 if (!overlay_events_enabled)
1426 /* Yes -- overlay event support is not active, so we
1427 should have set a breakpoint at the LMA. Remove it.
1429 CORE_ADDR addr = overlay_unmapped_address (b->address,
1431 /* Ignore any failures: if the LMA is in ROM, we will
1432 have already warned when we failed to insert it. */
1433 if (b->loc_type == bp_loc_hardware_breakpoint)
1434 target_remove_hw_breakpoint (addr, b->shadow_contents);
1436 target_remove_breakpoint (addr, b->shadow_contents);
1438 /* Did we set a breakpoint at the VMA?
1439 If so, we will have marked the breakpoint 'inserted'. */
1442 /* Yes -- remove it. Previously we did not bother to
1443 remove the breakpoint if the section had been
1444 unmapped, but let's not rely on that being safe. We
1445 don't know what the overlay manager might do. */
1446 if (b->loc_type == bp_loc_hardware_breakpoint)
1447 val = target_remove_hw_breakpoint (b->address,
1448 b->shadow_contents);
1450 val = target_remove_breakpoint (b->address,
1451 b->shadow_contents);
1455 /* No -- not inserted, so no need to remove. No error. */
1461 b->inserted = (is == mark_inserted);
1463 else if (b->loc_type == bp_loc_hardware_watchpoint
1464 && breakpoint_enabled (b->owner)
1470 b->inserted = (is == mark_inserted);
1471 /* Walk down the saved value chain. */
1472 for (v = b->owner->val_chain; v; v = v->next)
1474 /* For each memory reference remove the watchpoint
1476 if (VALUE_LVAL (v) == lval_memory
1477 && ! VALUE_LAZY (v))
1479 struct type *vtype = check_typedef (VALUE_TYPE (v));
1481 if (v == b->owner->val_chain
1482 || (TYPE_CODE (vtype) != TYPE_CODE_STRUCT
1483 && TYPE_CODE (vtype) != TYPE_CODE_ARRAY))
1488 addr = VALUE_ADDRESS (v) + VALUE_OFFSET (v);
1489 len = TYPE_LENGTH (VALUE_TYPE (v));
1491 if (b->owner->type == bp_read_watchpoint)
1493 else if (b->owner->type == bp_access_watchpoint)
1496 val = target_remove_watchpoint (addr, len, type);
1503 /* Failure to remove any of the hardware watchpoints comes here. */
1504 if ((is == mark_uninserted) && (b->inserted))
1505 warning ("Could not remove hardware watchpoint %d.",
1508 /* Free the saved value chain. We will construct a new one
1509 the next time the watchpoint is inserted. */
1510 for (v = b->owner->val_chain; v; v = n)
1515 b->owner->val_chain = NULL;
1517 else if ((b->owner->type == bp_catch_fork ||
1518 b->owner->type == bp_catch_vfork ||
1519 b->owner->type == bp_catch_exec)
1520 && breakpoint_enabled (b->owner)
1524 switch (b->owner->type)
1527 val = target_remove_fork_catchpoint (PIDGET (inferior_ptid));
1529 case bp_catch_vfork:
1530 val = target_remove_vfork_catchpoint (PIDGET (inferior_ptid));
1533 val = target_remove_exec_catchpoint (PIDGET (inferior_ptid));
1536 warning ("Internal error, %s line %d.", __FILE__, __LINE__);
1541 b->inserted = (is == mark_inserted);
1543 else if ((b->owner->type == bp_catch_catch ||
1544 b->owner->type == bp_catch_throw)
1545 && breakpoint_enabled (b->owner)
1549 val = target_remove_breakpoint (b->address, b->shadow_contents);
1552 b->inserted = (is == mark_inserted);
1554 else if (ep_is_exception_catchpoint (b->owner)
1555 && b->inserted /* sometimes previous insert doesn't happen */
1556 && breakpoint_enabled (b->owner)
1560 val = target_remove_breakpoint (b->address, b->shadow_contents);
1564 b->inserted = (is == mark_inserted);
1570 /* Clear the "inserted" flag in all breakpoints. */
1573 mark_breakpoints_out (void)
1575 struct bp_location *bpt;
1577 ALL_BP_LOCATIONS (bpt)
1581 /* Clear the "inserted" flag in all breakpoints and delete any
1582 breakpoints which should go away between runs of the program.
1584 Plus other such housekeeping that has to be done for breakpoints
1587 Note: this function gets called at the end of a run (by
1588 generic_mourn_inferior) and when a run begins (by
1589 init_wait_for_inferior). */
1594 breakpoint_init_inferior (enum inf_context context)
1596 struct breakpoint *b, *temp;
1597 struct bp_location *bpt;
1598 static int warning_needed = 0;
1600 ALL_BP_LOCATIONS (bpt)
1603 ALL_BREAKPOINTS_SAFE (b, temp)
1608 case bp_watchpoint_scope:
1610 /* If the call dummy breakpoint is at the entry point it will
1611 cause problems when the inferior is rerun, so we better
1614 Also get rid of scope breakpoints. */
1615 delete_breakpoint (b);
1619 case bp_hardware_watchpoint:
1620 case bp_read_watchpoint:
1621 case bp_access_watchpoint:
1623 /* Likewise for watchpoints on local expressions. */
1624 if (b->exp_valid_block != NULL)
1625 delete_breakpoint (b);
1626 if (context == inf_starting)
1628 /* Reset val field to force reread of starting value
1629 in insert_breakpoints. */
1631 value_free (b->val);
1636 /* Likewise for exception catchpoints in dynamic-linked
1637 executables where required */
1638 if (ep_is_exception_catchpoint (b) &&
1639 exception_catchpoints_are_fragile)
1642 delete_breakpoint (b);
1648 if (exception_catchpoints_are_fragile)
1649 exception_support_initialized = 0;
1651 /* Don't issue the warning unless it's really needed... */
1652 if (warning_needed && (context != inf_exited))
1654 warning ("Exception catchpoints from last run were deleted.");
1655 warning ("You must reinsert them explicitly.");
1660 /* breakpoint_here_p (PC) returns non-zero if an enabled breakpoint
1661 exists at PC. It returns ordinary_breakpoint_here if it's an
1662 ordinary breakpoint, or permanent_breakpoint_here if it's a
1663 permanent breakpoint.
1664 - When continuing from a location with an ordinary breakpoint, we
1665 actually single step once before calling insert_breakpoints.
1666 - When continuing from a localion with a permanent breakpoint, we
1667 need to use the `SKIP_PERMANENT_BREAKPOINT' macro, provided by
1668 the target, to advance the PC past the breakpoint. */
1670 enum breakpoint_here
1671 breakpoint_here_p (CORE_ADDR pc)
1673 struct bp_location *bpt;
1674 int any_breakpoint_here = 0;
1676 ALL_BP_LOCATIONS (bpt)
1678 if (bpt->loc_type != bp_loc_software_breakpoint
1679 && bpt->loc_type != bp_loc_hardware_breakpoint)
1682 if ((breakpoint_enabled (bpt->owner)
1683 || bpt->owner->enable_state == bp_permanent)
1684 && bpt->address == pc) /* bp is enabled and matches pc */
1686 if (overlay_debugging
1687 && section_is_overlay (bpt->section)
1688 && !section_is_mapped (bpt->section))
1689 continue; /* unmapped overlay -- can't be a match */
1690 else if (bpt->owner->enable_state == bp_permanent)
1691 return permanent_breakpoint_here;
1693 any_breakpoint_here = 1;
1697 return any_breakpoint_here ? ordinary_breakpoint_here : 0;
1701 /* breakpoint_inserted_here_p (PC) is just like breakpoint_here_p(),
1702 but it only returns true if there is actually a breakpoint inserted
1706 breakpoint_inserted_here_p (CORE_ADDR pc)
1708 struct bp_location *bpt;
1710 ALL_BP_LOCATIONS (bpt)
1712 if (bpt->loc_type != bp_loc_software_breakpoint
1713 && bpt->loc_type != bp_loc_hardware_breakpoint)
1717 && bpt->address == pc) /* bp is inserted and matches pc */
1719 if (overlay_debugging
1720 && section_is_overlay (bpt->section)
1721 && !section_is_mapped (bpt->section))
1722 continue; /* unmapped overlay -- can't be a match */
1731 /* This function returns non-zero iff there is a software breakpoint
1735 software_breakpoint_inserted_here_p (CORE_ADDR pc)
1737 struct bp_location *bpt;
1738 int any_breakpoint_here = 0;
1740 ALL_BP_LOCATIONS (bpt)
1742 if (bpt->loc_type != bp_loc_software_breakpoint)
1745 if ((breakpoint_enabled (bpt->owner)
1746 || bpt->owner->enable_state == bp_permanent)
1748 && bpt->address == pc) /* bp is enabled and matches pc */
1750 if (overlay_debugging
1751 && section_is_overlay (bpt->section)
1752 && !section_is_mapped (bpt->section))
1753 continue; /* unmapped overlay -- can't be a match */
1762 /* Return nonzero if FRAME is a dummy frame. We can't use
1763 DEPRECATED_PC_IN_CALL_DUMMY because figuring out the saved SP would
1764 take too much time, at least using frame_register() on the 68k.
1765 This means that for this function to work right a port must use the
1766 bp_call_dummy breakpoint. */
1769 deprecated_frame_in_dummy (struct frame_info *frame)
1771 struct breakpoint *b;
1773 /* This function is used by two files: get_frame_type(), after first
1774 checking that !DEPRECATED_USE_GENERIC_DUMMY_FRAMES; and
1775 sparc-tdep.c, which doesn't yet use generic dummy frames anyway. */
1776 gdb_assert (!DEPRECATED_USE_GENERIC_DUMMY_FRAMES);
1780 if (b->type == bp_call_dummy
1781 && frame_id_eq (b->frame_id, get_frame_id (frame))
1782 /* We need to check the PC as well as the frame on the sparc,
1783 for signals.exp in the testsuite. */
1784 && (get_frame_pc (frame)
1786 - DEPRECATED_SIZEOF_CALL_DUMMY_WORDS / sizeof (LONGEST) * DEPRECATED_REGISTER_SIZE))
1787 && get_frame_pc (frame) <= b->loc->address)
1793 /* breakpoint_thread_match (PC, PTID) returns true if the breakpoint at
1794 PC is valid for process/thread PTID. */
1797 breakpoint_thread_match (CORE_ADDR pc, ptid_t ptid)
1799 struct bp_location *bpt;
1802 thread = pid_to_thread_id (ptid);
1804 ALL_BP_LOCATIONS (bpt)
1806 if (bpt->loc_type != bp_loc_software_breakpoint
1807 && bpt->loc_type != bp_loc_hardware_breakpoint)
1810 if ((breakpoint_enabled (bpt->owner)
1811 || bpt->owner->enable_state == bp_permanent)
1812 && bpt->address == pc
1813 && (bpt->owner->thread == -1 || bpt->owner->thread == thread))
1815 if (overlay_debugging
1816 && section_is_overlay (bpt->section)
1817 && !section_is_mapped (bpt->section))
1818 continue; /* unmapped overlay -- can't be a match */
1828 /* bpstat stuff. External routines' interfaces are documented
1832 ep_is_catchpoint (struct breakpoint *ep)
1835 (ep->type == bp_catch_load)
1836 || (ep->type == bp_catch_unload)
1837 || (ep->type == bp_catch_fork)
1838 || (ep->type == bp_catch_vfork)
1839 || (ep->type == bp_catch_exec)
1840 || (ep->type == bp_catch_catch)
1841 || (ep->type == bp_catch_throw);
1843 /* ??rehrauer: Add more kinds here, as are implemented... */
1847 ep_is_shlib_catchpoint (struct breakpoint *ep)
1850 (ep->type == bp_catch_load)
1851 || (ep->type == bp_catch_unload);
1855 ep_is_exception_catchpoint (struct breakpoint *ep)
1858 (ep->type == bp_catch_catch)
1859 || (ep->type == bp_catch_throw);
1862 /* Clear a bpstat so that it says we are not at any breakpoint.
1863 Also free any storage that is part of a bpstat. */
1866 bpstat_clear (bpstat *bsp)
1877 if (p->old_val != NULL)
1878 value_free (p->old_val);
1879 free_command_lines (&p->commands);
1886 /* Return a copy of a bpstat. Like "bs1 = bs2" but all storage that
1887 is part of the bpstat is copied as well. */
1890 bpstat_copy (bpstat bs)
1894 bpstat retval = NULL;
1899 for (; bs != NULL; bs = bs->next)
1901 tmp = (bpstat) xmalloc (sizeof (*tmp));
1902 memcpy (tmp, bs, sizeof (*tmp));
1903 if (bs->commands != NULL)
1904 tmp->commands = copy_command_lines (bs->commands);
1905 if (bs->old_val != NULL)
1906 tmp->old_val = value_copy (bs->old_val);
1909 /* This is the first thing in the chain. */
1919 /* Find the bpstat associated with this breakpoint */
1922 bpstat_find_breakpoint (bpstat bsp, struct breakpoint *breakpoint)
1927 for (; bsp != NULL; bsp = bsp->next)
1929 if (bsp->breakpoint_at == breakpoint)
1935 /* Find a step_resume breakpoint associated with this bpstat.
1936 (If there are multiple step_resume bp's on the list, this function
1937 will arbitrarily pick one.)
1939 It is an error to use this function if BPSTAT doesn't contain a
1940 step_resume breakpoint.
1942 See wait_for_inferior's use of this function. */
1944 bpstat_find_step_resume_breakpoint (bpstat bsp)
1949 error ("Internal error (bpstat_find_step_resume_breakpoint)");
1951 current_thread = pid_to_thread_id (inferior_ptid);
1953 for (; bsp != NULL; bsp = bsp->next)
1955 if ((bsp->breakpoint_at != NULL) &&
1956 (bsp->breakpoint_at->type == bp_step_resume) &&
1957 (bsp->breakpoint_at->thread == current_thread ||
1958 bsp->breakpoint_at->thread == -1))
1959 return bsp->breakpoint_at;
1962 error ("Internal error (no step_resume breakpoint found)");
1966 /* Return the breakpoint number of the first breakpoint we are stopped
1967 at. *BSP upon return is a bpstat which points to the remaining
1968 breakpoints stopped at (but which is not guaranteed to be good for
1969 anything but further calls to bpstat_num).
1970 Return 0 if passed a bpstat which does not indicate any breakpoints. */
1973 bpstat_num (bpstat *bsp)
1975 struct breakpoint *b;
1978 return 0; /* No more breakpoint values */
1981 b = (*bsp)->breakpoint_at;
1982 *bsp = (*bsp)->next;
1984 return -1; /* breakpoint that's been deleted since */
1986 return b->number; /* We have its number */
1990 /* Modify BS so that the actions will not be performed. */
1993 bpstat_clear_actions (bpstat bs)
1995 for (; bs != NULL; bs = bs->next)
1997 free_command_lines (&bs->commands);
1998 if (bs->old_val != NULL)
2000 value_free (bs->old_val);
2006 /* Stub for cleaning up our state if we error-out of a breakpoint command */
2008 cleanup_executing_breakpoints (void *ignore)
2010 executing_breakpoint_commands = 0;
2013 /* Execute all the commands associated with all the breakpoints at this
2014 location. Any of these commands could cause the process to proceed
2015 beyond this point, etc. We look out for such changes by checking
2016 the global "breakpoint_proceeded" after each command. */
2019 bpstat_do_actions (bpstat *bsp)
2022 struct cleanup *old_chain;
2024 /* Avoid endless recursion if a `source' command is contained
2026 if (executing_breakpoint_commands)
2029 executing_breakpoint_commands = 1;
2030 old_chain = make_cleanup (cleanup_executing_breakpoints, 0);
2033 /* Note that (as of this writing), our callers all appear to
2034 be passing us the address of global stop_bpstat. And, if
2035 our calls to execute_control_command cause the inferior to
2036 proceed, that global (and hence, *bsp) will change.
2038 We must be careful to not touch *bsp unless the inferior
2039 has not proceeded. */
2041 /* This pointer will iterate over the list of bpstat's. */
2044 breakpoint_proceeded = 0;
2045 for (; bs != NULL; bs = bs->next)
2047 struct command_line *cmd;
2048 struct cleanup *this_cmd_tree_chain;
2050 /* Take ownership of the BSP's command tree, if it has one.
2052 The command tree could legitimately contain commands like
2053 'step' and 'next', which call clear_proceed_status, which
2054 frees stop_bpstat's command tree. To make sure this doesn't
2055 free the tree we're executing out from under us, we need to
2056 take ownership of the tree ourselves. Since a given bpstat's
2057 commands are only executed once, we don't need to copy it; we
2058 can clear the pointer in the bpstat, and make sure we free
2059 the tree when we're done. */
2062 this_cmd_tree_chain = make_cleanup_free_command_lines (&cmd);
2066 execute_control_command (cmd);
2068 if (breakpoint_proceeded)
2074 /* We can free this command tree now. */
2075 do_cleanups (this_cmd_tree_chain);
2077 if (breakpoint_proceeded)
2078 /* The inferior is proceeded by the command; bomb out now.
2079 The bpstat chain has been blown away by wait_for_inferior.
2080 But since execution has stopped again, there is a new bpstat
2081 to look at, so start over. */
2084 do_cleanups (old_chain);
2087 /* This is the normal print function for a bpstat. In the future,
2088 much of this logic could (should?) be moved to bpstat_stop_status,
2089 by having it set different print_it values.
2091 Current scheme: When we stop, bpstat_print() is called. It loops
2092 through the bpstat list of things causing this stop, calling the
2093 print_bp_stop_message function on each one. The behavior of the
2094 print_bp_stop_message function depends on the print_it field of
2095 bpstat. If such field so indicates, call this function here.
2097 Return values from this routine (ultimately used by bpstat_print()
2098 and normal_stop() to decide what to do):
2099 PRINT_NOTHING: Means we already printed all we needed to print,
2100 don't print anything else.
2101 PRINT_SRC_ONLY: Means we printed something, and we do *not* desire
2102 that something to be followed by a location.
2103 PRINT_SCR_AND_LOC: Means we printed something, and we *do* desire
2104 that something to be followed by a location.
2105 PRINT_UNKNOWN: Means we printed nothing or we need to do some more
2108 static enum print_stop_action
2109 print_it_typical (bpstat bs)
2111 struct cleanup *old_chain, *ui_out_chain;
2112 struct ui_stream *stb;
2113 stb = ui_out_stream_new (uiout);
2114 old_chain = make_cleanup_ui_out_stream_delete (stb);
2115 /* bs->breakpoint_at can be NULL if it was a momentary breakpoint
2116 which has since been deleted. */
2117 if (bs->breakpoint_at == NULL)
2118 return PRINT_UNKNOWN;
2120 switch (bs->breakpoint_at->type)
2123 case bp_hardware_breakpoint:
2124 if (bs->breakpoint_at->loc->address != bs->breakpoint_at->loc->requested_address)
2125 breakpoint_adjustment_warning (bs->breakpoint_at->loc->requested_address,
2126 bs->breakpoint_at->loc->address,
2127 bs->breakpoint_at->number, 1);
2128 annotate_breakpoint (bs->breakpoint_at->number);
2129 ui_out_text (uiout, "\nBreakpoint ");
2130 if (ui_out_is_mi_like_p (uiout))
2131 ui_out_field_string (uiout, "reason", "breakpoint-hit");
2132 ui_out_field_int (uiout, "bkptno", bs->breakpoint_at->number);
2133 ui_out_text (uiout, ", ");
2134 return PRINT_SRC_AND_LOC;
2137 case bp_shlib_event:
2138 /* Did we stop because the user set the stop_on_solib_events
2139 variable? (If so, we report this as a generic, "Stopped due
2140 to shlib event" message.) */
2141 printf_filtered ("Stopped due to shared library event\n");
2142 return PRINT_NOTHING;
2145 case bp_thread_event:
2146 /* Not sure how we will get here.
2147 GDB should not stop for these breakpoints. */
2148 printf_filtered ("Thread Event Breakpoint: gdb should not stop!\n");
2149 return PRINT_NOTHING;
2152 case bp_overlay_event:
2153 /* By analogy with the thread event, GDB should not stop for these. */
2154 printf_filtered ("Overlay Event Breakpoint: gdb should not stop!\n");
2155 return PRINT_NOTHING;
2159 annotate_catchpoint (bs->breakpoint_at->number);
2160 printf_filtered ("\nCatchpoint %d (", bs->breakpoint_at->number);
2161 printf_filtered ("loaded");
2162 printf_filtered (" %s), ", bs->breakpoint_at->triggered_dll_pathname);
2163 return PRINT_SRC_AND_LOC;
2166 case bp_catch_unload:
2167 annotate_catchpoint (bs->breakpoint_at->number);
2168 printf_filtered ("\nCatchpoint %d (", bs->breakpoint_at->number);
2169 printf_filtered ("unloaded");
2170 printf_filtered (" %s), ", bs->breakpoint_at->triggered_dll_pathname);
2171 return PRINT_SRC_AND_LOC;
2175 annotate_catchpoint (bs->breakpoint_at->number);
2176 printf_filtered ("\nCatchpoint %d (", bs->breakpoint_at->number);
2177 printf_filtered ("forked");
2178 printf_filtered (" process %d), ",
2179 bs->breakpoint_at->forked_inferior_pid);
2180 return PRINT_SRC_AND_LOC;
2183 case bp_catch_vfork:
2184 annotate_catchpoint (bs->breakpoint_at->number);
2185 printf_filtered ("\nCatchpoint %d (", bs->breakpoint_at->number);
2186 printf_filtered ("vforked");
2187 printf_filtered (" process %d), ",
2188 bs->breakpoint_at->forked_inferior_pid);
2189 return PRINT_SRC_AND_LOC;
2193 annotate_catchpoint (bs->breakpoint_at->number);
2194 printf_filtered ("\nCatchpoint %d (exec'd %s), ",
2195 bs->breakpoint_at->number,
2196 bs->breakpoint_at->exec_pathname);
2197 return PRINT_SRC_AND_LOC;
2200 case bp_catch_catch:
2201 if (current_exception_event &&
2202 (CURRENT_EXCEPTION_KIND == EX_EVENT_CATCH))
2204 annotate_catchpoint (bs->breakpoint_at->number);
2205 printf_filtered ("\nCatchpoint %d (exception caught), ",
2206 bs->breakpoint_at->number);
2207 printf_filtered ("throw location ");
2208 if (CURRENT_EXCEPTION_THROW_PC && CURRENT_EXCEPTION_THROW_LINE)
2209 printf_filtered ("%s:%d",
2210 CURRENT_EXCEPTION_THROW_FILE,
2211 CURRENT_EXCEPTION_THROW_LINE);
2213 printf_filtered ("unknown");
2215 printf_filtered (", catch location ");
2216 if (CURRENT_EXCEPTION_CATCH_PC && CURRENT_EXCEPTION_CATCH_LINE)
2217 printf_filtered ("%s:%d",
2218 CURRENT_EXCEPTION_CATCH_FILE,
2219 CURRENT_EXCEPTION_CATCH_LINE);
2221 printf_filtered ("unknown");
2223 printf_filtered ("\n");
2224 /* don't bother to print location frame info */
2225 return PRINT_SRC_ONLY;
2229 /* really throw, some other bpstat will handle it */
2230 return PRINT_UNKNOWN;
2234 case bp_catch_throw:
2235 if (current_exception_event &&
2236 (CURRENT_EXCEPTION_KIND == EX_EVENT_THROW))
2238 annotate_catchpoint (bs->breakpoint_at->number);
2239 printf_filtered ("\nCatchpoint %d (exception thrown), ",
2240 bs->breakpoint_at->number);
2241 printf_filtered ("throw location ");
2242 if (CURRENT_EXCEPTION_THROW_PC && CURRENT_EXCEPTION_THROW_LINE)
2243 printf_filtered ("%s:%d",
2244 CURRENT_EXCEPTION_THROW_FILE,
2245 CURRENT_EXCEPTION_THROW_LINE);
2247 printf_filtered ("unknown");
2249 printf_filtered (", catch location ");
2250 if (CURRENT_EXCEPTION_CATCH_PC && CURRENT_EXCEPTION_CATCH_LINE)
2251 printf_filtered ("%s:%d",
2252 CURRENT_EXCEPTION_CATCH_FILE,
2253 CURRENT_EXCEPTION_CATCH_LINE);
2255 printf_filtered ("unknown");
2257 printf_filtered ("\n");
2258 /* don't bother to print location frame info */
2259 return PRINT_SRC_ONLY;
2263 /* really catch, some other bpstat will handle it */
2264 return PRINT_UNKNOWN;
2269 case bp_hardware_watchpoint:
2270 if (bs->old_val != NULL)
2272 annotate_watchpoint (bs->breakpoint_at->number);
2273 if (ui_out_is_mi_like_p (uiout))
2274 ui_out_field_string (uiout, "reason", "watchpoint-trigger");
2275 mention (bs->breakpoint_at);
2276 ui_out_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "value");
2277 ui_out_text (uiout, "\nOld value = ");
2278 value_print (bs->old_val, stb->stream, 0, Val_pretty_default);
2279 ui_out_field_stream (uiout, "old", stb);
2280 ui_out_text (uiout, "\nNew value = ");
2281 value_print (bs->breakpoint_at->val, stb->stream, 0, Val_pretty_default);
2282 ui_out_field_stream (uiout, "new", stb);
2283 do_cleanups (ui_out_chain);
2284 ui_out_text (uiout, "\n");
2285 value_free (bs->old_val);
2288 /* More than one watchpoint may have been triggered. */
2289 return PRINT_UNKNOWN;
2292 case bp_read_watchpoint:
2293 if (ui_out_is_mi_like_p (uiout))
2294 ui_out_field_string (uiout, "reason", "read-watchpoint-trigger");
2295 mention (bs->breakpoint_at);
2296 ui_out_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "value");
2297 ui_out_text (uiout, "\nValue = ");
2298 value_print (bs->breakpoint_at->val, stb->stream, 0, Val_pretty_default);
2299 ui_out_field_stream (uiout, "value", stb);
2300 do_cleanups (ui_out_chain);
2301 ui_out_text (uiout, "\n");
2302 return PRINT_UNKNOWN;
2305 case bp_access_watchpoint:
2306 if (bs->old_val != NULL)
2308 annotate_watchpoint (bs->breakpoint_at->number);
2309 if (ui_out_is_mi_like_p (uiout))
2310 ui_out_field_string (uiout, "reason", "access-watchpoint-trigger");
2311 mention (bs->breakpoint_at);
2312 ui_out_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "value");
2313 ui_out_text (uiout, "\nOld value = ");
2314 value_print (bs->old_val, stb->stream, 0, Val_pretty_default);
2315 ui_out_field_stream (uiout, "old", stb);
2316 value_free (bs->old_val);
2318 ui_out_text (uiout, "\nNew value = ");
2322 mention (bs->breakpoint_at);
2323 if (ui_out_is_mi_like_p (uiout))
2324 ui_out_field_string (uiout, "reason", "access-watchpoint-trigger");
2325 ui_out_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "value");
2326 ui_out_text (uiout, "\nValue = ");
2328 value_print (bs->breakpoint_at->val, stb->stream, 0,Val_pretty_default);
2329 ui_out_field_stream (uiout, "new", stb);
2330 do_cleanups (ui_out_chain);
2331 ui_out_text (uiout, "\n");
2332 return PRINT_UNKNOWN;
2335 /* Fall through, we don't deal with these types of breakpoints
2339 if (ui_out_is_mi_like_p (uiout))
2340 ui_out_field_string (uiout, "reason", "function-finished");
2341 return PRINT_UNKNOWN;
2345 if (ui_out_is_mi_like_p (uiout))
2346 ui_out_field_string (uiout, "reason", "location-reached");
2347 return PRINT_UNKNOWN;
2352 case bp_longjmp_resume:
2353 case bp_step_resume:
2354 case bp_through_sigtramp:
2355 case bp_watchpoint_scope:
2358 return PRINT_UNKNOWN;
2362 /* Generic routine for printing messages indicating why we
2363 stopped. The behavior of this function depends on the value
2364 'print_it' in the bpstat structure. Under some circumstances we
2365 may decide not to print anything here and delegate the task to
2368 static enum print_stop_action
2369 print_bp_stop_message (bpstat bs)
2371 switch (bs->print_it)
2374 /* Nothing should be printed for this bpstat entry. */
2375 return PRINT_UNKNOWN;
2379 /* We still want to print the frame, but we already printed the
2380 relevant messages. */
2381 return PRINT_SRC_AND_LOC;
2384 case print_it_normal:
2385 /* Normal case. Call the breakpoint's print_it method, or
2386 print_it_typical. */
2387 if (bs->breakpoint_at != NULL && bs->breakpoint_at->ops != NULL
2388 && bs->breakpoint_at->ops->print_it != NULL)
2389 return bs->breakpoint_at->ops->print_it (bs->breakpoint_at);
2391 return print_it_typical (bs);
2395 internal_error (__FILE__, __LINE__,
2396 "print_bp_stop_message: unrecognized enum value");
2401 /* Print a message indicating what happened. This is called from
2402 normal_stop(). The input to this routine is the head of the bpstat
2403 list - a list of the eventpoints that caused this stop. This
2404 routine calls the generic print routine for printing a message
2405 about reasons for stopping. This will print (for example) the
2406 "Breakpoint n," part of the output. The return value of this
2409 PRINT_UNKNOWN: Means we printed nothing
2410 PRINT_SRC_AND_LOC: Means we printed something, and expect subsequent
2411 code to print the location. An example is
2412 "Breakpoint 1, " which should be followed by
2414 PRINT_SRC_ONLY: Means we printed something, but there is no need
2415 to also print the location part of the message.
2416 An example is the catch/throw messages, which
2417 don't require a location appended to the end.
2418 PRINT_NOTHING: We have done some printing and we don't need any
2419 further info to be printed.*/
2421 enum print_stop_action
2422 bpstat_print (bpstat bs)
2426 /* Maybe another breakpoint in the chain caused us to stop.
2427 (Currently all watchpoints go on the bpstat whether hit or not.
2428 That probably could (should) be changed, provided care is taken
2429 with respect to bpstat_explains_signal). */
2430 for (; bs; bs = bs->next)
2432 val = print_bp_stop_message (bs);
2433 if (val == PRINT_SRC_ONLY
2434 || val == PRINT_SRC_AND_LOC
2435 || val == PRINT_NOTHING)
2439 /* We reached the end of the chain, or we got a null BS to start
2440 with and nothing was printed. */
2441 return PRINT_UNKNOWN;
2444 /* Evaluate the expression EXP and return 1 if value is zero.
2445 This is used inside a catch_errors to evaluate the breakpoint condition.
2446 The argument is a "struct expression *" that has been cast to char * to
2447 make it pass through catch_errors. */
2450 breakpoint_cond_eval (void *exp)
2452 struct value *mark = value_mark ();
2453 int i = !value_true (evaluate_expression ((struct expression *) exp));
2454 value_free_to_mark (mark);
2458 /* Allocate a new bpstat and chain it to the current one. */
2461 bpstat_alloc (struct breakpoint *b, bpstat cbs /* Current "bs" value */ )
2465 bs = (bpstat) xmalloc (sizeof (*bs));
2467 bs->breakpoint_at = b;
2468 /* If the condition is false, etc., don't do the commands. */
2469 bs->commands = NULL;
2471 bs->print_it = print_it_normal;
2475 /* Possible return values for watchpoint_check (this can't be an enum
2476 because of check_errors). */
2477 /* The watchpoint has been deleted. */
2478 #define WP_DELETED 1
2479 /* The value has changed. */
2480 #define WP_VALUE_CHANGED 2
2481 /* The value has not changed. */
2482 #define WP_VALUE_NOT_CHANGED 3
2484 #define BP_TEMPFLAG 1
2485 #define BP_HARDWAREFLAG 2
2487 /* Check watchpoint condition. */
2490 watchpoint_check (void *p)
2492 bpstat bs = (bpstat) p;
2493 struct breakpoint *b;
2494 struct frame_info *fr;
2495 int within_current_scope;
2497 b = bs->breakpoint_at;
2499 if (b->exp_valid_block == NULL)
2500 within_current_scope = 1;
2503 /* There is no current frame at this moment. If we're going to have
2504 any chance of handling watchpoints on local variables, we'll need
2505 the frame chain (so we can determine if we're in scope). */
2506 reinit_frame_cache ();
2507 fr = frame_find_by_id (b->watchpoint_frame);
2508 within_current_scope = (fr != NULL);
2509 /* in_function_epilogue_p() returns a non-zero value if we're still
2510 in the function but the stack frame has already been invalidated.
2511 Since we can't rely on the values of local variables after the
2512 stack has been destroyed, we are treating the watchpoint in that
2513 state as `not changed' without further checking.
2515 vinschen/2003-09-04: The former implementation left out the case
2516 that the watchpoint frame couldn't be found by frame_find_by_id()
2517 because the current PC is currently in an epilogue. Calling
2518 gdbarch_in_function_epilogue_p() also when fr == NULL fixes that. */
2519 if ((!within_current_scope || fr == get_current_frame ())
2520 && gdbarch_in_function_epilogue_p (current_gdbarch, read_pc ()))
2521 return WP_VALUE_NOT_CHANGED;
2522 if (fr && within_current_scope)
2523 /* If we end up stopping, the current frame will get selected
2524 in normal_stop. So this call to select_frame won't affect
2529 if (within_current_scope)
2531 /* We use value_{,free_to_}mark because it could be a
2532 *long* time before we return to the command level and
2533 call free_all_values. We can't call free_all_values because
2534 we might be in the middle of evaluating a function call. */
2536 struct value *mark = value_mark ();
2537 struct value *new_val = evaluate_expression (bs->breakpoint_at->exp);
2538 if (!value_equal (b->val, new_val))
2540 release_value (new_val);
2541 value_free_to_mark (mark);
2542 bs->old_val = b->val;
2544 /* We will stop here */
2545 return WP_VALUE_CHANGED;
2549 /* Nothing changed, don't do anything. */
2550 value_free_to_mark (mark);
2551 /* We won't stop here */
2552 return WP_VALUE_NOT_CHANGED;
2557 /* This seems like the only logical thing to do because
2558 if we temporarily ignored the watchpoint, then when
2559 we reenter the block in which it is valid it contains
2560 garbage (in the case of a function, it may have two
2561 garbage values, one before and one after the prologue).
2562 So we can't even detect the first assignment to it and
2563 watch after that (since the garbage may or may not equal
2564 the first value assigned). */
2565 /* We print all the stop information in print_it_typical(), but
2566 in this case, by the time we call print_it_typical() this bp
2567 will be deleted already. So we have no choice but print the
2568 information here. */
2569 if (ui_out_is_mi_like_p (uiout))
2570 ui_out_field_string (uiout, "reason", "watchpoint-scope");
2571 ui_out_text (uiout, "\nWatchpoint ");
2572 ui_out_field_int (uiout, "wpnum", bs->breakpoint_at->number);
2573 ui_out_text (uiout, " deleted because the program has left the block in\n\
2574 which its expression is valid.\n");
2576 if (b->related_breakpoint)
2577 b->related_breakpoint->disposition = disp_del_at_next_stop;
2578 b->disposition = disp_del_at_next_stop;
2584 /* Get a bpstat associated with having just stopped at address
2587 /* Determine whether we stopped at a breakpoint, etc, or whether we
2588 don't understand this stop. Result is a chain of bpstat's such that:
2590 if we don't understand the stop, the result is a null pointer.
2592 if we understand why we stopped, the result is not null.
2594 Each element of the chain refers to a particular breakpoint or
2595 watchpoint at which we have stopped. (We may have stopped for
2596 several reasons concurrently.)
2598 Each element of the chain has valid next, breakpoint_at,
2599 commands, FIXME??? fields. */
2602 bpstat_stop_status (CORE_ADDR bp_addr, ptid_t ptid)
2604 struct breakpoint *b, *temp;
2605 /* True if we've hit a breakpoint (as opposed to a watchpoint). */
2606 int real_breakpoint = 0;
2607 /* Root of the chain of bpstat's */
2608 struct bpstats root_bs[1];
2609 /* Pointer to the last thing in the chain currently. */
2610 bpstat bs = root_bs;
2611 int thread_id = pid_to_thread_id (ptid);
2613 ALL_BREAKPOINTS_SAFE (b, temp)
2615 if (!breakpoint_enabled (b) && b->enable_state != bp_permanent)
2618 if (b->type != bp_watchpoint
2619 && b->type != bp_hardware_watchpoint
2620 && b->type != bp_read_watchpoint
2621 && b->type != bp_access_watchpoint
2622 && b->type != bp_hardware_breakpoint
2623 && b->type != bp_catch_fork
2624 && b->type != bp_catch_vfork
2625 && b->type != bp_catch_exec
2626 && b->type != bp_catch_catch
2627 && b->type != bp_catch_throw) /* a non-watchpoint bp */
2629 if (b->loc->address != bp_addr) /* address doesn't match */
2631 if (overlay_debugging /* unmapped overlay section */
2632 && section_is_overlay (b->loc->section)
2633 && !section_is_mapped (b->loc->section))
2637 if (b->type == bp_hardware_breakpoint)
2639 if (b->loc->address != bp_addr)
2641 if (overlay_debugging /* unmapped overlay section */
2642 && section_is_overlay (b->loc->section)
2643 && !section_is_mapped (b->loc->section))
2647 /* Is this a catchpoint of a load or unload? If so, did we
2648 get a load or unload of the specified library? If not,
2650 if ((b->type == bp_catch_load)
2651 #if defined(SOLIB_HAVE_LOAD_EVENT)
2652 && (!SOLIB_HAVE_LOAD_EVENT (PIDGET (inferior_ptid))
2653 || ((b->dll_pathname != NULL)
2654 && (strcmp (b->dll_pathname,
2655 SOLIB_LOADED_LIBRARY_PATHNAME (
2656 PIDGET (inferior_ptid)))
2662 if ((b->type == bp_catch_unload)
2663 #if defined(SOLIB_HAVE_UNLOAD_EVENT)
2664 && (!SOLIB_HAVE_UNLOAD_EVENT (PIDGET (inferior_ptid))
2665 || ((b->dll_pathname != NULL)
2666 && (strcmp (b->dll_pathname,
2667 SOLIB_UNLOADED_LIBRARY_PATHNAME (
2668 PIDGET (inferior_ptid)))
2674 if ((b->type == bp_catch_fork)
2675 && !inferior_has_forked (PIDGET (inferior_ptid),
2676 &b->forked_inferior_pid))
2679 if ((b->type == bp_catch_vfork)
2680 && !inferior_has_vforked (PIDGET (inferior_ptid),
2681 &b->forked_inferior_pid))
2684 if ((b->type == bp_catch_exec)
2685 && !inferior_has_execd (PIDGET (inferior_ptid), &b->exec_pathname))
2688 if (ep_is_exception_catchpoint (b) &&
2689 !(current_exception_event = target_get_current_exception_event ()))
2692 /* Come here if it's a watchpoint, or if the break address matches */
2694 bs = bpstat_alloc (b, bs); /* Alloc a bpstat to explain stop */
2696 /* Watchpoints may change this, if not found to have triggered. */
2700 if (b->type == bp_watchpoint ||
2701 b->type == bp_hardware_watchpoint)
2703 char *message = xstrprintf ("Error evaluating expression for watchpoint %d\n",
2705 struct cleanup *cleanups = make_cleanup (xfree, message);
2706 int e = catch_errors (watchpoint_check, bs, message,
2708 do_cleanups (cleanups);
2712 /* We've already printed what needs to be printed. */
2713 /* Actually this is superfluous, because by the time we
2714 call print_it_typical() the wp will be already deleted,
2715 and the function will return immediately. */
2716 bs->print_it = print_it_done;
2719 case WP_VALUE_CHANGED:
2723 case WP_VALUE_NOT_CHANGED:
2725 bs->print_it = print_it_noop;
2732 /* Error from catch_errors. */
2733 printf_filtered ("Watchpoint %d deleted.\n", b->number);
2734 if (b->related_breakpoint)
2735 b->related_breakpoint->disposition = disp_del_at_next_stop;
2736 b->disposition = disp_del_at_next_stop;
2737 /* We've already printed what needs to be printed. */
2738 bs->print_it = print_it_done;
2744 else if (b->type == bp_read_watchpoint ||
2745 b->type == bp_access_watchpoint)
2751 addr = target_stopped_data_address ();
2754 for (v = b->val_chain; v; v = v->next)
2756 if (VALUE_LVAL (v) == lval_memory
2757 && ! VALUE_LAZY (v))
2759 struct type *vtype = check_typedef (VALUE_TYPE (v));
2761 if (v == b->val_chain
2762 || (TYPE_CODE (vtype) != TYPE_CODE_STRUCT
2763 && TYPE_CODE (vtype) != TYPE_CODE_ARRAY))
2767 vaddr = VALUE_ADDRESS (v) + VALUE_OFFSET (v);
2768 /* Exact match not required. Within range is
2770 if (addr >= vaddr &&
2771 addr < vaddr + TYPE_LENGTH (VALUE_TYPE (v)))
2778 char *message = xstrprintf ("Error evaluating expression for watchpoint %d\n",
2780 struct cleanup *cleanups = make_cleanup (xfree, message);
2781 int e = catch_errors (watchpoint_check, bs, message,
2783 do_cleanups (cleanups);
2787 /* We've already printed what needs to be printed. */
2788 bs->print_it = print_it_done;
2791 case WP_VALUE_CHANGED:
2792 if (b->type == bp_read_watchpoint)
2794 /* Don't stop: read watchpoints shouldn't fire if
2795 the value has changed. This is for targets
2796 which cannot set read-only watchpoints. */
2797 bs->print_it = print_it_noop;
2803 case WP_VALUE_NOT_CHANGED:
2810 /* Error from catch_errors. */
2811 printf_filtered ("Watchpoint %d deleted.\n", b->number);
2812 if (b->related_breakpoint)
2813 b->related_breakpoint->disposition = disp_del_at_next_stop;
2814 b->disposition = disp_del_at_next_stop;
2815 /* We've already printed what needs to be printed. */
2816 bs->print_it = print_it_done;
2820 else /* found == 0 */
2822 /* This is a case where some watchpoint(s) triggered,
2823 but not at the address of this watchpoint (FOUND
2824 was left zero). So don't print anything for this
2826 bs->print_it = print_it_noop;
2833 /* By definition, an encountered breakpoint is a triggered
2837 real_breakpoint = 1;
2840 if (frame_id_p (b->frame_id)
2841 && !frame_id_eq (b->frame_id, get_frame_id (get_current_frame ())))
2845 int value_is_zero = 0;
2849 /* Need to select the frame, with all that implies
2850 so that the conditions will have the right context. */
2851 select_frame (get_current_frame ());
2853 = catch_errors (breakpoint_cond_eval, (b->cond),
2854 "Error in testing breakpoint condition:\n",
2856 /* FIXME-someday, should give breakpoint # */
2859 if (b->cond && value_is_zero)
2862 /* Don't consider this a hit. */
2865 else if (b->thread != -1 && b->thread != thread_id)
2868 /* Don't consider this a hit. */
2871 else if (b->ignore_count > 0)
2874 annotate_ignore_count_change ();
2879 /* We will stop here */
2880 if (b->disposition == disp_disable)
2881 b->enable_state = bp_disabled;
2884 bs->commands = b->commands;
2886 (strcmp ("silent", bs->commands->line) == 0
2887 || (xdb_commands && strcmp ("Q", bs->commands->line) == 0)))
2889 bs->commands = bs->commands->next;
2892 bs->commands = copy_command_lines (bs->commands);
2895 /* Print nothing for this entry if we dont stop or if we dont print. */
2896 if (bs->stop == 0 || bs->print == 0)
2897 bs->print_it = print_it_noop;
2900 bs->next = NULL; /* Terminate the chain */
2901 bs = root_bs->next; /* Re-grab the head of the chain */
2903 /* The value of a hardware watchpoint hasn't changed, but the
2904 intermediate memory locations we are watching may have. */
2905 if (bs && !bs->stop &&
2906 (bs->breakpoint_at->type == bp_hardware_watchpoint ||
2907 bs->breakpoint_at->type == bp_read_watchpoint ||
2908 bs->breakpoint_at->type == bp_access_watchpoint))
2910 remove_breakpoints ();
2911 insert_breakpoints ();
2916 /* Tell what to do about this bpstat. */
2918 bpstat_what (bpstat bs)
2920 /* Classify each bpstat as one of the following. */
2923 /* This bpstat element has no effect on the main_action. */
2926 /* There was a watchpoint, stop but don't print. */
2929 /* There was a watchpoint, stop and print. */
2932 /* There was a breakpoint but we're not stopping. */
2935 /* There was a breakpoint, stop but don't print. */
2938 /* There was a breakpoint, stop and print. */
2941 /* We hit the longjmp breakpoint. */
2944 /* We hit the longjmp_resume breakpoint. */
2947 /* We hit the step_resume breakpoint. */
2950 /* We hit the through_sigtramp breakpoint. */
2953 /* We hit the shared library event breakpoint. */
2956 /* We caught a shared library event. */
2959 /* This is just used to count how many enums there are. */
2963 /* Here is the table which drives this routine. So that we can
2964 format it pretty, we define some abbreviations for the
2965 enum bpstat_what codes. */
2966 #define kc BPSTAT_WHAT_KEEP_CHECKING
2967 #define ss BPSTAT_WHAT_STOP_SILENT
2968 #define sn BPSTAT_WHAT_STOP_NOISY
2969 #define sgl BPSTAT_WHAT_SINGLE
2970 #define slr BPSTAT_WHAT_SET_LONGJMP_RESUME
2971 #define clr BPSTAT_WHAT_CLEAR_LONGJMP_RESUME
2972 #define clrs BPSTAT_WHAT_CLEAR_LONGJMP_RESUME_SINGLE
2973 #define sr BPSTAT_WHAT_STEP_RESUME
2974 #define ts BPSTAT_WHAT_THROUGH_SIGTRAMP
2975 #define shl BPSTAT_WHAT_CHECK_SHLIBS
2976 #define shlr BPSTAT_WHAT_CHECK_SHLIBS_RESUME_FROM_HOOK
2978 /* "Can't happen." Might want to print an error message.
2979 abort() is not out of the question, but chances are GDB is just
2980 a bit confused, not unusable. */
2981 #define err BPSTAT_WHAT_STOP_NOISY
2983 /* Given an old action and a class, come up with a new action. */
2984 /* One interesting property of this table is that wp_silent is the same
2985 as bp_silent and wp_noisy is the same as bp_noisy. That is because
2986 after stopping, the check for whether to step over a breakpoint
2987 (BPSTAT_WHAT_SINGLE type stuff) is handled in proceed() without
2988 reference to how we stopped. We retain separate wp_silent and
2989 bp_silent codes in case we want to change that someday.
2991 Another possibly interesting property of this table is that
2992 there's a partial ordering, priority-like, of the actions. Once
2993 you've decided that some action is appropriate, you'll never go
2994 back and decide something of a lower priority is better. The
2997 kc < clr sgl shl shlr slr sn sr ss ts
2998 sgl < clrs shl shlr slr sn sr ss ts
2999 slr < err shl shlr sn sr ss ts
3000 clr < clrs err shl shlr sn sr ss ts
3001 clrs < err shl shlr sn sr ss ts
3002 ss < shl shlr sn sr ts
3009 What I think this means is that we don't need a damned table
3010 here. If you just put the rows and columns in the right order,
3011 it'd look awfully regular. We could simply walk the bpstat list
3012 and choose the highest priority action we find, with a little
3013 logic to handle the 'err' cases, and the CLEAR_LONGJMP_RESUME/
3014 CLEAR_LONGJMP_RESUME_SINGLE distinction (which breakpoint.h says
3015 is messy anyway). */
3017 /* step_resume entries: a step resume breakpoint overrides another
3018 breakpoint of signal handling (see comment in wait_for_inferior
3019 at first PC_IN_SIGTRAMP where we set the step_resume breakpoint). */
3020 /* We handle the through_sigtramp_breakpoint the same way; having both
3021 one of those and a step_resume_breakpoint is probably very rare (?). */
3023 static const enum bpstat_what_main_action
3024 table[(int) class_last][(int) BPSTAT_WHAT_LAST] =
3027 /* kc ss sn sgl slr clr clrs sr ts shl shlr
3030 {kc, ss, sn, sgl, slr, clr, clrs, sr, ts, shl, shlr},
3032 {ss, ss, sn, ss, ss, ss, ss, sr, ts, shl, shlr},
3034 {sn, sn, sn, sn, sn, sn, sn, sr, ts, shl, shlr},
3036 {sgl, ss, sn, sgl, slr, clrs, clrs, sr, ts, shl, shlr},
3038 {ss, ss, sn, ss, ss, ss, ss, sr, ts, shl, shlr},
3040 {sn, sn, sn, sn, sn, sn, sn, sr, ts, shl, shlr},
3042 {slr, ss, sn, slr, slr, err, err, sr, ts, shl, shlr},
3044 {clr, ss, sn, clrs, err, err, err, sr, ts, shl, shlr},
3046 {sr, sr, sr, sr, sr, sr, sr, sr, ts, shl, shlr},
3048 {ts, ts, ts, ts, ts, ts, ts, ts, ts, shl, shlr},
3050 {shl, shl, shl, shl, shl, shl, shl, shl, ts, shl, shlr},
3052 {shlr, shlr, shlr, shlr, shlr, shlr, shlr, shlr, ts, shlr, shlr}
3067 enum bpstat_what_main_action current_action = BPSTAT_WHAT_KEEP_CHECKING;
3068 struct bpstat_what retval;
3070 retval.call_dummy = 0;
3071 for (; bs != NULL; bs = bs->next)
3073 enum class bs_class = no_effect;
3074 if (bs->breakpoint_at == NULL)
3075 /* I suspect this can happen if it was a momentary breakpoint
3076 which has since been deleted. */
3078 switch (bs->breakpoint_at->type)
3084 case bp_hardware_breakpoint:
3090 bs_class = bp_noisy;
3092 bs_class = bp_silent;
3095 bs_class = bp_nostop;
3098 case bp_hardware_watchpoint:
3099 case bp_read_watchpoint:
3100 case bp_access_watchpoint:
3104 bs_class = wp_noisy;
3106 bs_class = wp_silent;
3109 /* There was a watchpoint, but we're not stopping.
3110 This requires no further action. */
3111 bs_class = no_effect;
3114 bs_class = long_jump;
3116 case bp_longjmp_resume:
3117 bs_class = long_resume;
3119 case bp_step_resume:
3122 bs_class = step_resume;
3125 /* It is for the wrong frame. */
3126 bs_class = bp_nostop;
3128 case bp_through_sigtramp:
3129 bs_class = through_sig;
3131 case bp_watchpoint_scope:
3132 bs_class = bp_nostop;
3134 case bp_shlib_event:
3135 bs_class = shlib_event;
3137 case bp_thread_event:
3138 case bp_overlay_event:
3139 bs_class = bp_nostop;
3142 case bp_catch_unload:
3143 /* Only if this catchpoint triggered should we cause the
3144 step-out-of-dld behaviour. Otherwise, we ignore this
3147 bs_class = catch_shlib_event;
3149 bs_class = no_effect;
3152 case bp_catch_vfork:
3157 bs_class = bp_noisy;
3159 bs_class = bp_silent;
3162 /* There was a catchpoint, but we're not stopping.
3163 This requires no further action. */
3164 bs_class = no_effect;
3166 case bp_catch_catch:
3167 if (!bs->stop || CURRENT_EXCEPTION_KIND != EX_EVENT_CATCH)
3168 bs_class = bp_nostop;
3170 bs_class = bs->print ? bp_noisy : bp_silent;
3172 case bp_catch_throw:
3173 if (!bs->stop || CURRENT_EXCEPTION_KIND != EX_EVENT_THROW)
3174 bs_class = bp_nostop;
3176 bs_class = bs->print ? bp_noisy : bp_silent;
3179 /* Make sure the action is stop (silent or noisy),
3180 so infrun.c pops the dummy frame. */
3181 bs_class = bp_silent;
3182 retval.call_dummy = 1;
3185 current_action = table[(int) bs_class][(int) current_action];
3187 retval.main_action = current_action;
3191 /* Nonzero if we should step constantly (e.g. watchpoints on machines
3192 without hardware support). This isn't related to a specific bpstat,
3193 just to things like whether watchpoints are set. */
3196 bpstat_should_step (void)
3198 struct breakpoint *b;
3200 if (breakpoint_enabled (b) && b->type == bp_watchpoint)
3205 /* Nonzero if there are enabled hardware watchpoints. */
3207 bpstat_have_active_hw_watchpoints (void)
3209 struct bp_location *bpt;
3210 ALL_BP_LOCATIONS (bpt)
3211 if (breakpoint_enabled (bpt->owner)
3213 && bpt->loc_type == bp_loc_hardware_watchpoint)
3219 /* Given a bpstat that records zero or more triggered eventpoints, this
3220 function returns another bpstat which contains only the catchpoints
3221 on that first list, if any. */
3223 bpstat_get_triggered_catchpoints (bpstat ep_list, bpstat *cp_list)
3225 struct bpstats root_bs[1];
3226 bpstat bs = root_bs;
3227 struct breakpoint *ep;
3230 bpstat_clear (cp_list);
3231 root_bs->next = NULL;
3233 for (; ep_list != NULL; ep_list = ep_list->next)
3235 /* Is this eventpoint a catchpoint? If not, ignore it. */
3236 ep = ep_list->breakpoint_at;
3239 if ((ep->type != bp_catch_load) &&
3240 (ep->type != bp_catch_unload) &&
3241 (ep->type != bp_catch_catch) &&
3242 (ep->type != bp_catch_throw))
3243 /* pai: (temp) ADD fork/vfork here!! */
3246 /* Yes; add it to the list. */
3247 bs = bpstat_alloc (ep, bs);
3252 #if defined(SOLIB_ADD)
3253 /* Also, for each triggered catchpoint, tag it with the name of
3254 the library that caused this trigger. (We copy the name now,
3255 because it's only guaranteed to be available NOW, when the
3256 catchpoint triggers. Clients who may wish to know the name
3257 later must get it from the catchpoint itself.) */
3258 if (ep->triggered_dll_pathname != NULL)
3259 xfree (ep->triggered_dll_pathname);
3260 if (ep->type == bp_catch_load)
3261 dll_pathname = SOLIB_LOADED_LIBRARY_PATHNAME (
3262 PIDGET (inferior_ptid));
3264 dll_pathname = SOLIB_UNLOADED_LIBRARY_PATHNAME (
3265 PIDGET (inferior_ptid));
3267 dll_pathname = NULL;
3271 ep->triggered_dll_pathname = (char *)
3272 xmalloc (strlen (dll_pathname) + 1);
3273 strcpy (ep->triggered_dll_pathname, dll_pathname);
3276 ep->triggered_dll_pathname = NULL;
3282 /* Print B to gdb_stdout. */
3284 print_one_breakpoint (struct breakpoint *b,
3285 CORE_ADDR *last_addr)
3287 struct command_line *l;
3289 struct ep_type_description
3294 static struct ep_type_description bptypes[] =
3296 {bp_none, "?deleted?"},
3297 {bp_breakpoint, "breakpoint"},
3298 {bp_hardware_breakpoint, "hw breakpoint"},
3299 {bp_until, "until"},
3300 {bp_finish, "finish"},
3301 {bp_watchpoint, "watchpoint"},
3302 {bp_hardware_watchpoint, "hw watchpoint"},
3303 {bp_read_watchpoint, "read watchpoint"},
3304 {bp_access_watchpoint, "acc watchpoint"},
3305 {bp_longjmp, "longjmp"},
3306 {bp_longjmp_resume, "longjmp resume"},
3307 {bp_step_resume, "step resume"},
3308 {bp_through_sigtramp, "sigtramp"},
3309 {bp_watchpoint_scope, "watchpoint scope"},
3310 {bp_call_dummy, "call dummy"},
3311 {bp_shlib_event, "shlib events"},
3312 {bp_thread_event, "thread events"},
3313 {bp_overlay_event, "overlay events"},
3314 {bp_catch_load, "catch load"},
3315 {bp_catch_unload, "catch unload"},
3316 {bp_catch_fork, "catch fork"},
3317 {bp_catch_vfork, "catch vfork"},
3318 {bp_catch_exec, "catch exec"},
3319 {bp_catch_catch, "catch catch"},
3320 {bp_catch_throw, "catch throw"}
3323 static char *bpdisps[] =
3324 {"del", "dstp", "dis", "keep"};
3325 static char bpenables[] = "nynny";
3326 char wrap_indent[80];
3327 struct ui_stream *stb = ui_out_stream_new (uiout);
3328 struct cleanup *old_chain = make_cleanup_ui_out_stream_delete (stb);
3329 struct cleanup *bkpt_chain;
3332 bkpt_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "bkpt");
3336 ui_out_field_int (uiout, "number", b->number);
3340 if (((int) b->type > (sizeof (bptypes) / sizeof (bptypes[0])))
3341 || ((int) b->type != bptypes[(int) b->type].type))
3342 internal_error (__FILE__, __LINE__,
3343 "bptypes table does not describe type #%d.",
3345 ui_out_field_string (uiout, "type", bptypes[(int) b->type].description);
3349 ui_out_field_string (uiout, "disp", bpdisps[(int) b->disposition]);
3353 ui_out_field_fmt (uiout, "enabled", "%c", bpenables[(int) b->enable_state]);
3354 ui_out_spaces (uiout, 2);
3357 strcpy (wrap_indent, " ");
3360 if (TARGET_ADDR_BIT <= 32)
3361 strcat (wrap_indent, " ");
3363 strcat (wrap_indent, " ");
3366 if (b->ops != NULL && b->ops->print_one != NULL)
3367 b->ops->print_one (b, last_addr);
3372 internal_error (__FILE__, __LINE__,
3373 "print_one_breakpoint: bp_none encountered\n");
3377 case bp_hardware_watchpoint:
3378 case bp_read_watchpoint:
3379 case bp_access_watchpoint:
3380 /* Field 4, the address, is omitted (which makes the columns
3381 not line up too nicely with the headers, but the effect
3382 is relatively readable). */
3384 ui_out_field_skip (uiout, "addr");
3386 print_expression (b->exp, stb->stream);
3387 ui_out_field_stream (uiout, "what", stb);
3391 case bp_catch_unload:
3392 /* Field 4, the address, is omitted (which makes the columns
3393 not line up too nicely with the headers, but the effect
3394 is relatively readable). */
3396 ui_out_field_skip (uiout, "addr");
3398 if (b->dll_pathname == NULL)
3400 ui_out_field_string (uiout, "what", "<any library>");
3401 ui_out_spaces (uiout, 1);
3405 ui_out_text (uiout, "library \"");
3406 ui_out_field_string (uiout, "what", b->dll_pathname);
3407 ui_out_text (uiout, "\" ");
3412 case bp_catch_vfork:
3413 /* Field 4, the address, is omitted (which makes the columns
3414 not line up too nicely with the headers, but the effect
3415 is relatively readable). */
3417 ui_out_field_skip (uiout, "addr");
3419 if (b->forked_inferior_pid != 0)
3421 ui_out_text (uiout, "process ");
3422 ui_out_field_int (uiout, "what", b->forked_inferior_pid);
3423 ui_out_spaces (uiout, 1);
3427 /* Field 4, the address, is omitted (which makes the columns
3428 not line up too nicely with the headers, but the effect
3429 is relatively readable). */
3431 ui_out_field_skip (uiout, "addr");
3433 if (b->exec_pathname != NULL)
3435 ui_out_text (uiout, "program \"");
3436 ui_out_field_string (uiout, "what", b->exec_pathname);
3437 ui_out_text (uiout, "\" ");
3441 case bp_catch_catch:
3442 /* Field 4, the address, is omitted (which makes the columns
3443 not line up too nicely with the headers, but the effect
3444 is relatively readable). */
3446 ui_out_field_skip (uiout, "addr");
3448 ui_out_field_string (uiout, "what", "exception catch");
3449 ui_out_spaces (uiout, 1);
3452 case bp_catch_throw:
3453 /* Field 4, the address, is omitted (which makes the columns
3454 not line up too nicely with the headers, but the effect
3455 is relatively readable). */
3457 ui_out_field_skip (uiout, "addr");
3459 ui_out_field_string (uiout, "what", "exception throw");
3460 ui_out_spaces (uiout, 1);
3464 case bp_hardware_breakpoint:
3468 case bp_longjmp_resume:
3469 case bp_step_resume:
3470 case bp_through_sigtramp:
3471 case bp_watchpoint_scope:
3473 case bp_shlib_event:
3474 case bp_thread_event:
3475 case bp_overlay_event:
3480 ui_out_field_string (uiout, "addr", "<PENDING>");
3482 ui_out_field_core_addr (uiout, "addr", b->loc->address);
3485 *last_addr = b->loc->address;
3488 sym = find_pc_sect_function (b->loc->address, b->loc->section);
3491 ui_out_text (uiout, "in ");
3492 ui_out_field_string (uiout, "func",
3493 SYMBOL_PRINT_NAME (sym));
3494 ui_out_wrap_hint (uiout, wrap_indent);
3495 ui_out_text (uiout, " at ");
3497 ui_out_field_string (uiout, "file", b->source_file);
3498 ui_out_text (uiout, ":");
3499 ui_out_field_int (uiout, "line", b->line_number);
3501 else if (b->pending)
3503 ui_out_field_string (uiout, "pending", b->addr_string);
3507 print_address_symbolic (b->loc->address, stb->stream, demangle, "");
3508 ui_out_field_stream (uiout, "at", stb);
3513 if (b->thread != -1)
3515 /* FIXME: This seems to be redundant and lost here; see the
3516 "stop only in" line a little further down. */
3517 ui_out_text (uiout, " thread ");
3518 ui_out_field_int (uiout, "thread", b->thread);
3521 ui_out_text (uiout, "\n");
3523 if (frame_id_p (b->frame_id))
3526 ui_out_text (uiout, "\tstop only in stack frame at ");
3527 /* FIXME: cagney/2002-12-01: Shouldn't be poeking around inside
3529 ui_out_field_core_addr (uiout, "frame", b->frame_id.stack_addr);
3530 ui_out_text (uiout, "\n");
3536 ui_out_text (uiout, "\tstop only if ");
3537 print_expression (b->cond, stb->stream);
3538 ui_out_field_stream (uiout, "cond", stb);
3539 ui_out_text (uiout, "\n");
3542 if (b->pending && b->cond_string)
3545 ui_out_text (uiout, "\tstop only if ");
3546 ui_out_field_string (uiout, "cond", b->cond_string);
3547 ui_out_text (uiout, "\n");
3550 if (b->thread != -1)
3552 /* FIXME should make an annotation for this */
3553 ui_out_text (uiout, "\tstop only in thread ");
3554 ui_out_field_int (uiout, "thread", b->thread);
3555 ui_out_text (uiout, "\n");
3558 if (show_breakpoint_hit_counts && b->hit_count)
3560 /* FIXME should make an annotation for this */
3561 if (ep_is_catchpoint (b))
3562 ui_out_text (uiout, "\tcatchpoint");
3564 ui_out_text (uiout, "\tbreakpoint");
3565 ui_out_text (uiout, " already hit ");
3566 ui_out_field_int (uiout, "times", b->hit_count);
3567 if (b->hit_count == 1)
3568 ui_out_text (uiout, " time\n");
3570 ui_out_text (uiout, " times\n");
3573 /* Output the count also if it is zero, but only if this is
3574 mi. FIXME: Should have a better test for this. */
3575 if (ui_out_is_mi_like_p (uiout))
3576 if (show_breakpoint_hit_counts && b->hit_count == 0)
3577 ui_out_field_int (uiout, "times", b->hit_count);
3579 if (b->ignore_count)
3582 ui_out_text (uiout, "\tignore next ");
3583 ui_out_field_int (uiout, "ignore", b->ignore_count);
3584 ui_out_text (uiout, " hits\n");
3587 if ((l = b->commands))
3589 struct cleanup *script_chain;
3592 script_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "script");
3593 print_command_lines (uiout, l, 4);
3594 do_cleanups (script_chain);
3596 do_cleanups (bkpt_chain);
3597 do_cleanups (old_chain);
3600 struct captured_breakpoint_query_args
3606 do_captured_breakpoint_query (struct ui_out *uiout, void *data)
3608 struct captured_breakpoint_query_args *args = data;
3609 struct breakpoint *b;
3610 CORE_ADDR dummy_addr = 0;
3613 if (args->bnum == b->number)
3615 print_one_breakpoint (b, &dummy_addr);
3623 gdb_breakpoint_query (struct ui_out *uiout, int bnum)
3625 struct captured_breakpoint_query_args args;
3627 /* For the moment we don't trust print_one_breakpoint() to not throw
3629 return catch_exceptions (uiout, do_captured_breakpoint_query, &args,
3630 NULL, RETURN_MASK_ALL);
3633 /* Return non-zero if B is user settable (breakpoints, watchpoints,
3634 catchpoints, et.al.). */
3637 user_settable_breakpoint (const struct breakpoint *b)
3639 return (b->type == bp_breakpoint
3640 || b->type == bp_catch_load
3641 || b->type == bp_catch_unload
3642 || b->type == bp_catch_fork
3643 || b->type == bp_catch_vfork
3644 || b->type == bp_catch_exec
3645 || b->type == bp_catch_catch
3646 || b->type == bp_catch_throw
3647 || b->type == bp_hardware_breakpoint
3648 || b->type == bp_watchpoint
3649 || b->type == bp_read_watchpoint
3650 || b->type == bp_access_watchpoint
3651 || b->type == bp_hardware_watchpoint);
3654 /* Print information on user settable breakpoint (watchpoint, etc)
3655 number BNUM. If BNUM is -1 print all user settable breakpoints.
3656 If ALLFLAG is non-zero, include non- user settable breakpoints. */
3659 breakpoint_1 (int bnum, int allflag)
3661 struct breakpoint *b;
3662 CORE_ADDR last_addr = (CORE_ADDR) -1;
3663 int nr_printable_breakpoints;
3664 struct cleanup *bkpttbl_chain;
3666 /* Compute the number of rows in the table. */
3667 nr_printable_breakpoints = 0;
3670 || bnum == b->number)
3672 if (allflag || user_settable_breakpoint (b))
3673 nr_printable_breakpoints++;
3678 = make_cleanup_ui_out_table_begin_end (uiout, 6, nr_printable_breakpoints,
3682 = make_cleanup_ui_out_table_begin_end (uiout, 5, nr_printable_breakpoints,
3685 if (nr_printable_breakpoints > 0)
3686 annotate_breakpoints_headers ();
3687 if (nr_printable_breakpoints > 0)
3689 ui_out_table_header (uiout, 3, ui_left, "number", "Num"); /* 1 */
3690 if (nr_printable_breakpoints > 0)
3692 ui_out_table_header (uiout, 14, ui_left, "type", "Type"); /* 2 */
3693 if (nr_printable_breakpoints > 0)
3695 ui_out_table_header (uiout, 4, ui_left, "disp", "Disp"); /* 3 */
3696 if (nr_printable_breakpoints > 0)
3698 ui_out_table_header (uiout, 3, ui_left, "enabled", "Enb"); /* 4 */
3701 if (nr_printable_breakpoints > 0)
3703 if (TARGET_ADDR_BIT <= 32)
3704 ui_out_table_header (uiout, 10, ui_left, "addr", "Address");/* 5 */
3706 ui_out_table_header (uiout, 18, ui_left, "addr", "Address");/* 5 */
3708 if (nr_printable_breakpoints > 0)
3710 ui_out_table_header (uiout, 40, ui_noalign, "what", "What"); /* 6 */
3711 ui_out_table_body (uiout);
3712 if (nr_printable_breakpoints > 0)
3713 annotate_breakpoints_table ();
3717 || bnum == b->number)
3719 /* We only print out user settable breakpoints unless the
3721 if (allflag || user_settable_breakpoint (b))
3722 print_one_breakpoint (b, &last_addr);
3725 do_cleanups (bkpttbl_chain);
3727 if (nr_printable_breakpoints == 0)
3730 ui_out_message (uiout, 0, "No breakpoints or watchpoints.\n");
3732 ui_out_message (uiout, 0, "No breakpoint or watchpoint number %d.\n",
3737 /* Compare against (CORE_ADDR)-1 in case some compiler decides
3738 that a comparison of an unsigned with -1 is always false. */
3739 if (last_addr != (CORE_ADDR) -1)
3740 set_next_address (last_addr);
3743 /* FIXME? Should this be moved up so that it is only called when
3744 there have been breakpoints? */
3745 annotate_breakpoints_table_end ();
3749 breakpoints_info (char *bnum_exp, int from_tty)
3754 bnum = parse_and_eval_long (bnum_exp);
3756 breakpoint_1 (bnum, 0);
3760 maintenance_info_breakpoints (char *bnum_exp, int from_tty)
3765 bnum = parse_and_eval_long (bnum_exp);
3767 breakpoint_1 (bnum, 1);
3770 /* Print a message describing any breakpoints set at PC. */
3773 describe_other_breakpoints (CORE_ADDR pc, asection *section)
3776 struct breakpoint *b;
3779 if (b->loc->address == pc) /* address match / overlay match */
3780 if (!b->pending && (!overlay_debugging || b->loc->section == section))
3784 printf_filtered ("Note: breakpoint%s ", (others > 1) ? "s" : "");
3786 if (b->loc->address == pc) /* address match / overlay match */
3787 if (!b->pending && (!overlay_debugging || b->loc->section == section))
3790 printf_filtered ("%d%s%s ",
3792 ((b->enable_state == bp_disabled ||
3793 b->enable_state == bp_shlib_disabled ||
3794 b->enable_state == bp_call_disabled)
3796 : b->enable_state == bp_permanent
3800 : ((others == 1) ? " and" : ""));
3802 printf_filtered ("also set at pc ");
3803 print_address_numeric (pc, 1, gdb_stdout);
3804 printf_filtered (".\n");
3808 /* Set the default place to put a breakpoint
3809 for the `break' command with no arguments. */
3812 set_default_breakpoint (int valid, CORE_ADDR addr, struct symtab *symtab,
3815 default_breakpoint_valid = valid;
3816 default_breakpoint_address = addr;
3817 default_breakpoint_symtab = symtab;
3818 default_breakpoint_line = line;
3821 /* Return true iff it is meaningful to use the address member of
3822 BPT. For some breakpoint types, the address member is irrelevant
3823 and it makes no sense to attempt to compare it to other addresses
3824 (or use it for any other purpose either).
3826 More specifically, each of the following breakpoint types will always
3827 have a zero valued address and we don't want check_duplicates() to mark
3828 breakpoints of any of these types to be a duplicate of an actual
3829 breakpoint at address zero:
3832 bp_hardware_watchpoint
3834 bp_access_watchpoint
3841 breakpoint_address_is_meaningful (struct breakpoint *bpt)
3843 enum bptype type = bpt->type;
3845 return (type != bp_watchpoint
3846 && type != bp_hardware_watchpoint
3847 && type != bp_read_watchpoint
3848 && type != bp_access_watchpoint
3849 && type != bp_catch_exec
3850 && type != bp_longjmp_resume
3851 && type != bp_catch_fork
3852 && type != bp_catch_vfork);
3855 /* Rescan breakpoints at the same address and section as BPT,
3856 marking the first one as "first" and any others as "duplicates".
3857 This is so that the bpt instruction is only inserted once.
3858 If we have a permanent breakpoint at the same place as BPT, make
3859 that one the official one, and the rest as duplicates. */
3862 check_duplicates (struct breakpoint *bpt)
3864 struct bp_location *b;
3866 struct bp_location *perm_bp = 0;
3867 CORE_ADDR address = bpt->loc->address;
3868 asection *section = bpt->loc->section;
3870 if (! breakpoint_address_is_meaningful (bpt))
3873 ALL_BP_LOCATIONS (b)
3874 if (b->owner->enable_state != bp_disabled
3875 && b->owner->enable_state != bp_shlib_disabled
3876 && !b->owner->pending
3877 && b->owner->enable_state != bp_call_disabled
3878 && b->address == address /* address / overlay match */
3879 && (!overlay_debugging || b->section == section)
3880 && breakpoint_address_is_meaningful (b->owner))
3882 /* Have we found a permanent breakpoint? */
3883 if (b->owner->enable_state == bp_permanent)
3890 b->duplicate = count > 1;
3893 /* If we found a permanent breakpoint at this address, go over the
3894 list again and declare all the other breakpoints there to be the
3898 perm_bp->duplicate = 0;
3900 /* Permanent breakpoint should always be inserted. */
3901 if (! perm_bp->inserted)
3902 internal_error (__FILE__, __LINE__,
3903 "allegedly permanent breakpoint is not "
3904 "actually inserted");
3906 ALL_BP_LOCATIONS (b)
3909 if (b->owner->enable_state != bp_disabled
3910 && b->owner->enable_state != bp_shlib_disabled
3911 && !b->owner->pending
3912 && b->owner->enable_state != bp_call_disabled
3913 && b->address == address /* address / overlay match */
3914 && (!overlay_debugging || b->section == section)
3915 && breakpoint_address_is_meaningful (b->owner))
3918 internal_error (__FILE__, __LINE__,
3919 "another breakpoint was inserted on top of "
3920 "a permanent breakpoint");
3929 breakpoint_adjustment_warning (CORE_ADDR from_addr, CORE_ADDR to_addr,
3930 int bnum, int have_bnum)
3935 strcpy (astr1, local_hex_string_custom ((unsigned long) from_addr, "08l"));
3936 strcpy (astr2, local_hex_string_custom ((unsigned long) to_addr, "08l"));
3938 warning ("Breakpoint %d address previously adjusted from %s to %s.",
3939 bnum, astr1, astr2);
3941 warning ("Breakpoint address adjusted from %s to %s.", astr1, astr2);
3944 /* Adjust a breakpoint's address to account for architectural constraints
3945 on breakpoint placement. Return the adjusted address. Note: Very
3946 few targets require this kind of adjustment. For most targets,
3947 this function is simply the identity function. */
3950 adjust_breakpoint_address (CORE_ADDR bpaddr)
3952 if (!gdbarch_adjust_breakpoint_address_p (current_gdbarch))
3954 /* Very few targets need any kind of breakpoint adjustment. */
3959 CORE_ADDR adjusted_bpaddr;
3961 /* Some targets have architectural constraints on the placement
3962 of breakpoint instructions. Obtain the adjusted address. */
3963 adjusted_bpaddr = gdbarch_adjust_breakpoint_address (current_gdbarch,
3966 /* An adjusted breakpoint address can significantly alter
3967 a user's expectations. Print a warning if an adjustment
3969 if (adjusted_bpaddr != bpaddr)
3970 breakpoint_adjustment_warning (bpaddr, adjusted_bpaddr, 0, 0);
3972 return adjusted_bpaddr;
3976 /* Allocate a struct bp_location. */
3978 static struct bp_location *
3979 allocate_bp_location (struct breakpoint *bpt, enum bptype bp_type)
3981 struct bp_location *loc, *loc_p;
3983 loc = xmalloc (sizeof (struct bp_location));
3984 memset (loc, 0, sizeof (*loc));
3994 case bp_longjmp_resume:
3995 case bp_step_resume:
3996 case bp_through_sigtramp:
3997 case bp_watchpoint_scope:
3999 case bp_shlib_event:
4000 case bp_thread_event:
4001 case bp_overlay_event:
4003 case bp_catch_unload:
4004 loc->loc_type = bp_loc_software_breakpoint;
4006 case bp_hardware_breakpoint:
4007 loc->loc_type = bp_loc_hardware_breakpoint;
4009 case bp_hardware_watchpoint:
4010 case bp_read_watchpoint:
4011 case bp_access_watchpoint:
4012 loc->loc_type = bp_loc_hardware_watchpoint;
4016 case bp_catch_vfork:
4018 case bp_catch_catch:
4019 case bp_catch_throw:
4020 loc->loc_type = bp_loc_other;
4023 internal_error (__FILE__, __LINE__, "unknown breakpoint type");
4026 /* Add this breakpoint to the end of the chain. */
4028 loc_p = bp_location_chain;
4030 bp_location_chain = loc;
4034 loc_p = loc_p->next;
4041 /* set_raw_breakpoint() is a low level routine for allocating and
4042 partially initializing a breakpoint of type BPTYPE. The newly
4043 created breakpoint's address, section, source file name, and line
4044 number are provided by SAL. The newly created and partially
4045 initialized breakpoint is added to the breakpoint chain and
4046 is also returned as the value of this function.
4048 It is expected that the caller will complete the initialization of
4049 the newly created breakpoint struct as well as output any status
4050 information regarding the creation of a new breakpoint. In
4051 particular, set_raw_breakpoint() does NOT set the breakpoint
4052 number! Care should be taken to not allow an error() to occur
4053 prior to completing the initialization of the breakpoint. If this
4054 should happen, a bogus breakpoint will be left on the chain. */
4057 set_raw_breakpoint (struct symtab_and_line sal, enum bptype bptype)
4059 struct breakpoint *b, *b1;
4061 b = (struct breakpoint *) xmalloc (sizeof (struct breakpoint));
4062 memset (b, 0, sizeof (*b));
4063 b->loc = allocate_bp_location (b, bptype);
4064 b->loc->requested_address = sal.pc;
4065 b->loc->address = adjust_breakpoint_address (b->loc->requested_address);
4066 if (sal.symtab == NULL)
4067 b->source_file = NULL;
4069 b->source_file = savestring (sal.symtab->filename,
4070 strlen (sal.symtab->filename));
4071 b->loc->section = sal.section;
4073 b->language = current_language->la_language;
4074 b->input_radix = input_radix;
4076 b->line_number = sal.line;
4077 b->enable_state = bp_enabled;
4080 b->ignore_count = 0;
4082 b->frame_id = null_frame_id;
4083 b->dll_pathname = NULL;
4084 b->triggered_dll_pathname = NULL;
4085 b->forked_inferior_pid = 0;
4086 b->exec_pathname = NULL;
4090 /* Add this breakpoint to the end of the chain
4091 so that a list of breakpoints will come out in order
4092 of increasing numbers. */
4094 b1 = breakpoint_chain;
4096 breakpoint_chain = b;
4104 check_duplicates (b);
4105 breakpoints_changed ();
4111 /* Note that the breakpoint object B describes a permanent breakpoint
4112 instruction, hard-wired into the inferior's code. */
4114 make_breakpoint_permanent (struct breakpoint *b)
4116 b->enable_state = bp_permanent;
4118 /* By definition, permanent breakpoints are already present in the code. */
4119 b->loc->inserted = 1;
4122 static struct breakpoint *
4123 create_internal_breakpoint (CORE_ADDR address, enum bptype type)
4125 static int internal_breakpoint_number = -1;
4126 struct symtab_and_line sal;
4127 struct breakpoint *b;
4129 init_sal (&sal); /* initialize to zeroes */
4132 sal.section = find_pc_overlay (sal.pc);
4134 b = set_raw_breakpoint (sal, type);
4135 b->number = internal_breakpoint_number--;
4136 b->disposition = disp_donttouch;
4143 create_longjmp_breakpoint (char *func_name)
4145 struct breakpoint *b;
4146 struct minimal_symbol *m;
4148 if (func_name == NULL)
4149 b = create_internal_breakpoint (0, bp_longjmp_resume);
4152 if ((m = lookup_minimal_symbol_text (func_name, NULL)) == NULL)
4155 b = create_internal_breakpoint (SYMBOL_VALUE_ADDRESS (m), bp_longjmp);
4158 b->enable_state = bp_disabled;
4161 b->addr_string = xstrdup (func_name);
4164 /* Call this routine when stepping and nexting to enable a breakpoint
4165 if we do a longjmp(). When we hit that breakpoint, call
4166 set_longjmp_resume_breakpoint() to figure out where we are going. */
4169 enable_longjmp_breakpoint (void)
4171 struct breakpoint *b;
4174 if (b->type == bp_longjmp)
4176 b->enable_state = bp_enabled;
4177 check_duplicates (b);
4182 disable_longjmp_breakpoint (void)
4184 struct breakpoint *b;
4187 if (b->type == bp_longjmp
4188 || b->type == bp_longjmp_resume)
4190 b->enable_state = bp_disabled;
4191 check_duplicates (b);
4196 create_overlay_event_breakpoint (char *func_name)
4198 struct breakpoint *b;
4199 struct minimal_symbol *m;
4201 if ((m = lookup_minimal_symbol_text (func_name, NULL)) == NULL)
4204 b = create_internal_breakpoint (SYMBOL_VALUE_ADDRESS (m),
4206 b->addr_string = xstrdup (func_name);
4208 if (overlay_debugging == ovly_auto)
4210 b->enable_state = bp_enabled;
4211 overlay_events_enabled = 1;
4215 b->enable_state = bp_disabled;
4216 overlay_events_enabled = 0;
4221 enable_overlay_breakpoints (void)
4223 struct breakpoint *b;
4226 if (b->type == bp_overlay_event)
4228 b->enable_state = bp_enabled;
4229 check_duplicates (b);
4230 overlay_events_enabled = 1;
4235 disable_overlay_breakpoints (void)
4237 struct breakpoint *b;
4240 if (b->type == bp_overlay_event)
4242 b->enable_state = bp_disabled;
4243 check_duplicates (b);
4244 overlay_events_enabled = 0;
4249 create_thread_event_breakpoint (CORE_ADDR address)
4251 struct breakpoint *b;
4253 b = create_internal_breakpoint (address, bp_thread_event);
4255 b->enable_state = bp_enabled;
4256 /* addr_string has to be used or breakpoint_re_set will delete me. */
4257 xasprintf (&b->addr_string, "*0x%s", paddr (b->loc->address));
4263 remove_thread_event_breakpoints (void)
4265 struct breakpoint *b, *temp;
4267 ALL_BREAKPOINTS_SAFE (b, temp)
4268 if (b->type == bp_thread_event)
4269 delete_breakpoint (b);
4272 struct captured_parse_breakpoint_args
4275 struct symtabs_and_lines *sals_p;
4276 char ***addr_string_p;
4280 struct lang_and_radix
4286 /* Cleanup helper routine to restore the current language and
4289 do_restore_lang_radix_cleanup (void *old)
4291 struct lang_and_radix *p = old;
4292 set_language (p->lang);
4293 input_radix = p->radix;
4296 /* Try and resolve a pending breakpoint. */
4298 resolve_pending_breakpoint (struct breakpoint *b)
4300 /* Try and reparse the breakpoint in case the shared library
4302 struct symtabs_and_lines sals;
4303 struct symtab_and_line pending_sal;
4304 char **cond_string = (char **) NULL;
4305 char *copy_arg = b->addr_string;
4310 struct ui_file *old_gdb_stderr;
4311 struct lang_and_radix old_lr;
4312 struct cleanup *old_chain;
4314 /* Set language, input-radix, then reissue breakpoint command.
4315 Ensure the language and input-radix are restored afterwards. */
4316 old_lr.lang = current_language->la_language;
4317 old_lr.radix = input_radix;
4318 old_chain = make_cleanup (do_restore_lang_radix_cleanup, &old_lr);
4320 set_language (b->language);
4321 input_radix = b->input_radix;
4322 rc = break_command_1 (b->addr_string, b->flag, b->from_tty, b);
4324 if (rc == GDB_RC_OK)
4325 /* Pending breakpoint has been resolved. */
4326 printf_filtered ("Pending breakpoint \"%s\" resolved\n", b->addr_string);
4328 do_cleanups (old_chain);
4334 remove_solib_event_breakpoints (void)
4336 struct breakpoint *b, *temp;
4338 ALL_BREAKPOINTS_SAFE (b, temp)
4339 if (b->type == bp_shlib_event)
4340 delete_breakpoint (b);
4344 create_solib_event_breakpoint (CORE_ADDR address)
4346 struct breakpoint *b;
4348 b = create_internal_breakpoint (address, bp_shlib_event);
4352 /* Disable any breakpoints that are on code in shared libraries. Only
4353 apply to enabled breakpoints, disabled ones can just stay disabled. */
4356 disable_breakpoints_in_shlibs (int silent)
4358 struct breakpoint *b;
4359 int disabled_shlib_breaks = 0;
4361 /* See also: insert_breakpoints, under DISABLE_UNSETTABLE_BREAK. */
4364 #if defined (PC_SOLIB)
4365 if (((b->type == bp_breakpoint) ||
4366 (b->type == bp_hardware_breakpoint)) &&
4367 breakpoint_enabled (b) &&
4368 !b->loc->duplicate &&
4369 PC_SOLIB (b->loc->address))
4371 b->enable_state = bp_shlib_disabled;
4374 if (!disabled_shlib_breaks)
4376 target_terminal_ours_for_output ();
4377 warning ("Temporarily disabling shared library breakpoints:");
4379 disabled_shlib_breaks = 1;
4380 warning ("breakpoint #%d ", b->number);
4387 /* Try to reenable any breakpoints in shared libraries. */
4389 re_enable_breakpoints_in_shlibs (void)
4391 struct breakpoint *b, *tmp;
4393 ALL_BREAKPOINTS_SAFE (b, tmp)
4395 if (b->enable_state == bp_shlib_disabled)
4399 /* Do not reenable the breakpoint if the shared library
4400 is still not mapped in. */
4401 lib = PC_SOLIB (b->loc->address);
4402 if (lib != NULL && target_read_memory (b->loc->address, buf, 1) == 0)
4403 b->enable_state = bp_enabled;
4405 else if (b->pending && (b->enable_state == bp_enabled))
4407 if (resolve_pending_breakpoint (b) == GDB_RC_OK)
4408 delete_breakpoint (b);
4416 solib_load_unload_1 (char *hookname, int tempflag, char *dll_pathname,
4417 char *cond_string, enum bptype bp_kind)
4419 struct breakpoint *b;
4420 struct symtabs_and_lines sals;
4421 struct cleanup *old_chain;
4422 struct cleanup *canonical_strings_chain = NULL;
4423 char *addr_start = hookname;
4424 char *addr_end = NULL;
4425 char **canonical = (char **) NULL;
4426 int thread = -1; /* All threads. */
4428 /* Set a breakpoint on the specified hook. */
4429 sals = decode_line_1 (&hookname, 1, (struct symtab *) NULL, 0, &canonical, NULL);
4430 addr_end = hookname;
4432 if (sals.nelts == 0)
4434 warning ("Unable to set a breakpoint on dynamic linker callback.");
4435 warning ("Suggest linking with /opt/langtools/lib/end.o.");
4436 warning ("GDB will be unable to track shl_load/shl_unload calls");
4439 if (sals.nelts != 1)
4441 warning ("Unable to set unique breakpoint on dynamic linker callback.");
4442 warning ("GDB will be unable to track shl_load/shl_unload calls");
4446 /* Make sure that all storage allocated in decode_line_1 gets freed
4447 in case the following errors out. */
4448 old_chain = make_cleanup (xfree, sals.sals);
4449 if (canonical != (char **) NULL)
4451 make_cleanup (xfree, canonical);
4452 canonical_strings_chain = make_cleanup (null_cleanup, 0);
4453 if (canonical[0] != NULL)
4454 make_cleanup (xfree, canonical[0]);
4457 resolve_sal_pc (&sals.sals[0]);
4459 /* Remove the canonical strings from the cleanup, they are needed below. */
4460 if (canonical != (char **) NULL)
4461 discard_cleanups (canonical_strings_chain);
4463 b = set_raw_breakpoint (sals.sals[0], bp_kind);
4464 set_breakpoint_count (breakpoint_count + 1);
4465 b->number = breakpoint_count;
4467 b->cond_string = (cond_string == NULL) ?
4468 NULL : savestring (cond_string, strlen (cond_string));
4471 if (canonical != (char **) NULL && canonical[0] != NULL)
4472 b->addr_string = canonical[0];
4473 else if (addr_start)
4474 b->addr_string = savestring (addr_start, addr_end - addr_start);
4476 b->enable_state = bp_enabled;
4477 b->disposition = tempflag ? disp_del : disp_donttouch;
4479 if (dll_pathname == NULL)
4480 b->dll_pathname = NULL;
4483 b->dll_pathname = (char *) xmalloc (strlen (dll_pathname) + 1);
4484 strcpy (b->dll_pathname, dll_pathname);
4488 do_cleanups (old_chain);
4492 create_solib_load_event_breakpoint (char *hookname, int tempflag,
4493 char *dll_pathname, char *cond_string)
4495 solib_load_unload_1 (hookname, tempflag, dll_pathname,
4496 cond_string, bp_catch_load);
4500 create_solib_unload_event_breakpoint (char *hookname, int tempflag,
4501 char *dll_pathname, char *cond_string)
4503 solib_load_unload_1 (hookname,tempflag, dll_pathname,
4504 cond_string, bp_catch_unload);
4508 create_fork_vfork_event_catchpoint (int tempflag, char *cond_string,
4509 enum bptype bp_kind)
4511 struct symtab_and_line sal;
4512 struct breakpoint *b;
4513 int thread = -1; /* All threads. */
4520 b = set_raw_breakpoint (sal, bp_kind);
4521 set_breakpoint_count (breakpoint_count + 1);
4522 b->number = breakpoint_count;
4524 b->cond_string = (cond_string == NULL) ?
4525 NULL : savestring (cond_string, strlen (cond_string));
4527 b->addr_string = NULL;
4528 b->enable_state = bp_enabled;
4529 b->disposition = tempflag ? disp_del : disp_donttouch;
4530 b->forked_inferior_pid = 0;
4536 create_fork_event_catchpoint (int tempflag, char *cond_string)
4538 create_fork_vfork_event_catchpoint (tempflag, cond_string, bp_catch_fork);
4542 create_vfork_event_catchpoint (int tempflag, char *cond_string)
4544 create_fork_vfork_event_catchpoint (tempflag, cond_string, bp_catch_vfork);
4548 create_exec_event_catchpoint (int tempflag, char *cond_string)
4550 struct symtab_and_line sal;
4551 struct breakpoint *b;
4552 int thread = -1; /* All threads. */
4559 b = set_raw_breakpoint (sal, bp_catch_exec);
4560 set_breakpoint_count (breakpoint_count + 1);
4561 b->number = breakpoint_count;
4563 b->cond_string = (cond_string == NULL) ?
4564 NULL : savestring (cond_string, strlen (cond_string));
4566 b->addr_string = NULL;
4567 b->enable_state = bp_enabled;
4568 b->disposition = tempflag ? disp_del : disp_donttouch;
4574 hw_breakpoint_used_count (void)
4576 struct breakpoint *b;
4581 if (b->type == bp_hardware_breakpoint && b->enable_state == bp_enabled)
4589 hw_watchpoint_used_count (enum bptype type, int *other_type_used)
4591 struct breakpoint *b;
4594 *other_type_used = 0;
4597 if (breakpoint_enabled (b))
4599 if (b->type == type)
4601 else if ((b->type == bp_hardware_watchpoint ||
4602 b->type == bp_read_watchpoint ||
4603 b->type == bp_access_watchpoint))
4604 *other_type_used = 1;
4610 /* Call this after hitting the longjmp() breakpoint. Use this to set
4611 a new breakpoint at the target of the jmp_buf.
4613 FIXME - This ought to be done by setting a temporary breakpoint
4614 that gets deleted automatically... */
4617 set_longjmp_resume_breakpoint (CORE_ADDR pc, struct frame_id frame_id)
4619 struct breakpoint *b;
4622 if (b->type == bp_longjmp_resume)
4624 b->loc->requested_address = pc;
4625 b->loc->address = adjust_breakpoint_address (b->loc->requested_address);
4626 b->enable_state = bp_enabled;
4627 b->frame_id = frame_id;
4628 check_duplicates (b);
4634 disable_watchpoints_before_interactive_call_start (void)
4636 struct breakpoint *b;
4640 if (((b->type == bp_watchpoint)
4641 || (b->type == bp_hardware_watchpoint)
4642 || (b->type == bp_read_watchpoint)
4643 || (b->type == bp_access_watchpoint)
4644 || ep_is_exception_catchpoint (b))
4645 && breakpoint_enabled (b))
4647 b->enable_state = bp_call_disabled;
4648 check_duplicates (b);
4654 enable_watchpoints_after_interactive_call_stop (void)
4656 struct breakpoint *b;
4660 if (((b->type == bp_watchpoint)
4661 || (b->type == bp_hardware_watchpoint)
4662 || (b->type == bp_read_watchpoint)
4663 || (b->type == bp_access_watchpoint)
4664 || ep_is_exception_catchpoint (b))
4665 && (b->enable_state == bp_call_disabled))
4667 b->enable_state = bp_enabled;
4668 check_duplicates (b);
4674 /* Set a breakpoint that will evaporate an end of command
4675 at address specified by SAL.
4676 Restrict it to frame FRAME if FRAME is nonzero. */
4679 set_momentary_breakpoint (struct symtab_and_line sal, struct frame_id frame_id,
4682 struct breakpoint *b;
4683 b = set_raw_breakpoint (sal, type);
4684 b->enable_state = bp_enabled;
4685 b->disposition = disp_donttouch;
4686 b->frame_id = frame_id;
4688 /* If we're debugging a multi-threaded program, then we
4689 want momentary breakpoints to be active in only a
4690 single thread of control. */
4691 if (in_thread_list (inferior_ptid))
4692 b->thread = pid_to_thread_id (inferior_ptid);
4698 /* Tell the user we have just set a breakpoint B. */
4701 mention (struct breakpoint *b)
4704 struct cleanup *old_chain, *ui_out_chain;
4705 struct ui_stream *stb;
4707 stb = ui_out_stream_new (uiout);
4708 old_chain = make_cleanup_ui_out_stream_delete (stb);
4710 /* FIXME: This is misplaced; mention() is called by things (like hitting a
4711 watchpoint) other than breakpoint creation. It should be possible to
4712 clean this up and at the same time replace the random calls to
4713 breakpoint_changed with this hook, as has already been done for
4714 delete_breakpoint_hook and so on. */
4715 if (create_breakpoint_hook)
4716 create_breakpoint_hook (b);
4717 breakpoint_create_event (b->number);
4719 if (b->ops != NULL && b->ops->print_mention != NULL)
4720 b->ops->print_mention (b);
4725 printf_filtered ("(apparently deleted?) Eventpoint %d: ", b->number);
4728 ui_out_text (uiout, "Watchpoint ");
4729 ui_out_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "wpt");
4730 ui_out_field_int (uiout, "number", b->number);
4731 ui_out_text (uiout, ": ");
4732 print_expression (b->exp, stb->stream);
4733 ui_out_field_stream (uiout, "exp", stb);
4734 do_cleanups (ui_out_chain);
4736 case bp_hardware_watchpoint:
4737 ui_out_text (uiout, "Hardware watchpoint ");
4738 ui_out_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "wpt");
4739 ui_out_field_int (uiout, "number", b->number);
4740 ui_out_text (uiout, ": ");
4741 print_expression (b->exp, stb->stream);
4742 ui_out_field_stream (uiout, "exp", stb);
4743 do_cleanups (ui_out_chain);
4745 case bp_read_watchpoint:
4746 ui_out_text (uiout, "Hardware read watchpoint ");
4747 ui_out_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "hw-rwpt");
4748 ui_out_field_int (uiout, "number", b->number);
4749 ui_out_text (uiout, ": ");
4750 print_expression (b->exp, stb->stream);
4751 ui_out_field_stream (uiout, "exp", stb);
4752 do_cleanups (ui_out_chain);
4754 case bp_access_watchpoint:
4755 ui_out_text (uiout, "Hardware access (read/write) watchpoint ");
4756 ui_out_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "hw-awpt");
4757 ui_out_field_int (uiout, "number", b->number);
4758 ui_out_text (uiout, ": ");
4759 print_expression (b->exp, stb->stream);
4760 ui_out_field_stream (uiout, "exp", stb);
4761 do_cleanups (ui_out_chain);
4764 if (ui_out_is_mi_like_p (uiout))
4769 printf_filtered ("Breakpoint %d", b->number);
4772 case bp_hardware_breakpoint:
4773 if (ui_out_is_mi_like_p (uiout))
4778 printf_filtered ("Hardware assisted breakpoint %d", b->number);
4782 case bp_catch_unload:
4783 printf_filtered ("Catchpoint %d (%s %s)",
4785 (b->type == bp_catch_load) ? "load" : "unload",
4786 (b->dll_pathname != NULL) ?
4787 b->dll_pathname : "<any library>");
4790 case bp_catch_vfork:
4791 printf_filtered ("Catchpoint %d (%s)",
4793 (b->type == bp_catch_fork) ? "fork" : "vfork");
4796 printf_filtered ("Catchpoint %d (exec)",
4799 case bp_catch_catch:
4800 case bp_catch_throw:
4801 printf_filtered ("Catchpoint %d (%s)",
4803 (b->type == bp_catch_catch) ? "catch" : "throw");
4809 case bp_longjmp_resume:
4810 case bp_step_resume:
4811 case bp_through_sigtramp:
4813 case bp_watchpoint_scope:
4814 case bp_shlib_event:
4815 case bp_thread_event:
4816 case bp_overlay_event:
4824 printf_filtered (" (%s) pending.", b->addr_string);
4828 if (addressprint || b->source_file == NULL)
4830 printf_filtered (" at ");
4831 print_address_numeric (b->loc->address, 1, gdb_stdout);
4834 printf_filtered (": file %s, line %d.",
4835 b->source_file, b->line_number);
4838 do_cleanups (old_chain);
4839 if (ui_out_is_mi_like_p (uiout))
4841 printf_filtered ("\n");
4845 /* Add SALS.nelts breakpoints to the breakpoint table. For each
4846 SALS.sal[i] breakpoint, include the corresponding ADDR_STRING[i],
4847 COND[i] and COND_STRING[i] values.
4849 The parameter PENDING_BP points to a pending breakpoint that is
4850 the basis of the breakpoints currently being created. The pending
4851 breakpoint may contain a separate condition string or commands
4852 that were added after the initial pending breakpoint was created.
4854 NOTE: If the function succeeds, the caller is expected to cleanup
4855 the arrays ADDR_STRING, COND_STRING, COND and SALS (but not the
4856 array contents). If the function fails (error() is called), the
4857 caller is expected to cleanups both the ADDR_STRING, COND_STRING,
4858 COND and SALS arrays and each of those arrays contents. */
4861 create_breakpoints (struct symtabs_and_lines sals, char **addr_string,
4862 struct expression **cond, char **cond_string,
4863 enum bptype type, enum bpdisp disposition,
4864 int thread, int ignore_count, int from_tty,
4865 struct breakpoint *pending_bp)
4867 if (type == bp_hardware_breakpoint)
4869 int i = hw_breakpoint_used_count ();
4870 int target_resources_ok =
4871 TARGET_CAN_USE_HARDWARE_WATCHPOINT (bp_hardware_breakpoint,
4873 if (target_resources_ok == 0)
4874 error ("No hardware breakpoint support in the target.");
4875 else if (target_resources_ok < 0)
4876 error ("Hardware breakpoints used exceeds limit.");
4879 /* Now set all the breakpoints. */
4882 for (i = 0; i < sals.nelts; i++)
4884 struct breakpoint *b;
4885 struct symtab_and_line sal = sals.sals[i];
4888 describe_other_breakpoints (sal.pc, sal.section);
4890 b = set_raw_breakpoint (sal, type);
4891 set_breakpoint_count (breakpoint_count + 1);
4892 b->number = breakpoint_count;
4896 b->addr_string = addr_string[i];
4898 /* addr_string has to be used or breakpoint_re_set will delete
4900 xasprintf (&b->addr_string, "*0x%s", paddr (b->loc->address));
4901 b->cond_string = cond_string[i];
4902 b->ignore_count = ignore_count;
4903 b->enable_state = bp_enabled;
4904 b->disposition = disposition;
4905 /* If resolving a pending breakpoint, a check must be made to see if
4906 the user has specified a new condition or commands for the
4907 breakpoint. A new condition will override any condition that was
4908 initially specified with the initial breakpoint command. */
4912 if (pending_bp->cond_string)
4914 arg = pending_bp->cond_string;
4915 b->cond_string = savestring (arg, strlen (arg));
4916 b->cond = parse_exp_1 (&arg, block_for_pc (b->loc->address), 0);
4918 error ("Junk at end of pending breakpoint condition expression");
4920 /* If there are commands associated with the breakpoint, they should
4922 if (pending_bp->commands)
4923 b->commands = copy_command_lines (pending_bp->commands);
4930 /* Parse ARG which is assumed to be a SAL specification possibly
4931 followed by conditionals. On return, SALS contains an array of SAL
4932 addresses found. ADDR_STRING contains a vector of (canonical)
4933 address strings. ARG points to the end of the SAL. */
4936 parse_breakpoint_sals (char **address,
4937 struct symtabs_and_lines *sals,
4938 char ***addr_string,
4941 char *addr_start = *address;
4942 *addr_string = NULL;
4943 /* If no arg given, or if first arg is 'if ', use the default
4945 if ((*address) == NULL
4946 || (strncmp ((*address), "if", 2) == 0 && isspace ((*address)[2])))
4948 if (default_breakpoint_valid)
4950 struct symtab_and_line sal;
4951 init_sal (&sal); /* initialize to zeroes */
4952 sals->sals = (struct symtab_and_line *)
4953 xmalloc (sizeof (struct symtab_and_line));
4954 sal.pc = default_breakpoint_address;
4955 sal.line = default_breakpoint_line;
4956 sal.symtab = default_breakpoint_symtab;
4957 sal.section = find_pc_overlay (sal.pc);
4958 sals->sals[0] = sal;
4962 error ("No default breakpoint address now.");
4966 /* Force almost all breakpoints to be in terms of the
4967 current_source_symtab (which is decode_line_1's default). This
4968 should produce the results we want almost all of the time while
4969 leaving default_breakpoint_* alone.
4970 ObjC: However, don't match an Objective-C method name which
4971 may have a '+' or '-' succeeded by a '[' */
4973 struct symtab_and_line cursal = get_current_source_symtab_and_line ();
4975 if (default_breakpoint_valid
4977 || ((strchr ("+-", (*address)[0]) != NULL)
4978 && ((*address)[1] != '['))))
4979 *sals = decode_line_1 (address, 1, default_breakpoint_symtab,
4980 default_breakpoint_line, addr_string,
4983 *sals = decode_line_1 (address, 1, (struct symtab *) NULL, 0,
4984 addr_string, not_found_ptr);
4986 /* For any SAL that didn't have a canonical string, fill one in. */
4987 if (sals->nelts > 0 && *addr_string == NULL)
4988 *addr_string = xcalloc (sals->nelts, sizeof (char **));
4989 if (addr_start != (*address))
4992 for (i = 0; i < sals->nelts; i++)
4994 /* Add the string if not present. */
4995 if ((*addr_string)[i] == NULL)
4996 (*addr_string)[i] = savestring (addr_start, (*address) - addr_start);
5002 /* Convert each SAL into a real PC. Verify that the PC can be
5003 inserted as a breakpoint. If it can't throw an error. */
5006 breakpoint_sals_to_pc (struct symtabs_and_lines *sals,
5010 for (i = 0; i < sals->nelts; i++)
5012 resolve_sal_pc (&sals->sals[i]);
5014 /* It's possible for the PC to be nonzero, but still an illegal
5015 value on some targets.
5017 For example, on HP-UX if you start gdb, and before running the
5018 inferior you try to set a breakpoint on a shared library function
5019 "foo" where the inferior doesn't call "foo" directly but does
5020 pass its address to another function call, then we do find a
5021 minimal symbol for the "foo", but it's address is invalid.
5022 (Appears to be an index into a table that the loader sets up
5023 when the inferior is run.)
5025 Give the target a chance to bless sals.sals[i].pc before we
5026 try to make a breakpoint for it. */
5027 if (PC_REQUIRES_RUN_BEFORE_USE (sals->sals[i].pc))
5029 if (address == NULL)
5030 error ("Cannot break without a running program.");
5032 error ("Cannot break on %s without a running program.",
5039 do_captured_parse_breakpoint (struct ui_out *ui, void *data)
5041 struct captured_parse_breakpoint_args *args = data;
5043 parse_breakpoint_sals (args->arg_p, args->sals_p, args->addr_string_p,
5044 args->not_found_ptr);
5049 /* Set a breakpoint according to ARG (function, linenum or *address)
5050 flag: first bit : 0 non-temporary, 1 temporary.
5051 second bit : 0 normal breakpoint, 1 hardware breakpoint.
5053 PENDING_BP is non-NULL when this function is being called to resolve
5054 a pending breakpoint. */
5057 break_command_1 (char *arg, int flag, int from_tty, struct breakpoint *pending_bp)
5059 int tempflag, hardwareflag;
5060 struct symtabs_and_lines sals;
5061 struct expression **cond = 0;
5062 struct symtab_and_line pending_sal;
5063 char **cond_string = (char **) NULL;
5066 char *addr_start = arg;
5068 struct cleanup *old_chain;
5069 struct cleanup *breakpoint_chain = NULL;
5070 struct captured_parse_breakpoint_args parse_args;
5074 int ignore_count = 0;
5077 hardwareflag = flag & BP_HARDWAREFLAG;
5078 tempflag = flag & BP_TEMPFLAG;
5084 parse_args.arg_p = &arg;
5085 parse_args.sals_p = &sals;
5086 parse_args.addr_string_p = &addr_string;
5087 parse_args.not_found_ptr = ¬_found;
5089 rc = catch_exceptions_with_msg (uiout, do_captured_parse_breakpoint,
5090 &parse_args, NULL, &err_msg,
5093 /* If caller is interested in rc value from parse, set value. */
5095 if (rc != GDB_RC_OK)
5097 /* Check for file or function not found. */
5100 /* If called to resolve pending breakpoint, just return error code. */
5104 error_output_message (NULL, err_msg);
5107 /* If pending breakpoint support is turned off, throw error. */
5109 if (pending_break_support == AUTO_BOOLEAN_FALSE)
5110 throw_exception (RETURN_ERROR);
5112 /* If pending breakpoint support is auto query and the user selects
5113 no, then simply return the error code. */
5114 if (pending_break_support == AUTO_BOOLEAN_AUTO &&
5115 !nquery ("Make breakpoint pending on future shared library load? "))
5118 /* At this point, either the user was queried about setting a
5119 pending breakpoint and selected yes, or pending breakpoint
5120 behavior is on and thus a pending breakpoint is defaulted
5121 on behalf of the user. */
5122 copy_arg = xstrdup (addr_start);
5123 addr_string = ©_arg;
5125 sals.sals = &pending_sal;
5132 else if (!sals.nelts)
5135 /* Create a chain of things that always need to be cleaned up. */
5136 old_chain = make_cleanup (null_cleanup, 0);
5140 /* Make sure that all storage allocated to SALS gets freed. */
5141 make_cleanup (xfree, sals.sals);
5143 /* Cleanup the addr_string array but not its contents. */
5144 make_cleanup (xfree, addr_string);
5147 /* Allocate space for all the cond expressions. */
5148 cond = xcalloc (sals.nelts, sizeof (struct expression *));
5149 make_cleanup (xfree, cond);
5151 /* Allocate space for all the cond strings. */
5152 cond_string = xcalloc (sals.nelts, sizeof (char **));
5153 make_cleanup (xfree, cond_string);
5155 /* ----------------------------- SNIP -----------------------------
5156 Anything added to the cleanup chain beyond this point is assumed
5157 to be part of a breakpoint. If the breakpoint create succeeds
5158 then the memory is not reclaimed. */
5159 breakpoint_chain = make_cleanup (null_cleanup, 0);
5161 /* Mark the contents of the addr_string for cleanup. These go on
5162 the breakpoint_chain and only occure if the breakpoint create
5164 for (i = 0; i < sals.nelts; i++)
5166 if (addr_string[i] != NULL)
5167 make_cleanup (xfree, addr_string[i]);
5170 /* Resolve all line numbers to PC's and verify that the addresses
5171 are ok for the target. */
5173 breakpoint_sals_to_pc (&sals, addr_start);
5175 /* Verify that condition can be parsed, before setting any
5176 breakpoints. Allocate a separate condition expression for each
5178 thread = -1; /* No specific thread yet */
5181 for (i = 0; i < sals.nelts; i++)
5188 char *cond_start = NULL;
5189 char *cond_end = NULL;
5190 while (*tok == ' ' || *tok == '\t')
5195 while (*end_tok != ' ' && *end_tok != '\t' && *end_tok != '\000')
5198 toklen = end_tok - tok;
5200 if (toklen >= 1 && strncmp (tok, "if", toklen) == 0)
5202 tok = cond_start = end_tok + 1;
5203 cond[i] = parse_exp_1 (&tok, block_for_pc (sals.sals[i].pc),
5205 make_cleanup (xfree, cond[i]);
5207 cond_string[i] = savestring (cond_start,
5208 cond_end - cond_start);
5209 make_cleanup (xfree, cond_string[i]);
5211 else if (toklen >= 1 && strncmp (tok, "thread", toklen) == 0)
5217 thread = strtol (tok, &tok, 0);
5219 error ("Junk after thread keyword.");
5220 if (!valid_thread_id (thread))
5221 error ("Unknown thread %d\n", thread);
5224 error ("Junk at end of arguments.");
5227 create_breakpoints (sals, addr_string, cond, cond_string,
5228 hardwareflag ? bp_hardware_breakpoint
5230 tempflag ? disp_del : disp_donttouch,
5231 thread, ignore_count, from_tty,
5236 struct symtab_and_line sal;
5237 struct breakpoint *b;
5242 make_cleanup (xfree, copy_arg);
5244 b = set_raw_breakpoint (sal, hardwareflag ? bp_hardware_breakpoint
5246 set_breakpoint_count (breakpoint_count + 1);
5247 b->number = breakpoint_count;
5250 b->addr_string = *addr_string;
5251 b->cond_string = *cond_string;
5252 b->ignore_count = ignore_count;
5254 b->disposition = tempflag ? disp_del : disp_donttouch;
5255 b->from_tty = from_tty;
5262 warning ("Multiple breakpoints were set.");
5263 warning ("Use the \"delete\" command to delete unwanted breakpoints.");
5265 /* That's it. Discard the cleanups for data inserted into the
5267 discard_cleanups (breakpoint_chain);
5268 /* But cleanup everything else. */
5269 do_cleanups (old_chain);
5274 /* Set a breakpoint of TYPE/DISPOSITION according to ARG (function,
5275 linenum or *address) with COND and IGNORE_COUNT. */
5277 struct captured_breakpoint_args
5288 do_captured_breakpoint (void *data)
5290 struct captured_breakpoint_args *args = data;
5291 struct symtabs_and_lines sals;
5292 struct expression **cond;
5293 struct cleanup *old_chain;
5294 struct cleanup *breakpoint_chain = NULL;
5301 /* Parse the source and lines spec. Delay check that the expression
5302 didn't contain trailing garbage until after cleanups are in
5306 address_end = args->address;
5308 parse_breakpoint_sals (&address_end, &sals, &addr_string, 0);
5313 /* Create a chain of things at always need to be cleaned up. */
5314 old_chain = make_cleanup (null_cleanup, 0);
5316 /* Always have a addr_string array, even if it is empty. */
5317 make_cleanup (xfree, addr_string);
5319 /* Make sure that all storage allocated to SALS gets freed. */
5320 make_cleanup (xfree, sals.sals);
5322 /* Allocate space for all the cond expressions. */
5323 cond = xcalloc (sals.nelts, sizeof (struct expression *));
5324 make_cleanup (xfree, cond);
5326 /* Allocate space for all the cond strings. */
5327 cond_string = xcalloc (sals.nelts, sizeof (char **));
5328 make_cleanup (xfree, cond_string);
5330 /* ----------------------------- SNIP -----------------------------
5331 Anything added to the cleanup chain beyond this point is assumed
5332 to be part of a breakpoint. If the breakpoint create goes
5333 through then that memory is not cleaned up. */
5334 breakpoint_chain = make_cleanup (null_cleanup, 0);
5336 /* Mark the contents of the addr_string for cleanup. These go on
5337 the breakpoint_chain and only occure if the breakpoint create
5339 for (i = 0; i < sals.nelts; i++)
5341 if (addr_string[i] != NULL)
5342 make_cleanup (xfree, addr_string[i]);
5345 /* Wait until now before checking for garbage at the end of the
5346 address. That way cleanups can take care of freeing any
5348 if (*address_end != '\0')
5349 error ("Garbage %s following breakpoint address", address_end);
5351 /* Resolve all line numbers to PC's. */
5352 breakpoint_sals_to_pc (&sals, args->address);
5354 /* Verify that conditions can be parsed, before setting any
5356 for (i = 0; i < sals.nelts; i++)
5358 if (args->condition != NULL)
5360 char *tok = args->condition;
5361 cond[i] = parse_exp_1 (&tok, block_for_pc (sals.sals[i].pc), 0);
5363 error ("Garbage %s follows condition", tok);
5364 make_cleanup (xfree, cond[i]);
5365 cond_string[i] = xstrdup (args->condition);
5369 create_breakpoints (sals, addr_string, cond, cond_string,
5370 args->hardwareflag ? bp_hardware_breakpoint : bp_breakpoint,
5371 args->tempflag ? disp_del : disp_donttouch,
5372 args->thread, args->ignore_count, 0/*from-tty*/,
5373 NULL/*pending_bp*/);
5375 /* That's it. Discard the cleanups for data inserted into the
5377 discard_cleanups (breakpoint_chain);
5378 /* But cleanup everything else. */
5379 do_cleanups (old_chain);
5384 gdb_breakpoint (char *address, char *condition,
5385 int hardwareflag, int tempflag,
5386 int thread, int ignore_count)
5388 struct captured_breakpoint_args args;
5389 args.address = address;
5390 args.condition = condition;
5391 args.hardwareflag = hardwareflag;
5392 args.tempflag = tempflag;
5393 args.thread = thread;
5394 args.ignore_count = ignore_count;
5395 return catch_errors (do_captured_breakpoint, &args,
5396 NULL, RETURN_MASK_ALL);
5401 break_at_finish_at_depth_command_1 (char *arg, int flag, int from_tty)
5403 struct frame_info *frame;
5404 CORE_ADDR low, high, selected_pc = 0;
5405 char *extra_args = NULL;
5407 int extra_args_len = 0, if_arg = 0;
5410 (arg[0] == 'i' && arg[1] == 'f' && (arg[2] == ' ' || arg[2] == '\t')))
5413 if (default_breakpoint_valid)
5415 if (deprecated_selected_frame)
5417 selected_pc = get_frame_pc (deprecated_selected_frame);
5422 error ("No selected frame.");
5425 error ("No default breakpoint address now.");
5429 extra_args = strchr (arg, ' ');
5433 extra_args_len = strlen (extra_args);
5434 level_arg = (char *) xmalloc (extra_args - arg);
5435 strncpy (level_arg, arg, extra_args - arg - 1);
5436 level_arg[extra_args - arg - 1] = '\0';
5440 level_arg = (char *) xmalloc (strlen (arg) + 1);
5441 strcpy (level_arg, arg);
5444 frame = parse_frame_specification (level_arg);
5446 selected_pc = get_frame_pc (frame);
5453 extra_args_len = strlen (arg);
5458 if (find_pc_partial_function (selected_pc, (char **) NULL, &low, &high))
5462 addr_string = xstrprintf ("*0x%s %s", paddr_nz (high), extra_args);
5464 addr_string = xstrprintf ("*0x%s", paddr_nz (high));
5465 break_command_1 (addr_string, flag, from_tty, NULL);
5466 xfree (addr_string);
5469 error ("No function contains the specified address");
5472 error ("Unable to set breakpoint at procedure exit");
5477 break_at_finish_command_1 (char *arg, int flag, int from_tty)
5479 char *addr_string, *break_string, *beg_addr_string;
5480 CORE_ADDR low, high;
5481 struct symtabs_and_lines sals;
5482 struct symtab_and_line sal;
5483 struct cleanup *old_chain;
5484 char *extra_args = NULL;
5485 int extra_args_len = 0;
5489 (arg[0] == 'i' && arg[1] == 'f' && (arg[2] == ' ' || arg[2] == '\t')))
5491 if (default_breakpoint_valid)
5493 if (deprecated_selected_frame)
5495 addr_string = xstrprintf ("*0x%s",
5496 paddr_nz (get_frame_pc (deprecated_selected_frame)));
5501 error ("No selected frame.");
5504 error ("No default breakpoint address now.");
5508 addr_string = (char *) xmalloc (strlen (arg) + 1);
5509 strcpy (addr_string, arg);
5515 extra_args_len = strlen (arg);
5519 /* get the stuff after the function name or address */
5520 extra_args = strchr (arg, ' ');
5524 extra_args_len = strlen (extra_args);
5531 beg_addr_string = addr_string;
5532 sals = decode_line_1 (&addr_string, 1, (struct symtab *) NULL, 0,
5533 (char ***) NULL, NULL);
5535 xfree (beg_addr_string);
5536 old_chain = make_cleanup (xfree, sals.sals);
5537 for (i = 0; (i < sals.nelts); i++)
5540 if (find_pc_partial_function (sal.pc, (char **) NULL, &low, &high))
5544 break_string = xstrprintf ("*0x%s %s", paddr_nz (high),
5547 break_string = xstrprintf ("*0x%s", paddr_nz (high));
5548 break_command_1 (break_string, flag, from_tty, NULL);
5549 xfree (break_string);
5552 error ("No function contains the specified address");
5556 warning ("Multiple breakpoints were set.\n");
5557 warning ("Use the \"delete\" command to delete unwanted breakpoints.");
5559 do_cleanups (old_chain);
5563 /* Helper function for break_command_1 and disassemble_command. */
5566 resolve_sal_pc (struct symtab_and_line *sal)
5570 if (sal->pc == 0 && sal->symtab != NULL)
5572 if (!find_line_pc (sal->symtab, sal->line, &pc))
5573 error ("No line %d in file \"%s\".",
5574 sal->line, sal->symtab->filename);
5578 if (sal->section == 0 && sal->symtab != NULL)
5580 struct blockvector *bv;
5585 bv = blockvector_for_pc_sect (sal->pc, 0, &index, sal->symtab);
5588 b = BLOCKVECTOR_BLOCK (bv, index);
5589 sym = block_function (b);
5592 fixup_symbol_section (sym, sal->symtab->objfile);
5593 sal->section = SYMBOL_BFD_SECTION (sym);
5597 /* It really is worthwhile to have the section, so we'll just
5598 have to look harder. This case can be executed if we have
5599 line numbers but no functions (as can happen in assembly
5602 struct minimal_symbol *msym;
5604 msym = lookup_minimal_symbol_by_pc (sal->pc);
5606 sal->section = SYMBOL_BFD_SECTION (msym);
5613 break_command (char *arg, int from_tty)
5615 break_command_1 (arg, 0, from_tty, NULL);
5619 break_at_finish_command (char *arg, int from_tty)
5621 break_at_finish_command_1 (arg, 0, from_tty);
5625 break_at_finish_at_depth_command (char *arg, int from_tty)
5627 break_at_finish_at_depth_command_1 (arg, 0, from_tty);
5631 tbreak_command (char *arg, int from_tty)
5633 break_command_1 (arg, BP_TEMPFLAG, from_tty, NULL);
5637 tbreak_at_finish_command (char *arg, int from_tty)
5639 break_at_finish_command_1 (arg, BP_TEMPFLAG, from_tty);
5643 hbreak_command (char *arg, int from_tty)
5645 break_command_1 (arg, BP_HARDWAREFLAG, from_tty, NULL);
5649 thbreak_command (char *arg, int from_tty)
5651 break_command_1 (arg, (BP_TEMPFLAG | BP_HARDWAREFLAG), from_tty, NULL);
5655 stop_command (char *arg, int from_tty)
5657 printf_filtered ("Specify the type of breakpoint to set.\n\
5658 Usage: stop in <function | address>\n\
5663 stopin_command (char *arg, int from_tty)
5667 if (arg == (char *) NULL)
5669 else if (*arg != '*')
5674 /* look for a ':'. If this is a line number specification, then
5675 say it is bad, otherwise, it should be an address or
5676 function/method name */
5677 while (*argptr && !hasColon)
5679 hasColon = (*argptr == ':');
5684 badInput = (*argptr != ':'); /* Not a class::method */
5686 badInput = isdigit (*arg); /* a simple line number */
5690 printf_filtered ("Usage: stop in <function | address>\n");
5692 break_command_1 (arg, 0, from_tty, NULL);
5696 stopat_command (char *arg, int from_tty)
5700 if (arg == (char *) NULL || *arg == '*') /* no line number */
5707 /* look for a ':'. If there is a '::' then get out, otherwise
5708 it is probably a line number. */
5709 while (*argptr && !hasColon)
5711 hasColon = (*argptr == ':');
5716 badInput = (*argptr == ':'); /* we have class::method */
5718 badInput = !isdigit (*arg); /* not a line number */
5722 printf_filtered ("Usage: stop at <line>\n");
5724 break_command_1 (arg, 0, from_tty, NULL);
5727 /* accessflag: hw_write: watch write,
5728 hw_read: watch read,
5729 hw_access: watch access (read or write) */
5731 watch_command_1 (char *arg, int accessflag, int from_tty)
5733 struct breakpoint *b;
5734 struct symtab_and_line sal;
5735 struct expression *exp;
5736 struct block *exp_valid_block;
5737 struct value *val, *mark;
5738 struct frame_info *frame;
5739 struct frame_info *prev_frame = NULL;
5740 char *exp_start = NULL;
5741 char *exp_end = NULL;
5742 char *tok, *end_tok;
5744 char *cond_start = NULL;
5745 char *cond_end = NULL;
5746 struct expression *cond = NULL;
5747 int i, other_type_used, target_resources_ok = 0;
5748 enum bptype bp_type;
5751 init_sal (&sal); /* initialize to zeroes */
5753 /* Parse arguments. */
5754 innermost_block = NULL;
5756 exp = parse_exp_1 (&arg, 0, 0);
5758 exp_valid_block = innermost_block;
5759 mark = value_mark ();
5760 val = evaluate_expression (exp);
5761 release_value (val);
5762 if (VALUE_LAZY (val))
5763 value_fetch_lazy (val);
5766 while (*tok == ' ' || *tok == '\t')
5770 while (*end_tok != ' ' && *end_tok != '\t' && *end_tok != '\000')
5773 toklen = end_tok - tok;
5774 if (toklen >= 1 && strncmp (tok, "if", toklen) == 0)
5776 tok = cond_start = end_tok + 1;
5777 cond = parse_exp_1 (&tok, 0, 0);
5781 error ("Junk at end of command.");
5783 if (accessflag == hw_read)
5784 bp_type = bp_read_watchpoint;
5785 else if (accessflag == hw_access)
5786 bp_type = bp_access_watchpoint;
5788 bp_type = bp_hardware_watchpoint;
5790 mem_cnt = can_use_hardware_watchpoint (val);
5791 if (mem_cnt == 0 && bp_type != bp_hardware_watchpoint)
5792 error ("Expression cannot be implemented with read/access watchpoint.");
5795 i = hw_watchpoint_used_count (bp_type, &other_type_used);
5796 target_resources_ok =
5797 TARGET_CAN_USE_HARDWARE_WATCHPOINT (bp_type, i + mem_cnt,
5799 if (target_resources_ok == 0 && bp_type != bp_hardware_watchpoint)
5800 error ("Target does not support this type of hardware watchpoint.");
5802 if (target_resources_ok < 0 && bp_type != bp_hardware_watchpoint)
5803 error ("Target can only support one kind of HW watchpoint at a time.");
5806 #if defined(HPUXHPPA)
5807 /* On HP-UX if you set a h/w
5808 watchpoint before the "run" command, the inferior dies with a e.g.,
5809 SIGILL once you start it. I initially believed this was due to a
5810 bad interaction between page protection traps and the initial
5811 startup sequence by the dynamic linker.
5813 However, I tried avoiding that by having HP-UX's implementation of
5814 TARGET_CAN_USE_HW_WATCHPOINT return FALSE if there was no inferior_ptid
5815 yet, which forced slow watches before a "run" or "attach", and it
5816 still fails somewhere in the startup code.
5818 Until I figure out what's happening, I'm disallowing watches altogether
5819 before the "run" or "attach" command. We'll tell the user they must
5820 set watches after getting the program started. */
5821 if (!target_has_execution)
5823 warning ("can't do that without a running program; try \"break main\", \"run\" first");
5826 #endif /* HPUXHPPA */
5828 /* Change the type of breakpoint to an ordinary watchpoint if a hardware
5829 watchpoint could not be set. */
5830 if (!mem_cnt || target_resources_ok <= 0)
5831 bp_type = bp_watchpoint;
5833 /* Now set up the breakpoint. */
5834 b = set_raw_breakpoint (sal, bp_type);
5835 set_breakpoint_count (breakpoint_count + 1);
5836 b->number = breakpoint_count;
5837 b->disposition = disp_donttouch;
5839 b->exp_valid_block = exp_valid_block;
5840 b->exp_string = savestring (exp_start, exp_end - exp_start);
5844 b->cond_string = savestring (cond_start, cond_end - cond_start);
5848 frame = block_innermost_frame (exp_valid_block);
5851 prev_frame = get_prev_frame (frame);
5852 b->watchpoint_frame = get_frame_id (frame);
5856 memset (&b->watchpoint_frame, 0, sizeof (b->watchpoint_frame));
5859 /* If the expression is "local", then set up a "watchpoint scope"
5860 breakpoint at the point where we've left the scope of the watchpoint
5862 if (innermost_block)
5866 struct breakpoint *scope_breakpoint;
5867 scope_breakpoint = create_internal_breakpoint (get_frame_pc (prev_frame),
5868 bp_watchpoint_scope);
5870 scope_breakpoint->enable_state = bp_enabled;
5872 /* Automatically delete the breakpoint when it hits. */
5873 scope_breakpoint->disposition = disp_del;
5875 /* Only break in the proper frame (help with recursion). */
5876 scope_breakpoint->frame_id = get_frame_id (prev_frame);
5878 /* Set the address at which we will stop. */
5879 scope_breakpoint->loc->requested_address
5880 = get_frame_pc (prev_frame);
5881 scope_breakpoint->loc->address
5882 = adjust_breakpoint_address (scope_breakpoint->loc->requested_address);
5884 /* The scope breakpoint is related to the watchpoint. We
5885 will need to act on them together. */
5886 b->related_breakpoint = scope_breakpoint;
5889 value_free_to_mark (mark);
5893 /* Return count of locations need to be watched and can be handled
5894 in hardware. If the watchpoint can not be handled
5895 in hardware return zero. */
5897 #if !defined(TARGET_REGION_SIZE_OK_FOR_HW_WATCHPOINT)
5898 #define TARGET_REGION_SIZE_OK_FOR_HW_WATCHPOINT(BYTE_SIZE) \
5899 ((BYTE_SIZE) <= (DEPRECATED_REGISTER_SIZE))
5902 #if !defined(TARGET_REGION_OK_FOR_HW_WATCHPOINT)
5903 #define TARGET_REGION_OK_FOR_HW_WATCHPOINT(ADDR,LEN) \
5904 (TARGET_REGION_SIZE_OK_FOR_HW_WATCHPOINT(LEN))
5908 can_use_hardware_watchpoint (struct value *v)
5910 int found_memory_cnt = 0;
5911 struct value *head = v;
5913 /* Did the user specifically forbid us to use hardware watchpoints? */
5914 if (!can_use_hw_watchpoints)
5917 /* Make sure that the value of the expression depends only upon
5918 memory contents, and values computed from them within GDB. If we
5919 find any register references or function calls, we can't use a
5920 hardware watchpoint.
5922 The idea here is that evaluating an expression generates a series
5923 of values, one holding the value of every subexpression. (The
5924 expression a*b+c has five subexpressions: a, b, a*b, c, and
5925 a*b+c.) GDB's values hold almost enough information to establish
5926 the criteria given above --- they identify memory lvalues,
5927 register lvalues, computed values, etcetera. So we can evaluate
5928 the expression, and then scan the chain of values that leaves
5929 behind to decide whether we can detect any possible change to the
5930 expression's final value using only hardware watchpoints.
5932 However, I don't think that the values returned by inferior
5933 function calls are special in any way. So this function may not
5934 notice that an expression involving an inferior function call
5935 can't be watched with hardware watchpoints. FIXME. */
5936 for (; v; v = v->next)
5938 if (VALUE_LVAL (v) == lval_memory)
5941 /* A lazy memory lvalue is one that GDB never needed to fetch;
5942 we either just used its address (e.g., `a' in `a.b') or
5943 we never needed it at all (e.g., `a' in `a,b'). */
5947 /* Ahh, memory we actually used! Check if we can cover
5948 it with hardware watchpoints. */
5949 struct type *vtype = check_typedef (VALUE_TYPE (v));
5951 /* We only watch structs and arrays if user asked for it
5952 explicitly, never if they just happen to appear in a
5953 middle of some value chain. */
5955 || (TYPE_CODE (vtype) != TYPE_CODE_STRUCT
5956 && TYPE_CODE (vtype) != TYPE_CODE_ARRAY))
5958 CORE_ADDR vaddr = VALUE_ADDRESS (v) + VALUE_OFFSET (v);
5959 int len = TYPE_LENGTH (VALUE_TYPE (v));
5961 if (!TARGET_REGION_OK_FOR_HW_WATCHPOINT (vaddr, len))
5968 else if (v->lval != not_lval && v->modifiable == 0)
5969 return 0; /* ??? What does this represent? */
5970 else if (v->lval == lval_register)
5971 return 0; /* cannot watch a register with a HW watchpoint */
5974 /* The expression itself looks suitable for using a hardware
5975 watchpoint, but give the target machine a chance to reject it. */
5976 return found_memory_cnt;
5980 watch_command_wrapper (char *arg, int from_tty)
5982 watch_command (arg, from_tty);
5986 watch_command (char *arg, int from_tty)
5988 watch_command_1 (arg, hw_write, from_tty);
5992 rwatch_command_wrapper (char *arg, int from_tty)
5994 rwatch_command (arg, from_tty);
5998 rwatch_command (char *arg, int from_tty)
6000 watch_command_1 (arg, hw_read, from_tty);
6004 awatch_command_wrapper (char *arg, int from_tty)
6006 awatch_command (arg, from_tty);
6010 awatch_command (char *arg, int from_tty)
6012 watch_command_1 (arg, hw_access, from_tty);
6016 /* Helper routines for the until_command routine in infcmd.c. Here
6017 because it uses the mechanisms of breakpoints. */
6019 /* This function is called by fetch_inferior_event via the
6020 cmd_continuation pointer, to complete the until command. It takes
6021 care of cleaning up the temporary breakpoints set up by the until
6024 until_break_command_continuation (struct continuation_arg *arg)
6026 struct cleanup *cleanups;
6028 cleanups = (struct cleanup *) arg->data.pointer;
6029 do_exec_cleanups (cleanups);
6033 until_break_command (char *arg, int from_tty, int anywhere)
6035 struct symtabs_and_lines sals;
6036 struct symtab_and_line sal;
6037 struct frame_info *prev_frame = get_prev_frame (deprecated_selected_frame);
6038 struct breakpoint *breakpoint;
6039 struct cleanup *old_chain;
6040 struct continuation_arg *arg1;
6043 clear_proceed_status ();
6045 /* Set a breakpoint where the user wants it and at return from
6048 if (default_breakpoint_valid)
6049 sals = decode_line_1 (&arg, 1, default_breakpoint_symtab,
6050 default_breakpoint_line, (char ***) NULL, NULL);
6052 sals = decode_line_1 (&arg, 1, (struct symtab *) NULL,
6053 0, (char ***) NULL, NULL);
6055 if (sals.nelts != 1)
6056 error ("Couldn't get information on specified line.");
6059 xfree (sals.sals); /* malloc'd, so freed */
6062 error ("Junk at end of arguments.");
6064 resolve_sal_pc (&sal);
6067 /* If the user told us to continue until a specified location,
6068 we don't specify a frame at which we need to stop. */
6069 breakpoint = set_momentary_breakpoint (sal, null_frame_id, bp_until);
6071 /* Otherwise, specify the current frame, because we want to stop only
6072 at the very same frame. */
6073 breakpoint = set_momentary_breakpoint (sal,
6074 get_frame_id (deprecated_selected_frame),
6077 if (!event_loop_p || !target_can_async_p ())
6078 old_chain = make_cleanup_delete_breakpoint (breakpoint);
6080 old_chain = make_exec_cleanup_delete_breakpoint (breakpoint);
6082 /* If we are running asynchronously, and the target supports async
6083 execution, we are not waiting for the target to stop, in the call
6084 tp proceed, below. This means that we cannot delete the
6085 brekpoints until the target has actually stopped. The only place
6086 where we get a chance to do that is in fetch_inferior_event, so
6087 we must set things up for that. */
6089 if (event_loop_p && target_can_async_p ())
6091 /* In this case the arg for the continuation is just the point
6092 in the exec_cleanups chain from where to start doing
6093 cleanups, because all the continuation does is the cleanups in
6094 the exec_cleanup_chain. */
6096 (struct continuation_arg *) xmalloc (sizeof (struct continuation_arg));
6098 arg1->data.pointer = old_chain;
6100 add_continuation (until_break_command_continuation, arg1);
6103 /* Keep within the current frame, or in frames called by the current
6107 sal = find_pc_line (get_frame_pc (prev_frame), 0);
6108 sal.pc = get_frame_pc (prev_frame);
6109 breakpoint = set_momentary_breakpoint (sal, get_frame_id (prev_frame),
6111 if (!event_loop_p || !target_can_async_p ())
6112 make_cleanup_delete_breakpoint (breakpoint);
6114 make_exec_cleanup_delete_breakpoint (breakpoint);
6117 proceed (-1, TARGET_SIGNAL_DEFAULT, 0);
6118 /* Do the cleanups now, anly if we are not running asynchronously,
6119 of if we are, but the target is still synchronous. */
6120 if (!event_loop_p || !target_can_async_p ())
6121 do_cleanups (old_chain);
6125 ep_skip_leading_whitespace (char **s)
6127 if ((s == NULL) || (*s == NULL))
6129 while (isspace (**s))
6133 /* This function examines a string, and attempts to find a token
6134 that might be an event name in the leading characters. If a
6135 possible match is found, a pointer to the last character of
6136 the token is returned. Else, NULL is returned. */
6139 ep_find_event_name_end (char *arg)
6142 char *event_name_end = NULL;
6144 /* If we could depend upon the presense of strrpbrk, we'd use that... */
6148 /* We break out of the loop when we find a token delimiter.
6149 Basically, we're looking for alphanumerics and underscores;
6150 anything else delimites the token. */
6153 if (!isalnum (*s) && (*s != '_'))
6159 return event_name_end;
6163 /* This function attempts to parse an optional "if <cond>" clause
6164 from the arg string. If one is not found, it returns NULL.
6166 Else, it returns a pointer to the condition string. (It does not
6167 attempt to evaluate the string against a particular block.) And,
6168 it updates arg to point to the first character following the parsed
6169 if clause in the arg string. */
6172 ep_parse_optional_if_clause (char **arg)
6176 if (((*arg)[0] != 'i') || ((*arg)[1] != 'f') || !isspace ((*arg)[2]))
6179 /* Skip the "if" keyword. */
6182 /* Skip any extra leading whitespace, and record the start of the
6183 condition string. */
6184 ep_skip_leading_whitespace (arg);
6187 /* Assume that the condition occupies the remainder of the arg string. */
6188 (*arg) += strlen (cond_string);
6193 /* This function attempts to parse an optional filename from the arg
6194 string. If one is not found, it returns NULL.
6196 Else, it returns a pointer to the parsed filename. (This function
6197 makes no attempt to verify that a file of that name exists, or is
6198 accessible.) And, it updates arg to point to the first character
6199 following the parsed filename in the arg string.
6201 Note that clients needing to preserve the returned filename for
6202 future access should copy it to their own buffers. */
6204 ep_parse_optional_filename (char **arg)
6206 static char filename[1024];
6211 if ((*arg_p == '\0') || isspace (*arg_p))
6229 /* Commands to deal with catching events, such as signals, exceptions,
6230 process start/exit, etc. */
6234 catch_fork, catch_vfork
6239 catch_fork_command_1 (catch_fork_kind fork_kind, char *arg, int tempflag,
6242 char *cond_string = NULL;
6244 ep_skip_leading_whitespace (&arg);
6246 /* The allowed syntax is:
6248 catch [v]fork if <cond>
6250 First, check if there's an if clause. */
6251 cond_string = ep_parse_optional_if_clause (&arg);
6253 if ((*arg != '\0') && !isspace (*arg))
6254 error ("Junk at end of arguments.");
6256 /* If this target supports it, create a fork or vfork catchpoint
6257 and enable reporting of such events. */
6261 create_fork_event_catchpoint (tempflag, cond_string);
6264 create_vfork_event_catchpoint (tempflag, cond_string);
6267 error ("unsupported or unknown fork kind; cannot catch it");
6273 catch_exec_command_1 (char *arg, int tempflag, int from_tty)
6275 char *cond_string = NULL;
6277 ep_skip_leading_whitespace (&arg);
6279 /* The allowed syntax is:
6281 catch exec if <cond>
6283 First, check if there's an if clause. */
6284 cond_string = ep_parse_optional_if_clause (&arg);
6286 if ((*arg != '\0') && !isspace (*arg))
6287 error ("Junk at end of arguments.");
6289 /* If this target supports it, create an exec catchpoint
6290 and enable reporting of such events. */
6291 create_exec_event_catchpoint (tempflag, cond_string);
6295 catch_load_command_1 (char *arg, int tempflag, int from_tty)
6297 char *dll_pathname = NULL;
6298 char *cond_string = NULL;
6300 ep_skip_leading_whitespace (&arg);
6302 /* The allowed syntax is:
6304 catch load if <cond>
6305 catch load <filename>
6306 catch load <filename> if <cond>
6308 The user is not allowed to specify the <filename> after an
6311 We'll ignore the pathological case of a file named "if".
6313 First, check if there's an if clause. If so, then there
6314 cannot be a filename. */
6315 cond_string = ep_parse_optional_if_clause (&arg);
6317 /* If there was an if clause, then there cannot be a filename.
6318 Else, there might be a filename and an if clause. */
6319 if (cond_string == NULL)
6321 dll_pathname = ep_parse_optional_filename (&arg);
6322 ep_skip_leading_whitespace (&arg);
6323 cond_string = ep_parse_optional_if_clause (&arg);
6326 if ((*arg != '\0') && !isspace (*arg))
6327 error ("Junk at end of arguments.");
6329 /* Create a load breakpoint that only triggers when a load of
6330 the specified dll (or any dll, if no pathname was specified)
6332 SOLIB_CREATE_CATCH_LOAD_HOOK (PIDGET (inferior_ptid), tempflag,
6333 dll_pathname, cond_string);
6337 catch_unload_command_1 (char *arg, int tempflag, int from_tty)
6339 char *dll_pathname = NULL;
6340 char *cond_string = NULL;
6342 ep_skip_leading_whitespace (&arg);
6344 /* The allowed syntax is:
6346 catch unload if <cond>
6347 catch unload <filename>
6348 catch unload <filename> if <cond>
6350 The user is not allowed to specify the <filename> after an
6353 We'll ignore the pathological case of a file named "if".
6355 First, check if there's an if clause. If so, then there
6356 cannot be a filename. */
6357 cond_string = ep_parse_optional_if_clause (&arg);
6359 /* If there was an if clause, then there cannot be a filename.
6360 Else, there might be a filename and an if clause. */
6361 if (cond_string == NULL)
6363 dll_pathname = ep_parse_optional_filename (&arg);
6364 ep_skip_leading_whitespace (&arg);
6365 cond_string = ep_parse_optional_if_clause (&arg);
6368 if ((*arg != '\0') && !isspace (*arg))
6369 error ("Junk at end of arguments.");
6371 /* Create an unload breakpoint that only triggers when an unload of
6372 the specified dll (or any dll, if no pathname was specified)
6374 SOLIB_CREATE_CATCH_UNLOAD_HOOK (PIDGET (inferior_ptid), tempflag,
6375 dll_pathname, cond_string);
6378 /* Commands to deal with catching exceptions. */
6380 /* Set a breakpoint at the specified callback routine for an
6381 exception event callback */
6384 create_exception_catchpoint (int tempflag, char *cond_string,
6385 enum exception_event_kind ex_event,
6386 struct symtab_and_line *sal)
6388 struct breakpoint *b;
6389 int thread = -1; /* All threads. */
6392 if (!sal) /* no exception support? */
6397 case EX_EVENT_THROW:
6398 bptype = bp_catch_throw;
6400 case EX_EVENT_CATCH:
6401 bptype = bp_catch_catch;
6403 default: /* error condition */
6404 error ("Internal error -- invalid catchpoint kind");
6407 b = set_raw_breakpoint (*sal, bptype);
6408 set_breakpoint_count (breakpoint_count + 1);
6409 b->number = breakpoint_count;
6411 b->cond_string = (cond_string == NULL) ?
6412 NULL : savestring (cond_string, strlen (cond_string));
6414 b->addr_string = NULL;
6415 b->enable_state = bp_enabled;
6416 b->disposition = tempflag ? disp_del : disp_donttouch;
6420 static enum print_stop_action
6421 print_exception_catchpoint (struct breakpoint *b)
6423 annotate_catchpoint (b->number);
6425 if (strstr (b->addr_string, "throw") != NULL)
6426 printf_filtered ("\nCatchpoint %d (exception thrown)\n",
6429 printf_filtered ("\nCatchpoint %d (exception caught)\n",
6432 return PRINT_SRC_AND_LOC;
6436 print_one_exception_catchpoint (struct breakpoint *b, CORE_ADDR *last_addr)
6441 ui_out_field_core_addr (uiout, "addr", b->loc->address);
6444 *last_addr = b->loc->address;
6445 if (strstr (b->addr_string, "throw") != NULL)
6446 ui_out_field_string (uiout, "what", "exception throw");
6448 ui_out_field_string (uiout, "what", "exception catch");
6452 print_mention_exception_catchpoint (struct breakpoint *b)
6454 if (strstr (b->addr_string, "throw") != NULL)
6455 printf_filtered ("Catchpoint %d (throw)", b->number);
6457 printf_filtered ("Catchpoint %d (catch)", b->number);
6460 static struct breakpoint_ops gnu_v3_exception_catchpoint_ops = {
6461 print_exception_catchpoint,
6462 print_one_exception_catchpoint,
6463 print_mention_exception_catchpoint
6467 handle_gnu_v3_exceptions (int tempflag, char *cond_string,
6468 enum exception_event_kind ex_event, int from_tty)
6470 char *trigger_func_name, *nameptr;
6471 struct symtabs_and_lines sals;
6472 struct breakpoint *b;
6474 if (ex_event == EX_EVENT_CATCH)
6475 trigger_func_name = xstrdup ("__cxa_begin_catch");
6477 trigger_func_name = xstrdup ("__cxa_throw");
6479 nameptr = trigger_func_name;
6480 sals = decode_line_1 (&nameptr, 1, NULL, 0, NULL, NULL);
6481 if (sals.nelts == 0)
6483 xfree (trigger_func_name);
6487 b = set_raw_breakpoint (sals.sals[0], bp_breakpoint);
6488 set_breakpoint_count (breakpoint_count + 1);
6489 b->number = breakpoint_count;
6491 b->cond_string = (cond_string == NULL) ?
6492 NULL : savestring (cond_string, strlen (cond_string));
6494 b->addr_string = trigger_func_name;
6495 b->enable_state = bp_enabled;
6496 b->disposition = tempflag ? disp_del : disp_donttouch;
6497 b->ops = &gnu_v3_exception_catchpoint_ops;
6504 /* Deal with "catch catch" and "catch throw" commands */
6507 catch_exception_command_1 (enum exception_event_kind ex_event, char *arg,
6508 int tempflag, int from_tty)
6510 char *cond_string = NULL;
6511 struct symtab_and_line *sal = NULL;
6513 ep_skip_leading_whitespace (&arg);
6515 cond_string = ep_parse_optional_if_clause (&arg);
6517 if ((*arg != '\0') && !isspace (*arg))
6518 error ("Junk at end of arguments.");
6520 if ((ex_event != EX_EVENT_THROW) &&
6521 (ex_event != EX_EVENT_CATCH))
6522 error ("Unsupported or unknown exception event; cannot catch it");
6524 if (handle_gnu_v3_exceptions (tempflag, cond_string, ex_event, from_tty))
6527 /* See if we can find a callback routine */
6528 sal = target_enable_exception_callback (ex_event, 1);
6532 /* We have callbacks from the runtime system for exceptions.
6533 Set a breakpoint on the sal found, if no errors */
6534 if (sal != (struct symtab_and_line *) -1)
6535 create_exception_catchpoint (tempflag, cond_string, ex_event, sal);
6537 return; /* something went wrong with setting up callbacks */
6540 warning ("Unsupported with this platform/compiler combination.");
6543 /* Cover routine to allow wrapping target_enable_exception_catchpoints
6544 inside a catch_errors */
6547 cover_target_enable_exception_callback (void *arg)
6549 args_for_catchpoint_enable *args = arg;
6550 struct symtab_and_line *sal;
6551 sal = target_enable_exception_callback (args->kind, args->enable_p);
6554 else if (sal == (struct symtab_and_line *) -1)
6557 return 1; /*is valid */
6561 catch_command_1 (char *arg, int tempflag, int from_tty)
6564 /* The first argument may be an event name, such as "start" or "load".
6565 If so, then handle it as such. If it doesn't match an event name,
6566 then attempt to interpret it as an exception name. (This latter is
6567 the v4.16-and-earlier GDB meaning of the "catch" command.)
6569 First, try to find the bounds of what might be an event name. */
6570 char *arg1_start = arg;
6574 if (arg1_start == NULL)
6576 /* Old behaviour was to use pre-v-4.16 syntax */
6577 /* catch_throw_command_1 (arg1_start, tempflag, from_tty); */
6579 /* Now, this is not allowed */
6580 error ("Catch requires an event name.");
6583 arg1_end = ep_find_event_name_end (arg1_start);
6584 if (arg1_end == NULL)
6585 error ("catch requires an event");
6586 arg1_length = arg1_end + 1 - arg1_start;
6588 /* Try to match what we found against known event names. */
6589 if (strncmp (arg1_start, "signal", arg1_length) == 0)
6591 error ("Catch of signal not yet implemented");
6593 else if (strncmp (arg1_start, "catch", arg1_length) == 0)
6595 catch_exception_command_1 (EX_EVENT_CATCH, arg1_end + 1,
6596 tempflag, from_tty);
6598 else if (strncmp (arg1_start, "throw", arg1_length) == 0)
6600 catch_exception_command_1 (EX_EVENT_THROW, arg1_end + 1,
6601 tempflag, from_tty);
6603 else if (strncmp (arg1_start, "thread_start", arg1_length) == 0)
6605 error ("Catch of thread_start not yet implemented");
6607 else if (strncmp (arg1_start, "thread_exit", arg1_length) == 0)
6609 error ("Catch of thread_exit not yet implemented");
6611 else if (strncmp (arg1_start, "thread_join", arg1_length) == 0)
6613 error ("Catch of thread_join not yet implemented");
6615 else if (strncmp (arg1_start, "start", arg1_length) == 0)
6617 error ("Catch of start not yet implemented");
6619 else if (strncmp (arg1_start, "exit", arg1_length) == 0)
6621 error ("Catch of exit not yet implemented");
6623 else if (strncmp (arg1_start, "fork", arg1_length) == 0)
6625 catch_fork_command_1 (catch_fork, arg1_end + 1, tempflag, from_tty);
6627 else if (strncmp (arg1_start, "vfork", arg1_length) == 0)
6629 catch_fork_command_1 (catch_vfork, arg1_end + 1, tempflag, from_tty);
6631 else if (strncmp (arg1_start, "exec", arg1_length) == 0)
6633 catch_exec_command_1 (arg1_end + 1, tempflag, from_tty);
6635 else if (strncmp (arg1_start, "load", arg1_length) == 0)
6637 catch_load_command_1 (arg1_end + 1, tempflag, from_tty);
6639 else if (strncmp (arg1_start, "unload", arg1_length) == 0)
6641 catch_unload_command_1 (arg1_end + 1, tempflag, from_tty);
6643 else if (strncmp (arg1_start, "stop", arg1_length) == 0)
6645 error ("Catch of stop not yet implemented");
6648 /* This doesn't appear to be an event name */
6652 /* Pre-v.4.16 behaviour was to treat the argument
6653 as the name of an exception */
6654 /* catch_throw_command_1 (arg1_start, tempflag, from_tty); */
6655 /* Now this is not allowed */
6656 error ("Unknown event kind specified for catch");
6661 /* Used by the gui, could be made a worker for other things. */
6664 set_breakpoint_sal (struct symtab_and_line sal)
6666 struct breakpoint *b;
6667 b = set_raw_breakpoint (sal, bp_breakpoint);
6668 set_breakpoint_count (breakpoint_count + 1);
6669 b->number = breakpoint_count;
6676 catch_command (char *arg, int from_tty)
6678 catch_command_1 (arg, 0, from_tty);
6683 tcatch_command (char *arg, int from_tty)
6685 catch_command_1 (arg, 1, from_tty);
6688 /* Delete breakpoints by address or line. */
6691 clear_command (char *arg, int from_tty)
6693 struct breakpoint *b, *tmp, *prev, *found;
6695 struct symtabs_and_lines sals;
6696 struct symtab_and_line sal;
6701 sals = decode_line_spec (arg, 1);
6706 sals.sals = (struct symtab_and_line *)
6707 xmalloc (sizeof (struct symtab_and_line));
6708 make_cleanup (xfree, sals.sals);
6709 init_sal (&sal); /* initialize to zeroes */
6710 sal.line = default_breakpoint_line;
6711 sal.symtab = default_breakpoint_symtab;
6712 sal.pc = default_breakpoint_address;
6713 if (sal.symtab == 0)
6714 error ("No source file specified.");
6722 /* For each line spec given, delete bps which correspond
6723 to it. Do it in two passes, solely to preserve the current
6724 behavior that from_tty is forced true if we delete more than
6728 for (i = 0; i < sals.nelts; i++)
6730 /* If exact pc given, clear bpts at that pc.
6731 If line given (pc == 0), clear all bpts on specified line.
6732 If defaulting, clear all bpts on default line
6735 defaulting sal.pc != 0 tests to do
6740 1 0 <can't happen> */
6745 /* Find all matching breakpoints, remove them from the
6746 breakpoint chain, and add them to the 'found' chain. */
6747 ALL_BREAKPOINTS_SAFE (b, tmp)
6749 /* Are we going to delete b? */
6750 if (b->type != bp_none
6751 && b->type != bp_watchpoint
6752 && b->type != bp_hardware_watchpoint
6753 && b->type != bp_read_watchpoint
6754 && b->type != bp_access_watchpoint
6755 /* Not if b is a watchpoint of any sort... */
6756 && (((sal.pc && (b->loc->address == sal.pc))
6757 && (!section_is_overlay (b->loc->section)
6758 || b->loc->section == sal.section))
6759 /* Yes, if sal.pc matches b (modulo overlays). */
6760 || ((default_match || (0 == sal.pc))
6761 && b->source_file != NULL
6762 && sal.symtab != NULL
6763 && strcmp (b->source_file, sal.symtab->filename) == 0
6764 && b->line_number == sal.line)))
6765 /* Yes, if sal source file and line matches b. */
6767 /* Remove it from breakpoint_chain... */
6768 if (b == breakpoint_chain)
6770 /* b is at the head of the list */
6771 breakpoint_chain = b->next;
6775 prev->next = b->next;
6777 /* And add it to 'found' chain. */
6783 /* Keep b, and keep a pointer to it. */
6788 /* Now go thru the 'found' chain and delete them. */
6792 error ("No breakpoint at %s.", arg);
6794 error ("No breakpoint at this line.");
6798 from_tty = 1; /* Always report if deleted more than one */
6800 printf_unfiltered ("Deleted breakpoint%s ", found->next ? "s" : "");
6801 breakpoints_changed ();
6805 printf_unfiltered ("%d ", found->number);
6807 delete_breakpoint (found);
6811 putchar_unfiltered ('\n');
6814 /* Delete breakpoint in BS if they are `delete' breakpoints and
6815 all breakpoints that are marked for deletion, whether hit or not.
6816 This is called after any breakpoint is hit, or after errors. */
6819 breakpoint_auto_delete (bpstat bs)
6821 struct breakpoint *b, *temp;
6823 for (; bs; bs = bs->next)
6824 if (bs->breakpoint_at && bs->breakpoint_at->disposition == disp_del
6826 delete_breakpoint (bs->breakpoint_at);
6828 ALL_BREAKPOINTS_SAFE (b, temp)
6830 if (b->disposition == disp_del_at_next_stop)
6831 delete_breakpoint (b);
6835 /* Delete a breakpoint and clean up all traces of it in the data
6839 delete_breakpoint (struct breakpoint *bpt)
6841 struct breakpoint *b;
6843 struct bp_location *loc;
6846 error ("Internal error (attempted to delete a NULL breakpoint)");
6849 /* Has this bp already been deleted? This can happen because multiple
6850 lists can hold pointers to bp's. bpstat lists are especial culprits.
6852 One example of this happening is a watchpoint's scope bp. When the
6853 scope bp triggers, we notice that the watchpoint is out of scope, and
6854 delete it. We also delete its scope bp. But the scope bp is marked
6855 "auto-deleting", and is already on a bpstat. That bpstat is then
6856 checked for auto-deleting bp's, which are deleted.
6858 A real solution to this problem might involve reference counts in bp's,
6859 and/or giving them pointers back to their referencing bpstat's, and
6860 teaching delete_breakpoint to only free a bp's storage when no more
6861 references were extent. A cheaper bandaid was chosen. */
6862 if (bpt->type == bp_none)
6865 if (delete_breakpoint_hook)
6866 delete_breakpoint_hook (bpt);
6867 breakpoint_delete_event (bpt->number);
6869 if (bpt->loc->inserted)
6870 remove_breakpoint (bpt->loc, mark_inserted);
6872 if (breakpoint_chain == bpt)
6873 breakpoint_chain = bpt->next;
6875 if (bp_location_chain == bpt->loc)
6876 bp_location_chain = bpt->loc->next;
6878 /* If we have callback-style exception catchpoints, don't go through
6879 the adjustments to the C++ runtime library etc. if the inferior
6880 isn't actually running. target_enable_exception_callback for a
6881 null target ops vector gives an undesirable error message, so we
6882 check here and avoid it. Since currently (1997-09-17) only HP-UX aCC's
6883 exceptions are supported in this way, it's OK for now. FIXME */
6884 if (ep_is_exception_catchpoint (bpt) && target_has_execution)
6886 /* Format possible error msg */
6887 char *message = xstrprintf ("Error in deleting catchpoint %d:\n",
6889 struct cleanup *cleanups = make_cleanup (xfree, message);
6890 args_for_catchpoint_enable args;
6891 args.kind = bpt->type == bp_catch_catch ?
6892 EX_EVENT_CATCH : EX_EVENT_THROW;
6894 catch_errors (cover_target_enable_exception_callback, &args,
6895 message, RETURN_MASK_ALL);
6896 do_cleanups (cleanups);
6903 b->next = bpt->next;
6907 ALL_BP_LOCATIONS (loc)
6908 if (loc->next == bpt->loc)
6910 loc->next = bpt->loc->next;
6914 check_duplicates (bpt);
6915 /* If this breakpoint was inserted, and there is another breakpoint
6916 at the same address, we need to insert the other breakpoint. */
6917 if (bpt->loc->inserted
6918 && bpt->type != bp_hardware_watchpoint
6919 && bpt->type != bp_read_watchpoint
6920 && bpt->type != bp_access_watchpoint
6921 && bpt->type != bp_catch_fork
6922 && bpt->type != bp_catch_vfork
6923 && bpt->type != bp_catch_exec)
6926 if (b->loc->address == bpt->loc->address
6927 && b->loc->section == bpt->loc->section
6928 && !b->loc->duplicate
6929 && b->enable_state != bp_disabled
6930 && b->enable_state != bp_shlib_disabled
6932 && b->enable_state != bp_call_disabled)
6936 /* We should never reach this point if there is a permanent
6937 breakpoint at the same address as the one being deleted.
6938 If there is a permanent breakpoint somewhere, it should
6939 always be the only one inserted. */
6940 if (b->enable_state == bp_permanent)
6941 internal_error (__FILE__, __LINE__,
6942 "another breakpoint was inserted on top of "
6943 "a permanent breakpoint");
6945 if (b->type == bp_hardware_breakpoint)
6946 val = target_insert_hw_breakpoint (b->loc->address, b->loc->shadow_contents);
6948 val = target_insert_breakpoint (b->loc->address, b->loc->shadow_contents);
6950 /* If there was an error in the insert, print a message, then stop execution. */
6953 struct ui_file *tmp_error_stream = mem_fileopen ();
6954 make_cleanup_ui_file_delete (tmp_error_stream);
6957 if (b->type == bp_hardware_breakpoint)
6959 fprintf_unfiltered (tmp_error_stream,
6960 "Cannot insert hardware breakpoint %d.\n"
6961 "You may have requested too many hardware breakpoints.\n",
6966 fprintf_unfiltered (tmp_error_stream, "Cannot insert breakpoint %d.\n", b->number);
6967 fprintf_filtered (tmp_error_stream, "Error accessing memory address ");
6968 print_address_numeric (b->loc->address, 1, tmp_error_stream);
6969 fprintf_filtered (tmp_error_stream, ": %s.\n",
6970 safe_strerror (val));
6973 fprintf_unfiltered (tmp_error_stream,"The same program may be running in another process.");
6974 target_terminal_ours_for_output ();
6975 error_stream(tmp_error_stream);
6978 b->loc->inserted = 1;
6982 free_command_lines (&bpt->commands);
6985 if (bpt->cond_string != NULL)
6986 xfree (bpt->cond_string);
6987 if (bpt->addr_string != NULL)
6988 xfree (bpt->addr_string);
6989 if (bpt->exp != NULL)
6991 if (bpt->exp_string != NULL)
6992 xfree (bpt->exp_string);
6993 if (bpt->val != NULL)
6994 value_free (bpt->val);
6995 if (bpt->source_file != NULL)
6996 xfree (bpt->source_file);
6997 if (bpt->dll_pathname != NULL)
6998 xfree (bpt->dll_pathname);
6999 if (bpt->triggered_dll_pathname != NULL)
7000 xfree (bpt->triggered_dll_pathname);
7001 if (bpt->exec_pathname != NULL)
7002 xfree (bpt->exec_pathname);
7004 /* Be sure no bpstat's are pointing at it after it's been freed. */
7005 /* FIXME, how can we find all bpstat's?
7006 We just check stop_bpstat for now. */
7007 for (bs = stop_bpstat; bs; bs = bs->next)
7008 if (bs->breakpoint_at == bpt)
7010 bs->breakpoint_at = NULL;
7012 /* bs->commands will be freed later. */
7014 /* On the chance that someone will soon try again to delete this same
7015 bp, we mark it as deleted before freeing its storage. */
7016 bpt->type = bp_none;
7023 do_delete_breakpoint_cleanup (void *b)
7025 delete_breakpoint (b);
7029 make_cleanup_delete_breakpoint (struct breakpoint *b)
7031 return make_cleanup (do_delete_breakpoint_cleanup, b);
7035 make_exec_cleanup_delete_breakpoint (struct breakpoint *b)
7037 return make_exec_cleanup (do_delete_breakpoint_cleanup, b);
7041 delete_command (char *arg, int from_tty)
7043 struct breakpoint *b, *temp;
7049 int breaks_to_delete = 0;
7051 /* Delete all breakpoints if no argument.
7052 Do not delete internal or call-dummy breakpoints, these
7053 have to be deleted with an explicit breakpoint number argument. */
7056 if (b->type != bp_call_dummy &&
7057 b->type != bp_shlib_event &&
7058 b->type != bp_thread_event &&
7059 b->type != bp_overlay_event &&
7061 breaks_to_delete = 1;
7064 /* Ask user only if there are some breakpoints to delete. */
7066 || (breaks_to_delete && query ("Delete all breakpoints? ")))
7068 ALL_BREAKPOINTS_SAFE (b, temp)
7070 if (b->type != bp_call_dummy &&
7071 b->type != bp_shlib_event &&
7072 b->type != bp_thread_event &&
7073 b->type != bp_overlay_event &&
7075 delete_breakpoint (b);
7080 map_breakpoint_numbers (arg, delete_breakpoint);
7083 /* Reset a breakpoint given it's struct breakpoint * BINT.
7084 The value we return ends up being the return value from catch_errors.
7085 Unused in this case. */
7088 breakpoint_re_set_one (void *bint)
7090 /* get past catch_errs */
7091 struct breakpoint *b = (struct breakpoint *) bint;
7094 struct symtabs_and_lines sals;
7096 enum enable_state save_enable;
7101 warning ("attempted to reset apparently deleted breakpoint #%d?",
7105 case bp_hardware_breakpoint:
7107 case bp_catch_unload:
7108 if (b->addr_string == NULL)
7110 /* Anything without a string can't be re-set. */
7111 delete_breakpoint (b);
7114 /* HACK: cagney/2001-11-11: kettenis/2001-11-11: MarkK wrote:
7116 ``And a hack it is, although Apple's Darwin version of GDB
7117 contains an almost identical hack to implement a "future
7118 break" command. It seems to work in many real world cases,
7119 but it is easy to come up with a test case where the patch
7120 doesn't help at all.''
7122 ``It seems that the way GDB implements breakpoints - in -
7123 shared - libraries was designed for a.out shared library
7124 systems (SunOS 4) where shared libraries were loaded at a
7125 fixed address in memory. Since ELF shared libraries can (and
7126 will) be loaded at any address in memory, things break.
7127 Fixing this is not trivial. Therefore, I'm not sure whether
7128 we should add this hack to the branch only. I cannot
7129 guarantee that things will be fixed on the trunk in the near
7132 In case we have a problem, disable this breakpoint. We'll
7133 restore its status if we succeed. Don't disable a
7134 shlib_disabled breakpoint though. There's a fair chance we
7135 can't re-set it if the shared library it's in hasn't been
7141 save_enable = b->enable_state;
7142 if (b->enable_state != bp_shlib_disabled)
7143 b->enable_state = bp_disabled;
7145 set_language (b->language);
7146 input_radix = b->input_radix;
7148 sals = decode_line_1 (&s, 1, (struct symtab *) NULL, 0, (char ***) NULL, NULL);
7149 for (i = 0; i < sals.nelts; i++)
7151 resolve_sal_pc (&sals.sals[i]);
7153 /* Reparse conditions, they might contain references to the
7155 if (b->cond_string != NULL)
7161 /* Avoid re-freeing b->exp if an error during the call
7165 b->cond = parse_exp_1 (&s, block_for_pc (sals.sals[i].pc), 0);
7168 /* We need to re-set the breakpoint if the address changes... */
7169 if (b->loc->address != sals.sals[i].pc
7170 /* ...or new and old breakpoints both have source files, and
7171 the source file name or the line number changes... */
7172 || (b->source_file != NULL
7173 && sals.sals[i].symtab != NULL
7174 && (strcmp (b->source_file, sals.sals[i].symtab->filename) != 0
7175 || b->line_number != sals.sals[i].line)
7177 /* ...or we switch between having a source file and not having
7179 || ((b->source_file == NULL) != (sals.sals[i].symtab == NULL))
7182 if (b->source_file != NULL)
7183 xfree (b->source_file);
7184 if (sals.sals[i].symtab == NULL)
7185 b->source_file = NULL;
7188 savestring (sals.sals[i].symtab->filename,
7189 strlen (sals.sals[i].symtab->filename));
7190 b->line_number = sals.sals[i].line;
7191 b->loc->requested_address = sals.sals[i].pc;
7193 = adjust_breakpoint_address (b->loc->requested_address);
7195 /* Used to check for duplicates here, but that can
7196 cause trouble, as it doesn't check for disabled
7201 /* Might be better to do this just once per breakpoint_re_set,
7202 rather than once for every breakpoint. */
7203 breakpoints_changed ();
7205 b->loc->section = sals.sals[i].section;
7206 b->enable_state = save_enable; /* Restore it, this worked. */
7209 /* Now that this is re-enabled, check_duplicates
7211 check_duplicates (b);
7218 case bp_hardware_watchpoint:
7219 case bp_read_watchpoint:
7220 case bp_access_watchpoint:
7221 innermost_block = NULL;
7222 /* The issue arises of what context to evaluate this in. The
7223 same one as when it was set, but what does that mean when
7224 symbols have been re-read? We could save the filename and
7225 functionname, but if the context is more local than that, the
7226 best we could do would be something like how many levels deep
7227 and which index at that particular level, but that's going to
7228 be less stable than filenames or function names. */
7230 /* So for now, just use a global context. */
7234 /* Avoid re-freeing b->exp if an error during the call to
7235 parse_expression. */
7238 b->exp = parse_expression (b->exp_string);
7239 b->exp_valid_block = innermost_block;
7240 mark = value_mark ();
7243 value_free (b->val);
7244 /* Avoid re-freeing b->val if an error during the call to
7245 evaluate_expression. */
7248 b->val = evaluate_expression (b->exp);
7249 release_value (b->val);
7250 if (VALUE_LAZY (b->val) && breakpoint_enabled (b))
7251 value_fetch_lazy (b->val);
7253 if (b->cond_string != NULL)
7259 /* Avoid re-freeing b->exp if an error during the call
7263 b->cond = parse_exp_1 (&s, (struct block *) 0, 0);
7265 if (breakpoint_enabled (b))
7267 value_free_to_mark (mark);
7269 case bp_catch_catch:
7270 case bp_catch_throw:
7272 /* We needn't really do anything to reset these, since the mask
7273 that requests them is unaffected by e.g., new libraries being
7276 case bp_catch_vfork:
7281 printf_filtered ("Deleting unknown breakpoint type %d\n", b->type);
7283 /* Delete longjmp and overlay event breakpoints; they will be
7284 reset later by breakpoint_re_set. */
7286 case bp_longjmp_resume:
7287 case bp_overlay_event:
7288 delete_breakpoint (b);
7291 /* This breakpoint is special, it's set up when the inferior
7292 starts and we really don't want to touch it. */
7293 case bp_shlib_event:
7295 /* Like bp_shlib_event, this breakpoint type is special.
7296 Once it is set up, we do not want to touch it. */
7297 case bp_thread_event:
7299 /* Keep temporary breakpoints, which can be encountered when we step
7300 over a dlopen call and SOLIB_ADD is resetting the breakpoints.
7301 Otherwise these should have been blown away via the cleanup chain
7302 or by breakpoint_init_inferior when we rerun the executable. */
7305 case bp_watchpoint_scope:
7307 case bp_step_resume:
7314 /* Re-set all breakpoints after symbols have been re-loaded. */
7316 breakpoint_re_set (void)
7318 struct breakpoint *b, *temp;
7319 enum language save_language;
7320 int save_input_radix;
7322 save_language = current_language->la_language;
7323 save_input_radix = input_radix;
7324 ALL_BREAKPOINTS_SAFE (b, temp)
7326 /* Format possible error msg */
7327 char *message = xstrprintf ("Error in re-setting breakpoint %d:\n",
7329 struct cleanup *cleanups = make_cleanup (xfree, message);
7330 catch_errors (breakpoint_re_set_one, b, message, RETURN_MASK_ALL);
7331 do_cleanups (cleanups);
7333 set_language (save_language);
7334 input_radix = save_input_radix;
7336 if (GET_LONGJMP_TARGET_P ())
7338 create_longjmp_breakpoint ("longjmp");
7339 create_longjmp_breakpoint ("_longjmp");
7340 create_longjmp_breakpoint ("siglongjmp");
7341 create_longjmp_breakpoint ("_siglongjmp");
7342 create_longjmp_breakpoint (NULL);
7345 create_overlay_event_breakpoint ("_ovly_debug_event");
7348 /* Reset the thread number of this breakpoint:
7350 - If the breakpoint is for all threads, leave it as-is.
7351 - Else, reset it to the current thread for inferior_ptid. */
7353 breakpoint_re_set_thread (struct breakpoint *b)
7355 if (b->thread != -1)
7357 if (in_thread_list (inferior_ptid))
7358 b->thread = pid_to_thread_id (inferior_ptid);
7362 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
7363 If from_tty is nonzero, it prints a message to that effect,
7364 which ends with a period (no newline). */
7367 set_ignore_count (int bptnum, int count, int from_tty)
7369 struct breakpoint *b;
7375 if (b->number == bptnum)
7377 b->ignore_count = count;
7381 printf_filtered ("Will stop next time breakpoint %d is reached.",
7383 else if (count == 1)
7384 printf_filtered ("Will ignore next crossing of breakpoint %d.",
7387 printf_filtered ("Will ignore next %d crossings of breakpoint %d.",
7390 breakpoints_changed ();
7391 breakpoint_modify_event (b->number);
7395 error ("No breakpoint number %d.", bptnum);
7398 /* Clear the ignore counts of all breakpoints. */
7400 breakpoint_clear_ignore_counts (void)
7402 struct breakpoint *b;
7405 b->ignore_count = 0;
7408 /* Command to set ignore-count of breakpoint N to COUNT. */
7411 ignore_command (char *args, int from_tty)
7417 error_no_arg ("a breakpoint number");
7419 num = get_number (&p);
7421 error ("bad breakpoint number: '%s'", args);
7423 error ("Second argument (specified ignore-count) is missing.");
7425 set_ignore_count (num,
7426 longest_to_int (value_as_long (parse_and_eval (p))),
7429 printf_filtered ("\n");
7432 /* Call FUNCTION on each of the breakpoints
7433 whose numbers are given in ARGS. */
7436 map_breakpoint_numbers (char *args, void (*function) (struct breakpoint *))
7441 struct breakpoint *b, *tmp;
7445 error_no_arg ("one or more breakpoint numbers");
7452 num = get_number_or_range (&p1);
7455 warning ("bad breakpoint number at or near '%s'", p);
7459 ALL_BREAKPOINTS_SAFE (b, tmp)
7460 if (b->number == num)
7462 struct breakpoint *related_breakpoint = b->related_breakpoint;
7465 if (related_breakpoint)
7466 function (related_breakpoint);
7470 printf_unfiltered ("No breakpoint number %d.\n", num);
7476 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
7477 If from_tty is nonzero, it prints a message to that effect,
7478 which ends with a period (no newline). */
7481 disable_breakpoint (struct breakpoint *bpt)
7483 /* Never disable a watchpoint scope breakpoint; we want to
7484 hit them when we leave scope so we can delete both the
7485 watchpoint and its scope breakpoint at that time. */
7486 if (bpt->type == bp_watchpoint_scope)
7489 /* You can't disable permanent breakpoints. */
7490 if (bpt->enable_state == bp_permanent)
7493 bpt->enable_state = bp_disabled;
7495 check_duplicates (bpt);
7497 if (modify_breakpoint_hook)
7498 modify_breakpoint_hook (bpt);
7499 breakpoint_modify_event (bpt->number);
7503 disable_command (char *args, int from_tty)
7505 struct breakpoint *bpt;
7507 ALL_BREAKPOINTS (bpt)
7511 warning ("attempted to disable apparently deleted breakpoint #%d?",
7516 case bp_catch_unload:
7518 case bp_catch_vfork:
7520 case bp_catch_catch:
7521 case bp_catch_throw:
7522 case bp_hardware_breakpoint:
7524 case bp_hardware_watchpoint:
7525 case bp_read_watchpoint:
7526 case bp_access_watchpoint:
7527 disable_breakpoint (bpt);
7532 map_breakpoint_numbers (args, disable_breakpoint);
7536 do_enable_breakpoint (struct breakpoint *bpt, enum bpdisp disposition)
7538 struct frame_info *save_selected_frame = NULL;
7539 int save_selected_frame_level = -1;
7540 int target_resources_ok, other_type_used;
7543 if (bpt->type == bp_hardware_breakpoint)
7546 i = hw_breakpoint_used_count ();
7547 target_resources_ok =
7548 TARGET_CAN_USE_HARDWARE_WATCHPOINT (bp_hardware_breakpoint,
7550 if (target_resources_ok == 0)
7551 error ("No hardware breakpoint support in the target.");
7552 else if (target_resources_ok < 0)
7553 error ("Hardware breakpoints used exceeds limit.");
7558 if (bpt->enable_state != bp_enabled)
7560 /* When enabling a pending breakpoint, we need to check if the breakpoint
7561 is resolvable since shared libraries could have been loaded
7562 after the breakpoint was disabled. */
7563 breakpoints_changed ();
7564 if (resolve_pending_breakpoint (bpt) == GDB_RC_OK)
7566 delete_breakpoint (bpt);
7569 bpt->enable_state = bp_enabled;
7570 bpt->disposition = disposition;
7573 else /* Not a pending breakpoint. */
7575 if (bpt->enable_state != bp_permanent)
7576 bpt->enable_state = bp_enabled;
7577 bpt->disposition = disposition;
7578 check_duplicates (bpt);
7579 breakpoints_changed ();
7581 if (bpt->type == bp_watchpoint ||
7582 bpt->type == bp_hardware_watchpoint ||
7583 bpt->type == bp_read_watchpoint ||
7584 bpt->type == bp_access_watchpoint)
7586 if (bpt->exp_valid_block != NULL)
7588 struct frame_info *fr =
7589 fr = frame_find_by_id (bpt->watchpoint_frame);
7593 Cannot enable watchpoint %d because the block in which its expression\n\
7594 is valid is not currently in scope.\n", bpt->number);
7595 bpt->enable_state = bp_disabled;
7599 save_selected_frame = deprecated_selected_frame;
7600 save_selected_frame_level = frame_relative_level (deprecated_selected_frame);
7604 value_free (bpt->val);
7605 mark = value_mark ();
7606 bpt->val = evaluate_expression (bpt->exp);
7607 release_value (bpt->val);
7608 if (VALUE_LAZY (bpt->val))
7609 value_fetch_lazy (bpt->val);
7611 if (bpt->type == bp_hardware_watchpoint ||
7612 bpt->type == bp_read_watchpoint ||
7613 bpt->type == bp_access_watchpoint)
7615 int i = hw_watchpoint_used_count (bpt->type, &other_type_used);
7616 int mem_cnt = can_use_hardware_watchpoint (bpt->val);
7618 /* Hack around 'unused var' error for some targets here */
7620 target_resources_ok = TARGET_CAN_USE_HARDWARE_WATCHPOINT (
7621 bpt->type, i + mem_cnt, other_type_used);
7622 /* we can consider of type is bp_hardware_watchpoint, convert to
7623 bp_watchpoint in the following condition */
7624 if (target_resources_ok < 0)
7627 Cannot enable watchpoint %d because target watch resources\n\
7628 have been allocated for other watchpoints.\n", bpt->number);
7629 bpt->enable_state = bp_disabled;
7630 value_free_to_mark (mark);
7635 if (save_selected_frame_level >= 0)
7636 select_frame (save_selected_frame);
7637 value_free_to_mark (mark);
7641 if (modify_breakpoint_hook)
7642 modify_breakpoint_hook (bpt);
7643 breakpoint_modify_event (bpt->number);
7647 enable_breakpoint (struct breakpoint *bpt)
7649 do_enable_breakpoint (bpt, bpt->disposition);
7652 /* The enable command enables the specified breakpoints (or all defined
7653 breakpoints) so they once again become (or continue to be) effective
7654 in stopping the inferior. */
7657 enable_command (char *args, int from_tty)
7659 struct breakpoint *bpt;
7661 ALL_BREAKPOINTS (bpt)
7665 warning ("attempted to enable apparently deleted breakpoint #%d?",
7670 case bp_catch_unload:
7672 case bp_catch_vfork:
7674 case bp_catch_catch:
7675 case bp_catch_throw:
7676 case bp_hardware_breakpoint:
7678 case bp_hardware_watchpoint:
7679 case bp_read_watchpoint:
7680 case bp_access_watchpoint:
7681 enable_breakpoint (bpt);
7686 map_breakpoint_numbers (args, enable_breakpoint);
7690 enable_once_breakpoint (struct breakpoint *bpt)
7692 do_enable_breakpoint (bpt, disp_disable);
7696 enable_once_command (char *args, int from_tty)
7698 map_breakpoint_numbers (args, enable_once_breakpoint);
7702 enable_delete_breakpoint (struct breakpoint *bpt)
7704 do_enable_breakpoint (bpt, disp_del);
7708 enable_delete_command (char *args, int from_tty)
7710 map_breakpoint_numbers (args, enable_delete_breakpoint);
7714 set_breakpoint_cmd (char *args, int from_tty)
7719 show_breakpoint_cmd (char *args, int from_tty)
7723 /* Use default_breakpoint_'s, or nothing if they aren't valid. */
7725 struct symtabs_and_lines
7726 decode_line_spec_1 (char *string, int funfirstline)
7728 struct symtabs_and_lines sals;
7730 error ("Empty line specification.");
7731 if (default_breakpoint_valid)
7732 sals = decode_line_1 (&string, funfirstline,
7733 default_breakpoint_symtab,
7734 default_breakpoint_line,
7735 (char ***) NULL, NULL);
7737 sals = decode_line_1 (&string, funfirstline,
7738 (struct symtab *) NULL, 0, (char ***) NULL, NULL);
7740 error ("Junk at end of line specification: %s", string);
7745 _initialize_breakpoint (void)
7747 static struct cmd_list_element *breakpoint_set_cmdlist;
7748 static struct cmd_list_element *breakpoint_show_cmdlist;
7749 struct cmd_list_element *c;
7751 breakpoint_chain = 0;
7752 /* Don't bother to call set_breakpoint_count. $bpnum isn't useful
7753 before a breakpoint is set. */
7754 breakpoint_count = 0;
7756 add_com ("ignore", class_breakpoint, ignore_command,
7757 "Set ignore-count of breakpoint number N to COUNT.\n\
7758 Usage is `ignore N COUNT'.");
7760 add_com_alias ("bc", "ignore", class_breakpoint, 1);
7762 add_com ("commands", class_breakpoint, commands_command,
7763 "Set commands to be executed when a breakpoint is hit.\n\
7764 Give breakpoint number as argument after \"commands\".\n\
7765 With no argument, the targeted breakpoint is the last one set.\n\
7766 The commands themselves follow starting on the next line.\n\
7767 Type a line containing \"end\" to indicate the end of them.\n\
7768 Give \"silent\" as the first line to make the breakpoint silent;\n\
7769 then no output is printed when it is hit, except what the commands print.");
7771 add_com ("condition", class_breakpoint, condition_command,
7772 "Specify breakpoint number N to break only if COND is true.\n\
7773 Usage is `condition N COND', where N is an integer and COND is an\n\
7774 expression to be evaluated whenever breakpoint N is reached.");
7776 c = add_com ("tbreak", class_breakpoint, tbreak_command,
7777 "Set a temporary breakpoint. Args like \"break\" command.\n\
7778 Like \"break\" except the breakpoint is only temporary,\n\
7779 so it will be deleted when hit. Equivalent to \"break\" followed\n\
7780 by using \"enable delete\" on the breakpoint number.");
7781 set_cmd_completer (c, location_completer);
7783 c = add_com ("hbreak", class_breakpoint, hbreak_command,
7784 "Set a hardware assisted breakpoint. Args like \"break\" command.\n\
7785 Like \"break\" except the breakpoint requires hardware support,\n\
7786 some target hardware may not have this support.");
7787 set_cmd_completer (c, location_completer);
7789 c = add_com ("thbreak", class_breakpoint, thbreak_command,
7790 "Set a temporary hardware assisted breakpoint. Args like \"break\" command.\n\
7791 Like \"hbreak\" except the breakpoint is only temporary,\n\
7792 so it will be deleted when hit.");
7793 set_cmd_completer (c, location_completer);
7795 add_prefix_cmd ("enable", class_breakpoint, enable_command,
7796 "Enable some breakpoints.\n\
7797 Give breakpoint numbers (separated by spaces) as arguments.\n\
7798 With no subcommand, breakpoints are enabled until you command otherwise.\n\
7799 This is used to cancel the effect of the \"disable\" command.\n\
7800 With a subcommand you can enable temporarily.",
7801 &enablelist, "enable ", 1, &cmdlist);
7803 add_com ("ab", class_breakpoint, enable_command,
7804 "Enable some breakpoints.\n\
7805 Give breakpoint numbers (separated by spaces) as arguments.\n\
7806 With no subcommand, breakpoints are enabled until you command otherwise.\n\
7807 This is used to cancel the effect of the \"disable\" command.\n\
7808 With a subcommand you can enable temporarily.");
7810 add_com_alias ("en", "enable", class_breakpoint, 1);
7812 add_abbrev_prefix_cmd ("breakpoints", class_breakpoint, enable_command,
7813 "Enable some breakpoints.\n\
7814 Give breakpoint numbers (separated by spaces) as arguments.\n\
7815 This is used to cancel the effect of the \"disable\" command.\n\
7816 May be abbreviated to simply \"enable\".\n",
7817 &enablebreaklist, "enable breakpoints ", 1, &enablelist);
7819 add_cmd ("once", no_class, enable_once_command,
7820 "Enable breakpoints for one hit. Give breakpoint numbers.\n\
7821 If a breakpoint is hit while enabled in this fashion, it becomes disabled.",
7824 add_cmd ("delete", no_class, enable_delete_command,
7825 "Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
7826 If a breakpoint is hit while enabled in this fashion, it is deleted.",
7829 add_cmd ("delete", no_class, enable_delete_command,
7830 "Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
7831 If a breakpoint is hit while enabled in this fashion, it is deleted.",
7834 add_cmd ("once", no_class, enable_once_command,
7835 "Enable breakpoints for one hit. Give breakpoint numbers.\n\
7836 If a breakpoint is hit while enabled in this fashion, it becomes disabled.",
7839 add_prefix_cmd ("disable", class_breakpoint, disable_command,
7840 "Disable some breakpoints.\n\
7841 Arguments are breakpoint numbers with spaces in between.\n\
7842 To disable all breakpoints, give no argument.\n\
7843 A disabled breakpoint is not forgotten, but has no effect until reenabled.",
7844 &disablelist, "disable ", 1, &cmdlist);
7845 add_com_alias ("dis", "disable", class_breakpoint, 1);
7846 add_com_alias ("disa", "disable", class_breakpoint, 1);
7848 add_com ("sb", class_breakpoint, disable_command,
7849 "Disable some breakpoints.\n\
7850 Arguments are breakpoint numbers with spaces in between.\n\
7851 To disable all breakpoints, give no argument.\n\
7852 A disabled breakpoint is not forgotten, but has no effect until reenabled.");
7854 add_cmd ("breakpoints", class_alias, disable_command,
7855 "Disable some breakpoints.\n\
7856 Arguments are breakpoint numbers with spaces in between.\n\
7857 To disable all breakpoints, give no argument.\n\
7858 A disabled breakpoint is not forgotten, but has no effect until reenabled.\n\
7859 This command may be abbreviated \"disable\".",
7862 add_prefix_cmd ("delete", class_breakpoint, delete_command,
7863 "Delete some breakpoints or auto-display expressions.\n\
7864 Arguments are breakpoint numbers with spaces in between.\n\
7865 To delete all breakpoints, give no argument.\n\
7867 Also a prefix command for deletion of other GDB objects.\n\
7868 The \"unset\" command is also an alias for \"delete\".",
7869 &deletelist, "delete ", 1, &cmdlist);
7870 add_com_alias ("d", "delete", class_breakpoint, 1);
7872 add_com ("db", class_breakpoint, delete_command,
7873 "Delete some breakpoints.\n\
7874 Arguments are breakpoint numbers with spaces in between.\n\
7875 To delete all breakpoints, give no argument.\n");
7877 add_cmd ("breakpoints", class_alias, delete_command,
7878 "Delete some breakpoints or auto-display expressions.\n\
7879 Arguments are breakpoint numbers with spaces in between.\n\
7880 To delete all breakpoints, give no argument.\n\
7881 This command may be abbreviated \"delete\".",
7884 add_com ("clear", class_breakpoint, clear_command,
7885 concat ("Clear breakpoint at specified line or function.\n\
7886 Argument may be line number, function name, or \"*\" and an address.\n\
7887 If line number is specified, all breakpoints in that line are cleared.\n\
7888 If function is specified, breakpoints at beginning of function are cleared.\n\
7889 If an address is specified, breakpoints at that address are cleared.\n\n",
7890 "With no argument, clears all breakpoints in the line that the selected frame\n\
7893 See also the \"delete\" command which clears breakpoints by number.", NULL));
7895 c = add_com ("break", class_breakpoint, break_command,
7896 concat ("Set breakpoint at specified line or function.\n\
7897 Argument may be line number, function name, or \"*\" and an address.\n\
7898 If line number is specified, break at start of code for that line.\n\
7899 If function is specified, break at start of code for that function.\n\
7900 If an address is specified, break at that exact address.\n",
7901 "With no arg, uses current execution address of selected stack frame.\n\
7902 This is useful for breaking on return to a stack frame.\n\
7904 Multiple breakpoints at one place are permitted, and useful if conditional.\n\
7906 Do \"help breakpoints\" for info on other commands dealing with breakpoints.", NULL));
7907 set_cmd_completer (c, location_completer);
7909 add_com_alias ("b", "break", class_run, 1);
7910 add_com_alias ("br", "break", class_run, 1);
7911 add_com_alias ("bre", "break", class_run, 1);
7912 add_com_alias ("brea", "break", class_run, 1);
7916 add_com_alias ("ba", "break", class_breakpoint, 1);
7917 add_com_alias ("bu", "ubreak", class_breakpoint, 1);
7922 add_abbrev_prefix_cmd ("stop", class_breakpoint, stop_command,
7923 "Break in function/address or break at a line in the current file.",
7924 &stoplist, "stop ", 1, &cmdlist);
7925 add_cmd ("in", class_breakpoint, stopin_command,
7926 "Break in function or address.\n", &stoplist);
7927 add_cmd ("at", class_breakpoint, stopat_command,
7928 "Break at a line in the current file.\n", &stoplist);
7929 add_com ("status", class_info, breakpoints_info,
7930 concat ("Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
7931 The \"Type\" column indicates one of:\n\
7932 \tbreakpoint - normal breakpoint\n\
7933 \twatchpoint - watchpoint\n\
7934 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
7935 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
7936 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
7937 address and file/line number respectively.\n\n",
7938 "Convenience variable \"$_\" and default examine address for \"x\"\n\
7939 are set to the address of the last breakpoint listed.\n\n\
7940 Convenience variable \"$bpnum\" contains the number of the last\n\
7941 breakpoint set.", NULL));
7944 add_info ("breakpoints", breakpoints_info,
7945 concat ("Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
7946 The \"Type\" column indicates one of:\n\
7947 \tbreakpoint - normal breakpoint\n\
7948 \twatchpoint - watchpoint\n\
7949 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
7950 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
7951 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
7952 address and file/line number respectively.\n\n",
7953 "Convenience variable \"$_\" and default examine address for \"x\"\n\
7954 are set to the address of the last breakpoint listed.\n\n\
7955 Convenience variable \"$bpnum\" contains the number of the last\n\
7956 breakpoint set.", NULL));
7959 add_com ("lb", class_breakpoint, 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));
7973 add_cmd ("breakpoints", class_maintenance, maintenance_info_breakpoints,
7974 concat ("Status of all breakpoints, or breakpoint number NUMBER.\n\
7975 The \"Type\" column indicates one of:\n\
7976 \tbreakpoint - normal breakpoint\n\
7977 \twatchpoint - watchpoint\n\
7978 \tlongjmp - internal breakpoint used to step through longjmp()\n\
7979 \tlongjmp resume - internal breakpoint at the target of longjmp()\n\
7980 \tuntil - internal breakpoint used by the \"until\" command\n\
7981 \tfinish - internal breakpoint used by the \"finish\" command\n",
7982 "The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
7983 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
7984 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
7985 address and file/line number respectively.\n\n",
7986 "Convenience variable \"$_\" and default examine address for \"x\"\n\
7987 are set to the address of the last breakpoint listed.\n\n\
7988 Convenience variable \"$bpnum\" contains the number of the last\n\
7989 breakpoint set.", NULL),
7990 &maintenanceinfolist);
7992 add_com ("catch", class_breakpoint, catch_command,
7993 "Set catchpoints to catch events.\n\
7994 Raised signals may be caught:\n\
7995 \tcatch signal - all signals\n\
7996 \tcatch signal <signame> - a particular signal\n\
7997 Raised exceptions may be caught:\n\
7998 \tcatch throw - all exceptions, when thrown\n\
7999 \tcatch throw <exceptname> - a particular exception, when thrown\n\
8000 \tcatch catch - all exceptions, when caught\n\
8001 \tcatch catch <exceptname> - a particular exception, when caught\n\
8002 Thread or process events may be caught:\n\
8003 \tcatch thread_start - any threads, just after creation\n\
8004 \tcatch thread_exit - any threads, just before expiration\n\
8005 \tcatch thread_join - any threads, just after joins\n\
8006 Process events may be caught:\n\
8007 \tcatch start - any processes, just after creation\n\
8008 \tcatch exit - any processes, just before expiration\n\
8009 \tcatch fork - calls to fork()\n\
8010 \tcatch vfork - calls to vfork()\n\
8011 \tcatch exec - calls to exec()\n\
8012 Dynamically-linked library events may be caught:\n\
8013 \tcatch load - loads of any library\n\
8014 \tcatch load <libname> - loads of a particular library\n\
8015 \tcatch unload - unloads of any library\n\
8016 \tcatch unload <libname> - unloads of a particular library\n\
8017 The act of your program's execution stopping may also be caught:\n\
8019 C++ exceptions may be caught:\n\
8020 \tcatch throw - all exceptions, when thrown\n\
8021 \tcatch catch - all exceptions, when caught\n\
8023 Do \"help set follow-fork-mode\" for info on debugging your program\n\
8024 after a fork or vfork is caught.\n\n\
8025 Do \"help breakpoints\" for info on other commands dealing with breakpoints.");
8027 add_com ("tcatch", class_breakpoint, tcatch_command,
8028 "Set temporary catchpoints to catch events.\n\
8029 Args like \"catch\" command.\n\
8030 Like \"catch\" except the catchpoint is only temporary,\n\
8031 so it will be deleted when hit. Equivalent to \"catch\" followed\n\
8032 by using \"enable delete\" on the catchpoint number.");
8034 c = add_com ("watch", class_breakpoint, watch_command,
8035 "Set a watchpoint for an expression.\n\
8036 A watchpoint stops execution of your program whenever the value of\n\
8037 an expression changes.");
8038 set_cmd_completer (c, location_completer);
8040 c = add_com ("rwatch", class_breakpoint, rwatch_command,
8041 "Set a read watchpoint for an expression.\n\
8042 A watchpoint stops execution of your program whenever the value of\n\
8043 an expression is read.");
8044 set_cmd_completer (c, location_completer);
8046 c = add_com ("awatch", class_breakpoint, awatch_command,
8047 "Set a watchpoint for an expression.\n\
8048 A watchpoint stops execution of your program whenever the value of\n\
8049 an expression is either read or written.");
8050 set_cmd_completer (c, location_completer);
8052 add_info ("watchpoints", breakpoints_info,
8053 "Synonym for ``info breakpoints''.");
8056 c = add_set_cmd ("can-use-hw-watchpoints", class_support, var_zinteger,
8057 (char *) &can_use_hw_watchpoints,
8058 "Set debugger's willingness to use watchpoint hardware.\n\
8059 If zero, gdb will not use hardware for new watchpoints, even if\n\
8060 such is available. (However, any hardware watchpoints that were\n\
8061 created before setting this to nonzero, will continue to use watchpoint\n\
8064 add_show_from_set (c, &showlist);
8066 can_use_hw_watchpoints = 1;
8068 add_prefix_cmd ("breakpoint", class_maintenance, set_breakpoint_cmd, "\
8069 Breakpoint specific settings\n\
8070 Configure various breakpoint-specific variables such as\n\
8071 pending breakpoint behavior",
8072 &breakpoint_set_cmdlist, "set breakpoint ",
8073 0/*allow-unknown*/, &setlist);
8074 add_prefix_cmd ("breakpoint", class_maintenance, show_breakpoint_cmd, "\
8075 Breakpoint specific settings\n\
8076 Configure various breakpoint-specific variables such as\n\
8077 pending breakpoint behavior",
8078 &breakpoint_show_cmdlist, "show breakpoint ",
8079 0/*allow-unknown*/, &showlist);
8081 add_setshow_cmd ("pending", no_class, var_auto_boolean,
8082 (char *) &pending_break_support,
8083 "Set debugger's behavior regarding pending breakpoints.\n\
8084 If on, an unrecognized breakpoint location will cause gdb to create a pending\n\
8085 breakpoint. If off, an unrecognized breakpoint location results in an error.\n\
8086 If auto, an unrecognized breakpoint location results in a user-query to see if\n\
8087 a pending breakpoint should be created.","\
8088 Show debugger's behavior regarding pending breakpoints.",
8089 NULL, NULL, &breakpoint_set_cmdlist, &breakpoint_show_cmdlist);
8091 pending_break_support = AUTO_BOOLEAN_AUTO;