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 Free Software
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 void break_command_1 (char *, int, int);
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 void set_breakpoint_count (int);
131 static int remove_breakpoint (struct bp_location *, insertion_state_t);
133 static enum print_stop_action print_it_typical (bpstat);
135 static enum print_stop_action print_bp_stop_message (bpstat bs);
139 enum exception_event_kind kind;
142 args_for_catchpoint_enable;
144 static int watchpoint_check (void *);
146 static int cover_target_enable_exception_callback (void *);
148 static void maintenance_info_breakpoints (char *, int);
150 static void create_longjmp_breakpoint (char *);
152 static void create_overlay_event_breakpoint (char *);
154 static int hw_breakpoint_used_count (void);
156 static int hw_watchpoint_used_count (enum bptype, int *);
158 static void hbreak_command (char *, int);
160 static void thbreak_command (char *, int);
162 static void watch_command_1 (char *, int, int);
164 static void rwatch_command (char *, int);
166 static void awatch_command (char *, int);
168 static void do_enable_breakpoint (struct breakpoint *, enum bpdisp);
170 static void solib_load_unload_1 (char *hookname,
173 char *cond_string, enum bptype bp_kind);
175 static void create_fork_vfork_event_catchpoint (int tempflag,
177 enum bptype bp_kind);
179 static void break_at_finish_at_depth_command_1 (char *arg,
180 int flag, int from_tty);
182 static void break_at_finish_command_1 (char *arg, int flag, int from_tty);
184 static void stop_command (char *arg, int from_tty);
186 static void stopin_command (char *arg, int from_tty);
188 static void stopat_command (char *arg, int from_tty);
190 static char *ep_find_event_name_end (char *arg);
192 static char *ep_parse_optional_if_clause (char **arg);
194 static char *ep_parse_optional_filename (char **arg);
196 #if defined(CHILD_INSERT_EXEC_CATCHPOINT)
197 static void catch_exec_command_1 (char *arg, int tempflag, int from_tty);
200 static void create_exception_catchpoint (int tempflag, char *cond_string,
201 enum exception_event_kind ex_event,
202 struct symtab_and_line *sal);
204 static void catch_exception_command_1 (enum exception_event_kind ex_event,
205 char *arg, int tempflag, int from_tty);
207 static void tcatch_command (char *arg, int from_tty);
209 static void ep_skip_leading_whitespace (char **s);
211 /* Prototypes for exported functions. */
213 /* If FALSE, gdb will not use hardware support for watchpoints, even
214 if such is available. */
215 static int can_use_hw_watchpoints;
217 void _initialize_breakpoint (void);
219 extern int addressprint; /* Print machine addresses? */
221 /* Are we executing breakpoint commands? */
222 static int executing_breakpoint_commands;
224 /* Are overlay event breakpoints enabled? */
225 static int overlay_events_enabled;
227 /* Walk the following statement or block through all breakpoints.
228 ALL_BREAKPOINTS_SAFE does so even if the statment deletes the current
231 #define ALL_BREAKPOINTS(B) for (B = breakpoint_chain; B; B = B->next)
233 #define ALL_BREAKPOINTS_SAFE(B,TMP) \
234 for (B = breakpoint_chain; \
235 B ? (TMP=B->next, 1): 0; \
238 /* Similar iterators for the low-level breakpoints. */
240 #define ALL_BP_LOCATIONS(B) for (B = bp_location_chain; B; B = B->next)
242 #define ALL_BP_LOCATIONS_SAFE(B,TMP) \
243 for (B = bp_location_chain; \
244 B ? (TMP=B->next, 1): 0; \
247 /* True if SHIFT_INST_REGS defined, false otherwise. */
249 int must_shift_inst_regs =
250 #if defined(SHIFT_INST_REGS)
257 /* True if breakpoint hit counts should be displayed in breakpoint info. */
259 int show_breakpoint_hit_counts = 1;
261 /* Chains of all breakpoints defined. */
263 struct breakpoint *breakpoint_chain;
265 struct bp_location *bp_location_chain;
267 /* Number of last breakpoint made. */
269 int breakpoint_count;
271 /* Pointer to current exception event record */
272 static struct exception_event_record *current_exception_event;
274 /* Indicator of whether exception catchpoints should be nuked
275 between runs of a program */
276 int exception_catchpoints_are_fragile = 0;
278 /* Indicator of when exception catchpoints set-up should be
279 reinitialized -- e.g. when program is re-run */
280 int exception_support_initialized = 0;
282 /* This function returns a pointer to the string representation of the
283 pathname of the dynamically-linked library that has just been
286 This function must be used only when SOLIB_HAVE_LOAD_EVENT is TRUE,
287 or undefined results are guaranteed.
289 This string's contents are only valid immediately after the
290 inferior has stopped in the dynamic linker hook, and becomes
291 invalid as soon as the inferior is continued. Clients should make
292 a copy of this string if they wish to continue the inferior and
293 then access the string. */
295 #ifndef SOLIB_LOADED_LIBRARY_PATHNAME
296 #define SOLIB_LOADED_LIBRARY_PATHNAME(pid) ""
299 /* This function returns a pointer to the string representation of the
300 pathname of the dynamically-linked library that has just been
303 This function must be used only when SOLIB_HAVE_UNLOAD_EVENT is
304 TRUE, or undefined results are guaranteed.
306 This string's contents are only valid immediately after the
307 inferior has stopped in the dynamic linker hook, and becomes
308 invalid as soon as the inferior is continued. Clients should make
309 a copy of this string if they wish to continue the inferior and
310 then access the string. */
312 #ifndef SOLIB_UNLOADED_LIBRARY_PATHNAME
313 #define SOLIB_UNLOADED_LIBRARY_PATHNAME(pid) ""
316 /* This function is called by the "catch load" command. It allows the
317 debugger to be notified by the dynamic linker when a specified
318 library file (or any library file, if filename is NULL) is loaded. */
320 #ifndef SOLIB_CREATE_CATCH_LOAD_HOOK
321 #define SOLIB_CREATE_CATCH_LOAD_HOOK(pid,tempflag,filename,cond_string) \
322 error ("catch of library loads not yet implemented on this platform")
325 /* This function is called by the "catch unload" command. It allows
326 the debugger to be notified by the dynamic linker when a specified
327 library file (or any library file, if filename is NULL) is
330 #ifndef SOLIB_CREATE_CATCH_UNLOAD_HOOK
331 #define SOLIB_CREATE_CATCH_UNLOAD_HOOK(pid,tempflag,filename,cond_string) \
332 error ("catch of library unloads not yet implemented on this platform")
335 /* Return whether a breakpoint is an active enabled breakpoint. */
337 breakpoint_enabled (struct breakpoint *b)
339 return b->enable_state == bp_enabled;
342 /* Set breakpoint count to NUM. */
345 set_breakpoint_count (int num)
347 breakpoint_count = num;
348 set_internalvar (lookup_internalvar ("bpnum"),
349 value_from_longest (builtin_type_int, (LONGEST) num));
352 /* Used in run_command to zero the hit count when a new run starts. */
355 clear_breakpoint_hit_counts (void)
357 struct breakpoint *b;
363 /* Default address, symtab and line to put a breakpoint at
364 for "break" command with no arg.
365 if default_breakpoint_valid is zero, the other three are
366 not valid, and "break" with no arg is an error.
368 This set by print_stack_frame, which calls set_default_breakpoint. */
370 int default_breakpoint_valid;
371 CORE_ADDR default_breakpoint_address;
372 struct symtab *default_breakpoint_symtab;
373 int default_breakpoint_line;
375 /* *PP is a string denoting a breakpoint. Get the number of the breakpoint.
376 Advance *PP after the string and any trailing whitespace.
378 Currently the string can either be a number or "$" followed by the name
379 of a convenience variable. Making it an expression wouldn't work well
380 for map_breakpoint_numbers (e.g. "4 + 5 + 6").
382 TRAILER is a character which can be found after the number; most
383 commonly this is `-'. If you don't want a trailer, use \0. */
385 get_number_trailer (char **pp, int trailer)
387 int retval = 0; /* default */
391 /* Empty line means refer to the last breakpoint. */
392 return breakpoint_count;
395 /* Make a copy of the name, so we can null-terminate it
396 to pass to lookup_internalvar(). */
401 while (isalnum (*p) || *p == '_')
403 varname = (char *) alloca (p - start + 1);
404 strncpy (varname, start, p - start);
405 varname[p - start] = '\0';
406 val = value_of_internalvar (lookup_internalvar (varname));
407 if (TYPE_CODE (VALUE_TYPE (val)) == TYPE_CODE_INT)
408 retval = (int) value_as_long (val);
411 printf_filtered ("Convenience variable must have integer value.\n");
419 while (*p >= '0' && *p <= '9')
422 /* There is no number here. (e.g. "cond a == b"). */
424 /* Skip non-numeric token */
425 while (*p && !isspace((int) *p))
427 /* Return zero, which caller must interpret as error. */
433 if (!(isspace (*p) || *p == '\0' || *p == trailer))
435 /* Trailing junk: return 0 and let caller print error msg. */
436 while (!(isspace (*p) || *p == '\0' || *p == trailer))
447 /* Like get_number_trailer, but don't allow a trailer. */
449 get_number (char **pp)
451 return get_number_trailer (pp, '\0');
454 /* Parse a number or a range.
455 * A number will be of the form handled by get_number.
456 * A range will be of the form <number1> - <number2>, and
457 * will represent all the integers between number1 and number2,
460 * While processing a range, this fuction is called iteratively;
461 * At each call it will return the next value in the range.
463 * At the beginning of parsing a range, the char pointer PP will
464 * be advanced past <number1> and left pointing at the '-' token.
465 * Subsequent calls will not advance the pointer until the range
466 * is completed. The call that completes the range will advance
467 * pointer PP past <number2>.
471 get_number_or_range (char **pp)
473 static int last_retval, end_value;
474 static char *end_ptr;
475 static int in_range = 0;
479 /* Default case: pp is pointing either to a solo number,
480 or to the first number of a range. */
481 last_retval = get_number_trailer (pp, '-');
486 /* This is the start of a range (<number1> - <number2>).
487 Skip the '-', parse and remember the second number,
488 and also remember the end of the final token. */
492 while (isspace ((int) *end_ptr))
493 end_ptr++; /* skip white space */
494 end_value = get_number (temp);
495 if (end_value < last_retval)
497 error ("inverted range");
499 else if (end_value == last_retval)
501 /* degenerate range (number1 == number2). Advance the
502 token pointer so that the range will be treated as a
511 error ("negative value");
514 /* pp points to the '-' that betokens a range. All
515 number-parsing has already been done. Return the next
516 integer value (one greater than the saved previous value).
517 Do not advance the token pointer 'pp' until the end of range
520 if (++last_retval == end_value)
522 /* End of range reached; advance token pointer. */
532 /* condition N EXP -- set break condition of breakpoint N to EXP. */
535 condition_command (char *arg, int from_tty)
537 struct breakpoint *b;
542 error_no_arg ("breakpoint number");
545 bnum = get_number (&p);
547 error ("Bad breakpoint argument: '%s'", arg);
550 if (b->number == bnum)
557 if (b->cond_string != NULL)
558 xfree (b->cond_string);
563 b->cond_string = NULL;
565 printf_filtered ("Breakpoint %d now unconditional.\n", bnum);
570 /* I don't know if it matters whether this is the string the user
571 typed in or the decompiled expression. */
572 b->cond_string = savestring (arg, strlen (arg));
573 b->cond = parse_exp_1 (&arg, block_for_pc (b->loc->address), 0);
575 error ("Junk at end of expression");
577 breakpoints_changed ();
578 breakpoint_modify_event (b->number);
582 error ("No breakpoint number %d.", bnum);
586 commands_command (char *arg, int from_tty)
588 struct breakpoint *b;
591 struct command_line *l;
593 /* If we allowed this, we would have problems with when to
594 free the storage, if we change the commands currently
597 if (executing_breakpoint_commands)
598 error ("Can't use the \"commands\" command among a breakpoint's commands.");
601 bnum = get_number (&p);
604 error ("Unexpected extra arguments following breakpoint number.");
607 if (b->number == bnum)
609 char *tmpbuf = xstrprintf ("Type commands for when breakpoint %d is hit, one per line.",
611 struct cleanup *cleanups = make_cleanup (xfree, tmpbuf);
612 l = read_command_lines (tmpbuf, from_tty);
613 do_cleanups (cleanups);
614 free_command_lines (&b->commands);
616 breakpoints_changed ();
617 breakpoint_modify_event (b->number);
620 error ("No breakpoint number %d.", bnum);
623 /* Like target_read_memory() but if breakpoints are inserted, return
624 the shadow contents instead of the breakpoints themselves.
626 Read "memory data" from whatever target or inferior we have.
627 Returns zero if successful, errno value if not. EIO is used
628 for address out of bounds. If breakpoints are inserted, returns
629 shadow contents, not the breakpoints themselves. From breakpoint.c. */
632 read_memory_nobpt (CORE_ADDR memaddr, char *myaddr, unsigned len)
635 struct bp_location *b;
636 CORE_ADDR bp_addr = 0;
639 if (BREAKPOINT_FROM_PC (&bp_addr, &bp_size) == NULL)
640 /* No breakpoints on this machine. */
641 return target_read_memory (memaddr, myaddr, len);
645 if (b->owner->type == bp_none)
646 warning ("reading through apparently deleted breakpoint #%d?",
649 if (b->loc_type != bp_loc_software_breakpoint)
653 /* Addresses and length of the part of the breakpoint that
655 /* XXXX The m68k, sh and h8300 have different local and remote
656 breakpoint values. BREAKPOINT_FROM_PC still manages to
657 correctly determine the breakpoints memory address and size
658 for these targets. */
659 bp_addr = b->address;
661 if (BREAKPOINT_FROM_PC (&bp_addr, &bp_size) == NULL)
666 if (bp_addr + bp_size <= memaddr)
667 /* The breakpoint is entirely before the chunk of memory we
670 if (bp_addr >= memaddr + len)
671 /* The breakpoint is entirely after the chunk of memory we are
674 /* Copy the breakpoint from the shadow contents, and recurse for
675 the things before and after. */
677 /* Offset within shadow_contents. */
680 if (bp_addr < memaddr)
682 /* Only copy the second part of the breakpoint. */
683 bp_size -= memaddr - bp_addr;
684 bptoffset = memaddr - bp_addr;
688 if (bp_addr + bp_size > memaddr + len)
690 /* Only copy the first part of the breakpoint. */
691 bp_size -= (bp_addr + bp_size) - (memaddr + len);
694 memcpy (myaddr + bp_addr - memaddr,
695 b->shadow_contents + bptoffset, bp_size);
697 if (bp_addr > memaddr)
699 /* Copy the section of memory before the breakpoint. */
700 status = read_memory_nobpt (memaddr, myaddr, bp_addr - memaddr);
705 if (bp_addr + bp_size < memaddr + len)
707 /* Copy the section of memory after the breakpoint. */
708 status = read_memory_nobpt (bp_addr + bp_size,
709 myaddr + bp_addr + bp_size - memaddr,
710 memaddr + len - (bp_addr + bp_size));
717 /* Nothing overlaps. Just call read_memory_noerr. */
718 return target_read_memory (memaddr, myaddr, len);
722 /* A wrapper function for inserting catchpoints. */
724 insert_catchpoint (struct ui_out *uo, void *args)
726 struct breakpoint *b = (struct breakpoint *) args;
732 val = target_insert_fork_catchpoint (PIDGET (inferior_ptid));
735 val = target_insert_vfork_catchpoint (PIDGET (inferior_ptid));
738 val = target_insert_exec_catchpoint (PIDGET (inferior_ptid));
741 internal_error (__FILE__, __LINE__, "unknown breakpoint type");
746 throw_exception (RETURN_ERROR);
751 /* Insert a low-level "breakpoint" of some type. BPT is the breakpoint.
752 Any error messages are printed to TMP_ERROR_STREAM; and DISABLED_BREAKS,
753 PROCESS_WARNING, and HW_BREAKPOINT_ERROR are used to report problems.
755 NOTE drow/2003-09-09: This routine could be broken down to an object-style
756 method for each breakpoint or catchpoint type. */
758 insert_bp_location (struct bp_location *bpt,
759 struct ui_file *tmp_error_stream,
760 int *disabled_breaks, int *process_warning,
761 int *hw_breakpoint_error)
765 /* Permanent breakpoints cannot be inserted or removed. Disabled
766 breakpoints should not be inserted. */
767 if (!breakpoint_enabled (bpt->owner))
770 if (bpt->inserted || bpt->duplicate)
773 if (bpt->loc_type == bp_loc_software_breakpoint
774 || bpt->loc_type == bp_loc_hardware_breakpoint)
776 /* First check to see if we have to handle an overlay. */
777 if (overlay_debugging == ovly_off
778 || bpt->section == NULL
779 || !(section_is_overlay (bpt->section)))
781 /* No overlay handling: just set the breakpoint. */
783 if (bpt->loc_type == bp_loc_hardware_breakpoint)
784 val = target_insert_hw_breakpoint (bpt->address,
785 bpt->shadow_contents);
787 val = target_insert_breakpoint (bpt->address,
788 bpt->shadow_contents);
792 /* This breakpoint is in an overlay section.
793 Shall we set a breakpoint at the LMA? */
794 if (!overlay_events_enabled)
796 /* Yes -- overlay event support is not active,
797 so we must try to set a breakpoint at the LMA.
798 This will not work for a hardware breakpoint. */
799 if (bpt->loc_type == bp_loc_hardware_breakpoint)
800 warning ("hardware breakpoint %d not supported in overlay!\n",
804 CORE_ADDR addr = overlay_unmapped_address (bpt->address,
806 /* Set a software (trap) breakpoint at the LMA. */
807 val = target_insert_breakpoint (addr, bpt->shadow_contents);
809 fprintf_unfiltered (tmp_error_stream,
810 "Overlay breakpoint %d failed: in ROM?",
814 /* Shall we set a breakpoint at the VMA? */
815 if (section_is_mapped (bpt->section))
817 /* Yes. This overlay section is mapped into memory. */
818 if (bpt->loc_type == bp_loc_hardware_breakpoint)
819 val = target_insert_hw_breakpoint (bpt->address,
820 bpt->shadow_contents);
822 val = target_insert_breakpoint (bpt->address,
823 bpt->shadow_contents);
827 /* No. This breakpoint will not be inserted.
828 No error, but do not mark the bp as 'inserted'. */
835 /* Can't set the breakpoint. */
836 #if defined (DISABLE_UNSETTABLE_BREAK)
837 if (DISABLE_UNSETTABLE_BREAK (bpt->address))
839 /* See also: disable_breakpoints_in_shlibs. */
841 bpt->owner->enable_state = bp_shlib_disabled;
842 if (!*disabled_breaks)
844 fprintf_unfiltered (tmp_error_stream,
845 "Cannot insert breakpoint %d.\n",
847 fprintf_unfiltered (tmp_error_stream,
848 "Temporarily disabling shared library breakpoints:\n");
850 *disabled_breaks = 1;
851 fprintf_unfiltered (tmp_error_stream,
852 "breakpoint #%d\n", bpt->owner->number);
857 #ifdef ONE_PROCESS_WRITETEXT
858 *process_warning = 1;
860 if (bpt->loc_type == bp_loc_hardware_breakpoint)
862 *hw_breakpoint_error = 1;
863 fprintf_unfiltered (tmp_error_stream,
864 "Cannot insert hardware breakpoint %d.\n",
869 fprintf_unfiltered (tmp_error_stream,
870 "Cannot insert breakpoint %d.\n",
872 fprintf_filtered (tmp_error_stream,
873 "Error accessing memory address ");
874 print_address_numeric (bpt->address, 1, tmp_error_stream);
875 fprintf_filtered (tmp_error_stream, ": %s.\n",
876 safe_strerror (val));
887 else if (bpt->loc_type == bp_loc_hardware_watchpoint
888 /* NOTE drow/2003-09-08: This state only exists for removing
889 watchpoints. It's not clear that it's necessary... */
890 && bpt->owner->disposition != disp_del_at_next_stop)
892 /* FIXME drow/2003-09-08: This code sets multiple hardware watchpoints
893 based on the expression. Ideally this should happen at a higher level,
894 and there should be one bp_location for each computed address we
895 must watch. As soon as a many-to-one mapping is available I'll
898 struct frame_info *saved_frame;
899 int saved_level, within_current_scope;
900 struct value *mark = value_mark ();
903 /* Save the current frame and level so we can restore it after
904 evaluating the watchpoint expression on its own frame. */
905 /* FIXME drow/2003-09-09: It would be nice if evaluate_expression
906 took a frame parameter, so that we didn't have to change the
908 saved_frame = deprecated_selected_frame;
909 saved_level = frame_relative_level (deprecated_selected_frame);
911 /* Determine if the watchpoint is within scope. */
912 if (bpt->owner->exp_valid_block == NULL)
913 within_current_scope = 1;
916 struct frame_info *fi;
917 fi = frame_find_by_id (bpt->owner->watchpoint_frame);
918 within_current_scope = (fi != NULL);
919 if (within_current_scope)
923 if (within_current_scope)
925 /* Evaluate the expression and cut the chain of values
926 produced off from the value chain.
928 Make sure the value returned isn't lazy; we use
929 laziness to determine what memory GDB actually needed
930 in order to compute the value of the expression. */
931 v = evaluate_expression (bpt->owner->exp);
933 value_release_to_mark (mark);
935 bpt->owner->val_chain = v;
938 /* Look at each value on the value chain. */
939 for (; v; v = v->next)
941 /* If it's a memory location, and GDB actually needed
942 its contents to evaluate the expression, then we
944 if (VALUE_LVAL (v) == lval_memory
947 struct type *vtype = check_typedef (VALUE_TYPE (v));
949 /* We only watch structs and arrays if user asked
950 for it explicitly, never if they just happen to
951 appear in the middle of some value chain. */
952 if (v == bpt->owner->val_chain
953 || (TYPE_CODE (vtype) != TYPE_CODE_STRUCT
954 && TYPE_CODE (vtype) != TYPE_CODE_ARRAY))
959 addr = VALUE_ADDRESS (v) + VALUE_OFFSET (v);
960 len = TYPE_LENGTH (VALUE_TYPE (v));
962 if (bpt->owner->type == bp_read_watchpoint)
964 else if (bpt->owner->type == bp_access_watchpoint)
967 val = target_insert_watchpoint (addr, len, type);
970 /* Don't exit the loop, try to insert
971 every value on the value chain. That's
972 because we will be removing all the
973 watches below, and removing a
974 watchpoint we didn't insert could have
982 /* Failure to insert a watchpoint on any memory value in the
983 value chain brings us here. */
986 remove_breakpoint (bpt, mark_uninserted);
987 *hw_breakpoint_error = 1;
988 fprintf_unfiltered (tmp_error_stream,
989 "Could not insert hardware watchpoint %d.\n",
996 printf_filtered ("Hardware watchpoint %d deleted ", bpt->owner->number);
997 printf_filtered ("because the program has left the block \n");
998 printf_filtered ("in which its expression is valid.\n");
999 if (bpt->owner->related_breakpoint)
1000 bpt->owner->related_breakpoint->disposition = disp_del_at_next_stop;
1001 bpt->owner->disposition = disp_del_at_next_stop;
1004 /* Restore the frame and level. */
1005 if (saved_frame != deprecated_selected_frame
1006 || saved_level != frame_relative_level (deprecated_selected_frame))
1007 select_frame (saved_frame);
1012 else if (ep_is_exception_catchpoint (bpt->owner))
1014 /* FIXME drow/2003-09-09: This code sets both a catchpoint and a
1015 breakpoint. Once again, it would be better if this was represented
1016 as two bp_locations. */
1018 /* If we get here, we must have a callback mechanism for exception
1019 events -- with g++ style embedded label support, we insert
1020 ordinary breakpoints and not catchpoints. */
1021 val = target_insert_breakpoint (bpt->address, bpt->shadow_contents);
1024 /* Couldn't set breakpoint for some reason */
1025 fprintf_unfiltered (tmp_error_stream,
1026 "Cannot insert catchpoint %d; disabling it.\n",
1027 bpt->owner->number);
1028 fprintf_filtered (tmp_error_stream,
1029 "Error accessing memory address ");
1030 print_address_numeric (bpt->address, 1, tmp_error_stream);
1031 fprintf_filtered (tmp_error_stream, ": %s.\n",
1032 safe_strerror (val));
1033 bpt->owner->enable_state = bp_disabled;
1037 /* Bp set, now make sure callbacks are enabled */
1038 /* Format possible error msg */
1039 char *message = xstrprintf ("Error inserting catchpoint %d:\n",
1040 bpt->owner->number);
1041 struct cleanup *cleanups = make_cleanup (xfree, message);
1043 args_for_catchpoint_enable args;
1044 args.kind = bpt->owner->type == bp_catch_catch ?
1045 EX_EVENT_CATCH : EX_EVENT_THROW;
1047 val = catch_errors (cover_target_enable_exception_callback,
1048 &args, message, RETURN_MASK_ALL);
1049 do_cleanups (cleanups);
1050 if (val != 0 && val != -1)
1053 /* Check if something went wrong; val == 0 can be ignored */
1056 /* something went wrong */
1057 fprintf_unfiltered (tmp_error_stream,
1058 "Cannot insert catchpoint %d; disabling it.\n",
1059 bpt->owner->number);
1060 bpt->owner->enable_state = bp_disabled;
1067 else if (bpt->owner->type == bp_catch_fork
1068 || bpt->owner->type == bp_catch_vfork
1069 || bpt->owner->type == bp_catch_exec)
1071 char *prefix = xstrprintf ("warning: inserting catchpoint %d: ",
1072 bpt->owner->number);
1073 struct cleanup *cleanups = make_cleanup (xfree, prefix);
1074 val = catch_exceptions (uiout, insert_catchpoint, bpt->owner, prefix,
1076 do_cleanups (cleanups);
1078 bpt->owner->enable_state = bp_disabled;
1082 /* We've already printed an error message if there was a problem
1083 inserting this catchpoint, and we've disabled the catchpoint,
1084 so just return success. */
1091 /* insert_breakpoints is used when starting or continuing the program.
1092 remove_breakpoints is used when the program stops.
1093 Both return zero if successful,
1094 or an `errno' value if could not write the inferior. */
1097 insert_breakpoints (void)
1099 struct bp_location *b, *temp;
1100 int return_val = 0; /* return success code. */
1102 int disabled_breaks = 0;
1103 int hw_breakpoint_error = 0;
1104 int process_warning = 0;
1106 struct ui_file *tmp_error_stream = mem_fileopen ();
1107 make_cleanup_ui_file_delete (tmp_error_stream);
1109 /* Explicitly mark the warning -- this will only be printed if
1110 there was an error. */
1111 fprintf_unfiltered (tmp_error_stream, "Warning:\n");
1113 ALL_BP_LOCATIONS_SAFE (b, temp)
1115 /* Permanent breakpoints cannot be inserted or removed. Disabled
1116 breakpoints should not be inserted. */
1117 if (!breakpoint_enabled (b->owner))
1120 /* FIXME drow/2003-10-07: This code should be pushed elsewhere when
1121 hardware watchpoints are split into multiple loc breakpoints. */
1122 if ((b->loc_type == bp_loc_hardware_watchpoint
1123 || b->owner->type == bp_watchpoint) && !b->owner->val)
1126 val = evaluate_expression (b->owner->exp);
1127 release_value (val);
1128 if (VALUE_LAZY (val))
1129 value_fetch_lazy (val);
1130 b->owner->val = val;
1133 val = insert_bp_location (b, tmp_error_stream,
1134 &disabled_breaks, &process_warning,
1135 &hw_breakpoint_error);
1142 /* If a hardware breakpoint or watchpoint was inserted, add a
1143 message about possibly exhausted resources. */
1144 if (hw_breakpoint_error)
1146 fprintf_unfiltered (tmp_error_stream,
1147 "Could not insert hardware breakpoints:\n\
1148 You may have requested too many hardware breakpoints/watchpoints.\n");
1150 #ifdef ONE_PROCESS_WRITETEXT
1151 if (process_warning)
1152 fprintf_unfiltered (tmp_error_stream,
1153 "The same program may be running in another process.");
1155 target_terminal_ours_for_output ();
1156 error_stream (tmp_error_stream);
1162 remove_breakpoints (void)
1164 struct bp_location *b;
1167 ALL_BP_LOCATIONS (b)
1171 val = remove_breakpoint (b, mark_uninserted);
1180 remove_hw_watchpoints (void)
1182 struct bp_location *b;
1185 ALL_BP_LOCATIONS (b)
1187 if (b->inserted && b->loc_type == bp_loc_hardware_watchpoint)
1189 val = remove_breakpoint (b, mark_uninserted);
1198 reattach_breakpoints (int pid)
1200 struct bp_location *b;
1202 struct cleanup *old_chain = save_inferior_ptid ();
1204 /* Set inferior_ptid; remove_breakpoint uses this global. */
1205 inferior_ptid = pid_to_ptid (pid);
1206 ALL_BP_LOCATIONS (b)
1210 remove_breakpoint (b, mark_inserted);
1211 if (b->loc_type == bp_loc_hardware_breakpoint)
1212 val = target_insert_hw_breakpoint (b->address, b->shadow_contents);
1214 val = target_insert_breakpoint (b->address, b->shadow_contents);
1215 /* FIXME drow/2003-10-07: This doesn't handle any other kinds of
1216 breakpoints. It's wrong for watchpoints, for example. */
1219 do_cleanups (old_chain);
1224 do_cleanups (old_chain);
1229 update_breakpoints_after_exec (void)
1231 struct breakpoint *b;
1232 struct breakpoint *temp;
1234 /* Doing this first prevents the badness of having delete_breakpoint()
1235 write a breakpoint's current "shadow contents" to lift the bp. That
1236 shadow is NOT valid after an exec()! */
1237 mark_breakpoints_out ();
1239 ALL_BREAKPOINTS_SAFE (b, temp)
1241 /* Solib breakpoints must be explicitly reset after an exec(). */
1242 if (b->type == bp_shlib_event)
1244 delete_breakpoint (b);
1248 /* Thread event breakpoints must be set anew after an exec(),
1249 as must overlay event breakpoints. */
1250 if (b->type == bp_thread_event || b->type == bp_overlay_event)
1252 delete_breakpoint (b);
1256 /* Step-resume breakpoints are meaningless after an exec(). */
1257 if (b->type == bp_step_resume)
1259 delete_breakpoint (b);
1263 /* Ditto the sigtramp handler breakpoints. */
1264 if (b->type == bp_through_sigtramp)
1266 delete_breakpoint (b);
1270 /* Ditto the exception-handling catchpoints. */
1271 if ((b->type == bp_catch_catch) || (b->type == bp_catch_throw))
1273 delete_breakpoint (b);
1277 /* Don't delete an exec catchpoint, because else the inferior
1278 won't stop when it ought!
1280 Similarly, we probably ought to keep vfork catchpoints, 'cause
1281 on this target, we may not be able to stop when the vfork is
1282 seen, but only when the subsequent exec is seen. (And because
1283 deleting fork catchpoints here but not vfork catchpoints will
1284 seem mysterious to users, keep those too.)
1286 ??rehrauer: Let's hope that merely clearing out this catchpoint's
1287 target address field, if any, is sufficient to have it be reset
1288 automagically. Certainly on HP-UX that's true.
1290 Jim Blandy <jimb@redhat.com>: Actually, zero is a perfectly
1291 valid code address on some platforms (like the mn10300
1292 simulators). We shouldn't assign any special interpretation to
1293 a breakpoint with a zero address. And in fact, GDB doesn't ---
1294 I can't see what that comment above is talking about. As far
1295 as I can tell, setting the address of a
1296 bp_catch_exec/bp_catch_vfork/bp_catch_fork breakpoint to zero
1297 is meaningless, since those are implemented with HP-UX kernel
1298 hackery, not by storing breakpoint instructions somewhere. */
1299 if ((b->type == bp_catch_exec) ||
1300 (b->type == bp_catch_vfork) ||
1301 (b->type == bp_catch_fork))
1303 b->loc->address = (CORE_ADDR) NULL;
1307 /* bp_finish is a special case. The only way we ought to be able
1308 to see one of these when an exec() has happened, is if the user
1309 caught a vfork, and then said "finish". Ordinarily a finish just
1310 carries them to the call-site of the current callee, by setting
1311 a temporary bp there and resuming. But in this case, the finish
1312 will carry them entirely through the vfork & exec.
1314 We don't want to allow a bp_finish to remain inserted now. But
1315 we can't safely delete it, 'cause finish_command has a handle to
1316 the bp on a bpstat, and will later want to delete it. There's a
1317 chance (and I've seen it happen) that if we delete the bp_finish
1318 here, that its storage will get reused by the time finish_command
1319 gets 'round to deleting the "use to be a bp_finish" breakpoint.
1320 We really must allow finish_command to delete a bp_finish.
1322 In the absense of a general solution for the "how do we know
1323 it's safe to delete something others may have handles to?"
1324 problem, what we'll do here is just uninsert the bp_finish, and
1325 let finish_command delete it.
1327 (We know the bp_finish is "doomed" in the sense that it's
1328 momentary, and will be deleted as soon as finish_command sees
1329 the inferior stopped. So it doesn't matter that the bp's
1330 address is probably bogus in the new a.out, unlike e.g., the
1331 solib breakpoints.) */
1333 if (b->type == bp_finish)
1338 /* Without a symbolic address, we have little hope of the
1339 pre-exec() address meaning the same thing in the post-exec()
1341 if (b->addr_string == NULL)
1343 delete_breakpoint (b);
1347 /* If this breakpoint has survived the above battery of checks, then
1348 it must have a symbolic address. Be sure that it gets reevaluated
1349 to a target address, rather than reusing the old evaluation.
1351 Jim Blandy <jimb@redhat.com>: As explained above in the comment
1352 for bp_catch_exec and friends, I'm pretty sure this is entirely
1353 unnecessary. A call to breakpoint_re_set_one always recomputes
1354 the breakpoint's address from scratch, or deletes it if it can't.
1355 So I think this assignment could be deleted without effect. */
1356 b->loc->address = (CORE_ADDR) NULL;
1358 /* FIXME what about longjmp breakpoints? Re-create them here? */
1359 create_overlay_event_breakpoint ("_ovly_debug_event");
1363 detach_breakpoints (int pid)
1365 struct bp_location *b;
1367 struct cleanup *old_chain = save_inferior_ptid ();
1369 if (pid == PIDGET (inferior_ptid))
1370 error ("Cannot detach breakpoints of inferior_ptid");
1372 /* Set inferior_ptid; remove_breakpoint uses this global. */
1373 inferior_ptid = pid_to_ptid (pid);
1374 ALL_BP_LOCATIONS (b)
1378 val = remove_breakpoint (b, mark_inserted);
1381 do_cleanups (old_chain);
1386 do_cleanups (old_chain);
1391 remove_breakpoint (struct bp_location *b, insertion_state_t is)
1395 if (b->owner->enable_state == bp_permanent)
1396 /* Permanent breakpoints cannot be inserted or removed. */
1399 if (b->owner->type == bp_none)
1400 warning ("attempted to remove apparently deleted breakpoint #%d?",
1403 if (b->loc_type == bp_loc_software_breakpoint
1404 || b->loc_type == bp_loc_hardware_breakpoint)
1406 /* "Normal" instruction breakpoint: either the standard
1407 trap-instruction bp (bp_breakpoint), or a
1408 bp_hardware_breakpoint. */
1410 /* First check to see if we have to handle an overlay. */
1411 if (overlay_debugging == ovly_off
1412 || b->section == NULL
1413 || !(section_is_overlay (b->section)))
1415 /* No overlay handling: just remove the breakpoint. */
1417 if (b->loc_type == bp_loc_hardware_breakpoint)
1418 val = target_remove_hw_breakpoint (b->address,
1419 b->shadow_contents);
1421 val = target_remove_breakpoint (b->address, b->shadow_contents);
1425 /* This breakpoint is in an overlay section.
1426 Did we set a breakpoint at the LMA? */
1427 if (!overlay_events_enabled)
1429 /* Yes -- overlay event support is not active, so we
1430 should have set a breakpoint at the LMA. Remove it.
1432 CORE_ADDR addr = overlay_unmapped_address (b->address,
1434 /* Ignore any failures: if the LMA is in ROM, we will
1435 have already warned when we failed to insert it. */
1436 if (b->loc_type == bp_loc_hardware_breakpoint)
1437 target_remove_hw_breakpoint (addr, b->shadow_contents);
1439 target_remove_breakpoint (addr, b->shadow_contents);
1441 /* Did we set a breakpoint at the VMA?
1442 If so, we will have marked the breakpoint 'inserted'. */
1445 /* Yes -- remove it. Previously we did not bother to
1446 remove the breakpoint if the section had been
1447 unmapped, but let's not rely on that being safe. We
1448 don't know what the overlay manager might do. */
1449 if (b->loc_type == bp_loc_hardware_breakpoint)
1450 val = target_remove_hw_breakpoint (b->address,
1451 b->shadow_contents);
1453 val = target_remove_breakpoint (b->address,
1454 b->shadow_contents);
1458 /* No -- not inserted, so no need to remove. No error. */
1464 b->inserted = (is == mark_inserted);
1466 else if (b->loc_type == bp_loc_hardware_watchpoint
1467 && breakpoint_enabled (b->owner)
1473 b->inserted = (is == mark_inserted);
1474 /* Walk down the saved value chain. */
1475 for (v = b->owner->val_chain; v; v = v->next)
1477 /* For each memory reference remove the watchpoint
1479 if (VALUE_LVAL (v) == lval_memory
1480 && ! VALUE_LAZY (v))
1482 struct type *vtype = check_typedef (VALUE_TYPE (v));
1484 if (v == b->owner->val_chain
1485 || (TYPE_CODE (vtype) != TYPE_CODE_STRUCT
1486 && TYPE_CODE (vtype) != TYPE_CODE_ARRAY))
1491 addr = VALUE_ADDRESS (v) + VALUE_OFFSET (v);
1492 len = TYPE_LENGTH (VALUE_TYPE (v));
1494 if (b->owner->type == bp_read_watchpoint)
1496 else if (b->owner->type == bp_access_watchpoint)
1499 val = target_remove_watchpoint (addr, len, type);
1506 /* Failure to remove any of the hardware watchpoints comes here. */
1507 if ((is == mark_uninserted) && (b->inserted))
1508 warning ("Could not remove hardware watchpoint %d.",
1511 /* Free the saved value chain. We will construct a new one
1512 the next time the watchpoint is inserted. */
1513 for (v = b->owner->val_chain; v; v = n)
1518 b->owner->val_chain = NULL;
1520 else if ((b->owner->type == bp_catch_fork ||
1521 b->owner->type == bp_catch_vfork ||
1522 b->owner->type == bp_catch_exec)
1523 && breakpoint_enabled (b->owner)
1527 switch (b->owner->type)
1530 val = target_remove_fork_catchpoint (PIDGET (inferior_ptid));
1532 case bp_catch_vfork:
1533 val = target_remove_vfork_catchpoint (PIDGET (inferior_ptid));
1536 val = target_remove_exec_catchpoint (PIDGET (inferior_ptid));
1539 warning ("Internal error, %s line %d.", __FILE__, __LINE__);
1544 b->inserted = (is == mark_inserted);
1546 else if ((b->owner->type == bp_catch_catch ||
1547 b->owner->type == bp_catch_throw)
1548 && breakpoint_enabled (b->owner)
1552 val = target_remove_breakpoint (b->address, b->shadow_contents);
1555 b->inserted = (is == mark_inserted);
1557 else if (ep_is_exception_catchpoint (b->owner)
1558 && b->inserted /* sometimes previous insert doesn't happen */
1559 && breakpoint_enabled (b->owner)
1563 val = target_remove_breakpoint (b->address, b->shadow_contents);
1567 b->inserted = (is == mark_inserted);
1573 /* Clear the "inserted" flag in all breakpoints. */
1576 mark_breakpoints_out (void)
1578 struct bp_location *bpt;
1580 ALL_BP_LOCATIONS (bpt)
1584 /* Clear the "inserted" flag in all breakpoints and delete any
1585 breakpoints which should go away between runs of the program.
1587 Plus other such housekeeping that has to be done for breakpoints
1590 Note: this function gets called at the end of a run (by
1591 generic_mourn_inferior) and when a run begins (by
1592 init_wait_for_inferior). */
1597 breakpoint_init_inferior (enum inf_context context)
1599 struct breakpoint *b, *temp;
1600 struct bp_location *bpt;
1601 static int warning_needed = 0;
1603 ALL_BP_LOCATIONS (bpt)
1606 ALL_BREAKPOINTS_SAFE (b, temp)
1611 case bp_watchpoint_scope:
1613 /* If the call dummy breakpoint is at the entry point it will
1614 cause problems when the inferior is rerun, so we better
1617 Also get rid of scope breakpoints. */
1618 delete_breakpoint (b);
1622 case bp_hardware_watchpoint:
1623 case bp_read_watchpoint:
1624 case bp_access_watchpoint:
1626 /* Likewise for watchpoints on local expressions. */
1627 if (b->exp_valid_block != NULL)
1628 delete_breakpoint (b);
1629 if (context == inf_starting)
1631 /* Reset val field to force reread of starting value
1632 in insert_breakpoints. */
1634 value_free (b->val);
1639 /* Likewise for exception catchpoints in dynamic-linked
1640 executables where required */
1641 if (ep_is_exception_catchpoint (b) &&
1642 exception_catchpoints_are_fragile)
1645 delete_breakpoint (b);
1651 if (exception_catchpoints_are_fragile)
1652 exception_support_initialized = 0;
1654 /* Don't issue the warning unless it's really needed... */
1655 if (warning_needed && (context != inf_exited))
1657 warning ("Exception catchpoints from last run were deleted.");
1658 warning ("You must reinsert them explicitly.");
1663 /* breakpoint_here_p (PC) returns non-zero if an enabled breakpoint
1664 exists at PC. It returns ordinary_breakpoint_here if it's an
1665 ordinary breakpoint, or permanent_breakpoint_here if it's a
1666 permanent breakpoint.
1667 - When continuing from a location with an ordinary breakpoint, we
1668 actually single step once before calling insert_breakpoints.
1669 - When continuing from a localion with a permanent breakpoint, we
1670 need to use the `SKIP_PERMANENT_BREAKPOINT' macro, provided by
1671 the target, to advance the PC past the breakpoint. */
1673 enum breakpoint_here
1674 breakpoint_here_p (CORE_ADDR pc)
1676 struct bp_location *bpt;
1677 int any_breakpoint_here = 0;
1679 ALL_BP_LOCATIONS (bpt)
1681 if (bpt->loc_type != bp_loc_software_breakpoint
1682 && bpt->loc_type != bp_loc_hardware_breakpoint)
1685 if ((breakpoint_enabled (bpt->owner)
1686 || bpt->owner->enable_state == bp_permanent)
1687 && bpt->address == pc) /* bp is enabled and matches pc */
1689 if (overlay_debugging
1690 && section_is_overlay (bpt->section)
1691 && !section_is_mapped (bpt->section))
1692 continue; /* unmapped overlay -- can't be a match */
1693 else if (bpt->owner->enable_state == bp_permanent)
1694 return permanent_breakpoint_here;
1696 any_breakpoint_here = 1;
1700 return any_breakpoint_here ? ordinary_breakpoint_here : 0;
1704 /* breakpoint_inserted_here_p (PC) is just like breakpoint_here_p(),
1705 but it only returns true if there is actually a breakpoint inserted
1709 breakpoint_inserted_here_p (CORE_ADDR pc)
1711 struct bp_location *bpt;
1713 ALL_BP_LOCATIONS (bpt)
1715 if (bpt->loc_type != bp_loc_software_breakpoint
1716 && bpt->loc_type != bp_loc_hardware_breakpoint)
1720 && bpt->address == pc) /* bp is inserted and matches pc */
1722 if (overlay_debugging
1723 && section_is_overlay (bpt->section)
1724 && !section_is_mapped (bpt->section))
1725 continue; /* unmapped overlay -- can't be a match */
1734 /* Return nonzero if FRAME is a dummy frame. We can't use
1735 DEPRECATED_PC_IN_CALL_DUMMY because figuring out the saved SP would
1736 take too much time, at least using frame_register() on the 68k.
1737 This means that for this function to work right a port must use the
1738 bp_call_dummy breakpoint. */
1741 deprecated_frame_in_dummy (struct frame_info *frame)
1743 struct breakpoint *b;
1745 /* This function is used by two files: get_frame_type(), after first
1746 checking that !DEPRECATED_USE_GENERIC_DUMMY_FRAMES; and
1747 sparc-tdep.c, which doesn't yet use generic dummy frames anyway. */
1748 gdb_assert (!DEPRECATED_USE_GENERIC_DUMMY_FRAMES);
1752 if (b->type == bp_call_dummy
1753 && frame_id_eq (b->frame_id, get_frame_id (frame))
1754 /* We need to check the PC as well as the frame on the sparc,
1755 for signals.exp in the testsuite. */
1756 && (get_frame_pc (frame)
1758 - DEPRECATED_SIZEOF_CALL_DUMMY_WORDS / sizeof (LONGEST) * DEPRECATED_REGISTER_SIZE))
1759 && get_frame_pc (frame) <= b->loc->address)
1765 /* breakpoint_thread_match (PC, PTID) returns true if the breakpoint at
1766 PC is valid for process/thread PTID. */
1769 breakpoint_thread_match (CORE_ADDR pc, ptid_t ptid)
1771 struct bp_location *bpt;
1774 thread = pid_to_thread_id (ptid);
1776 ALL_BP_LOCATIONS (bpt)
1778 if (bpt->loc_type != bp_loc_software_breakpoint
1779 && bpt->loc_type != bp_loc_hardware_breakpoint)
1782 if ((breakpoint_enabled (bpt->owner)
1783 || bpt->owner->enable_state == bp_permanent)
1784 && bpt->address == pc
1785 && (bpt->owner->thread == -1 || bpt->owner->thread == thread))
1787 if (overlay_debugging
1788 && section_is_overlay (bpt->section)
1789 && !section_is_mapped (bpt->section))
1790 continue; /* unmapped overlay -- can't be a match */
1800 /* bpstat stuff. External routines' interfaces are documented
1804 ep_is_catchpoint (struct breakpoint *ep)
1807 (ep->type == bp_catch_load)
1808 || (ep->type == bp_catch_unload)
1809 || (ep->type == bp_catch_fork)
1810 || (ep->type == bp_catch_vfork)
1811 || (ep->type == bp_catch_exec)
1812 || (ep->type == bp_catch_catch)
1813 || (ep->type == bp_catch_throw);
1815 /* ??rehrauer: Add more kinds here, as are implemented... */
1819 ep_is_shlib_catchpoint (struct breakpoint *ep)
1822 (ep->type == bp_catch_load)
1823 || (ep->type == bp_catch_unload);
1827 ep_is_exception_catchpoint (struct breakpoint *ep)
1830 (ep->type == bp_catch_catch)
1831 || (ep->type == bp_catch_throw);
1834 /* Clear a bpstat so that it says we are not at any breakpoint.
1835 Also free any storage that is part of a bpstat. */
1838 bpstat_clear (bpstat *bsp)
1849 if (p->old_val != NULL)
1850 value_free (p->old_val);
1851 free_command_lines (&p->commands);
1858 /* Return a copy of a bpstat. Like "bs1 = bs2" but all storage that
1859 is part of the bpstat is copied as well. */
1862 bpstat_copy (bpstat bs)
1866 bpstat retval = NULL;
1871 for (; bs != NULL; bs = bs->next)
1873 tmp = (bpstat) xmalloc (sizeof (*tmp));
1874 memcpy (tmp, bs, sizeof (*tmp));
1875 if (bs->commands != NULL)
1876 tmp->commands = copy_command_lines (bs->commands);
1877 if (bs->old_val != NULL)
1878 tmp->old_val = value_copy (bs->old_val);
1881 /* This is the first thing in the chain. */
1891 /* Find the bpstat associated with this breakpoint */
1894 bpstat_find_breakpoint (bpstat bsp, struct breakpoint *breakpoint)
1899 for (; bsp != NULL; bsp = bsp->next)
1901 if (bsp->breakpoint_at == breakpoint)
1907 /* Find a step_resume breakpoint associated with this bpstat.
1908 (If there are multiple step_resume bp's on the list, this function
1909 will arbitrarily pick one.)
1911 It is an error to use this function if BPSTAT doesn't contain a
1912 step_resume breakpoint.
1914 See wait_for_inferior's use of this function. */
1916 bpstat_find_step_resume_breakpoint (bpstat bsp)
1921 error ("Internal error (bpstat_find_step_resume_breakpoint)");
1923 current_thread = pid_to_thread_id (inferior_ptid);
1925 for (; bsp != NULL; bsp = bsp->next)
1927 if ((bsp->breakpoint_at != NULL) &&
1928 (bsp->breakpoint_at->type == bp_step_resume) &&
1929 (bsp->breakpoint_at->thread == current_thread ||
1930 bsp->breakpoint_at->thread == -1))
1931 return bsp->breakpoint_at;
1934 error ("Internal error (no step_resume breakpoint found)");
1938 /* Return the breakpoint number of the first breakpoint we are stopped
1939 at. *BSP upon return is a bpstat which points to the remaining
1940 breakpoints stopped at (but which is not guaranteed to be good for
1941 anything but further calls to bpstat_num).
1942 Return 0 if passed a bpstat which does not indicate any breakpoints. */
1945 bpstat_num (bpstat *bsp)
1947 struct breakpoint *b;
1950 return 0; /* No more breakpoint values */
1953 b = (*bsp)->breakpoint_at;
1954 *bsp = (*bsp)->next;
1956 return -1; /* breakpoint that's been deleted since */
1958 return b->number; /* We have its number */
1962 /* Modify BS so that the actions will not be performed. */
1965 bpstat_clear_actions (bpstat bs)
1967 for (; bs != NULL; bs = bs->next)
1969 free_command_lines (&bs->commands);
1970 if (bs->old_val != NULL)
1972 value_free (bs->old_val);
1978 /* Stub for cleaning up our state if we error-out of a breakpoint command */
1980 cleanup_executing_breakpoints (void *ignore)
1982 executing_breakpoint_commands = 0;
1985 /* Execute all the commands associated with all the breakpoints at this
1986 location. Any of these commands could cause the process to proceed
1987 beyond this point, etc. We look out for such changes by checking
1988 the global "breakpoint_proceeded" after each command. */
1991 bpstat_do_actions (bpstat *bsp)
1994 struct cleanup *old_chain;
1995 struct command_line *cmd;
1997 /* Avoid endless recursion if a `source' command is contained
1999 if (executing_breakpoint_commands)
2002 executing_breakpoint_commands = 1;
2003 old_chain = make_cleanup (cleanup_executing_breakpoints, 0);
2006 /* Note that (as of this writing), our callers all appear to
2007 be passing us the address of global stop_bpstat. And, if
2008 our calls to execute_control_command cause the inferior to
2009 proceed, that global (and hence, *bsp) will change.
2011 We must be careful to not touch *bsp unless the inferior
2012 has not proceeded. */
2014 /* This pointer will iterate over the list of bpstat's. */
2017 breakpoint_proceeded = 0;
2018 for (; bs != NULL; bs = bs->next)
2023 execute_control_command (cmd);
2025 if (breakpoint_proceeded)
2030 if (breakpoint_proceeded)
2031 /* The inferior is proceeded by the command; bomb out now.
2032 The bpstat chain has been blown away by wait_for_inferior.
2033 But since execution has stopped again, there is a new bpstat
2034 to look at, so start over. */
2037 free_command_lines (&bs->commands);
2039 do_cleanups (old_chain);
2042 /* This is the normal print function for a bpstat. In the future,
2043 much of this logic could (should?) be moved to bpstat_stop_status,
2044 by having it set different print_it values.
2046 Current scheme: When we stop, bpstat_print() is called. It loops
2047 through the bpstat list of things causing this stop, calling the
2048 print_bp_stop_message function on each one. The behavior of the
2049 print_bp_stop_message function depends on the print_it field of
2050 bpstat. If such field so indicates, call this function here.
2052 Return values from this routine (ultimately used by bpstat_print()
2053 and normal_stop() to decide what to do):
2054 PRINT_NOTHING: Means we already printed all we needed to print,
2055 don't print anything else.
2056 PRINT_SRC_ONLY: Means we printed something, and we do *not* desire
2057 that something to be followed by a location.
2058 PRINT_SCR_AND_LOC: Means we printed something, and we *do* desire
2059 that something to be followed by a location.
2060 PRINT_UNKNOWN: Means we printed nothing or we need to do some more
2063 static enum print_stop_action
2064 print_it_typical (bpstat bs)
2066 struct cleanup *old_chain, *ui_out_chain;
2067 struct ui_stream *stb;
2068 stb = ui_out_stream_new (uiout);
2069 old_chain = make_cleanup_ui_out_stream_delete (stb);
2070 /* bs->breakpoint_at can be NULL if it was a momentary breakpoint
2071 which has since been deleted. */
2072 if (bs->breakpoint_at == NULL)
2073 return PRINT_UNKNOWN;
2075 switch (bs->breakpoint_at->type)
2078 case bp_hardware_breakpoint:
2079 if (bs->breakpoint_at->loc->address != bs->breakpoint_at->loc->requested_address)
2080 breakpoint_adjustment_warning (bs->breakpoint_at->loc->requested_address,
2081 bs->breakpoint_at->loc->address,
2082 bs->breakpoint_at->number, 1);
2083 annotate_breakpoint (bs->breakpoint_at->number);
2084 ui_out_text (uiout, "\nBreakpoint ");
2085 if (ui_out_is_mi_like_p (uiout))
2086 ui_out_field_string (uiout, "reason", "breakpoint-hit");
2087 ui_out_field_int (uiout, "bkptno", bs->breakpoint_at->number);
2088 ui_out_text (uiout, ", ");
2089 return PRINT_SRC_AND_LOC;
2092 case bp_shlib_event:
2093 /* Did we stop because the user set the stop_on_solib_events
2094 variable? (If so, we report this as a generic, "Stopped due
2095 to shlib event" message.) */
2096 printf_filtered ("Stopped due to shared library event\n");
2097 return PRINT_NOTHING;
2100 case bp_thread_event:
2101 /* Not sure how we will get here.
2102 GDB should not stop for these breakpoints. */
2103 printf_filtered ("Thread Event Breakpoint: gdb should not stop!\n");
2104 return PRINT_NOTHING;
2107 case bp_overlay_event:
2108 /* By analogy with the thread event, GDB should not stop for these. */
2109 printf_filtered ("Overlay Event Breakpoint: gdb should not stop!\n");
2110 return PRINT_NOTHING;
2114 annotate_catchpoint (bs->breakpoint_at->number);
2115 printf_filtered ("\nCatchpoint %d (", bs->breakpoint_at->number);
2116 printf_filtered ("loaded");
2117 printf_filtered (" %s), ", bs->breakpoint_at->triggered_dll_pathname);
2118 return PRINT_SRC_AND_LOC;
2121 case bp_catch_unload:
2122 annotate_catchpoint (bs->breakpoint_at->number);
2123 printf_filtered ("\nCatchpoint %d (", bs->breakpoint_at->number);
2124 printf_filtered ("unloaded");
2125 printf_filtered (" %s), ", bs->breakpoint_at->triggered_dll_pathname);
2126 return PRINT_SRC_AND_LOC;
2130 annotate_catchpoint (bs->breakpoint_at->number);
2131 printf_filtered ("\nCatchpoint %d (", bs->breakpoint_at->number);
2132 printf_filtered ("forked");
2133 printf_filtered (" process %d), ",
2134 bs->breakpoint_at->forked_inferior_pid);
2135 return PRINT_SRC_AND_LOC;
2138 case bp_catch_vfork:
2139 annotate_catchpoint (bs->breakpoint_at->number);
2140 printf_filtered ("\nCatchpoint %d (", bs->breakpoint_at->number);
2141 printf_filtered ("vforked");
2142 printf_filtered (" process %d), ",
2143 bs->breakpoint_at->forked_inferior_pid);
2144 return PRINT_SRC_AND_LOC;
2148 annotate_catchpoint (bs->breakpoint_at->number);
2149 printf_filtered ("\nCatchpoint %d (exec'd %s), ",
2150 bs->breakpoint_at->number,
2151 bs->breakpoint_at->exec_pathname);
2152 return PRINT_SRC_AND_LOC;
2155 case bp_catch_catch:
2156 if (current_exception_event &&
2157 (CURRENT_EXCEPTION_KIND == EX_EVENT_CATCH))
2159 annotate_catchpoint (bs->breakpoint_at->number);
2160 printf_filtered ("\nCatchpoint %d (exception caught), ",
2161 bs->breakpoint_at->number);
2162 printf_filtered ("throw location ");
2163 if (CURRENT_EXCEPTION_THROW_PC && CURRENT_EXCEPTION_THROW_LINE)
2164 printf_filtered ("%s:%d",
2165 CURRENT_EXCEPTION_THROW_FILE,
2166 CURRENT_EXCEPTION_THROW_LINE);
2168 printf_filtered ("unknown");
2170 printf_filtered (", catch location ");
2171 if (CURRENT_EXCEPTION_CATCH_PC && CURRENT_EXCEPTION_CATCH_LINE)
2172 printf_filtered ("%s:%d",
2173 CURRENT_EXCEPTION_CATCH_FILE,
2174 CURRENT_EXCEPTION_CATCH_LINE);
2176 printf_filtered ("unknown");
2178 printf_filtered ("\n");
2179 /* don't bother to print location frame info */
2180 return PRINT_SRC_ONLY;
2184 /* really throw, some other bpstat will handle it */
2185 return PRINT_UNKNOWN;
2189 case bp_catch_throw:
2190 if (current_exception_event &&
2191 (CURRENT_EXCEPTION_KIND == EX_EVENT_THROW))
2193 annotate_catchpoint (bs->breakpoint_at->number);
2194 printf_filtered ("\nCatchpoint %d (exception thrown), ",
2195 bs->breakpoint_at->number);
2196 printf_filtered ("throw location ");
2197 if (CURRENT_EXCEPTION_THROW_PC && CURRENT_EXCEPTION_THROW_LINE)
2198 printf_filtered ("%s:%d",
2199 CURRENT_EXCEPTION_THROW_FILE,
2200 CURRENT_EXCEPTION_THROW_LINE);
2202 printf_filtered ("unknown");
2204 printf_filtered (", catch location ");
2205 if (CURRENT_EXCEPTION_CATCH_PC && CURRENT_EXCEPTION_CATCH_LINE)
2206 printf_filtered ("%s:%d",
2207 CURRENT_EXCEPTION_CATCH_FILE,
2208 CURRENT_EXCEPTION_CATCH_LINE);
2210 printf_filtered ("unknown");
2212 printf_filtered ("\n");
2213 /* don't bother to print location frame info */
2214 return PRINT_SRC_ONLY;
2218 /* really catch, some other bpstat will handle it */
2219 return PRINT_UNKNOWN;
2224 case bp_hardware_watchpoint:
2225 if (bs->old_val != NULL)
2227 annotate_watchpoint (bs->breakpoint_at->number);
2228 if (ui_out_is_mi_like_p (uiout))
2229 ui_out_field_string (uiout, "reason", "watchpoint-trigger");
2230 mention (bs->breakpoint_at);
2231 ui_out_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "value");
2232 ui_out_text (uiout, "\nOld value = ");
2233 value_print (bs->old_val, stb->stream, 0, Val_pretty_default);
2234 ui_out_field_stream (uiout, "old", stb);
2235 ui_out_text (uiout, "\nNew value = ");
2236 value_print (bs->breakpoint_at->val, stb->stream, 0, Val_pretty_default);
2237 ui_out_field_stream (uiout, "new", stb);
2238 do_cleanups (ui_out_chain);
2239 ui_out_text (uiout, "\n");
2240 value_free (bs->old_val);
2243 /* More than one watchpoint may have been triggered. */
2244 return PRINT_UNKNOWN;
2247 case bp_read_watchpoint:
2248 if (ui_out_is_mi_like_p (uiout))
2249 ui_out_field_string (uiout, "reason", "read-watchpoint-trigger");
2250 mention (bs->breakpoint_at);
2251 ui_out_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "value");
2252 ui_out_text (uiout, "\nValue = ");
2253 value_print (bs->breakpoint_at->val, stb->stream, 0, Val_pretty_default);
2254 ui_out_field_stream (uiout, "value", stb);
2255 do_cleanups (ui_out_chain);
2256 ui_out_text (uiout, "\n");
2257 return PRINT_UNKNOWN;
2260 case bp_access_watchpoint:
2261 if (bs->old_val != NULL)
2263 annotate_watchpoint (bs->breakpoint_at->number);
2264 if (ui_out_is_mi_like_p (uiout))
2265 ui_out_field_string (uiout, "reason", "access-watchpoint-trigger");
2266 mention (bs->breakpoint_at);
2267 ui_out_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "value");
2268 ui_out_text (uiout, "\nOld value = ");
2269 value_print (bs->old_val, stb->stream, 0, Val_pretty_default);
2270 ui_out_field_stream (uiout, "old", stb);
2271 value_free (bs->old_val);
2273 ui_out_text (uiout, "\nNew value = ");
2277 mention (bs->breakpoint_at);
2278 if (ui_out_is_mi_like_p (uiout))
2279 ui_out_field_string (uiout, "reason", "access-watchpoint-trigger");
2280 ui_out_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "value");
2281 ui_out_text (uiout, "\nValue = ");
2283 value_print (bs->breakpoint_at->val, stb->stream, 0,Val_pretty_default);
2284 ui_out_field_stream (uiout, "new", stb);
2285 do_cleanups (ui_out_chain);
2286 ui_out_text (uiout, "\n");
2287 return PRINT_UNKNOWN;
2290 /* Fall through, we don't deal with these types of breakpoints
2294 if (ui_out_is_mi_like_p (uiout))
2295 ui_out_field_string (uiout, "reason", "function-finished");
2296 return PRINT_UNKNOWN;
2300 if (ui_out_is_mi_like_p (uiout))
2301 ui_out_field_string (uiout, "reason", "location-reached");
2302 return PRINT_UNKNOWN;
2307 case bp_longjmp_resume:
2308 case bp_step_resume:
2309 case bp_through_sigtramp:
2310 case bp_watchpoint_scope:
2313 return PRINT_UNKNOWN;
2317 /* Generic routine for printing messages indicating why we
2318 stopped. The behavior of this function depends on the value
2319 'print_it' in the bpstat structure. Under some circumstances we
2320 may decide not to print anything here and delegate the task to
2323 static enum print_stop_action
2324 print_bp_stop_message (bpstat bs)
2326 switch (bs->print_it)
2329 /* Nothing should be printed for this bpstat entry. */
2330 return PRINT_UNKNOWN;
2334 /* We still want to print the frame, but we already printed the
2335 relevant messages. */
2336 return PRINT_SRC_AND_LOC;
2339 case print_it_normal:
2340 /* Normal case. Call the breakpoint's print_it method, or
2341 print_it_typical. */
2342 if (bs->breakpoint_at != NULL && bs->breakpoint_at->ops != NULL
2343 && bs->breakpoint_at->ops->print_it != NULL)
2344 return bs->breakpoint_at->ops->print_it (bs->breakpoint_at);
2346 return print_it_typical (bs);
2350 internal_error (__FILE__, __LINE__,
2351 "print_bp_stop_message: unrecognized enum value");
2356 /* Print a message indicating what happened. This is called from
2357 normal_stop(). The input to this routine is the head of the bpstat
2358 list - a list of the eventpoints that caused this stop. This
2359 routine calls the generic print routine for printing a message
2360 about reasons for stopping. This will print (for example) the
2361 "Breakpoint n," part of the output. The return value of this
2364 PRINT_UNKNOWN: Means we printed nothing
2365 PRINT_SRC_AND_LOC: Means we printed something, and expect subsequent
2366 code to print the location. An example is
2367 "Breakpoint 1, " which should be followed by
2369 PRINT_SRC_ONLY: Means we printed something, but there is no need
2370 to also print the location part of the message.
2371 An example is the catch/throw messages, which
2372 don't require a location appended to the end.
2373 PRINT_NOTHING: We have done some printing and we don't need any
2374 further info to be printed.*/
2376 enum print_stop_action
2377 bpstat_print (bpstat bs)
2381 /* Maybe another breakpoint in the chain caused us to stop.
2382 (Currently all watchpoints go on the bpstat whether hit or not.
2383 That probably could (should) be changed, provided care is taken
2384 with respect to bpstat_explains_signal). */
2385 for (; bs; bs = bs->next)
2387 val = print_bp_stop_message (bs);
2388 if (val == PRINT_SRC_ONLY
2389 || val == PRINT_SRC_AND_LOC
2390 || val == PRINT_NOTHING)
2394 /* We reached the end of the chain, or we got a null BS to start
2395 with and nothing was printed. */
2396 return PRINT_UNKNOWN;
2399 /* Evaluate the expression EXP and return 1 if value is zero.
2400 This is used inside a catch_errors to evaluate the breakpoint condition.
2401 The argument is a "struct expression *" that has been cast to char * to
2402 make it pass through catch_errors. */
2405 breakpoint_cond_eval (void *exp)
2407 struct value *mark = value_mark ();
2408 int i = !value_true (evaluate_expression ((struct expression *) exp));
2409 value_free_to_mark (mark);
2413 /* Allocate a new bpstat and chain it to the current one. */
2416 bpstat_alloc (struct breakpoint *b, bpstat cbs /* Current "bs" value */ )
2420 bs = (bpstat) xmalloc (sizeof (*bs));
2422 bs->breakpoint_at = b;
2423 /* If the condition is false, etc., don't do the commands. */
2424 bs->commands = NULL;
2426 bs->print_it = print_it_normal;
2430 /* Possible return values for watchpoint_check (this can't be an enum
2431 because of check_errors). */
2432 /* The watchpoint has been deleted. */
2433 #define WP_DELETED 1
2434 /* The value has changed. */
2435 #define WP_VALUE_CHANGED 2
2436 /* The value has not changed. */
2437 #define WP_VALUE_NOT_CHANGED 3
2439 #define BP_TEMPFLAG 1
2440 #define BP_HARDWAREFLAG 2
2442 /* Check watchpoint condition. */
2445 watchpoint_check (void *p)
2447 bpstat bs = (bpstat) p;
2448 struct breakpoint *b;
2449 struct frame_info *fr;
2450 int within_current_scope;
2452 struct frame_id current_frame_id;
2455 b = bs->breakpoint_at;
2457 if (b->exp_valid_block == NULL)
2458 within_current_scope = 1;
2461 /* There is no current frame at this moment. If we're going to have
2462 any chance of handling watchpoints on local variables, we'll need
2463 the frame chain (so we can determine if we're in scope). */
2464 reinit_frame_cache ();
2465 fr = frame_find_by_id (b->watchpoint_frame);
2466 within_current_scope = (fr != NULL);
2467 /* in_function_epilogue_p() returns a non-zero value if we're still
2468 in the function but the stack frame has already been invalidated.
2469 Since we can't rely on the values of local variables after the
2470 stack has been destroyed, we are treating the watchpoint in that
2471 state as `not changed' without further checking.
2473 vinschen/2003-09-04: The former implementation left out the case
2474 that the watchpoint frame couldn't be found by frame_find_by_id()
2475 because the current PC is currently in an epilogue. Calling
2476 gdbarch_in_function_epilogue_p() also when fr == NULL fixes that. */
2477 if ((!within_current_scope || fr == get_current_frame ())
2478 && gdbarch_in_function_epilogue_p (current_gdbarch, read_pc ()))
2479 return WP_VALUE_NOT_CHANGED;
2480 if (fr && within_current_scope)
2481 /* If we end up stopping, the current frame will get selected
2482 in normal_stop. So this call to select_frame won't affect
2487 if (within_current_scope)
2489 /* We use value_{,free_to_}mark because it could be a
2490 *long* time before we return to the command level and
2491 call free_all_values. We can't call free_all_values because
2492 we might be in the middle of evaluating a function call. */
2494 struct value *mark = value_mark ();
2495 struct value *new_val = evaluate_expression (bs->breakpoint_at->exp);
2496 if (!value_equal (b->val, new_val))
2498 release_value (new_val);
2499 value_free_to_mark (mark);
2500 bs->old_val = b->val;
2502 /* We will stop here */
2503 return WP_VALUE_CHANGED;
2507 /* Nothing changed, don't do anything. */
2508 value_free_to_mark (mark);
2509 /* We won't stop here */
2510 return WP_VALUE_NOT_CHANGED;
2515 /* This seems like the only logical thing to do because
2516 if we temporarily ignored the watchpoint, then when
2517 we reenter the block in which it is valid it contains
2518 garbage (in the case of a function, it may have two
2519 garbage values, one before and one after the prologue).
2520 So we can't even detect the first assignment to it and
2521 watch after that (since the garbage may or may not equal
2522 the first value assigned). */
2523 /* We print all the stop information in print_it_typical(), but
2524 in this case, by the time we call print_it_typical() this bp
2525 will be deleted already. So we have no choice but print the
2526 information here. */
2527 if (ui_out_is_mi_like_p (uiout))
2528 ui_out_field_string (uiout, "reason", "watchpoint-scope");
2529 ui_out_text (uiout, "\nWatchpoint ");
2530 ui_out_field_int (uiout, "wpnum", bs->breakpoint_at->number);
2531 ui_out_text (uiout, " deleted because the program has left the block in\n\
2532 which its expression is valid.\n");
2534 if (b->related_breakpoint)
2535 b->related_breakpoint->disposition = disp_del_at_next_stop;
2536 b->disposition = disp_del_at_next_stop;
2542 /* Get a bpstat associated with having just stopped at address *PC
2543 and frame address CORE_ADDRESS. Update *PC to point at the
2544 breakpoint (if we hit a breakpoint). NOT_A_SW_BREAKPOINT is nonzero
2545 if this is known to not be a real breakpoint (it could still be a
2546 watchpoint, though). */
2548 /* Determine whether we stopped at a breakpoint, etc, or whether we
2549 don't understand this stop. Result is a chain of bpstat's such that:
2551 if we don't understand the stop, the result is a null pointer.
2553 if we understand why we stopped, the result is not null.
2555 Each element of the chain refers to a particular breakpoint or
2556 watchpoint at which we have stopped. (We may have stopped for
2557 several reasons concurrently.)
2559 Each element of the chain has valid next, breakpoint_at,
2560 commands, FIXME??? fields. */
2563 bpstat_stop_status (CORE_ADDR *pc, int not_a_sw_breakpoint)
2565 struct breakpoint *b, *temp;
2567 /* True if we've hit a breakpoint (as opposed to a watchpoint). */
2568 int real_breakpoint = 0;
2569 /* Root of the chain of bpstat's */
2570 struct bpstats root_bs[1];
2571 /* Pointer to the last thing in the chain currently. */
2572 bpstat bs = root_bs;
2574 /* Get the address where the breakpoint would have been. The
2575 "not_a_sw_breakpoint" argument is meant to distinguish between a
2576 breakpoint trap event and a trace/singlestep trap event. For a
2577 trace/singlestep trap event, we would not want to subtract
2578 DECR_PC_AFTER_BREAK from the PC. */
2580 bp_addr = *pc - (not_a_sw_breakpoint ? 0 : DECR_PC_AFTER_BREAK);
2582 ALL_BREAKPOINTS_SAFE (b, temp)
2584 if (!breakpoint_enabled (b) && b->enable_state != bp_permanent)
2587 if (b->type != bp_watchpoint
2588 && b->type != bp_hardware_watchpoint
2589 && b->type != bp_read_watchpoint
2590 && b->type != bp_access_watchpoint
2591 && b->type != bp_hardware_breakpoint
2592 && b->type != bp_catch_fork
2593 && b->type != bp_catch_vfork
2594 && b->type != bp_catch_exec
2595 && b->type != bp_catch_catch
2596 && b->type != bp_catch_throw) /* a non-watchpoint bp */
2598 if (b->loc->address != bp_addr) /* address doesn't match */
2600 if (overlay_debugging /* unmapped overlay section */
2601 && section_is_overlay (b->loc->section)
2602 && !section_is_mapped (b->loc->section))
2606 if (b->type == bp_hardware_breakpoint)
2608 if (b->loc->address != (*pc - DECR_PC_AFTER_HW_BREAK))
2610 if (overlay_debugging /* unmapped overlay section */
2611 && section_is_overlay (b->loc->section)
2612 && !section_is_mapped (b->loc->section))
2616 /* Is this a catchpoint of a load or unload? If so, did we
2617 get a load or unload of the specified library? If not,
2619 if ((b->type == bp_catch_load)
2620 #if defined(SOLIB_HAVE_LOAD_EVENT)
2621 && (!SOLIB_HAVE_LOAD_EVENT (PIDGET (inferior_ptid))
2622 || ((b->dll_pathname != NULL)
2623 && (strcmp (b->dll_pathname,
2624 SOLIB_LOADED_LIBRARY_PATHNAME (
2625 PIDGET (inferior_ptid)))
2631 if ((b->type == bp_catch_unload)
2632 #if defined(SOLIB_HAVE_UNLOAD_EVENT)
2633 && (!SOLIB_HAVE_UNLOAD_EVENT (PIDGET (inferior_ptid))
2634 || ((b->dll_pathname != NULL)
2635 && (strcmp (b->dll_pathname,
2636 SOLIB_UNLOADED_LIBRARY_PATHNAME (
2637 PIDGET (inferior_ptid)))
2643 if ((b->type == bp_catch_fork)
2644 && !inferior_has_forked (PIDGET (inferior_ptid),
2645 &b->forked_inferior_pid))
2648 if ((b->type == bp_catch_vfork)
2649 && !inferior_has_vforked (PIDGET (inferior_ptid),
2650 &b->forked_inferior_pid))
2653 if ((b->type == bp_catch_exec)
2654 && !inferior_has_execd (PIDGET (inferior_ptid), &b->exec_pathname))
2657 if (ep_is_exception_catchpoint (b) &&
2658 !(current_exception_event = target_get_current_exception_event ()))
2661 /* Come here if it's a watchpoint, or if the break address matches */
2663 bs = bpstat_alloc (b, bs); /* Alloc a bpstat to explain stop */
2665 /* Watchpoints may change this, if not found to have triggered. */
2669 if (b->type == bp_watchpoint ||
2670 b->type == bp_hardware_watchpoint)
2672 char *message = xstrprintf ("Error evaluating expression for watchpoint %d\n",
2674 struct cleanup *cleanups = make_cleanup (xfree, message);
2675 int e = catch_errors (watchpoint_check, bs, message,
2677 do_cleanups (cleanups);
2681 /* We've already printed what needs to be printed. */
2682 /* Actually this is superfluous, because by the time we
2683 call print_it_typical() the wp will be already deleted,
2684 and the function will return immediately. */
2685 bs->print_it = print_it_done;
2688 case WP_VALUE_CHANGED:
2692 case WP_VALUE_NOT_CHANGED:
2694 bs->print_it = print_it_noop;
2701 /* Error from catch_errors. */
2702 printf_filtered ("Watchpoint %d deleted.\n", b->number);
2703 if (b->related_breakpoint)
2704 b->related_breakpoint->disposition = disp_del_at_next_stop;
2705 b->disposition = disp_del_at_next_stop;
2706 /* We've already printed what needs to be printed. */
2707 bs->print_it = print_it_done;
2713 else if (b->type == bp_read_watchpoint ||
2714 b->type == bp_access_watchpoint)
2720 addr = target_stopped_data_address ();
2723 for (v = b->val_chain; v; v = v->next)
2725 if (VALUE_LVAL (v) == lval_memory
2726 && ! VALUE_LAZY (v))
2728 struct type *vtype = check_typedef (VALUE_TYPE (v));
2730 if (v == b->val_chain
2731 || (TYPE_CODE (vtype) != TYPE_CODE_STRUCT
2732 && TYPE_CODE (vtype) != TYPE_CODE_ARRAY))
2736 vaddr = VALUE_ADDRESS (v) + VALUE_OFFSET (v);
2737 /* Exact match not required. Within range is
2739 if (addr >= vaddr &&
2740 addr < vaddr + TYPE_LENGTH (VALUE_TYPE (v)))
2747 char *message = xstrprintf ("Error evaluating expression for watchpoint %d\n",
2749 struct cleanup *cleanups = make_cleanup (xfree, message);
2750 int e = catch_errors (watchpoint_check, bs, message,
2752 do_cleanups (cleanups);
2756 /* We've already printed what needs to be printed. */
2757 bs->print_it = print_it_done;
2760 case WP_VALUE_CHANGED:
2761 if (b->type == bp_read_watchpoint)
2763 /* Don't stop: read watchpoints shouldn't fire if
2764 the value has changed. This is for targets
2765 which cannot set read-only watchpoints. */
2766 bs->print_it = print_it_noop;
2772 case WP_VALUE_NOT_CHANGED:
2779 /* Error from catch_errors. */
2780 printf_filtered ("Watchpoint %d deleted.\n", b->number);
2781 if (b->related_breakpoint)
2782 b->related_breakpoint->disposition = disp_del_at_next_stop;
2783 b->disposition = disp_del_at_next_stop;
2784 /* We've already printed what needs to be printed. */
2785 bs->print_it = print_it_done;
2789 else /* found == 0 */
2791 /* This is a case where some watchpoint(s) triggered,
2792 but not at the address of this watchpoint (FOUND
2793 was left zero). So don't print anything for this
2795 bs->print_it = print_it_noop;
2802 /* By definition, an encountered breakpoint is a triggered
2806 real_breakpoint = 1;
2809 if (frame_id_p (b->frame_id)
2810 && !frame_id_eq (b->frame_id, get_frame_id (get_current_frame ())))
2814 int value_is_zero = 0;
2818 /* Need to select the frame, with all that implies
2819 so that the conditions will have the right context. */
2820 select_frame (get_current_frame ());
2822 = catch_errors (breakpoint_cond_eval, (b->cond),
2823 "Error in testing breakpoint condition:\n",
2825 /* FIXME-someday, should give breakpoint # */
2828 if (b->cond && value_is_zero)
2831 /* Don't consider this a hit. */
2834 else if (b->ignore_count > 0)
2837 annotate_ignore_count_change ();
2842 /* We will stop here */
2843 if (b->disposition == disp_disable)
2844 b->enable_state = bp_disabled;
2847 bs->commands = b->commands;
2849 (strcmp ("silent", bs->commands->line) == 0
2850 || (xdb_commands && strcmp ("Q", bs->commands->line) == 0)))
2852 bs->commands = bs->commands->next;
2855 bs->commands = copy_command_lines (bs->commands);
2858 /* Print nothing for this entry if we dont stop or if we dont print. */
2859 if (bs->stop == 0 || bs->print == 0)
2860 bs->print_it = print_it_noop;
2863 bs->next = NULL; /* Terminate the chain */
2864 bs = root_bs->next; /* Re-grab the head of the chain */
2866 if (real_breakpoint && bs)
2868 if (bs->breakpoint_at->type == bp_hardware_breakpoint)
2870 if (DECR_PC_AFTER_HW_BREAK != 0)
2872 *pc = *pc - DECR_PC_AFTER_HW_BREAK;
2878 if (DECR_PC_AFTER_BREAK != 0 || must_shift_inst_regs)
2881 #if defined (SHIFT_INST_REGS)
2883 #else /* No SHIFT_INST_REGS. */
2885 #endif /* No SHIFT_INST_REGS. */
2890 /* The value of a hardware watchpoint hasn't changed, but the
2891 intermediate memory locations we are watching may have. */
2892 if (bs && !bs->stop &&
2893 (bs->breakpoint_at->type == bp_hardware_watchpoint ||
2894 bs->breakpoint_at->type == bp_read_watchpoint ||
2895 bs->breakpoint_at->type == bp_access_watchpoint))
2897 remove_breakpoints ();
2898 insert_breakpoints ();
2903 /* Tell what to do about this bpstat. */
2905 bpstat_what (bpstat bs)
2907 /* Classify each bpstat as one of the following. */
2910 /* This bpstat element has no effect on the main_action. */
2913 /* There was a watchpoint, stop but don't print. */
2916 /* There was a watchpoint, stop and print. */
2919 /* There was a breakpoint but we're not stopping. */
2922 /* There was a breakpoint, stop but don't print. */
2925 /* There was a breakpoint, stop and print. */
2928 /* We hit the longjmp breakpoint. */
2931 /* We hit the longjmp_resume breakpoint. */
2934 /* We hit the step_resume breakpoint. */
2937 /* We hit the through_sigtramp breakpoint. */
2940 /* We hit the shared library event breakpoint. */
2943 /* We caught a shared library event. */
2946 /* This is just used to count how many enums there are. */
2950 /* Here is the table which drives this routine. So that we can
2951 format it pretty, we define some abbreviations for the
2952 enum bpstat_what codes. */
2953 #define kc BPSTAT_WHAT_KEEP_CHECKING
2954 #define ss BPSTAT_WHAT_STOP_SILENT
2955 #define sn BPSTAT_WHAT_STOP_NOISY
2956 #define sgl BPSTAT_WHAT_SINGLE
2957 #define slr BPSTAT_WHAT_SET_LONGJMP_RESUME
2958 #define clr BPSTAT_WHAT_CLEAR_LONGJMP_RESUME
2959 #define clrs BPSTAT_WHAT_CLEAR_LONGJMP_RESUME_SINGLE
2960 #define sr BPSTAT_WHAT_STEP_RESUME
2961 #define ts BPSTAT_WHAT_THROUGH_SIGTRAMP
2962 #define shl BPSTAT_WHAT_CHECK_SHLIBS
2963 #define shlr BPSTAT_WHAT_CHECK_SHLIBS_RESUME_FROM_HOOK
2965 /* "Can't happen." Might want to print an error message.
2966 abort() is not out of the question, but chances are GDB is just
2967 a bit confused, not unusable. */
2968 #define err BPSTAT_WHAT_STOP_NOISY
2970 /* Given an old action and a class, come up with a new action. */
2971 /* One interesting property of this table is that wp_silent is the same
2972 as bp_silent and wp_noisy is the same as bp_noisy. That is because
2973 after stopping, the check for whether to step over a breakpoint
2974 (BPSTAT_WHAT_SINGLE type stuff) is handled in proceed() without
2975 reference to how we stopped. We retain separate wp_silent and
2976 bp_silent codes in case we want to change that someday.
2978 Another possibly interesting property of this table is that
2979 there's a partial ordering, priority-like, of the actions. Once
2980 you've decided that some action is appropriate, you'll never go
2981 back and decide something of a lower priority is better. The
2984 kc < clr sgl shl shlr slr sn sr ss ts
2985 sgl < clrs shl shlr slr sn sr ss ts
2986 slr < err shl shlr sn sr ss ts
2987 clr < clrs err shl shlr sn sr ss ts
2988 clrs < err shl shlr sn sr ss ts
2989 ss < shl shlr sn sr ts
2996 What I think this means is that we don't need a damned table
2997 here. If you just put the rows and columns in the right order,
2998 it'd look awfully regular. We could simply walk the bpstat list
2999 and choose the highest priority action we find, with a little
3000 logic to handle the 'err' cases, and the CLEAR_LONGJMP_RESUME/
3001 CLEAR_LONGJMP_RESUME_SINGLE distinction (which breakpoint.h says
3002 is messy anyway). */
3004 /* step_resume entries: a step resume breakpoint overrides another
3005 breakpoint of signal handling (see comment in wait_for_inferior
3006 at first PC_IN_SIGTRAMP where we set the step_resume breakpoint). */
3007 /* We handle the through_sigtramp_breakpoint the same way; having both
3008 one of those and a step_resume_breakpoint is probably very rare (?). */
3010 static const enum bpstat_what_main_action
3011 table[(int) class_last][(int) BPSTAT_WHAT_LAST] =
3014 /* kc ss sn sgl slr clr clrs sr ts shl shlr
3017 {kc, ss, sn, sgl, slr, clr, clrs, sr, ts, shl, shlr},
3019 {ss, ss, sn, ss, ss, ss, ss, sr, ts, shl, shlr},
3021 {sn, sn, sn, sn, sn, sn, sn, sr, ts, shl, shlr},
3023 {sgl, ss, sn, sgl, slr, clrs, clrs, sr, ts, shl, shlr},
3025 {ss, ss, sn, ss, ss, ss, ss, sr, ts, shl, shlr},
3027 {sn, sn, sn, sn, sn, sn, sn, sr, ts, shl, shlr},
3029 {slr, ss, sn, slr, slr, err, err, sr, ts, shl, shlr},
3031 {clr, ss, sn, clrs, err, err, err, sr, ts, shl, shlr},
3033 {sr, sr, sr, sr, sr, sr, sr, sr, ts, shl, shlr},
3035 {ts, ts, ts, ts, ts, ts, ts, ts, ts, shl, shlr},
3037 {shl, shl, shl, shl, shl, shl, shl, shl, ts, shl, shlr},
3039 {shlr, shlr, shlr, shlr, shlr, shlr, shlr, shlr, ts, shlr, shlr}
3054 enum bpstat_what_main_action current_action = BPSTAT_WHAT_KEEP_CHECKING;
3055 struct bpstat_what retval;
3057 retval.call_dummy = 0;
3058 for (; bs != NULL; bs = bs->next)
3060 enum class bs_class = no_effect;
3061 if (bs->breakpoint_at == NULL)
3062 /* I suspect this can happen if it was a momentary breakpoint
3063 which has since been deleted. */
3065 switch (bs->breakpoint_at->type)
3071 case bp_hardware_breakpoint:
3077 bs_class = bp_noisy;
3079 bs_class = bp_silent;
3082 bs_class = bp_nostop;
3085 case bp_hardware_watchpoint:
3086 case bp_read_watchpoint:
3087 case bp_access_watchpoint:
3091 bs_class = wp_noisy;
3093 bs_class = wp_silent;
3096 /* There was a watchpoint, but we're not stopping.
3097 This requires no further action. */
3098 bs_class = no_effect;
3101 bs_class = long_jump;
3103 case bp_longjmp_resume:
3104 bs_class = long_resume;
3106 case bp_step_resume:
3109 bs_class = step_resume;
3112 /* It is for the wrong frame. */
3113 bs_class = bp_nostop;
3115 case bp_through_sigtramp:
3116 bs_class = through_sig;
3118 case bp_watchpoint_scope:
3119 bs_class = bp_nostop;
3121 case bp_shlib_event:
3122 bs_class = shlib_event;
3124 case bp_thread_event:
3125 case bp_overlay_event:
3126 bs_class = bp_nostop;
3129 case bp_catch_unload:
3130 /* Only if this catchpoint triggered should we cause the
3131 step-out-of-dld behaviour. Otherwise, we ignore this
3134 bs_class = catch_shlib_event;
3136 bs_class = no_effect;
3139 case bp_catch_vfork:
3144 bs_class = bp_noisy;
3146 bs_class = bp_silent;
3149 /* There was a catchpoint, but we're not stopping.
3150 This requires no further action. */
3151 bs_class = no_effect;
3153 case bp_catch_catch:
3154 if (!bs->stop || CURRENT_EXCEPTION_KIND != EX_EVENT_CATCH)
3155 bs_class = bp_nostop;
3157 bs_class = bs->print ? bp_noisy : bp_silent;
3159 case bp_catch_throw:
3160 if (!bs->stop || CURRENT_EXCEPTION_KIND != EX_EVENT_THROW)
3161 bs_class = bp_nostop;
3163 bs_class = bs->print ? bp_noisy : bp_silent;
3166 /* Make sure the action is stop (silent or noisy),
3167 so infrun.c pops the dummy frame. */
3168 bs_class = bp_silent;
3169 retval.call_dummy = 1;
3172 current_action = table[(int) bs_class][(int) current_action];
3174 retval.main_action = current_action;
3178 /* Nonzero if we should step constantly (e.g. watchpoints on machines
3179 without hardware support). This isn't related to a specific bpstat,
3180 just to things like whether watchpoints are set. */
3183 bpstat_should_step (void)
3185 struct breakpoint *b;
3187 if (breakpoint_enabled (b) && b->type == bp_watchpoint)
3192 /* Nonzero if there are enabled hardware watchpoints. */
3194 bpstat_have_active_hw_watchpoints (void)
3196 struct bp_location *bpt;
3197 ALL_BP_LOCATIONS (bpt)
3198 if (breakpoint_enabled (bpt->owner)
3200 && bpt->loc_type == bp_loc_hardware_watchpoint)
3206 /* Given a bpstat that records zero or more triggered eventpoints, this
3207 function returns another bpstat which contains only the catchpoints
3208 on that first list, if any. */
3210 bpstat_get_triggered_catchpoints (bpstat ep_list, bpstat *cp_list)
3212 struct bpstats root_bs[1];
3213 bpstat bs = root_bs;
3214 struct breakpoint *ep;
3217 bpstat_clear (cp_list);
3218 root_bs->next = NULL;
3220 for (; ep_list != NULL; ep_list = ep_list->next)
3222 /* Is this eventpoint a catchpoint? If not, ignore it. */
3223 ep = ep_list->breakpoint_at;
3226 if ((ep->type != bp_catch_load) &&
3227 (ep->type != bp_catch_unload) &&
3228 (ep->type != bp_catch_catch) &&
3229 (ep->type != bp_catch_throw))
3230 /* pai: (temp) ADD fork/vfork here!! */
3233 /* Yes; add it to the list. */
3234 bs = bpstat_alloc (ep, bs);
3239 #if defined(SOLIB_ADD)
3240 /* Also, for each triggered catchpoint, tag it with the name of
3241 the library that caused this trigger. (We copy the name now,
3242 because it's only guaranteed to be available NOW, when the
3243 catchpoint triggers. Clients who may wish to know the name
3244 later must get it from the catchpoint itself.) */
3245 if (ep->triggered_dll_pathname != NULL)
3246 xfree (ep->triggered_dll_pathname);
3247 if (ep->type == bp_catch_load)
3248 dll_pathname = SOLIB_LOADED_LIBRARY_PATHNAME (
3249 PIDGET (inferior_ptid));
3251 dll_pathname = SOLIB_UNLOADED_LIBRARY_PATHNAME (
3252 PIDGET (inferior_ptid));
3254 dll_pathname = NULL;
3258 ep->triggered_dll_pathname = (char *)
3259 xmalloc (strlen (dll_pathname) + 1);
3260 strcpy (ep->triggered_dll_pathname, dll_pathname);
3263 ep->triggered_dll_pathname = NULL;
3269 /* Print B to gdb_stdout. */
3271 print_one_breakpoint (struct breakpoint *b,
3272 CORE_ADDR *last_addr)
3274 struct command_line *l;
3276 struct ep_type_description
3281 static struct ep_type_description bptypes[] =
3283 {bp_none, "?deleted?"},
3284 {bp_breakpoint, "breakpoint"},
3285 {bp_hardware_breakpoint, "hw breakpoint"},
3286 {bp_until, "until"},
3287 {bp_finish, "finish"},
3288 {bp_watchpoint, "watchpoint"},
3289 {bp_hardware_watchpoint, "hw watchpoint"},
3290 {bp_read_watchpoint, "read watchpoint"},
3291 {bp_access_watchpoint, "acc watchpoint"},
3292 {bp_longjmp, "longjmp"},
3293 {bp_longjmp_resume, "longjmp resume"},
3294 {bp_step_resume, "step resume"},
3295 {bp_through_sigtramp, "sigtramp"},
3296 {bp_watchpoint_scope, "watchpoint scope"},
3297 {bp_call_dummy, "call dummy"},
3298 {bp_shlib_event, "shlib events"},
3299 {bp_thread_event, "thread events"},
3300 {bp_overlay_event, "overlay events"},
3301 {bp_catch_load, "catch load"},
3302 {bp_catch_unload, "catch unload"},
3303 {bp_catch_fork, "catch fork"},
3304 {bp_catch_vfork, "catch vfork"},
3305 {bp_catch_exec, "catch exec"},
3306 {bp_catch_catch, "catch catch"},
3307 {bp_catch_throw, "catch throw"}
3310 static char *bpdisps[] =
3311 {"del", "dstp", "dis", "keep"};
3312 static char bpenables[] = "nynny";
3313 char wrap_indent[80];
3314 struct ui_stream *stb = ui_out_stream_new (uiout);
3315 struct cleanup *old_chain = make_cleanup_ui_out_stream_delete (stb);
3316 struct cleanup *bkpt_chain;
3319 bkpt_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "bkpt");
3323 ui_out_field_int (uiout, "number", b->number);
3327 if (((int) b->type > (sizeof (bptypes) / sizeof (bptypes[0])))
3328 || ((int) b->type != bptypes[(int) b->type].type))
3329 internal_error (__FILE__, __LINE__,
3330 "bptypes table does not describe type #%d.",
3332 ui_out_field_string (uiout, "type", bptypes[(int) b->type].description);
3336 ui_out_field_string (uiout, "disp", bpdisps[(int) b->disposition]);
3340 ui_out_field_fmt (uiout, "enabled", "%c", bpenables[(int) b->enable_state]);
3341 ui_out_spaces (uiout, 2);
3344 strcpy (wrap_indent, " ");
3347 if (TARGET_ADDR_BIT <= 32)
3348 strcat (wrap_indent, " ");
3350 strcat (wrap_indent, " ");
3353 if (b->ops != NULL && b->ops->print_one != NULL)
3354 b->ops->print_one (b, last_addr);
3359 internal_error (__FILE__, __LINE__,
3360 "print_one_breakpoint: bp_none encountered\n");
3364 case bp_hardware_watchpoint:
3365 case bp_read_watchpoint:
3366 case bp_access_watchpoint:
3367 /* Field 4, the address, is omitted (which makes the columns
3368 not line up too nicely with the headers, but the effect
3369 is relatively readable). */
3371 ui_out_field_skip (uiout, "addr");
3373 print_expression (b->exp, stb->stream);
3374 ui_out_field_stream (uiout, "what", stb);
3378 case bp_catch_unload:
3379 /* Field 4, the address, is omitted (which makes the columns
3380 not line up too nicely with the headers, but the effect
3381 is relatively readable). */
3383 ui_out_field_skip (uiout, "addr");
3385 if (b->dll_pathname == NULL)
3387 ui_out_field_string (uiout, "what", "<any library>");
3388 ui_out_spaces (uiout, 1);
3392 ui_out_text (uiout, "library \"");
3393 ui_out_field_string (uiout, "what", b->dll_pathname);
3394 ui_out_text (uiout, "\" ");
3399 case bp_catch_vfork:
3400 /* Field 4, the address, is omitted (which makes the columns
3401 not line up too nicely with the headers, but the effect
3402 is relatively readable). */
3404 ui_out_field_skip (uiout, "addr");
3406 if (b->forked_inferior_pid != 0)
3408 ui_out_text (uiout, "process ");
3409 ui_out_field_int (uiout, "what", b->forked_inferior_pid);
3410 ui_out_spaces (uiout, 1);
3414 /* Field 4, the address, is omitted (which makes the columns
3415 not line up too nicely with the headers, but the effect
3416 is relatively readable). */
3418 ui_out_field_skip (uiout, "addr");
3420 if (b->exec_pathname != NULL)
3422 ui_out_text (uiout, "program \"");
3423 ui_out_field_string (uiout, "what", b->exec_pathname);
3424 ui_out_text (uiout, "\" ");
3428 case bp_catch_catch:
3429 /* Field 4, the address, is omitted (which makes the columns
3430 not line up too nicely with the headers, but the effect
3431 is relatively readable). */
3433 ui_out_field_skip (uiout, "addr");
3435 ui_out_field_string (uiout, "what", "exception catch");
3436 ui_out_spaces (uiout, 1);
3439 case bp_catch_throw:
3440 /* Field 4, the address, is omitted (which makes the columns
3441 not line up too nicely with the headers, but the effect
3442 is relatively readable). */
3444 ui_out_field_skip (uiout, "addr");
3446 ui_out_field_string (uiout, "what", "exception throw");
3447 ui_out_spaces (uiout, 1);
3451 case bp_hardware_breakpoint:
3455 case bp_longjmp_resume:
3456 case bp_step_resume:
3457 case bp_through_sigtramp:
3458 case bp_watchpoint_scope:
3460 case bp_shlib_event:
3461 case bp_thread_event:
3462 case bp_overlay_event:
3466 ui_out_field_core_addr (uiout, "addr", b->loc->address);
3469 *last_addr = b->loc->address;
3472 sym = find_pc_sect_function (b->loc->address, b->loc->section);
3475 ui_out_text (uiout, "in ");
3476 ui_out_field_string (uiout, "func",
3477 SYMBOL_PRINT_NAME (sym));
3478 ui_out_wrap_hint (uiout, wrap_indent);
3479 ui_out_text (uiout, " at ");
3481 ui_out_field_string (uiout, "file", b->source_file);
3482 ui_out_text (uiout, ":");
3483 ui_out_field_int (uiout, "line", b->line_number);
3487 print_address_symbolic (b->loc->address, stb->stream, demangle, "");
3488 ui_out_field_stream (uiout, "at", stb);
3493 if (b->thread != -1)
3495 /* FIXME: This seems to be redundant and lost here; see the
3496 "stop only in" line a little further down. */
3497 ui_out_text (uiout, " thread ");
3498 ui_out_field_int (uiout, "thread", b->thread);
3501 ui_out_text (uiout, "\n");
3503 if (frame_id_p (b->frame_id))
3506 ui_out_text (uiout, "\tstop only in stack frame at ");
3507 /* FIXME: cagney/2002-12-01: Shouldn't be poeking around inside
3509 ui_out_field_core_addr (uiout, "frame", b->frame_id.stack_addr);
3510 ui_out_text (uiout, "\n");
3516 ui_out_text (uiout, "\tstop only if ");
3517 print_expression (b->cond, stb->stream);
3518 ui_out_field_stream (uiout, "cond", stb);
3519 ui_out_text (uiout, "\n");
3522 if (b->thread != -1)
3524 /* FIXME should make an annotation for this */
3525 ui_out_text (uiout, "\tstop only in thread ");
3526 ui_out_field_int (uiout, "thread", b->thread);
3527 ui_out_text (uiout, "\n");
3530 if (show_breakpoint_hit_counts && b->hit_count)
3532 /* FIXME should make an annotation for this */
3533 if (ep_is_catchpoint (b))
3534 ui_out_text (uiout, "\tcatchpoint");
3536 ui_out_text (uiout, "\tbreakpoint");
3537 ui_out_text (uiout, " already hit ");
3538 ui_out_field_int (uiout, "times", b->hit_count);
3539 if (b->hit_count == 1)
3540 ui_out_text (uiout, " time\n");
3542 ui_out_text (uiout, " times\n");
3545 /* Output the count also if it is zero, but only if this is
3546 mi. FIXME: Should have a better test for this. */
3547 if (ui_out_is_mi_like_p (uiout))
3548 if (show_breakpoint_hit_counts && b->hit_count == 0)
3549 ui_out_field_int (uiout, "times", b->hit_count);
3551 if (b->ignore_count)
3554 ui_out_text (uiout, "\tignore next ");
3555 ui_out_field_int (uiout, "ignore", b->ignore_count);
3556 ui_out_text (uiout, " hits\n");
3559 if ((l = b->commands))
3561 struct cleanup *script_chain;
3564 script_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "script");
3565 print_command_lines (uiout, l, 4);
3566 do_cleanups (script_chain);
3568 do_cleanups (bkpt_chain);
3569 do_cleanups (old_chain);
3572 struct captured_breakpoint_query_args
3578 do_captured_breakpoint_query (struct ui_out *uiout, void *data)
3580 struct captured_breakpoint_query_args *args = data;
3581 struct breakpoint *b;
3582 CORE_ADDR dummy_addr = 0;
3585 if (args->bnum == b->number)
3587 print_one_breakpoint (b, &dummy_addr);
3595 gdb_breakpoint_query (struct ui_out *uiout, int bnum)
3597 struct captured_breakpoint_query_args args;
3599 /* For the moment we don't trust print_one_breakpoint() to not throw
3601 return catch_exceptions (uiout, do_captured_breakpoint_query, &args,
3602 NULL, RETURN_MASK_ALL);
3605 /* Return non-zero if B is user settable (breakpoints, watchpoints,
3606 catchpoints, et.al.). */
3609 user_settable_breakpoint (const struct breakpoint *b)
3611 return (b->type == bp_breakpoint
3612 || b->type == bp_catch_load
3613 || b->type == bp_catch_unload
3614 || b->type == bp_catch_fork
3615 || b->type == bp_catch_vfork
3616 || b->type == bp_catch_exec
3617 || b->type == bp_catch_catch
3618 || b->type == bp_catch_throw
3619 || b->type == bp_hardware_breakpoint
3620 || b->type == bp_watchpoint
3621 || b->type == bp_read_watchpoint
3622 || b->type == bp_access_watchpoint
3623 || b->type == bp_hardware_watchpoint);
3626 /* Print information on user settable breakpoint (watchpoint, etc)
3627 number BNUM. If BNUM is -1 print all user settable breakpoints.
3628 If ALLFLAG is non-zero, include non- user settable breakpoints. */
3631 breakpoint_1 (int bnum, int allflag)
3633 struct breakpoint *b;
3634 CORE_ADDR last_addr = (CORE_ADDR) -1;
3635 int nr_printable_breakpoints;
3636 struct cleanup *bkpttbl_chain;
3638 /* Compute the number of rows in the table. */
3639 nr_printable_breakpoints = 0;
3642 || bnum == b->number)
3644 if (allflag || user_settable_breakpoint (b))
3645 nr_printable_breakpoints++;
3650 = make_cleanup_ui_out_table_begin_end (uiout, 6, nr_printable_breakpoints,
3654 = make_cleanup_ui_out_table_begin_end (uiout, 5, nr_printable_breakpoints,
3657 if (nr_printable_breakpoints > 0)
3658 annotate_breakpoints_headers ();
3659 if (nr_printable_breakpoints > 0)
3661 ui_out_table_header (uiout, 3, ui_left, "number", "Num"); /* 1 */
3662 if (nr_printable_breakpoints > 0)
3664 ui_out_table_header (uiout, 14, ui_left, "type", "Type"); /* 2 */
3665 if (nr_printable_breakpoints > 0)
3667 ui_out_table_header (uiout, 4, ui_left, "disp", "Disp"); /* 3 */
3668 if (nr_printable_breakpoints > 0)
3670 ui_out_table_header (uiout, 3, ui_left, "enabled", "Enb"); /* 4 */
3673 if (nr_printable_breakpoints > 0)
3675 if (TARGET_ADDR_BIT <= 32)
3676 ui_out_table_header (uiout, 10, ui_left, "addr", "Address");/* 5 */
3678 ui_out_table_header (uiout, 18, ui_left, "addr", "Address");/* 5 */
3680 if (nr_printable_breakpoints > 0)
3682 ui_out_table_header (uiout, 40, ui_noalign, "what", "What"); /* 6 */
3683 ui_out_table_body (uiout);
3684 if (nr_printable_breakpoints > 0)
3685 annotate_breakpoints_table ();
3689 || bnum == b->number)
3691 /* We only print out user settable breakpoints unless the
3693 if (allflag || user_settable_breakpoint (b))
3694 print_one_breakpoint (b, &last_addr);
3697 do_cleanups (bkpttbl_chain);
3699 if (nr_printable_breakpoints == 0)
3702 ui_out_message (uiout, 0, "No breakpoints or watchpoints.\n");
3704 ui_out_message (uiout, 0, "No breakpoint or watchpoint number %d.\n",
3709 /* Compare against (CORE_ADDR)-1 in case some compiler decides
3710 that a comparison of an unsigned with -1 is always false. */
3711 if (last_addr != (CORE_ADDR) -1)
3712 set_next_address (last_addr);
3715 /* FIXME? Should this be moved up so that it is only called when
3716 there have been breakpoints? */
3717 annotate_breakpoints_table_end ();
3721 breakpoints_info (char *bnum_exp, int from_tty)
3726 bnum = parse_and_eval_long (bnum_exp);
3728 breakpoint_1 (bnum, 0);
3732 maintenance_info_breakpoints (char *bnum_exp, int from_tty)
3737 bnum = parse_and_eval_long (bnum_exp);
3739 breakpoint_1 (bnum, 1);
3742 /* Print a message describing any breakpoints set at PC. */
3745 describe_other_breakpoints (CORE_ADDR pc, asection *section)
3748 struct breakpoint *b;
3751 if (b->loc->address == pc) /* address match / overlay match */
3752 if (!overlay_debugging || b->loc->section == section)
3756 printf_filtered ("Note: breakpoint%s ", (others > 1) ? "s" : "");
3758 if (b->loc->address == pc) /* address match / overlay match */
3759 if (!overlay_debugging || b->loc->section == section)
3762 printf_filtered ("%d%s%s ",
3764 ((b->enable_state == bp_disabled ||
3765 b->enable_state == bp_shlib_disabled ||
3766 b->enable_state == bp_call_disabled)
3768 : b->enable_state == bp_permanent
3772 : ((others == 1) ? " and" : ""));
3774 printf_filtered ("also set at pc ");
3775 print_address_numeric (pc, 1, gdb_stdout);
3776 printf_filtered (".\n");
3780 /* Set the default place to put a breakpoint
3781 for the `break' command with no arguments. */
3784 set_default_breakpoint (int valid, CORE_ADDR addr, struct symtab *symtab,
3787 default_breakpoint_valid = valid;
3788 default_breakpoint_address = addr;
3789 default_breakpoint_symtab = symtab;
3790 default_breakpoint_line = line;
3793 /* Return true iff it is meaningful to use the address member of
3794 BPT. For some breakpoint types, the address member is irrelevant
3795 and it makes no sense to attempt to compare it to other addresses
3796 (or use it for any other purpose either).
3798 More specifically, each of the following breakpoint types will always
3799 have a zero valued address and we don't want check_duplicates() to mark
3800 breakpoints of any of these types to be a duplicate of an actual
3801 breakpoint at address zero:
3804 bp_hardware_watchpoint
3806 bp_access_watchpoint
3813 breakpoint_address_is_meaningful (struct breakpoint *bpt)
3815 enum bptype type = bpt->type;
3817 return (type != bp_watchpoint
3818 && type != bp_hardware_watchpoint
3819 && type != bp_read_watchpoint
3820 && type != bp_access_watchpoint
3821 && type != bp_catch_exec
3822 && type != bp_longjmp_resume
3823 && type != bp_catch_fork
3824 && type != bp_catch_vfork);
3827 /* Rescan breakpoints at the same address and section as BPT,
3828 marking the first one as "first" and any others as "duplicates".
3829 This is so that the bpt instruction is only inserted once.
3830 If we have a permanent breakpoint at the same place as BPT, make
3831 that one the official one, and the rest as duplicates. */
3834 check_duplicates (struct breakpoint *bpt)
3836 struct bp_location *b;
3838 struct bp_location *perm_bp = 0;
3839 CORE_ADDR address = bpt->loc->address;
3840 asection *section = bpt->loc->section;
3842 if (! breakpoint_address_is_meaningful (bpt))
3845 ALL_BP_LOCATIONS (b)
3846 if (b->owner->enable_state != bp_disabled
3847 && b->owner->enable_state != bp_shlib_disabled
3848 && b->owner->enable_state != bp_call_disabled
3849 && b->address == address /* address / overlay match */
3850 && (!overlay_debugging || b->section == section)
3851 && breakpoint_address_is_meaningful (b->owner))
3853 /* Have we found a permanent breakpoint? */
3854 if (b->owner->enable_state == bp_permanent)
3861 b->duplicate = count > 1;
3864 /* If we found a permanent breakpoint at this address, go over the
3865 list again and declare all the other breakpoints there to be the
3869 perm_bp->duplicate = 0;
3871 /* Permanent breakpoint should always be inserted. */
3872 if (! perm_bp->inserted)
3873 internal_error (__FILE__, __LINE__,
3874 "allegedly permanent breakpoint is not "
3875 "actually inserted");
3877 ALL_BP_LOCATIONS (b)
3880 if (b->owner->enable_state != bp_disabled
3881 && b->owner->enable_state != bp_shlib_disabled
3882 && b->owner->enable_state != bp_call_disabled
3883 && b->address == address /* address / overlay match */
3884 && (!overlay_debugging || b->section == section)
3885 && breakpoint_address_is_meaningful (b->owner))
3888 internal_error (__FILE__, __LINE__,
3889 "another breakpoint was inserted on top of "
3890 "a permanent breakpoint");
3899 breakpoint_adjustment_warning (CORE_ADDR from_addr, CORE_ADDR to_addr,
3900 int bnum, int have_bnum)
3905 strcpy (astr1, local_hex_string_custom ((unsigned long) from_addr, "08l"));
3906 strcpy (astr2, local_hex_string_custom ((unsigned long) to_addr, "08l"));
3908 warning ("Breakpoint %d address previously adjusted from %s to %s.",
3909 bnum, astr1, astr2);
3911 warning ("Breakpoint address adjusted from %s to %s.", astr1, astr2);
3914 /* Adjust a breakpoint's address to account for architectural constraints
3915 on breakpoint placement. Return the adjusted address. Note: Very
3916 few targets require this kind of adjustment. For most targets,
3917 this function is simply the identity function. */
3920 adjust_breakpoint_address (CORE_ADDR bpaddr)
3922 if (!gdbarch_adjust_breakpoint_address_p (current_gdbarch))
3924 /* Very few targets need any kind of breakpoint adjustment. */
3929 CORE_ADDR adjusted_bpaddr;
3931 /* Some targets have architectural constraints on the placement
3932 of breakpoint instructions. Obtain the adjusted address. */
3933 adjusted_bpaddr = gdbarch_adjust_breakpoint_address (current_gdbarch,
3936 /* An adjusted breakpoint address can significantly alter
3937 a user's expectations. Print a warning if an adjustment
3939 if (adjusted_bpaddr != bpaddr)
3940 breakpoint_adjustment_warning (bpaddr, adjusted_bpaddr, 0, 0);
3942 return adjusted_bpaddr;
3946 /* Allocate a struct bp_location. */
3948 static struct bp_location *
3949 allocate_bp_location (struct breakpoint *bpt, enum bptype bp_type)
3951 struct bp_location *loc, *loc_p;
3953 loc = xmalloc (sizeof (struct bp_location));
3954 memset (loc, 0, sizeof (*loc));
3964 case bp_longjmp_resume:
3965 case bp_step_resume:
3966 case bp_through_sigtramp:
3967 case bp_watchpoint_scope:
3969 case bp_shlib_event:
3970 case bp_thread_event:
3971 case bp_overlay_event:
3973 case bp_catch_unload:
3974 loc->loc_type = bp_loc_software_breakpoint;
3976 case bp_hardware_breakpoint:
3977 loc->loc_type = bp_loc_hardware_breakpoint;
3979 case bp_hardware_watchpoint:
3980 case bp_read_watchpoint:
3981 case bp_access_watchpoint:
3982 loc->loc_type = bp_loc_hardware_watchpoint;
3986 case bp_catch_vfork:
3988 case bp_catch_catch:
3989 case bp_catch_throw:
3990 loc->loc_type = bp_loc_other;
3993 internal_error (__FILE__, __LINE__, "unknown breakpoint type");
3996 /* Add this breakpoint to the end of the chain. */
3998 loc_p = bp_location_chain;
4000 bp_location_chain = loc;
4004 loc_p = loc_p->next;
4011 /* set_raw_breakpoint() is a low level routine for allocating and
4012 partially initializing a breakpoint of type BPTYPE. The newly
4013 created breakpoint's address, section, source file name, and line
4014 number are provided by SAL. The newly created and partially
4015 initialized breakpoint is added to the breakpoint chain and
4016 is also returned as the value of this function.
4018 It is expected that the caller will complete the initialization of
4019 the newly created breakpoint struct as well as output any status
4020 information regarding the creation of a new breakpoint. In
4021 particular, set_raw_breakpoint() does NOT set the breakpoint
4022 number! Care should be taken to not allow an error() to occur
4023 prior to completing the initialization of the breakpoint. If this
4024 should happen, a bogus breakpoint will be left on the chain. */
4027 set_raw_breakpoint (struct symtab_and_line sal, enum bptype bptype)
4029 struct breakpoint *b, *b1;
4031 b = (struct breakpoint *) xmalloc (sizeof (struct breakpoint));
4032 memset (b, 0, sizeof (*b));
4033 b->loc = allocate_bp_location (b, bptype);
4034 b->loc->requested_address = sal.pc;
4035 b->loc->address = adjust_breakpoint_address (b->loc->requested_address);
4036 if (sal.symtab == NULL)
4037 b->source_file = NULL;
4039 b->source_file = savestring (sal.symtab->filename,
4040 strlen (sal.symtab->filename));
4041 b->loc->section = sal.section;
4043 b->language = current_language->la_language;
4044 b->input_radix = input_radix;
4046 b->line_number = sal.line;
4047 b->enable_state = bp_enabled;
4050 b->ignore_count = 0;
4052 b->frame_id = null_frame_id;
4053 b->dll_pathname = NULL;
4054 b->triggered_dll_pathname = NULL;
4055 b->forked_inferior_pid = 0;
4056 b->exec_pathname = NULL;
4059 /* Add this breakpoint to the end of the chain
4060 so that a list of breakpoints will come out in order
4061 of increasing numbers. */
4063 b1 = breakpoint_chain;
4065 breakpoint_chain = b;
4073 check_duplicates (b);
4074 breakpoints_changed ();
4080 /* Note that the breakpoint object B describes a permanent breakpoint
4081 instruction, hard-wired into the inferior's code. */
4083 make_breakpoint_permanent (struct breakpoint *b)
4085 b->enable_state = bp_permanent;
4087 /* By definition, permanent breakpoints are already present in the code. */
4088 b->loc->inserted = 1;
4091 static struct breakpoint *
4092 create_internal_breakpoint (CORE_ADDR address, enum bptype type)
4094 static int internal_breakpoint_number = -1;
4095 struct symtab_and_line sal;
4096 struct breakpoint *b;
4098 init_sal (&sal); /* initialize to zeroes */
4101 sal.section = find_pc_overlay (sal.pc);
4103 b = set_raw_breakpoint (sal, type);
4104 b->number = internal_breakpoint_number--;
4105 b->disposition = disp_donttouch;
4112 create_longjmp_breakpoint (char *func_name)
4114 struct breakpoint *b;
4115 struct minimal_symbol *m;
4117 if (func_name == NULL)
4118 b = create_internal_breakpoint (0, bp_longjmp_resume);
4121 if ((m = lookup_minimal_symbol_text (func_name, NULL)) == NULL)
4124 b = create_internal_breakpoint (SYMBOL_VALUE_ADDRESS (m), bp_longjmp);
4127 b->enable_state = bp_disabled;
4130 b->addr_string = xstrdup (func_name);
4133 /* Call this routine when stepping and nexting to enable a breakpoint
4134 if we do a longjmp(). When we hit that breakpoint, call
4135 set_longjmp_resume_breakpoint() to figure out where we are going. */
4138 enable_longjmp_breakpoint (void)
4140 struct breakpoint *b;
4143 if (b->type == bp_longjmp)
4145 b->enable_state = bp_enabled;
4146 check_duplicates (b);
4151 disable_longjmp_breakpoint (void)
4153 struct breakpoint *b;
4156 if (b->type == bp_longjmp
4157 || b->type == bp_longjmp_resume)
4159 b->enable_state = bp_disabled;
4160 check_duplicates (b);
4165 create_overlay_event_breakpoint (char *func_name)
4167 struct breakpoint *b;
4168 struct minimal_symbol *m;
4170 if ((m = lookup_minimal_symbol_text (func_name, NULL)) == NULL)
4173 b = create_internal_breakpoint (SYMBOL_VALUE_ADDRESS (m),
4175 b->addr_string = xstrdup (func_name);
4177 if (overlay_debugging == ovly_auto)
4179 b->enable_state = bp_enabled;
4180 overlay_events_enabled = 1;
4184 b->enable_state = bp_disabled;
4185 overlay_events_enabled = 0;
4190 enable_overlay_breakpoints (void)
4192 struct breakpoint *b;
4195 if (b->type == bp_overlay_event)
4197 b->enable_state = bp_enabled;
4198 check_duplicates (b);
4199 overlay_events_enabled = 1;
4204 disable_overlay_breakpoints (void)
4206 struct breakpoint *b;
4209 if (b->type == bp_overlay_event)
4211 b->enable_state = bp_disabled;
4212 check_duplicates (b);
4213 overlay_events_enabled = 0;
4218 create_thread_event_breakpoint (CORE_ADDR address)
4220 struct breakpoint *b;
4222 b = create_internal_breakpoint (address, bp_thread_event);
4224 b->enable_state = bp_enabled;
4225 /* addr_string has to be used or breakpoint_re_set will delete me. */
4226 xasprintf (&b->addr_string, "*0x%s", paddr (b->loc->address));
4232 remove_thread_event_breakpoints (void)
4234 struct breakpoint *b, *temp;
4236 ALL_BREAKPOINTS_SAFE (b, temp)
4237 if (b->type == bp_thread_event)
4238 delete_breakpoint (b);
4243 remove_solib_event_breakpoints (void)
4245 struct breakpoint *b, *temp;
4247 ALL_BREAKPOINTS_SAFE (b, temp)
4248 if (b->type == bp_shlib_event)
4249 delete_breakpoint (b);
4253 create_solib_event_breakpoint (CORE_ADDR address)
4255 struct breakpoint *b;
4257 b = create_internal_breakpoint (address, bp_shlib_event);
4261 /* Disable any breakpoints that are on code in shared libraries. Only
4262 apply to enabled breakpoints, disabled ones can just stay disabled. */
4265 disable_breakpoints_in_shlibs (int silent)
4267 struct breakpoint *b;
4268 int disabled_shlib_breaks = 0;
4270 /* See also: insert_breakpoints, under DISABLE_UNSETTABLE_BREAK. */
4273 #if defined (PC_SOLIB)
4274 if (((b->type == bp_breakpoint) ||
4275 (b->type == bp_hardware_breakpoint)) &&
4276 breakpoint_enabled (b) &&
4277 !b->loc->duplicate &&
4278 PC_SOLIB (b->loc->address))
4280 b->enable_state = bp_shlib_disabled;
4283 if (!disabled_shlib_breaks)
4285 target_terminal_ours_for_output ();
4286 warning ("Temporarily disabling shared library breakpoints:");
4288 disabled_shlib_breaks = 1;
4289 warning ("breakpoint #%d ", b->number);
4296 /* Try to reenable any breakpoints in shared libraries. */
4298 re_enable_breakpoints_in_shlibs (void)
4300 struct breakpoint *b;
4303 if (b->enable_state == bp_shlib_disabled)
4307 /* Do not reenable the breakpoint if the shared library
4308 is still not mapped in. */
4309 lib = PC_SOLIB (b->loc->address);
4310 if (lib != NULL && target_read_memory (b->loc->address, buf, 1) == 0)
4311 b->enable_state = bp_enabled;
4318 solib_load_unload_1 (char *hookname, int tempflag, char *dll_pathname,
4319 char *cond_string, enum bptype bp_kind)
4321 struct breakpoint *b;
4322 struct symtabs_and_lines sals;
4323 struct cleanup *old_chain;
4324 struct cleanup *canonical_strings_chain = NULL;
4325 char *addr_start = hookname;
4326 char *addr_end = NULL;
4327 char **canonical = (char **) NULL;
4328 int thread = -1; /* All threads. */
4330 /* Set a breakpoint on the specified hook. */
4331 sals = decode_line_1 (&hookname, 1, (struct symtab *) NULL, 0, &canonical);
4332 addr_end = hookname;
4334 if (sals.nelts == 0)
4336 warning ("Unable to set a breakpoint on dynamic linker callback.");
4337 warning ("Suggest linking with /opt/langtools/lib/end.o.");
4338 warning ("GDB will be unable to track shl_load/shl_unload calls");
4341 if (sals.nelts != 1)
4343 warning ("Unable to set unique breakpoint on dynamic linker callback.");
4344 warning ("GDB will be unable to track shl_load/shl_unload calls");
4348 /* Make sure that all storage allocated in decode_line_1 gets freed
4349 in case the following errors out. */
4350 old_chain = make_cleanup (xfree, sals.sals);
4351 if (canonical != (char **) NULL)
4353 make_cleanup (xfree, canonical);
4354 canonical_strings_chain = make_cleanup (null_cleanup, 0);
4355 if (canonical[0] != NULL)
4356 make_cleanup (xfree, canonical[0]);
4359 resolve_sal_pc (&sals.sals[0]);
4361 /* Remove the canonical strings from the cleanup, they are needed below. */
4362 if (canonical != (char **) NULL)
4363 discard_cleanups (canonical_strings_chain);
4365 b = set_raw_breakpoint (sals.sals[0], bp_kind);
4366 set_breakpoint_count (breakpoint_count + 1);
4367 b->number = breakpoint_count;
4369 b->cond_string = (cond_string == NULL) ?
4370 NULL : savestring (cond_string, strlen (cond_string));
4373 if (canonical != (char **) NULL && canonical[0] != NULL)
4374 b->addr_string = canonical[0];
4375 else if (addr_start)
4376 b->addr_string = savestring (addr_start, addr_end - addr_start);
4378 b->enable_state = bp_enabled;
4379 b->disposition = tempflag ? disp_del : disp_donttouch;
4381 if (dll_pathname == NULL)
4382 b->dll_pathname = NULL;
4385 b->dll_pathname = (char *) xmalloc (strlen (dll_pathname) + 1);
4386 strcpy (b->dll_pathname, dll_pathname);
4390 do_cleanups (old_chain);
4394 create_solib_load_event_breakpoint (char *hookname, int tempflag,
4395 char *dll_pathname, char *cond_string)
4397 solib_load_unload_1 (hookname, tempflag, dll_pathname,
4398 cond_string, bp_catch_load);
4402 create_solib_unload_event_breakpoint (char *hookname, int tempflag,
4403 char *dll_pathname, char *cond_string)
4405 solib_load_unload_1 (hookname,tempflag, dll_pathname,
4406 cond_string, bp_catch_unload);
4410 create_fork_vfork_event_catchpoint (int tempflag, char *cond_string,
4411 enum bptype bp_kind)
4413 struct symtab_and_line sal;
4414 struct breakpoint *b;
4415 int thread = -1; /* All threads. */
4422 b = set_raw_breakpoint (sal, bp_kind);
4423 set_breakpoint_count (breakpoint_count + 1);
4424 b->number = breakpoint_count;
4426 b->cond_string = (cond_string == NULL) ?
4427 NULL : savestring (cond_string, strlen (cond_string));
4429 b->addr_string = NULL;
4430 b->enable_state = bp_enabled;
4431 b->disposition = tempflag ? disp_del : disp_donttouch;
4432 b->forked_inferior_pid = 0;
4438 create_fork_event_catchpoint (int tempflag, char *cond_string)
4440 create_fork_vfork_event_catchpoint (tempflag, cond_string, bp_catch_fork);
4444 create_vfork_event_catchpoint (int tempflag, char *cond_string)
4446 create_fork_vfork_event_catchpoint (tempflag, cond_string, bp_catch_vfork);
4450 create_exec_event_catchpoint (int tempflag, char *cond_string)
4452 struct symtab_and_line sal;
4453 struct breakpoint *b;
4454 int thread = -1; /* All threads. */
4461 b = set_raw_breakpoint (sal, bp_catch_exec);
4462 set_breakpoint_count (breakpoint_count + 1);
4463 b->number = breakpoint_count;
4465 b->cond_string = (cond_string == NULL) ?
4466 NULL : savestring (cond_string, strlen (cond_string));
4468 b->addr_string = NULL;
4469 b->enable_state = bp_enabled;
4470 b->disposition = tempflag ? disp_del : disp_donttouch;
4476 hw_breakpoint_used_count (void)
4478 struct breakpoint *b;
4483 if (b->type == bp_hardware_breakpoint && b->enable_state == bp_enabled)
4491 hw_watchpoint_used_count (enum bptype type, int *other_type_used)
4493 struct breakpoint *b;
4496 *other_type_used = 0;
4499 if (breakpoint_enabled (b))
4501 if (b->type == type)
4503 else if ((b->type == bp_hardware_watchpoint ||
4504 b->type == bp_read_watchpoint ||
4505 b->type == bp_access_watchpoint))
4506 *other_type_used = 1;
4512 /* Call this after hitting the longjmp() breakpoint. Use this to set
4513 a new breakpoint at the target of the jmp_buf.
4515 FIXME - This ought to be done by setting a temporary breakpoint
4516 that gets deleted automatically... */
4519 set_longjmp_resume_breakpoint (CORE_ADDR pc, struct frame_id frame_id)
4521 struct breakpoint *b;
4524 if (b->type == bp_longjmp_resume)
4526 b->loc->requested_address = pc;
4527 b->loc->address = adjust_breakpoint_address (b->loc->requested_address);
4528 b->enable_state = bp_enabled;
4529 b->frame_id = frame_id;
4530 check_duplicates (b);
4536 disable_watchpoints_before_interactive_call_start (void)
4538 struct breakpoint *b;
4542 if (((b->type == bp_watchpoint)
4543 || (b->type == bp_hardware_watchpoint)
4544 || (b->type == bp_read_watchpoint)
4545 || (b->type == bp_access_watchpoint)
4546 || ep_is_exception_catchpoint (b))
4547 && breakpoint_enabled (b))
4549 b->enable_state = bp_call_disabled;
4550 check_duplicates (b);
4556 enable_watchpoints_after_interactive_call_stop (void)
4558 struct breakpoint *b;
4562 if (((b->type == bp_watchpoint)
4563 || (b->type == bp_hardware_watchpoint)
4564 || (b->type == bp_read_watchpoint)
4565 || (b->type == bp_access_watchpoint)
4566 || ep_is_exception_catchpoint (b))
4567 && (b->enable_state == bp_call_disabled))
4569 b->enable_state = bp_enabled;
4570 check_duplicates (b);
4576 /* Set a breakpoint that will evaporate an end of command
4577 at address specified by SAL.
4578 Restrict it to frame FRAME if FRAME is nonzero. */
4581 set_momentary_breakpoint (struct symtab_and_line sal, struct frame_id frame_id,
4584 struct breakpoint *b;
4585 b = set_raw_breakpoint (sal, type);
4586 b->enable_state = bp_enabled;
4587 b->disposition = disp_donttouch;
4588 b->frame_id = frame_id;
4590 /* If we're debugging a multi-threaded program, then we
4591 want momentary breakpoints to be active in only a
4592 single thread of control. */
4593 if (in_thread_list (inferior_ptid))
4594 b->thread = pid_to_thread_id (inferior_ptid);
4600 /* Tell the user we have just set a breakpoint B. */
4603 mention (struct breakpoint *b)
4606 struct cleanup *old_chain, *ui_out_chain;
4607 struct ui_stream *stb;
4609 stb = ui_out_stream_new (uiout);
4610 old_chain = make_cleanup_ui_out_stream_delete (stb);
4612 /* FIXME: This is misplaced; mention() is called by things (like hitting a
4613 watchpoint) other than breakpoint creation. It should be possible to
4614 clean this up and at the same time replace the random calls to
4615 breakpoint_changed with this hook, as has already been done for
4616 delete_breakpoint_hook and so on. */
4617 if (create_breakpoint_hook)
4618 create_breakpoint_hook (b);
4619 breakpoint_create_event (b->number);
4621 if (b->ops != NULL && b->ops->print_mention != NULL)
4622 b->ops->print_mention (b);
4627 printf_filtered ("(apparently deleted?) Eventpoint %d: ", b->number);
4630 ui_out_text (uiout, "Watchpoint ");
4631 ui_out_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "wpt");
4632 ui_out_field_int (uiout, "number", b->number);
4633 ui_out_text (uiout, ": ");
4634 print_expression (b->exp, stb->stream);
4635 ui_out_field_stream (uiout, "exp", stb);
4636 do_cleanups (ui_out_chain);
4638 case bp_hardware_watchpoint:
4639 ui_out_text (uiout, "Hardware watchpoint ");
4640 ui_out_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "wpt");
4641 ui_out_field_int (uiout, "number", b->number);
4642 ui_out_text (uiout, ": ");
4643 print_expression (b->exp, stb->stream);
4644 ui_out_field_stream (uiout, "exp", stb);
4645 do_cleanups (ui_out_chain);
4647 case bp_read_watchpoint:
4648 ui_out_text (uiout, "Hardware read watchpoint ");
4649 ui_out_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "hw-rwpt");
4650 ui_out_field_int (uiout, "number", b->number);
4651 ui_out_text (uiout, ": ");
4652 print_expression (b->exp, stb->stream);
4653 ui_out_field_stream (uiout, "exp", stb);
4654 do_cleanups (ui_out_chain);
4656 case bp_access_watchpoint:
4657 ui_out_text (uiout, "Hardware access (read/write) watchpoint ");
4658 ui_out_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "hw-awpt");
4659 ui_out_field_int (uiout, "number", b->number);
4660 ui_out_text (uiout, ": ");
4661 print_expression (b->exp, stb->stream);
4662 ui_out_field_stream (uiout, "exp", stb);
4663 do_cleanups (ui_out_chain);
4666 if (ui_out_is_mi_like_p (uiout))
4671 printf_filtered ("Breakpoint %d", b->number);
4674 case bp_hardware_breakpoint:
4675 if (ui_out_is_mi_like_p (uiout))
4680 printf_filtered ("Hardware assisted breakpoint %d", b->number);
4684 case bp_catch_unload:
4685 printf_filtered ("Catchpoint %d (%s %s)",
4687 (b->type == bp_catch_load) ? "load" : "unload",
4688 (b->dll_pathname != NULL) ?
4689 b->dll_pathname : "<any library>");
4692 case bp_catch_vfork:
4693 printf_filtered ("Catchpoint %d (%s)",
4695 (b->type == bp_catch_fork) ? "fork" : "vfork");
4698 printf_filtered ("Catchpoint %d (exec)",
4701 case bp_catch_catch:
4702 case bp_catch_throw:
4703 printf_filtered ("Catchpoint %d (%s)",
4705 (b->type == bp_catch_catch) ? "catch" : "throw");
4711 case bp_longjmp_resume:
4712 case bp_step_resume:
4713 case bp_through_sigtramp:
4715 case bp_watchpoint_scope:
4716 case bp_shlib_event:
4717 case bp_thread_event:
4718 case bp_overlay_event:
4724 if (addressprint || b->source_file == NULL)
4726 printf_filtered (" at ");
4727 print_address_numeric (b->loc->address, 1, gdb_stdout);
4730 printf_filtered (": file %s, line %d.",
4731 b->source_file, b->line_number);
4733 do_cleanups (old_chain);
4734 if (ui_out_is_mi_like_p (uiout))
4736 printf_filtered ("\n");
4740 /* Add SALS.nelts breakpoints to the breakpoint table. For each
4741 SALS.sal[i] breakpoint, include the corresponding ADDR_STRING[i],
4742 COND[i] and COND_STRING[i] values.
4744 NOTE: If the function succeeds, the caller is expected to cleanup
4745 the arrays ADDR_STRING, COND_STRING, COND and SALS (but not the
4746 array contents). If the function fails (error() is called), the
4747 caller is expected to cleanups both the ADDR_STRING, COND_STRING,
4748 COND and SALS arrays and each of those arrays contents. */
4751 create_breakpoints (struct symtabs_and_lines sals, char **addr_string,
4752 struct expression **cond, char **cond_string,
4753 enum bptype type, enum bpdisp disposition,
4754 int thread, int ignore_count, int from_tty)
4756 if (type == bp_hardware_breakpoint)
4758 int i = hw_breakpoint_used_count ();
4759 int target_resources_ok =
4760 TARGET_CAN_USE_HARDWARE_WATCHPOINT (bp_hardware_breakpoint,
4762 if (target_resources_ok == 0)
4763 error ("No hardware breakpoint support in the target.");
4764 else if (target_resources_ok < 0)
4765 error ("Hardware breakpoints used exceeds limit.");
4768 /* Now set all the breakpoints. */
4771 for (i = 0; i < sals.nelts; i++)
4773 struct breakpoint *b;
4774 struct symtab_and_line sal = sals.sals[i];
4777 describe_other_breakpoints (sal.pc, sal.section);
4779 b = set_raw_breakpoint (sal, type);
4780 set_breakpoint_count (breakpoint_count + 1);
4781 b->number = breakpoint_count;
4785 b->addr_string = addr_string[i];
4787 /* addr_string has to be used or breakpoint_re_set will delete
4789 xasprintf (&b->addr_string, "*0x%s", paddr (b->loc->address));
4790 b->cond_string = cond_string[i];
4791 b->ignore_count = ignore_count;
4792 b->enable_state = bp_enabled;
4793 b->disposition = disposition;
4799 /* Parse ARG which is assumed to be a SAL specification possibly
4800 followed by conditionals. On return, SALS contains an array of SAL
4801 addresses found. ADDR_STRING contains a vector of (canonical)
4802 address strings. ARG points to the end of the SAL. */
4805 parse_breakpoint_sals (char **address,
4806 struct symtabs_and_lines *sals,
4807 char ***addr_string)
4809 char *addr_start = *address;
4810 *addr_string = NULL;
4811 /* If no arg given, or if first arg is 'if ', use the default
4813 if ((*address) == NULL
4814 || (strncmp ((*address), "if", 2) == 0 && isspace ((*address)[2])))
4816 if (default_breakpoint_valid)
4818 struct symtab_and_line sal;
4819 init_sal (&sal); /* initialize to zeroes */
4820 sals->sals = (struct symtab_and_line *)
4821 xmalloc (sizeof (struct symtab_and_line));
4822 sal.pc = default_breakpoint_address;
4823 sal.line = default_breakpoint_line;
4824 sal.symtab = default_breakpoint_symtab;
4825 sal.section = find_pc_overlay (sal.pc);
4826 sals->sals[0] = sal;
4830 error ("No default breakpoint address now.");
4834 /* Force almost all breakpoints to be in terms of the
4835 current_source_symtab (which is decode_line_1's default). This
4836 should produce the results we want almost all of the time while
4837 leaving default_breakpoint_* alone.
4838 ObjC: However, don't match an Objective-C method name which
4839 may have a '+' or '-' succeeded by a '[' */
4841 struct symtab_and_line cursal = get_current_source_symtab_and_line ();
4843 if (default_breakpoint_valid
4845 || ((strchr ("+-", (*address)[0]) != NULL)
4846 && ((*address)[1] != '['))))
4847 *sals = decode_line_1 (address, 1, default_breakpoint_symtab,
4848 default_breakpoint_line, addr_string);
4850 *sals = decode_line_1 (address, 1, (struct symtab *) NULL, 0, addr_string);
4852 /* For any SAL that didn't have a canonical string, fill one in. */
4853 if (sals->nelts > 0 && *addr_string == NULL)
4854 *addr_string = xcalloc (sals->nelts, sizeof (char **));
4855 if (addr_start != (*address))
4858 for (i = 0; i < sals->nelts; i++)
4860 /* Add the string if not present. */
4861 if ((*addr_string)[i] == NULL)
4862 (*addr_string)[i] = savestring (addr_start, (*address) - addr_start);
4868 /* Convert each SAL into a real PC. Verify that the PC can be
4869 inserted as a breakpoint. If it can't throw an error. */
4872 breakpoint_sals_to_pc (struct symtabs_and_lines *sals,
4876 for (i = 0; i < sals->nelts; i++)
4878 resolve_sal_pc (&sals->sals[i]);
4880 /* It's possible for the PC to be nonzero, but still an illegal
4881 value on some targets.
4883 For example, on HP-UX if you start gdb, and before running the
4884 inferior you try to set a breakpoint on a shared library function
4885 "foo" where the inferior doesn't call "foo" directly but does
4886 pass its address to another function call, then we do find a
4887 minimal symbol for the "foo", but it's address is invalid.
4888 (Appears to be an index into a table that the loader sets up
4889 when the inferior is run.)
4891 Give the target a chance to bless sals.sals[i].pc before we
4892 try to make a breakpoint for it. */
4893 if (PC_REQUIRES_RUN_BEFORE_USE (sals->sals[i].pc))
4895 if (address == NULL)
4896 error ("Cannot break without a running program.");
4898 error ("Cannot break on %s without a running program.",
4904 /* Set a breakpoint according to ARG (function, linenum or *address)
4905 flag: first bit : 0 non-temporary, 1 temporary.
4906 second bit : 0 normal breakpoint, 1 hardware breakpoint. */
4909 break_command_1 (char *arg, int flag, int from_tty)
4911 int tempflag, hardwareflag;
4912 struct symtabs_and_lines sals;
4913 struct expression **cond = 0;
4914 /* Pointers in arg to the start, and one past the end, of the
4916 char **cond_string = (char **) NULL;
4917 char *addr_start = arg;
4919 struct cleanup *old_chain;
4920 struct cleanup *breakpoint_chain = NULL;
4923 int ignore_count = 0;
4925 hardwareflag = flag & BP_HARDWAREFLAG;
4926 tempflag = flag & BP_TEMPFLAG;
4931 parse_breakpoint_sals (&arg, &sals, &addr_string);
4936 /* Create a chain of things that always need to be cleaned up. */
4937 old_chain = make_cleanup (null_cleanup, 0);
4939 /* Make sure that all storage allocated to SALS gets freed. */
4940 make_cleanup (xfree, sals.sals);
4942 /* Cleanup the addr_string array but not its contents. */
4943 make_cleanup (xfree, addr_string);
4945 /* Allocate space for all the cond expressions. */
4946 cond = xcalloc (sals.nelts, sizeof (struct expression *));
4947 make_cleanup (xfree, cond);
4949 /* Allocate space for all the cond strings. */
4950 cond_string = xcalloc (sals.nelts, sizeof (char **));
4951 make_cleanup (xfree, cond_string);
4953 /* ----------------------------- SNIP -----------------------------
4954 Anything added to the cleanup chain beyond this point is assumed
4955 to be part of a breakpoint. If the breakpoint create succeeds
4956 then the memory is not reclaimed. */
4957 breakpoint_chain = make_cleanup (null_cleanup, 0);
4959 /* Mark the contents of the addr_string for cleanup. These go on
4960 the breakpoint_chain and only occure if the breakpoint create
4962 for (i = 0; i < sals.nelts; i++)
4964 if (addr_string[i] != NULL)
4965 make_cleanup (xfree, addr_string[i]);
4968 /* Resolve all line numbers to PC's and verify that the addresses
4969 are ok for the target. */
4970 breakpoint_sals_to_pc (&sals, addr_start);
4972 /* Verify that condition can be parsed, before setting any
4973 breakpoints. Allocate a separate condition expression for each
4975 thread = -1; /* No specific thread yet */
4976 for (i = 0; i < sals.nelts; i++)
4983 char *cond_start = NULL;
4984 char *cond_end = NULL;
4985 while (*tok == ' ' || *tok == '\t')
4990 while (*end_tok != ' ' && *end_tok != '\t' && *end_tok != '\000')
4993 toklen = end_tok - tok;
4995 if (toklen >= 1 && strncmp (tok, "if", toklen) == 0)
4997 tok = cond_start = end_tok + 1;
4998 cond[i] = parse_exp_1 (&tok, block_for_pc (sals.sals[i].pc), 0);
4999 make_cleanup (xfree, cond[i]);
5001 cond_string[i] = savestring (cond_start, cond_end - cond_start);
5002 make_cleanup (xfree, cond_string[i]);
5004 else if (toklen >= 1 && strncmp (tok, "thread", toklen) == 0)
5010 thread = strtol (tok, &tok, 0);
5012 error ("Junk after thread keyword.");
5013 if (!valid_thread_id (thread))
5014 error ("Unknown thread %d\n", thread);
5017 error ("Junk at end of arguments.");
5021 create_breakpoints (sals, addr_string, cond, cond_string,
5022 hardwareflag ? bp_hardware_breakpoint : bp_breakpoint,
5023 tempflag ? disp_del : disp_donttouch,
5024 thread, ignore_count, from_tty);
5028 warning ("Multiple breakpoints were set.");
5029 warning ("Use the \"delete\" command to delete unwanted breakpoints.");
5031 /* That's it. Discard the cleanups for data inserted into the
5033 discard_cleanups (breakpoint_chain);
5034 /* But cleanup everything else. */
5035 do_cleanups (old_chain);
5038 /* Set a breakpoint of TYPE/DISPOSITION according to ARG (function,
5039 linenum or *address) with COND and IGNORE_COUNT. */
5041 struct captured_breakpoint_args
5052 do_captured_breakpoint (void *data)
5054 struct captured_breakpoint_args *args = data;
5055 struct symtabs_and_lines sals;
5056 struct expression **cond;
5057 struct cleanup *old_chain;
5058 struct cleanup *breakpoint_chain = NULL;
5065 /* Parse the source and lines spec. Delay check that the expression
5066 didn't contain trailing garbage until after cleanups are in
5070 address_end = args->address;
5072 parse_breakpoint_sals (&address_end, &sals, &addr_string);
5077 /* Create a chain of things at always need to be cleaned up. */
5078 old_chain = make_cleanup (null_cleanup, 0);
5080 /* Always have a addr_string array, even if it is empty. */
5081 make_cleanup (xfree, addr_string);
5083 /* Make sure that all storage allocated to SALS gets freed. */
5084 make_cleanup (xfree, sals.sals);
5086 /* Allocate space for all the cond expressions. */
5087 cond = xcalloc (sals.nelts, sizeof (struct expression *));
5088 make_cleanup (xfree, cond);
5090 /* Allocate space for all the cond strings. */
5091 cond_string = xcalloc (sals.nelts, sizeof (char **));
5092 make_cleanup (xfree, cond_string);
5094 /* ----------------------------- SNIP -----------------------------
5095 Anything added to the cleanup chain beyond this point is assumed
5096 to be part of a breakpoint. If the breakpoint create goes
5097 through then that memory is not cleaned up. */
5098 breakpoint_chain = make_cleanup (null_cleanup, 0);
5100 /* Mark the contents of the addr_string for cleanup. These go on
5101 the breakpoint_chain and only occure if the breakpoint create
5103 for (i = 0; i < sals.nelts; i++)
5105 if (addr_string[i] != NULL)
5106 make_cleanup (xfree, addr_string[i]);
5109 /* Wait until now before checking for garbage at the end of the
5110 address. That way cleanups can take care of freeing any
5112 if (*address_end != '\0')
5113 error ("Garbage %s following breakpoint address", address_end);
5115 /* Resolve all line numbers to PC's. */
5116 breakpoint_sals_to_pc (&sals, args->address);
5118 /* Verify that conditions can be parsed, before setting any
5120 for (i = 0; i < sals.nelts; i++)
5122 if (args->condition != NULL)
5124 char *tok = args->condition;
5125 cond[i] = parse_exp_1 (&tok, block_for_pc (sals.sals[i].pc), 0);
5127 error ("Garbage %s follows condition", tok);
5128 make_cleanup (xfree, cond[i]);
5129 cond_string[i] = xstrdup (args->condition);
5133 create_breakpoints (sals, addr_string, cond, cond_string,
5134 args->hardwareflag ? bp_hardware_breakpoint : bp_breakpoint,
5135 args->tempflag ? disp_del : disp_donttouch,
5136 args->thread, args->ignore_count, 0/*from-tty*/);
5138 /* That's it. Discard the cleanups for data inserted into the
5140 discard_cleanups (breakpoint_chain);
5141 /* But cleanup everything else. */
5142 do_cleanups (old_chain);
5147 gdb_breakpoint (char *address, char *condition,
5148 int hardwareflag, int tempflag,
5149 int thread, int ignore_count)
5151 struct captured_breakpoint_args args;
5152 args.address = address;
5153 args.condition = condition;
5154 args.hardwareflag = hardwareflag;
5155 args.tempflag = tempflag;
5156 args.thread = thread;
5157 args.ignore_count = ignore_count;
5158 return catch_errors (do_captured_breakpoint, &args,
5159 NULL, RETURN_MASK_ALL);
5164 break_at_finish_at_depth_command_1 (char *arg, int flag, int from_tty)
5166 struct frame_info *frame;
5167 CORE_ADDR low, high, selected_pc = 0;
5168 char *extra_args = NULL;
5170 int extra_args_len = 0, if_arg = 0;
5173 (arg[0] == 'i' && arg[1] == 'f' && (arg[2] == ' ' || arg[2] == '\t')))
5176 if (default_breakpoint_valid)
5178 if (deprecated_selected_frame)
5180 selected_pc = get_frame_pc (deprecated_selected_frame);
5185 error ("No selected frame.");
5188 error ("No default breakpoint address now.");
5192 extra_args = strchr (arg, ' ');
5196 extra_args_len = strlen (extra_args);
5197 level_arg = (char *) xmalloc (extra_args - arg);
5198 strncpy (level_arg, arg, extra_args - arg - 1);
5199 level_arg[extra_args - arg - 1] = '\0';
5203 level_arg = (char *) xmalloc (strlen (arg) + 1);
5204 strcpy (level_arg, arg);
5207 frame = parse_frame_specification (level_arg);
5209 selected_pc = get_frame_pc (frame);
5216 extra_args_len = strlen (arg);
5221 if (find_pc_partial_function (selected_pc, (char **) NULL, &low, &high))
5225 addr_string = xstrprintf ("*0x%s %s", paddr_nz (high), extra_args);
5227 addr_string = xstrprintf ("*0x%s", paddr_nz (high));
5228 break_command_1 (addr_string, flag, from_tty);
5229 xfree (addr_string);
5232 error ("No function contains the specified address");
5235 error ("Unable to set breakpoint at procedure exit");
5240 break_at_finish_command_1 (char *arg, int flag, int from_tty)
5242 char *addr_string, *break_string, *beg_addr_string;
5243 CORE_ADDR low, high;
5244 struct symtabs_and_lines sals;
5245 struct symtab_and_line sal;
5246 struct cleanup *old_chain;
5247 char *extra_args = NULL;
5248 int extra_args_len = 0;
5252 (arg[0] == 'i' && arg[1] == 'f' && (arg[2] == ' ' || arg[2] == '\t')))
5254 if (default_breakpoint_valid)
5256 if (deprecated_selected_frame)
5258 addr_string = xstrprintf ("*0x%s",
5259 paddr_nz (get_frame_pc (deprecated_selected_frame)));
5264 error ("No selected frame.");
5267 error ("No default breakpoint address now.");
5271 addr_string = (char *) xmalloc (strlen (arg) + 1);
5272 strcpy (addr_string, arg);
5278 extra_args_len = strlen (arg);
5282 /* get the stuff after the function name or address */
5283 extra_args = strchr (arg, ' ');
5287 extra_args_len = strlen (extra_args);
5294 beg_addr_string = addr_string;
5295 sals = decode_line_1 (&addr_string, 1, (struct symtab *) NULL, 0,
5298 xfree (beg_addr_string);
5299 old_chain = make_cleanup (xfree, sals.sals);
5300 for (i = 0; (i < sals.nelts); i++)
5303 if (find_pc_partial_function (sal.pc, (char **) NULL, &low, &high))
5307 break_string = xstrprintf ("*0x%s %s", paddr_nz (high),
5310 break_string = xstrprintf ("*0x%s", paddr_nz (high));
5311 break_command_1 (break_string, flag, from_tty);
5312 xfree (break_string);
5315 error ("No function contains the specified address");
5319 warning ("Multiple breakpoints were set.\n");
5320 warning ("Use the \"delete\" command to delete unwanted breakpoints.");
5322 do_cleanups (old_chain);
5326 /* Helper function for break_command_1 and disassemble_command. */
5329 resolve_sal_pc (struct symtab_and_line *sal)
5333 if (sal->pc == 0 && sal->symtab != NULL)
5335 if (!find_line_pc (sal->symtab, sal->line, &pc))
5336 error ("No line %d in file \"%s\".",
5337 sal->line, sal->symtab->filename);
5341 if (sal->section == 0 && sal->symtab != NULL)
5343 struct blockvector *bv;
5348 bv = blockvector_for_pc_sect (sal->pc, 0, &index, sal->symtab);
5351 b = BLOCKVECTOR_BLOCK (bv, index);
5352 sym = block_function (b);
5355 fixup_symbol_section (sym, sal->symtab->objfile);
5356 sal->section = SYMBOL_BFD_SECTION (sym);
5360 /* It really is worthwhile to have the section, so we'll just
5361 have to look harder. This case can be executed if we have
5362 line numbers but no functions (as can happen in assembly
5365 struct minimal_symbol *msym;
5367 msym = lookup_minimal_symbol_by_pc (sal->pc);
5369 sal->section = SYMBOL_BFD_SECTION (msym);
5376 break_command (char *arg, int from_tty)
5378 break_command_1 (arg, 0, from_tty);
5382 break_at_finish_command (char *arg, int from_tty)
5384 break_at_finish_command_1 (arg, 0, from_tty);
5388 break_at_finish_at_depth_command (char *arg, int from_tty)
5390 break_at_finish_at_depth_command_1 (arg, 0, from_tty);
5394 tbreak_command (char *arg, int from_tty)
5396 break_command_1 (arg, BP_TEMPFLAG, from_tty);
5400 tbreak_at_finish_command (char *arg, int from_tty)
5402 break_at_finish_command_1 (arg, BP_TEMPFLAG, from_tty);
5406 hbreak_command (char *arg, int from_tty)
5408 break_command_1 (arg, BP_HARDWAREFLAG, from_tty);
5412 thbreak_command (char *arg, int from_tty)
5414 break_command_1 (arg, (BP_TEMPFLAG | BP_HARDWAREFLAG), from_tty);
5418 stop_command (char *arg, int from_tty)
5420 printf_filtered ("Specify the type of breakpoint to set.\n\
5421 Usage: stop in <function | address>\n\
5426 stopin_command (char *arg, int from_tty)
5430 if (arg == (char *) NULL)
5432 else if (*arg != '*')
5437 /* look for a ':'. If this is a line number specification, then
5438 say it is bad, otherwise, it should be an address or
5439 function/method name */
5440 while (*argptr && !hasColon)
5442 hasColon = (*argptr == ':');
5447 badInput = (*argptr != ':'); /* Not a class::method */
5449 badInput = isdigit (*arg); /* a simple line number */
5453 printf_filtered ("Usage: stop in <function | address>\n");
5455 break_command_1 (arg, 0, from_tty);
5459 stopat_command (char *arg, int from_tty)
5463 if (arg == (char *) NULL || *arg == '*') /* no line number */
5470 /* look for a ':'. If there is a '::' then get out, otherwise
5471 it is probably a line number. */
5472 while (*argptr && !hasColon)
5474 hasColon = (*argptr == ':');
5479 badInput = (*argptr == ':'); /* we have class::method */
5481 badInput = !isdigit (*arg); /* not a line number */
5485 printf_filtered ("Usage: stop at <line>\n");
5487 break_command_1 (arg, 0, from_tty);
5490 /* accessflag: hw_write: watch write,
5491 hw_read: watch read,
5492 hw_access: watch access (read or write) */
5494 watch_command_1 (char *arg, int accessflag, int from_tty)
5496 struct breakpoint *b;
5497 struct symtab_and_line sal;
5498 struct expression *exp;
5499 struct block *exp_valid_block;
5500 struct value *val, *mark;
5501 struct frame_info *frame;
5502 struct frame_info *prev_frame = NULL;
5503 char *exp_start = NULL;
5504 char *exp_end = NULL;
5505 char *tok, *end_tok;
5507 char *cond_start = NULL;
5508 char *cond_end = NULL;
5509 struct expression *cond = NULL;
5510 int i, other_type_used, target_resources_ok = 0;
5511 enum bptype bp_type;
5514 init_sal (&sal); /* initialize to zeroes */
5516 /* Parse arguments. */
5517 innermost_block = NULL;
5519 exp = parse_exp_1 (&arg, 0, 0);
5521 exp_valid_block = innermost_block;
5522 mark = value_mark ();
5523 val = evaluate_expression (exp);
5524 release_value (val);
5525 if (VALUE_LAZY (val))
5526 value_fetch_lazy (val);
5529 while (*tok == ' ' || *tok == '\t')
5533 while (*end_tok != ' ' && *end_tok != '\t' && *end_tok != '\000')
5536 toklen = end_tok - tok;
5537 if (toklen >= 1 && strncmp (tok, "if", toklen) == 0)
5539 tok = cond_start = end_tok + 1;
5540 cond = parse_exp_1 (&tok, 0, 0);
5544 error ("Junk at end of command.");
5546 if (accessflag == hw_read)
5547 bp_type = bp_read_watchpoint;
5548 else if (accessflag == hw_access)
5549 bp_type = bp_access_watchpoint;
5551 bp_type = bp_hardware_watchpoint;
5553 mem_cnt = can_use_hardware_watchpoint (val);
5554 if (mem_cnt == 0 && bp_type != bp_hardware_watchpoint)
5555 error ("Expression cannot be implemented with read/access watchpoint.");
5558 i = hw_watchpoint_used_count (bp_type, &other_type_used);
5559 target_resources_ok =
5560 TARGET_CAN_USE_HARDWARE_WATCHPOINT (bp_type, i + mem_cnt,
5562 if (target_resources_ok == 0 && bp_type != bp_hardware_watchpoint)
5563 error ("Target does not support this type of hardware watchpoint.");
5565 if (target_resources_ok < 0 && bp_type != bp_hardware_watchpoint)
5566 error ("Target can only support one kind of HW watchpoint at a time.");
5569 #if defined(HPUXHPPA)
5570 /* On HP-UX if you set a h/w
5571 watchpoint before the "run" command, the inferior dies with a e.g.,
5572 SIGILL once you start it. I initially believed this was due to a
5573 bad interaction between page protection traps and the initial
5574 startup sequence by the dynamic linker.
5576 However, I tried avoiding that by having HP-UX's implementation of
5577 TARGET_CAN_USE_HW_WATCHPOINT return FALSE if there was no inferior_ptid
5578 yet, which forced slow watches before a "run" or "attach", and it
5579 still fails somewhere in the startup code.
5581 Until I figure out what's happening, I'm disallowing watches altogether
5582 before the "run" or "attach" command. We'll tell the user they must
5583 set watches after getting the program started. */
5584 if (!target_has_execution)
5586 warning ("can't do that without a running program; try \"break main\", \"run\" first");
5589 #endif /* HPUXHPPA */
5591 /* Change the type of breakpoint to an ordinary watchpoint if a hardware
5592 watchpoint could not be set. */
5593 if (!mem_cnt || target_resources_ok <= 0)
5594 bp_type = bp_watchpoint;
5596 /* Now set up the breakpoint. */
5597 b = set_raw_breakpoint (sal, bp_type);
5598 set_breakpoint_count (breakpoint_count + 1);
5599 b->number = breakpoint_count;
5600 b->disposition = disp_donttouch;
5602 b->exp_valid_block = exp_valid_block;
5603 b->exp_string = savestring (exp_start, exp_end - exp_start);
5607 b->cond_string = savestring (cond_start, cond_end - cond_start);
5611 frame = block_innermost_frame (exp_valid_block);
5614 prev_frame = get_prev_frame (frame);
5615 b->watchpoint_frame = get_frame_id (frame);
5619 memset (&b->watchpoint_frame, 0, sizeof (b->watchpoint_frame));
5622 /* If the expression is "local", then set up a "watchpoint scope"
5623 breakpoint at the point where we've left the scope of the watchpoint
5625 if (innermost_block)
5629 struct breakpoint *scope_breakpoint;
5630 scope_breakpoint = create_internal_breakpoint (get_frame_pc (prev_frame),
5631 bp_watchpoint_scope);
5633 scope_breakpoint->enable_state = bp_enabled;
5635 /* Automatically delete the breakpoint when it hits. */
5636 scope_breakpoint->disposition = disp_del;
5638 /* Only break in the proper frame (help with recursion). */
5639 scope_breakpoint->frame_id = get_frame_id (prev_frame);
5641 /* Set the address at which we will stop. */
5642 scope_breakpoint->loc->requested_address
5643 = get_frame_pc (prev_frame);
5644 scope_breakpoint->loc->address
5645 = adjust_breakpoint_address (scope_breakpoint->loc->requested_address);
5647 /* The scope breakpoint is related to the watchpoint. We
5648 will need to act on them together. */
5649 b->related_breakpoint = scope_breakpoint;
5652 value_free_to_mark (mark);
5656 /* Return count of locations need to be watched and can be handled
5657 in hardware. If the watchpoint can not be handled
5658 in hardware return zero. */
5660 #if !defined(TARGET_REGION_SIZE_OK_FOR_HW_WATCHPOINT)
5661 #define TARGET_REGION_SIZE_OK_FOR_HW_WATCHPOINT(BYTE_SIZE) \
5662 ((BYTE_SIZE) <= (DEPRECATED_REGISTER_SIZE))
5665 #if !defined(TARGET_REGION_OK_FOR_HW_WATCHPOINT)
5666 #define TARGET_REGION_OK_FOR_HW_WATCHPOINT(ADDR,LEN) \
5667 (TARGET_REGION_SIZE_OK_FOR_HW_WATCHPOINT(LEN))
5671 can_use_hardware_watchpoint (struct value *v)
5673 int found_memory_cnt = 0;
5674 struct value *head = v;
5676 /* Did the user specifically forbid us to use hardware watchpoints? */
5677 if (!can_use_hw_watchpoints)
5680 /* Make sure that the value of the expression depends only upon
5681 memory contents, and values computed from them within GDB. If we
5682 find any register references or function calls, we can't use a
5683 hardware watchpoint.
5685 The idea here is that evaluating an expression generates a series
5686 of values, one holding the value of every subexpression. (The
5687 expression a*b+c has five subexpressions: a, b, a*b, c, and
5688 a*b+c.) GDB's values hold almost enough information to establish
5689 the criteria given above --- they identify memory lvalues,
5690 register lvalues, computed values, etcetera. So we can evaluate
5691 the expression, and then scan the chain of values that leaves
5692 behind to decide whether we can detect any possible change to the
5693 expression's final value using only hardware watchpoints.
5695 However, I don't think that the values returned by inferior
5696 function calls are special in any way. So this function may not
5697 notice that an expression involving an inferior function call
5698 can't be watched with hardware watchpoints. FIXME. */
5699 for (; v; v = v->next)
5701 if (VALUE_LVAL (v) == lval_memory)
5704 /* A lazy memory lvalue is one that GDB never needed to fetch;
5705 we either just used its address (e.g., `a' in `a.b') or
5706 we never needed it at all (e.g., `a' in `a,b'). */
5710 /* Ahh, memory we actually used! Check if we can cover
5711 it with hardware watchpoints. */
5712 struct type *vtype = check_typedef (VALUE_TYPE (v));
5714 /* We only watch structs and arrays if user asked for it
5715 explicitly, never if they just happen to appear in a
5716 middle of some value chain. */
5718 || (TYPE_CODE (vtype) != TYPE_CODE_STRUCT
5719 && TYPE_CODE (vtype) != TYPE_CODE_ARRAY))
5721 CORE_ADDR vaddr = VALUE_ADDRESS (v) + VALUE_OFFSET (v);
5722 int len = TYPE_LENGTH (VALUE_TYPE (v));
5724 if (!TARGET_REGION_OK_FOR_HW_WATCHPOINT (vaddr, len))
5731 else if (v->lval != not_lval && v->modifiable == 0)
5732 return 0; /* ??? What does this represent? */
5733 else if (v->lval == lval_register)
5734 return 0; /* cannot watch a register with a HW watchpoint */
5737 /* The expression itself looks suitable for using a hardware
5738 watchpoint, but give the target machine a chance to reject it. */
5739 return found_memory_cnt;
5743 watch_command_wrapper (char *arg, int from_tty)
5745 watch_command (arg, from_tty);
5749 watch_command (char *arg, int from_tty)
5751 watch_command_1 (arg, hw_write, from_tty);
5755 rwatch_command_wrapper (char *arg, int from_tty)
5757 rwatch_command (arg, from_tty);
5761 rwatch_command (char *arg, int from_tty)
5763 watch_command_1 (arg, hw_read, from_tty);
5767 awatch_command_wrapper (char *arg, int from_tty)
5769 awatch_command (arg, from_tty);
5773 awatch_command (char *arg, int from_tty)
5775 watch_command_1 (arg, hw_access, from_tty);
5779 /* Helper routines for the until_command routine in infcmd.c. Here
5780 because it uses the mechanisms of breakpoints. */
5782 /* This function is called by fetch_inferior_event via the
5783 cmd_continuation pointer, to complete the until command. It takes
5784 care of cleaning up the temporary breakpoints set up by the until
5787 until_break_command_continuation (struct continuation_arg *arg)
5789 struct cleanup *cleanups;
5791 cleanups = (struct cleanup *) arg->data.pointer;
5792 do_exec_cleanups (cleanups);
5796 until_break_command (char *arg, int from_tty, int anywhere)
5798 struct symtabs_and_lines sals;
5799 struct symtab_and_line sal;
5800 struct frame_info *prev_frame = get_prev_frame (deprecated_selected_frame);
5801 struct breakpoint *breakpoint;
5802 struct cleanup *old_chain;
5803 struct continuation_arg *arg1;
5806 clear_proceed_status ();
5808 /* Set a breakpoint where the user wants it and at return from
5811 if (default_breakpoint_valid)
5812 sals = decode_line_1 (&arg, 1, default_breakpoint_symtab,
5813 default_breakpoint_line, (char ***) NULL);
5815 sals = decode_line_1 (&arg, 1, (struct symtab *) NULL,
5816 0, (char ***) NULL);
5818 if (sals.nelts != 1)
5819 error ("Couldn't get information on specified line.");
5822 xfree (sals.sals); /* malloc'd, so freed */
5825 error ("Junk at end of arguments.");
5827 resolve_sal_pc (&sal);
5830 /* If the user told us to continue until a specified location,
5831 we don't specify a frame at which we need to stop. */
5832 breakpoint = set_momentary_breakpoint (sal, null_frame_id, bp_until);
5834 /* Otherwise, specify the current frame, because we want to stop only
5835 at the very same frame. */
5836 breakpoint = set_momentary_breakpoint (sal,
5837 get_frame_id (deprecated_selected_frame),
5840 if (!event_loop_p || !target_can_async_p ())
5841 old_chain = make_cleanup_delete_breakpoint (breakpoint);
5843 old_chain = make_exec_cleanup_delete_breakpoint (breakpoint);
5845 /* If we are running asynchronously, and the target supports async
5846 execution, we are not waiting for the target to stop, in the call
5847 tp proceed, below. This means that we cannot delete the
5848 brekpoints until the target has actually stopped. The only place
5849 where we get a chance to do that is in fetch_inferior_event, so
5850 we must set things up for that. */
5852 if (event_loop_p && target_can_async_p ())
5854 /* In this case the arg for the continuation is just the point
5855 in the exec_cleanups chain from where to start doing
5856 cleanups, because all the continuation does is the cleanups in
5857 the exec_cleanup_chain. */
5859 (struct continuation_arg *) xmalloc (sizeof (struct continuation_arg));
5861 arg1->data.pointer = old_chain;
5863 add_continuation (until_break_command_continuation, arg1);
5866 /* Keep within the current frame, or in frames called by the current
5870 sal = find_pc_line (get_frame_pc (prev_frame), 0);
5871 sal.pc = get_frame_pc (prev_frame);
5872 breakpoint = set_momentary_breakpoint (sal, get_frame_id (prev_frame),
5874 if (!event_loop_p || !target_can_async_p ())
5875 make_cleanup_delete_breakpoint (breakpoint);
5877 make_exec_cleanup_delete_breakpoint (breakpoint);
5880 proceed (-1, TARGET_SIGNAL_DEFAULT, 0);
5881 /* Do the cleanups now, anly if we are not running asynchronously,
5882 of if we are, but the target is still synchronous. */
5883 if (!event_loop_p || !target_can_async_p ())
5884 do_cleanups (old_chain);
5888 /* These aren't used; I don't konw what they were for. */
5889 /* Set a breakpoint at the catch clause for NAME. */
5891 catch_breakpoint (char *name)
5896 disable_catch_breakpoint (void)
5901 delete_catch_breakpoint (void)
5906 enable_catch_breakpoint (void)
5912 ep_skip_leading_whitespace (char **s)
5914 if ((s == NULL) || (*s == NULL))
5916 while (isspace (**s))
5920 /* This function examines a string, and attempts to find a token
5921 that might be an event name in the leading characters. If a
5922 possible match is found, a pointer to the last character of
5923 the token is returned. Else, NULL is returned. */
5926 ep_find_event_name_end (char *arg)
5929 char *event_name_end = NULL;
5931 /* If we could depend upon the presense of strrpbrk, we'd use that... */
5935 /* We break out of the loop when we find a token delimiter.
5936 Basically, we're looking for alphanumerics and underscores;
5937 anything else delimites the token. */
5940 if (!isalnum (*s) && (*s != '_'))
5946 return event_name_end;
5950 /* This function attempts to parse an optional "if <cond>" clause
5951 from the arg string. If one is not found, it returns NULL.
5953 Else, it returns a pointer to the condition string. (It does not
5954 attempt to evaluate the string against a particular block.) And,
5955 it updates arg to point to the first character following the parsed
5956 if clause in the arg string. */
5959 ep_parse_optional_if_clause (char **arg)
5963 if (((*arg)[0] != 'i') || ((*arg)[1] != 'f') || !isspace ((*arg)[2]))
5966 /* Skip the "if" keyword. */
5969 /* Skip any extra leading whitespace, and record the start of the
5970 condition string. */
5971 ep_skip_leading_whitespace (arg);
5974 /* Assume that the condition occupies the remainder of the arg string. */
5975 (*arg) += strlen (cond_string);
5980 /* This function attempts to parse an optional filename from the arg
5981 string. If one is not found, it returns NULL.
5983 Else, it returns a pointer to the parsed filename. (This function
5984 makes no attempt to verify that a file of that name exists, or is
5985 accessible.) And, it updates arg to point to the first character
5986 following the parsed filename in the arg string.
5988 Note that clients needing to preserve the returned filename for
5989 future access should copy it to their own buffers. */
5991 ep_parse_optional_filename (char **arg)
5993 static char filename[1024];
5998 if ((*arg_p == '\0') || isspace (*arg_p))
6016 /* Commands to deal with catching events, such as signals, exceptions,
6017 process start/exit, etc. */
6021 catch_fork, catch_vfork
6025 #if defined(CHILD_INSERT_FORK_CATCHPOINT) || defined(CHILD_INSERT_VFORK_CATCHPOINT)
6026 static void catch_fork_command_1 (catch_fork_kind fork_kind,
6027 char *arg, int tempflag, int from_tty);
6030 catch_fork_command_1 (catch_fork_kind fork_kind, char *arg, int tempflag,
6033 char *cond_string = NULL;
6035 ep_skip_leading_whitespace (&arg);
6037 /* The allowed syntax is:
6039 catch [v]fork if <cond>
6041 First, check if there's an if clause. */
6042 cond_string = ep_parse_optional_if_clause (&arg);
6044 if ((*arg != '\0') && !isspace (*arg))
6045 error ("Junk at end of arguments.");
6047 /* If this target supports it, create a fork or vfork catchpoint
6048 and enable reporting of such events. */
6052 create_fork_event_catchpoint (tempflag, cond_string);
6055 create_vfork_event_catchpoint (tempflag, cond_string);
6058 error ("unsupported or unknown fork kind; cannot catch it");
6064 #if defined(CHILD_INSERT_EXEC_CATCHPOINT)
6066 catch_exec_command_1 (char *arg, int tempflag, int from_tty)
6068 char *cond_string = NULL;
6070 ep_skip_leading_whitespace (&arg);
6072 /* The allowed syntax is:
6074 catch exec if <cond>
6076 First, check if there's an if clause. */
6077 cond_string = ep_parse_optional_if_clause (&arg);
6079 if ((*arg != '\0') && !isspace (*arg))
6080 error ("Junk at end of arguments.");
6082 /* If this target supports it, create an exec catchpoint
6083 and enable reporting of such events. */
6084 create_exec_event_catchpoint (tempflag, cond_string);
6088 #if defined(SOLIB_ADD)
6090 catch_load_command_1 (char *arg, int tempflag, int from_tty)
6092 char *dll_pathname = NULL;
6093 char *cond_string = NULL;
6095 ep_skip_leading_whitespace (&arg);
6097 /* The allowed syntax is:
6099 catch load if <cond>
6100 catch load <filename>
6101 catch load <filename> if <cond>
6103 The user is not allowed to specify the <filename> after an
6106 We'll ignore the pathological case of a file named "if".
6108 First, check if there's an if clause. If so, then there
6109 cannot be a filename. */
6110 cond_string = ep_parse_optional_if_clause (&arg);
6112 /* If there was an if clause, then there cannot be a filename.
6113 Else, there might be a filename and an if clause. */
6114 if (cond_string == NULL)
6116 dll_pathname = ep_parse_optional_filename (&arg);
6117 ep_skip_leading_whitespace (&arg);
6118 cond_string = ep_parse_optional_if_clause (&arg);
6121 if ((*arg != '\0') && !isspace (*arg))
6122 error ("Junk at end of arguments.");
6124 /* Create a load breakpoint that only triggers when a load of
6125 the specified dll (or any dll, if no pathname was specified)
6127 SOLIB_CREATE_CATCH_LOAD_HOOK (PIDGET (inferior_ptid), tempflag,
6128 dll_pathname, cond_string);
6132 catch_unload_command_1 (char *arg, int tempflag, int from_tty)
6134 char *dll_pathname = NULL;
6135 char *cond_string = NULL;
6137 ep_skip_leading_whitespace (&arg);
6139 /* The allowed syntax is:
6141 catch unload if <cond>
6142 catch unload <filename>
6143 catch unload <filename> if <cond>
6145 The user is not allowed to specify the <filename> after an
6148 We'll ignore the pathological case of a file named "if".
6150 First, check if there's an if clause. If so, then there
6151 cannot be a filename. */
6152 cond_string = ep_parse_optional_if_clause (&arg);
6154 /* If there was an if clause, then there cannot be a filename.
6155 Else, there might be a filename and an if clause. */
6156 if (cond_string == NULL)
6158 dll_pathname = ep_parse_optional_filename (&arg);
6159 ep_skip_leading_whitespace (&arg);
6160 cond_string = ep_parse_optional_if_clause (&arg);
6163 if ((*arg != '\0') && !isspace (*arg))
6164 error ("Junk at end of arguments.");
6166 /* Create an unload breakpoint that only triggers when an unload of
6167 the specified dll (or any dll, if no pathname was specified)
6169 SOLIB_CREATE_CATCH_UNLOAD_HOOK (PIDGET (inferior_ptid), tempflag,
6170 dll_pathname, cond_string);
6172 #endif /* SOLIB_ADD */
6174 /* Commands to deal with catching exceptions. */
6176 /* Set a breakpoint at the specified callback routine for an
6177 exception event callback */
6180 create_exception_catchpoint (int tempflag, char *cond_string,
6181 enum exception_event_kind ex_event,
6182 struct symtab_and_line *sal)
6184 struct breakpoint *b;
6185 int thread = -1; /* All threads. */
6188 if (!sal) /* no exception support? */
6193 case EX_EVENT_THROW:
6194 bptype = bp_catch_throw;
6196 case EX_EVENT_CATCH:
6197 bptype = bp_catch_catch;
6199 default: /* error condition */
6200 error ("Internal error -- invalid catchpoint kind");
6203 b = set_raw_breakpoint (*sal, bptype);
6204 set_breakpoint_count (breakpoint_count + 1);
6205 b->number = breakpoint_count;
6207 b->cond_string = (cond_string == NULL) ?
6208 NULL : savestring (cond_string, strlen (cond_string));
6210 b->addr_string = NULL;
6211 b->enable_state = bp_enabled;
6212 b->disposition = tempflag ? disp_del : disp_donttouch;
6216 static enum print_stop_action
6217 print_exception_catchpoint (struct breakpoint *b)
6219 annotate_catchpoint (b->number);
6221 if (strstr (b->addr_string, "throw") != NULL)
6222 printf_filtered ("\nCatchpoint %d (exception thrown)\n",
6225 printf_filtered ("\nCatchpoint %d (exception caught)\n",
6228 return PRINT_SRC_AND_LOC;
6232 print_one_exception_catchpoint (struct breakpoint *b, CORE_ADDR *last_addr)
6237 ui_out_field_core_addr (uiout, "addr", b->loc->address);
6240 *last_addr = b->loc->address;
6241 if (strstr (b->addr_string, "throw") != NULL)
6242 ui_out_field_string (uiout, "what", "exception throw");
6244 ui_out_field_string (uiout, "what", "exception catch");
6248 print_mention_exception_catchpoint (struct breakpoint *b)
6250 if (strstr (b->addr_string, "throw") != NULL)
6251 printf_filtered ("Catchpoint %d (throw)", b->number);
6253 printf_filtered ("Catchpoint %d (catch)", b->number);
6256 static struct breakpoint_ops gnu_v3_exception_catchpoint_ops = {
6257 print_exception_catchpoint,
6258 print_one_exception_catchpoint,
6259 print_mention_exception_catchpoint
6263 handle_gnu_v3_exceptions (int tempflag, char *cond_string,
6264 enum exception_event_kind ex_event, int from_tty)
6266 char *trigger_func_name, *nameptr;
6267 struct symtabs_and_lines sals;
6268 struct breakpoint *b;
6270 if (ex_event == EX_EVENT_CATCH)
6271 trigger_func_name = xstrdup ("__cxa_begin_catch");
6273 trigger_func_name = xstrdup ("__cxa_throw");
6275 nameptr = trigger_func_name;
6276 sals = decode_line_1 (&nameptr, 1, NULL, 0, NULL);
6277 if (sals.nelts == 0)
6279 xfree (trigger_func_name);
6283 b = set_raw_breakpoint (sals.sals[0], bp_breakpoint);
6284 set_breakpoint_count (breakpoint_count + 1);
6285 b->number = breakpoint_count;
6287 b->cond_string = (cond_string == NULL) ?
6288 NULL : savestring (cond_string, strlen (cond_string));
6290 b->addr_string = trigger_func_name;
6291 b->enable_state = bp_enabled;
6292 b->disposition = tempflag ? disp_del : disp_donttouch;
6293 b->ops = &gnu_v3_exception_catchpoint_ops;
6300 /* Deal with "catch catch" and "catch throw" commands */
6303 catch_exception_command_1 (enum exception_event_kind ex_event, char *arg,
6304 int tempflag, int from_tty)
6306 char *cond_string = NULL;
6307 struct symtab_and_line *sal = NULL;
6309 ep_skip_leading_whitespace (&arg);
6311 cond_string = ep_parse_optional_if_clause (&arg);
6313 if ((*arg != '\0') && !isspace (*arg))
6314 error ("Junk at end of arguments.");
6316 if ((ex_event != EX_EVENT_THROW) &&
6317 (ex_event != EX_EVENT_CATCH))
6318 error ("Unsupported or unknown exception event; cannot catch it");
6320 if (handle_gnu_v3_exceptions (tempflag, cond_string, ex_event, from_tty))
6323 /* See if we can find a callback routine */
6324 sal = target_enable_exception_callback (ex_event, 1);
6328 /* We have callbacks from the runtime system for exceptions.
6329 Set a breakpoint on the sal found, if no errors */
6330 if (sal != (struct symtab_and_line *) -1)
6331 create_exception_catchpoint (tempflag, cond_string, ex_event, sal);
6333 return; /* something went wrong with setting up callbacks */
6336 warning ("Unsupported with this platform/compiler combination.");
6339 /* Cover routine to allow wrapping target_enable_exception_catchpoints
6340 inside a catch_errors */
6343 cover_target_enable_exception_callback (void *arg)
6345 args_for_catchpoint_enable *args = arg;
6346 struct symtab_and_line *sal;
6347 sal = target_enable_exception_callback (args->kind, args->enable_p);
6350 else if (sal == (struct symtab_and_line *) -1)
6353 return 1; /*is valid */
6357 catch_command_1 (char *arg, int tempflag, int from_tty)
6360 /* The first argument may be an event name, such as "start" or "load".
6361 If so, then handle it as such. If it doesn't match an event name,
6362 then attempt to interpret it as an exception name. (This latter is
6363 the v4.16-and-earlier GDB meaning of the "catch" command.)
6365 First, try to find the bounds of what might be an event name. */
6366 char *arg1_start = arg;
6370 if (arg1_start == NULL)
6372 /* Old behaviour was to use pre-v-4.16 syntax */
6373 /* catch_throw_command_1 (arg1_start, tempflag, from_tty); */
6375 /* Now, this is not allowed */
6376 error ("Catch requires an event name.");
6379 arg1_end = ep_find_event_name_end (arg1_start);
6380 if (arg1_end == NULL)
6381 error ("catch requires an event");
6382 arg1_length = arg1_end + 1 - arg1_start;
6384 /* Try to match what we found against known event names. */
6385 if (strncmp (arg1_start, "signal", arg1_length) == 0)
6387 error ("Catch of signal not yet implemented");
6389 else if (strncmp (arg1_start, "catch", arg1_length) == 0)
6391 catch_exception_command_1 (EX_EVENT_CATCH, arg1_end + 1,
6392 tempflag, from_tty);
6394 else if (strncmp (arg1_start, "throw", arg1_length) == 0)
6396 catch_exception_command_1 (EX_EVENT_THROW, arg1_end + 1,
6397 tempflag, from_tty);
6399 else if (strncmp (arg1_start, "thread_start", arg1_length) == 0)
6401 error ("Catch of thread_start not yet implemented");
6403 else if (strncmp (arg1_start, "thread_exit", arg1_length) == 0)
6405 error ("Catch of thread_exit not yet implemented");
6407 else if (strncmp (arg1_start, "thread_join", arg1_length) == 0)
6409 error ("Catch of thread_join not yet implemented");
6411 else if (strncmp (arg1_start, "start", arg1_length) == 0)
6413 error ("Catch of start not yet implemented");
6415 else if (strncmp (arg1_start, "exit", arg1_length) == 0)
6417 error ("Catch of exit not yet implemented");
6419 else if (strncmp (arg1_start, "fork", arg1_length) == 0)
6421 #if defined(CHILD_INSERT_FORK_CATCHPOINT)
6422 catch_fork_command_1 (catch_fork, arg1_end + 1, tempflag, from_tty);
6424 error ("Catch of fork not yet implemented");
6427 else if (strncmp (arg1_start, "vfork", arg1_length) == 0)
6429 #if defined(CHILD_INSERT_VFORK_CATCHPOINT)
6430 catch_fork_command_1 (catch_vfork, arg1_end + 1, tempflag, from_tty);
6432 error ("Catch of vfork not yet implemented");
6435 else if (strncmp (arg1_start, "exec", arg1_length) == 0)
6437 #if defined(CHILD_INSERT_EXEC_CATCHPOINT)
6438 catch_exec_command_1 (arg1_end + 1, tempflag, from_tty);
6440 error ("Catch of exec not yet implemented");
6443 else if (strncmp (arg1_start, "load", arg1_length) == 0)
6445 #if defined(SOLIB_ADD)
6446 catch_load_command_1 (arg1_end + 1, tempflag, from_tty);
6448 error ("Catch of load not implemented");
6451 else if (strncmp (arg1_start, "unload", arg1_length) == 0)
6453 #if defined(SOLIB_ADD)
6454 catch_unload_command_1 (arg1_end + 1, tempflag, from_tty);
6456 error ("Catch of load not implemented");
6459 else if (strncmp (arg1_start, "stop", arg1_length) == 0)
6461 error ("Catch of stop not yet implemented");
6464 /* This doesn't appear to be an event name */
6468 /* Pre-v.4.16 behaviour was to treat the argument
6469 as the name of an exception */
6470 /* catch_throw_command_1 (arg1_start, tempflag, from_tty); */
6471 /* Now this is not allowed */
6472 error ("Unknown event kind specified for catch");
6477 /* Used by the gui, could be made a worker for other things. */
6480 set_breakpoint_sal (struct symtab_and_line sal)
6482 struct breakpoint *b;
6483 b = set_raw_breakpoint (sal, bp_breakpoint);
6484 set_breakpoint_count (breakpoint_count + 1);
6485 b->number = breakpoint_count;
6492 /* These aren't used; I don't know what they were for. */
6493 /* Disable breakpoints on all catch clauses described in ARGS. */
6495 disable_catch (char *args)
6497 /* Map the disable command to catch clauses described in ARGS. */
6500 /* Enable breakpoints on all catch clauses described in ARGS. */
6502 enable_catch (char *args)
6504 /* Map the disable command to catch clauses described in ARGS. */
6507 /* Delete breakpoints on all catch clauses in the active scope. */
6509 delete_catch (char *args)
6511 /* Map the delete command to catch clauses described in ARGS. */
6516 catch_command (char *arg, int from_tty)
6518 catch_command_1 (arg, 0, from_tty);
6523 tcatch_command (char *arg, int from_tty)
6525 catch_command_1 (arg, 1, from_tty);
6528 /* Delete breakpoints by address or line. */
6531 clear_command (char *arg, int from_tty)
6533 struct breakpoint *b, *tmp, *prev, *found;
6535 struct symtabs_and_lines sals;
6536 struct symtab_and_line sal;
6541 sals = decode_line_spec (arg, 1);
6546 sals.sals = (struct symtab_and_line *)
6547 xmalloc (sizeof (struct symtab_and_line));
6548 make_cleanup (xfree, sals.sals);
6549 init_sal (&sal); /* initialize to zeroes */
6550 sal.line = default_breakpoint_line;
6551 sal.symtab = default_breakpoint_symtab;
6552 sal.pc = default_breakpoint_address;
6553 if (sal.symtab == 0)
6554 error ("No source file specified.");
6562 /* For each line spec given, delete bps which correspond
6563 to it. Do it in two passes, solely to preserve the current
6564 behavior that from_tty is forced true if we delete more than
6568 for (i = 0; i < sals.nelts; i++)
6570 /* If exact pc given, clear bpts at that pc.
6571 If line given (pc == 0), clear all bpts on specified line.
6572 If defaulting, clear all bpts on default line
6575 defaulting sal.pc != 0 tests to do
6580 1 0 <can't happen> */
6585 /* Find all matching breakpoints, remove them from the
6586 breakpoint chain, and add them to the 'found' chain. */
6587 ALL_BREAKPOINTS_SAFE (b, tmp)
6589 /* Are we going to delete b? */
6590 if (b->type != bp_none
6591 && b->type != bp_watchpoint
6592 && b->type != bp_hardware_watchpoint
6593 && b->type != bp_read_watchpoint
6594 && b->type != bp_access_watchpoint
6595 /* Not if b is a watchpoint of any sort... */
6596 && (((sal.pc && (b->loc->address == sal.pc))
6597 && (!section_is_overlay (b->loc->section)
6598 || b->loc->section == sal.section))
6599 /* Yes, if sal.pc matches b (modulo overlays). */
6600 || ((default_match || (0 == sal.pc))
6601 && b->source_file != NULL
6602 && sal.symtab != NULL
6603 && strcmp (b->source_file, sal.symtab->filename) == 0
6604 && b->line_number == sal.line)))
6605 /* Yes, if sal source file and line matches b. */
6607 /* Remove it from breakpoint_chain... */
6608 if (b == breakpoint_chain)
6610 /* b is at the head of the list */
6611 breakpoint_chain = b->next;
6615 prev->next = b->next;
6617 /* And add it to 'found' chain. */
6623 /* Keep b, and keep a pointer to it. */
6628 /* Now go thru the 'found' chain and delete them. */
6632 error ("No breakpoint at %s.", arg);
6634 error ("No breakpoint at this line.");
6638 from_tty = 1; /* Always report if deleted more than one */
6640 printf_unfiltered ("Deleted breakpoint%s ", found->next ? "s" : "");
6641 breakpoints_changed ();
6645 printf_unfiltered ("%d ", found->number);
6647 delete_breakpoint (found);
6651 putchar_unfiltered ('\n');
6654 /* Delete breakpoint in BS if they are `delete' breakpoints and
6655 all breakpoints that are marked for deletion, whether hit or not.
6656 This is called after any breakpoint is hit, or after errors. */
6659 breakpoint_auto_delete (bpstat bs)
6661 struct breakpoint *b, *temp;
6663 for (; bs; bs = bs->next)
6664 if (bs->breakpoint_at && bs->breakpoint_at->disposition == disp_del
6666 delete_breakpoint (bs->breakpoint_at);
6668 ALL_BREAKPOINTS_SAFE (b, temp)
6670 if (b->disposition == disp_del_at_next_stop)
6671 delete_breakpoint (b);
6675 /* Delete a breakpoint and clean up all traces of it in the data
6679 delete_breakpoint (struct breakpoint *bpt)
6681 struct breakpoint *b;
6683 struct bp_location *loc;
6686 error ("Internal error (attempted to delete a NULL breakpoint)");
6689 /* Has this bp already been deleted? This can happen because multiple
6690 lists can hold pointers to bp's. bpstat lists are especial culprits.
6692 One example of this happening is a watchpoint's scope bp. When the
6693 scope bp triggers, we notice that the watchpoint is out of scope, and
6694 delete it. We also delete its scope bp. But the scope bp is marked
6695 "auto-deleting", and is already on a bpstat. That bpstat is then
6696 checked for auto-deleting bp's, which are deleted.
6698 A real solution to this problem might involve reference counts in bp's,
6699 and/or giving them pointers back to their referencing bpstat's, and
6700 teaching delete_breakpoint to only free a bp's storage when no more
6701 references were extent. A cheaper bandaid was chosen. */
6702 if (bpt->type == bp_none)
6705 if (delete_breakpoint_hook)
6706 delete_breakpoint_hook (bpt);
6707 breakpoint_delete_event (bpt->number);
6709 if (bpt->loc->inserted)
6710 remove_breakpoint (bpt->loc, mark_inserted);
6712 if (breakpoint_chain == bpt)
6713 breakpoint_chain = bpt->next;
6715 if (bp_location_chain == bpt->loc)
6716 bp_location_chain = bpt->loc->next;
6718 /* If we have callback-style exception catchpoints, don't go through
6719 the adjustments to the C++ runtime library etc. if the inferior
6720 isn't actually running. target_enable_exception_callback for a
6721 null target ops vector gives an undesirable error message, so we
6722 check here and avoid it. Since currently (1997-09-17) only HP-UX aCC's
6723 exceptions are supported in this way, it's OK for now. FIXME */
6724 if (ep_is_exception_catchpoint (bpt) && target_has_execution)
6726 /* Format possible error msg */
6727 char *message = xstrprintf ("Error in deleting catchpoint %d:\n",
6729 struct cleanup *cleanups = make_cleanup (xfree, message);
6730 args_for_catchpoint_enable args;
6731 args.kind = bpt->type == bp_catch_catch ?
6732 EX_EVENT_CATCH : EX_EVENT_THROW;
6734 catch_errors (cover_target_enable_exception_callback, &args,
6735 message, RETURN_MASK_ALL);
6736 do_cleanups (cleanups);
6743 b->next = bpt->next;
6747 ALL_BP_LOCATIONS (loc)
6748 if (loc->next == bpt->loc)
6750 loc->next = bpt->loc->next;
6754 check_duplicates (bpt);
6755 /* If this breakpoint was inserted, and there is another breakpoint
6756 at the same address, we need to insert the other breakpoint. */
6757 if (bpt->loc->inserted
6758 && bpt->type != bp_hardware_watchpoint
6759 && bpt->type != bp_read_watchpoint
6760 && bpt->type != bp_access_watchpoint
6761 && bpt->type != bp_catch_fork
6762 && bpt->type != bp_catch_vfork
6763 && bpt->type != bp_catch_exec)
6766 if (b->loc->address == bpt->loc->address
6767 && b->loc->section == bpt->loc->section
6768 && !b->loc->duplicate
6769 && b->enable_state != bp_disabled
6770 && b->enable_state != bp_shlib_disabled
6771 && b->enable_state != bp_call_disabled)
6775 /* We should never reach this point if there is a permanent
6776 breakpoint at the same address as the one being deleted.
6777 If there is a permanent breakpoint somewhere, it should
6778 always be the only one inserted. */
6779 if (b->enable_state == bp_permanent)
6780 internal_error (__FILE__, __LINE__,
6781 "another breakpoint was inserted on top of "
6782 "a permanent breakpoint");
6784 if (b->type == bp_hardware_breakpoint)
6785 val = target_insert_hw_breakpoint (b->loc->address, b->loc->shadow_contents);
6787 val = target_insert_breakpoint (b->loc->address, b->loc->shadow_contents);
6789 /* If there was an error in the insert, print a message, then stop execution. */
6792 struct ui_file *tmp_error_stream = mem_fileopen ();
6793 make_cleanup_ui_file_delete (tmp_error_stream);
6796 if (b->type == bp_hardware_breakpoint)
6798 fprintf_unfiltered (tmp_error_stream,
6799 "Cannot insert hardware breakpoint %d.\n"
6800 "You may have requested too many hardware breakpoints.\n",
6805 fprintf_unfiltered (tmp_error_stream, "Cannot insert breakpoint %d.\n", b->number);
6806 fprintf_filtered (tmp_error_stream, "Error accessing memory address ");
6807 print_address_numeric (b->loc->address, 1, tmp_error_stream);
6808 fprintf_filtered (tmp_error_stream, ": %s.\n",
6809 safe_strerror (val));
6812 fprintf_unfiltered (tmp_error_stream,"The same program may be running in another process.");
6813 target_terminal_ours_for_output ();
6814 error_stream(tmp_error_stream);
6817 b->loc->inserted = 1;
6821 free_command_lines (&bpt->commands);
6824 if (bpt->cond_string != NULL)
6825 xfree (bpt->cond_string);
6826 if (bpt->addr_string != NULL)
6827 xfree (bpt->addr_string);
6828 if (bpt->exp != NULL)
6830 if (bpt->exp_string != NULL)
6831 xfree (bpt->exp_string);
6832 if (bpt->val != NULL)
6833 value_free (bpt->val);
6834 if (bpt->source_file != NULL)
6835 xfree (bpt->source_file);
6836 if (bpt->dll_pathname != NULL)
6837 xfree (bpt->dll_pathname);
6838 if (bpt->triggered_dll_pathname != NULL)
6839 xfree (bpt->triggered_dll_pathname);
6840 if (bpt->exec_pathname != NULL)
6841 xfree (bpt->exec_pathname);
6843 /* Be sure no bpstat's are pointing at it after it's been freed. */
6844 /* FIXME, how can we find all bpstat's?
6845 We just check stop_bpstat for now. */
6846 for (bs = stop_bpstat; bs; bs = bs->next)
6847 if (bs->breakpoint_at == bpt)
6849 bs->breakpoint_at = NULL;
6851 /* bs->commands will be freed later. */
6853 /* On the chance that someone will soon try again to delete this same
6854 bp, we mark it as deleted before freeing its storage. */
6855 bpt->type = bp_none;
6862 do_delete_breakpoint_cleanup (void *b)
6864 delete_breakpoint (b);
6868 make_cleanup_delete_breakpoint (struct breakpoint *b)
6870 return make_cleanup (do_delete_breakpoint_cleanup, b);
6874 make_exec_cleanup_delete_breakpoint (struct breakpoint *b)
6876 return make_exec_cleanup (do_delete_breakpoint_cleanup, b);
6880 delete_command (char *arg, int from_tty)
6882 struct breakpoint *b, *temp;
6888 int breaks_to_delete = 0;
6890 /* Delete all breakpoints if no argument.
6891 Do not delete internal or call-dummy breakpoints, these
6892 have to be deleted with an explicit breakpoint number argument. */
6895 if (b->type != bp_call_dummy &&
6896 b->type != bp_shlib_event &&
6897 b->type != bp_thread_event &&
6898 b->type != bp_overlay_event &&
6900 breaks_to_delete = 1;
6903 /* Ask user only if there are some breakpoints to delete. */
6905 || (breaks_to_delete && query ("Delete all breakpoints? ")))
6907 ALL_BREAKPOINTS_SAFE (b, temp)
6909 if (b->type != bp_call_dummy &&
6910 b->type != bp_shlib_event &&
6911 b->type != bp_thread_event &&
6912 b->type != bp_overlay_event &&
6914 delete_breakpoint (b);
6919 map_breakpoint_numbers (arg, delete_breakpoint);
6922 /* Reset a breakpoint given it's struct breakpoint * BINT.
6923 The value we return ends up being the return value from catch_errors.
6924 Unused in this case. */
6927 breakpoint_re_set_one (void *bint)
6929 /* get past catch_errs */
6930 struct breakpoint *b = (struct breakpoint *) bint;
6933 struct symtabs_and_lines sals;
6935 enum enable_state save_enable;
6940 warning ("attempted to reset apparently deleted breakpoint #%d?",
6944 case bp_hardware_breakpoint:
6946 case bp_catch_unload:
6947 if (b->addr_string == NULL)
6949 /* Anything without a string can't be re-set. */
6950 delete_breakpoint (b);
6953 /* HACK: cagney/2001-11-11: kettenis/2001-11-11: MarkK wrote:
6955 ``And a hack it is, although Apple's Darwin version of GDB
6956 contains an almost identical hack to implement a "future
6957 break" command. It seems to work in many real world cases,
6958 but it is easy to come up with a test case where the patch
6959 doesn't help at all.''
6961 ``It seems that the way GDB implements breakpoints - in -
6962 shared - libraries was designed for a.out shared library
6963 systems (SunOS 4) where shared libraries were loaded at a
6964 fixed address in memory. Since ELF shared libraries can (and
6965 will) be loaded at any address in memory, things break.
6966 Fixing this is not trivial. Therefore, I'm not sure whether
6967 we should add this hack to the branch only. I cannot
6968 guarantee that things will be fixed on the trunk in the near
6971 In case we have a problem, disable this breakpoint. We'll
6972 restore its status if we succeed. Don't disable a
6973 shlib_disabled breakpoint though. There's a fair chance we
6974 can't re-set it if the shared library it's in hasn't been
6976 save_enable = b->enable_state;
6977 if (b->enable_state != bp_shlib_disabled)
6978 b->enable_state = bp_disabled;
6980 set_language (b->language);
6981 input_radix = b->input_radix;
6983 sals = decode_line_1 (&s, 1, (struct symtab *) NULL, 0, (char ***) NULL);
6984 for (i = 0; i < sals.nelts; i++)
6986 resolve_sal_pc (&sals.sals[i]);
6988 /* Reparse conditions, they might contain references to the
6990 if (b->cond_string != NULL)
6995 b->cond = parse_exp_1 (&s, block_for_pc (sals.sals[i].pc), 0);
6998 /* We need to re-set the breakpoint if the address changes... */
6999 if (b->loc->address != sals.sals[i].pc
7000 /* ...or new and old breakpoints both have source files, and
7001 the source file name or the line number changes... */
7002 || (b->source_file != NULL
7003 && sals.sals[i].symtab != NULL
7004 && (strcmp (b->source_file, sals.sals[i].symtab->filename) != 0
7005 || b->line_number != sals.sals[i].line)
7007 /* ...or we switch between having a source file and not having
7009 || ((b->source_file == NULL) != (sals.sals[i].symtab == NULL))
7012 if (b->source_file != NULL)
7013 xfree (b->source_file);
7014 if (sals.sals[i].symtab == NULL)
7015 b->source_file = NULL;
7018 savestring (sals.sals[i].symtab->filename,
7019 strlen (sals.sals[i].symtab->filename));
7020 b->line_number = sals.sals[i].line;
7021 b->loc->requested_address = sals.sals[i].pc;
7023 = adjust_breakpoint_address (b->loc->requested_address);
7025 /* Used to check for duplicates here, but that can
7026 cause trouble, as it doesn't check for disabled
7031 /* Might be better to do this just once per breakpoint_re_set,
7032 rather than once for every breakpoint. */
7033 breakpoints_changed ();
7035 b->loc->section = sals.sals[i].section;
7036 b->enable_state = save_enable; /* Restore it, this worked. */
7039 /* Now that this is re-enabled, check_duplicates
7041 check_duplicates (b);
7048 case bp_hardware_watchpoint:
7049 case bp_read_watchpoint:
7050 case bp_access_watchpoint:
7051 innermost_block = NULL;
7052 /* The issue arises of what context to evaluate this in. The
7053 same one as when it was set, but what does that mean when
7054 symbols have been re-read? We could save the filename and
7055 functionname, but if the context is more local than that, the
7056 best we could do would be something like how many levels deep
7057 and which index at that particular level, but that's going to
7058 be less stable than filenames or function names. */
7060 /* So for now, just use a global context. */
7063 b->exp = parse_expression (b->exp_string);
7064 b->exp_valid_block = innermost_block;
7065 mark = value_mark ();
7067 value_free (b->val);
7068 b->val = evaluate_expression (b->exp);
7069 release_value (b->val);
7070 if (VALUE_LAZY (b->val) && breakpoint_enabled (b))
7071 value_fetch_lazy (b->val);
7073 if (b->cond_string != NULL)
7078 b->cond = parse_exp_1 (&s, (struct block *) 0, 0);
7080 if (breakpoint_enabled (b))
7082 value_free_to_mark (mark);
7084 case bp_catch_catch:
7085 case bp_catch_throw:
7087 /* We needn't really do anything to reset these, since the mask
7088 that requests them is unaffected by e.g., new libraries being
7091 case bp_catch_vfork:
7096 printf_filtered ("Deleting unknown breakpoint type %d\n", b->type);
7098 /* Delete longjmp and overlay event breakpoints; they will be
7099 reset later by breakpoint_re_set. */
7101 case bp_longjmp_resume:
7102 case bp_overlay_event:
7103 delete_breakpoint (b);
7106 /* This breakpoint is special, it's set up when the inferior
7107 starts and we really don't want to touch it. */
7108 case bp_shlib_event:
7110 /* Like bp_shlib_event, this breakpoint type is special.
7111 Once it is set up, we do not want to touch it. */
7112 case bp_thread_event:
7114 /* Keep temporary breakpoints, which can be encountered when we step
7115 over a dlopen call and SOLIB_ADD is resetting the breakpoints.
7116 Otherwise these should have been blown away via the cleanup chain
7117 or by breakpoint_init_inferior when we rerun the executable. */
7120 case bp_watchpoint_scope:
7122 case bp_step_resume:
7129 /* Re-set all breakpoints after symbols have been re-loaded. */
7131 breakpoint_re_set (void)
7133 struct breakpoint *b, *temp;
7134 enum language save_language;
7135 int save_input_radix;
7137 save_language = current_language->la_language;
7138 save_input_radix = input_radix;
7139 ALL_BREAKPOINTS_SAFE (b, temp)
7141 /* Format possible error msg */
7142 char *message = xstrprintf ("Error in re-setting breakpoint %d:\n",
7144 struct cleanup *cleanups = make_cleanup (xfree, message);
7145 catch_errors (breakpoint_re_set_one, b, message, RETURN_MASK_ALL);
7146 do_cleanups (cleanups);
7148 set_language (save_language);
7149 input_radix = save_input_radix;
7151 if (GET_LONGJMP_TARGET_P ())
7153 create_longjmp_breakpoint ("longjmp");
7154 create_longjmp_breakpoint ("_longjmp");
7155 create_longjmp_breakpoint ("siglongjmp");
7156 create_longjmp_breakpoint ("_siglongjmp");
7157 create_longjmp_breakpoint (NULL);
7160 create_overlay_event_breakpoint ("_ovly_debug_event");
7163 /* Reset the thread number of this breakpoint:
7165 - If the breakpoint is for all threads, leave it as-is.
7166 - Else, reset it to the current thread for inferior_ptid. */
7168 breakpoint_re_set_thread (struct breakpoint *b)
7170 if (b->thread != -1)
7172 if (in_thread_list (inferior_ptid))
7173 b->thread = pid_to_thread_id (inferior_ptid);
7177 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
7178 If from_tty is nonzero, it prints a message to that effect,
7179 which ends with a period (no newline). */
7182 set_ignore_count (int bptnum, int count, int from_tty)
7184 struct breakpoint *b;
7190 if (b->number == bptnum)
7192 b->ignore_count = count;
7196 printf_filtered ("Will stop next time breakpoint %d is reached.",
7198 else if (count == 1)
7199 printf_filtered ("Will ignore next crossing of breakpoint %d.",
7202 printf_filtered ("Will ignore next %d crossings of breakpoint %d.",
7205 breakpoints_changed ();
7206 breakpoint_modify_event (b->number);
7210 error ("No breakpoint number %d.", bptnum);
7213 /* Clear the ignore counts of all breakpoints. */
7215 breakpoint_clear_ignore_counts (void)
7217 struct breakpoint *b;
7220 b->ignore_count = 0;
7223 /* Command to set ignore-count of breakpoint N to COUNT. */
7226 ignore_command (char *args, int from_tty)
7232 error_no_arg ("a breakpoint number");
7234 num = get_number (&p);
7236 error ("bad breakpoint number: '%s'", args);
7238 error ("Second argument (specified ignore-count) is missing.");
7240 set_ignore_count (num,
7241 longest_to_int (value_as_long (parse_and_eval (p))),
7244 printf_filtered ("\n");
7247 /* Call FUNCTION on each of the breakpoints
7248 whose numbers are given in ARGS. */
7251 map_breakpoint_numbers (char *args, void (*function) (struct breakpoint *))
7256 struct breakpoint *b, *tmp;
7260 error_no_arg ("one or more breakpoint numbers");
7267 num = get_number_or_range (&p1);
7270 warning ("bad breakpoint number at or near '%s'", p);
7274 ALL_BREAKPOINTS_SAFE (b, tmp)
7275 if (b->number == num)
7277 struct breakpoint *related_breakpoint = b->related_breakpoint;
7280 if (related_breakpoint)
7281 function (related_breakpoint);
7285 printf_unfiltered ("No breakpoint number %d.\n", num);
7291 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
7292 If from_tty is nonzero, it prints a message to that effect,
7293 which ends with a period (no newline). */
7296 disable_breakpoint (struct breakpoint *bpt)
7298 /* Never disable a watchpoint scope breakpoint; we want to
7299 hit them when we leave scope so we can delete both the
7300 watchpoint and its scope breakpoint at that time. */
7301 if (bpt->type == bp_watchpoint_scope)
7304 /* You can't disable permanent breakpoints. */
7305 if (bpt->enable_state == bp_permanent)
7308 bpt->enable_state = bp_disabled;
7310 check_duplicates (bpt);
7312 if (modify_breakpoint_hook)
7313 modify_breakpoint_hook (bpt);
7314 breakpoint_modify_event (bpt->number);
7318 disable_command (char *args, int from_tty)
7320 struct breakpoint *bpt;
7322 ALL_BREAKPOINTS (bpt)
7326 warning ("attempted to disable apparently deleted breakpoint #%d?",
7331 case bp_catch_unload:
7333 case bp_catch_vfork:
7335 case bp_catch_catch:
7336 case bp_catch_throw:
7337 case bp_hardware_breakpoint:
7339 case bp_hardware_watchpoint:
7340 case bp_read_watchpoint:
7341 case bp_access_watchpoint:
7342 disable_breakpoint (bpt);
7347 map_breakpoint_numbers (args, disable_breakpoint);
7351 do_enable_breakpoint (struct breakpoint *bpt, enum bpdisp disposition)
7353 struct frame_info *save_selected_frame = NULL;
7354 int save_selected_frame_level = -1;
7355 int target_resources_ok, other_type_used;
7358 if (bpt->type == bp_hardware_breakpoint)
7361 i = hw_breakpoint_used_count ();
7362 target_resources_ok =
7363 TARGET_CAN_USE_HARDWARE_WATCHPOINT (bp_hardware_breakpoint,
7365 if (target_resources_ok == 0)
7366 error ("No hardware breakpoint support in the target.");
7367 else if (target_resources_ok < 0)
7368 error ("Hardware breakpoints used exceeds limit.");
7371 if (bpt->enable_state != bp_permanent)
7372 bpt->enable_state = bp_enabled;
7373 bpt->disposition = disposition;
7374 check_duplicates (bpt);
7375 breakpoints_changed ();
7377 if (bpt->type == bp_watchpoint ||
7378 bpt->type == bp_hardware_watchpoint ||
7379 bpt->type == bp_read_watchpoint ||
7380 bpt->type == bp_access_watchpoint)
7382 if (bpt->exp_valid_block != NULL)
7384 struct frame_info *fr =
7385 fr = frame_find_by_id (bpt->watchpoint_frame);
7389 Cannot enable watchpoint %d because the block in which its expression\n\
7390 is valid is not currently in scope.\n", bpt->number);
7391 bpt->enable_state = bp_disabled;
7395 save_selected_frame = deprecated_selected_frame;
7396 save_selected_frame_level = frame_relative_level (deprecated_selected_frame);
7400 value_free (bpt->val);
7401 mark = value_mark ();
7402 bpt->val = evaluate_expression (bpt->exp);
7403 release_value (bpt->val);
7404 if (VALUE_LAZY (bpt->val))
7405 value_fetch_lazy (bpt->val);
7407 if (bpt->type == bp_hardware_watchpoint ||
7408 bpt->type == bp_read_watchpoint ||
7409 bpt->type == bp_access_watchpoint)
7411 int i = hw_watchpoint_used_count (bpt->type, &other_type_used);
7412 int mem_cnt = can_use_hardware_watchpoint (bpt->val);
7414 /* Hack around 'unused var' error for some targets here */
7416 target_resources_ok = TARGET_CAN_USE_HARDWARE_WATCHPOINT (
7417 bpt->type, i + mem_cnt, other_type_used);
7418 /* we can consider of type is bp_hardware_watchpoint, convert to
7419 bp_watchpoint in the following condition */
7420 if (target_resources_ok < 0)
7423 Cannot enable watchpoint %d because target watch resources\n\
7424 have been allocated for other watchpoints.\n", bpt->number);
7425 bpt->enable_state = bp_disabled;
7426 value_free_to_mark (mark);
7431 if (save_selected_frame_level >= 0)
7432 select_frame (save_selected_frame);
7433 value_free_to_mark (mark);
7435 if (modify_breakpoint_hook)
7436 modify_breakpoint_hook (bpt);
7437 breakpoint_modify_event (bpt->number);
7441 enable_breakpoint (struct breakpoint *bpt)
7443 do_enable_breakpoint (bpt, bpt->disposition);
7446 /* The enable command enables the specified breakpoints (or all defined
7447 breakpoints) so they once again become (or continue to be) effective
7448 in stopping the inferior. */
7451 enable_command (char *args, int from_tty)
7453 struct breakpoint *bpt;
7455 ALL_BREAKPOINTS (bpt)
7459 warning ("attempted to enable apparently deleted breakpoint #%d?",
7464 case bp_catch_unload:
7466 case bp_catch_vfork:
7468 case bp_catch_catch:
7469 case bp_catch_throw:
7470 case bp_hardware_breakpoint:
7472 case bp_hardware_watchpoint:
7473 case bp_read_watchpoint:
7474 case bp_access_watchpoint:
7475 enable_breakpoint (bpt);
7480 map_breakpoint_numbers (args, enable_breakpoint);
7484 enable_once_breakpoint (struct breakpoint *bpt)
7486 do_enable_breakpoint (bpt, disp_disable);
7490 enable_once_command (char *args, int from_tty)
7492 map_breakpoint_numbers (args, enable_once_breakpoint);
7496 enable_delete_breakpoint (struct breakpoint *bpt)
7498 do_enable_breakpoint (bpt, disp_del);
7502 enable_delete_command (char *args, int from_tty)
7504 map_breakpoint_numbers (args, enable_delete_breakpoint);
7507 /* Use default_breakpoint_'s, or nothing if they aren't valid. */
7509 struct symtabs_and_lines
7510 decode_line_spec_1 (char *string, int funfirstline)
7512 struct symtabs_and_lines sals;
7514 error ("Empty line specification.");
7515 if (default_breakpoint_valid)
7516 sals = decode_line_1 (&string, funfirstline,
7517 default_breakpoint_symtab,
7518 default_breakpoint_line,
7521 sals = decode_line_1 (&string, funfirstline,
7522 (struct symtab *) NULL, 0, (char ***) NULL);
7524 error ("Junk at end of line specification: %s", string);
7529 _initialize_breakpoint (void)
7531 struct cmd_list_element *c;
7533 breakpoint_chain = 0;
7534 /* Don't bother to call set_breakpoint_count. $bpnum isn't useful
7535 before a breakpoint is set. */
7536 breakpoint_count = 0;
7538 add_com ("ignore", class_breakpoint, ignore_command,
7539 "Set ignore-count of breakpoint number N to COUNT.\n\
7540 Usage is `ignore N COUNT'.");
7542 add_com_alias ("bc", "ignore", class_breakpoint, 1);
7544 add_com ("commands", class_breakpoint, commands_command,
7545 "Set commands to be executed when a breakpoint is hit.\n\
7546 Give breakpoint number as argument after \"commands\".\n\
7547 With no argument, the targeted breakpoint is the last one set.\n\
7548 The commands themselves follow starting on the next line.\n\
7549 Type a line containing \"end\" to indicate the end of them.\n\
7550 Give \"silent\" as the first line to make the breakpoint silent;\n\
7551 then no output is printed when it is hit, except what the commands print.");
7553 add_com ("condition", class_breakpoint, condition_command,
7554 "Specify breakpoint number N to break only if COND is true.\n\
7555 Usage is `condition N COND', where N is an integer and COND is an\n\
7556 expression to be evaluated whenever breakpoint N is reached.");
7558 c = add_com ("tbreak", class_breakpoint, tbreak_command,
7559 "Set a temporary breakpoint. Args like \"break\" command.\n\
7560 Like \"break\" except the breakpoint is only temporary,\n\
7561 so it will be deleted when hit. Equivalent to \"break\" followed\n\
7562 by using \"enable delete\" on the breakpoint number.");
7563 set_cmd_completer (c, location_completer);
7565 c = add_com ("hbreak", class_breakpoint, hbreak_command,
7566 "Set a hardware assisted breakpoint. Args like \"break\" command.\n\
7567 Like \"break\" except the breakpoint requires hardware support,\n\
7568 some target hardware may not have this support.");
7569 set_cmd_completer (c, location_completer);
7571 c = add_com ("thbreak", class_breakpoint, thbreak_command,
7572 "Set a temporary hardware assisted breakpoint. Args like \"break\" command.\n\
7573 Like \"hbreak\" except the breakpoint is only temporary,\n\
7574 so it will be deleted when hit.");
7575 set_cmd_completer (c, location_completer);
7577 add_prefix_cmd ("enable", class_breakpoint, enable_command,
7578 "Enable some breakpoints.\n\
7579 Give breakpoint numbers (separated by spaces) as arguments.\n\
7580 With no subcommand, breakpoints are enabled until you command otherwise.\n\
7581 This is used to cancel the effect of the \"disable\" command.\n\
7582 With a subcommand you can enable temporarily.",
7583 &enablelist, "enable ", 1, &cmdlist);
7585 add_com ("ab", class_breakpoint, enable_command,
7586 "Enable some breakpoints.\n\
7587 Give breakpoint numbers (separated by spaces) as arguments.\n\
7588 With no subcommand, breakpoints are enabled until you command otherwise.\n\
7589 This is used to cancel the effect of the \"disable\" command.\n\
7590 With a subcommand you can enable temporarily.");
7592 add_com_alias ("en", "enable", class_breakpoint, 1);
7594 add_abbrev_prefix_cmd ("breakpoints", class_breakpoint, enable_command,
7595 "Enable some breakpoints.\n\
7596 Give breakpoint numbers (separated by spaces) as arguments.\n\
7597 This is used to cancel the effect of the \"disable\" command.\n\
7598 May be abbreviated to simply \"enable\".\n",
7599 &enablebreaklist, "enable breakpoints ", 1, &enablelist);
7601 add_cmd ("once", no_class, enable_once_command,
7602 "Enable breakpoints for one hit. Give breakpoint numbers.\n\
7603 If a breakpoint is hit while enabled in this fashion, it becomes disabled.",
7606 add_cmd ("delete", no_class, enable_delete_command,
7607 "Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
7608 If a breakpoint is hit while enabled in this fashion, it is deleted.",
7611 add_cmd ("delete", no_class, enable_delete_command,
7612 "Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
7613 If a breakpoint is hit while enabled in this fashion, it is deleted.",
7616 add_cmd ("once", no_class, enable_once_command,
7617 "Enable breakpoints for one hit. Give breakpoint numbers.\n\
7618 If a breakpoint is hit while enabled in this fashion, it becomes disabled.",
7621 add_prefix_cmd ("disable", class_breakpoint, disable_command,
7622 "Disable some breakpoints.\n\
7623 Arguments are breakpoint numbers with spaces in between.\n\
7624 To disable all breakpoints, give no argument.\n\
7625 A disabled breakpoint is not forgotten, but has no effect until reenabled.",
7626 &disablelist, "disable ", 1, &cmdlist);
7627 add_com_alias ("dis", "disable", class_breakpoint, 1);
7628 add_com_alias ("disa", "disable", class_breakpoint, 1);
7630 add_com ("sb", class_breakpoint, disable_command,
7631 "Disable some breakpoints.\n\
7632 Arguments are breakpoint numbers with spaces in between.\n\
7633 To disable all breakpoints, give no argument.\n\
7634 A disabled breakpoint is not forgotten, but has no effect until reenabled.");
7636 add_cmd ("breakpoints", class_alias, disable_command,
7637 "Disable some breakpoints.\n\
7638 Arguments are breakpoint numbers with spaces in between.\n\
7639 To disable all breakpoints, give no argument.\n\
7640 A disabled breakpoint is not forgotten, but has no effect until reenabled.\n\
7641 This command may be abbreviated \"disable\".",
7644 add_prefix_cmd ("delete", class_breakpoint, delete_command,
7645 "Delete some breakpoints or auto-display expressions.\n\
7646 Arguments are breakpoint numbers with spaces in between.\n\
7647 To delete all breakpoints, give no argument.\n\
7649 Also a prefix command for deletion of other GDB objects.\n\
7650 The \"unset\" command is also an alias for \"delete\".",
7651 &deletelist, "delete ", 1, &cmdlist);
7652 add_com_alias ("d", "delete", class_breakpoint, 1);
7654 add_com ("db", class_breakpoint, delete_command,
7655 "Delete some breakpoints.\n\
7656 Arguments are breakpoint numbers with spaces in between.\n\
7657 To delete all breakpoints, give no argument.\n");
7659 add_cmd ("breakpoints", class_alias, delete_command,
7660 "Delete some breakpoints or auto-display expressions.\n\
7661 Arguments are breakpoint numbers with spaces in between.\n\
7662 To delete all breakpoints, give no argument.\n\
7663 This command may be abbreviated \"delete\".",
7666 add_com ("clear", class_breakpoint, clear_command,
7667 concat ("Clear breakpoint at specified line or function.\n\
7668 Argument may be line number, function name, or \"*\" and an address.\n\
7669 If line number is specified, all breakpoints in that line are cleared.\n\
7670 If function is specified, breakpoints at beginning of function are cleared.\n\
7671 If an address is specified, breakpoints at that address are cleared.\n\n",
7672 "With no argument, clears all breakpoints in the line that the selected frame\n\
7675 See also the \"delete\" command which clears breakpoints by number.", NULL));
7677 c = add_com ("break", class_breakpoint, break_command,
7678 concat ("Set breakpoint at specified line or function.\n\
7679 Argument may be line number, function name, or \"*\" and an address.\n\
7680 If line number is specified, break at start of code for that line.\n\
7681 If function is specified, break at start of code for that function.\n\
7682 If an address is specified, break at that exact address.\n",
7683 "With no arg, uses current execution address of selected stack frame.\n\
7684 This is useful for breaking on return to a stack frame.\n\
7686 Multiple breakpoints at one place are permitted, and useful if conditional.\n\
7688 Do \"help breakpoints\" for info on other commands dealing with breakpoints.", NULL));
7689 set_cmd_completer (c, location_completer);
7691 add_com_alias ("b", "break", class_run, 1);
7692 add_com_alias ("br", "break", class_run, 1);
7693 add_com_alias ("bre", "break", class_run, 1);
7694 add_com_alias ("brea", "break", class_run, 1);
7698 add_com_alias ("ba", "break", class_breakpoint, 1);
7699 add_com_alias ("bu", "ubreak", class_breakpoint, 1);
7704 add_abbrev_prefix_cmd ("stop", class_breakpoint, stop_command,
7705 "Break in function/address or break at a line in the current file.",
7706 &stoplist, "stop ", 1, &cmdlist);
7707 add_cmd ("in", class_breakpoint, stopin_command,
7708 "Break in function or address.\n", &stoplist);
7709 add_cmd ("at", class_breakpoint, stopat_command,
7710 "Break at a line in the current file.\n", &stoplist);
7711 add_com ("status", class_info, breakpoints_info,
7712 concat ("Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
7713 The \"Type\" column indicates one of:\n\
7714 \tbreakpoint - normal breakpoint\n\
7715 \twatchpoint - watchpoint\n\
7716 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
7717 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
7718 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
7719 address and file/line number respectively.\n\n",
7720 "Convenience variable \"$_\" and default examine address for \"x\"\n\
7721 are set to the address of the last breakpoint listed.\n\n\
7722 Convenience variable \"$bpnum\" contains the number of the last\n\
7723 breakpoint set.", NULL));
7726 add_info ("breakpoints", breakpoints_info,
7727 concat ("Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
7728 The \"Type\" column indicates one of:\n\
7729 \tbreakpoint - normal breakpoint\n\
7730 \twatchpoint - watchpoint\n\
7731 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
7732 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
7733 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
7734 address and file/line number respectively.\n\n",
7735 "Convenience variable \"$_\" and default examine address for \"x\"\n\
7736 are set to the address of the last breakpoint listed.\n\n\
7737 Convenience variable \"$bpnum\" contains the number of the last\n\
7738 breakpoint set.", NULL));
7741 add_com ("lb", class_breakpoint, breakpoints_info,
7742 concat ("Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
7743 The \"Type\" column indicates one of:\n\
7744 \tbreakpoint - normal breakpoint\n\
7745 \twatchpoint - watchpoint\n\
7746 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
7747 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
7748 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
7749 address and file/line number respectively.\n\n",
7750 "Convenience variable \"$_\" and default examine address for \"x\"\n\
7751 are set to the address of the last breakpoint listed.\n\n\
7752 Convenience variable \"$bpnum\" contains the number of the last\n\
7753 breakpoint set.", NULL));
7755 add_cmd ("breakpoints", class_maintenance, maintenance_info_breakpoints,
7756 concat ("Status of all breakpoints, or breakpoint number NUMBER.\n\
7757 The \"Type\" column indicates one of:\n\
7758 \tbreakpoint - normal breakpoint\n\
7759 \twatchpoint - watchpoint\n\
7760 \tlongjmp - internal breakpoint used to step through longjmp()\n\
7761 \tlongjmp resume - internal breakpoint at the target of longjmp()\n\
7762 \tuntil - internal breakpoint used by the \"until\" command\n\
7763 \tfinish - internal breakpoint used by the \"finish\" command\n",
7764 "The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
7765 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
7766 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
7767 address and file/line number respectively.\n\n",
7768 "Convenience variable \"$_\" and default examine address for \"x\"\n\
7769 are set to the address of the last breakpoint listed.\n\n\
7770 Convenience variable \"$bpnum\" contains the number of the last\n\
7771 breakpoint set.", NULL),
7772 &maintenanceinfolist);
7774 add_com ("catch", class_breakpoint, catch_command,
7775 "Set catchpoints to catch events.\n\
7776 Raised signals may be caught:\n\
7777 \tcatch signal - all signals\n\
7778 \tcatch signal <signame> - a particular signal\n\
7779 Raised exceptions may be caught:\n\
7780 \tcatch throw - all exceptions, when thrown\n\
7781 \tcatch throw <exceptname> - a particular exception, when thrown\n\
7782 \tcatch catch - all exceptions, when caught\n\
7783 \tcatch catch <exceptname> - a particular exception, when caught\n\
7784 Thread or process events may be caught:\n\
7785 \tcatch thread_start - any threads, just after creation\n\
7786 \tcatch thread_exit - any threads, just before expiration\n\
7787 \tcatch thread_join - any threads, just after joins\n\
7788 Process events may be caught:\n\
7789 \tcatch start - any processes, just after creation\n\
7790 \tcatch exit - any processes, just before expiration\n\
7791 \tcatch fork - calls to fork()\n\
7792 \tcatch vfork - calls to vfork()\n\
7793 \tcatch exec - calls to exec()\n\
7794 Dynamically-linked library events may be caught:\n\
7795 \tcatch load - loads of any library\n\
7796 \tcatch load <libname> - loads of a particular library\n\
7797 \tcatch unload - unloads of any library\n\
7798 \tcatch unload <libname> - unloads of a particular library\n\
7799 The act of your program's execution stopping may also be caught:\n\
7801 C++ exceptions may be caught:\n\
7802 \tcatch throw - all exceptions, when thrown\n\
7803 \tcatch catch - all exceptions, when caught\n\
7805 Do \"help set follow-fork-mode\" for info on debugging your program\n\
7806 after a fork or vfork is caught.\n\n\
7807 Do \"help breakpoints\" for info on other commands dealing with breakpoints.");
7809 add_com ("tcatch", class_breakpoint, tcatch_command,
7810 "Set temporary catchpoints to catch events.\n\
7811 Args like \"catch\" command.\n\
7812 Like \"catch\" except the catchpoint is only temporary,\n\
7813 so it will be deleted when hit. Equivalent to \"catch\" followed\n\
7814 by using \"enable delete\" on the catchpoint number.");
7816 c = add_com ("watch", class_breakpoint, watch_command,
7817 "Set a watchpoint for an expression.\n\
7818 A watchpoint stops execution of your program whenever the value of\n\
7819 an expression changes.");
7820 set_cmd_completer (c, location_completer);
7822 c = add_com ("rwatch", class_breakpoint, rwatch_command,
7823 "Set a read watchpoint for an expression.\n\
7824 A watchpoint stops execution of your program whenever the value of\n\
7825 an expression is read.");
7826 set_cmd_completer (c, location_completer);
7828 c = add_com ("awatch", class_breakpoint, awatch_command,
7829 "Set a watchpoint for an expression.\n\
7830 A watchpoint stops execution of your program whenever the value of\n\
7831 an expression is either read or written.");
7832 set_cmd_completer (c, location_completer);
7834 add_info ("watchpoints", breakpoints_info,
7835 "Synonym for ``info breakpoints''.");
7838 c = add_set_cmd ("can-use-hw-watchpoints", class_support, var_zinteger,
7839 (char *) &can_use_hw_watchpoints,
7840 "Set debugger's willingness to use watchpoint hardware.\n\
7841 If zero, gdb will not use hardware for new watchpoints, even if\n\
7842 such is available. (However, any hardware watchpoints that were\n\
7843 created before setting this to nonzero, will continue to use watchpoint\n\
7846 add_show_from_set (c, &showlist);
7848 can_use_hw_watchpoints = 1;