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 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"
45 #include "completer.h"
49 #include "gdb-events.h"
51 /* Prototypes for local functions. */
53 static void until_break_command_continuation (struct continuation_arg *arg);
55 static void catch_command_1 (char *, int, int);
57 static void enable_delete_command (char *, int);
59 static void enable_delete_breakpoint (struct breakpoint *);
61 static void enable_once_command (char *, int);
63 static void enable_once_breakpoint (struct breakpoint *);
65 static void disable_command (char *, int);
67 static void enable_command (char *, int);
69 static void map_breakpoint_numbers (char *, void (*)(struct breakpoint *));
71 static void ignore_command (char *, int);
73 static int breakpoint_re_set_one (PTR);
75 static void clear_command (char *, int);
77 static void catch_command (char *, int);
79 static void handle_gnu_4_16_catch_command (char *, int, int);
81 static struct symtabs_and_lines get_catch_sals (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 describe_other_breakpoints (CORE_ADDR, asection *);
102 static void breakpoints_info (char *, int);
104 static void breakpoint_1 (int, int);
106 static bpstat bpstat_alloc (struct breakpoint *, bpstat);
108 static int breakpoint_cond_eval (PTR);
110 static void cleanup_executing_breakpoints (PTR);
112 static void commands_command (char *, int);
114 static void condition_command (char *, int);
116 static int get_number_trailer (char **, int);
118 void set_breakpoint_count (int);
127 static int remove_breakpoint (struct breakpoint *, insertion_state_t);
129 static enum print_stop_action print_it_typical (bpstat);
131 static enum print_stop_action print_bp_stop_message (bpstat bs);
135 enum exception_event_kind kind;
138 args_for_catchpoint_enable;
140 static int watchpoint_check (PTR);
142 static int cover_target_enable_exception_callback (PTR);
144 static void maintenance_info_breakpoints (char *, int);
146 static void create_longjmp_breakpoint (char *);
148 static void create_overlay_event_breakpoint (char *);
150 static int hw_breakpoint_used_count (void);
152 static int hw_watchpoint_used_count (enum bptype, int *);
154 static void hbreak_command (char *, int);
156 static void thbreak_command (char *, int);
158 static void watch_command_1 (char *, int, int);
160 static void rwatch_command (char *, int);
162 static void awatch_command (char *, int);
164 static void do_enable_breakpoint (struct breakpoint *, enum bpdisp);
166 static void solib_load_unload_1 (char *hookname,
169 char *cond_string, enum bptype bp_kind);
171 static void create_fork_vfork_event_catchpoint (int tempflag,
173 enum bptype bp_kind);
175 static void break_at_finish_at_depth_command_1 (char *arg,
176 int flag, int from_tty);
178 static void break_at_finish_command_1 (char *arg, int flag, int from_tty);
180 static void stop_command (char *arg, int from_tty);
182 static void stopin_command (char *arg, int from_tty);
184 static void stopat_command (char *arg, int from_tty);
186 static char *ep_find_event_name_end (char *arg);
188 static char *ep_parse_optional_if_clause (char **arg);
190 static char *ep_parse_optional_filename (char **arg);
192 #if defined(CHILD_INSERT_EXEC_CATCHPOINT)
193 static void catch_exec_command_1 (char *arg, int tempflag, int from_tty);
196 static void create_exception_catchpoint (int tempflag, char *cond_string,
197 enum exception_event_kind ex_event,
198 struct symtab_and_line *sal);
200 static void catch_exception_command_1 (enum exception_event_kind ex_event,
201 char *arg, int tempflag, int from_tty);
203 static void tcatch_command (char *arg, int from_tty);
205 static void ep_skip_leading_whitespace (char **s);
207 /* Prototypes for exported functions. */
209 /* If FALSE, gdb will not use hardware support for watchpoints, even
210 if such is available. */
211 static int can_use_hw_watchpoints;
213 void _initialize_breakpoint (void);
215 extern int addressprint; /* Print machine addresses? */
217 /* Are we executing breakpoint commands? */
218 static int executing_breakpoint_commands;
220 /* Are overlay event breakpoints enabled? */
221 static int overlay_events_enabled;
223 /* Walk the following statement or block through all breakpoints.
224 ALL_BREAKPOINTS_SAFE does so even if the statment deletes the current
227 #define ALL_BREAKPOINTS(B) for (B = breakpoint_chain; B; B = B->next)
229 #define ALL_BREAKPOINTS_SAFE(B,TMP) \
230 for (B = breakpoint_chain; \
231 B ? (TMP=B->next, 1): 0; \
234 /* True if SHIFT_INST_REGS defined, false otherwise. */
236 int must_shift_inst_regs =
237 #if defined(SHIFT_INST_REGS)
244 /* True if breakpoint hit counts should be displayed in breakpoint info. */
246 int show_breakpoint_hit_counts = 1;
248 /* Chain of all breakpoints defined. */
250 struct breakpoint *breakpoint_chain;
252 /* Number of last breakpoint made. */
254 int breakpoint_count;
256 /* Pointer to current exception event record */
257 static struct exception_event_record *current_exception_event;
259 /* Indicator of whether exception catchpoints should be nuked
260 between runs of a program */
261 int exception_catchpoints_are_fragile = 0;
263 /* Indicator of when exception catchpoints set-up should be
264 reinitialized -- e.g. when program is re-run */
265 int exception_support_initialized = 0;
267 /* This function returns a pointer to the string representation of the
268 pathname of the dynamically-linked library that has just been
271 This function must be used only when SOLIB_HAVE_LOAD_EVENT is TRUE,
272 or undefined results are guaranteed.
274 This string's contents are only valid immediately after the
275 inferior has stopped in the dynamic linker hook, and becomes
276 invalid as soon as the inferior is continued. Clients should make
277 a copy of this string if they wish to continue the inferior and
278 then access the string. */
280 #ifndef SOLIB_LOADED_LIBRARY_PATHNAME
281 #define SOLIB_LOADED_LIBRARY_PATHNAME(pid) ""
284 /* This function returns a pointer to the string representation of the
285 pathname of the dynamically-linked library that has just been
288 This function must be used only when SOLIB_HAVE_UNLOAD_EVENT is
289 TRUE, or undefined results are guaranteed.
291 This string's contents are only valid immediately after the
292 inferior has stopped in the dynamic linker hook, and becomes
293 invalid as soon as the inferior is continued. Clients should make
294 a copy of this string if they wish to continue the inferior and
295 then access the string. */
297 #ifndef SOLIB_UNLOADED_LIBRARY_PATHNAME
298 #define SOLIB_UNLOADED_LIBRARY_PATHNAME(pid) ""
301 /* This function is called by the "catch load" command. It allows the
302 debugger to be notified by the dynamic linker when a specified
303 library file (or any library file, if filename is NULL) is loaded. */
305 #ifndef SOLIB_CREATE_CATCH_LOAD_HOOK
306 #define SOLIB_CREATE_CATCH_LOAD_HOOK(pid,tempflag,filename,cond_string) \
307 error ("catch of library loads not yet implemented on this platform")
310 /* This function is called by the "catch unload" command. It allows
311 the debugger to be notified by the dynamic linker when a specified
312 library file (or any library file, if filename is NULL) is
315 #ifndef SOLIB_CREATE_CATCH_UNLOAD_HOOK
316 #define SOLIB_CREATE_CATCH_UNLOAD_HOOK(pid,tempflag,filename,cond_string) \
317 error ("catch of library unloads not yet implemented on this platform")
320 /* Set breakpoint count to NUM. */
323 set_breakpoint_count (int num)
325 breakpoint_count = num;
326 set_internalvar (lookup_internalvar ("bpnum"),
327 value_from_longest (builtin_type_int, (LONGEST) num));
330 /* Used in run_command to zero the hit count when a new run starts. */
333 clear_breakpoint_hit_counts (void)
335 struct breakpoint *b;
341 /* Default address, symtab and line to put a breakpoint at
342 for "break" command with no arg.
343 if default_breakpoint_valid is zero, the other three are
344 not valid, and "break" with no arg is an error.
346 This set by print_stack_frame, which calls set_default_breakpoint. */
348 int default_breakpoint_valid;
349 CORE_ADDR default_breakpoint_address;
350 struct symtab *default_breakpoint_symtab;
351 int default_breakpoint_line;
353 /* *PP is a string denoting a breakpoint. Get the number of the breakpoint.
354 Advance *PP after the string and any trailing whitespace.
356 Currently the string can either be a number or "$" followed by the name
357 of a convenience variable. Making it an expression wouldn't work well
358 for map_breakpoint_numbers (e.g. "4 + 5 + 6").
360 TRAILER is a character which can be found after the number; most
361 commonly this is `-'. If you don't want a trailer, use \0. */
363 get_number_trailer (char **pp, int trailer)
365 int retval = 0; /* default */
369 /* Empty line means refer to the last breakpoint. */
370 return breakpoint_count;
373 /* Make a copy of the name, so we can null-terminate it
374 to pass to lookup_internalvar(). */
379 while (isalnum (*p) || *p == '_')
381 varname = (char *) alloca (p - start + 1);
382 strncpy (varname, start, p - start);
383 varname[p - start] = '\0';
384 val = value_of_internalvar (lookup_internalvar (varname));
385 if (TYPE_CODE (VALUE_TYPE (val)) == TYPE_CODE_INT)
386 retval = (int) value_as_long (val);
389 printf_filtered ("Convenience variable must have integer value.\n");
397 while (*p >= '0' && *p <= '9')
400 /* There is no number here. (e.g. "cond a == b"). */
402 /* Skip non-numeric token */
403 while (*p && !isspace((int) *p))
405 /* Return zero, which caller must interpret as error. */
411 if (!(isspace (*p) || *p == '\0' || *p == trailer))
413 /* Trailing junk: return 0 and let caller print error msg. */
414 while (!(isspace (*p) || *p == '\0' || *p == trailer))
425 /* Like get_number_trailer, but don't allow a trailer. */
427 get_number (char **pp)
429 return get_number_trailer (pp, '\0');
432 /* Parse a number or a range.
433 * A number will be of the form handled by get_number.
434 * A range will be of the form <number1> - <number2>, and
435 * will represent all the integers between number1 and number2,
438 * While processing a range, this fuction is called iteratively;
439 * At each call it will return the next value in the range.
441 * At the beginning of parsing a range, the char pointer PP will
442 * be advanced past <number1> and left pointing at the '-' token.
443 * Subsequent calls will not advance the pointer until the range
444 * is completed. The call that completes the range will advance
445 * pointer PP past <number2>.
449 get_number_or_range (char **pp)
451 static int last_retval, end_value;
452 static char *end_ptr;
453 static int in_range = 0;
457 /* Default case: pp is pointing either to a solo number,
458 or to the first number of a range. */
459 last_retval = get_number_trailer (pp, '-');
464 /* This is the start of a range (<number1> - <number2>).
465 Skip the '-', parse and remember the second number,
466 and also remember the end of the final token. */
470 while (isspace ((int) *end_ptr))
471 end_ptr++; /* skip white space */
472 end_value = get_number (temp);
473 if (end_value < last_retval)
475 error ("inverted range");
477 else if (end_value == last_retval)
479 /* degenerate range (number1 == number2). Advance the
480 token pointer so that the range will be treated as a
489 error ("negative value");
492 /* pp points to the '-' that betokens a range. All
493 number-parsing has already been done. Return the next
494 integer value (one greater than the saved previous value).
495 Do not advance the token pointer 'pp' until the end of range
498 if (++last_retval == end_value)
500 /* End of range reached; advance token pointer. */
510 /* condition N EXP -- set break condition of breakpoint N to EXP. */
513 condition_command (char *arg, int from_tty)
515 register struct breakpoint *b;
520 error_no_arg ("breakpoint number");
523 bnum = get_number (&p);
525 error ("Bad breakpoint argument: '%s'", arg);
528 if (b->number == bnum)
535 if (b->cond_string != NULL)
536 xfree (b->cond_string);
541 b->cond_string = NULL;
543 printf_filtered ("Breakpoint %d now unconditional.\n", bnum);
548 /* I don't know if it matters whether this is the string the user
549 typed in or the decompiled expression. */
550 b->cond_string = savestring (arg, strlen (arg));
551 b->cond = parse_exp_1 (&arg, block_for_pc (b->address), 0);
553 error ("Junk at end of expression");
555 breakpoints_changed ();
556 breakpoint_modify_event (b->number);
560 error ("No breakpoint number %d.", bnum);
565 commands_command (char *arg, int from_tty)
567 register struct breakpoint *b;
570 struct command_line *l;
572 /* If we allowed this, we would have problems with when to
573 free the storage, if we change the commands currently
576 if (executing_breakpoint_commands)
577 error ("Can't use the \"commands\" command among a breakpoint's commands.");
580 bnum = get_number (&p);
583 error ("Unexpected extra arguments following breakpoint number.");
586 if (b->number == bnum)
590 "Type commands for when breakpoint %d is hit, one per line.",
592 l = read_command_lines (tmpbuf, from_tty);
593 free_command_lines (&b->commands);
595 breakpoints_changed ();
596 breakpoint_modify_event (b->number);
599 error ("No breakpoint number %d.", bnum);
602 /* Like target_read_memory() but if breakpoints are inserted, return
603 the shadow contents instead of the breakpoints themselves.
605 Read "memory data" from whatever target or inferior we have.
606 Returns zero if successful, errno value if not. EIO is used
607 for address out of bounds. If breakpoints are inserted, returns
608 shadow contents, not the breakpoints themselves. From breakpoint.c. */
611 read_memory_nobpt (CORE_ADDR memaddr, char *myaddr, unsigned len)
614 struct breakpoint *b;
615 CORE_ADDR bp_addr = 0;
618 if (BREAKPOINT_FROM_PC (&bp_addr, &bp_size) == NULL)
619 /* No breakpoints on this machine. */
620 return target_read_memory (memaddr, myaddr, len);
624 if (b->type == bp_none)
625 warning ("reading through apparently deleted breakpoint #%d?",
628 /* memory breakpoint? */
629 if (b->type == bp_watchpoint
630 || b->type == bp_hardware_watchpoint
631 || b->type == bp_read_watchpoint
632 || b->type == bp_access_watchpoint)
637 /* Addresses and length of the part of the breakpoint that
639 /* XXXX The m68k, sh and h8300 have different local and remote
640 breakpoint values. BREAKPOINT_FROM_PC still manages to
641 correctly determine the breakpoints memory address and size
642 for these targets. */
643 bp_addr = b->address;
645 if (BREAKPOINT_FROM_PC (&bp_addr, &bp_size) == NULL)
650 if (bp_addr + bp_size <= memaddr)
651 /* The breakpoint is entirely before the chunk of memory we
654 if (bp_addr >= memaddr + len)
655 /* The breakpoint is entirely after the chunk of memory we are
658 /* Copy the breakpoint from the shadow contents, and recurse for
659 the things before and after. */
661 /* Offset within shadow_contents. */
664 if (bp_addr < memaddr)
666 /* Only copy the second part of the breakpoint. */
667 bp_size -= memaddr - bp_addr;
668 bptoffset = memaddr - bp_addr;
672 if (bp_addr + bp_size > memaddr + len)
674 /* Only copy the first part of the breakpoint. */
675 bp_size -= (bp_addr + bp_size) - (memaddr + len);
678 memcpy (myaddr + bp_addr - memaddr,
679 b->shadow_contents + bptoffset, bp_size);
681 if (bp_addr > memaddr)
683 /* Copy the section of memory before the breakpoint. */
684 status = read_memory_nobpt (memaddr, myaddr, bp_addr - memaddr);
689 if (bp_addr + bp_size < memaddr + len)
691 /* Copy the section of memory after the breakpoint. */
692 status = read_memory_nobpt (bp_addr + bp_size,
693 myaddr + bp_addr + bp_size - memaddr,
694 memaddr + len - (bp_addr + bp_size));
701 /* Nothing overlaps. Just call read_memory_noerr. */
702 return target_read_memory (memaddr, myaddr, len);
706 /* insert_breakpoints is used when starting or continuing the program.
707 remove_breakpoints is used when the program stops.
708 Both return zero if successful,
709 or an `errno' value if could not write the inferior. */
712 insert_breakpoints (void)
714 register struct breakpoint *b, *temp;
715 int return_val = 0; /* return success code. */
717 int disabled_breaks = 0;
719 static char message1[] = "Error inserting catchpoint %d:\n";
720 static char message[sizeof (message1) + 30];
723 ALL_BREAKPOINTS_SAFE (b, temp)
725 if (b->enable_state == bp_permanent)
726 /* Permanent breakpoints cannot be inserted or removed. */
728 else if (b->type != bp_watchpoint
729 && b->type != bp_hardware_watchpoint
730 && b->type != bp_read_watchpoint
731 && b->type != bp_access_watchpoint
732 && b->type != bp_catch_fork
733 && b->type != bp_catch_vfork
734 && b->type != bp_catch_exec
735 && b->type != bp_catch_throw
736 && b->type != bp_catch_catch
737 && b->enable_state != bp_disabled
738 && b->enable_state != bp_shlib_disabled
739 && b->enable_state != bp_call_disabled
743 /* "Normal" instruction breakpoint: either the standard
744 trap-instruction bp (bp_breakpoint), or a
745 bp_hardware_breakpoint. */
747 /* First check to see if we have to handle an overlay. */
748 if (overlay_debugging == ovly_off
749 || b->section == NULL
750 || !(section_is_overlay (b->section)))
752 /* No overlay handling: just set the breakpoint. */
754 if (b->type == bp_hardware_breakpoint)
755 val = target_insert_hw_breakpoint (b->address,
758 val = target_insert_breakpoint (b->address, b->shadow_contents);
762 /* This breakpoint is in an overlay section.
763 Shall we set a breakpoint at the LMA? */
764 if (!overlay_events_enabled)
766 /* Yes -- overlay event support is not active,
767 so we must try to set a breakpoint at the LMA.
768 This will not work for a hardware breakpoint. */
769 if (b->type == bp_hardware_breakpoint)
770 warning ("hardware breakpoint %d not supported in overlay!\n",
774 CORE_ADDR addr = overlay_unmapped_address (b->address,
776 /* Set a software (trap) breakpoint at the LMA. */
777 val = target_insert_breakpoint (addr, b->shadow_contents);
779 warning ("overlay breakpoint %d failed: in ROM?",
783 /* Shall we set a breakpoint at the VMA? */
784 if (section_is_mapped (b->section))
786 /* Yes. This overlay section is mapped into memory. */
787 if (b->type == bp_hardware_breakpoint)
788 val = target_insert_hw_breakpoint (b->address,
791 val = target_insert_breakpoint (b->address,
796 /* No. This breakpoint will not be inserted.
797 No error, but do not mark the bp as 'inserted'. */
804 /* Can't set the breakpoint. */
805 #if defined (DISABLE_UNSETTABLE_BREAK)
806 if (DISABLE_UNSETTABLE_BREAK (b->address))
808 /* See also: disable_breakpoints_in_shlibs. */
810 b->enable_state = bp_shlib_disabled;
811 if (!disabled_breaks)
813 target_terminal_ours_for_output ();
814 warning ("Cannot insert breakpoint %d:", b->number);
815 warning ("Temporarily disabling shared library breakpoints:");
818 warning ("breakpoint #%d ", b->number);
823 target_terminal_ours_for_output ();
824 warning ("Cannot insert breakpoint %d:", b->number);
825 #ifdef ONE_PROCESS_WRITETEXT
826 warning ("The same program may be running in another process.");
828 memory_error (val, b->address); /* which bombs us out */
835 return_val = val; /* remember failure */
837 else if (ep_is_exception_catchpoint (b)
838 && b->enable_state != bp_disabled
839 && b->enable_state != bp_shlib_disabled
840 && b->enable_state != bp_call_disabled
845 /* If we get here, we must have a callback mechanism for exception
846 events -- with g++ style embedded label support, we insert
847 ordinary breakpoints and not catchpoints. */
848 /* Format possible error message */
849 sprintf (message, message1, b->number);
851 val = target_insert_breakpoint (b->address, b->shadow_contents);
854 /* Couldn't set breakpoint for some reason */
855 target_terminal_ours_for_output ();
856 warning ("Cannot insert catchpoint %d; disabling it.",
858 b->enable_state = bp_disabled;
862 /* Bp set, now make sure callbacks are enabled */
864 args_for_catchpoint_enable args;
865 args.kind = b->type == bp_catch_catch ?
866 EX_EVENT_CATCH : EX_EVENT_THROW;
868 val = catch_errors (cover_target_enable_exception_callback,
870 message, RETURN_MASK_ALL);
871 if (val != 0 && val != -1)
875 /* Check if something went wrong; val == 0 can be ignored */
878 /* something went wrong */
879 target_terminal_ours_for_output ();
880 warning ("Cannot insert catchpoint %d; disabling it.",
882 b->enable_state = bp_disabled;
887 return_val = val; /* remember failure */
890 else if ((b->type == bp_hardware_watchpoint ||
891 b->type == bp_read_watchpoint ||
892 b->type == bp_access_watchpoint)
893 && b->enable_state == bp_enabled
894 && b->disposition != disp_del_at_next_stop
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 saved_frame = selected_frame;
906 saved_level = frame_relative_level (selected_frame);
908 /* Determine if the watchpoint is within scope. */
909 if (b->exp_valid_block == NULL)
910 within_current_scope = 1;
913 struct frame_info *fi;
914 fi = frame_find_by_id (b->watchpoint_frame);
915 within_current_scope = (fi != NULL);
916 if (within_current_scope)
920 if (within_current_scope)
922 /* Evaluate the expression and cut the chain of values
923 produced off from the value chain.
925 Make sure the value returned isn't lazy; we use
926 laziness to determine what memory GDB actually needed
927 in order to compute the value of the expression. */
928 v = evaluate_expression (b->exp);
930 value_release_to_mark (mark);
935 /* Look at each value on the value chain. */
936 for (; v; v = v->next)
938 /* If it's a memory location, and GDB actually needed
939 its contents to evaluate the expression, then we
941 if (VALUE_LVAL (v) == lval_memory
944 struct type *vtype = check_typedef (VALUE_TYPE (v));
946 /* We only watch structs and arrays if user asked
947 for it explicitly, never if they just happen to
948 appear in the middle of some value chain. */
949 if (v == b->val_chain
950 || (TYPE_CODE (vtype) != TYPE_CODE_STRUCT
951 && TYPE_CODE (vtype) != TYPE_CODE_ARRAY))
956 addr = VALUE_ADDRESS (v) + VALUE_OFFSET (v);
957 len = TYPE_LENGTH (VALUE_TYPE (v));
959 if (b->type == bp_read_watchpoint)
961 else if (b->type == bp_access_watchpoint)
964 val = target_insert_watchpoint (addr, len, type);
967 /* Don't exit the loop, try to insert
968 every value on the value chain. That's
969 because we will be removing all the
970 watches below, and removing a
971 watchpoint we didn't insert could have
979 /* Failure to insert a watchpoint on any memory value in the
980 value chain brings us here. */
983 remove_breakpoint (b, mark_uninserted);
984 warning ("Could not insert hardware watchpoint %d.",
991 printf_filtered ("Hardware watchpoint %d deleted ", b->number);
992 printf_filtered ("because the program has left the block \n");
993 printf_filtered ("in which its expression is valid.\n");
994 if (b->related_breakpoint)
995 b->related_breakpoint->disposition = disp_del_at_next_stop;
996 b->disposition = disp_del_at_next_stop;
999 /* Restore the frame and level. */
1000 if ((saved_frame != selected_frame) ||
1001 (saved_level != frame_relative_level (selected_frame)))
1002 select_frame (saved_frame);
1005 return_val = val; /* remember failure */
1007 else if ((b->type == bp_catch_fork
1008 || b->type == bp_catch_vfork
1009 || b->type == bp_catch_exec)
1010 && b->enable_state == bp_enabled
1018 val = target_insert_fork_catchpoint (PIDGET (inferior_ptid));
1020 case bp_catch_vfork:
1021 val = target_insert_vfork_catchpoint (PIDGET (inferior_ptid));
1024 val = target_insert_exec_catchpoint (PIDGET (inferior_ptid));
1027 warning ("Internal error, %s line %d.", __FILE__, __LINE__);
1032 target_terminal_ours_for_output ();
1033 warning ("Cannot insert catchpoint %d.", b->number);
1039 return_val = val; /* remember failure */
1048 remove_breakpoints (void)
1050 register struct breakpoint *b;
1057 val = remove_breakpoint (b, mark_uninserted);
1066 remove_hw_watchpoints (void)
1068 register struct breakpoint *b;
1074 && (b->type == bp_hardware_watchpoint
1075 || b->type == bp_read_watchpoint
1076 || b->type == bp_access_watchpoint))
1078 val = remove_breakpoint (b, mark_uninserted);
1087 reattach_breakpoints (int pid)
1089 register struct breakpoint *b;
1091 struct cleanup *old_chain = save_inferior_ptid ();
1093 /* Set inferior_ptid; remove_breakpoint uses this global. */
1094 inferior_ptid = pid_to_ptid (pid);
1099 remove_breakpoint (b, mark_inserted);
1100 if (b->type == bp_hardware_breakpoint)
1101 val = target_insert_hw_breakpoint (b->address, b->shadow_contents);
1103 val = target_insert_breakpoint (b->address, b->shadow_contents);
1106 do_cleanups (old_chain);
1111 do_cleanups (old_chain);
1116 update_breakpoints_after_exec (void)
1118 struct breakpoint *b;
1119 struct breakpoint *temp;
1121 /* Doing this first prevents the badness of having delete_breakpoint()
1122 write a breakpoint's current "shadow contents" to lift the bp. That
1123 shadow is NOT valid after an exec()! */
1124 mark_breakpoints_out ();
1126 ALL_BREAKPOINTS_SAFE (b, temp)
1128 /* Solib breakpoints must be explicitly reset after an exec(). */
1129 if (b->type == bp_shlib_event)
1131 delete_breakpoint (b);
1135 /* Thread event breakpoints must be set anew after an exec(),
1136 as must overlay event breakpoints. */
1137 if (b->type == bp_thread_event || b->type == bp_overlay_event)
1139 delete_breakpoint (b);
1143 /* Step-resume breakpoints are meaningless after an exec(). */
1144 if (b->type == bp_step_resume)
1146 delete_breakpoint (b);
1150 /* Ditto the sigtramp handler breakpoints. */
1151 if (b->type == bp_through_sigtramp)
1153 delete_breakpoint (b);
1157 /* Ditto the exception-handling catchpoints. */
1158 if ((b->type == bp_catch_catch) || (b->type == bp_catch_throw))
1160 delete_breakpoint (b);
1164 /* Don't delete an exec catchpoint, because else the inferior
1165 won't stop when it ought!
1167 Similarly, we probably ought to keep vfork catchpoints, 'cause
1168 on this target, we may not be able to stop when the vfork is
1169 seen, but only when the subsequent exec is seen. (And because
1170 deleting fork catchpoints here but not vfork catchpoints will
1171 seem mysterious to users, keep those too.)
1173 ??rehrauer: Let's hope that merely clearing out this catchpoint's
1174 target address field, if any, is sufficient to have it be reset
1175 automagically. Certainly on HP-UX that's true.
1177 Jim Blandy <jimb@redhat.com>: Actually, zero is a perfectly
1178 valid code address on some platforms (like the mn10200 and
1179 mn10300 simulators). We shouldn't assign any special
1180 interpretation to a breakpoint with a zero address. And in
1181 fact, GDB doesn't --- I can't see what that comment above is
1182 talking about. As far as I can tell, setting the address of a
1183 bp_catch_exec/bp_catch_vfork/bp_catch_fork breakpoint to zero
1184 is meaningless, since those are implemented with HP-UX kernel
1185 hackery, not by storing breakpoint instructions somewhere. */
1186 if ((b->type == bp_catch_exec) ||
1187 (b->type == bp_catch_vfork) ||
1188 (b->type == bp_catch_fork))
1190 b->address = (CORE_ADDR) NULL;
1194 /* bp_finish is a special case. The only way we ought to be able
1195 to see one of these when an exec() has happened, is if the user
1196 caught a vfork, and then said "finish". Ordinarily a finish just
1197 carries them to the call-site of the current callee, by setting
1198 a temporary bp there and resuming. But in this case, the finish
1199 will carry them entirely through the vfork & exec.
1201 We don't want to allow a bp_finish to remain inserted now. But
1202 we can't safely delete it, 'cause finish_command has a handle to
1203 the bp on a bpstat, and will later want to delete it. There's a
1204 chance (and I've seen it happen) that if we delete the bp_finish
1205 here, that its storage will get reused by the time finish_command
1206 gets 'round to deleting the "use to be a bp_finish" breakpoint.
1207 We really must allow finish_command to delete a bp_finish.
1209 In the absense of a general solution for the "how do we know
1210 it's safe to delete something others may have handles to?"
1211 problem, what we'll do here is just uninsert the bp_finish, and
1212 let finish_command delete it.
1214 (We know the bp_finish is "doomed" in the sense that it's
1215 momentary, and will be deleted as soon as finish_command sees
1216 the inferior stopped. So it doesn't matter that the bp's
1217 address is probably bogus in the new a.out, unlike e.g., the
1218 solib breakpoints.) */
1220 if (b->type == bp_finish)
1225 /* Without a symbolic address, we have little hope of the
1226 pre-exec() address meaning the same thing in the post-exec()
1228 if (b->addr_string == NULL)
1230 delete_breakpoint (b);
1234 /* If this breakpoint has survived the above battery of checks, then
1235 it must have a symbolic address. Be sure that it gets reevaluated
1236 to a target address, rather than reusing the old evaluation.
1238 Jim Blandy <jimb@redhat.com>: As explained above in the comment
1239 for bp_catch_exec and friends, I'm pretty sure this is entirely
1240 unnecessary. A call to breakpoint_re_set_one always recomputes
1241 the breakpoint's address from scratch, or deletes it if it can't.
1242 So I think this assignment could be deleted without effect. */
1243 b->address = (CORE_ADDR) NULL;
1245 /* FIXME what about longjmp breakpoints? Re-create them here? */
1246 create_overlay_event_breakpoint ("_ovly_debug_event");
1250 detach_breakpoints (int pid)
1252 register struct breakpoint *b;
1254 struct cleanup *old_chain = save_inferior_ptid ();
1256 if (pid == PIDGET (inferior_ptid))
1257 error ("Cannot detach breakpoints of inferior_ptid");
1259 /* Set inferior_ptid; remove_breakpoint uses this global. */
1260 inferior_ptid = pid_to_ptid (pid);
1265 val = remove_breakpoint (b, mark_inserted);
1268 do_cleanups (old_chain);
1273 do_cleanups (old_chain);
1278 remove_breakpoint (struct breakpoint *b, insertion_state_t is)
1282 if (b->enable_state == bp_permanent)
1283 /* Permanent breakpoints cannot be inserted or removed. */
1286 if (b->type == bp_none)
1287 warning ("attempted to remove apparently deleted breakpoint #%d?",
1290 if (b->type != bp_watchpoint
1291 && b->type != bp_hardware_watchpoint
1292 && b->type != bp_read_watchpoint
1293 && b->type != bp_access_watchpoint
1294 && b->type != bp_catch_fork
1295 && b->type != bp_catch_vfork
1296 && b->type != bp_catch_exec
1297 && b->type != bp_catch_catch
1298 && b->type != bp_catch_throw)
1300 /* "Normal" instruction breakpoint: either the standard
1301 trap-instruction bp (bp_breakpoint), or a
1302 bp_hardware_breakpoint. */
1304 /* First check to see if we have to handle an overlay. */
1305 if (overlay_debugging == ovly_off
1306 || b->section == NULL
1307 || !(section_is_overlay (b->section)))
1309 /* No overlay handling: just remove the breakpoint. */
1311 if (b->type == bp_hardware_breakpoint)
1312 val = target_remove_hw_breakpoint (b->address,
1313 b->shadow_contents);
1315 val = target_remove_breakpoint (b->address, b->shadow_contents);
1319 /* This breakpoint is in an overlay section.
1320 Did we set a breakpoint at the LMA? */
1321 if (!overlay_events_enabled)
1323 /* Yes -- overlay event support is not active, so we
1324 should have set a breakpoint at the LMA. Remove it.
1326 CORE_ADDR addr = overlay_unmapped_address (b->address,
1328 /* Ignore any failures: if the LMA is in ROM, we will
1329 have already warned when we failed to insert it. */
1330 if (b->type != bp_hardware_breakpoint)
1331 target_remove_hw_breakpoint (addr, b->shadow_contents);
1333 target_remove_breakpoint (addr, b->shadow_contents);
1335 /* Did we set a breakpoint at the VMA?
1336 If so, we will have marked the breakpoint 'inserted'. */
1339 /* Yes -- remove it. Previously we did not bother to
1340 remove the breakpoint if the section had been
1341 unmapped, but let's not rely on that being safe. We
1342 don't know what the overlay manager might do. */
1343 if (b->type == bp_hardware_breakpoint)
1344 val = target_remove_hw_breakpoint (b->address,
1345 b->shadow_contents);
1347 val = target_remove_breakpoint (b->address,
1348 b->shadow_contents);
1352 /* No -- not inserted, so no need to remove. No error. */
1358 b->inserted = (is == mark_inserted);
1360 else if ((b->type == bp_hardware_watchpoint ||
1361 b->type == bp_read_watchpoint ||
1362 b->type == bp_access_watchpoint)
1363 && b->enable_state == bp_enabled
1369 b->inserted = (is == mark_inserted);
1370 /* Walk down the saved value chain. */
1371 for (v = b->val_chain; v; v = v->next)
1373 /* For each memory reference remove the watchpoint
1375 if (VALUE_LVAL (v) == lval_memory
1376 && ! VALUE_LAZY (v))
1378 struct type *vtype = check_typedef (VALUE_TYPE (v));
1380 if (v == b->val_chain
1381 || (TYPE_CODE (vtype) != TYPE_CODE_STRUCT
1382 && TYPE_CODE (vtype) != TYPE_CODE_ARRAY))
1387 addr = VALUE_ADDRESS (v) + VALUE_OFFSET (v);
1388 len = TYPE_LENGTH (VALUE_TYPE (v));
1390 if (b->type == bp_read_watchpoint)
1392 else if (b->type == bp_access_watchpoint)
1395 val = target_remove_watchpoint (addr, len, type);
1402 /* Failure to remove any of the hardware watchpoints comes here. */
1403 if ((is == mark_uninserted) && (b->inserted))
1404 warning ("Could not remove hardware watchpoint %d.",
1407 /* Free the saved value chain. We will construct a new one
1408 the next time the watchpoint is inserted. */
1409 for (v = b->val_chain; v; v = n)
1414 b->val_chain = NULL;
1416 else if ((b->type == bp_catch_fork ||
1417 b->type == bp_catch_vfork ||
1418 b->type == bp_catch_exec)
1419 && b->enable_state == bp_enabled
1426 val = target_remove_fork_catchpoint (PIDGET (inferior_ptid));
1428 case bp_catch_vfork:
1429 val = target_remove_vfork_catchpoint (PIDGET (inferior_ptid));
1432 val = target_remove_exec_catchpoint (PIDGET (inferior_ptid));
1435 warning ("Internal error, %s line %d.", __FILE__, __LINE__);
1440 b->inserted = (is == mark_inserted);
1442 else if ((b->type == bp_catch_catch ||
1443 b->type == bp_catch_throw)
1444 && b->enable_state == bp_enabled
1448 val = target_remove_breakpoint (b->address, b->shadow_contents);
1451 b->inserted = (is == mark_inserted);
1453 else if (ep_is_exception_catchpoint (b)
1454 && b->inserted /* sometimes previous insert doesn't happen */
1455 && b->enable_state == bp_enabled
1459 val = target_remove_breakpoint (b->address, b->shadow_contents);
1463 b->inserted = (is == mark_inserted);
1469 /* Clear the "inserted" flag in all breakpoints. */
1472 mark_breakpoints_out (void)
1474 register struct breakpoint *b;
1480 /* Clear the "inserted" flag in all breakpoints and delete any
1481 breakpoints which should go away between runs of the program.
1483 Plus other such housekeeping that has to be done for breakpoints
1486 Note: this function gets called at the end of a run (by
1487 generic_mourn_inferior) and when a run begins (by
1488 init_wait_for_inferior). */
1493 breakpoint_init_inferior (enum inf_context context)
1495 register struct breakpoint *b, *temp;
1496 static int warning_needed = 0;
1498 ALL_BREAKPOINTS_SAFE (b, temp)
1505 case bp_watchpoint_scope:
1507 /* If the call dummy breakpoint is at the entry point it will
1508 cause problems when the inferior is rerun, so we better
1511 Also get rid of scope breakpoints. */
1512 delete_breakpoint (b);
1516 case bp_hardware_watchpoint:
1517 case bp_read_watchpoint:
1518 case bp_access_watchpoint:
1520 /* Likewise for watchpoints on local expressions. */
1521 if (b->exp_valid_block != NULL)
1522 delete_breakpoint (b);
1525 /* Likewise for exception catchpoints in dynamic-linked
1526 executables where required */
1527 if (ep_is_exception_catchpoint (b) &&
1528 exception_catchpoints_are_fragile)
1531 delete_breakpoint (b);
1537 if (exception_catchpoints_are_fragile)
1538 exception_support_initialized = 0;
1540 /* Don't issue the warning unless it's really needed... */
1541 if (warning_needed && (context != inf_exited))
1543 warning ("Exception catchpoints from last run were deleted.");
1544 warning ("You must reinsert them explicitly.");
1549 /* breakpoint_here_p (PC) returns non-zero if an enabled breakpoint
1550 exists at PC. It returns ordinary_breakpoint_here if it's an
1551 ordinary breakpoint, or permanent_breakpoint_here if it's a
1552 permanent breakpoint.
1553 - When continuing from a location with an ordinary breakpoint, we
1554 actually single step once before calling insert_breakpoints.
1555 - When continuing from a localion with a permanent breakpoint, we
1556 need to use the `SKIP_PERMANENT_BREAKPOINT' macro, provided by
1557 the target, to advance the PC past the breakpoint. */
1559 enum breakpoint_here
1560 breakpoint_here_p (CORE_ADDR pc)
1562 register struct breakpoint *b;
1563 int any_breakpoint_here = 0;
1566 if ((b->enable_state == bp_enabled
1567 || b->enable_state == bp_permanent)
1568 && b->address == pc) /* bp is enabled and matches pc */
1570 if (overlay_debugging
1571 && section_is_overlay (b->section)
1572 && !section_is_mapped (b->section))
1573 continue; /* unmapped overlay -- can't be a match */
1574 else if (b->enable_state == bp_permanent)
1575 return permanent_breakpoint_here;
1577 any_breakpoint_here = 1;
1580 return any_breakpoint_here ? ordinary_breakpoint_here : 0;
1584 /* breakpoint_inserted_here_p (PC) is just like breakpoint_here_p(),
1585 but it only returns true if there is actually a breakpoint inserted
1589 breakpoint_inserted_here_p (CORE_ADDR pc)
1591 register struct breakpoint *b;
1595 && b->address == pc) /* bp is inserted and matches pc */
1597 if (overlay_debugging
1598 && section_is_overlay (b->section)
1599 && !section_is_mapped (b->section))
1600 continue; /* unmapped overlay -- can't be a match */
1608 /* Return nonzero if FRAME is a dummy frame. We can't use
1609 PC_IN_CALL_DUMMY because figuring out the saved SP would take too
1610 much time, at least using get_saved_register on the 68k. This
1611 means that for this function to work right a port must use the
1612 bp_call_dummy breakpoint. */
1615 frame_in_dummy (struct frame_info *frame)
1617 struct breakpoint *b;
1622 if (USE_GENERIC_DUMMY_FRAMES)
1623 return generic_pc_in_call_dummy (frame->pc, frame->frame, frame->frame);
1627 if (b->type == bp_call_dummy
1628 && b->frame == frame->frame
1629 /* We need to check the PC as well as the frame on the sparc,
1630 for signals.exp in the testsuite. */
1633 - SIZEOF_CALL_DUMMY_WORDS / sizeof (LONGEST) * REGISTER_SIZE))
1634 && frame->pc <= b->address)
1640 /* breakpoint_thread_match (PC, PID) returns true if the breakpoint at
1641 PC is valid for process/thread PID. */
1644 breakpoint_thread_match (CORE_ADDR pc, ptid_t ptid)
1646 struct breakpoint *b;
1649 thread = pid_to_thread_id (ptid);
1652 if (b->enable_state != bp_disabled
1653 && b->enable_state != bp_shlib_disabled
1654 && b->enable_state != bp_call_disabled
1656 && (b->thread == -1 || b->thread == thread))
1658 if (overlay_debugging
1659 && section_is_overlay (b->section)
1660 && !section_is_mapped (b->section))
1661 continue; /* unmapped overlay -- can't be a match */
1670 /* bpstat stuff. External routines' interfaces are documented
1674 ep_is_catchpoint (struct breakpoint *ep)
1677 (ep->type == bp_catch_load)
1678 || (ep->type == bp_catch_unload)
1679 || (ep->type == bp_catch_fork)
1680 || (ep->type == bp_catch_vfork)
1681 || (ep->type == bp_catch_exec)
1682 || (ep->type == bp_catch_catch)
1683 || (ep->type == bp_catch_throw);
1685 /* ??rehrauer: Add more kinds here, as are implemented... */
1689 ep_is_shlib_catchpoint (struct breakpoint *ep)
1692 (ep->type == bp_catch_load)
1693 || (ep->type == bp_catch_unload);
1697 ep_is_exception_catchpoint (struct breakpoint *ep)
1700 (ep->type == bp_catch_catch)
1701 || (ep->type == bp_catch_throw);
1704 /* Clear a bpstat so that it says we are not at any breakpoint.
1705 Also free any storage that is part of a bpstat. */
1708 bpstat_clear (bpstat *bsp)
1719 if (p->old_val != NULL)
1720 value_free (p->old_val);
1727 /* Return a copy of a bpstat. Like "bs1 = bs2" but all storage that
1728 is part of the bpstat is copied as well. */
1731 bpstat_copy (bpstat bs)
1735 bpstat retval = NULL;
1740 for (; bs != NULL; bs = bs->next)
1742 tmp = (bpstat) xmalloc (sizeof (*tmp));
1743 memcpy (tmp, bs, sizeof (*tmp));
1745 /* This is the first thing in the chain. */
1755 /* Find the bpstat associated with this breakpoint */
1758 bpstat_find_breakpoint (bpstat bsp, struct breakpoint *breakpoint)
1763 for (; bsp != NULL; bsp = bsp->next)
1765 if (bsp->breakpoint_at == breakpoint)
1771 /* Find a step_resume breakpoint associated with this bpstat.
1772 (If there are multiple step_resume bp's on the list, this function
1773 will arbitrarily pick one.)
1775 It is an error to use this function if BPSTAT doesn't contain a
1776 step_resume breakpoint.
1778 See wait_for_inferior's use of this function. */
1780 bpstat_find_step_resume_breakpoint (bpstat bsp)
1785 error ("Internal error (bpstat_find_step_resume_breakpoint)");
1787 current_thread = pid_to_thread_id (inferior_ptid);
1789 for (; bsp != NULL; bsp = bsp->next)
1791 if ((bsp->breakpoint_at != NULL) &&
1792 (bsp->breakpoint_at->type == bp_step_resume) &&
1793 (bsp->breakpoint_at->thread == current_thread ||
1794 bsp->breakpoint_at->thread == -1))
1795 return bsp->breakpoint_at;
1798 error ("Internal error (no step_resume breakpoint found)");
1802 /* Return the breakpoint number of the first breakpoint we are stopped
1803 at. *BSP upon return is a bpstat which points to the remaining
1804 breakpoints stopped at (but which is not guaranteed to be good for
1805 anything but further calls to bpstat_num).
1806 Return 0 if passed a bpstat which does not indicate any breakpoints. */
1809 bpstat_num (bpstat *bsp)
1811 struct breakpoint *b;
1814 return 0; /* No more breakpoint values */
1817 b = (*bsp)->breakpoint_at;
1818 *bsp = (*bsp)->next;
1820 return -1; /* breakpoint that's been deleted since */
1822 return b->number; /* We have its number */
1826 /* Modify BS so that the actions will not be performed. */
1829 bpstat_clear_actions (bpstat bs)
1831 for (; bs != NULL; bs = bs->next)
1833 bs->commands = NULL;
1834 if (bs->old_val != NULL)
1836 value_free (bs->old_val);
1842 /* Stub for cleaning up our state if we error-out of a breakpoint command */
1845 cleanup_executing_breakpoints (PTR ignore)
1847 executing_breakpoint_commands = 0;
1850 /* Execute all the commands associated with all the breakpoints at this
1851 location. Any of these commands could cause the process to proceed
1852 beyond this point, etc. We look out for such changes by checking
1853 the global "breakpoint_proceeded" after each command. */
1856 bpstat_do_actions (bpstat *bsp)
1859 struct cleanup *old_chain;
1860 struct command_line *cmd;
1862 /* Avoid endless recursion if a `source' command is contained
1864 if (executing_breakpoint_commands)
1867 executing_breakpoint_commands = 1;
1868 old_chain = make_cleanup (cleanup_executing_breakpoints, 0);
1871 /* Note that (as of this writing), our callers all appear to
1872 be passing us the address of global stop_bpstat. And, if
1873 our calls to execute_control_command cause the inferior to
1874 proceed, that global (and hence, *bsp) will change.
1876 We must be careful to not touch *bsp unless the inferior
1877 has not proceeded. */
1879 /* This pointer will iterate over the list of bpstat's. */
1882 breakpoint_proceeded = 0;
1883 for (; bs != NULL; bs = bs->next)
1888 execute_control_command (cmd);
1890 if (breakpoint_proceeded)
1895 if (breakpoint_proceeded)
1896 /* The inferior is proceeded by the command; bomb out now.
1897 The bpstat chain has been blown away by wait_for_inferior.
1898 But since execution has stopped again, there is a new bpstat
1899 to look at, so start over. */
1902 bs->commands = NULL;
1905 executing_breakpoint_commands = 0;
1906 discard_cleanups (old_chain);
1909 /* This is the normal print function for a bpstat. In the future,
1910 much of this logic could (should?) be moved to bpstat_stop_status,
1911 by having it set different print_it values.
1913 Current scheme: When we stop, bpstat_print() is called. It loops
1914 through the bpstat list of things causing this stop, calling the
1915 print_bp_stop_message function on each one. The behavior of the
1916 print_bp_stop_message function depends on the print_it field of
1917 bpstat. If such field so indicates, call this function here.
1919 Return values from this routine (ultimately used by bpstat_print()
1920 and normal_stop() to decide what to do):
1921 PRINT_NOTHING: Means we already printed all we needed to print,
1922 don't print anything else.
1923 PRINT_SRC_ONLY: Means we printed something, and we do *not* desire
1924 that something to be followed by a location.
1925 PRINT_SCR_AND_LOC: Means we printed something, and we *do* desire
1926 that something to be followed by a location.
1927 PRINT_UNKNOWN: Means we printed nothing or we need to do some more
1930 static enum print_stop_action
1931 print_it_typical (bpstat bs)
1933 struct cleanup *old_chain;
1934 struct ui_stream *stb;
1935 stb = ui_out_stream_new (uiout);
1936 old_chain = make_cleanup_ui_out_stream_delete (stb);
1937 /* bs->breakpoint_at can be NULL if it was a momentary breakpoint
1938 which has since been deleted. */
1939 if (bs->breakpoint_at == NULL)
1940 return PRINT_UNKNOWN;
1942 switch (bs->breakpoint_at->type)
1945 case bp_hardware_breakpoint:
1946 annotate_breakpoint (bs->breakpoint_at->number);
1947 ui_out_text (uiout, "\nBreakpoint ");
1948 if (ui_out_is_mi_like_p (uiout))
1949 ui_out_field_string (uiout, "reason", "breakpoint-hit");
1950 ui_out_field_int (uiout, "bkptno", bs->breakpoint_at->number);
1951 ui_out_text (uiout, ", ");
1952 return PRINT_SRC_AND_LOC;
1955 case bp_shlib_event:
1956 /* Did we stop because the user set the stop_on_solib_events
1957 variable? (If so, we report this as a generic, "Stopped due
1958 to shlib event" message.) */
1959 printf_filtered ("Stopped due to shared library event\n");
1960 return PRINT_NOTHING;
1963 case bp_thread_event:
1964 /* Not sure how we will get here.
1965 GDB should not stop for these breakpoints. */
1966 printf_filtered ("Thread Event Breakpoint: gdb should not stop!\n");
1967 return PRINT_NOTHING;
1970 case bp_overlay_event:
1971 /* By analogy with the thread event, GDB should not stop for these. */
1972 printf_filtered ("Overlay Event Breakpoint: gdb should not stop!\n");
1973 return PRINT_NOTHING;
1977 annotate_catchpoint (bs->breakpoint_at->number);
1978 printf_filtered ("\nCatchpoint %d (", bs->breakpoint_at->number);
1979 printf_filtered ("loaded");
1980 printf_filtered (" %s), ", bs->breakpoint_at->triggered_dll_pathname);
1981 return PRINT_SRC_AND_LOC;
1984 case bp_catch_unload:
1985 annotate_catchpoint (bs->breakpoint_at->number);
1986 printf_filtered ("\nCatchpoint %d (", bs->breakpoint_at->number);
1987 printf_filtered ("unloaded");
1988 printf_filtered (" %s), ", bs->breakpoint_at->triggered_dll_pathname);
1989 return PRINT_SRC_AND_LOC;
1993 annotate_catchpoint (bs->breakpoint_at->number);
1994 printf_filtered ("\nCatchpoint %d (", bs->breakpoint_at->number);
1995 printf_filtered ("forked");
1996 printf_filtered (" process %d), ",
1997 bs->breakpoint_at->forked_inferior_pid);
1998 return PRINT_SRC_AND_LOC;
2001 case bp_catch_vfork:
2002 annotate_catchpoint (bs->breakpoint_at->number);
2003 printf_filtered ("\nCatchpoint %d (", bs->breakpoint_at->number);
2004 printf_filtered ("vforked");
2005 printf_filtered (" process %d), ",
2006 bs->breakpoint_at->forked_inferior_pid);
2007 return PRINT_SRC_AND_LOC;
2011 annotate_catchpoint (bs->breakpoint_at->number);
2012 printf_filtered ("\nCatchpoint %d (exec'd %s), ",
2013 bs->breakpoint_at->number,
2014 bs->breakpoint_at->exec_pathname);
2015 return PRINT_SRC_AND_LOC;
2018 case bp_catch_catch:
2019 if (current_exception_event &&
2020 (CURRENT_EXCEPTION_KIND == EX_EVENT_CATCH))
2022 annotate_catchpoint (bs->breakpoint_at->number);
2023 printf_filtered ("\nCatchpoint %d (exception caught), ",
2024 bs->breakpoint_at->number);
2025 printf_filtered ("throw location ");
2026 if (CURRENT_EXCEPTION_THROW_PC && CURRENT_EXCEPTION_THROW_LINE)
2027 printf_filtered ("%s:%d",
2028 CURRENT_EXCEPTION_THROW_FILE,
2029 CURRENT_EXCEPTION_THROW_LINE);
2031 printf_filtered ("unknown");
2033 printf_filtered (", catch location ");
2034 if (CURRENT_EXCEPTION_CATCH_PC && CURRENT_EXCEPTION_CATCH_LINE)
2035 printf_filtered ("%s:%d",
2036 CURRENT_EXCEPTION_CATCH_FILE,
2037 CURRENT_EXCEPTION_CATCH_LINE);
2039 printf_filtered ("unknown");
2041 printf_filtered ("\n");
2042 /* don't bother to print location frame info */
2043 return PRINT_SRC_ONLY;
2047 /* really throw, some other bpstat will handle it */
2048 return PRINT_UNKNOWN;
2052 case bp_catch_throw:
2053 if (current_exception_event &&
2054 (CURRENT_EXCEPTION_KIND == EX_EVENT_THROW))
2056 annotate_catchpoint (bs->breakpoint_at->number);
2057 printf_filtered ("\nCatchpoint %d (exception thrown), ",
2058 bs->breakpoint_at->number);
2059 printf_filtered ("throw location ");
2060 if (CURRENT_EXCEPTION_THROW_PC && CURRENT_EXCEPTION_THROW_LINE)
2061 printf_filtered ("%s:%d",
2062 CURRENT_EXCEPTION_THROW_FILE,
2063 CURRENT_EXCEPTION_THROW_LINE);
2065 printf_filtered ("unknown");
2067 printf_filtered (", catch location ");
2068 if (CURRENT_EXCEPTION_CATCH_PC && CURRENT_EXCEPTION_CATCH_LINE)
2069 printf_filtered ("%s:%d",
2070 CURRENT_EXCEPTION_CATCH_FILE,
2071 CURRENT_EXCEPTION_CATCH_LINE);
2073 printf_filtered ("unknown");
2075 printf_filtered ("\n");
2076 /* don't bother to print location frame info */
2077 return PRINT_SRC_ONLY;
2081 /* really catch, some other bpstat will handle it */
2082 return PRINT_UNKNOWN;
2087 case bp_hardware_watchpoint:
2088 if (bs->old_val != NULL)
2090 annotate_watchpoint (bs->breakpoint_at->number);
2091 if (ui_out_is_mi_like_p (uiout))
2092 ui_out_field_string (uiout, "reason", "watchpoint-trigger");
2093 mention (bs->breakpoint_at);
2094 ui_out_tuple_begin (uiout, "value");
2095 ui_out_text (uiout, "\nOld value = ");
2096 value_print (bs->old_val, stb->stream, 0, Val_pretty_default);
2097 ui_out_field_stream (uiout, "old", stb);
2098 ui_out_text (uiout, "\nNew value = ");
2099 value_print (bs->breakpoint_at->val, stb->stream, 0, Val_pretty_default);
2100 ui_out_field_stream (uiout, "new", stb);
2101 ui_out_tuple_end (uiout);
2102 ui_out_text (uiout, "\n");
2103 value_free (bs->old_val);
2106 /* More than one watchpoint may have been triggered. */
2107 return PRINT_UNKNOWN;
2110 case bp_read_watchpoint:
2111 if (ui_out_is_mi_like_p (uiout))
2112 ui_out_field_string (uiout, "reason", "read-watchpoint-trigger");
2113 mention (bs->breakpoint_at);
2114 ui_out_tuple_begin (uiout, "value");
2115 ui_out_text (uiout, "\nValue = ");
2116 value_print (bs->breakpoint_at->val, stb->stream, 0, Val_pretty_default);
2117 ui_out_field_stream (uiout, "value", stb);
2118 ui_out_tuple_end (uiout);
2119 ui_out_text (uiout, "\n");
2120 return PRINT_UNKNOWN;
2123 case bp_access_watchpoint:
2124 if (bs->old_val != NULL)
2126 annotate_watchpoint (bs->breakpoint_at->number);
2127 if (ui_out_is_mi_like_p (uiout))
2128 ui_out_field_string (uiout, "reason", "access-watchpoint-trigger");
2129 mention (bs->breakpoint_at);
2130 ui_out_tuple_begin (uiout, "value");
2131 ui_out_text (uiout, "\nOld value = ");
2132 value_print (bs->old_val, stb->stream, 0, Val_pretty_default);
2133 ui_out_field_stream (uiout, "old", stb);
2134 value_free (bs->old_val);
2136 ui_out_text (uiout, "\nNew value = ");
2140 mention (bs->breakpoint_at);
2141 if (ui_out_is_mi_like_p (uiout))
2142 ui_out_field_string (uiout, "reason", "access-watchpoint-trigger");
2143 ui_out_tuple_begin (uiout, "value");
2144 ui_out_text (uiout, "\nValue = ");
2146 value_print (bs->breakpoint_at->val, stb->stream, 0,Val_pretty_default);
2147 ui_out_field_stream (uiout, "new", stb);
2148 ui_out_tuple_end (uiout);
2149 ui_out_text (uiout, "\n");
2150 return PRINT_UNKNOWN;
2153 /* Fall through, we don't deal with these types of breakpoints
2157 if (ui_out_is_mi_like_p (uiout))
2158 ui_out_field_string (uiout, "reason", "function-finished");
2159 return PRINT_UNKNOWN;
2163 if (ui_out_is_mi_like_p (uiout))
2164 ui_out_field_string (uiout, "reason", "location-reached");
2165 return PRINT_UNKNOWN;
2170 case bp_longjmp_resume:
2171 case bp_step_resume:
2172 case bp_through_sigtramp:
2173 case bp_watchpoint_scope:
2176 return PRINT_UNKNOWN;
2180 /* Generic routine for printing messages indicating why we
2181 stopped. The behavior of this function depends on the value
2182 'print_it' in the bpstat structure. Under some circumstances we
2183 may decide not to print anything here and delegate the task to
2186 static enum print_stop_action
2187 print_bp_stop_message (bpstat bs)
2189 switch (bs->print_it)
2192 /* Nothing should be printed for this bpstat entry. */
2193 return PRINT_UNKNOWN;
2197 /* We still want to print the frame, but we already printed the
2198 relevant messages. */
2199 return PRINT_SRC_AND_LOC;
2202 case print_it_normal:
2203 /* Normal case, we handle everything in print_it_typical. */
2204 return print_it_typical (bs);
2207 internal_error (__FILE__, __LINE__,
2208 "print_bp_stop_message: unrecognized enum value");
2213 /* Print a message indicating what happened. This is called from
2214 normal_stop(). The input to this routine is the head of the bpstat
2215 list - a list of the eventpoints that caused this stop. This
2216 routine calls the generic print routine for printing a message
2217 about reasons for stopping. This will print (for example) the
2218 "Breakpoint n," part of the output. The return value of this
2221 PRINT_UNKNOWN: Means we printed nothing
2222 PRINT_SRC_AND_LOC: Means we printed something, and expect subsequent
2223 code to print the location. An example is
2224 "Breakpoint 1, " which should be followed by
2226 PRINT_SRC_ONLY: Means we printed something, but there is no need
2227 to also print the location part of the message.
2228 An example is the catch/throw messages, which
2229 don't require a location appended to the end.
2230 PRINT_NOTHING: We have done some printing and we don't need any
2231 further info to be printed.*/
2233 enum print_stop_action
2234 bpstat_print (bpstat bs)
2238 /* Maybe another breakpoint in the chain caused us to stop.
2239 (Currently all watchpoints go on the bpstat whether hit or not.
2240 That probably could (should) be changed, provided care is taken
2241 with respect to bpstat_explains_signal). */
2242 for (; bs; bs = bs->next)
2244 val = print_bp_stop_message (bs);
2245 if (val == PRINT_SRC_ONLY
2246 || val == PRINT_SRC_AND_LOC
2247 || val == PRINT_NOTHING)
2251 /* We reached the end of the chain, or we got a null BS to start
2252 with and nothing was printed. */
2253 return PRINT_UNKNOWN;
2256 /* Evaluate the expression EXP and return 1 if value is zero.
2257 This is used inside a catch_errors to evaluate the breakpoint condition.
2258 The argument is a "struct expression *" that has been cast to char * to
2259 make it pass through catch_errors. */
2262 breakpoint_cond_eval (PTR exp)
2264 struct value *mark = value_mark ();
2265 int i = !value_true (evaluate_expression ((struct expression *) exp));
2266 value_free_to_mark (mark);
2270 /* Allocate a new bpstat and chain it to the current one. */
2273 bpstat_alloc (struct breakpoint *b, bpstat cbs /* Current "bs" value */ )
2277 bs = (bpstat) xmalloc (sizeof (*bs));
2279 bs->breakpoint_at = b;
2280 /* If the condition is false, etc., don't do the commands. */
2281 bs->commands = NULL;
2283 bs->print_it = print_it_normal;
2287 /* Possible return values for watchpoint_check (this can't be an enum
2288 because of check_errors). */
2289 /* The watchpoint has been deleted. */
2290 #define WP_DELETED 1
2291 /* The value has changed. */
2292 #define WP_VALUE_CHANGED 2
2293 /* The value has not changed. */
2294 #define WP_VALUE_NOT_CHANGED 3
2296 #define BP_TEMPFLAG 1
2297 #define BP_HARDWAREFLAG 2
2299 /* Check watchpoint condition. */
2302 watchpoint_check (PTR p)
2304 bpstat bs = (bpstat) p;
2305 struct breakpoint *b;
2306 struct frame_info *fr;
2307 int within_current_scope;
2309 b = bs->breakpoint_at;
2311 if (b->exp_valid_block == NULL)
2312 within_current_scope = 1;
2315 /* There is no current frame at this moment. If we're going to have
2316 any chance of handling watchpoints on local variables, we'll need
2317 the frame chain (so we can determine if we're in scope). */
2318 reinit_frame_cache ();
2319 fr = frame_find_by_id (b->watchpoint_frame);
2320 within_current_scope = (fr != NULL);
2321 /* in_function_epilogue_p() returns a non-zero value if we're still
2322 in the function but the stack frame has already been invalidated.
2323 Since we can't rely on the values of local variables after the
2324 stack has been destroyed, we are treating the watchpoint in that
2325 state as `not changed' without further checking. */
2326 if (within_current_scope && fr == get_current_frame ()
2327 && gdbarch_in_function_epilogue_p (current_gdbarch, read_pc ()))
2328 return WP_VALUE_NOT_CHANGED;
2329 if (within_current_scope)
2330 /* If we end up stopping, the current frame will get selected
2331 in normal_stop. So this call to select_frame won't affect
2336 if (within_current_scope)
2338 /* We use value_{,free_to_}mark because it could be a
2339 *long* time before we return to the command level and
2340 call free_all_values. We can't call free_all_values because
2341 we might be in the middle of evaluating a function call. */
2343 struct value *mark = value_mark ();
2344 struct value *new_val = evaluate_expression (bs->breakpoint_at->exp);
2345 if (!value_equal (b->val, new_val))
2347 release_value (new_val);
2348 value_free_to_mark (mark);
2349 bs->old_val = b->val;
2351 /* We will stop here */
2352 return WP_VALUE_CHANGED;
2356 /* Nothing changed, don't do anything. */
2357 value_free_to_mark (mark);
2358 /* We won't stop here */
2359 return WP_VALUE_NOT_CHANGED;
2364 /* This seems like the only logical thing to do because
2365 if we temporarily ignored the watchpoint, then when
2366 we reenter the block in which it is valid it contains
2367 garbage (in the case of a function, it may have two
2368 garbage values, one before and one after the prologue).
2369 So we can't even detect the first assignment to it and
2370 watch after that (since the garbage may or may not equal
2371 the first value assigned). */
2372 /* We print all the stop information in print_it_typical(), but
2373 in this case, by the time we call print_it_typical() this bp
2374 will be deleted already. So we have no choice but print the
2375 information here. */
2376 if (ui_out_is_mi_like_p (uiout))
2377 ui_out_field_string (uiout, "reason", "watchpoint-scope");
2378 ui_out_text (uiout, "\nWatchpoint ");
2379 ui_out_field_int (uiout, "wpnum", bs->breakpoint_at->number);
2380 ui_out_text (uiout, " deleted because the program has left the block in\n\
2381 which its expression is valid.\n");
2383 if (b->related_breakpoint)
2384 b->related_breakpoint->disposition = disp_del_at_next_stop;
2385 b->disposition = disp_del_at_next_stop;
2391 /* Get a bpstat associated with having just stopped at address *PC
2392 and frame address CORE_ADDRESS. Update *PC to point at the
2393 breakpoint (if we hit a breakpoint). NOT_A_BREAKPOINT is nonzero
2394 if this is known to not be a real breakpoint (it could still be a
2395 watchpoint, though). */
2397 /* Determine whether we stopped at a breakpoint, etc, or whether we
2398 don't understand this stop. Result is a chain of bpstat's such that:
2400 if we don't understand the stop, the result is a null pointer.
2402 if we understand why we stopped, the result is not null.
2404 Each element of the chain refers to a particular breakpoint or
2405 watchpoint at which we have stopped. (We may have stopped for
2406 several reasons concurrently.)
2408 Each element of the chain has valid next, breakpoint_at,
2409 commands, FIXME??? fields. */
2412 bpstat_stop_status (CORE_ADDR *pc, int not_a_breakpoint)
2414 register struct breakpoint *b, *temp;
2416 /* True if we've hit a breakpoint (as opposed to a watchpoint). */
2417 int real_breakpoint = 0;
2418 /* Root of the chain of bpstat's */
2419 struct bpstats root_bs[1];
2420 /* Pointer to the last thing in the chain currently. */
2421 bpstat bs = root_bs;
2422 static char message1[] =
2423 "Error evaluating expression for watchpoint %d\n";
2424 char message[sizeof (message1) + 30 /* slop */ ];
2426 /* Get the address where the breakpoint would have been.
2427 The "not_a_breakpoint" argument is meant to distinguish
2428 between a breakpoint trap event and a trace/singlestep
2429 trap event. For a trace/singlestep trap event, we would
2430 not want to subtract DECR_PC_AFTER_BREAK from the PC. */
2432 bp_addr = *pc - (not_a_breakpoint && !SOFTWARE_SINGLE_STEP_P () ?
2433 0 : DECR_PC_AFTER_BREAK);
2435 ALL_BREAKPOINTS_SAFE (b, temp)
2437 if (b->enable_state == bp_disabled
2438 || b->enable_state == bp_shlib_disabled
2439 || b->enable_state == bp_call_disabled)
2442 if (b->type != bp_watchpoint
2443 && b->type != bp_hardware_watchpoint
2444 && b->type != bp_read_watchpoint
2445 && b->type != bp_access_watchpoint
2446 && b->type != bp_hardware_breakpoint
2447 && b->type != bp_catch_fork
2448 && b->type != bp_catch_vfork
2449 && b->type != bp_catch_exec
2450 && b->type != bp_catch_catch
2451 && b->type != bp_catch_throw) /* a non-watchpoint bp */
2453 if (b->address != bp_addr) /* address doesn't match */
2455 if (overlay_debugging /* unmapped overlay section */
2456 && section_is_overlay (b->section)
2457 && !section_is_mapped (b->section))
2461 if (b->type == bp_hardware_breakpoint)
2463 if (b->address != (*pc - DECR_PC_AFTER_HW_BREAK))
2465 if (overlay_debugging /* unmapped overlay section */
2466 && section_is_overlay (b->section)
2467 && !section_is_mapped (b->section))
2471 /* Is this a catchpoint of a load or unload? If so, did we
2472 get a load or unload of the specified library? If not,
2474 if ((b->type == bp_catch_load)
2475 #if defined(SOLIB_HAVE_LOAD_EVENT)
2476 && (!SOLIB_HAVE_LOAD_EVENT (PIDGET (inferior_ptid))
2477 || ((b->dll_pathname != NULL)
2478 && (strcmp (b->dll_pathname,
2479 SOLIB_LOADED_LIBRARY_PATHNAME (
2480 PIDGET (inferior_ptid)))
2486 if ((b->type == bp_catch_unload)
2487 #if defined(SOLIB_HAVE_UNLOAD_EVENT)
2488 && (!SOLIB_HAVE_UNLOAD_EVENT (PIDGET (inferior_ptid))
2489 || ((b->dll_pathname != NULL)
2490 && (strcmp (b->dll_pathname,
2491 SOLIB_UNLOADED_LIBRARY_PATHNAME (
2492 PIDGET (inferior_ptid)))
2498 if ((b->type == bp_catch_fork)
2499 && !target_has_forked (PIDGET (inferior_ptid),
2500 &b->forked_inferior_pid))
2503 if ((b->type == bp_catch_vfork)
2504 && !target_has_vforked (PIDGET (inferior_ptid),
2505 &b->forked_inferior_pid))
2508 if ((b->type == bp_catch_exec)
2509 && !target_has_execd (PIDGET (inferior_ptid), &b->exec_pathname))
2512 if (ep_is_exception_catchpoint (b) &&
2513 !(current_exception_event = target_get_current_exception_event ()))
2516 /* Come here if it's a watchpoint, or if the break address matches */
2518 bs = bpstat_alloc (b, bs); /* Alloc a bpstat to explain stop */
2520 /* Watchpoints may change this, if not found to have triggered. */
2524 sprintf (message, message1, b->number);
2525 if (b->type == bp_watchpoint ||
2526 b->type == bp_hardware_watchpoint)
2528 switch (catch_errors (watchpoint_check, bs, message,
2532 /* We've already printed what needs to be printed. */
2533 /* Actually this is superfluous, because by the time we
2534 call print_it_typical() the wp will be already deleted,
2535 and the function will return immediately. */
2536 bs->print_it = print_it_done;
2539 case WP_VALUE_CHANGED:
2543 case WP_VALUE_NOT_CHANGED:
2545 bs->print_it = print_it_noop;
2552 /* Error from catch_errors. */
2553 printf_filtered ("Watchpoint %d deleted.\n", b->number);
2554 if (b->related_breakpoint)
2555 b->related_breakpoint->disposition = disp_del_at_next_stop;
2556 b->disposition = disp_del_at_next_stop;
2557 /* We've already printed what needs to be printed. */
2558 bs->print_it = print_it_done;
2564 else if (b->type == bp_read_watchpoint ||
2565 b->type == bp_access_watchpoint)
2571 addr = target_stopped_data_address ();
2574 for (v = b->val_chain; v; v = v->next)
2576 if (VALUE_LVAL (v) == lval_memory
2577 && ! VALUE_LAZY (v))
2579 struct type *vtype = check_typedef (VALUE_TYPE (v));
2581 if (v == b->val_chain
2582 || (TYPE_CODE (vtype) != TYPE_CODE_STRUCT
2583 && TYPE_CODE (vtype) != TYPE_CODE_ARRAY))
2587 vaddr = VALUE_ADDRESS (v) + VALUE_OFFSET (v);
2588 /* Exact match not required. Within range is
2590 if (addr >= vaddr &&
2591 addr < vaddr + TYPE_LENGTH (VALUE_TYPE (v)))
2597 switch (catch_errors (watchpoint_check, bs, message,
2601 /* We've already printed what needs to be printed. */
2602 bs->print_it = print_it_done;
2605 case WP_VALUE_CHANGED:
2606 if (b->type == bp_read_watchpoint)
2608 /* Don't stop: read watchpoints shouldn't fire if
2609 the value has changed. This is for targets which
2610 cannot set read-only watchpoints. */
2611 bs->print_it = print_it_noop;
2617 case WP_VALUE_NOT_CHANGED:
2624 /* Error from catch_errors. */
2625 printf_filtered ("Watchpoint %d deleted.\n", b->number);
2626 if (b->related_breakpoint)
2627 b->related_breakpoint->disposition = disp_del_at_next_stop;
2628 b->disposition = disp_del_at_next_stop;
2629 /* We've already printed what needs to be printed. */
2630 bs->print_it = print_it_done;
2633 else /* found == 0 */
2635 /* This is a case where some watchpoint(s) triggered,
2636 but not at the address of this watchpoint (FOUND
2637 was left zero). So don't print anything for this
2639 bs->print_it = print_it_noop;
2646 /* By definition, an encountered breakpoint is a triggered
2650 real_breakpoint = 1;
2654 b->frame != (get_current_frame ())->frame)
2658 int value_is_zero = 0;
2662 /* Need to select the frame, with all that implies
2663 so that the conditions will have the right context. */
2664 select_frame (get_current_frame ());
2666 = catch_errors (breakpoint_cond_eval, (b->cond),
2667 "Error in testing breakpoint condition:\n",
2669 /* FIXME-someday, should give breakpoint # */
2672 if (b->cond && value_is_zero)
2675 /* Don't consider this a hit. */
2678 else if (b->ignore_count > 0)
2681 annotate_ignore_count_change ();
2686 /* We will stop here */
2687 if (b->disposition == disp_disable)
2688 b->enable_state = bp_disabled;
2689 bs->commands = b->commands;
2693 (STREQ ("silent", bs->commands->line) ||
2694 (xdb_commands && STREQ ("Q", bs->commands->line))))
2696 bs->commands = bs->commands->next;
2701 /* Print nothing for this entry if we dont stop or if we dont print. */
2702 if (bs->stop == 0 || bs->print == 0)
2703 bs->print_it = print_it_noop;
2706 bs->next = NULL; /* Terminate the chain */
2707 bs = root_bs->next; /* Re-grab the head of the chain */
2709 if (real_breakpoint && bs)
2711 if (bs->breakpoint_at->type == bp_hardware_breakpoint)
2713 if (DECR_PC_AFTER_HW_BREAK != 0)
2715 *pc = *pc - DECR_PC_AFTER_HW_BREAK;
2721 if (DECR_PC_AFTER_BREAK != 0 || must_shift_inst_regs)
2724 #if defined (SHIFT_INST_REGS)
2726 #else /* No SHIFT_INST_REGS. */
2728 #endif /* No SHIFT_INST_REGS. */
2733 /* The value of a hardware watchpoint hasn't changed, but the
2734 intermediate memory locations we are watching may have. */
2735 if (bs && !bs->stop &&
2736 (bs->breakpoint_at->type == bp_hardware_watchpoint ||
2737 bs->breakpoint_at->type == bp_read_watchpoint ||
2738 bs->breakpoint_at->type == bp_access_watchpoint))
2740 remove_breakpoints ();
2741 insert_breakpoints ();
2746 /* Tell what to do about this bpstat. */
2748 bpstat_what (bpstat bs)
2750 /* Classify each bpstat as one of the following. */
2753 /* This bpstat element has no effect on the main_action. */
2756 /* There was a watchpoint, stop but don't print. */
2759 /* There was a watchpoint, stop and print. */
2762 /* There was a breakpoint but we're not stopping. */
2765 /* There was a breakpoint, stop but don't print. */
2768 /* There was a breakpoint, stop and print. */
2771 /* We hit the longjmp breakpoint. */
2774 /* We hit the longjmp_resume breakpoint. */
2777 /* We hit the step_resume breakpoint. */
2780 /* We hit the through_sigtramp breakpoint. */
2783 /* We hit the shared library event breakpoint. */
2786 /* We caught a shared library event. */
2789 /* This is just used to count how many enums there are. */
2793 /* Here is the table which drives this routine. So that we can
2794 format it pretty, we define some abbreviations for the
2795 enum bpstat_what codes. */
2796 #define kc BPSTAT_WHAT_KEEP_CHECKING
2797 #define ss BPSTAT_WHAT_STOP_SILENT
2798 #define sn BPSTAT_WHAT_STOP_NOISY
2799 #define sgl BPSTAT_WHAT_SINGLE
2800 #define slr BPSTAT_WHAT_SET_LONGJMP_RESUME
2801 #define clr BPSTAT_WHAT_CLEAR_LONGJMP_RESUME
2802 #define clrs BPSTAT_WHAT_CLEAR_LONGJMP_RESUME_SINGLE
2803 #define sr BPSTAT_WHAT_STEP_RESUME
2804 #define ts BPSTAT_WHAT_THROUGH_SIGTRAMP
2805 #define shl BPSTAT_WHAT_CHECK_SHLIBS
2806 #define shlr BPSTAT_WHAT_CHECK_SHLIBS_RESUME_FROM_HOOK
2808 /* "Can't happen." Might want to print an error message.
2809 abort() is not out of the question, but chances are GDB is just
2810 a bit confused, not unusable. */
2811 #define err BPSTAT_WHAT_STOP_NOISY
2813 /* Given an old action and a class, come up with a new action. */
2814 /* One interesting property of this table is that wp_silent is the same
2815 as bp_silent and wp_noisy is the same as bp_noisy. That is because
2816 after stopping, the check for whether to step over a breakpoint
2817 (BPSTAT_WHAT_SINGLE type stuff) is handled in proceed() without
2818 reference to how we stopped. We retain separate wp_silent and
2819 bp_silent codes in case we want to change that someday.
2821 Another possibly interesting property of this table is that
2822 there's a partial ordering, priority-like, of the actions. Once
2823 you've decided that some action is appropriate, you'll never go
2824 back and decide something of a lower priority is better. The
2827 kc < clr sgl shl shlr slr sn sr ss ts
2828 sgl < clrs shl shlr slr sn sr ss ts
2829 slr < err shl shlr sn sr ss ts
2830 clr < clrs err shl shlr sn sr ss ts
2831 clrs < err shl shlr sn sr ss ts
2832 ss < shl shlr sn sr ts
2839 What I think this means is that we don't need a damned table
2840 here. If you just put the rows and columns in the right order,
2841 it'd look awfully regular. We could simply walk the bpstat list
2842 and choose the highest priority action we find, with a little
2843 logic to handle the 'err' cases, and the CLEAR_LONGJMP_RESUME/
2844 CLEAR_LONGJMP_RESUME_SINGLE distinction (which breakpoint.h says
2845 is messy anyway). */
2847 /* step_resume entries: a step resume breakpoint overrides another
2848 breakpoint of signal handling (see comment in wait_for_inferior
2849 at first PC_IN_SIGTRAMP where we set the step_resume breakpoint). */
2850 /* We handle the through_sigtramp_breakpoint the same way; having both
2851 one of those and a step_resume_breakpoint is probably very rare (?). */
2853 static const enum bpstat_what_main_action
2854 table[(int) class_last][(int) BPSTAT_WHAT_LAST] =
2857 /* kc ss sn sgl slr clr clrs sr ts shl shlr
2860 {kc, ss, sn, sgl, slr, clr, clrs, sr, ts, shl, shlr},
2862 {ss, ss, sn, ss, ss, ss, ss, sr, ts, shl, shlr},
2864 {sn, sn, sn, sn, sn, sn, sn, sr, ts, shl, shlr},
2866 {sgl, ss, sn, sgl, slr, clrs, clrs, sr, ts, shl, shlr},
2868 {ss, ss, sn, ss, ss, ss, ss, sr, ts, shl, shlr},
2870 {sn, sn, sn, sn, sn, sn, sn, sr, ts, shl, shlr},
2872 {slr, ss, sn, slr, slr, err, err, sr, ts, shl, shlr},
2874 {clr, ss, sn, clrs, err, err, err, sr, ts, shl, shlr},
2876 {sr, sr, sr, sr, sr, sr, sr, sr, ts, shl, shlr},
2878 {ts, ts, ts, ts, ts, ts, ts, ts, ts, shl, shlr},
2880 {shl, shl, shl, shl, shl, shl, shl, shl, ts, shl, shlr},
2882 {shlr, shlr, shlr, shlr, shlr, shlr, shlr, shlr, ts, shlr, shlr}
2897 enum bpstat_what_main_action current_action = BPSTAT_WHAT_KEEP_CHECKING;
2898 struct bpstat_what retval;
2900 retval.call_dummy = 0;
2901 for (; bs != NULL; bs = bs->next)
2903 enum class bs_class = no_effect;
2904 if (bs->breakpoint_at == NULL)
2905 /* I suspect this can happen if it was a momentary breakpoint
2906 which has since been deleted. */
2908 switch (bs->breakpoint_at->type)
2914 case bp_hardware_breakpoint:
2920 bs_class = bp_noisy;
2922 bs_class = bp_silent;
2925 bs_class = bp_nostop;
2928 case bp_hardware_watchpoint:
2929 case bp_read_watchpoint:
2930 case bp_access_watchpoint:
2934 bs_class = wp_noisy;
2936 bs_class = wp_silent;
2939 /* There was a watchpoint, but we're not stopping.
2940 This requires no further action. */
2941 bs_class = no_effect;
2944 bs_class = long_jump;
2946 case bp_longjmp_resume:
2947 bs_class = long_resume;
2949 case bp_step_resume:
2952 bs_class = step_resume;
2955 /* It is for the wrong frame. */
2956 bs_class = bp_nostop;
2958 case bp_through_sigtramp:
2959 bs_class = through_sig;
2961 case bp_watchpoint_scope:
2962 bs_class = bp_nostop;
2964 case bp_shlib_event:
2965 bs_class = shlib_event;
2967 case bp_thread_event:
2968 case bp_overlay_event:
2969 bs_class = bp_nostop;
2972 case bp_catch_unload:
2973 /* Only if this catchpoint triggered should we cause the
2974 step-out-of-dld behaviour. Otherwise, we ignore this
2977 bs_class = catch_shlib_event;
2979 bs_class = no_effect;
2982 case bp_catch_vfork:
2987 bs_class = bp_noisy;
2989 bs_class = bp_silent;
2992 /* There was a catchpoint, but we're not stopping.
2993 This requires no further action. */
2994 bs_class = no_effect;
2996 case bp_catch_catch:
2997 if (!bs->stop || CURRENT_EXCEPTION_KIND != EX_EVENT_CATCH)
2998 bs_class = bp_nostop;
3000 bs_class = bs->print ? bp_noisy : bp_silent;
3002 case bp_catch_throw:
3003 if (!bs->stop || CURRENT_EXCEPTION_KIND != EX_EVENT_THROW)
3004 bs_class = bp_nostop;
3006 bs_class = bs->print ? bp_noisy : bp_silent;
3009 /* Make sure the action is stop (silent or noisy),
3010 so infrun.c pops the dummy frame. */
3011 bs_class = bp_silent;
3012 retval.call_dummy = 1;
3015 current_action = table[(int) bs_class][(int) current_action];
3017 retval.main_action = current_action;
3021 /* Nonzero if we should step constantly (e.g. watchpoints on machines
3022 without hardware support). This isn't related to a specific bpstat,
3023 just to things like whether watchpoints are set. */
3026 bpstat_should_step (void)
3028 struct breakpoint *b;
3030 if (b->enable_state == bp_enabled && b->type == bp_watchpoint)
3035 /* Nonzero if there are enabled hardware watchpoints. */
3037 bpstat_have_active_hw_watchpoints (void)
3039 struct breakpoint *b;
3041 if ((b->enable_state == bp_enabled) &&
3043 ((b->type == bp_hardware_watchpoint) ||
3044 (b->type == bp_read_watchpoint) ||
3045 (b->type == bp_access_watchpoint)))
3051 /* Given a bpstat that records zero or more triggered eventpoints, this
3052 function returns another bpstat which contains only the catchpoints
3053 on that first list, if any. */
3055 bpstat_get_triggered_catchpoints (bpstat ep_list, bpstat *cp_list)
3057 struct bpstats root_bs[1];
3058 bpstat bs = root_bs;
3059 struct breakpoint *ep;
3062 bpstat_clear (cp_list);
3063 root_bs->next = NULL;
3065 for (; ep_list != NULL; ep_list = ep_list->next)
3067 /* Is this eventpoint a catchpoint? If not, ignore it. */
3068 ep = ep_list->breakpoint_at;
3071 if ((ep->type != bp_catch_load) &&
3072 (ep->type != bp_catch_unload) &&
3073 (ep->type != bp_catch_catch) &&
3074 (ep->type != bp_catch_throw))
3075 /* pai: (temp) ADD fork/vfork here!! */
3078 /* Yes; add it to the list. */
3079 bs = bpstat_alloc (ep, bs);
3084 #if defined(SOLIB_ADD)
3085 /* Also, for each triggered catchpoint, tag it with the name of
3086 the library that caused this trigger. (We copy the name now,
3087 because it's only guaranteed to be available NOW, when the
3088 catchpoint triggers. Clients who may wish to know the name
3089 later must get it from the catchpoint itself.) */
3090 if (ep->triggered_dll_pathname != NULL)
3091 xfree (ep->triggered_dll_pathname);
3092 if (ep->type == bp_catch_load)
3093 dll_pathname = SOLIB_LOADED_LIBRARY_PATHNAME (
3094 PIDGET (inferior_ptid));
3096 dll_pathname = SOLIB_UNLOADED_LIBRARY_PATHNAME (
3097 PIDGET (inferior_ptid));
3099 dll_pathname = NULL;
3103 ep->triggered_dll_pathname = (char *)
3104 xmalloc (strlen (dll_pathname) + 1);
3105 strcpy (ep->triggered_dll_pathname, dll_pathname);
3108 ep->triggered_dll_pathname = NULL;
3114 /* Print B to gdb_stdout. */
3116 print_one_breakpoint (struct breakpoint *b,
3117 CORE_ADDR *last_addr)
3119 register struct command_line *l;
3120 register struct symbol *sym;
3121 struct ep_type_description
3126 static struct ep_type_description bptypes[] =
3128 {bp_none, "?deleted?"},
3129 {bp_breakpoint, "breakpoint"},
3130 {bp_hardware_breakpoint, "hw breakpoint"},
3131 {bp_until, "until"},
3132 {bp_finish, "finish"},
3133 {bp_watchpoint, "watchpoint"},
3134 {bp_hardware_watchpoint, "hw watchpoint"},
3135 {bp_read_watchpoint, "read watchpoint"},
3136 {bp_access_watchpoint, "acc watchpoint"},
3137 {bp_longjmp, "longjmp"},
3138 {bp_longjmp_resume, "longjmp resume"},
3139 {bp_step_resume, "step resume"},
3140 {bp_through_sigtramp, "sigtramp"},
3141 {bp_watchpoint_scope, "watchpoint scope"},
3142 {bp_call_dummy, "call dummy"},
3143 {bp_shlib_event, "shlib events"},
3144 {bp_thread_event, "thread events"},
3145 {bp_overlay_event, "overlay events"},
3146 {bp_catch_load, "catch load"},
3147 {bp_catch_unload, "catch unload"},
3148 {bp_catch_fork, "catch fork"},
3149 {bp_catch_vfork, "catch vfork"},
3150 {bp_catch_exec, "catch exec"},
3151 {bp_catch_catch, "catch catch"},
3152 {bp_catch_throw, "catch throw"}
3155 static char *bpdisps[] =
3156 {"del", "dstp", "dis", "keep"};
3157 static char bpenables[] = "nynny";
3158 char wrap_indent[80];
3159 struct ui_stream *stb = ui_out_stream_new (uiout);
3160 struct cleanup *old_chain = make_cleanup_ui_out_stream_delete (stb);
3163 ui_out_tuple_begin (uiout, "bkpt");
3167 ui_out_field_int (uiout, "number", b->number);
3171 if (((int) b->type > (sizeof (bptypes) / sizeof (bptypes[0])))
3172 || ((int) b->type != bptypes[(int) b->type].type))
3173 internal_error (__FILE__, __LINE__,
3174 "bptypes table does not describe type #%d.",
3176 ui_out_field_string (uiout, "type", bptypes[(int) b->type].description);
3180 ui_out_field_string (uiout, "disp", bpdisps[(int) b->disposition]);
3184 ui_out_field_fmt (uiout, "enabled", "%c", bpenables[(int) b->enable_state]);
3185 ui_out_spaces (uiout, 2);
3188 strcpy (wrap_indent, " ");
3191 if (TARGET_ADDR_BIT <= 32)
3192 strcat (wrap_indent, " ");
3194 strcat (wrap_indent, " ");
3199 internal_error (__FILE__, __LINE__,
3200 "print_one_breakpoint: bp_none encountered\n");
3204 case bp_hardware_watchpoint:
3205 case bp_read_watchpoint:
3206 case bp_access_watchpoint:
3207 /* Field 4, the address, is omitted (which makes the columns
3208 not line up too nicely with the headers, but the effect
3209 is relatively readable). */
3211 ui_out_field_skip (uiout, "addr");
3213 print_expression (b->exp, stb->stream);
3214 ui_out_field_stream (uiout, "what", stb);
3218 case bp_catch_unload:
3219 /* Field 4, the address, is omitted (which makes the columns
3220 not line up too nicely with the headers, but the effect
3221 is relatively readable). */
3223 ui_out_field_skip (uiout, "addr");
3225 if (b->dll_pathname == NULL)
3227 ui_out_field_string (uiout, "what", "<any library>");
3228 ui_out_spaces (uiout, 1);
3232 ui_out_text (uiout, "library \"");
3233 ui_out_field_string (uiout, "what", b->dll_pathname);
3234 ui_out_text (uiout, "\" ");
3239 case bp_catch_vfork:
3240 /* Field 4, the address, is omitted (which makes the columns
3241 not line up too nicely with the headers, but the effect
3242 is relatively readable). */
3244 ui_out_field_skip (uiout, "addr");
3246 if (b->forked_inferior_pid != 0)
3248 ui_out_text (uiout, "process ");
3249 ui_out_field_int (uiout, "what", b->forked_inferior_pid);
3250 ui_out_spaces (uiout, 1);
3254 /* Field 4, the address, is omitted (which makes the columns
3255 not line up too nicely with the headers, but the effect
3256 is relatively readable). */
3258 ui_out_field_skip (uiout, "addr");
3260 if (b->exec_pathname != NULL)
3262 ui_out_text (uiout, "program \"");
3263 ui_out_field_string (uiout, "what", b->exec_pathname);
3264 ui_out_text (uiout, "\" ");
3268 case bp_catch_catch:
3269 /* Field 4, the address, is omitted (which makes the columns
3270 not line up too nicely with the headers, but the effect
3271 is relatively readable). */
3273 ui_out_field_skip (uiout, "addr");
3275 ui_out_field_string (uiout, "what", "exception catch");
3276 ui_out_spaces (uiout, 1);
3279 case bp_catch_throw:
3280 /* Field 4, the address, is omitted (which makes the columns
3281 not line up too nicely with the headers, but the effect
3282 is relatively readable). */
3284 ui_out_field_skip (uiout, "addr");
3286 ui_out_field_string (uiout, "what", "exception throw");
3287 ui_out_spaces (uiout, 1);
3291 case bp_hardware_breakpoint:
3295 case bp_longjmp_resume:
3296 case bp_step_resume:
3297 case bp_through_sigtramp:
3298 case bp_watchpoint_scope:
3300 case bp_shlib_event:
3301 case bp_thread_event:
3302 case bp_overlay_event:
3306 ui_out_field_core_addr (uiout, "addr", b->address);
3309 *last_addr = b->address;
3312 sym = find_pc_sect_function (b->address, b->section);
3315 ui_out_text (uiout, "in ");
3316 ui_out_field_string (uiout, "func",
3317 SYMBOL_SOURCE_NAME (sym));
3318 ui_out_wrap_hint (uiout, wrap_indent);
3319 ui_out_text (uiout, " at ");
3321 ui_out_field_string (uiout, "file", b->source_file);
3322 ui_out_text (uiout, ":");
3323 ui_out_field_int (uiout, "line", b->line_number);
3327 print_address_symbolic (b->address, stb->stream, demangle, "");
3328 ui_out_field_stream (uiout, "at", stb);
3333 if (b->thread != -1)
3335 /* FIXME: This seems to be redundant and lost here; see the
3336 "stop only in" line a little further down. */
3337 ui_out_text (uiout, " thread ");
3338 ui_out_field_int (uiout, "thread", b->thread);
3341 ui_out_text (uiout, "\n");
3346 ui_out_text (uiout, "\tstop only in stack frame at ");
3347 ui_out_field_core_addr (uiout, "frame", b->frame);
3348 ui_out_text (uiout, "\n");
3354 ui_out_text (uiout, "\tstop only if ");
3355 print_expression (b->cond, stb->stream);
3356 ui_out_field_stream (uiout, "cond", stb);
3357 ui_out_text (uiout, "\n");
3360 if (b->thread != -1)
3362 /* FIXME should make an annotation for this */
3363 ui_out_text (uiout, "\tstop only in thread ");
3364 ui_out_field_int (uiout, "thread", b->thread);
3365 ui_out_text (uiout, "\n");
3368 if (show_breakpoint_hit_counts && b->hit_count)
3370 /* FIXME should make an annotation for this */
3371 if (ep_is_catchpoint (b))
3372 ui_out_text (uiout, "\tcatchpoint");
3374 ui_out_text (uiout, "\tbreakpoint");
3375 ui_out_text (uiout, " already hit ");
3376 ui_out_field_int (uiout, "times", b->hit_count);
3377 if (b->hit_count == 1)
3378 ui_out_text (uiout, " time\n");
3380 ui_out_text (uiout, " times\n");
3383 /* Output the count also if it is zero, but only if this is
3384 mi. FIXME: Should have a better test for this. */
3385 if (ui_out_is_mi_like_p (uiout))
3386 if (show_breakpoint_hit_counts && b->hit_count == 0)
3387 ui_out_field_int (uiout, "times", b->hit_count);
3389 if (b->ignore_count)
3392 ui_out_text (uiout, "\tignore next ");
3393 ui_out_field_int (uiout, "ignore", b->ignore_count);
3394 ui_out_text (uiout, " hits\n");
3397 if ((l = b->commands))
3400 ui_out_tuple_begin (uiout, "script");
3401 print_command_lines (uiout, l, 4);
3402 ui_out_tuple_end (uiout);
3404 ui_out_tuple_end (uiout);
3405 do_cleanups (old_chain);
3408 struct captured_breakpoint_query_args
3414 do_captured_breakpoint_query (struct ui_out *uiout, void *data)
3416 struct captured_breakpoint_query_args *args = data;
3417 register struct breakpoint *b;
3418 CORE_ADDR dummy_addr = 0;
3421 if (args->bnum == b->number)
3423 print_one_breakpoint (b, &dummy_addr);
3431 gdb_breakpoint_query (struct ui_out *uiout, int bnum)
3433 struct captured_breakpoint_query_args args;
3435 /* For the moment we don't trust print_one_breakpoint() to not throw
3437 return catch_exceptions (uiout, do_captured_breakpoint_query, &args,
3438 NULL, RETURN_MASK_ALL);
3441 /* Return non-zero if B is user settable (breakpoints, watchpoints,
3442 catchpoints, et.al.). */
3445 user_settable_breakpoint (const struct breakpoint *b)
3447 return (b->type == bp_breakpoint
3448 || b->type == bp_catch_load
3449 || b->type == bp_catch_unload
3450 || b->type == bp_catch_fork
3451 || b->type == bp_catch_vfork
3452 || b->type == bp_catch_exec
3453 || b->type == bp_catch_catch
3454 || b->type == bp_catch_throw
3455 || b->type == bp_hardware_breakpoint
3456 || b->type == bp_watchpoint
3457 || b->type == bp_read_watchpoint
3458 || b->type == bp_access_watchpoint
3459 || b->type == bp_hardware_watchpoint);
3462 /* Print information on user settable breakpoint (watchpoint, etc)
3463 number BNUM. If BNUM is -1 print all user settable breakpoints.
3464 If ALLFLAG is non-zero, include non- user settable breakpoints. */
3467 breakpoint_1 (int bnum, int allflag)
3469 register struct breakpoint *b;
3470 CORE_ADDR last_addr = (CORE_ADDR) -1;
3471 int nr_printable_breakpoints;
3473 /* Compute the number of rows in the table. */
3474 nr_printable_breakpoints = 0;
3477 || bnum == b->number)
3479 if (allflag || user_settable_breakpoint (b))
3480 nr_printable_breakpoints++;
3484 ui_out_table_begin (uiout, 6, nr_printable_breakpoints, "BreakpointTable");
3486 ui_out_table_begin (uiout, 5, nr_printable_breakpoints, "BreakpointTable");
3488 if (nr_printable_breakpoints > 0)
3489 annotate_breakpoints_headers ();
3490 if (nr_printable_breakpoints > 0)
3492 ui_out_table_header (uiout, 3, ui_left, "number", "Num"); /* 1 */
3493 if (nr_printable_breakpoints > 0)
3495 ui_out_table_header (uiout, 14, ui_left, "type", "Type"); /* 2 */
3496 if (nr_printable_breakpoints > 0)
3498 ui_out_table_header (uiout, 4, ui_left, "disp", "Disp"); /* 3 */
3499 if (nr_printable_breakpoints > 0)
3501 ui_out_table_header (uiout, 3, ui_left, "enabled", "Enb"); /* 4 */
3504 if (nr_printable_breakpoints > 0)
3506 if (TARGET_ADDR_BIT <= 32)
3507 ui_out_table_header (uiout, 10, ui_left, "addr", "Address");/* 5 */
3509 ui_out_table_header (uiout, 18, ui_left, "addr", "Address");/* 5 */
3511 if (nr_printable_breakpoints > 0)
3513 ui_out_table_header (uiout, 40, ui_noalign, "what", "What"); /* 6 */
3514 ui_out_table_body (uiout);
3515 if (nr_printable_breakpoints > 0)
3516 annotate_breakpoints_table ();
3520 || bnum == b->number)
3522 /* We only print out user settable breakpoints unless the
3524 if (allflag || user_settable_breakpoint (b))
3525 print_one_breakpoint (b, &last_addr);
3528 ui_out_table_end (uiout);
3530 if (nr_printable_breakpoints == 0)
3533 ui_out_message (uiout, 0, "No breakpoints or watchpoints.\n");
3535 ui_out_message (uiout, 0, "No breakpoint or watchpoint number %d.\n",
3540 /* Compare against (CORE_ADDR)-1 in case some compiler decides
3541 that a comparison of an unsigned with -1 is always false. */
3542 if (last_addr != (CORE_ADDR) -1)
3543 set_next_address (last_addr);
3546 /* FIXME? Should this be moved up so that it is only called when
3547 there have been breakpoints? */
3548 annotate_breakpoints_table_end ();
3553 breakpoints_info (char *bnum_exp, int from_tty)
3558 bnum = parse_and_eval_long (bnum_exp);
3560 breakpoint_1 (bnum, 0);
3565 maintenance_info_breakpoints (char *bnum_exp, int from_tty)
3570 bnum = parse_and_eval_long (bnum_exp);
3572 breakpoint_1 (bnum, 1);
3575 /* Print a message describing any breakpoints set at PC. */
3578 describe_other_breakpoints (CORE_ADDR pc, asection *section)
3580 register int others = 0;
3581 register struct breakpoint *b;
3584 if (b->address == pc) /* address match / overlay match */
3585 if (!overlay_debugging || b->section == section)
3589 printf_filtered ("Note: breakpoint%s ", (others > 1) ? "s" : "");
3591 if (b->address == pc) /* address match / overlay match */
3592 if (!overlay_debugging || b->section == section)
3595 printf_filtered ("%d%s%s ",
3597 ((b->enable_state == bp_disabled ||
3598 b->enable_state == bp_shlib_disabled ||
3599 b->enable_state == bp_call_disabled)
3601 : b->enable_state == bp_permanent
3605 : ((others == 1) ? " and" : ""));
3607 printf_filtered ("also set at pc ");
3608 print_address_numeric (pc, 1, gdb_stdout);
3609 printf_filtered (".\n");
3613 /* Set the default place to put a breakpoint
3614 for the `break' command with no arguments. */
3617 set_default_breakpoint (int valid, CORE_ADDR addr, struct symtab *symtab,
3620 default_breakpoint_valid = valid;
3621 default_breakpoint_address = addr;
3622 default_breakpoint_symtab = symtab;
3623 default_breakpoint_line = line;
3626 /* Return true iff it is meaningful to use the address member of
3627 BPT. For some breakpoint types, the address member is irrelevant
3628 and it makes no sense to attempt to compare it to other addresses
3629 (or use it for any other purpose either).
3631 More specifically, each of the following breakpoint types will always
3632 have a zero valued address and we don't want check_duplicates() to mark
3633 breakpoints of any of these types to be a duplicate of an actual
3634 breakpoint at address zero:
3637 bp_hardware_watchpoint
3639 bp_access_watchpoint
3646 breakpoint_address_is_meaningful (struct breakpoint *bpt)
3648 enum bptype type = bpt->type;
3650 return (type != bp_watchpoint
3651 && type != bp_hardware_watchpoint
3652 && type != bp_read_watchpoint
3653 && type != bp_access_watchpoint
3654 && type != bp_catch_exec
3655 && type != bp_longjmp_resume
3656 && type != bp_catch_fork
3657 && type != bp_catch_vfork);
3660 /* Rescan breakpoints at the same address and section as BPT,
3661 marking the first one as "first" and any others as "duplicates".
3662 This is so that the bpt instruction is only inserted once.
3663 If we have a permanent breakpoint at the same place as BPT, make
3664 that one the official one, and the rest as duplicates. */
3667 check_duplicates (struct breakpoint *bpt)
3669 register struct breakpoint *b;
3670 register int count = 0;
3671 struct breakpoint *perm_bp = 0;
3672 CORE_ADDR address = bpt->address;
3673 asection *section = bpt->section;
3675 if (! breakpoint_address_is_meaningful (bpt))
3679 if (b->enable_state != bp_disabled
3680 && b->enable_state != bp_shlib_disabled
3681 && b->enable_state != bp_call_disabled
3682 && b->address == address /* address / overlay match */
3683 && (!overlay_debugging || b->section == section)
3684 && breakpoint_address_is_meaningful (b))
3686 /* Have we found a permanent breakpoint? */
3687 if (b->enable_state == bp_permanent)
3694 b->duplicate = count > 1;
3697 /* If we found a permanent breakpoint at this address, go over the
3698 list again and declare all the other breakpoints there to be the
3702 perm_bp->duplicate = 0;
3704 /* Permanent breakpoint should always be inserted. */
3705 if (! perm_bp->inserted)
3706 internal_error (__FILE__, __LINE__,
3707 "allegedly permanent breakpoint is not "
3708 "actually inserted");
3714 internal_error (__FILE__, __LINE__,
3715 "another breakpoint was inserted on top of "
3716 "a permanent breakpoint");
3718 if (b->enable_state != bp_disabled
3719 && b->enable_state != bp_shlib_disabled
3720 && b->enable_state != bp_call_disabled
3721 && b->address == address /* address / overlay match */
3722 && (!overlay_debugging || b->section == section)
3723 && breakpoint_address_is_meaningful (b))
3729 /* set_raw_breakpoint() is a low level routine for allocating and
3730 partially initializing a breakpoint of type BPTYPE. The newly
3731 created breakpoint's address, section, source file name, and line
3732 number are provided by SAL. The newly created and partially
3733 initialized breakpoint is added to the breakpoint chain and
3734 is also returned as the value of this function.
3736 It is expected that the caller will complete the initialization of
3737 the newly created breakpoint struct as well as output any status
3738 information regarding the creation of a new breakpoint. In
3739 particular, set_raw_breakpoint() does NOT set the breakpoint
3740 number! Care should be taken to not allow an error() to occur
3741 prior to completing the initialization of the breakpoint. If this
3742 should happen, a bogus breakpoint will be left on the chain. */
3745 set_raw_breakpoint (struct symtab_and_line sal, enum bptype bptype)
3747 register struct breakpoint *b, *b1;
3749 b = (struct breakpoint *) xmalloc (sizeof (struct breakpoint));
3750 memset (b, 0, sizeof (*b));
3751 b->address = sal.pc;
3752 if (sal.symtab == NULL)
3753 b->source_file = NULL;
3755 b->source_file = savestring (sal.symtab->filename,
3756 strlen (sal.symtab->filename));
3757 b->section = sal.section;
3759 b->language = current_language->la_language;
3760 b->input_radix = input_radix;
3762 b->line_number = sal.line;
3763 b->enable_state = bp_enabled;
3766 b->ignore_count = 0;
3769 b->dll_pathname = NULL;
3770 b->triggered_dll_pathname = NULL;
3771 b->forked_inferior_pid = 0;
3772 b->exec_pathname = NULL;
3774 /* Add this breakpoint to the end of the chain
3775 so that a list of breakpoints will come out in order
3776 of increasing numbers. */
3778 b1 = breakpoint_chain;
3780 breakpoint_chain = b;
3788 check_duplicates (b);
3789 breakpoints_changed ();
3795 /* Note that the breakpoint object B describes a permanent breakpoint
3796 instruction, hard-wired into the inferior's code. */
3798 make_breakpoint_permanent (struct breakpoint *b)
3800 b->enable_state = bp_permanent;
3802 /* By definition, permanent breakpoints are already present in the code. */
3806 static struct breakpoint *
3807 create_internal_breakpoint (CORE_ADDR address, enum bptype type)
3809 static int internal_breakpoint_number = -1;
3810 struct symtab_and_line sal;
3811 struct breakpoint *b;
3813 INIT_SAL (&sal); /* initialize to zeroes */
3816 sal.section = find_pc_overlay (sal.pc);
3818 b = set_raw_breakpoint (sal, type);
3819 b->number = internal_breakpoint_number--;
3820 b->disposition = disp_donttouch;
3827 create_longjmp_breakpoint (char *func_name)
3829 struct breakpoint *b;
3830 struct minimal_symbol *m;
3832 if (func_name == NULL)
3833 b = create_internal_breakpoint (0, bp_longjmp_resume);
3836 if ((m = lookup_minimal_symbol_text (func_name, NULL, NULL)) == NULL)
3839 b = create_internal_breakpoint (SYMBOL_VALUE_ADDRESS (m), bp_longjmp);
3842 b->enable_state = bp_disabled;
3845 b->addr_string = xstrdup (func_name);
3848 /* Call this routine when stepping and nexting to enable a breakpoint
3849 if we do a longjmp(). When we hit that breakpoint, call
3850 set_longjmp_resume_breakpoint() to figure out where we are going. */
3853 enable_longjmp_breakpoint (void)
3855 register struct breakpoint *b;
3858 if (b->type == bp_longjmp)
3860 b->enable_state = bp_enabled;
3861 check_duplicates (b);
3866 disable_longjmp_breakpoint (void)
3868 register struct breakpoint *b;
3871 if (b->type == bp_longjmp
3872 || b->type == bp_longjmp_resume)
3874 b->enable_state = bp_disabled;
3875 check_duplicates (b);
3880 create_overlay_event_breakpoint (char *func_name)
3882 struct breakpoint *b;
3883 struct minimal_symbol *m;
3885 if ((m = lookup_minimal_symbol_text (func_name, NULL, NULL)) == NULL)
3888 b = create_internal_breakpoint (SYMBOL_VALUE_ADDRESS (m),
3890 b->addr_string = xstrdup (func_name);
3892 if (overlay_debugging == ovly_auto)
3894 b->enable_state = bp_enabled;
3895 overlay_events_enabled = 1;
3899 b->enable_state = bp_disabled;
3900 overlay_events_enabled = 0;
3905 enable_overlay_breakpoints (void)
3907 register struct breakpoint *b;
3910 if (b->type == bp_overlay_event)
3912 b->enable_state = bp_enabled;
3913 check_duplicates (b);
3914 overlay_events_enabled = 1;
3919 disable_overlay_breakpoints (void)
3921 register struct breakpoint *b;
3924 if (b->type == bp_overlay_event)
3926 b->enable_state = bp_disabled;
3927 check_duplicates (b);
3928 overlay_events_enabled = 0;
3933 create_thread_event_breakpoint (CORE_ADDR address)
3935 struct breakpoint *b;
3936 char addr_string[80]; /* Surely an addr can't be longer than that. */
3938 b = create_internal_breakpoint (address, bp_thread_event);
3940 b->enable_state = bp_enabled;
3941 /* addr_string has to be used or breakpoint_re_set will delete me. */
3942 sprintf (addr_string, "*0x%s", paddr (b->address));
3943 b->addr_string = xstrdup (addr_string);
3949 remove_thread_event_breakpoints (void)
3951 struct breakpoint *b, *temp;
3953 ALL_BREAKPOINTS_SAFE (b, temp)
3954 if (b->type == bp_thread_event)
3955 delete_breakpoint (b);
3960 remove_solib_event_breakpoints (void)
3962 register struct breakpoint *b, *temp;
3964 ALL_BREAKPOINTS_SAFE (b, temp)
3965 if (b->type == bp_shlib_event)
3966 delete_breakpoint (b);
3970 create_solib_event_breakpoint (CORE_ADDR address)
3972 struct breakpoint *b;
3974 b = create_internal_breakpoint (address, bp_shlib_event);
3978 /* Disable any breakpoints that are on code in shared libraries. Only
3979 apply to enabled breakpoints, disabled ones can just stay disabled. */
3982 disable_breakpoints_in_shlibs (int silent)
3984 struct breakpoint *b;
3985 int disabled_shlib_breaks = 0;
3987 /* See also: insert_breakpoints, under DISABLE_UNSETTABLE_BREAK. */
3990 #if defined (PC_SOLIB)
3991 if (((b->type == bp_breakpoint) ||
3992 (b->type == bp_hardware_breakpoint)) &&
3993 b->enable_state == bp_enabled &&
3995 PC_SOLIB (b->address))
3997 b->enable_state = bp_shlib_disabled;
4000 if (!disabled_shlib_breaks)
4002 target_terminal_ours_for_output ();
4003 warning ("Temporarily disabling shared library breakpoints:");
4005 disabled_shlib_breaks = 1;
4006 warning ("breakpoint #%d ", b->number);
4013 /* Try to reenable any breakpoints in shared libraries. */
4015 re_enable_breakpoints_in_shlibs (void)
4017 struct breakpoint *b;
4020 if (b->enable_state == bp_shlib_disabled)
4024 /* Do not reenable the breakpoint if the shared library
4025 is still not mapped in. */
4026 if (target_read_memory (b->address, buf, 1) == 0)
4027 b->enable_state = bp_enabled;
4034 solib_load_unload_1 (char *hookname, int tempflag, char *dll_pathname,
4035 char *cond_string, enum bptype bp_kind)
4037 struct breakpoint *b;
4038 struct symtabs_and_lines sals;
4039 struct cleanup *old_chain;
4040 struct cleanup *canonical_strings_chain = NULL;
4041 char *addr_start = hookname;
4042 char *addr_end = NULL;
4043 char **canonical = (char **) NULL;
4044 int thread = -1; /* All threads. */
4046 /* Set a breakpoint on the specified hook. */
4047 sals = decode_line_1 (&hookname, 1, (struct symtab *) NULL, 0, &canonical);
4048 addr_end = hookname;
4050 if (sals.nelts == 0)
4052 warning ("Unable to set a breakpoint on dynamic linker callback.");
4053 warning ("Suggest linking with /opt/langtools/lib/end.o.");
4054 warning ("GDB will be unable to track shl_load/shl_unload calls");
4057 if (sals.nelts != 1)
4059 warning ("Unable to set unique breakpoint on dynamic linker callback.");
4060 warning ("GDB will be unable to track shl_load/shl_unload calls");
4064 /* Make sure that all storage allocated in decode_line_1 gets freed
4065 in case the following errors out. */
4066 old_chain = make_cleanup (xfree, sals.sals);
4067 if (canonical != (char **) NULL)
4069 make_cleanup (xfree, canonical);
4070 canonical_strings_chain = make_cleanup (null_cleanup, 0);
4071 if (canonical[0] != NULL)
4072 make_cleanup (xfree, canonical[0]);
4075 resolve_sal_pc (&sals.sals[0]);
4077 /* Remove the canonical strings from the cleanup, they are needed below. */
4078 if (canonical != (char **) NULL)
4079 discard_cleanups (canonical_strings_chain);
4081 b = set_raw_breakpoint (sals.sals[0], bp_kind);
4082 set_breakpoint_count (breakpoint_count + 1);
4083 b->number = breakpoint_count;
4085 b->cond_string = (cond_string == NULL) ?
4086 NULL : savestring (cond_string, strlen (cond_string));
4089 if (canonical != (char **) NULL && canonical[0] != NULL)
4090 b->addr_string = canonical[0];
4091 else if (addr_start)
4092 b->addr_string = savestring (addr_start, addr_end - addr_start);
4094 b->enable_state = bp_enabled;
4095 b->disposition = tempflag ? disp_del : disp_donttouch;
4097 if (dll_pathname == NULL)
4098 b->dll_pathname = NULL;
4101 b->dll_pathname = (char *) xmalloc (strlen (dll_pathname) + 1);
4102 strcpy (b->dll_pathname, dll_pathname);
4106 do_cleanups (old_chain);
4110 create_solib_load_event_breakpoint (char *hookname, int tempflag,
4111 char *dll_pathname, char *cond_string)
4113 solib_load_unload_1 (hookname, tempflag, dll_pathname,
4114 cond_string, bp_catch_load);
4118 create_solib_unload_event_breakpoint (char *hookname, int tempflag,
4119 char *dll_pathname, char *cond_string)
4121 solib_load_unload_1 (hookname,tempflag, dll_pathname,
4122 cond_string, bp_catch_unload);
4126 create_fork_vfork_event_catchpoint (int tempflag, char *cond_string,
4127 enum bptype bp_kind)
4129 struct symtab_and_line sal;
4130 struct breakpoint *b;
4131 int thread = -1; /* All threads. */
4138 b = set_raw_breakpoint (sal, bp_kind);
4139 set_breakpoint_count (breakpoint_count + 1);
4140 b->number = breakpoint_count;
4142 b->cond_string = (cond_string == NULL) ?
4143 NULL : savestring (cond_string, strlen (cond_string));
4145 b->addr_string = NULL;
4146 b->enable_state = bp_enabled;
4147 b->disposition = tempflag ? disp_del : disp_donttouch;
4148 b->forked_inferior_pid = 0;
4154 create_fork_event_catchpoint (int tempflag, char *cond_string)
4156 create_fork_vfork_event_catchpoint (tempflag, cond_string, bp_catch_fork);
4160 create_vfork_event_catchpoint (int tempflag, char *cond_string)
4162 create_fork_vfork_event_catchpoint (tempflag, cond_string, bp_catch_vfork);
4166 create_exec_event_catchpoint (int tempflag, char *cond_string)
4168 struct symtab_and_line sal;
4169 struct breakpoint *b;
4170 int thread = -1; /* All threads. */
4177 b = set_raw_breakpoint (sal, bp_catch_exec);
4178 set_breakpoint_count (breakpoint_count + 1);
4179 b->number = breakpoint_count;
4181 b->cond_string = (cond_string == NULL) ?
4182 NULL : savestring (cond_string, strlen (cond_string));
4184 b->addr_string = NULL;
4185 b->enable_state = bp_enabled;
4186 b->disposition = tempflag ? disp_del : disp_donttouch;
4192 hw_breakpoint_used_count (void)
4194 register struct breakpoint *b;
4199 if (b->type == bp_hardware_breakpoint && b->enable_state == bp_enabled)
4207 hw_watchpoint_used_count (enum bptype type, int *other_type_used)
4209 register struct breakpoint *b;
4212 *other_type_used = 0;
4215 if (b->enable_state == bp_enabled)
4217 if (b->type == type)
4219 else if ((b->type == bp_hardware_watchpoint ||
4220 b->type == bp_read_watchpoint ||
4221 b->type == bp_access_watchpoint)
4222 && b->enable_state == bp_enabled)
4223 *other_type_used = 1;
4229 /* Call this after hitting the longjmp() breakpoint. Use this to set
4230 a new breakpoint at the target of the jmp_buf.
4232 FIXME - This ought to be done by setting a temporary breakpoint
4233 that gets deleted automatically... */
4236 set_longjmp_resume_breakpoint (CORE_ADDR pc, struct frame_info *frame)
4238 register struct breakpoint *b;
4241 if (b->type == bp_longjmp_resume)
4244 b->enable_state = bp_enabled;
4246 b->frame = frame->frame;
4249 check_duplicates (b);
4255 disable_watchpoints_before_interactive_call_start (void)
4257 struct breakpoint *b;
4261 if (((b->type == bp_watchpoint)
4262 || (b->type == bp_hardware_watchpoint)
4263 || (b->type == bp_read_watchpoint)
4264 || (b->type == bp_access_watchpoint)
4265 || ep_is_exception_catchpoint (b))
4266 && (b->enable_state == bp_enabled))
4268 b->enable_state = bp_call_disabled;
4269 check_duplicates (b);
4275 enable_watchpoints_after_interactive_call_stop (void)
4277 struct breakpoint *b;
4281 if (((b->type == bp_watchpoint)
4282 || (b->type == bp_hardware_watchpoint)
4283 || (b->type == bp_read_watchpoint)
4284 || (b->type == bp_access_watchpoint)
4285 || ep_is_exception_catchpoint (b))
4286 && (b->enable_state == bp_call_disabled))
4288 b->enable_state = bp_enabled;
4289 check_duplicates (b);
4295 /* Set a breakpoint that will evaporate an end of command
4296 at address specified by SAL.
4297 Restrict it to frame FRAME if FRAME is nonzero. */
4300 set_momentary_breakpoint (struct symtab_and_line sal, struct frame_info *frame,
4303 register struct breakpoint *b;
4304 b = set_raw_breakpoint (sal, type);
4305 b->enable_state = bp_enabled;
4306 b->disposition = disp_donttouch;
4307 b->frame = (frame ? frame->frame : 0);
4309 /* If we're debugging a multi-threaded program, then we
4310 want momentary breakpoints to be active in only a
4311 single thread of control. */
4312 if (in_thread_list (inferior_ptid))
4313 b->thread = pid_to_thread_id (inferior_ptid);
4319 /* Tell the user we have just set a breakpoint B. */
4322 mention (struct breakpoint *b)
4325 struct cleanup *old_chain;
4326 struct ui_stream *stb;
4328 stb = ui_out_stream_new (uiout);
4329 old_chain = make_cleanup_ui_out_stream_delete (stb);
4331 /* FIXME: This is misplaced; mention() is called by things (like hitting a
4332 watchpoint) other than breakpoint creation. It should be possible to
4333 clean this up and at the same time replace the random calls to
4334 breakpoint_changed with this hook, as has already been done for
4335 delete_breakpoint_hook and so on. */
4336 if (create_breakpoint_hook)
4337 create_breakpoint_hook (b);
4338 breakpoint_create_event (b->number);
4343 printf_filtered ("(apparently deleted?) Eventpoint %d: ", b->number);
4346 ui_out_text (uiout, "Watchpoint ");
4347 ui_out_tuple_begin (uiout, "wpt");
4348 ui_out_field_int (uiout, "number", b->number);
4349 ui_out_text (uiout, ": ");
4350 print_expression (b->exp, stb->stream);
4351 ui_out_field_stream (uiout, "exp", stb);
4352 ui_out_tuple_end (uiout);
4354 case bp_hardware_watchpoint:
4355 ui_out_text (uiout, "Hardware watchpoint ");
4356 ui_out_tuple_begin (uiout, "wpt");
4357 ui_out_field_int (uiout, "number", b->number);
4358 ui_out_text (uiout, ": ");
4359 print_expression (b->exp, stb->stream);
4360 ui_out_field_stream (uiout, "exp", stb);
4361 ui_out_tuple_end (uiout);
4363 case bp_read_watchpoint:
4364 ui_out_text (uiout, "Hardware read watchpoint ");
4365 ui_out_tuple_begin (uiout, "hw-rwpt");
4366 ui_out_field_int (uiout, "number", b->number);
4367 ui_out_text (uiout, ": ");
4368 print_expression (b->exp, stb->stream);
4369 ui_out_field_stream (uiout, "exp", stb);
4370 ui_out_tuple_end (uiout);
4372 case bp_access_watchpoint:
4373 ui_out_text (uiout, "Hardware access (read/write) watchpoint ");
4374 ui_out_tuple_begin (uiout, "hw-awpt");
4375 ui_out_field_int (uiout, "number", b->number);
4376 ui_out_text (uiout, ": ");
4377 print_expression (b->exp, stb->stream);
4378 ui_out_field_stream (uiout, "exp", stb);
4379 ui_out_tuple_end (uiout);
4382 if (ui_out_is_mi_like_p (uiout))
4387 printf_filtered ("Breakpoint %d", b->number);
4390 case bp_hardware_breakpoint:
4391 if (ui_out_is_mi_like_p (uiout))
4396 printf_filtered ("Hardware assisted breakpoint %d", b->number);
4400 case bp_catch_unload:
4401 printf_filtered ("Catchpoint %d (%s %s)",
4403 (b->type == bp_catch_load) ? "load" : "unload",
4404 (b->dll_pathname != NULL) ?
4405 b->dll_pathname : "<any library>");
4408 case bp_catch_vfork:
4409 printf_filtered ("Catchpoint %d (%s)",
4411 (b->type == bp_catch_fork) ? "fork" : "vfork");
4414 printf_filtered ("Catchpoint %d (exec)",
4417 case bp_catch_catch:
4418 case bp_catch_throw:
4419 printf_filtered ("Catchpoint %d (%s)",
4421 (b->type == bp_catch_catch) ? "catch" : "throw");
4427 case bp_longjmp_resume:
4428 case bp_step_resume:
4429 case bp_through_sigtramp:
4431 case bp_watchpoint_scope:
4432 case bp_shlib_event:
4433 case bp_thread_event:
4434 case bp_overlay_event:
4439 if (addressprint || b->source_file == NULL)
4441 printf_filtered (" at ");
4442 print_address_numeric (b->address, 1, gdb_stdout);
4445 printf_filtered (": file %s, line %d.",
4446 b->source_file, b->line_number);
4448 do_cleanups (old_chain);
4449 if (ui_out_is_mi_like_p (uiout))
4451 printf_filtered ("\n");
4455 /* Add SALS.nelts breakpoints to the breakpoint table. For each
4456 SALS.sal[i] breakpoint, include the corresponding ADDR_STRING[i],
4457 COND[i] and COND_STRING[i] values.
4459 NOTE: If the function succeeds, the caller is expected to cleanup
4460 the arrays ADDR_STRING, COND_STRING, COND and SALS (but not the
4461 array contents). If the function fails (error() is called), the
4462 caller is expected to cleanups both the ADDR_STRING, COND_STRING,
4463 COND and SALS arrays and each of those arrays contents. */
4466 create_breakpoints (struct symtabs_and_lines sals, char **addr_string,
4467 struct expression **cond, char **cond_string,
4468 enum bptype type, enum bpdisp disposition,
4469 int thread, int ignore_count, int from_tty)
4471 if (type == bp_hardware_breakpoint)
4473 int i = hw_breakpoint_used_count ();
4474 int target_resources_ok =
4475 TARGET_CAN_USE_HARDWARE_WATCHPOINT (bp_hardware_breakpoint,
4477 if (target_resources_ok == 0)
4478 error ("No hardware breakpoint support in the target.");
4479 else if (target_resources_ok < 0)
4480 error ("Hardware breakpoints used exceeds limit.");
4483 /* Now set all the breakpoints. */
4486 for (i = 0; i < sals.nelts; i++)
4488 struct breakpoint *b;
4489 struct symtab_and_line sal = sals.sals[i];
4492 describe_other_breakpoints (sal.pc, sal.section);
4494 b = set_raw_breakpoint (sal, type);
4495 set_breakpoint_count (breakpoint_count + 1);
4496 b->number = breakpoint_count;
4499 b->addr_string = addr_string[i];
4500 b->cond_string = cond_string[i];
4501 b->ignore_count = ignore_count;
4502 b->enable_state = bp_enabled;
4503 b->disposition = disposition;
4509 /* Parse ARG which is assumed to be a SAL specification possibly
4510 followed by conditionals. On return, SALS contains an array of SAL
4511 addresses found. ADDR_STRING contains a vector of (canonical)
4512 address strings. ARG points to the end of the SAL. */
4515 parse_breakpoint_sals (char **address,
4516 struct symtabs_and_lines *sals,
4517 char ***addr_string)
4519 char *addr_start = *address;
4520 *addr_string = NULL;
4521 /* If no arg given, or if first arg is 'if ', use the default
4523 if ((*address) == NULL
4524 || (strncmp ((*address), "if", 2) == 0 && isspace ((*address)[2])))
4526 if (default_breakpoint_valid)
4528 struct symtab_and_line sal;
4529 INIT_SAL (&sal); /* initialize to zeroes */
4530 sals->sals = (struct symtab_and_line *)
4531 xmalloc (sizeof (struct symtab_and_line));
4532 sal.pc = default_breakpoint_address;
4533 sal.line = default_breakpoint_line;
4534 sal.symtab = default_breakpoint_symtab;
4535 sal.section = find_pc_overlay (sal.pc);
4536 sals->sals[0] = sal;
4540 error ("No default breakpoint address now.");
4544 /* Force almost all breakpoints to be in terms of the
4545 current_source_symtab (which is decode_line_1's default). This
4546 should produce the results we want almost all of the time while
4547 leaving default_breakpoint_* alone. */
4548 if (default_breakpoint_valid
4549 && (!current_source_symtab
4550 || (strchr ("+-", (*address)[0]) != NULL)))
4551 *sals = decode_line_1 (address, 1, default_breakpoint_symtab,
4552 default_breakpoint_line, addr_string);
4554 *sals = decode_line_1 (address, 1, (struct symtab *) NULL, 0, addr_string);
4556 /* For any SAL that didn't have a canonical string, fill one in. */
4557 if (sals->nelts > 0 && *addr_string == NULL)
4558 *addr_string = xcalloc (sals->nelts, sizeof (char **));
4559 if (addr_start != (*address))
4562 for (i = 0; i < sals->nelts; i++)
4564 /* Add the string if not present. */
4565 if ((*addr_string)[i] == NULL)
4566 (*addr_string)[i] = savestring (addr_start, (*address) - addr_start);
4572 /* Convert each SAL into a real PC. Verify that the PC can be
4573 inserted as a breakpoint. If it can't throw an error. */
4576 breakpoint_sals_to_pc (struct symtabs_and_lines *sals,
4580 for (i = 0; i < sals->nelts; i++)
4582 resolve_sal_pc (&sals->sals[i]);
4584 /* It's possible for the PC to be nonzero, but still an illegal
4585 value on some targets.
4587 For example, on HP-UX if you start gdb, and before running the
4588 inferior you try to set a breakpoint on a shared library function
4589 "foo" where the inferior doesn't call "foo" directly but does
4590 pass its address to another function call, then we do find a
4591 minimal symbol for the "foo", but it's address is invalid.
4592 (Appears to be an index into a table that the loader sets up
4593 when the inferior is run.)
4595 Give the target a chance to bless sals.sals[i].pc before we
4596 try to make a breakpoint for it. */
4597 if (PC_REQUIRES_RUN_BEFORE_USE (sals->sals[i].pc))
4599 if (address == NULL)
4600 error ("Cannot break without a running program.");
4602 error ("Cannot break on %s without a running program.",
4608 /* Set a breakpoint according to ARG (function, linenum or *address)
4609 flag: first bit : 0 non-temporary, 1 temporary.
4610 second bit : 0 normal breakpoint, 1 hardware breakpoint. */
4613 break_command_1 (char *arg, int flag, int from_tty)
4615 int tempflag, hardwareflag;
4616 struct symtabs_and_lines sals;
4617 register struct expression **cond = 0;
4618 /* Pointers in arg to the start, and one past the end, of the
4620 char **cond_string = (char **) NULL;
4621 char *addr_start = arg;
4623 struct cleanup *old_chain;
4624 struct cleanup *breakpoint_chain = NULL;
4627 int ignore_count = 0;
4629 hardwareflag = flag & BP_HARDWAREFLAG;
4630 tempflag = flag & BP_TEMPFLAG;
4635 parse_breakpoint_sals (&arg, &sals, &addr_string);
4640 /* Create a chain of things that always need to be cleaned up. */
4641 old_chain = make_cleanup (null_cleanup, 0);
4643 /* Make sure that all storage allocated to SALS gets freed. */
4644 make_cleanup (xfree, sals.sals);
4646 /* Cleanup the addr_string array but not its contents. */
4647 make_cleanup (xfree, addr_string);
4649 /* Allocate space for all the cond expressions. */
4650 cond = xcalloc (sals.nelts, sizeof (struct expression *));
4651 make_cleanup (xfree, cond);
4653 /* Allocate space for all the cond strings. */
4654 cond_string = xcalloc (sals.nelts, sizeof (char **));
4655 make_cleanup (xfree, cond_string);
4657 /* ----------------------------- SNIP -----------------------------
4658 Anything added to the cleanup chain beyond this point is assumed
4659 to be part of a breakpoint. If the breakpoint create succeeds
4660 then the memory is not reclaimed. */
4661 breakpoint_chain = make_cleanup (null_cleanup, 0);
4663 /* Mark the contents of the addr_string for cleanup. These go on
4664 the breakpoint_chain and only occure if the breakpoint create
4666 for (i = 0; i < sals.nelts; i++)
4668 if (addr_string[i] != NULL)
4669 make_cleanup (xfree, addr_string[i]);
4672 /* Resolve all line numbers to PC's and verify that the addresses
4673 are ok for the target. */
4674 breakpoint_sals_to_pc (&sals, addr_start);
4676 /* Verify that condition can be parsed, before setting any
4677 breakpoints. Allocate a separate condition expression for each
4679 thread = -1; /* No specific thread yet */
4680 for (i = 0; i < sals.nelts; i++)
4687 char *cond_start = NULL;
4688 char *cond_end = NULL;
4689 while (*tok == ' ' || *tok == '\t')
4694 while (*end_tok != ' ' && *end_tok != '\t' && *end_tok != '\000')
4697 toklen = end_tok - tok;
4699 if (toklen >= 1 && strncmp (tok, "if", toklen) == 0)
4701 tok = cond_start = end_tok + 1;
4702 cond[i] = parse_exp_1 (&tok, block_for_pc (sals.sals[i].pc), 0);
4703 make_cleanup (xfree, cond[i]);
4705 cond_string[i] = savestring (cond_start, cond_end - cond_start);
4706 make_cleanup (xfree, cond_string[i]);
4708 else if (toklen >= 1 && strncmp (tok, "thread", toklen) == 0)
4714 thread = strtol (tok, &tok, 0);
4716 error ("Junk after thread keyword.");
4717 if (!valid_thread_id (thread))
4718 error ("Unknown thread %d\n", thread);
4721 error ("Junk at end of arguments.");
4725 create_breakpoints (sals, addr_string, cond, cond_string,
4726 hardwareflag ? bp_hardware_breakpoint : bp_breakpoint,
4727 tempflag ? disp_del : disp_donttouch,
4728 thread, ignore_count, from_tty);
4732 warning ("Multiple breakpoints were set.");
4733 warning ("Use the \"delete\" command to delete unwanted breakpoints.");
4735 /* That's it. Discard the cleanups for data inserted into the
4737 discard_cleanups (breakpoint_chain);
4738 /* But cleanup everything else. */
4739 do_cleanups (old_chain);
4742 /* Set a breakpoint of TYPE/DISPOSITION according to ARG (function,
4743 linenum or *address) with COND and IGNORE_COUNT. */
4745 struct captured_breakpoint_args
4756 do_captured_breakpoint (void *data)
4758 struct captured_breakpoint_args *args = data;
4759 struct symtabs_and_lines sals;
4760 register struct expression **cond;
4761 struct cleanup *old_chain;
4762 struct cleanup *breakpoint_chain = NULL;
4769 /* Parse the source and lines spec. Delay check that the expression
4770 didn't contain trailing garbage until after cleanups are in
4774 address_end = args->address;
4776 parse_breakpoint_sals (&address_end, &sals, &addr_string);
4781 /* Create a chain of things at always need to be cleaned up. */
4782 old_chain = make_cleanup (null_cleanup, 0);
4784 /* Always have a addr_string array, even if it is empty. */
4785 make_cleanup (xfree, addr_string);
4787 /* Make sure that all storage allocated to SALS gets freed. */
4788 make_cleanup (xfree, sals.sals);
4790 /* Allocate space for all the cond expressions. */
4791 cond = xcalloc (sals.nelts, sizeof (struct expression *));
4792 make_cleanup (xfree, cond);
4794 /* Allocate space for all the cond strings. */
4795 cond_string = xcalloc (sals.nelts, sizeof (char **));
4796 make_cleanup (xfree, cond_string);
4798 /* ----------------------------- SNIP -----------------------------
4799 Anything added to the cleanup chain beyond this point is assumed
4800 to be part of a breakpoint. If the breakpoint create goes
4801 through then that memory is not cleaned up. */
4802 breakpoint_chain = make_cleanup (null_cleanup, 0);
4804 /* Mark the contents of the addr_string for cleanup. These go on
4805 the breakpoint_chain and only occure if the breakpoint create
4807 for (i = 0; i < sals.nelts; i++)
4809 if (addr_string[i] != NULL)
4810 make_cleanup (xfree, addr_string[i]);
4813 /* Wait until now before checking for garbage at the end of the
4814 address. That way cleanups can take care of freeing any
4816 if (*address_end != '\0')
4817 error ("Garbage %s following breakpoint address", address_end);
4819 /* Resolve all line numbers to PC's. */
4820 breakpoint_sals_to_pc (&sals, args->address);
4822 /* Verify that conditions can be parsed, before setting any
4824 for (i = 0; i < sals.nelts; i++)
4826 if (args->condition != NULL)
4828 char *tok = args->condition;
4829 cond[i] = parse_exp_1 (&tok, block_for_pc (sals.sals[i].pc), 0);
4831 error ("Garbage %s follows condition", tok);
4832 make_cleanup (xfree, cond[i]);
4833 cond_string[i] = xstrdup (args->condition);
4837 create_breakpoints (sals, addr_string, cond, cond_string,
4838 args->hardwareflag ? bp_hardware_breakpoint : bp_breakpoint,
4839 args->tempflag ? disp_del : disp_donttouch,
4840 args->thread, args->ignore_count, 0/*from-tty*/);
4842 /* That's it. Discard the cleanups for data inserted into the
4844 discard_cleanups (breakpoint_chain);
4845 /* But cleanup everything else. */
4846 do_cleanups (old_chain);
4851 gdb_breakpoint (char *address, char *condition,
4852 int hardwareflag, int tempflag,
4853 int thread, int ignore_count)
4855 struct captured_breakpoint_args args;
4856 args.address = address;
4857 args.condition = condition;
4858 args.hardwareflag = hardwareflag;
4859 args.tempflag = tempflag;
4860 args.thread = thread;
4861 args.ignore_count = ignore_count;
4862 return catch_errors (do_captured_breakpoint, &args,
4863 NULL, RETURN_MASK_ALL);
4868 break_at_finish_at_depth_command_1 (char *arg, int flag, int from_tty)
4870 struct frame_info *frame;
4871 CORE_ADDR low, high, selected_pc = 0;
4872 char *extra_args = NULL;
4875 int extra_args_len = 0, if_arg = 0;
4878 (arg[0] == 'i' && arg[1] == 'f' && (arg[2] == ' ' || arg[2] == '\t')))
4881 if (default_breakpoint_valid)
4885 selected_pc = selected_frame->pc;
4890 error ("No selected frame.");
4893 error ("No default breakpoint address now.");
4897 extra_args = strchr (arg, ' ');
4901 extra_args_len = strlen (extra_args);
4902 level_arg = (char *) xmalloc (extra_args - arg);
4903 strncpy (level_arg, arg, extra_args - arg - 1);
4904 level_arg[extra_args - arg - 1] = '\0';
4908 level_arg = (char *) xmalloc (strlen (arg) + 1);
4909 strcpy (level_arg, arg);
4912 frame = parse_frame_specification (level_arg);
4914 selected_pc = frame->pc;
4921 extra_args_len = strlen (arg);
4926 if (find_pc_partial_function (selected_pc, (char **) NULL, &low, &high))
4928 addr_string = (char *) xmalloc (26 + extra_args_len);
4930 sprintf (addr_string, "*0x%s %s", paddr_nz (high), extra_args);
4932 sprintf (addr_string, "*0x%s", paddr_nz (high));
4933 break_command_1 (addr_string, flag, from_tty);
4934 xfree (addr_string);
4937 error ("No function contains the specified address");
4940 error ("Unable to set breakpoint at procedure exit");
4945 break_at_finish_command_1 (char *arg, int flag, int from_tty)
4947 char *addr_string, *break_string, *beg_addr_string;
4948 CORE_ADDR low, high;
4949 struct symtabs_and_lines sals;
4950 struct symtab_and_line sal;
4951 struct cleanup *old_chain;
4952 char *extra_args = NULL;
4953 int extra_args_len = 0;
4957 (arg[0] == 'i' && arg[1] == 'f' && (arg[2] == ' ' || arg[2] == '\t')))
4959 if (default_breakpoint_valid)
4963 addr_string = (char *) xmalloc (15);
4964 sprintf (addr_string, "*0x%s", paddr_nz (selected_frame->pc));
4969 error ("No selected frame.");
4972 error ("No default breakpoint address now.");
4976 addr_string = (char *) xmalloc (strlen (arg) + 1);
4977 strcpy (addr_string, arg);
4983 extra_args_len = strlen (arg);
4987 /* get the stuff after the function name or address */
4988 extra_args = strchr (arg, ' ');
4992 extra_args_len = strlen (extra_args);
4999 beg_addr_string = addr_string;
5000 sals = decode_line_1 (&addr_string, 1, (struct symtab *) NULL, 0,
5003 xfree (beg_addr_string);
5004 old_chain = make_cleanup (xfree, sals.sals);
5005 for (i = 0; (i < sals.nelts); i++)
5008 if (find_pc_partial_function (sal.pc, (char **) NULL, &low, &high))
5010 break_string = (char *) xmalloc (extra_args_len + 26);
5012 sprintf (break_string, "*0x%s %s", paddr_nz (high), extra_args);
5014 sprintf (break_string, "*0x%s", paddr_nz (high));
5015 break_command_1 (break_string, flag, from_tty);
5016 xfree (break_string);
5019 error ("No function contains the specified address");
5023 warning ("Multiple breakpoints were set.\n");
5024 warning ("Use the \"delete\" command to delete unwanted breakpoints.");
5026 do_cleanups (old_chain);
5030 /* Helper function for break_command_1 and disassemble_command. */
5033 resolve_sal_pc (struct symtab_and_line *sal)
5037 if (sal->pc == 0 && sal->symtab != NULL)
5039 if (!find_line_pc (sal->symtab, sal->line, &pc))
5040 error ("No line %d in file \"%s\".",
5041 sal->line, sal->symtab->filename);
5045 if (sal->section == 0 && sal->symtab != NULL)
5047 struct blockvector *bv;
5052 bv = blockvector_for_pc_sect (sal->pc, 0, &index, sal->symtab);
5055 b = BLOCKVECTOR_BLOCK (bv, index);
5056 sym = block_function (b);
5059 fixup_symbol_section (sym, sal->symtab->objfile);
5060 sal->section = SYMBOL_BFD_SECTION (sym);
5064 /* It really is worthwhile to have the section, so we'll just
5065 have to look harder. This case can be executed if we have
5066 line numbers but no functions (as can happen in assembly
5069 struct minimal_symbol *msym;
5071 msym = lookup_minimal_symbol_by_pc (sal->pc);
5073 sal->section = SYMBOL_BFD_SECTION (msym);
5080 break_command (char *arg, int from_tty)
5082 break_command_1 (arg, 0, from_tty);
5086 break_at_finish_command (char *arg, int from_tty)
5088 break_at_finish_command_1 (arg, 0, from_tty);
5092 break_at_finish_at_depth_command (char *arg, int from_tty)
5094 break_at_finish_at_depth_command_1 (arg, 0, from_tty);
5098 tbreak_command (char *arg, int from_tty)
5100 break_command_1 (arg, BP_TEMPFLAG, from_tty);
5104 tbreak_at_finish_command (char *arg, int from_tty)
5106 break_at_finish_command_1 (arg, BP_TEMPFLAG, from_tty);
5110 hbreak_command (char *arg, int from_tty)
5112 break_command_1 (arg, BP_HARDWAREFLAG, from_tty);
5116 thbreak_command (char *arg, int from_tty)
5118 break_command_1 (arg, (BP_TEMPFLAG | BP_HARDWAREFLAG), from_tty);
5122 stop_command (char *arg, int from_tty)
5124 printf_filtered ("Specify the type of breakpoint to set.\n\
5125 Usage: stop in <function | address>\n\
5130 stopin_command (char *arg, int from_tty)
5134 if (arg == (char *) NULL)
5136 else if (*arg != '*')
5141 /* look for a ':'. If this is a line number specification, then
5142 say it is bad, otherwise, it should be an address or
5143 function/method name */
5144 while (*argptr && !hasColon)
5146 hasColon = (*argptr == ':');
5151 badInput = (*argptr != ':'); /* Not a class::method */
5153 badInput = isdigit (*arg); /* a simple line number */
5157 printf_filtered ("Usage: stop in <function | address>\n");
5159 break_command_1 (arg, 0, from_tty);
5163 stopat_command (char *arg, int from_tty)
5167 if (arg == (char *) NULL || *arg == '*') /* no line number */
5174 /* look for a ':'. If there is a '::' then get out, otherwise
5175 it is probably a line number. */
5176 while (*argptr && !hasColon)
5178 hasColon = (*argptr == ':');
5183 badInput = (*argptr == ':'); /* we have class::method */
5185 badInput = !isdigit (*arg); /* not a line number */
5189 printf_filtered ("Usage: stop at <line>\n");
5191 break_command_1 (arg, 0, from_tty);
5195 /* accessflag: hw_write: watch write,
5196 hw_read: watch read,
5197 hw_access: watch access (read or write) */
5199 watch_command_1 (char *arg, int accessflag, int from_tty)
5201 struct breakpoint *b;
5202 struct symtab_and_line sal;
5203 struct expression *exp;
5204 struct block *exp_valid_block;
5205 struct value *val, *mark;
5206 struct frame_info *frame;
5207 struct frame_info *prev_frame = NULL;
5208 char *exp_start = NULL;
5209 char *exp_end = NULL;
5210 char *tok, *end_tok;
5212 char *cond_start = NULL;
5213 char *cond_end = NULL;
5214 struct expression *cond = NULL;
5215 int i, other_type_used, target_resources_ok = 0;
5216 enum bptype bp_type;
5219 INIT_SAL (&sal); /* initialize to zeroes */
5221 /* Parse arguments. */
5222 innermost_block = NULL;
5224 exp = parse_exp_1 (&arg, 0, 0);
5226 exp_valid_block = innermost_block;
5227 mark = value_mark ();
5228 val = evaluate_expression (exp);
5229 release_value (val);
5230 if (VALUE_LAZY (val))
5231 value_fetch_lazy (val);
5234 while (*tok == ' ' || *tok == '\t')
5238 while (*end_tok != ' ' && *end_tok != '\t' && *end_tok != '\000')
5241 toklen = end_tok - tok;
5242 if (toklen >= 1 && strncmp (tok, "if", toklen) == 0)
5244 tok = cond_start = end_tok + 1;
5245 cond = parse_exp_1 (&tok, 0, 0);
5249 error ("Junk at end of command.");
5251 if (accessflag == hw_read)
5252 bp_type = bp_read_watchpoint;
5253 else if (accessflag == hw_access)
5254 bp_type = bp_access_watchpoint;
5256 bp_type = bp_hardware_watchpoint;
5258 mem_cnt = can_use_hardware_watchpoint (val);
5259 if (mem_cnt == 0 && bp_type != bp_hardware_watchpoint)
5260 error ("Expression cannot be implemented with read/access watchpoint.");
5263 i = hw_watchpoint_used_count (bp_type, &other_type_used);
5264 target_resources_ok =
5265 TARGET_CAN_USE_HARDWARE_WATCHPOINT (bp_type, i + mem_cnt,
5267 if (target_resources_ok == 0 && bp_type != bp_hardware_watchpoint)
5268 error ("Target does not support this type of hardware watchpoint.");
5270 if (target_resources_ok < 0 && bp_type != bp_hardware_watchpoint)
5271 error ("Target can only support one kind of HW watchpoint at a time.");
5274 #if defined(HPUXHPPA)
5275 /* On HP-UX if you set a h/w
5276 watchpoint before the "run" command, the inferior dies with a e.g.,
5277 SIGILL once you start it. I initially believed this was due to a
5278 bad interaction between page protection traps and the initial
5279 startup sequence by the dynamic linker.
5281 However, I tried avoiding that by having HP-UX's implementation of
5282 TARGET_CAN_USE_HW_WATCHPOINT return FALSE if there was no inferior_ptid
5283 yet, which forced slow watches before a "run" or "attach", and it
5284 still fails somewhere in the startup code.
5286 Until I figure out what's happening, I'm disallowing watches altogether
5287 before the "run" or "attach" command. We'll tell the user they must
5288 set watches after getting the program started. */
5289 if (!target_has_execution)
5291 warning ("can't do that without a running program; try \"break main\", \"run\" first");
5294 #endif /* HPUXHPPA */
5296 /* Change the type of breakpoint to an ordinary watchpoint if a hardware
5297 watchpoint could not be set. */
5298 if (!mem_cnt || target_resources_ok <= 0)
5299 bp_type = bp_watchpoint;
5301 /* Now set up the breakpoint. */
5302 b = set_raw_breakpoint (sal, bp_type);
5303 set_breakpoint_count (breakpoint_count + 1);
5304 b->number = breakpoint_count;
5305 b->disposition = disp_donttouch;
5307 b->exp_valid_block = exp_valid_block;
5308 b->exp_string = savestring (exp_start, exp_end - exp_start);
5312 b->cond_string = savestring (cond_start, cond_end - cond_start);
5316 frame = block_innermost_frame (exp_valid_block);
5319 prev_frame = get_prev_frame (frame);
5320 get_frame_id (frame, &b->watchpoint_frame);
5324 memset (&b->watchpoint_frame, 0, sizeof (b->watchpoint_frame));
5327 /* If the expression is "local", then set up a "watchpoint scope"
5328 breakpoint at the point where we've left the scope of the watchpoint
5330 if (innermost_block)
5334 struct breakpoint *scope_breakpoint;
5335 struct symtab_and_line scope_sal;
5337 INIT_SAL (&scope_sal); /* initialize to zeroes */
5338 scope_sal.pc = get_frame_pc (prev_frame);
5339 scope_sal.section = find_pc_overlay (scope_sal.pc);
5341 scope_breakpoint = set_raw_breakpoint (scope_sal,
5342 bp_watchpoint_scope);
5343 set_breakpoint_count (breakpoint_count + 1);
5344 scope_breakpoint->number = breakpoint_count;
5346 scope_breakpoint->enable_state = bp_enabled;
5348 /* Automatically delete the breakpoint when it hits. */
5349 scope_breakpoint->disposition = disp_del;
5351 /* Only break in the proper frame (help with recursion). */
5352 scope_breakpoint->frame = prev_frame->frame;
5354 /* Set the address at which we will stop. */
5355 scope_breakpoint->address = get_frame_pc (prev_frame);
5357 /* The scope breakpoint is related to the watchpoint. We
5358 will need to act on them together. */
5359 b->related_breakpoint = scope_breakpoint;
5362 value_free_to_mark (mark);
5366 /* Return count of locations need to be watched and can be handled
5367 in hardware. If the watchpoint can not be handled
5368 in hardware return zero. */
5370 #if !defined(TARGET_REGION_SIZE_OK_FOR_HW_WATCHPOINT)
5371 #define TARGET_REGION_SIZE_OK_FOR_HW_WATCHPOINT(BYTE_SIZE) \
5372 ((BYTE_SIZE) <= (REGISTER_SIZE))
5375 #if !defined(TARGET_REGION_OK_FOR_HW_WATCHPOINT)
5376 #define TARGET_REGION_OK_FOR_HW_WATCHPOINT(ADDR,LEN) \
5377 (TARGET_REGION_SIZE_OK_FOR_HW_WATCHPOINT(LEN))
5381 can_use_hardware_watchpoint (struct value *v)
5383 int found_memory_cnt = 0;
5384 struct value *head = v;
5386 /* Did the user specifically forbid us to use hardware watchpoints? */
5387 if (!can_use_hw_watchpoints)
5390 /* Make sure that the value of the expression depends only upon
5391 memory contents, and values computed from them within GDB. If we
5392 find any register references or function calls, we can't use a
5393 hardware watchpoint.
5395 The idea here is that evaluating an expression generates a series
5396 of values, one holding the value of every subexpression. (The
5397 expression a*b+c has five subexpressions: a, b, a*b, c, and
5398 a*b+c.) GDB's values hold almost enough information to establish
5399 the criteria given above --- they identify memory lvalues,
5400 register lvalues, computed values, etcetera. So we can evaluate
5401 the expression, and then scan the chain of values that leaves
5402 behind to decide whether we can detect any possible change to the
5403 expression's final value using only hardware watchpoints.
5405 However, I don't think that the values returned by inferior
5406 function calls are special in any way. So this function may not
5407 notice that an expression involving an inferior function call
5408 can't be watched with hardware watchpoints. FIXME. */
5409 for (; v; v = v->next)
5411 if (VALUE_LVAL (v) == lval_memory)
5414 /* A lazy memory lvalue is one that GDB never needed to fetch;
5415 we either just used its address (e.g., `a' in `a.b') or
5416 we never needed it at all (e.g., `a' in `a,b'). */
5420 /* Ahh, memory we actually used! Check if we can cover
5421 it with hardware watchpoints. */
5422 struct type *vtype = check_typedef (VALUE_TYPE (v));
5424 /* We only watch structs and arrays if user asked for it
5425 explicitly, never if they just happen to appear in a
5426 middle of some value chain. */
5428 || (TYPE_CODE (vtype) != TYPE_CODE_STRUCT
5429 && TYPE_CODE (vtype) != TYPE_CODE_ARRAY))
5431 CORE_ADDR vaddr = VALUE_ADDRESS (v) + VALUE_OFFSET (v);
5432 int len = TYPE_LENGTH (VALUE_TYPE (v));
5434 if (!TARGET_REGION_OK_FOR_HW_WATCHPOINT (vaddr, len))
5441 else if (v->lval != not_lval && v->modifiable == 0)
5442 return 0; /* ??? What does this represent? */
5443 else if (v->lval == lval_register)
5444 return 0; /* cannot watch a register with a HW watchpoint */
5447 /* The expression itself looks suitable for using a hardware
5448 watchpoint, but give the target machine a chance to reject it. */
5449 return found_memory_cnt;
5453 watch_command_wrapper (char *arg, int from_tty)
5455 watch_command (arg, from_tty);
5459 watch_command (char *arg, int from_tty)
5461 watch_command_1 (arg, hw_write, from_tty);
5465 rwatch_command_wrapper (char *arg, int from_tty)
5467 rwatch_command (arg, from_tty);
5471 rwatch_command (char *arg, int from_tty)
5473 watch_command_1 (arg, hw_read, from_tty);
5477 awatch_command_wrapper (char *arg, int from_tty)
5479 awatch_command (arg, from_tty);
5483 awatch_command (char *arg, int from_tty)
5485 watch_command_1 (arg, hw_access, from_tty);
5489 /* Helper routines for the until_command routine in infcmd.c. Here
5490 because it uses the mechanisms of breakpoints. */
5492 /* This function is called by fetch_inferior_event via the
5493 cmd_continuation pointer, to complete the until command. It takes
5494 care of cleaning up the temporary breakpoints set up by the until
5497 until_break_command_continuation (struct continuation_arg *arg)
5499 struct cleanup *cleanups;
5501 cleanups = (struct cleanup *) arg->data.pointer;
5502 do_exec_cleanups (cleanups);
5507 until_break_command (char *arg, int from_tty)
5509 struct symtabs_and_lines sals;
5510 struct symtab_and_line sal;
5511 struct frame_info *prev_frame = get_prev_frame (selected_frame);
5512 struct breakpoint *breakpoint;
5513 struct cleanup *old_chain;
5514 struct continuation_arg *arg1;
5517 clear_proceed_status ();
5519 /* Set a breakpoint where the user wants it and at return from
5522 if (default_breakpoint_valid)
5523 sals = decode_line_1 (&arg, 1, default_breakpoint_symtab,
5524 default_breakpoint_line, (char ***) NULL);
5526 sals = decode_line_1 (&arg, 1, (struct symtab *) NULL,
5527 0, (char ***) NULL);
5529 if (sals.nelts != 1)
5530 error ("Couldn't get information on specified line.");
5533 xfree (sals.sals); /* malloc'd, so freed */
5536 error ("Junk at end of arguments.");
5538 resolve_sal_pc (&sal);
5540 breakpoint = set_momentary_breakpoint (sal, selected_frame, bp_until);
5542 if (!event_loop_p || !target_can_async_p ())
5543 old_chain = make_cleanup_delete_breakpoint (breakpoint);
5545 old_chain = make_exec_cleanup_delete_breakpoint (breakpoint);
5547 /* If we are running asynchronously, and the target supports async
5548 execution, we are not waiting for the target to stop, in the call
5549 tp proceed, below. This means that we cannot delete the
5550 brekpoints until the target has actually stopped. The only place
5551 where we get a chance to do that is in fetch_inferior_event, so
5552 we must set things up for that. */
5554 if (event_loop_p && target_can_async_p ())
5556 /* In this case the arg for the continuation is just the point
5557 in the exec_cleanups chain from where to start doing
5558 cleanups, because all the continuation does is the cleanups in
5559 the exec_cleanup_chain. */
5561 (struct continuation_arg *) xmalloc (sizeof (struct continuation_arg));
5563 arg1->data.pointer = old_chain;
5565 add_continuation (until_break_command_continuation, arg1);
5568 /* Keep within the current frame */
5572 sal = find_pc_line (prev_frame->pc, 0);
5573 sal.pc = prev_frame->pc;
5574 breakpoint = set_momentary_breakpoint (sal, prev_frame, bp_until);
5575 if (!event_loop_p || !target_can_async_p ())
5576 make_cleanup_delete_breakpoint (breakpoint);
5578 make_exec_cleanup_delete_breakpoint (breakpoint);
5581 proceed (-1, TARGET_SIGNAL_DEFAULT, 0);
5582 /* Do the cleanups now, anly if we are not running asynchronously,
5583 of if we are, but the target is still synchronous. */
5584 if (!event_loop_p || !target_can_async_p ())
5585 do_cleanups (old_chain);
5589 /* These aren't used; I don't konw what they were for. */
5590 /* Set a breakpoint at the catch clause for NAME. */
5592 catch_breakpoint (char *name)
5597 disable_catch_breakpoint (void)
5602 delete_catch_breakpoint (void)
5607 enable_catch_breakpoint (void)
5614 struct sal_chain *next;
5615 struct symtab_and_line sal;
5619 /* Not really used -- invocation in handle_gnu_4_16_catch_command
5620 had been commented out in the v.4.16 sources, and stays
5621 disabled there now because "catch NAME" syntax isn't allowed.
5623 /* This isn't used; I don't know what it was for. */
5624 /* For each catch clause identified in ARGS, run FUNCTION
5625 with that clause as an argument. */
5626 static struct symtabs_and_lines
5627 map_catch_names (char *args, int (*function) ())
5629 register char *p = args;
5631 struct symtabs_and_lines sals;
5633 struct sal_chain *sal_chain = 0;
5637 error_no_arg ("one or more catch names");
5645 /* Don't swallow conditional part. */
5646 if (p1[0] == 'i' && p1[1] == 'f'
5647 && (p1[2] == ' ' || p1[2] == '\t'))
5653 while (isalnum (*p1) || *p1 == '_' || *p1 == '$')
5657 if (*p1 && *p1 != ' ' && *p1 != '\t')
5658 error ("Arguments must be catch names.");
5664 struct sal_chain *next = (struct sal_chain *)
5665 alloca (sizeof (struct sal_chain));
5666 next->next = sal_chain;
5667 next->sal = get_catch_sal (p);
5672 printf_unfiltered ("No catch clause for exception %s.\n", p);
5677 while (*p == ' ' || *p == '\t')
5683 /* This shares a lot of code with `print_frame_label_vars' from stack.c. */
5685 static struct symtabs_and_lines
5686 get_catch_sals (int this_level_only)
5688 register struct blockvector *bl;
5689 register struct block *block;
5690 int index, have_default = 0;
5692 struct symtabs_and_lines sals;
5693 struct sal_chain *sal_chain = 0;
5694 char *blocks_searched;
5696 /* Not sure whether an error message is always the correct response,
5697 but it's better than a core dump. */
5698 if (selected_frame == NULL)
5699 error ("No selected frame.");
5700 block = get_frame_block (selected_frame, 0);
5701 pc = selected_frame->pc;
5707 error ("No symbol table info available.\n");
5709 bl = blockvector_for_pc (BLOCK_END (block) - 4, &index);
5710 blocks_searched = (char *) alloca (BLOCKVECTOR_NBLOCKS (bl) * sizeof (char));
5711 memset (blocks_searched, 0, BLOCKVECTOR_NBLOCKS (bl) * sizeof (char));
5715 CORE_ADDR end = BLOCK_END (block) - 4;
5718 if (bl != blockvector_for_pc (end, &index))
5719 error ("blockvector blotch");
5720 if (BLOCKVECTOR_BLOCK (bl, index) != block)
5721 error ("blockvector botch");
5722 last_index = BLOCKVECTOR_NBLOCKS (bl);
5725 /* Don't print out blocks that have gone by. */
5726 while (index < last_index
5727 && BLOCK_END (BLOCKVECTOR_BLOCK (bl, index)) < pc)
5730 while (index < last_index
5731 && BLOCK_END (BLOCKVECTOR_BLOCK (bl, index)) < end)
5733 if (blocks_searched[index] == 0)
5735 struct block *b = BLOCKVECTOR_BLOCK (bl, index);
5737 register struct symbol *sym;
5739 ALL_BLOCK_SYMBOLS (b, i, sym)
5741 if (STREQ (SYMBOL_NAME (sym), "default"))
5747 if (SYMBOL_CLASS (sym) == LOC_LABEL)
5749 struct sal_chain *next = (struct sal_chain *)
5750 alloca (sizeof (struct sal_chain));
5751 next->next = sal_chain;
5752 next->sal = find_pc_line (SYMBOL_VALUE_ADDRESS (sym),
5757 blocks_searched[index] = 1;
5763 if (sal_chain && this_level_only)
5766 /* After handling the function's top-level block, stop.
5767 Don't continue to its superblock, the block of
5768 per-file symbols. */
5769 if (BLOCK_FUNCTION (block))
5771 block = BLOCK_SUPERBLOCK (block);
5776 struct sal_chain *tmp_chain;
5778 /* Count the number of entries. */
5779 for (index = 0, tmp_chain = sal_chain; tmp_chain;
5780 tmp_chain = tmp_chain->next)
5784 sals.sals = (struct symtab_and_line *)
5785 xmalloc (index * sizeof (struct symtab_and_line));
5786 for (index = 0; sal_chain; sal_chain = sal_chain->next, index++)
5787 sals.sals[index] = sal_chain->sal;
5794 ep_skip_leading_whitespace (char **s)
5796 if ((s == NULL) || (*s == NULL))
5798 while (isspace (**s))
5802 /* This function examines a string, and attempts to find a token
5803 that might be an event name in the leading characters. If a
5804 possible match is found, a pointer to the last character of
5805 the token is returned. Else, NULL is returned. */
5808 ep_find_event_name_end (char *arg)
5811 char *event_name_end = NULL;
5813 /* If we could depend upon the presense of strrpbrk, we'd use that... */
5817 /* We break out of the loop when we find a token delimiter.
5818 Basically, we're looking for alphanumerics and underscores;
5819 anything else delimites the token. */
5822 if (!isalnum (*s) && (*s != '_'))
5828 return event_name_end;
5832 /* This function attempts to parse an optional "if <cond>" clause
5833 from the arg string. If one is not found, it returns NULL.
5835 Else, it returns a pointer to the condition string. (It does not
5836 attempt to evaluate the string against a particular block.) And,
5837 it updates arg to point to the first character following the parsed
5838 if clause in the arg string. */
5841 ep_parse_optional_if_clause (char **arg)
5845 if (((*arg)[0] != 'i') || ((*arg)[1] != 'f') || !isspace ((*arg)[2]))
5848 /* Skip the "if" keyword. */
5851 /* Skip any extra leading whitespace, and record the start of the
5852 condition string. */
5853 ep_skip_leading_whitespace (arg);
5856 /* Assume that the condition occupies the remainder of the arg string. */
5857 (*arg) += strlen (cond_string);
5862 /* This function attempts to parse an optional filename from the arg
5863 string. If one is not found, it returns NULL.
5865 Else, it returns a pointer to the parsed filename. (This function
5866 makes no attempt to verify that a file of that name exists, or is
5867 accessible.) And, it updates arg to point to the first character
5868 following the parsed filename in the arg string.
5870 Note that clients needing to preserve the returned filename for
5871 future access should copy it to their own buffers. */
5873 ep_parse_optional_filename (char **arg)
5875 static char filename[1024];
5880 if ((*arg_p == '\0') || isspace (*arg_p))
5898 /* Commands to deal with catching events, such as signals, exceptions,
5899 process start/exit, etc. */
5903 catch_fork, catch_vfork
5907 #if defined(CHILD_INSERT_FORK_CATCHPOINT) || defined(CHILD_INSERT_VFORK_CATCHPOINT)
5908 static void catch_fork_command_1 (catch_fork_kind fork_kind,
5909 char *arg, int tempflag, int from_tty);
5912 catch_fork_command_1 (catch_fork_kind fork_kind, char *arg, int tempflag,
5915 char *cond_string = NULL;
5917 ep_skip_leading_whitespace (&arg);
5919 /* The allowed syntax is:
5921 catch [v]fork if <cond>
5923 First, check if there's an if clause. */
5924 cond_string = ep_parse_optional_if_clause (&arg);
5926 if ((*arg != '\0') && !isspace (*arg))
5927 error ("Junk at end of arguments.");
5929 /* If this target supports it, create a fork or vfork catchpoint
5930 and enable reporting of such events. */
5934 create_fork_event_catchpoint (tempflag, cond_string);
5937 create_vfork_event_catchpoint (tempflag, cond_string);
5940 error ("unsupported or unknown fork kind; cannot catch it");
5946 #if defined(CHILD_INSERT_EXEC_CATCHPOINT)
5948 catch_exec_command_1 (char *arg, int tempflag, int from_tty)
5950 char *cond_string = NULL;
5952 ep_skip_leading_whitespace (&arg);
5954 /* The allowed syntax is:
5956 catch exec if <cond>
5958 First, check if there's an if clause. */
5959 cond_string = ep_parse_optional_if_clause (&arg);
5961 if ((*arg != '\0') && !isspace (*arg))
5962 error ("Junk at end of arguments.");
5964 /* If this target supports it, create an exec catchpoint
5965 and enable reporting of such events. */
5966 create_exec_event_catchpoint (tempflag, cond_string);
5970 #if defined(SOLIB_ADD)
5972 catch_load_command_1 (char *arg, int tempflag, int from_tty)
5974 char *dll_pathname = NULL;
5975 char *cond_string = NULL;
5977 ep_skip_leading_whitespace (&arg);
5979 /* The allowed syntax is:
5981 catch load if <cond>
5982 catch load <filename>
5983 catch load <filename> if <cond>
5985 The user is not allowed to specify the <filename> after an
5988 We'll ignore the pathological case of a file named "if".
5990 First, check if there's an if clause. If so, then there
5991 cannot be a filename. */
5992 cond_string = ep_parse_optional_if_clause (&arg);
5994 /* If there was an if clause, then there cannot be a filename.
5995 Else, there might be a filename and an if clause. */
5996 if (cond_string == NULL)
5998 dll_pathname = ep_parse_optional_filename (&arg);
5999 ep_skip_leading_whitespace (&arg);
6000 cond_string = ep_parse_optional_if_clause (&arg);
6003 if ((*arg != '\0') && !isspace (*arg))
6004 error ("Junk at end of arguments.");
6006 /* Create a load breakpoint that only triggers when a load of
6007 the specified dll (or any dll, if no pathname was specified)
6009 SOLIB_CREATE_CATCH_LOAD_HOOK (PIDGET (inferior_ptid), tempflag,
6010 dll_pathname, cond_string);
6014 catch_unload_command_1 (char *arg, int tempflag, int from_tty)
6016 char *dll_pathname = NULL;
6017 char *cond_string = NULL;
6019 ep_skip_leading_whitespace (&arg);
6021 /* The allowed syntax is:
6023 catch unload if <cond>
6024 catch unload <filename>
6025 catch unload <filename> if <cond>
6027 The user is not allowed to specify the <filename> after an
6030 We'll ignore the pathological case of a file named "if".
6032 First, check if there's an if clause. If so, then there
6033 cannot be a filename. */
6034 cond_string = ep_parse_optional_if_clause (&arg);
6036 /* If there was an if clause, then there cannot be a filename.
6037 Else, there might be a filename and an if clause. */
6038 if (cond_string == NULL)
6040 dll_pathname = ep_parse_optional_filename (&arg);
6041 ep_skip_leading_whitespace (&arg);
6042 cond_string = ep_parse_optional_if_clause (&arg);
6045 if ((*arg != '\0') && !isspace (*arg))
6046 error ("Junk at end of arguments.");
6048 /* Create an unload breakpoint that only triggers when an unload of
6049 the specified dll (or any dll, if no pathname was specified)
6051 SOLIB_CREATE_CATCH_UNLOAD_HOOK (PIDGET (inferior_ptid), tempflag,
6052 dll_pathname, cond_string);
6054 #endif /* SOLIB_ADD */
6056 /* Commands to deal with catching exceptions. */
6058 /* Set a breakpoint at the specified callback routine for an
6059 exception event callback */
6062 create_exception_catchpoint (int tempflag, char *cond_string,
6063 enum exception_event_kind ex_event,
6064 struct symtab_and_line *sal)
6066 struct breakpoint *b;
6067 int thread = -1; /* All threads. */
6070 if (!sal) /* no exception support? */
6075 case EX_EVENT_THROW:
6076 bptype = bp_catch_throw;
6078 case EX_EVENT_CATCH:
6079 bptype = bp_catch_catch;
6081 default: /* error condition */
6082 error ("Internal error -- invalid catchpoint kind");
6085 b = set_raw_breakpoint (*sal, bptype);
6086 set_breakpoint_count (breakpoint_count + 1);
6087 b->number = breakpoint_count;
6089 b->cond_string = (cond_string == NULL) ?
6090 NULL : savestring (cond_string, strlen (cond_string));
6092 b->addr_string = NULL;
6093 b->enable_state = bp_enabled;
6094 b->disposition = tempflag ? disp_del : disp_donttouch;
6098 /* Deal with "catch catch" and "catch throw" commands */
6101 catch_exception_command_1 (enum exception_event_kind ex_event, char *arg,
6102 int tempflag, int from_tty)
6104 char *cond_string = NULL;
6105 struct symtab_and_line *sal = NULL;
6107 ep_skip_leading_whitespace (&arg);
6109 cond_string = ep_parse_optional_if_clause (&arg);
6111 if ((*arg != '\0') && !isspace (*arg))
6112 error ("Junk at end of arguments.");
6114 if ((ex_event != EX_EVENT_THROW) &&
6115 (ex_event != EX_EVENT_CATCH))
6116 error ("Unsupported or unknown exception event; cannot catch it");
6118 /* See if we can find a callback routine */
6119 sal = target_enable_exception_callback (ex_event, 1);
6123 /* We have callbacks from the runtime system for exceptions.
6124 Set a breakpoint on the sal found, if no errors */
6125 if (sal != (struct symtab_and_line *) -1)
6126 create_exception_catchpoint (tempflag, cond_string, ex_event, sal);
6128 return; /* something went wrong with setting up callbacks */
6132 /* No callbacks from runtime system for exceptions.
6133 Try GNU C++ exception breakpoints using labels in debug info. */
6134 if (ex_event == EX_EVENT_CATCH)
6136 handle_gnu_4_16_catch_command (arg, tempflag, from_tty);
6138 else if (ex_event == EX_EVENT_THROW)
6140 /* Set a breakpoint on __raise_exception () */
6142 warning ("Unsupported with this platform/compiler combination.");
6143 warning ("Perhaps you can achieve the effect you want by setting");
6144 warning ("a breakpoint on __raise_exception().");
6149 /* Cover routine to allow wrapping target_enable_exception_catchpoints
6150 inside a catch_errors */
6153 cover_target_enable_exception_callback (PTR arg)
6155 args_for_catchpoint_enable *args = arg;
6156 struct symtab_and_line *sal;
6157 sal = target_enable_exception_callback (args->kind, args->enable_p);
6160 else if (sal == (struct symtab_and_line *) -1)
6163 return 1; /*is valid */
6168 /* This is the original v.4.16 and earlier version of the
6169 catch_command_1() function. Now that other flavours of "catch"
6170 have been introduced, and since exception handling can be handled
6171 in other ways (through target ops) also, this is used only for the
6172 GNU C++ exception handling system.
6173 Note: Only the "catch" flavour of GDB 4.16 is handled here. The
6174 "catch NAME" is now no longer allowed in catch_command_1(). Also,
6175 there was no code in GDB 4.16 for "catch throw".
6177 Called from catch_exception_command_1 () */
6181 handle_gnu_4_16_catch_command (char *arg, int tempflag, int from_tty)
6183 /* First, translate ARG into something we can deal with in terms
6186 struct symtabs_and_lines sals;
6187 struct symtab_and_line sal;
6188 register struct expression *cond = 0;
6189 register struct breakpoint *b;
6193 INIT_SAL (&sal); /* initialize to zeroes */
6195 /* If no arg given, or if first arg is 'if ', all active catch clauses
6196 are breakpointed. */
6198 if (!arg || (arg[0] == 'i' && arg[1] == 'f'
6199 && (arg[2] == ' ' || arg[2] == '\t')))
6201 /* Grab all active catch clauses. */
6202 sals = get_catch_sals (0);
6206 /* Grab selected catch clauses. */
6207 error ("catch NAME not implemented");
6210 /* Not sure why this code has been disabled. I'm leaving
6211 it disabled. We can never come here now anyway
6212 since we don't allow the "catch NAME" syntax.
6215 /* This isn't used; I don't know what it was for. */
6216 sals = map_catch_names (arg, catch_breakpoint);
6224 for (i = 0; i < sals.nelts; i++)
6226 resolve_sal_pc (&sals.sals[i]);
6230 if (arg[0] == 'i' && arg[1] == 'f'
6231 && (arg[2] == ' ' || arg[2] == '\t'))
6232 cond = parse_exp_1 ((arg += 2, &arg),
6233 block_for_pc (sals.sals[i].pc), 0);
6235 error ("Junk at end of arguments.");
6240 for (i = 0; i < sals.nelts; i++)
6245 describe_other_breakpoints (sal.pc, sal.section);
6247 /* Important -- this is an ordinary breakpoint. For platforms
6248 with callback support for exceptions,
6249 create_exception_catchpoint() will create special bp types
6250 (bp_catch_catch and bp_catch_throw), and there is code in
6251 insert_breakpoints() and elsewhere that depends on that. */
6252 b = set_raw_breakpoint (sal, bp_breakpoint);
6253 set_breakpoint_count (breakpoint_count + 1);
6254 b->number = breakpoint_count;
6257 b->enable_state = bp_enabled;
6258 b->disposition = tempflag ? disp_del : disp_donttouch;
6265 warning ("Multiple breakpoints were set.");
6266 warning ("Use the \"delete\" command to delete unwanted breakpoints.");
6272 catch_command_1 (char *arg, int tempflag, int from_tty)
6275 /* The first argument may be an event name, such as "start" or "load".
6276 If so, then handle it as such. If it doesn't match an event name,
6277 then attempt to interpret it as an exception name. (This latter is
6278 the v4.16-and-earlier GDB meaning of the "catch" command.)
6280 First, try to find the bounds of what might be an event name. */
6281 char *arg1_start = arg;
6285 if (arg1_start == NULL)
6287 /* Old behaviour was to use pre-v-4.16 syntax */
6288 /* catch_throw_command_1 (arg1_start, tempflag, from_tty); */
6290 /* Now, this is not allowed */
6291 error ("Catch requires an event name.");
6294 arg1_end = ep_find_event_name_end (arg1_start);
6295 if (arg1_end == NULL)
6296 error ("catch requires an event");
6297 arg1_length = arg1_end + 1 - arg1_start;
6299 /* Try to match what we found against known event names. */
6300 if (strncmp (arg1_start, "signal", arg1_length) == 0)
6302 error ("Catch of signal not yet implemented");
6304 else if (strncmp (arg1_start, "catch", arg1_length) == 0)
6306 catch_exception_command_1 (EX_EVENT_CATCH, arg1_end + 1,
6307 tempflag, from_tty);
6309 else if (strncmp (arg1_start, "throw", arg1_length) == 0)
6311 catch_exception_command_1 (EX_EVENT_THROW, arg1_end + 1,
6312 tempflag, from_tty);
6314 else if (strncmp (arg1_start, "thread_start", arg1_length) == 0)
6316 error ("Catch of thread_start not yet implemented");
6318 else if (strncmp (arg1_start, "thread_exit", arg1_length) == 0)
6320 error ("Catch of thread_exit not yet implemented");
6322 else if (strncmp (arg1_start, "thread_join", arg1_length) == 0)
6324 error ("Catch of thread_join not yet implemented");
6326 else if (strncmp (arg1_start, "start", arg1_length) == 0)
6328 error ("Catch of start not yet implemented");
6330 else if (strncmp (arg1_start, "exit", arg1_length) == 0)
6332 error ("Catch of exit not yet implemented");
6334 else if (strncmp (arg1_start, "fork", arg1_length) == 0)
6336 #if defined(CHILD_INSERT_FORK_CATCHPOINT)
6337 catch_fork_command_1 (catch_fork, arg1_end + 1, tempflag, from_tty);
6339 error ("Catch of fork not yet implemented");
6342 else if (strncmp (arg1_start, "vfork", arg1_length) == 0)
6344 #if defined(CHILD_INSERT_VFORK_CATCHPOINT)
6345 catch_fork_command_1 (catch_vfork, arg1_end + 1, tempflag, from_tty);
6347 error ("Catch of vfork not yet implemented");
6350 else if (strncmp (arg1_start, "exec", arg1_length) == 0)
6352 #if defined(CHILD_INSERT_EXEC_CATCHPOINT)
6353 catch_exec_command_1 (arg1_end + 1, tempflag, from_tty);
6355 error ("Catch of exec not yet implemented");
6358 else if (strncmp (arg1_start, "load", arg1_length) == 0)
6360 #if defined(SOLIB_ADD)
6361 catch_load_command_1 (arg1_end + 1, tempflag, from_tty);
6363 error ("Catch of load not implemented");
6366 else if (strncmp (arg1_start, "unload", arg1_length) == 0)
6368 #if defined(SOLIB_ADD)
6369 catch_unload_command_1 (arg1_end + 1, tempflag, from_tty);
6371 error ("Catch of load not implemented");
6374 else if (strncmp (arg1_start, "stop", arg1_length) == 0)
6376 error ("Catch of stop not yet implemented");
6379 /* This doesn't appear to be an event name */
6383 /* Pre-v.4.16 behaviour was to treat the argument
6384 as the name of an exception */
6385 /* catch_throw_command_1 (arg1_start, tempflag, from_tty); */
6386 /* Now this is not allowed */
6387 error ("Unknown event kind specified for catch");
6392 /* Used by the gui, could be made a worker for other things. */
6395 set_breakpoint_sal (struct symtab_and_line sal)
6397 struct breakpoint *b;
6398 b = set_raw_breakpoint (sal, bp_breakpoint);
6399 set_breakpoint_count (breakpoint_count + 1);
6400 b->number = breakpoint_count;
6407 /* These aren't used; I don't know what they were for. */
6408 /* Disable breakpoints on all catch clauses described in ARGS. */
6410 disable_catch (char *args)
6412 /* Map the disable command to catch clauses described in ARGS. */
6415 /* Enable breakpoints on all catch clauses described in ARGS. */
6417 enable_catch (char *args)
6419 /* Map the disable command to catch clauses described in ARGS. */
6422 /* Delete breakpoints on all catch clauses in the active scope. */
6424 delete_catch (char *args)
6426 /* Map the delete command to catch clauses described in ARGS. */
6431 catch_command (char *arg, int from_tty)
6433 catch_command_1 (arg, 0, from_tty);
6438 tcatch_command (char *arg, int from_tty)
6440 catch_command_1 (arg, 1, from_tty);
6443 /* Delete breakpoints by address or line. */
6446 clear_command (char *arg, int from_tty)
6448 struct breakpoint *b, *tmp, *prev, *found;
6450 struct symtabs_and_lines sals;
6451 struct symtab_and_line sal;
6456 sals = decode_line_spec (arg, 1);
6461 sals.sals = (struct symtab_and_line *)
6462 xmalloc (sizeof (struct symtab_and_line));
6463 make_cleanup (xfree, sals.sals);
6464 INIT_SAL (&sal); /* initialize to zeroes */
6465 sal.line = default_breakpoint_line;
6466 sal.symtab = default_breakpoint_symtab;
6467 sal.pc = default_breakpoint_address;
6468 if (sal.symtab == 0)
6469 error ("No source file specified.");
6477 /* For each line spec given, delete bps which correspond
6478 to it. Do it in two passes, solely to preserve the current
6479 behavior that from_tty is forced true if we delete more than
6483 for (i = 0; i < sals.nelts; i++)
6485 /* If exact pc given, clear bpts at that pc.
6486 If line given (pc == 0), clear all bpts on specified line.
6487 If defaulting, clear all bpts on default line
6490 defaulting sal.pc != 0 tests to do
6495 1 0 <can't happen> */
6500 /* Find all matching breakpoints, remove them from the
6501 breakpoint chain, and add them to the 'found' chain. */
6502 ALL_BREAKPOINTS_SAFE (b, tmp)
6504 /* Are we going to delete b? */
6505 if (b->type != bp_none
6506 && b->type != bp_watchpoint
6507 && b->type != bp_hardware_watchpoint
6508 && b->type != bp_read_watchpoint
6509 && b->type != bp_access_watchpoint
6510 /* Not if b is a watchpoint of any sort... */
6511 && (((sal.pc && (b->address == sal.pc))
6512 && (!section_is_overlay (b->section)
6513 || b->section == sal.section))
6514 /* Yes, if sal.pc matches b (modulo overlays). */
6515 || ((default_match || (0 == sal.pc))
6516 && b->source_file != NULL
6517 && sal.symtab != NULL
6518 && STREQ (b->source_file, sal.symtab->filename)
6519 && b->line_number == sal.line)))
6520 /* Yes, if sal source file and line matches b. */
6522 /* Remove it from breakpoint_chain... */
6523 if (b == breakpoint_chain)
6525 /* b is at the head of the list */
6526 breakpoint_chain = b->next;
6530 prev->next = b->next;
6532 /* And add it to 'found' chain. */
6538 /* Keep b, and keep a pointer to it. */
6543 /* Now go thru the 'found' chain and delete them. */
6547 error ("No breakpoint at %s.", arg);
6549 error ("No breakpoint at this line.");
6553 from_tty = 1; /* Always report if deleted more than one */
6555 printf_unfiltered ("Deleted breakpoint%s ", found->next ? "s" : "");
6556 breakpoints_changed ();
6560 printf_unfiltered ("%d ", found->number);
6562 delete_breakpoint (found);
6566 putchar_unfiltered ('\n');
6569 /* Delete breakpoint in BS if they are `delete' breakpoints and
6570 all breakpoints that are marked for deletion, whether hit or not.
6571 This is called after any breakpoint is hit, or after errors. */
6574 breakpoint_auto_delete (bpstat bs)
6576 struct breakpoint *b, *temp;
6578 for (; bs; bs = bs->next)
6579 if (bs->breakpoint_at && bs->breakpoint_at->disposition == disp_del
6581 delete_breakpoint (bs->breakpoint_at);
6583 ALL_BREAKPOINTS_SAFE (b, temp)
6585 if (b->disposition == disp_del_at_next_stop)
6586 delete_breakpoint (b);
6590 /* Delete a breakpoint and clean up all traces of it in the data
6594 delete_breakpoint (struct breakpoint *bpt)
6596 register struct breakpoint *b;
6600 error ("Internal error (attempted to delete a NULL breakpoint)");
6603 /* Has this bp already been deleted? This can happen because multiple
6604 lists can hold pointers to bp's. bpstat lists are especial culprits.
6606 One example of this happening is a watchpoint's scope bp. When the
6607 scope bp triggers, we notice that the watchpoint is out of scope, and
6608 delete it. We also delete its scope bp. But the scope bp is marked
6609 "auto-deleting", and is already on a bpstat. That bpstat is then
6610 checked for auto-deleting bp's, which are deleted.
6612 A real solution to this problem might involve reference counts in bp's,
6613 and/or giving them pointers back to their referencing bpstat's, and
6614 teaching delete_breakpoint to only free a bp's storage when no more
6615 references were extent. A cheaper bandaid was chosen. */
6616 if (bpt->type == bp_none)
6619 if (delete_breakpoint_hook)
6620 delete_breakpoint_hook (bpt);
6621 breakpoint_delete_event (bpt->number);
6624 remove_breakpoint (bpt, mark_inserted);
6626 if (breakpoint_chain == bpt)
6627 breakpoint_chain = bpt->next;
6629 /* If we have callback-style exception catchpoints, don't go through
6630 the adjustments to the C++ runtime library etc. if the inferior
6631 isn't actually running. target_enable_exception_callback for a
6632 null target ops vector gives an undesirable error message, so we
6633 check here and avoid it. Since currently (1997-09-17) only HP-UX aCC's
6634 exceptions are supported in this way, it's OK for now. FIXME */
6635 if (ep_is_exception_catchpoint (bpt) && target_has_execution)
6637 static char message1[] = "Error in deleting catchpoint %d:\n";
6638 static char message[sizeof (message1) + 30];
6639 args_for_catchpoint_enable args;
6641 /* Format possible error msg */
6642 sprintf (message, message1, bpt->number);
6643 args.kind = bpt->type == bp_catch_catch ?
6644 EX_EVENT_CATCH : EX_EVENT_THROW;
6646 catch_errors (cover_target_enable_exception_callback, &args,
6647 message, RETURN_MASK_ALL);
6654 b->next = bpt->next;
6658 check_duplicates (bpt);
6659 /* If this breakpoint was inserted, and there is another breakpoint
6660 at the same address, we need to insert the other breakpoint. */
6662 && bpt->type != bp_hardware_watchpoint
6663 && bpt->type != bp_read_watchpoint
6664 && bpt->type != bp_access_watchpoint
6665 && bpt->type != bp_catch_fork
6666 && bpt->type != bp_catch_vfork
6667 && bpt->type != bp_catch_exec)
6670 if (b->address == bpt->address
6671 && b->section == bpt->section
6673 && b->enable_state != bp_disabled
6674 && b->enable_state != bp_shlib_disabled
6675 && b->enable_state != bp_call_disabled)
6679 /* We should never reach this point if there is a permanent
6680 breakpoint at the same address as the one being deleted.
6681 If there is a permanent breakpoint somewhere, it should
6682 always be the only one inserted. */
6683 if (b->enable_state == bp_permanent)
6684 internal_error (__FILE__, __LINE__,
6685 "another breakpoint was inserted on top of "
6686 "a permanent breakpoint");
6688 if (b->type == bp_hardware_breakpoint)
6689 val = target_insert_hw_breakpoint (b->address, b->shadow_contents);
6691 val = target_insert_breakpoint (b->address, b->shadow_contents);
6695 target_terminal_ours_for_output ();
6696 warning ("Cannot insert breakpoint %d:", b->number);
6697 memory_error (val, b->address); /* which bombs us out */
6704 free_command_lines (&bpt->commands);
6707 if (bpt->cond_string != NULL)
6708 xfree (bpt->cond_string);
6709 if (bpt->addr_string != NULL)
6710 xfree (bpt->addr_string);
6711 if (bpt->exp != NULL)
6713 if (bpt->exp_string != NULL)
6714 xfree (bpt->exp_string);
6715 if (bpt->val != NULL)
6716 value_free (bpt->val);
6717 if (bpt->source_file != NULL)
6718 xfree (bpt->source_file);
6719 if (bpt->dll_pathname != NULL)
6720 xfree (bpt->dll_pathname);
6721 if (bpt->triggered_dll_pathname != NULL)
6722 xfree (bpt->triggered_dll_pathname);
6723 if (bpt->exec_pathname != NULL)
6724 xfree (bpt->exec_pathname);
6726 /* Be sure no bpstat's are pointing at it after it's been freed. */
6727 /* FIXME, how can we find all bpstat's?
6728 We just check stop_bpstat for now. */
6729 for (bs = stop_bpstat; bs; bs = bs->next)
6730 if (bs->breakpoint_at == bpt)
6732 bs->breakpoint_at = NULL;
6734 /* we'd call bpstat_clear_actions, but that free's stuff and due
6735 to the multiple pointers pointing to one item with no
6736 reference counts found anywhere through out the bpstat's (how
6737 do you spell fragile?), we don't want to free things twice --
6738 better a memory leak than a corrupt malloc pool! */
6739 bs->commands = NULL;
6742 /* On the chance that someone will soon try again to delete this same
6743 bp, we mark it as deleted before freeing its storage. */
6744 bpt->type = bp_none;
6750 do_delete_breakpoint_cleanup (void *b)
6752 delete_breakpoint (b);
6756 make_cleanup_delete_breakpoint (struct breakpoint *b)
6758 return make_cleanup (do_delete_breakpoint_cleanup, b);
6762 make_exec_cleanup_delete_breakpoint (struct breakpoint *b)
6764 return make_exec_cleanup (do_delete_breakpoint_cleanup, b);
6768 delete_command (char *arg, int from_tty)
6770 struct breakpoint *b, *temp;
6774 int breaks_to_delete = 0;
6776 /* Delete all breakpoints if no argument.
6777 Do not delete internal or call-dummy breakpoints, these
6778 have to be deleted with an explicit breakpoint number argument. */
6781 if (b->type != bp_call_dummy &&
6782 b->type != bp_shlib_event &&
6783 b->type != bp_thread_event &&
6784 b->type != bp_overlay_event &&
6786 breaks_to_delete = 1;
6789 /* Ask user only if there are some breakpoints to delete. */
6791 || (breaks_to_delete && query ("Delete all breakpoints? ")))
6793 ALL_BREAKPOINTS_SAFE (b, temp)
6795 if (b->type != bp_call_dummy &&
6796 b->type != bp_shlib_event &&
6797 b->type != bp_thread_event &&
6798 b->type != bp_overlay_event &&
6800 delete_breakpoint (b);
6805 map_breakpoint_numbers (arg, delete_breakpoint);
6808 /* Reset a breakpoint given it's struct breakpoint * BINT.
6809 The value we return ends up being the return value from catch_errors.
6810 Unused in this case. */
6813 breakpoint_re_set_one (PTR bint)
6815 /* get past catch_errs */
6816 struct breakpoint *b = (struct breakpoint *) bint;
6819 struct symtabs_and_lines sals;
6821 enum enable_state save_enable;
6826 warning ("attempted to reset apparently deleted breakpoint #%d?",
6830 case bp_hardware_breakpoint:
6832 case bp_catch_unload:
6833 if (b->addr_string == NULL)
6835 /* Anything without a string can't be re-set. */
6836 delete_breakpoint (b);
6839 /* HACK: cagney/2001-11-11: kettenis/2001-11-11: MarkK wrote:
6841 ``And a hack it is, although Apple's Darwin version of GDB
6842 contains an almost identical hack to implement a "future
6843 break" command. It seems to work in many real world cases,
6844 but it is easy to come up with a test case where the patch
6845 doesn't help at all.''
6847 ``It seems that the way GDB implements breakpoints - in -
6848 shared - libraries was designed for a.out shared library
6849 systems (SunOS 4) where shared libraries were loaded at a
6850 fixed address in memory. Since ELF shared libraries can (and
6851 will) be loaded at any address in memory, things break.
6852 Fixing this is not trivial. Therefore, I'm not sure whether
6853 we should add this hack to the branch only. I cannot
6854 guarantee that things will be fixed on the trunk in the near
6857 In case we have a problem, disable this breakpoint. We'll
6858 restore its status if we succeed. Don't disable a
6859 shlib_disabled breakpoint though. There's a fair chance we
6860 can't re-set it if the shared library it's in hasn't been
6862 save_enable = b->enable_state;
6863 if (b->enable_state != bp_shlib_disabled)
6864 b->enable_state = bp_disabled;
6866 set_language (b->language);
6867 input_radix = b->input_radix;
6869 sals = decode_line_1 (&s, 1, (struct symtab *) NULL, 0, (char ***) NULL);
6870 for (i = 0; i < sals.nelts; i++)
6872 resolve_sal_pc (&sals.sals[i]);
6874 /* Reparse conditions, they might contain references to the
6876 if (b->cond_string != NULL)
6881 b->cond = parse_exp_1 (&s, block_for_pc (sals.sals[i].pc), 0);
6884 /* We need to re-set the breakpoint if the address changes... */
6885 if (b->address != sals.sals[i].pc
6886 /* ...or new and old breakpoints both have source files, and
6887 the source file name or the line number changes... */
6888 || (b->source_file != NULL
6889 && sals.sals[i].symtab != NULL
6890 && (!STREQ (b->source_file, sals.sals[i].symtab->filename)
6891 || b->line_number != sals.sals[i].line)
6893 /* ...or we switch between having a source file and not having
6895 || ((b->source_file == NULL) != (sals.sals[i].symtab == NULL))
6898 if (b->source_file != NULL)
6899 xfree (b->source_file);
6900 if (sals.sals[i].symtab == NULL)
6901 b->source_file = NULL;
6904 savestring (sals.sals[i].symtab->filename,
6905 strlen (sals.sals[i].symtab->filename));
6906 b->line_number = sals.sals[i].line;
6907 b->address = sals.sals[i].pc;
6909 /* Used to check for duplicates here, but that can
6910 cause trouble, as it doesn't check for disabled
6915 /* Might be better to do this just once per breakpoint_re_set,
6916 rather than once for every breakpoint. */
6917 breakpoints_changed ();
6919 b->section = sals.sals[i].section;
6920 b->enable_state = save_enable; /* Restore it, this worked. */
6923 /* Now that this is re-enabled, check_duplicates
6925 check_duplicates (b);
6932 case bp_hardware_watchpoint:
6933 case bp_read_watchpoint:
6934 case bp_access_watchpoint:
6935 innermost_block = NULL;
6936 /* The issue arises of what context to evaluate this in. The
6937 same one as when it was set, but what does that mean when
6938 symbols have been re-read? We could save the filename and
6939 functionname, but if the context is more local than that, the
6940 best we could do would be something like how many levels deep
6941 and which index at that particular level, but that's going to
6942 be less stable than filenames or function names. */
6944 /* So for now, just use a global context. */
6947 b->exp = parse_expression (b->exp_string);
6948 b->exp_valid_block = innermost_block;
6949 mark = value_mark ();
6951 value_free (b->val);
6952 b->val = evaluate_expression (b->exp);
6953 release_value (b->val);
6954 if (VALUE_LAZY (b->val))
6955 value_fetch_lazy (b->val);
6957 if (b->cond_string != NULL)
6962 b->cond = parse_exp_1 (&s, (struct block *) 0, 0);
6964 if (b->enable_state == bp_enabled)
6966 value_free_to_mark (mark);
6968 case bp_catch_catch:
6969 case bp_catch_throw:
6971 /* We needn't really do anything to reset these, since the mask
6972 that requests them is unaffected by e.g., new libraries being
6975 case bp_catch_vfork:
6980 printf_filtered ("Deleting unknown breakpoint type %d\n", b->type);
6982 /* Delete longjmp and overlay event breakpoints; they will be
6983 reset later by breakpoint_re_set. */
6985 case bp_longjmp_resume:
6986 case bp_overlay_event:
6987 delete_breakpoint (b);
6990 /* This breakpoint is special, it's set up when the inferior
6991 starts and we really don't want to touch it. */
6992 case bp_shlib_event:
6994 /* Like bp_shlib_event, this breakpoint type is special.
6995 Once it is set up, we do not want to touch it. */
6996 case bp_thread_event:
6998 /* Keep temporary breakpoints, which can be encountered when we step
6999 over a dlopen call and SOLIB_ADD is resetting the breakpoints.
7000 Otherwise these should have been blown away via the cleanup chain
7001 or by breakpoint_init_inferior when we rerun the executable. */
7004 case bp_watchpoint_scope:
7006 case bp_step_resume:
7013 /* Re-set all breakpoints after symbols have been re-loaded. */
7015 breakpoint_re_set (void)
7017 struct breakpoint *b, *temp;
7018 enum language save_language;
7019 int save_input_radix;
7020 static char message1[] = "Error in re-setting breakpoint %d:\n";
7021 char message[sizeof (message1) + 30 /* slop */ ];
7023 save_language = current_language->la_language;
7024 save_input_radix = input_radix;
7025 ALL_BREAKPOINTS_SAFE (b, temp)
7027 /* Format possible error msg */
7028 sprintf (message, message1, b->number);
7029 catch_errors (breakpoint_re_set_one, b, message, RETURN_MASK_ALL);
7031 set_language (save_language);
7032 input_radix = save_input_radix;
7034 if (GET_LONGJMP_TARGET_P ())
7036 create_longjmp_breakpoint ("longjmp");
7037 create_longjmp_breakpoint ("_longjmp");
7038 create_longjmp_breakpoint ("siglongjmp");
7039 create_longjmp_breakpoint ("_siglongjmp");
7040 create_longjmp_breakpoint (NULL);
7043 create_overlay_event_breakpoint ("_ovly_debug_event");
7046 /* Reset the thread number of this breakpoint:
7048 - If the breakpoint is for all threads, leave it as-is.
7049 - Else, reset it to the current thread for inferior_ptid. */
7051 breakpoint_re_set_thread (struct breakpoint *b)
7053 if (b->thread != -1)
7055 if (in_thread_list (inferior_ptid))
7056 b->thread = pid_to_thread_id (inferior_ptid);
7060 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
7061 If from_tty is nonzero, it prints a message to that effect,
7062 which ends with a period (no newline). */
7065 set_ignore_count (int bptnum, int count, int from_tty)
7067 register struct breakpoint *b;
7073 if (b->number == bptnum)
7075 b->ignore_count = count;
7079 printf_filtered ("Will stop next time breakpoint %d is reached.",
7081 else if (count == 1)
7082 printf_filtered ("Will ignore next crossing of breakpoint %d.",
7085 printf_filtered ("Will ignore next %d crossings of breakpoint %d.",
7088 breakpoints_changed ();
7089 breakpoint_modify_event (b->number);
7093 error ("No breakpoint number %d.", bptnum);
7096 /* Clear the ignore counts of all breakpoints. */
7098 breakpoint_clear_ignore_counts (void)
7100 struct breakpoint *b;
7103 b->ignore_count = 0;
7106 /* Command to set ignore-count of breakpoint N to COUNT. */
7109 ignore_command (char *args, int from_tty)
7115 error_no_arg ("a breakpoint number");
7117 num = get_number (&p);
7119 error ("bad breakpoint number: '%s'", args);
7121 error ("Second argument (specified ignore-count) is missing.");
7123 set_ignore_count (num,
7124 longest_to_int (value_as_long (parse_and_eval (p))),
7127 printf_filtered ("\n");
7130 /* Call FUNCTION on each of the breakpoints
7131 whose numbers are given in ARGS. */
7134 map_breakpoint_numbers (char *args, void (*function) (struct breakpoint *))
7136 register char *p = args;
7139 register struct breakpoint *b, *tmp;
7143 error_no_arg ("one or more breakpoint numbers");
7150 num = get_number_or_range (&p1);
7153 warning ("bad breakpoint number at or near '%s'", p);
7157 ALL_BREAKPOINTS_SAFE (b, tmp)
7158 if (b->number == num)
7160 struct breakpoint *related_breakpoint = b->related_breakpoint;
7163 if (related_breakpoint)
7164 function (related_breakpoint);
7168 printf_unfiltered ("No breakpoint number %d.\n", num);
7174 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
7175 If from_tty is nonzero, it prints a message to that effect,
7176 which ends with a period (no newline). */
7179 disable_breakpoint (struct breakpoint *bpt)
7181 /* Never disable a watchpoint scope breakpoint; we want to
7182 hit them when we leave scope so we can delete both the
7183 watchpoint and its scope breakpoint at that time. */
7184 if (bpt->type == bp_watchpoint_scope)
7187 /* You can't disable permanent breakpoints. */
7188 if (bpt->enable_state == bp_permanent)
7191 bpt->enable_state = bp_disabled;
7193 check_duplicates (bpt);
7195 if (modify_breakpoint_hook)
7196 modify_breakpoint_hook (bpt);
7197 breakpoint_modify_event (bpt->number);
7202 disable_command (char *args, int from_tty)
7204 register struct breakpoint *bpt;
7206 ALL_BREAKPOINTS (bpt)
7210 warning ("attempted to disable apparently deleted breakpoint #%d?",
7215 case bp_catch_unload:
7217 case bp_catch_vfork:
7219 case bp_catch_catch:
7220 case bp_catch_throw:
7221 case bp_hardware_breakpoint:
7223 case bp_hardware_watchpoint:
7224 case bp_read_watchpoint:
7225 case bp_access_watchpoint:
7226 disable_breakpoint (bpt);
7231 map_breakpoint_numbers (args, disable_breakpoint);
7235 do_enable_breakpoint (struct breakpoint *bpt, enum bpdisp disposition)
7237 struct frame_info *save_selected_frame = NULL;
7238 int save_selected_frame_level = -1;
7239 int target_resources_ok, other_type_used;
7242 if (bpt->type == bp_hardware_breakpoint)
7245 i = hw_breakpoint_used_count ();
7246 target_resources_ok =
7247 TARGET_CAN_USE_HARDWARE_WATCHPOINT (bp_hardware_breakpoint,
7249 if (target_resources_ok == 0)
7250 error ("No hardware breakpoint support in the target.");
7251 else if (target_resources_ok < 0)
7252 error ("Hardware breakpoints used exceeds limit.");
7255 if (bpt->enable_state != bp_permanent)
7256 bpt->enable_state = bp_enabled;
7257 bpt->disposition = disposition;
7258 check_duplicates (bpt);
7259 breakpoints_changed ();
7261 if (bpt->type == bp_watchpoint ||
7262 bpt->type == bp_hardware_watchpoint ||
7263 bpt->type == bp_read_watchpoint ||
7264 bpt->type == bp_access_watchpoint)
7266 if (bpt->exp_valid_block != NULL)
7268 struct frame_info *fr =
7269 fr = frame_find_by_id (bpt->watchpoint_frame);
7273 Cannot enable watchpoint %d because the block in which its expression\n\
7274 is valid is not currently in scope.\n", bpt->number);
7275 bpt->enable_state = bp_disabled;
7279 save_selected_frame = selected_frame;
7280 save_selected_frame_level = frame_relative_level (selected_frame);
7284 value_free (bpt->val);
7285 mark = value_mark ();
7286 bpt->val = evaluate_expression (bpt->exp);
7287 release_value (bpt->val);
7288 if (VALUE_LAZY (bpt->val))
7289 value_fetch_lazy (bpt->val);
7291 if (bpt->type == bp_hardware_watchpoint ||
7292 bpt->type == bp_read_watchpoint ||
7293 bpt->type == bp_access_watchpoint)
7295 int i = hw_watchpoint_used_count (bpt->type, &other_type_used);
7296 int mem_cnt = can_use_hardware_watchpoint (bpt->val);
7298 /* Hack around 'unused var' error for some targets here */
7300 target_resources_ok = TARGET_CAN_USE_HARDWARE_WATCHPOINT (
7301 bpt->type, i + mem_cnt, other_type_used);
7302 /* we can consider of type is bp_hardware_watchpoint, convert to
7303 bp_watchpoint in the following condition */
7304 if (target_resources_ok < 0)
7307 Cannot enable watchpoint %d because target watch resources\n\
7308 have been allocated for other watchpoints.\n", bpt->number);
7309 bpt->enable_state = bp_disabled;
7310 value_free_to_mark (mark);
7315 if (save_selected_frame_level >= 0)
7316 select_frame (save_selected_frame);
7317 value_free_to_mark (mark);
7319 if (modify_breakpoint_hook)
7320 modify_breakpoint_hook (bpt);
7321 breakpoint_modify_event (bpt->number);
7325 enable_breakpoint (struct breakpoint *bpt)
7327 do_enable_breakpoint (bpt, bpt->disposition);
7330 /* The enable command enables the specified breakpoints (or all defined
7331 breakpoints) so they once again become (or continue to be) effective
7332 in stopping the inferior. */
7336 enable_command (char *args, int from_tty)
7338 register struct breakpoint *bpt;
7340 ALL_BREAKPOINTS (bpt)
7344 warning ("attempted to enable apparently deleted breakpoint #%d?",
7349 case bp_catch_unload:
7351 case bp_catch_vfork:
7353 case bp_catch_catch:
7354 case bp_catch_throw:
7355 case bp_hardware_breakpoint:
7357 case bp_hardware_watchpoint:
7358 case bp_read_watchpoint:
7359 case bp_access_watchpoint:
7360 enable_breakpoint (bpt);
7365 map_breakpoint_numbers (args, enable_breakpoint);
7369 enable_once_breakpoint (struct breakpoint *bpt)
7371 do_enable_breakpoint (bpt, disp_disable);
7376 enable_once_command (char *args, int from_tty)
7378 map_breakpoint_numbers (args, enable_once_breakpoint);
7382 enable_delete_breakpoint (struct breakpoint *bpt)
7384 do_enable_breakpoint (bpt, disp_del);
7389 enable_delete_command (char *args, int from_tty)
7391 map_breakpoint_numbers (args, enable_delete_breakpoint);
7394 /* Use default_breakpoint_'s, or nothing if they aren't valid. */
7396 struct symtabs_and_lines
7397 decode_line_spec_1 (char *string, int funfirstline)
7399 struct symtabs_and_lines sals;
7401 error ("Empty line specification.");
7402 if (default_breakpoint_valid)
7403 sals = decode_line_1 (&string, funfirstline,
7404 default_breakpoint_symtab,
7405 default_breakpoint_line,
7408 sals = decode_line_1 (&string, funfirstline,
7409 (struct symtab *) NULL, 0, (char ***) NULL);
7411 error ("Junk at end of line specification: %s", string);
7416 _initialize_breakpoint (void)
7418 struct cmd_list_element *c;
7420 breakpoint_chain = 0;
7421 /* Don't bother to call set_breakpoint_count. $bpnum isn't useful
7422 before a breakpoint is set. */
7423 breakpoint_count = 0;
7425 add_com ("ignore", class_breakpoint, ignore_command,
7426 "Set ignore-count of breakpoint number N to COUNT.\n\
7427 Usage is `ignore N COUNT'.");
7429 add_com_alias ("bc", "ignore", class_breakpoint, 1);
7431 add_com ("commands", class_breakpoint, commands_command,
7432 "Set commands to be executed when a breakpoint is hit.\n\
7433 Give breakpoint number as argument after \"commands\".\n\
7434 With no argument, the targeted breakpoint is the last one set.\n\
7435 The commands themselves follow starting on the next line.\n\
7436 Type a line containing \"end\" to indicate the end of them.\n\
7437 Give \"silent\" as the first line to make the breakpoint silent;\n\
7438 then no output is printed when it is hit, except what the commands print.");
7440 add_com ("condition", class_breakpoint, condition_command,
7441 "Specify breakpoint number N to break only if COND is true.\n\
7442 Usage is `condition N COND', where N is an integer and COND is an\n\
7443 expression to be evaluated whenever breakpoint N is reached.");
7445 c = add_com ("tbreak", class_breakpoint, tbreak_command,
7446 "Set a temporary breakpoint. Args like \"break\" command.\n\
7447 Like \"break\" except the breakpoint is only temporary,\n\
7448 so it will be deleted when hit. Equivalent to \"break\" followed\n\
7449 by using \"enable delete\" on the breakpoint number.");
7450 set_cmd_completer (c, location_completer);
7452 c = add_com ("hbreak", class_breakpoint, hbreak_command,
7453 "Set a hardware assisted breakpoint. Args like \"break\" command.\n\
7454 Like \"break\" except the breakpoint requires hardware support,\n\
7455 some target hardware may not have this support.");
7456 set_cmd_completer (c, location_completer);
7458 c = add_com ("thbreak", class_breakpoint, thbreak_command,
7459 "Set a temporary hardware assisted breakpoint. Args like \"break\" command.\n\
7460 Like \"hbreak\" except the breakpoint is only temporary,\n\
7461 so it will be deleted when hit.");
7462 set_cmd_completer (c, location_completer);
7464 add_prefix_cmd ("enable", class_breakpoint, enable_command,
7465 "Enable some breakpoints.\n\
7466 Give breakpoint numbers (separated by spaces) as arguments.\n\
7467 With no subcommand, breakpoints are enabled until you command otherwise.\n\
7468 This is used to cancel the effect of the \"disable\" command.\n\
7469 With a subcommand you can enable temporarily.",
7470 &enablelist, "enable ", 1, &cmdlist);
7472 add_com ("ab", class_breakpoint, enable_command,
7473 "Enable some breakpoints.\n\
7474 Give breakpoint numbers (separated by spaces) as arguments.\n\
7475 With no subcommand, breakpoints are enabled until you command otherwise.\n\
7476 This is used to cancel the effect of the \"disable\" command.\n\
7477 With a subcommand you can enable temporarily.");
7479 add_com_alias ("en", "enable", class_breakpoint, 1);
7481 add_abbrev_prefix_cmd ("breakpoints", class_breakpoint, enable_command,
7482 "Enable some breakpoints.\n\
7483 Give breakpoint numbers (separated by spaces) as arguments.\n\
7484 This is used to cancel the effect of the \"disable\" command.\n\
7485 May be abbreviated to simply \"enable\".\n",
7486 &enablebreaklist, "enable breakpoints ", 1, &enablelist);
7488 add_cmd ("once", no_class, enable_once_command,
7489 "Enable breakpoints for one hit. Give breakpoint numbers.\n\
7490 If a breakpoint is hit while enabled in this fashion, it becomes disabled.",
7493 add_cmd ("delete", no_class, enable_delete_command,
7494 "Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
7495 If a breakpoint is hit while enabled in this fashion, it is deleted.",
7498 add_cmd ("delete", no_class, enable_delete_command,
7499 "Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
7500 If a breakpoint is hit while enabled in this fashion, it is deleted.",
7503 add_cmd ("once", no_class, enable_once_command,
7504 "Enable breakpoints for one hit. Give breakpoint numbers.\n\
7505 If a breakpoint is hit while enabled in this fashion, it becomes disabled.",
7508 add_prefix_cmd ("disable", class_breakpoint, disable_command,
7509 "Disable some breakpoints.\n\
7510 Arguments are breakpoint numbers with spaces in between.\n\
7511 To disable all breakpoints, give no argument.\n\
7512 A disabled breakpoint is not forgotten, but has no effect until reenabled.",
7513 &disablelist, "disable ", 1, &cmdlist);
7514 add_com_alias ("dis", "disable", class_breakpoint, 1);
7515 add_com_alias ("disa", "disable", class_breakpoint, 1);
7517 add_com ("sb", class_breakpoint, disable_command,
7518 "Disable some breakpoints.\n\
7519 Arguments are breakpoint numbers with spaces in between.\n\
7520 To disable all breakpoints, give no argument.\n\
7521 A disabled breakpoint is not forgotten, but has no effect until reenabled.");
7523 add_cmd ("breakpoints", class_alias, disable_command,
7524 "Disable some breakpoints.\n\
7525 Arguments are breakpoint numbers with spaces in between.\n\
7526 To disable all breakpoints, give no argument.\n\
7527 A disabled breakpoint is not forgotten, but has no effect until reenabled.\n\
7528 This command may be abbreviated \"disable\".",
7531 add_prefix_cmd ("delete", class_breakpoint, delete_command,
7532 "Delete some breakpoints or auto-display expressions.\n\
7533 Arguments are breakpoint numbers with spaces in between.\n\
7534 To delete all breakpoints, give no argument.\n\
7536 Also a prefix command for deletion of other GDB objects.\n\
7537 The \"unset\" command is also an alias for \"delete\".",
7538 &deletelist, "delete ", 1, &cmdlist);
7539 add_com_alias ("d", "delete", class_breakpoint, 1);
7541 add_com ("db", class_breakpoint, delete_command,
7542 "Delete some breakpoints.\n\
7543 Arguments are breakpoint numbers with spaces in between.\n\
7544 To delete all breakpoints, give no argument.\n");
7546 add_cmd ("breakpoints", class_alias, delete_command,
7547 "Delete some breakpoints or auto-display expressions.\n\
7548 Arguments are breakpoint numbers with spaces in between.\n\
7549 To delete all breakpoints, give no argument.\n\
7550 This command may be abbreviated \"delete\".",
7553 add_com ("clear", class_breakpoint, clear_command,
7554 concat ("Clear breakpoint at specified line or function.\n\
7555 Argument may be line number, function name, or \"*\" and an address.\n\
7556 If line number is specified, all breakpoints in that line are cleared.\n\
7557 If function is specified, breakpoints at beginning of function are cleared.\n\
7558 If an address is specified, breakpoints at that address are cleared.\n\n",
7559 "With no argument, clears all breakpoints in the line that the selected frame\n\
7562 See also the \"delete\" command which clears breakpoints by number.", NULL));
7564 c = add_com ("break", class_breakpoint, break_command,
7565 concat ("Set breakpoint at specified line or function.\n\
7566 Argument may be line number, function name, or \"*\" and an address.\n\
7567 If line number is specified, break at start of code for that line.\n\
7568 If function is specified, break at start of code for that function.\n\
7569 If an address is specified, break at that exact address.\n",
7570 "With no arg, uses current execution address of selected stack frame.\n\
7571 This is useful for breaking on return to a stack frame.\n\
7573 Multiple breakpoints at one place are permitted, and useful if conditional.\n\
7575 Do \"help breakpoints\" for info on other commands dealing with breakpoints.", NULL));
7576 set_cmd_completer (c, location_completer);
7578 add_com_alias ("b", "break", class_run, 1);
7579 add_com_alias ("br", "break", class_run, 1);
7580 add_com_alias ("bre", "break", class_run, 1);
7581 add_com_alias ("brea", "break", class_run, 1);
7585 add_com_alias ("ba", "break", class_breakpoint, 1);
7586 add_com_alias ("bu", "ubreak", class_breakpoint, 1);
7591 add_abbrev_prefix_cmd ("stop", class_breakpoint, stop_command,
7592 "Break in function/address or break at a line in the current file.",
7593 &stoplist, "stop ", 1, &cmdlist);
7594 add_cmd ("in", class_breakpoint, stopin_command,
7595 "Break in function or address.\n", &stoplist);
7596 add_cmd ("at", class_breakpoint, stopat_command,
7597 "Break at a line in the current file.\n", &stoplist);
7598 add_com ("status", class_info, breakpoints_info,
7599 concat ("Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
7600 The \"Type\" column indicates one of:\n\
7601 \tbreakpoint - normal breakpoint\n\
7602 \twatchpoint - watchpoint\n\
7603 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
7604 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
7605 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
7606 address and file/line number respectively.\n\n",
7607 "Convenience variable \"$_\" and default examine address for \"x\"\n\
7608 are set to the address of the last breakpoint listed.\n\n\
7609 Convenience variable \"$bpnum\" contains the number of the last\n\
7610 breakpoint set.", NULL));
7613 add_info ("breakpoints", breakpoints_info,
7614 concat ("Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
7615 The \"Type\" column indicates one of:\n\
7616 \tbreakpoint - normal breakpoint\n\
7617 \twatchpoint - watchpoint\n\
7618 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
7619 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
7620 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
7621 address and file/line number respectively.\n\n",
7622 "Convenience variable \"$_\" and default examine address for \"x\"\n\
7623 are set to the address of the last breakpoint listed.\n\n\
7624 Convenience variable \"$bpnum\" contains the number of the last\n\
7625 breakpoint set.", NULL));
7628 add_com ("lb", class_breakpoint, breakpoints_info,
7629 concat ("Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
7630 The \"Type\" column indicates one of:\n\
7631 \tbreakpoint - normal breakpoint\n\
7632 \twatchpoint - watchpoint\n\
7633 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
7634 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
7635 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
7636 address and file/line number respectively.\n\n",
7637 "Convenience variable \"$_\" and default examine address for \"x\"\n\
7638 are set to the address of the last breakpoint listed.\n\n\
7639 Convenience variable \"$bpnum\" contains the number of the last\n\
7640 breakpoint set.", NULL));
7642 add_cmd ("breakpoints", class_maintenance, maintenance_info_breakpoints,
7643 concat ("Status of all breakpoints, or breakpoint number NUMBER.\n\
7644 The \"Type\" column indicates one of:\n\
7645 \tbreakpoint - normal breakpoint\n\
7646 \twatchpoint - watchpoint\n\
7647 \tlongjmp - internal breakpoint used to step through longjmp()\n\
7648 \tlongjmp resume - internal breakpoint at the target of longjmp()\n\
7649 \tuntil - internal breakpoint used by the \"until\" command\n\
7650 \tfinish - internal breakpoint used by the \"finish\" command\n",
7651 "The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
7652 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
7653 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
7654 address and file/line number respectively.\n\n",
7655 "Convenience variable \"$_\" and default examine address for \"x\"\n\
7656 are set to the address of the last breakpoint listed.\n\n\
7657 Convenience variable \"$bpnum\" contains the number of the last\n\
7658 breakpoint set.", NULL),
7659 &maintenanceinfolist);
7661 add_com ("catch", class_breakpoint, catch_command,
7662 "Set catchpoints to catch events.\n\
7663 Raised signals may be caught:\n\
7664 \tcatch signal - all signals\n\
7665 \tcatch signal <signame> - a particular signal\n\
7666 Raised exceptions may be caught:\n\
7667 \tcatch throw - all exceptions, when thrown\n\
7668 \tcatch throw <exceptname> - a particular exception, when thrown\n\
7669 \tcatch catch - all exceptions, when caught\n\
7670 \tcatch catch <exceptname> - a particular exception, when caught\n\
7671 Thread or process events may be caught:\n\
7672 \tcatch thread_start - any threads, just after creation\n\
7673 \tcatch thread_exit - any threads, just before expiration\n\
7674 \tcatch thread_join - any threads, just after joins\n\
7675 Process events may be caught:\n\
7676 \tcatch start - any processes, just after creation\n\
7677 \tcatch exit - any processes, just before expiration\n\
7678 \tcatch fork - calls to fork()\n\
7679 \tcatch vfork - calls to vfork()\n\
7680 \tcatch exec - calls to exec()\n\
7681 Dynamically-linked library events may be caught:\n\
7682 \tcatch load - loads of any library\n\
7683 \tcatch load <libname> - loads of a particular library\n\
7684 \tcatch unload - unloads of any library\n\
7685 \tcatch unload <libname> - unloads of a particular library\n\
7686 The act of your program's execution stopping may also be caught:\n\
7688 C++ exceptions may be caught:\n\
7689 \tcatch throw - all exceptions, when thrown\n\
7690 \tcatch catch - all exceptions, when caught\n\
7692 Do \"help set follow-fork-mode\" for info on debugging your program\n\
7693 after a fork or vfork is caught.\n\n\
7694 Do \"help breakpoints\" for info on other commands dealing with breakpoints.");
7696 add_com ("tcatch", class_breakpoint, tcatch_command,
7697 "Set temporary catchpoints to catch events.\n\
7698 Args like \"catch\" command.\n\
7699 Like \"catch\" except the catchpoint is only temporary,\n\
7700 so it will be deleted when hit. Equivalent to \"catch\" followed\n\
7701 by using \"enable delete\" on the catchpoint number.");
7703 c = add_com ("watch", class_breakpoint, watch_command,
7704 "Set a watchpoint for an expression.\n\
7705 A watchpoint stops execution of your program whenever the value of\n\
7706 an expression changes.");
7707 set_cmd_completer (c, location_completer);
7709 c = add_com ("rwatch", class_breakpoint, rwatch_command,
7710 "Set a read watchpoint for an expression.\n\
7711 A watchpoint stops execution of your program whenever the value of\n\
7712 an expression is read.");
7713 set_cmd_completer (c, location_completer);
7715 c = add_com ("awatch", class_breakpoint, awatch_command,
7716 "Set a watchpoint for an expression.\n\
7717 A watchpoint stops execution of your program whenever the value of\n\
7718 an expression is either read or written.");
7719 set_cmd_completer (c, location_completer);
7721 add_info ("watchpoints", breakpoints_info,
7722 "Synonym for ``info breakpoints''.");
7725 c = add_set_cmd ("can-use-hw-watchpoints", class_support, var_zinteger,
7726 (char *) &can_use_hw_watchpoints,
7727 "Set debugger's willingness to use watchpoint hardware.\n\
7728 If zero, gdb will not use hardware for new watchpoints, even if\n\
7729 such is available. (However, any hardware watchpoints that were\n\
7730 created before setting this to nonzero, will continue to use watchpoint\n\
7733 add_show_from_set (c, &showlist);
7735 can_use_hw_watchpoints = 1;