1 /* Everything about breakpoints, for GDB.
2 Copyright 1986, 87, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 1999
3 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
26 #include "breakpoint.h"
28 #include "expression.h"
34 #include "gdbthread.h"
37 #include "gdb_string.h"
43 #include "gdb-events.h"
45 /* Prototypes for local functions. */
47 static void until_break_command_continuation (struct continuation_arg *arg);
50 catch_command_1 PARAMS ((char *, int, int));
53 enable_delete_command PARAMS ((char *, int));
56 enable_delete_breakpoint PARAMS ((struct breakpoint *));
59 enable_once_command PARAMS ((char *, int));
62 enable_once_breakpoint PARAMS ((struct breakpoint *));
65 disable_command PARAMS ((char *, int));
68 enable_command PARAMS ((char *, int));
71 map_breakpoint_numbers PARAMS ((char *, void (*)(struct breakpoint *)));
74 ignore_command PARAMS ((char *, int));
76 static int breakpoint_re_set_one PARAMS ((PTR));
79 clear_command PARAMS ((char *, int));
82 catch_command PARAMS ((char *, int));
85 handle_gnu_4_16_catch_command PARAMS ((char *, int, int));
87 static struct symtabs_and_lines
88 get_catch_sals PARAMS ((int));
91 watch_command PARAMS ((char *, int));
94 can_use_hardware_watchpoint PARAMS ((struct value *));
96 static void break_at_finish_command PARAMS ((char *, int));
97 static void break_at_finish_at_depth_command PARAMS ((char *, int));
100 tbreak_command PARAMS ((char *, int));
102 static void tbreak_at_finish_command PARAMS ((char *, int));
105 break_command_1 PARAMS ((char *, int, int));
108 mention PARAMS ((struct breakpoint *));
111 set_raw_breakpoint PARAMS ((struct symtab_and_line));
114 check_duplicates PARAMS ((CORE_ADDR, asection *));
117 describe_other_breakpoints PARAMS ((CORE_ADDR, asection *));
120 breakpoints_info PARAMS ((char *, int));
123 breakpoint_1 PARAMS ((int, int));
126 bpstat_alloc PARAMS ((struct breakpoint *, bpstat));
128 static int breakpoint_cond_eval PARAMS ((PTR));
131 cleanup_executing_breakpoints PARAMS ((PTR));
134 commands_command PARAMS ((char *, int));
137 condition_command PARAMS ((char *, int));
140 get_number_trailer PARAMS ((char **, int));
143 set_breakpoint_count PARAMS ((int));
146 static struct breakpoint *
147 create_temp_exception_breakpoint PARAMS ((CORE_ADDR));
158 remove_breakpoint PARAMS ((struct breakpoint *, insertion_state_t));
160 static enum print_stop_action print_it_typical PARAMS ((bpstat));
162 static enum print_stop_action print_bp_stop_message (bpstat bs);
166 enum exception_event_kind kind;
169 args_for_catchpoint_enable;
171 static int watchpoint_check PARAMS ((PTR));
173 static int cover_target_enable_exception_callback PARAMS ((PTR));
175 static void maintenance_info_breakpoints PARAMS ((char *, int));
177 #ifdef GET_LONGJMP_TARGET
178 static void create_longjmp_breakpoint PARAMS ((char *));
181 static int hw_breakpoint_used_count PARAMS ((void));
183 static int hw_watchpoint_used_count PARAMS ((enum bptype, int *));
185 static void hbreak_command PARAMS ((char *, int));
187 static void thbreak_command PARAMS ((char *, int));
189 static void watch_command_1 PARAMS ((char *, int, int));
191 static void rwatch_command PARAMS ((char *, int));
193 static void awatch_command PARAMS ((char *, int));
195 static void do_enable_breakpoint PARAMS ((struct breakpoint *, enum bpdisp));
197 static void solib_load_unload_1 PARAMS ((char *hookname,
201 enum bptype bp_kind));
203 static void create_fork_vfork_event_catchpoint PARAMS ((int tempflag,
205 enum bptype bp_kind));
207 static void break_at_finish_at_depth_command_1 PARAMS ((char *arg,
211 static void break_at_finish_command_1 PARAMS ((char *arg,
215 static void stop_command PARAMS ((char *arg, int from_tty));
217 static void stopin_command PARAMS ((char *arg, int from_tty));
219 static void stopat_command PARAMS ((char *arg, int from_tty));
221 static char *ep_find_event_name_end PARAMS ((char *arg));
223 static char *ep_parse_optional_if_clause PARAMS ((char **arg));
225 static char *ep_parse_optional_filename PARAMS ((char **arg));
227 #if defined(CHILD_INSERT_EXEC_CATCHPOINT)
228 static void catch_exec_command_1 PARAMS ((char *arg, int tempflag,
232 static void create_exception_catchpoint
233 PARAMS ((int tempflag, char *cond_string,
234 enum exception_event_kind ex_event,
235 struct symtab_and_line * sal));
237 static void catch_exception_command_1
238 PARAMS ((enum exception_event_kind ex_event,
239 char *arg, int tempflag, int from_tty));
241 static void tcatch_command PARAMS ((char *arg, int from_tty));
243 static void ep_skip_leading_whitespace PARAMS ((char **s));
245 /* Prototypes for exported functions. */
248 awatch_command PARAMS ((char *, int));
251 do_enable_breakpoint PARAMS ((struct breakpoint *, enum bpdisp));
253 /* If FALSE, gdb will not use hardware support for watchpoints, even
254 if such is available. */
255 static int can_use_hw_watchpoints;
257 void _initialize_breakpoint PARAMS ((void));
259 void set_breakpoint_count PARAMS ((int));
261 extern int addressprint; /* Print machine addresses? */
263 #if defined (GET_LONGJMP_TARGET) || defined (SOLIB_ADD)
264 static int internal_breakpoint_number = -1;
267 /* Are we executing breakpoint commands? */
268 static int executing_breakpoint_commands;
270 /* Walk the following statement or block through all breakpoints.
271 ALL_BREAKPOINTS_SAFE does so even if the statment deletes the current
274 #define ALL_BREAKPOINTS(B) for (B = breakpoint_chain; B; B = B->next)
276 #define ALL_BREAKPOINTS_SAFE(B,TMP) \
277 for (B = breakpoint_chain; \
278 B ? (TMP=B->next, 1): 0; \
281 /* True if SHIFT_INST_REGS defined, false otherwise. */
283 int must_shift_inst_regs =
284 #if defined(SHIFT_INST_REGS)
291 /* True if breakpoint hit counts should be displayed in breakpoint info. */
293 int show_breakpoint_hit_counts = 1;
295 /* Chain of all breakpoints defined. */
297 struct breakpoint *breakpoint_chain;
299 /* Number of last breakpoint made. */
301 int breakpoint_count;
303 /* Pointer to current exception event record */
304 static struct exception_event_record *current_exception_event;
306 /* Indicator of whether exception catchpoints should be nuked
307 between runs of a program */
308 int exception_catchpoints_are_fragile = 0;
310 /* Indicator of when exception catchpoints set-up should be
311 reinitialized -- e.g. when program is re-run */
312 int exception_support_initialized = 0;
314 /* This function returns a pointer to the string representation of the
315 pathname of the dynamically-linked library that has just been
318 This function must be used only when SOLIB_HAVE_LOAD_EVENT is TRUE,
319 or undefined results are guaranteed.
321 This string's contents are only valid immediately after the
322 inferior has stopped in the dynamic linker hook, and becomes
323 invalid as soon as the inferior is continued. Clients should make
324 a copy of this string if they wish to continue the inferior and
325 then access the string. */
327 #ifndef SOLIB_LOADED_LIBRARY_PATHNAME
328 #define SOLIB_LOADED_LIBRARY_PATHNAME(pid) ""
331 /* This function returns a pointer to the string representation of the
332 pathname of the dynamically-linked library that has just been
335 This function must be used only when SOLIB_HAVE_UNLOAD_EVENT is
336 TRUE, or undefined results are guaranteed.
338 This string's contents are only valid immediately after the
339 inferior has stopped in the dynamic linker hook, and becomes
340 invalid as soon as the inferior is continued. Clients should make
341 a copy of this string if they wish to continue the inferior and
342 then access the string. */
344 #ifndef SOLIB_UNLOADED_LIBRARY_PATHNAME
345 #define SOLIB_UNLOADED_LIBRARY_PATHNAME(pid) ""
348 /* This function is called by the "catch load" command. It allows the
349 debugger to be notified by the dynamic linker when a specified
350 library file (or any library file, if filename is NULL) is loaded. */
352 #ifndef SOLIB_CREATE_CATCH_LOAD_HOOK
353 #define SOLIB_CREATE_CATCH_LOAD_HOOK(pid,tempflag,filename,cond_string) \
354 error ("catch of library loads not yet implemented on this platform")
357 /* This function is called by the "catch unload" command. It allows
358 the debugger to be notified by the dynamic linker when a specified
359 library file (or any library file, if filename is NULL) is
362 #ifndef SOLIB_CREATE_CATCH_UNLOAD_HOOK
363 #define SOLIB_CREATE_CATCH_UNLOAD_HOOK(pid,tempflag,filename,cond_string) \
364 error ("catch of library unloads not yet implemented on this platform")
367 /* Set breakpoint count to NUM. */
370 set_breakpoint_count (num)
373 breakpoint_count = num;
374 set_internalvar (lookup_internalvar ("bpnum"),
375 value_from_longest (builtin_type_int, (LONGEST) num));
378 /* Used in run_command to zero the hit count when a new run starts. */
381 clear_breakpoint_hit_counts ()
383 struct breakpoint *b;
389 /* Default address, symtab and line to put a breakpoint at
390 for "break" command with no arg.
391 if default_breakpoint_valid is zero, the other three are
392 not valid, and "break" with no arg is an error.
394 This set by print_stack_frame, which calls set_default_breakpoint. */
396 int default_breakpoint_valid;
397 CORE_ADDR default_breakpoint_address;
398 struct symtab *default_breakpoint_symtab;
399 int default_breakpoint_line;
401 /* *PP is a string denoting a breakpoint. Get the number of the breakpoint.
402 Advance *PP after the string and any trailing whitespace.
404 Currently the string can either be a number or "$" followed by the name
405 of a convenience variable. Making it an expression wouldn't work well
406 for map_breakpoint_numbers (e.g. "4 + 5 + 6").
408 TRAILER is a character which can be found after the number; most
409 commonly this is `-'. If you don't want a trailer, use \0. */
411 get_number_trailer (pp, trailer)
415 int retval = 0; /* default */
419 /* Empty line means refer to the last breakpoint. */
420 return breakpoint_count;
423 /* Make a copy of the name, so we can null-terminate it
424 to pass to lookup_internalvar(). */
429 while (isalnum (*p) || *p == '_')
431 varname = (char *) alloca (p - start + 1);
432 strncpy (varname, start, p - start);
433 varname[p - start] = '\0';
434 val = value_of_internalvar (lookup_internalvar (varname));
435 if (TYPE_CODE (VALUE_TYPE (val)) == TYPE_CODE_INT)
436 retval = (int) value_as_long (val);
439 printf_filtered ("Convenience variable must have integer value.\n");
447 while (*p >= '0' && *p <= '9')
450 /* There is no number here. (e.g. "cond a == b"). */
452 /* Skip non-numeric token */
453 while (*p && !isspace((int) *p))
455 /* Return zero, which caller must interpret as error. */
461 if (!(isspace (*p) || *p == '\0' || *p == trailer))
463 /* Trailing junk: return 0 and let caller print error msg. */
464 while (!(isspace (*p) || *p == '\0' || *p == trailer))
475 /* Like get_number_trailer, but don't allow a trailer. */
480 return get_number_trailer (pp, '\0');
483 /* Parse a number or a range.
484 * A number will be of the form handled by get_number.
485 * A range will be of the form <number1> - <number2>, and
486 * will represent all the integers between number1 and number2,
489 * While processing a range, this fuction is called iteratively;
490 * At each call it will return the next value in the range.
492 * At the beginning of parsing a range, the char pointer PP will
493 * be advanced past <number1> and left pointing at the '-' token.
494 * Subsequent calls will not advance the pointer until the range
495 * is completed. The call that completes the range will advance
496 * pointer PP past <number2>.
500 get_number_or_range (pp)
503 static int last_retval, end_value;
504 static char *end_ptr;
505 static int in_range = 0;
509 /* Default case: pp is pointing either to a solo number,
510 or to the first number of a range. */
511 last_retval = get_number_trailer (pp, '-');
516 /* This is the start of a range (<number1> - <number2>).
517 Skip the '-', parse and remember the second number,
518 and also remember the end of the final token. */
522 while (isspace ((int) *end_ptr))
523 end_ptr++; /* skip white space */
524 end_value = get_number (temp);
525 if (end_value < last_retval)
527 error ("inverted range");
529 else if (end_value == last_retval)
531 /* degenerate range (number1 == number2). Advance the
532 token pointer so that the range will be treated as a
541 error ("negative value");
544 /* pp points to the '-' that betokens a range. All
545 number-parsing has already been done. Return the next
546 integer value (one greater than the saved previous value).
547 Do not advance the token pointer 'pp' until the end of range
550 if (++last_retval == end_value)
552 /* End of range reached; advance token pointer. */
562 /* condition N EXP -- set break condition of breakpoint N to EXP. */
565 condition_command (arg, from_tty)
569 register struct breakpoint *b;
574 error_no_arg ("breakpoint number");
577 bnum = get_number (&p);
579 error ("Bad breakpoint argument: '%s'", arg);
582 if (b->number == bnum)
586 free ((PTR) b->cond);
589 if (b->cond_string != NULL)
590 free ((PTR) b->cond_string);
595 b->cond_string = NULL;
597 printf_filtered ("Breakpoint %d now unconditional.\n", bnum);
602 /* I don't know if it matters whether this is the string the user
603 typed in or the decompiled expression. */
604 b->cond_string = savestring (arg, strlen (arg));
605 b->cond = parse_exp_1 (&arg, block_for_pc (b->address), 0);
607 error ("Junk at end of expression");
609 breakpoints_changed ();
613 error ("No breakpoint number %d.", bnum);
618 commands_command (arg, from_tty)
622 register struct breakpoint *b;
625 struct command_line *l;
627 /* If we allowed this, we would have problems with when to
628 free the storage, if we change the commands currently
631 if (executing_breakpoint_commands)
632 error ("Can't use the \"commands\" command among a breakpoint's commands.");
635 bnum = get_number (&p);
638 error ("Unexpected extra arguments following breakpoint number.");
641 if (b->number == bnum)
645 "Type commands for when breakpoint %d is hit, one per line.",
647 l = read_command_lines (tmpbuf, from_tty);
648 free_command_lines (&b->commands);
650 breakpoints_changed ();
653 error ("No breakpoint number %d.", bnum);
656 /* Like target_read_memory() but if breakpoints are inserted, return
657 the shadow contents instead of the breakpoints themselves.
659 Read "memory data" from whatever target or inferior we have.
660 Returns zero if successful, errno value if not. EIO is used
661 for address out of bounds. If breakpoints are inserted, returns
662 shadow contents, not the breakpoints themselves. From breakpoint.c. */
665 read_memory_nobpt (memaddr, myaddr, len)
671 struct breakpoint *b;
672 CORE_ADDR bp_addr = 0;
675 if (BREAKPOINT_FROM_PC (&bp_addr, &bp_size) == NULL)
676 /* No breakpoints on this machine. */
677 return target_read_memory (memaddr, myaddr, len);
681 if (b->type == bp_none)
682 warning ("reading through apparently deleted breakpoint #%d?",
685 /* memory breakpoint? */
686 if (b->type == bp_watchpoint
687 || b->type == bp_hardware_watchpoint
688 || b->type == bp_read_watchpoint
689 || b->type == bp_access_watchpoint)
694 /* Addresses and length of the part of the breakpoint that
696 /* XXXX The m68k, sh and h8300 have different local and remote
697 breakpoint values. BREAKPOINT_FROM_PC still manages to
698 correctly determine the breakpoints memory address and size
699 for these targets. */
700 bp_addr = b->address;
702 if (BREAKPOINT_FROM_PC (&bp_addr, &bp_size) == NULL)
707 if (bp_addr + bp_size <= memaddr)
708 /* The breakpoint is entirely before the chunk of memory we
711 if (bp_addr >= memaddr + len)
712 /* The breakpoint is entirely after the chunk of memory we are
715 /* Copy the breakpoint from the shadow contents, and recurse for
716 the things before and after. */
718 /* Offset within shadow_contents. */
721 if (bp_addr < memaddr)
723 /* Only copy the second part of the breakpoint. */
724 bp_size -= memaddr - bp_addr;
725 bptoffset = memaddr - bp_addr;
729 if (bp_addr + bp_size > memaddr + len)
731 /* Only copy the first part of the breakpoint. */
732 bp_size -= (bp_addr + bp_size) - (memaddr + len);
735 memcpy (myaddr + bp_addr - memaddr,
736 b->shadow_contents + bptoffset, bp_size);
738 if (bp_addr > memaddr)
740 /* Copy the section of memory before the breakpoint. */
741 status = read_memory_nobpt (memaddr, myaddr, bp_addr - memaddr);
746 if (bp_addr + bp_size < memaddr + len)
748 /* Copy the section of memory after the breakpoint. */
749 status = read_memory_nobpt
751 myaddr + bp_addr + bp_size - memaddr,
752 memaddr + len - (bp_addr + bp_size));
759 /* Nothing overlaps. Just call read_memory_noerr. */
760 return target_read_memory (memaddr, myaddr, len);
764 /* insert_breakpoints is used when starting or continuing the program.
765 remove_breakpoints is used when the program stops.
766 Both return zero if successful,
767 or an `errno' value if could not write the inferior. */
770 insert_breakpoints ()
772 register struct breakpoint *b, *temp;
773 int return_val = 0; /* return success code. */
775 int disabled_breaks = 0;
777 static char message1[] = "Error inserting catchpoint %d:\n";
778 static char message[sizeof (message1) + 30];
781 ALL_BREAKPOINTS_SAFE (b, temp)
783 if (b->enable == permanent)
784 /* Permanent breakpoints cannot be inserted or removed. */
786 else if (b->type != bp_watchpoint
787 && b->type != bp_hardware_watchpoint
788 && b->type != bp_read_watchpoint
789 && b->type != bp_access_watchpoint
790 && b->type != bp_catch_fork
791 && b->type != bp_catch_vfork
792 && b->type != bp_catch_exec
793 && b->type != bp_catch_throw
794 && b->type != bp_catch_catch
795 && b->enable != disabled
796 && b->enable != shlib_disabled
797 && b->enable != call_disabled
801 if (b->type == bp_hardware_breakpoint)
802 val = target_insert_hw_breakpoint (b->address, b->shadow_contents);
805 /* Check to see if breakpoint is in an overlay section;
806 if so, we should set the breakpoint at the LMA address.
807 Only if the section is currently mapped should we ALSO
808 set a break at the VMA address. */
809 if (overlay_debugging && b->section &&
810 section_is_overlay (b->section))
814 addr = overlay_unmapped_address (b->address, b->section);
815 val = target_insert_breakpoint (addr, b->shadow_contents);
816 /* This would be the time to check val, to see if the
817 breakpoint write to the load address succeeded.
818 However, this might be an ordinary occurrance, eg. if
819 the unmapped overlay is in ROM. */
820 val = 0; /* in case unmapped address failed */
821 if (section_is_mapped (b->section))
822 val = target_insert_breakpoint (b->address,
825 else /* ordinary (non-overlay) address */
826 val = target_insert_breakpoint (b->address, b->shadow_contents);
830 /* Can't set the breakpoint. */
831 #if defined (DISABLE_UNSETTABLE_BREAK)
832 if (DISABLE_UNSETTABLE_BREAK (b->address))
834 /* See also: disable_breakpoints_in_shlibs. */
836 b->enable = shlib_disabled;
837 if (!disabled_breaks)
839 target_terminal_ours_for_output ();
840 warning ("Cannot insert breakpoint %d:", b->number);
841 warning ("Temporarily disabling shared library breakpoints:");
844 warning ("breakpoint #%d ", b->number);
849 target_terminal_ours_for_output ();
850 warning ("Cannot insert breakpoint %d:", b->number);
851 #ifdef ONE_PROCESS_WRITETEXT
852 warning ("The same program may be running in another process.");
854 memory_error (val, b->address); /* which bombs us out */
861 return_val = val; /* remember failure */
863 else if (ep_is_exception_catchpoint (b)
864 && b->enable != disabled
865 && b->enable != shlib_disabled
866 && b->enable != call_disabled
871 /* If we get here, we must have a callback mechanism for exception
872 events -- with g++ style embedded label support, we insert
873 ordinary breakpoints and not catchpoints. */
874 /* Format possible error message */
875 sprintf (message, message1, b->number);
877 val = target_insert_breakpoint (b->address, b->shadow_contents);
880 /* Couldn't set breakpoint for some reason */
881 target_terminal_ours_for_output ();
882 warning ("Cannot insert catchpoint %d; disabling it.",
884 b->enable = disabled;
888 /* Bp set, now make sure callbacks are enabled */
890 args_for_catchpoint_enable args;
891 args.kind = b->type == bp_catch_catch ?
892 EX_EVENT_CATCH : EX_EVENT_THROW;
894 val = catch_errors (cover_target_enable_exception_callback,
896 message, RETURN_MASK_ALL);
897 if (val != 0 && val != -1)
901 /* Check if something went wrong; val == 0 can be ignored */
904 /* something went wrong */
905 target_terminal_ours_for_output ();
906 warning ("Cannot insert catchpoint %d; disabling it.",
908 b->enable = disabled;
913 return_val = val; /* remember failure */
916 else if ((b->type == bp_hardware_watchpoint ||
917 b->type == bp_read_watchpoint ||
918 b->type == bp_access_watchpoint)
919 && b->enable == enabled
923 struct frame_info *saved_frame;
924 int saved_level, within_current_scope;
925 value_ptr mark = value_mark ();
928 /* Save the current frame and level so we can restore it after
929 evaluating the watchpoint expression on its own frame. */
930 saved_frame = selected_frame;
931 saved_level = selected_frame_level;
933 /* Determine if the watchpoint is within scope. */
934 if (b->exp_valid_block == NULL)
935 within_current_scope = 1;
938 struct frame_info *fi;
940 /* There might be no current frame at this moment if we are
941 resuming from a step over a breakpoint.
942 Set up current frame before trying to find the watchpoint
944 get_current_frame ();
945 fi = find_frame_addr_in_frame_chain (b->watchpoint_frame);
946 within_current_scope = (fi != NULL);
947 if (within_current_scope)
948 select_frame (fi, -1);
951 if (within_current_scope)
953 /* Evaluate the expression and cut the chain of values
954 produced off from the value chain.
956 Make sure the value returned isn't lazy; we use
957 laziness to determine what memory GDB actually needed
958 in order to compute the value of the expression. */
959 v = evaluate_expression (b->exp);
961 value_release_to_mark (mark);
966 /* Look at each value on the value chain. */
967 for (; v; v = v->next)
969 /* If it's a memory location, and GDB actually needed
970 its contents to evaluate the expression, then we
972 if (VALUE_LVAL (v) == lval_memory
978 addr = VALUE_ADDRESS (v) + VALUE_OFFSET (v);
979 len = TYPE_LENGTH (VALUE_TYPE (v));
981 if (b->type == bp_read_watchpoint)
983 else if (b->type == bp_access_watchpoint)
986 val = target_insert_watchpoint (addr, len, type);
995 /* Failure to insert a watchpoint on any memory value in the
996 value chain brings us here. */
999 remove_breakpoint (b, mark_uninserted);
1000 warning ("Could not insert hardware watchpoint %d.",
1007 printf_filtered ("Hardware watchpoint %d deleted", b->number);
1008 printf_filtered ("because the program has left the block \n");
1009 printf_filtered ("in which its expression is valid.\n");
1010 if (b->related_breakpoint)
1011 b->related_breakpoint->disposition = del_at_next_stop;
1012 b->disposition = del_at_next_stop;
1015 /* Restore the frame and level. */
1016 if ((saved_frame != selected_frame) ||
1017 (saved_level != selected_frame_level))
1018 select_and_print_frame (saved_frame, saved_level);
1021 return_val = val; /* remember failure */
1023 else if ((b->type == bp_catch_fork
1024 || b->type == bp_catch_vfork
1025 || b->type == bp_catch_exec)
1026 && b->enable == enabled
1034 val = target_insert_fork_catchpoint (inferior_pid);
1036 case bp_catch_vfork:
1037 val = target_insert_vfork_catchpoint (inferior_pid);
1040 val = target_insert_exec_catchpoint (inferior_pid);
1043 warning ("Internal error, %s line %d.", __FILE__, __LINE__);
1048 target_terminal_ours_for_output ();
1049 warning ("Cannot insert catchpoint %d.", b->number);
1055 return_val = val; /* remember failure */
1064 remove_breakpoints ()
1066 register struct breakpoint *b;
1073 val = remove_breakpoint (b, mark_uninserted);
1082 reattach_breakpoints (pid)
1085 register struct breakpoint *b;
1087 int saved_inferior_pid = inferior_pid;
1089 /* FIXME: use a cleanup, to insure that inferior_pid gets replaced! */
1090 inferior_pid = pid; /* Because remove_breakpoint will use this global. */
1095 remove_breakpoint (b, mark_inserted);
1096 if (b->type == bp_hardware_breakpoint)
1097 val = target_insert_hw_breakpoint (b->address, b->shadow_contents);
1099 val = target_insert_breakpoint (b->address, b->shadow_contents);
1102 inferior_pid = saved_inferior_pid;
1107 inferior_pid = saved_inferior_pid;
1112 update_breakpoints_after_exec ()
1114 struct breakpoint *b;
1115 struct breakpoint *temp;
1117 /* Doing this first prevents the badness of having delete_breakpoint()
1118 write a breakpoint's current "shadow contents" to lift the bp. That
1119 shadow is NOT valid after an exec()! */
1120 mark_breakpoints_out ();
1122 ALL_BREAKPOINTS_SAFE (b, temp)
1124 /* Solib breakpoints must be explicitly reset after an exec(). */
1125 if (b->type == bp_shlib_event)
1127 delete_breakpoint (b);
1131 /* Step-resume breakpoints are meaningless after an exec(). */
1132 if (b->type == bp_step_resume)
1134 delete_breakpoint (b);
1138 /* Ditto the sigtramp handler breakpoints. */
1139 if (b->type == bp_through_sigtramp)
1141 delete_breakpoint (b);
1145 /* Ditto the exception-handling catchpoints. */
1146 if ((b->type == bp_catch_catch) || (b->type == bp_catch_throw))
1148 delete_breakpoint (b);
1152 /* Don't delete an exec catchpoint, because else the inferior
1153 won't stop when it ought!
1155 Similarly, we probably ought to keep vfork catchpoints, 'cause
1156 on this target, we may not be able to stop when the vfork is
1157 seen, but only when the subsequent exec is seen. (And because
1158 deleting fork catchpoints here but not vfork catchpoints will
1159 seem mysterious to users, keep those too.)
1161 ??rehrauer: Let's hope that merely clearing out this catchpoint's
1162 target address field, if any, is sufficient to have it be reset
1163 automagically. Certainly on HP-UX that's true. */
1164 if ((b->type == bp_catch_exec) ||
1165 (b->type == bp_catch_vfork) ||
1166 (b->type == bp_catch_fork))
1168 b->address = (CORE_ADDR) NULL;
1172 /* bp_finish is a special case. The only way we ought to be able
1173 to see one of these when an exec() has happened, is if the user
1174 caught a vfork, and then said "finish". Ordinarily a finish just
1175 carries them to the call-site of the current callee, by setting
1176 a temporary bp there and resuming. But in this case, the finish
1177 will carry them entirely through the vfork & exec.
1179 We don't want to allow a bp_finish to remain inserted now. But
1180 we can't safely delete it, 'cause finish_command has a handle to
1181 the bp on a bpstat, and will later want to delete it. There's a
1182 chance (and I've seen it happen) that if we delete the bp_finish
1183 here, that its storage will get reused by the time finish_command
1184 gets 'round to deleting the "use to be a bp_finish" breakpoint.
1185 We really must allow finish_command to delete a bp_finish.
1187 In the absense of a general solution for the "how do we know
1188 it's safe to delete something others may have handles to?"
1189 problem, what we'll do here is just uninsert the bp_finish, and
1190 let finish_command delete it.
1192 (We know the bp_finish is "doomed" in the sense that it's
1193 momentary, and will be deleted as soon as finish_command sees
1194 the inferior stopped. So it doesn't matter that the bp's
1195 address is probably bogus in the new a.out, unlike e.g., the
1196 solib breakpoints.) */
1198 if (b->type == bp_finish)
1203 /* Without a symbolic address, we have little hope of the
1204 pre-exec() address meaning the same thing in the post-exec()
1206 if (b->addr_string == NULL)
1208 delete_breakpoint (b);
1212 /* If this breakpoint has survived the above battery of checks, then
1213 it must have a symbolic address. Be sure that it gets reevaluated
1214 to a target address, rather than reusing the old evaluation. */
1215 b->address = (CORE_ADDR) NULL;
1220 detach_breakpoints (pid)
1223 register struct breakpoint *b;
1225 int saved_inferior_pid = inferior_pid;
1227 if (pid == inferior_pid)
1228 error ("Cannot detach breakpoints of inferior_pid");
1230 /* FIXME: use a cleanup, to insure that inferior_pid gets replaced! */
1231 inferior_pid = pid; /* Because remove_breakpoint will use this global. */
1236 val = remove_breakpoint (b, mark_inserted);
1239 inferior_pid = saved_inferior_pid;
1244 inferior_pid = saved_inferior_pid;
1249 remove_breakpoint (b, is)
1250 struct breakpoint *b;
1251 insertion_state_t is;
1255 if (b->enable == permanent)
1256 /* Permanent breakpoints cannot be inserted or removed. */
1259 if (b->type == bp_none)
1260 warning ("attempted to remove apparently deleted breakpoint #%d?",
1263 if (b->type != bp_watchpoint
1264 && b->type != bp_hardware_watchpoint
1265 && b->type != bp_read_watchpoint
1266 && b->type != bp_access_watchpoint
1267 && b->type != bp_catch_fork
1268 && b->type != bp_catch_vfork
1269 && b->type != bp_catch_exec
1270 && b->type != bp_catch_catch
1271 && b->type != bp_catch_throw)
1273 if (b->type == bp_hardware_breakpoint)
1274 val = target_remove_hw_breakpoint (b->address, b->shadow_contents);
1277 /* Check to see if breakpoint is in an overlay section;
1278 if so, we should remove the breakpoint at the LMA address.
1279 If that is not equal to the raw address, then we should
1280 presumable remove the breakpoint there as well. */
1281 if (overlay_debugging && b->section &&
1282 section_is_overlay (b->section))
1286 addr = overlay_unmapped_address (b->address, b->section);
1287 val = target_remove_breakpoint (addr, b->shadow_contents);
1288 /* This would be the time to check val, to see if the
1289 shadow breakpoint write to the load address succeeded.
1290 However, this might be an ordinary occurrance, eg. if
1291 the unmapped overlay is in ROM. */
1292 val = 0; /* in case unmapped address failed */
1293 if (section_is_mapped (b->section))
1294 val = target_remove_breakpoint (b->address,
1295 b->shadow_contents);
1297 else /* ordinary (non-overlay) address */
1298 val = target_remove_breakpoint (b->address, b->shadow_contents);
1302 b->inserted = (is == mark_inserted);
1304 else if ((b->type == bp_hardware_watchpoint ||
1305 b->type == bp_read_watchpoint ||
1306 b->type == bp_access_watchpoint)
1307 && b->enable == enabled
1312 b->inserted = (is == mark_inserted);
1313 /* Walk down the saved value chain. */
1314 for (v = b->val_chain; v; v = v->next)
1316 /* For each memory reference remove the watchpoint
1318 if (VALUE_LVAL (v) == lval_memory
1319 && ! VALUE_LAZY (v))
1324 addr = VALUE_ADDRESS (v) + VALUE_OFFSET (v);
1325 len = TYPE_LENGTH (VALUE_TYPE (v));
1327 if (b->type == bp_read_watchpoint)
1329 else if (b->type == bp_access_watchpoint)
1332 val = target_remove_watchpoint (addr, len, type);
1338 /* Failure to remove any of the hardware watchpoints comes here. */
1339 if ((is == mark_uninserted) && (b->inserted))
1340 warning ("Could not remove hardware watchpoint %d.",
1343 /* Free the saved value chain. We will construct a new one
1344 the next time the watchpoint is inserted. */
1345 for (v = b->val_chain; v; v = n)
1350 b->val_chain = NULL;
1352 else if ((b->type == bp_catch_fork ||
1353 b->type == bp_catch_vfork ||
1354 b->type == bp_catch_exec)
1355 && b->enable == enabled
1362 val = target_remove_fork_catchpoint (inferior_pid);
1364 case bp_catch_vfork:
1365 val = target_remove_vfork_catchpoint (inferior_pid);
1368 val = target_remove_exec_catchpoint (inferior_pid);
1371 warning ("Internal error, %s line %d.", __FILE__, __LINE__);
1376 b->inserted = (is == mark_inserted);
1378 else if ((b->type == bp_catch_catch ||
1379 b->type == bp_catch_throw)
1380 && b->enable == enabled
1384 val = target_remove_breakpoint (b->address, b->shadow_contents);
1387 b->inserted = (is == mark_inserted);
1389 else if (ep_is_exception_catchpoint (b)
1390 && b->inserted /* sometimes previous insert doesn't happen */
1391 && b->enable == enabled
1395 val = target_remove_breakpoint (b->address, b->shadow_contents);
1399 b->inserted = (is == mark_inserted);
1405 /* Clear the "inserted" flag in all breakpoints. */
1408 mark_breakpoints_out ()
1410 register struct breakpoint *b;
1416 /* Clear the "inserted" flag in all breakpoints and delete any
1417 breakpoints which should go away between runs of the program.
1419 Plus other such housekeeping that has to be done for breakpoints
1422 Note: this function gets called at the end of a run (by
1423 generic_mourn_inferior) and when a run begins (by
1424 init_wait_for_inferior). */
1429 breakpoint_init_inferior (context)
1430 enum inf_context context;
1432 register struct breakpoint *b, *temp;
1433 static int warning_needed = 0;
1435 ALL_BREAKPOINTS_SAFE (b, temp)
1442 case bp_watchpoint_scope:
1444 /* If the call dummy breakpoint is at the entry point it will
1445 cause problems when the inferior is rerun, so we better
1448 Also get rid of scope breakpoints. */
1449 delete_breakpoint (b);
1453 case bp_hardware_watchpoint:
1454 case bp_read_watchpoint:
1455 case bp_access_watchpoint:
1457 /* Likewise for watchpoints on local expressions. */
1458 if (b->exp_valid_block != NULL)
1459 delete_breakpoint (b);
1462 /* Likewise for exception catchpoints in dynamic-linked
1463 executables where required */
1464 if (ep_is_exception_catchpoint (b) &&
1465 exception_catchpoints_are_fragile)
1468 delete_breakpoint (b);
1474 if (exception_catchpoints_are_fragile)
1475 exception_support_initialized = 0;
1477 /* Don't issue the warning unless it's really needed... */
1478 if (warning_needed && (context != inf_exited))
1480 warning ("Exception catchpoints from last run were deleted.");
1481 warning ("You must reinsert them explicitly.");
1486 /* breakpoint_here_p (PC) returns non-zero if an enabled breakpoint
1487 exists at PC. It returns ordinary_breakpoint_here if it's an
1488 ordinary breakpoint, or permanent_breakpoint_here if it's a
1489 permanent breakpoint.
1490 - When continuing from a location with an ordinary breakpoint, we
1491 actually single step once before calling insert_breakpoints.
1492 - When continuing from a localion with a permanent breakpoint, we
1493 need to use the `SKIP_PERMANENT_BREAKPOINT' macro, provided by
1494 the target, to advance the PC past the breakpoint. */
1496 enum breakpoint_here
1497 breakpoint_here_p (pc)
1500 register struct breakpoint *b;
1501 int any_breakpoint_here = 0;
1504 if ((b->enable == enabled
1505 || b->enable == permanent)
1506 && b->address == pc) /* bp is enabled and matches pc */
1508 if (overlay_debugging &&
1509 section_is_overlay (b->section) &&
1510 !section_is_mapped (b->section))
1511 continue; /* unmapped overlay -- can't be a match */
1512 else if (b->enable == permanent)
1513 return permanent_breakpoint_here;
1515 any_breakpoint_here = 1;
1518 return any_breakpoint_here ? ordinary_breakpoint_here : 0;
1522 /* breakpoint_inserted_here_p (PC) is just like breakpoint_here_p(),
1523 but it only returns true if there is actually a breakpoint inserted
1527 breakpoint_inserted_here_p (pc)
1530 register struct breakpoint *b;
1534 && b->address == pc) /* bp is inserted and matches pc */
1536 if (overlay_debugging &&
1537 section_is_overlay (b->section) &&
1538 !section_is_mapped (b->section))
1539 continue; /* unmapped overlay -- can't be a match */
1547 /* Return nonzero if FRAME is a dummy frame. We can't use
1548 PC_IN_CALL_DUMMY because figuring out the saved SP would take too
1549 much time, at least using get_saved_register on the 68k. This
1550 means that for this function to work right a port must use the
1551 bp_call_dummy breakpoint. */
1554 frame_in_dummy (frame)
1555 struct frame_info *frame;
1557 struct breakpoint *b;
1562 if (USE_GENERIC_DUMMY_FRAMES)
1563 return generic_pc_in_call_dummy (frame->pc, frame->frame, frame->frame);
1567 if (b->type == bp_call_dummy
1568 && b->frame == frame->frame
1569 /* We need to check the PC as well as the frame on the sparc,
1570 for signals.exp in the testsuite. */
1573 - SIZEOF_CALL_DUMMY_WORDS / sizeof (LONGEST) * REGISTER_SIZE))
1574 && frame->pc <= b->address)
1580 /* breakpoint_match_thread (PC, PID) returns true if the breakpoint at PC
1581 is valid for process/thread PID. */
1584 breakpoint_thread_match (pc, pid)
1588 struct breakpoint *b;
1591 thread = pid_to_thread_id (pid);
1594 if (b->enable != disabled
1595 && b->enable != shlib_disabled
1596 && b->enable != call_disabled
1598 && (b->thread == -1 || b->thread == thread))
1600 if (overlay_debugging &&
1601 section_is_overlay (b->section) &&
1602 !section_is_mapped (b->section))
1603 continue; /* unmapped overlay -- can't be a match */
1612 /* bpstat stuff. External routines' interfaces are documented
1616 ep_is_catchpoint (ep)
1617 struct breakpoint *ep;
1620 (ep->type == bp_catch_load)
1621 || (ep->type == bp_catch_unload)
1622 || (ep->type == bp_catch_fork)
1623 || (ep->type == bp_catch_vfork)
1624 || (ep->type == bp_catch_exec)
1625 || (ep->type == bp_catch_catch)
1626 || (ep->type == bp_catch_throw)
1629 /* ??rehrauer: Add more kinds here, as are implemented... */
1634 ep_is_shlib_catchpoint (ep)
1635 struct breakpoint *ep;
1638 (ep->type == bp_catch_load)
1639 || (ep->type == bp_catch_unload)
1644 ep_is_exception_catchpoint (ep)
1645 struct breakpoint *ep;
1648 (ep->type == bp_catch_catch)
1649 || (ep->type == bp_catch_throw)
1653 /* Clear a bpstat so that it says we are not at any breakpoint.
1654 Also free any storage that is part of a bpstat. */
1669 if (p->old_val != NULL)
1670 value_free (p->old_val);
1677 /* Return a copy of a bpstat. Like "bs1 = bs2" but all storage that
1678 is part of the bpstat is copied as well. */
1686 bpstat retval = NULL;
1691 for (; bs != NULL; bs = bs->next)
1693 tmp = (bpstat) xmalloc (sizeof (*tmp));
1694 memcpy (tmp, bs, sizeof (*tmp));
1696 /* This is the first thing in the chain. */
1706 /* Find the bpstat associated with this breakpoint */
1709 bpstat_find_breakpoint (bsp, breakpoint)
1711 struct breakpoint *breakpoint;
1716 for (; bsp != NULL; bsp = bsp->next)
1718 if (bsp->breakpoint_at == breakpoint)
1724 /* Find a step_resume breakpoint associated with this bpstat.
1725 (If there are multiple step_resume bp's on the list, this function
1726 will arbitrarily pick one.)
1728 It is an error to use this function if BPSTAT doesn't contain a
1729 step_resume breakpoint.
1731 See wait_for_inferior's use of this function. */
1733 bpstat_find_step_resume_breakpoint (bsp)
1737 error ("Internal error (bpstat_find_step_resume_breakpoint)");
1739 for (; bsp != NULL; bsp = bsp->next)
1741 if ((bsp->breakpoint_at != NULL) &&
1742 (bsp->breakpoint_at->type == bp_step_resume))
1743 return bsp->breakpoint_at;
1746 error ("Internal error (no step_resume breakpoint found)");
1750 /* Return the breakpoint number of the first breakpoint we are stopped
1751 at. *BSP upon return is a bpstat which points to the remaining
1752 breakpoints stopped at (but which is not guaranteed to be good for
1753 anything but further calls to bpstat_num).
1754 Return 0 if passed a bpstat which does not indicate any breakpoints. */
1760 struct breakpoint *b;
1763 return 0; /* No more breakpoint values */
1766 b = (*bsp)->breakpoint_at;
1767 *bsp = (*bsp)->next;
1769 return -1; /* breakpoint that's been deleted since */
1771 return b->number; /* We have its number */
1775 /* Modify BS so that the actions will not be performed. */
1778 bpstat_clear_actions (bs)
1781 for (; bs != NULL; bs = bs->next)
1783 bs->commands = NULL;
1784 if (bs->old_val != NULL)
1786 value_free (bs->old_val);
1792 /* Stub for cleaning up our state if we error-out of a breakpoint command */
1795 cleanup_executing_breakpoints (ignore)
1798 executing_breakpoint_commands = 0;
1801 /* Execute all the commands associated with all the breakpoints at this
1802 location. Any of these commands could cause the process to proceed
1803 beyond this point, etc. We look out for such changes by checking
1804 the global "breakpoint_proceeded" after each command. */
1807 bpstat_do_actions (bsp)
1811 struct cleanup *old_chain;
1812 struct command_line *cmd;
1814 /* Avoid endless recursion if a `source' command is contained
1816 if (executing_breakpoint_commands)
1819 executing_breakpoint_commands = 1;
1820 old_chain = make_cleanup (cleanup_executing_breakpoints, 0);
1823 /* Note that (as of this writing), our callers all appear to
1824 be passing us the address of global stop_bpstat. And, if
1825 our calls to execute_control_command cause the inferior to
1826 proceed, that global (and hence, *bsp) will change.
1828 We must be careful to not touch *bsp unless the inferior
1829 has not proceeded. */
1831 /* This pointer will iterate over the list of bpstat's. */
1834 breakpoint_proceeded = 0;
1835 for (; bs != NULL; bs = bs->next)
1840 execute_control_command (cmd);
1842 if (breakpoint_proceeded)
1847 if (breakpoint_proceeded)
1848 /* The inferior is proceeded by the command; bomb out now.
1849 The bpstat chain has been blown away by wait_for_inferior.
1850 But since execution has stopped again, there is a new bpstat
1851 to look at, so start over. */
1854 bs->commands = NULL;
1857 executing_breakpoint_commands = 0;
1858 discard_cleanups (old_chain);
1861 /* This is the normal print function for a bpstat. In the future,
1862 much of this logic could (should?) be moved to bpstat_stop_status,
1863 by having it set different print_it values.
1865 Current scheme: When we stop, bpstat_print() is called. It loops
1866 through the bpstat list of things causing this stop, calling the
1867 print_bp_stop_message function on each one. The behavior of the
1868 print_bp_stop_message function depends on the print_it field of
1869 bpstat. If such field so indicates, call this function here.
1871 Return values from this routine (ultimately used by bpstat_print()
1872 and normal_stop() to decide what to do):
1873 PRINT_NOTHING: Means we already printed all we needed to print,
1874 don't print anything else.
1875 PRINT_SRC_ONLY: Means we printed something, and we do *not* desire
1876 that something to be followed by a location.
1877 PRINT_SCR_AND_LOC: Means we printed something, and we *do* desire
1878 that something to be followed by a location.
1879 PRINT_UNKNOWN: Means we printed nothing or we need to do some more
1882 static enum print_stop_action
1883 print_it_typical (bs)
1886 /* bs->breakpoint_at can be NULL if it was a momentary breakpoint
1887 which has since been deleted. */
1888 if (bs->breakpoint_at == NULL)
1889 return PRINT_UNKNOWN;
1891 switch (bs->breakpoint_at->type)
1894 case bp_hardware_breakpoint:
1895 /* I think the user probably only wants to see one breakpoint
1896 number, not all of them. */
1897 annotate_breakpoint (bs->breakpoint_at->number);
1898 printf_filtered ("\nBreakpoint %d, ", bs->breakpoint_at->number);
1899 return PRINT_SRC_AND_LOC;
1902 case bp_shlib_event:
1903 /* Did we stop because the user set the stop_on_solib_events
1904 variable? (If so, we report this as a generic, "Stopped due
1905 to shlib event" message.) */
1906 printf_filtered ("Stopped due to shared library event\n");
1907 return PRINT_NOTHING;
1911 annotate_catchpoint (bs->breakpoint_at->number);
1912 printf_filtered ("\nCatchpoint %d (", bs->breakpoint_at->number);
1913 printf_filtered ("loaded");
1914 printf_filtered (" %s), ", bs->breakpoint_at->triggered_dll_pathname);
1915 return PRINT_SRC_AND_LOC;
1918 case bp_catch_unload:
1919 annotate_catchpoint (bs->breakpoint_at->number);
1920 printf_filtered ("\nCatchpoint %d (", bs->breakpoint_at->number);
1921 printf_filtered ("unloaded");
1922 printf_filtered (" %s), ", bs->breakpoint_at->triggered_dll_pathname);
1923 return PRINT_SRC_AND_LOC;
1927 annotate_catchpoint (bs->breakpoint_at->number);
1928 printf_filtered ("\nCatchpoint %d (", bs->breakpoint_at->number);
1929 printf_filtered ("forked");
1930 printf_filtered (" process %d), ",
1931 bs->breakpoint_at->forked_inferior_pid);
1932 return PRINT_SRC_AND_LOC;
1935 case bp_catch_vfork:
1936 annotate_catchpoint (bs->breakpoint_at->number);
1937 printf_filtered ("\nCatchpoint %d (", bs->breakpoint_at->number);
1938 printf_filtered ("vforked");
1939 printf_filtered (" process %d), ",
1940 bs->breakpoint_at->forked_inferior_pid);
1941 return PRINT_SRC_AND_LOC;
1945 annotate_catchpoint (bs->breakpoint_at->number);
1946 printf_filtered ("\nCatchpoint %d (exec'd %s), ",
1947 bs->breakpoint_at->number,
1948 bs->breakpoint_at->exec_pathname);
1949 return PRINT_SRC_AND_LOC;
1952 case bp_catch_catch:
1953 if (current_exception_event &&
1954 (CURRENT_EXCEPTION_KIND == EX_EVENT_CATCH))
1956 annotate_catchpoint (bs->breakpoint_at->number);
1957 printf_filtered ("\nCatchpoint %d (exception caught), ",
1958 bs->breakpoint_at->number);
1959 printf_filtered ("throw location ");
1960 if (CURRENT_EXCEPTION_THROW_PC && CURRENT_EXCEPTION_THROW_LINE)
1961 printf_filtered ("%s:%d",
1962 CURRENT_EXCEPTION_THROW_FILE,
1963 CURRENT_EXCEPTION_THROW_LINE);
1965 printf_filtered ("unknown");
1967 printf_filtered (", catch location ");
1968 if (CURRENT_EXCEPTION_CATCH_PC && CURRENT_EXCEPTION_CATCH_LINE)
1969 printf_filtered ("%s:%d",
1970 CURRENT_EXCEPTION_CATCH_FILE,
1971 CURRENT_EXCEPTION_CATCH_LINE);
1973 printf_filtered ("unknown");
1975 printf_filtered ("\n");
1976 /* don't bother to print location frame info */
1977 return PRINT_SRC_ONLY;
1981 /* really throw, some other bpstat will handle it */
1982 return PRINT_UNKNOWN;
1986 case bp_catch_throw:
1987 if (current_exception_event &&
1988 (CURRENT_EXCEPTION_KIND == EX_EVENT_THROW))
1990 annotate_catchpoint (bs->breakpoint_at->number);
1991 printf_filtered ("\nCatchpoint %d (exception thrown), ",
1992 bs->breakpoint_at->number);
1993 printf_filtered ("throw location ");
1994 if (CURRENT_EXCEPTION_THROW_PC && CURRENT_EXCEPTION_THROW_LINE)
1995 printf_filtered ("%s:%d",
1996 CURRENT_EXCEPTION_THROW_FILE,
1997 CURRENT_EXCEPTION_THROW_LINE);
1999 printf_filtered ("unknown");
2001 printf_filtered (", catch location ");
2002 if (CURRENT_EXCEPTION_CATCH_PC && CURRENT_EXCEPTION_CATCH_LINE)
2003 printf_filtered ("%s:%d",
2004 CURRENT_EXCEPTION_CATCH_FILE,
2005 CURRENT_EXCEPTION_CATCH_LINE);
2007 printf_filtered ("unknown");
2009 printf_filtered ("\n");
2010 /* don't bother to print location frame info */
2011 return PRINT_SRC_ONLY;
2015 /* really catch, some other bpstat will handle it */
2016 return PRINT_UNKNOWN;
2021 case bp_hardware_watchpoint:
2022 if (bs->old_val != NULL)
2024 annotate_watchpoint (bs->breakpoint_at->number);
2025 mention (bs->breakpoint_at);
2026 printf_filtered ("\nOld value = ");
2027 value_print (bs->old_val, gdb_stdout, 0, Val_pretty_default);
2028 printf_filtered ("\nNew value = ");
2029 value_print (bs->breakpoint_at->val, gdb_stdout, 0,
2030 Val_pretty_default);
2031 printf_filtered ("\n");
2032 value_free (bs->old_val);
2035 /* More than one watchpoint may have been triggered. */
2036 return PRINT_UNKNOWN;
2039 case bp_read_watchpoint:
2040 mention (bs->breakpoint_at);
2041 printf_filtered ("\nValue = ");
2042 value_print (bs->breakpoint_at->val, gdb_stdout, 0,
2043 Val_pretty_default);
2044 printf_filtered ("\n");
2045 return PRINT_UNKNOWN;
2048 case bp_access_watchpoint:
2049 if (bs->old_val != NULL)
2051 annotate_watchpoint (bs->breakpoint_at->number);
2052 mention (bs->breakpoint_at);
2053 printf_filtered ("\nOld value = ");
2054 value_print (bs->old_val, gdb_stdout, 0, Val_pretty_default);
2055 value_free (bs->old_val);
2057 printf_filtered ("\nNew value = ");
2061 mention (bs->breakpoint_at);
2062 printf_filtered ("\nValue = ");
2064 value_print (bs->breakpoint_at->val, gdb_stdout, 0,
2065 Val_pretty_default);
2066 printf_filtered ("\n");
2067 return PRINT_UNKNOWN;
2070 /* Fall through, we don't deal with these types of breakpoints
2077 case bp_longjmp_resume:
2078 case bp_step_resume:
2079 case bp_through_sigtramp:
2080 case bp_watchpoint_scope:
2083 return PRINT_UNKNOWN;
2087 /* Generic routine for printing messages indicating why we
2088 stopped. The behavior of this function depends on the value
2089 'print_it' in the bpstat structure. Under some circumstances we
2090 may decide not to print anything here and delegate the task to
2093 static enum print_stop_action
2094 print_bp_stop_message (bpstat bs)
2096 switch (bs->print_it)
2099 /* Nothing should be printed for this bpstat entry. */
2100 return PRINT_UNKNOWN;
2104 /* We still want to print the frame, but we already printed the
2105 relevant messages. */
2106 return PRINT_SRC_AND_LOC;
2109 case print_it_normal:
2110 /* Normal case, we handle everything in print_it_typical. */
2111 return print_it_typical (bs);
2114 internal_error ("print_bp_stop_message: unrecognized enum value");
2119 /* Print a message indicating what happened. This is called from
2120 normal_stop(). The input to this routine is the head of the bpstat
2121 list - a list of the eventpoints that caused this stop. This
2122 routine calls the generic print routine for printing a message
2123 about reasons for stopping. This will print (for example) the
2124 "Breakpoint n," part of the output. The return value of this
2127 PRINT_UNKNOWN: Means we printed nothing
2128 PRINT_SRC_AND_LOC: Means we printed something, and expect subsequent
2129 code to print the location. An example is
2130 "Breakpoint 1, " which should be followed by
2132 PRINT_SRC_ONLY: Means we printed something, but there is no need
2133 to also print the location part of the message.
2134 An example is the catch/throw messages, which
2135 don't require a location appended to the end.
2136 PRINT_NOTHING: We have done some printing and we don't need any
2137 further info to be printed.*/
2139 enum print_stop_action
2145 /* Maybe another breakpoint in the chain caused us to stop.
2146 (Currently all watchpoints go on the bpstat whether hit or not.
2147 That probably could (should) be changed, provided care is taken
2148 with respect to bpstat_explains_signal). */
2149 for (; bs; bs = bs->next)
2151 val = print_bp_stop_message (bs);
2152 if (val == PRINT_SRC_ONLY
2153 || val == PRINT_SRC_AND_LOC
2154 || val == PRINT_NOTHING)
2158 /* We reached the end of the chain, or we got a null BS to start
2159 with and nothing was printed. */
2160 return PRINT_UNKNOWN;
2163 /* Evaluate the expression EXP and return 1 if value is zero.
2164 This is used inside a catch_errors to evaluate the breakpoint condition.
2165 The argument is a "struct expression *" that has been cast to char * to
2166 make it pass through catch_errors. */
2169 breakpoint_cond_eval (exp)
2172 value_ptr mark = value_mark ();
2173 int i = !value_true (evaluate_expression ((struct expression *) exp));
2174 value_free_to_mark (mark);
2178 /* Allocate a new bpstat and chain it to the current one. */
2181 bpstat_alloc (b, cbs)
2182 register struct breakpoint *b;
2183 bpstat cbs; /* Current "bs" value */
2187 bs = (bpstat) xmalloc (sizeof (*bs));
2189 bs->breakpoint_at = b;
2190 /* If the condition is false, etc., don't do the commands. */
2191 bs->commands = NULL;
2193 bs->print_it = print_it_normal;
2197 /* Possible return values for watchpoint_check (this can't be an enum
2198 because of check_errors). */
2199 /* The watchpoint has been deleted. */
2200 #define WP_DELETED 1
2201 /* The value has changed. */
2202 #define WP_VALUE_CHANGED 2
2203 /* The value has not changed. */
2204 #define WP_VALUE_NOT_CHANGED 3
2206 #define BP_TEMPFLAG 1
2207 #define BP_HARDWAREFLAG 2
2209 /* Check watchpoint condition. */
2212 watchpoint_check (p)
2215 bpstat bs = (bpstat) p;
2216 struct breakpoint *b;
2217 struct frame_info *fr;
2218 int within_current_scope;
2220 b = bs->breakpoint_at;
2222 if (b->exp_valid_block == NULL)
2223 within_current_scope = 1;
2226 /* There is no current frame at this moment. If we're going to have
2227 any chance of handling watchpoints on local variables, we'll need
2228 the frame chain (so we can determine if we're in scope). */
2229 reinit_frame_cache ();
2230 fr = find_frame_addr_in_frame_chain (b->watchpoint_frame);
2231 within_current_scope = (fr != NULL);
2232 if (within_current_scope)
2233 /* If we end up stopping, the current frame will get selected
2234 in normal_stop. So this call to select_frame won't affect
2236 select_frame (fr, -1);
2239 if (within_current_scope)
2241 /* We use value_{,free_to_}mark because it could be a
2242 *long* time before we return to the command level and
2243 call free_all_values. We can't call free_all_values because
2244 we might be in the middle of evaluating a function call. */
2246 value_ptr mark = value_mark ();
2247 value_ptr new_val = evaluate_expression (bs->breakpoint_at->exp);
2248 if (!value_equal (b->val, new_val))
2250 release_value (new_val);
2251 value_free_to_mark (mark);
2252 bs->old_val = b->val;
2254 /* We will stop here */
2255 return WP_VALUE_CHANGED;
2259 /* Nothing changed, don't do anything. */
2260 value_free_to_mark (mark);
2261 /* We won't stop here */
2262 return WP_VALUE_NOT_CHANGED;
2267 /* This seems like the only logical thing to do because
2268 if we temporarily ignored the watchpoint, then when
2269 we reenter the block in which it is valid it contains
2270 garbage (in the case of a function, it may have two
2271 garbage values, one before and one after the prologue).
2272 So we can't even detect the first assignment to it and
2273 watch after that (since the garbage may or may not equal
2274 the first value assigned). */
2275 /* We print all the stop information in print_it_typical(), but
2276 in this case, by the time we call print_it_typical() this bp
2277 will be deleted already. So we have no choice but print the
2278 information here. */
2280 Watchpoint %d deleted because the program has left the block in\n\
2281 which its expression is valid.\n", bs->breakpoint_at->number);
2283 if (b->related_breakpoint)
2284 b->related_breakpoint->disposition = del_at_next_stop;
2285 b->disposition = del_at_next_stop;
2291 /* Get a bpstat associated with having just stopped at address *PC
2292 and frame address CORE_ADDRESS. Update *PC to point at the
2293 breakpoint (if we hit a breakpoint). NOT_A_BREAKPOINT is nonzero
2294 if this is known to not be a real breakpoint (it could still be a
2295 watchpoint, though). */
2297 /* Determine whether we stopped at a breakpoint, etc, or whether we
2298 don't understand this stop. Result is a chain of bpstat's such that:
2300 if we don't understand the stop, the result is a null pointer.
2302 if we understand why we stopped, the result is not null.
2304 Each element of the chain refers to a particular breakpoint or
2305 watchpoint at which we have stopped. (We may have stopped for
2306 several reasons concurrently.)
2308 Each element of the chain has valid next, breakpoint_at,
2309 commands, FIXME??? fields. */
2312 bpstat_stop_status (pc, not_a_breakpoint)
2314 int not_a_breakpoint;
2316 register struct breakpoint *b, *temp;
2318 /* True if we've hit a breakpoint (as opposed to a watchpoint). */
2319 int real_breakpoint = 0;
2320 /* Root of the chain of bpstat's */
2321 struct bpstats root_bs[1];
2322 /* Pointer to the last thing in the chain currently. */
2323 bpstat bs = root_bs;
2324 static char message1[] =
2325 "Error evaluating expression for watchpoint %d\n";
2326 char message[sizeof (message1) + 30 /* slop */ ];
2328 /* Get the address where the breakpoint would have been. */
2329 bp_addr = *pc - (not_a_breakpoint && !SOFTWARE_SINGLE_STEP_P ?
2330 0 : DECR_PC_AFTER_BREAK);
2332 ALL_BREAKPOINTS_SAFE (b, temp)
2334 if (b->enable == disabled
2335 || b->enable == shlib_disabled
2336 || b->enable == call_disabled)
2339 if (b->type != bp_watchpoint
2340 && b->type != bp_hardware_watchpoint
2341 && b->type != bp_read_watchpoint
2342 && b->type != bp_access_watchpoint
2343 && b->type != bp_hardware_breakpoint
2344 && b->type != bp_catch_fork
2345 && b->type != bp_catch_vfork
2346 && b->type != bp_catch_exec
2347 && b->type != bp_catch_catch
2348 && b->type != bp_catch_throw) /* a non-watchpoint bp */
2349 if (b->address != bp_addr || /* address doesn't match or */
2350 (overlay_debugging && /* overlay doesn't match */
2351 section_is_overlay (b->section) &&
2352 !section_is_mapped (b->section)))
2355 if (b->type == bp_hardware_breakpoint
2356 && b->address != (*pc - DECR_PC_AFTER_HW_BREAK))
2359 /* Is this a catchpoint of a load or unload? If so, did we
2360 get a load or unload of the specified library? If not,
2362 if ((b->type == bp_catch_load)
2363 #if defined(SOLIB_HAVE_LOAD_EVENT)
2364 && (!SOLIB_HAVE_LOAD_EVENT (inferior_pid)
2365 || ((b->dll_pathname != NULL)
2366 && (strcmp (b->dll_pathname,
2367 SOLIB_LOADED_LIBRARY_PATHNAME (inferior_pid))
2373 if ((b->type == bp_catch_unload)
2374 #if defined(SOLIB_HAVE_UNLOAD_EVENT)
2375 && (!SOLIB_HAVE_UNLOAD_EVENT (inferior_pid)
2376 || ((b->dll_pathname != NULL)
2377 && (strcmp (b->dll_pathname,
2378 SOLIB_UNLOADED_LIBRARY_PATHNAME (inferior_pid))
2384 if ((b->type == bp_catch_fork)
2385 && !target_has_forked (inferior_pid, &b->forked_inferior_pid))
2388 if ((b->type == bp_catch_vfork)
2389 && !target_has_vforked (inferior_pid, &b->forked_inferior_pid))
2392 if ((b->type == bp_catch_exec)
2393 && !target_has_execd (inferior_pid, &b->exec_pathname))
2396 if (ep_is_exception_catchpoint (b) &&
2397 !(current_exception_event = target_get_current_exception_event ()))
2400 /* Come here if it's a watchpoint, or if the break address matches */
2402 bs = bpstat_alloc (b, bs); /* Alloc a bpstat to explain stop */
2404 /* Watchpoints may change this, if not found to have triggered. */
2408 sprintf (message, message1, b->number);
2409 if (b->type == bp_watchpoint ||
2410 b->type == bp_hardware_watchpoint)
2412 switch (catch_errors (watchpoint_check, bs, message,
2416 /* We've already printed what needs to be printed. */
2417 /* Actually this is superfluous, because by the time we
2418 call print_it_typical() the wp will be already deleted,
2419 and the function will return immediately. */
2420 bs->print_it = print_it_done;
2423 case WP_VALUE_CHANGED:
2427 case WP_VALUE_NOT_CHANGED:
2429 bs->print_it = print_it_noop;
2436 /* Error from catch_errors. */
2437 printf_filtered ("Watchpoint %d deleted.\n", b->number);
2438 if (b->related_breakpoint)
2439 b->related_breakpoint->disposition = del_at_next_stop;
2440 b->disposition = del_at_next_stop;
2441 /* We've already printed what needs to be printed. */
2442 bs->print_it = print_it_done;
2448 else if (b->type == bp_read_watchpoint ||
2449 b->type == bp_access_watchpoint)
2455 addr = target_stopped_data_address ();
2458 for (v = b->val_chain; v; v = v->next)
2460 if (VALUE_LVAL (v) == lval_memory
2461 && ! VALUE_LAZY (v))
2465 vaddr = VALUE_ADDRESS (v) + VALUE_OFFSET (v);
2466 /* Exact match not required. Within range is sufficient.
2468 if (addr >= vaddr &&
2469 addr < vaddr + TYPE_LENGTH (VALUE_TYPE (v)))
2474 switch (catch_errors (watchpoint_check, bs, message,
2478 /* We've already printed what needs to be printed. */
2479 bs->print_it = print_it_done;
2482 case WP_VALUE_CHANGED:
2483 case WP_VALUE_NOT_CHANGED:
2490 /* Error from catch_errors. */
2491 printf_filtered ("Watchpoint %d deleted.\n", b->number);
2492 if (b->related_breakpoint)
2493 b->related_breakpoint->disposition = del_at_next_stop;
2494 b->disposition = del_at_next_stop;
2495 /* We've already printed what needs to be printed. */
2496 bs->print_it = print_it_done;
2499 else /* found == 0 */
2501 /* This is a case where some watchpoint(s) triggered,
2502 but not at the address of this watchpoint (FOUND
2503 was left zero). So don't print anything for this
2505 bs->print_it = print_it_noop;
2512 /* By definition, an encountered breakpoint is a triggered
2516 real_breakpoint = 1;
2519 if (b->frame && b->frame != (get_current_frame ())->frame &&
2520 (b->type == bp_step_resume &&
2521 (INNER_THAN (get_current_frame ()->frame, b->frame))))
2525 int value_is_zero = 0;
2529 /* Need to select the frame, with all that implies
2530 so that the conditions will have the right context. */
2531 select_frame (get_current_frame (), 0);
2533 = catch_errors (breakpoint_cond_eval, (b->cond),
2534 "Error in testing breakpoint condition:\n",
2536 /* FIXME-someday, should give breakpoint # */
2539 if (b->cond && value_is_zero)
2542 /* Don't consider this a hit. */
2545 else if (b->ignore_count > 0)
2548 annotate_ignore_count_change ();
2553 /* We will stop here */
2554 if (b->disposition == disable)
2555 b->enable = disabled;
2556 bs->commands = b->commands;
2560 (STREQ ("silent", bs->commands->line) ||
2561 (xdb_commands && STREQ ("Q", bs->commands->line))))
2563 bs->commands = bs->commands->next;
2568 /* Print nothing for this entry if we dont stop or if we dont print. */
2569 if (bs->stop == 0 || bs->print == 0)
2570 bs->print_it = print_it_noop;
2573 bs->next = NULL; /* Terminate the chain */
2574 bs = root_bs->next; /* Re-grab the head of the chain */
2576 if (real_breakpoint && bs)
2578 if (bs->breakpoint_at->type == bp_hardware_breakpoint)
2580 if (DECR_PC_AFTER_HW_BREAK != 0)
2582 *pc = *pc - DECR_PC_AFTER_HW_BREAK;
2588 if (DECR_PC_AFTER_BREAK != 0 || must_shift_inst_regs)
2591 #if defined (SHIFT_INST_REGS)
2593 #else /* No SHIFT_INST_REGS. */
2595 #endif /* No SHIFT_INST_REGS. */
2600 /* The value of a hardware watchpoint hasn't changed, but the
2601 intermediate memory locations we are watching may have. */
2602 if (bs && !bs->stop &&
2603 (bs->breakpoint_at->type == bp_hardware_watchpoint ||
2604 bs->breakpoint_at->type == bp_read_watchpoint ||
2605 bs->breakpoint_at->type == bp_access_watchpoint))
2607 remove_breakpoints ();
2608 insert_breakpoints ();
2613 /* Tell what to do about this bpstat. */
2618 /* Classify each bpstat as one of the following. */
2621 /* This bpstat element has no effect on the main_action. */
2624 /* There was a watchpoint, stop but don't print. */
2627 /* There was a watchpoint, stop and print. */
2630 /* There was a breakpoint but we're not stopping. */
2633 /* There was a breakpoint, stop but don't print. */
2636 /* There was a breakpoint, stop and print. */
2639 /* We hit the longjmp breakpoint. */
2642 /* We hit the longjmp_resume breakpoint. */
2645 /* We hit the step_resume breakpoint. */
2648 /* We hit the through_sigtramp breakpoint. */
2651 /* We hit the shared library event breakpoint. */
2654 /* We caught a shared library event. */
2657 /* This is just used to count how many enums there are. */
2661 /* Here is the table which drives this routine. So that we can
2662 format it pretty, we define some abbreviations for the
2663 enum bpstat_what codes. */
2664 #define kc BPSTAT_WHAT_KEEP_CHECKING
2665 #define ss BPSTAT_WHAT_STOP_SILENT
2666 #define sn BPSTAT_WHAT_STOP_NOISY
2667 #define sgl BPSTAT_WHAT_SINGLE
2668 #define slr BPSTAT_WHAT_SET_LONGJMP_RESUME
2669 #define clr BPSTAT_WHAT_CLEAR_LONGJMP_RESUME
2670 #define clrs BPSTAT_WHAT_CLEAR_LONGJMP_RESUME_SINGLE
2671 #define sr BPSTAT_WHAT_STEP_RESUME
2672 #define ts BPSTAT_WHAT_THROUGH_SIGTRAMP
2673 #define shl BPSTAT_WHAT_CHECK_SHLIBS
2674 #define shlr BPSTAT_WHAT_CHECK_SHLIBS_RESUME_FROM_HOOK
2676 /* "Can't happen." Might want to print an error message.
2677 abort() is not out of the question, but chances are GDB is just
2678 a bit confused, not unusable. */
2679 #define err BPSTAT_WHAT_STOP_NOISY
2681 /* Given an old action and a class, come up with a new action. */
2682 /* One interesting property of this table is that wp_silent is the same
2683 as bp_silent and wp_noisy is the same as bp_noisy. That is because
2684 after stopping, the check for whether to step over a breakpoint
2685 (BPSTAT_WHAT_SINGLE type stuff) is handled in proceed() without
2686 reference to how we stopped. We retain separate wp_silent and
2687 bp_silent codes in case we want to change that someday.
2689 Another possibly interesting property of this table is that
2690 there's a partial ordering, priority-like, of the actions. Once
2691 you've decided that some action is appropriate, you'll never go
2692 back and decide something of a lower priority is better. The
2695 kc < clr sgl shl slr sn sr ss ts
2696 sgl < clrs shl shlr slr sn sr ss ts
2697 slr < err shl shlr sn sr ss ts
2698 clr < clrs err shl shlr sn sr ss ts
2699 clrs < err shl shlr sn sr ss ts
2700 ss < shl shlr sn sr ts
2707 What I think this means is that we don't need a damned table
2708 here. If you just put the rows and columns in the right order,
2709 it'd look awfully regular. We could simply walk the bpstat list
2710 and choose the highest priority action we find, with a little
2711 logic to handle the 'err' cases, and the CLEAR_LONGJMP_RESUME/
2712 CLEAR_LONGJMP_RESUME_SINGLE distinction (which breakpoint.h says
2713 is messy anyway). */
2715 /* step_resume entries: a step resume breakpoint overrides another
2716 breakpoint of signal handling (see comment in wait_for_inferior
2717 at first IN_SIGTRAMP where we set the step_resume breakpoint). */
2718 /* We handle the through_sigtramp_breakpoint the same way; having both
2719 one of those and a step_resume_breakpoint is probably very rare (?). */
2721 static const enum bpstat_what_main_action
2722 table[(int) class_last][(int) BPSTAT_WHAT_LAST] =
2725 /* kc ss sn sgl slr clr clrs sr ts shl shlr
2728 {kc, ss, sn, sgl, slr, clr, clrs, sr, ts, shl, shlr},
2730 {ss, ss, sn, ss, ss, ss, ss, sr, ts, shl, shlr},
2732 {sn, sn, sn, sn, sn, sn, sn, sr, ts, shl, shlr},
2734 {sgl, ss, sn, sgl, slr, clrs, clrs, sr, ts, shl, shlr},
2736 {ss, ss, sn, ss, ss, ss, ss, sr, ts, shl, shlr},
2738 {sn, sn, sn, sn, sn, sn, sn, sr, ts, shl, shlr},
2740 {slr, ss, sn, slr, err, err, err, sr, ts, shl, shlr},
2742 {clr, ss, sn, clrs, err, err, err, sr, ts, shl, shlr},
2744 {sr, sr, sr, sr, sr, sr, sr, sr, ts, shl, shlr},
2746 {ts, ts, ts, ts, ts, ts, ts, ts, ts, shl, shlr},
2748 {shl, shl, shl, shl, shl, shl, shl, shl, ts, shl, shlr},
2750 {shlr, shlr, shlr, shlr, shlr, shlr, shlr, shlr, ts, shlr, shlr}
2765 enum bpstat_what_main_action current_action = BPSTAT_WHAT_KEEP_CHECKING;
2766 struct bpstat_what retval;
2768 retval.call_dummy = 0;
2769 for (; bs != NULL; bs = bs->next)
2771 enum class bs_class = no_effect;
2772 if (bs->breakpoint_at == NULL)
2773 /* I suspect this can happen if it was a momentary breakpoint
2774 which has since been deleted. */
2776 switch (bs->breakpoint_at->type)
2782 case bp_hardware_breakpoint:
2788 bs_class = bp_noisy;
2790 bs_class = bp_silent;
2793 bs_class = bp_nostop;
2796 case bp_hardware_watchpoint:
2797 case bp_read_watchpoint:
2798 case bp_access_watchpoint:
2802 bs_class = wp_noisy;
2804 bs_class = wp_silent;
2807 /* There was a watchpoint, but we're not stopping.
2808 This requires no further action. */
2809 bs_class = no_effect;
2812 bs_class = long_jump;
2814 case bp_longjmp_resume:
2815 bs_class = long_resume;
2817 case bp_step_resume:
2820 bs_class = step_resume;
2823 /* It is for the wrong frame. */
2824 bs_class = bp_nostop;
2826 case bp_through_sigtramp:
2827 bs_class = through_sig;
2829 case bp_watchpoint_scope:
2830 bs_class = bp_nostop;
2832 case bp_shlib_event:
2833 bs_class = shlib_event;
2836 case bp_catch_unload:
2837 /* Only if this catchpoint triggered should we cause the
2838 step-out-of-dld behaviour. Otherwise, we ignore this
2841 bs_class = catch_shlib_event;
2843 bs_class = no_effect;
2846 case bp_catch_vfork:
2851 bs_class = bp_noisy;
2853 bs_class = bp_silent;
2856 /* There was a catchpoint, but we're not stopping.
2857 This requires no further action. */
2858 bs_class = no_effect;
2860 case bp_catch_catch:
2861 if (!bs->stop || CURRENT_EXCEPTION_KIND != EX_EVENT_CATCH)
2862 bs_class = bp_nostop;
2864 bs_class = bs->print ? bp_noisy : bp_silent;
2866 case bp_catch_throw:
2867 if (!bs->stop || CURRENT_EXCEPTION_KIND != EX_EVENT_THROW)
2868 bs_class = bp_nostop;
2870 bs_class = bs->print ? bp_noisy : bp_silent;
2873 /* Make sure the action is stop (silent or noisy),
2874 so infrun.c pops the dummy frame. */
2875 bs_class = bp_silent;
2876 retval.call_dummy = 1;
2879 current_action = table[(int) bs_class][(int) current_action];
2881 retval.main_action = current_action;
2885 /* Nonzero if we should step constantly (e.g. watchpoints on machines
2886 without hardware support). This isn't related to a specific bpstat,
2887 just to things like whether watchpoints are set. */
2890 bpstat_should_step ()
2892 struct breakpoint *b;
2894 if (b->enable == enabled && b->type == bp_watchpoint)
2899 /* Nonzero if there are enabled hardware watchpoints. */
2901 bpstat_have_active_hw_watchpoints ()
2903 struct breakpoint *b;
2905 if ((b->enable == enabled) &&
2907 ((b->type == bp_hardware_watchpoint) ||
2908 (b->type == bp_read_watchpoint) ||
2909 (b->type == bp_access_watchpoint)))
2915 /* Given a bpstat that records zero or more triggered eventpoints, this
2916 function returns another bpstat which contains only the catchpoints
2917 on that first list, if any. */
2919 bpstat_get_triggered_catchpoints (ep_list, cp_list)
2923 struct bpstats root_bs[1];
2924 bpstat bs = root_bs;
2925 struct breakpoint *ep;
2928 bpstat_clear (cp_list);
2929 root_bs->next = NULL;
2931 for (; ep_list != NULL; ep_list = ep_list->next)
2933 /* Is this eventpoint a catchpoint? If not, ignore it. */
2934 ep = ep_list->breakpoint_at;
2937 if ((ep->type != bp_catch_load) &&
2938 (ep->type != bp_catch_unload) &&
2939 (ep->type != bp_catch_catch) &&
2940 (ep->type != bp_catch_throw))
2941 /* pai: (temp) ADD fork/vfork here!! */
2944 /* Yes; add it to the list. */
2945 bs = bpstat_alloc (ep, bs);
2950 #if defined(SOLIB_ADD)
2951 /* Also, for each triggered catchpoint, tag it with the name of
2952 the library that caused this trigger. (We copy the name now,
2953 because it's only guaranteed to be available NOW, when the
2954 catchpoint triggers. Clients who may wish to know the name
2955 later must get it from the catchpoint itself.) */
2956 if (ep->triggered_dll_pathname != NULL)
2957 free (ep->triggered_dll_pathname);
2958 if (ep->type == bp_catch_load)
2959 dll_pathname = SOLIB_LOADED_LIBRARY_PATHNAME (inferior_pid);
2961 dll_pathname = SOLIB_UNLOADED_LIBRARY_PATHNAME (inferior_pid);
2963 dll_pathname = NULL;
2967 ep->triggered_dll_pathname = (char *)
2968 xmalloc (strlen (dll_pathname) + 1);
2969 strcpy (ep->triggered_dll_pathname, dll_pathname);
2972 ep->triggered_dll_pathname = NULL;
2978 /* Print information on breakpoint number BNUM, or -1 if all.
2979 If WATCHPOINTS is zero, process only breakpoints; if WATCHPOINTS
2980 is nonzero, process only watchpoints. */
2987 ep_type_description_t;
2990 breakpoint_1 (bnum, allflag)
2994 register struct breakpoint *b;
2995 register struct command_line *l;
2996 register struct symbol *sym;
2997 CORE_ADDR last_addr = (CORE_ADDR) -1;
2998 int found_a_breakpoint = 0;
2999 static ep_type_description_t bptypes[] =
3001 {bp_none, "?deleted?"},
3002 {bp_breakpoint, "breakpoint"},
3003 {bp_hardware_breakpoint, "hw breakpoint"},
3004 {bp_until, "until"},
3005 {bp_finish, "finish"},
3006 {bp_watchpoint, "watchpoint"},
3007 {bp_hardware_watchpoint, "hw watchpoint"},
3008 {bp_read_watchpoint, "read watchpoint"},
3009 {bp_access_watchpoint, "acc watchpoint"},
3010 {bp_longjmp, "longjmp"},
3011 {bp_longjmp_resume, "longjmp resume"},
3012 {bp_step_resume, "step resume"},
3013 {bp_through_sigtramp, "sigtramp"},
3014 {bp_watchpoint_scope, "watchpoint scope"},
3015 {bp_call_dummy, "call dummy"},
3016 {bp_shlib_event, "shlib events"},
3017 {bp_catch_load, "catch load"},
3018 {bp_catch_unload, "catch unload"},
3019 {bp_catch_fork, "catch fork"},
3020 {bp_catch_vfork, "catch vfork"},
3021 {bp_catch_exec, "catch exec"},
3022 {bp_catch_catch, "catch catch"},
3023 {bp_catch_throw, "catch throw"}
3026 static char *bpdisps[] =
3027 {"del", "dstp", "dis", "keep"};
3028 static char bpenables[] = "nynny";
3029 char wrap_indent[80];
3035 || bnum == b->number)
3037 /* We only print out user settable breakpoints unless the allflag is set. */
3039 && b->type != bp_breakpoint
3040 && b->type != bp_catch_load
3041 && b->type != bp_catch_unload
3042 && b->type != bp_catch_fork
3043 && b->type != bp_catch_vfork
3044 && b->type != bp_catch_exec
3045 && b->type != bp_catch_catch
3046 && b->type != bp_catch_throw
3047 && b->type != bp_hardware_breakpoint
3048 && b->type != bp_watchpoint
3049 && b->type != bp_read_watchpoint
3050 && b->type != bp_access_watchpoint
3051 && b->type != bp_hardware_watchpoint)
3054 if (!found_a_breakpoint++)
3056 annotate_breakpoints_headers ();
3059 printf_filtered ("Num ");
3061 printf_filtered ("Type ");
3063 printf_filtered ("Disp ");
3065 printf_filtered ("Enb ");
3069 printf_filtered ("Address ");
3072 printf_filtered ("What\n");
3074 annotate_breakpoints_table ();
3079 printf_filtered ("%-3d ", b->number);
3081 if ((int) b->type > (sizeof (bptypes) / sizeof (bptypes[0])))
3082 error ("bptypes table does not describe type #%d.", (int) b->type);
3083 if ((int) b->type != bptypes[(int) b->type].type)
3084 error ("bptypes table does not describe type #%d?", (int) b->type);
3085 printf_filtered ("%-14s ", bptypes[(int) b->type].description);
3087 printf_filtered ("%-4s ", bpdisps[(int) b->disposition]);
3089 printf_filtered ("%-3c ", bpenables[(int) b->enable]);
3091 strcpy (wrap_indent, " ");
3093 strcat (wrap_indent, " ");
3097 case bp_hardware_watchpoint:
3098 case bp_read_watchpoint:
3099 case bp_access_watchpoint:
3100 /* Field 4, the address, is omitted (which makes the columns
3101 not line up too nicely with the headers, but the effect
3102 is relatively readable). */
3104 print_expression (b->exp, gdb_stdout);
3108 case bp_catch_unload:
3109 /* Field 4, the address, is omitted (which makes the columns
3110 not line up too nicely with the headers, but the effect
3111 is relatively readable). */
3113 if (b->dll_pathname == NULL)
3114 printf_filtered ("<any library> ");
3116 printf_filtered ("library \"%s\" ", b->dll_pathname);
3120 case bp_catch_vfork:
3121 /* Field 4, the address, is omitted (which makes the columns
3122 not line up too nicely with the headers, but the effect
3123 is relatively readable). */
3125 if (b->forked_inferior_pid != 0)
3126 printf_filtered ("process %d ", b->forked_inferior_pid);
3130 /* Field 4, the address, is omitted (which makes the columns
3131 not line up too nicely with the headers, but the effect
3132 is relatively readable). */
3134 if (b->exec_pathname != NULL)
3135 printf_filtered ("program \"%s\" ", b->exec_pathname);
3137 case bp_catch_catch:
3138 /* Field 4, the address, is omitted (which makes the columns
3139 not line up too nicely with the headers, but the effect
3140 is relatively readable). */
3142 printf_filtered ("exception catch ");
3144 case bp_catch_throw:
3145 /* Field 4, the address, is omitted (which makes the columns
3146 not line up too nicely with the headers, but the effect
3147 is relatively readable). */
3149 printf_filtered ("exception throw ");
3153 case bp_hardware_breakpoint:
3157 case bp_longjmp_resume:
3158 case bp_step_resume:
3159 case bp_through_sigtramp:
3160 case bp_watchpoint_scope:
3162 case bp_shlib_event:
3166 /* FIXME-32x64: need a print_address_numeric with
3170 local_hex_string_custom
3171 ((unsigned long) b->address, "08l"));
3176 last_addr = b->address;
3179 sym = find_pc_sect_function (b->address, b->section);
3182 fputs_filtered ("in ", gdb_stdout);
3183 fputs_filtered (SYMBOL_SOURCE_NAME (sym), gdb_stdout);
3184 wrap_here (wrap_indent);
3185 fputs_filtered (" at ", gdb_stdout);
3187 fputs_filtered (b->source_file, gdb_stdout);
3188 printf_filtered (":%d", b->line_number);
3191 print_address_symbolic (b->address, gdb_stdout, demangle, " ");
3195 if (b->thread != -1)
3196 printf_filtered (" thread %d", b->thread);
3198 printf_filtered ("\n");
3204 printf_filtered ("\tstop only in stack frame at ");
3205 print_address_numeric (b->frame, 1, gdb_stdout);
3206 printf_filtered ("\n");
3213 printf_filtered ("\tstop only if ");
3214 print_expression (b->cond, gdb_stdout);
3215 printf_filtered ("\n");
3218 if (b->thread != -1)
3220 /* FIXME should make an annotation for this */
3221 printf_filtered ("\tstop only in thread %d\n", b->thread);
3224 if (show_breakpoint_hit_counts && b->hit_count)
3226 /* FIXME should make an annotation for this */
3227 if (ep_is_catchpoint (b))
3228 printf_filtered ("\tcatchpoint");
3230 printf_filtered ("\tbreakpoint");
3231 printf_filtered (" already hit %d time%s\n",
3232 b->hit_count, (b->hit_count == 1 ? "" : "s"));
3235 if (b->ignore_count)
3239 printf_filtered ("\tignore next %d hits\n", b->ignore_count);
3242 if ((l = b->commands))
3248 print_command_line (l, 4, gdb_stdout);
3254 if (!found_a_breakpoint)
3257 printf_filtered ("No breakpoints or watchpoints.\n");
3259 printf_filtered ("No breakpoint or watchpoint number %d.\n", bnum);
3262 /* Compare against (CORE_ADDR)-1 in case some compiler decides
3263 that a comparison of an unsigned with -1 is always false. */
3264 if (last_addr != (CORE_ADDR) -1)
3265 set_next_address (last_addr);
3267 annotate_breakpoints_table_end ();
3272 breakpoints_info (bnum_exp, from_tty)
3279 bnum = parse_and_eval_address (bnum_exp);
3281 breakpoint_1 (bnum, 0);
3286 maintenance_info_breakpoints (bnum_exp, from_tty)
3293 bnum = parse_and_eval_address (bnum_exp);
3295 breakpoint_1 (bnum, 1);
3298 /* Print a message describing any breakpoints set at PC. */
3301 describe_other_breakpoints (pc, section)
3305 register int others = 0;
3306 register struct breakpoint *b;
3309 if (b->address == pc)
3310 if (overlay_debugging == 0 ||
3311 b->section == section)
3315 printf_filtered ("Note: breakpoint%s ", (others > 1) ? "s" : "");
3317 if (b->address == pc)
3318 if (overlay_debugging == 0 ||
3319 b->section == section)
3325 ((b->enable == disabled ||
3326 b->enable == shlib_disabled ||
3327 b->enable == call_disabled) ? " (disabled)"
3328 : b->enable == permanent ? " (permanent)"
3330 (others > 1) ? "," : ((others == 1) ? " and" : ""));
3332 printf_filtered ("also set at pc ");
3333 print_address_numeric (pc, 1, gdb_stdout);
3334 printf_filtered (".\n");
3338 /* Set the default place to put a breakpoint
3339 for the `break' command with no arguments. */
3342 set_default_breakpoint (valid, addr, symtab, line)
3345 struct symtab *symtab;
3348 default_breakpoint_valid = valid;
3349 default_breakpoint_address = addr;
3350 default_breakpoint_symtab = symtab;
3351 default_breakpoint_line = line;
3354 /* Rescan breakpoints at address ADDRESS,
3355 marking the first one as "first" and any others as "duplicates".
3356 This is so that the bpt instruction is only inserted once.
3357 If we have a permanent breakpoint at ADDRESS, make that one
3358 the official one, and the rest as duplicates. */
3361 check_duplicates (address, section)
3365 register struct breakpoint *b;
3366 register int count = 0;
3367 struct breakpoint *perm_bp = 0;
3369 if (address == 0) /* Watchpoints are uninteresting */
3373 if (b->enable != disabled
3374 && b->enable != shlib_disabled
3375 && b->enable != call_disabled
3376 && b->address == address
3377 && (overlay_debugging == 0 || b->section == section))
3379 /* Have we found a permanent breakpoint? */
3380 if (b->enable == permanent)
3387 b->duplicate = count > 1;
3390 /* If we found a permanent breakpoint at this address, go over the
3391 list again and declare all the other breakpoints there to be the
3395 perm_bp->duplicate = 0;
3397 /* Permanent breakpoint should always be inserted. */
3398 if (! perm_bp->inserted)
3399 internal_error ("allegedly permanent breakpoint is not "
3400 "actually inserted");
3406 internal_error ("another breakpoint was inserted on top of "
3407 "a permanent breakpoint");
3409 if (b->enable != disabled
3410 && b->enable != shlib_disabled
3411 && b->enable != call_disabled
3412 && b->address == address
3413 && (overlay_debugging == 0 || b->section == section))
3419 /* Low level routine to set a breakpoint.
3420 Takes as args the three things that every breakpoint must have.
3421 Returns the breakpoint object so caller can set other things.
3422 Does not set the breakpoint number!
3423 Does not print anything.
3425 ==> This routine should not be called if there is a chance of later
3426 error(); otherwise it leaves a bogus breakpoint on the chain. Validate
3427 your arguments BEFORE calling this routine! */
3430 set_raw_breakpoint (sal)
3431 struct symtab_and_line sal;
3433 register struct breakpoint *b, *b1;
3435 b = (struct breakpoint *) xmalloc (sizeof (struct breakpoint));
3436 memset (b, 0, sizeof (*b));
3437 b->address = sal.pc;
3438 if (sal.symtab == NULL)
3439 b->source_file = NULL;
3441 b->source_file = savestring (sal.symtab->filename,
3442 strlen (sal.symtab->filename));
3443 b->section = sal.section;
3444 b->language = current_language->la_language;
3445 b->input_radix = input_radix;
3447 b->line_number = sal.line;
3448 b->enable = enabled;
3451 b->ignore_count = 0;
3454 b->dll_pathname = NULL;
3455 b->triggered_dll_pathname = NULL;
3456 b->forked_inferior_pid = 0;
3457 b->exec_pathname = NULL;
3459 /* Add this breakpoint to the end of the chain
3460 so that a list of breakpoints will come out in order
3461 of increasing numbers. */
3463 b1 = breakpoint_chain;
3465 breakpoint_chain = b;
3473 check_duplicates (sal.pc, sal.section);
3474 breakpoints_changed ();
3480 /* Note that the breakpoint object B describes a permanent breakpoint
3481 instruction, hard-wired into the inferior's code. */
3483 make_breakpoint_permanent (struct breakpoint *b)
3485 b->enable = permanent;
3487 /* By definition, permanent breakpoints are already present in the code. */
3491 #ifdef GET_LONGJMP_TARGET
3494 create_longjmp_breakpoint (func_name)
3497 struct symtab_and_line sal;
3498 struct breakpoint *b;
3500 INIT_SAL (&sal); /* initialize to zeroes */
3501 if (func_name != NULL)
3503 struct minimal_symbol *m;
3505 m = lookup_minimal_symbol_text (func_name, NULL,
3506 (struct objfile *) NULL);
3508 sal.pc = SYMBOL_VALUE_ADDRESS (m);
3512 sal.section = find_pc_overlay (sal.pc);
3513 b = set_raw_breakpoint (sal);
3517 b->type = func_name != NULL ? bp_longjmp : bp_longjmp_resume;
3518 b->disposition = donttouch;
3519 b->enable = disabled;
3522 b->addr_string = strsave (func_name);
3523 b->number = internal_breakpoint_number--;
3526 #endif /* #ifdef GET_LONGJMP_TARGET */
3528 /* Call this routine when stepping and nexting to enable a breakpoint
3529 if we do a longjmp(). When we hit that breakpoint, call
3530 set_longjmp_resume_breakpoint() to figure out where we are going. */
3533 enable_longjmp_breakpoint ()
3535 register struct breakpoint *b;
3538 if (b->type == bp_longjmp)
3540 b->enable = enabled;
3541 check_duplicates (b->address, b->section);
3546 disable_longjmp_breakpoint ()
3548 register struct breakpoint *b;
3551 if (b->type == bp_longjmp
3552 || b->type == bp_longjmp_resume)
3554 b->enable = disabled;
3555 check_duplicates (b->address, b->section);
3561 remove_solib_event_breakpoints ()
3563 register struct breakpoint *b, *temp;
3565 ALL_BREAKPOINTS_SAFE (b, temp)
3566 if (b->type == bp_shlib_event)
3567 delete_breakpoint (b);
3571 create_solib_event_breakpoint (address)
3574 struct breakpoint *b;
3575 struct symtab_and_line sal;
3577 INIT_SAL (&sal); /* initialize to zeroes */
3579 sal.section = find_pc_overlay (sal.pc);
3580 b = set_raw_breakpoint (sal);
3581 b->number = internal_breakpoint_number--;
3582 b->disposition = donttouch;
3583 b->type = bp_shlib_event;
3588 /* Disable any breakpoints that are on code in shared libraries. Only
3589 apply to enabled breakpoints, disabled ones can just stay disabled. */
3592 disable_breakpoints_in_shlibs (silent)
3595 struct breakpoint *b;
3596 int disabled_shlib_breaks = 0;
3598 /* See also: insert_breakpoints, under DISABLE_UNSETTABLE_BREAK. */
3601 #if defined (PC_SOLIB)
3602 if (((b->type == bp_breakpoint) ||
3603 (b->type == bp_hardware_breakpoint)) &&
3604 b->enable == enabled &&
3606 PC_SOLIB (b->address))
3608 b->enable = shlib_disabled;
3611 if (!disabled_shlib_breaks)
3613 target_terminal_ours_for_output ();
3614 warning ("Temporarily disabling shared library breakpoints:");
3616 disabled_shlib_breaks = 1;
3617 warning ("breakpoint #%d ", b->number);
3624 /* Try to reenable any breakpoints in shared libraries. */
3626 re_enable_breakpoints_in_shlibs ()
3628 struct breakpoint *b;
3631 if (b->enable == shlib_disabled)
3635 /* Do not reenable the breakpoint if the shared library
3636 is still not mapped in. */
3637 if (target_read_memory (b->address, buf, 1) == 0)
3638 b->enable = enabled;
3645 solib_load_unload_1 (hookname, tempflag, dll_pathname, cond_string, bp_kind)
3650 enum bptype bp_kind;
3652 struct breakpoint *b;
3653 struct symtabs_and_lines sals;
3654 struct cleanup *old_chain;
3655 struct cleanup *canonical_strings_chain = NULL;
3656 char *addr_start = hookname;
3657 char *addr_end = NULL;
3658 char **canonical = (char **) NULL;
3659 int thread = -1; /* All threads. */
3661 /* Set a breakpoint on the specified hook. */
3662 sals = decode_line_1 (&hookname, 1, (struct symtab *) NULL, 0, &canonical);
3663 addr_end = hookname;
3665 if (sals.nelts == 0)
3667 warning ("Unable to set a breakpoint on dynamic linker callback.");
3668 warning ("Suggest linking with /opt/langtools/lib/end.o.");
3669 warning ("GDB will be unable to track shl_load/shl_unload calls");
3672 if (sals.nelts != 1)
3674 warning ("Unable to set unique breakpoint on dynamic linker callback.");
3675 warning ("GDB will be unable to track shl_load/shl_unload calls");
3679 /* Make sure that all storage allocated in decode_line_1 gets freed
3680 in case the following errors out. */
3681 old_chain = make_cleanup (free, sals.sals);
3682 if (canonical != (char **) NULL)
3684 make_cleanup (free, canonical);
3685 canonical_strings_chain = make_cleanup (null_cleanup, 0);
3686 if (canonical[0] != NULL)
3687 make_cleanup (free, canonical[0]);
3690 resolve_sal_pc (&sals.sals[0]);
3692 /* Remove the canonical strings from the cleanup, they are needed below. */
3693 if (canonical != (char **) NULL)
3694 discard_cleanups (canonical_strings_chain);
3696 b = set_raw_breakpoint (sals.sals[0]);
3697 set_breakpoint_count (breakpoint_count + 1);
3698 b->number = breakpoint_count;
3700 b->cond_string = (cond_string == NULL) ?
3701 NULL : savestring (cond_string, strlen (cond_string));
3704 if (canonical != (char **) NULL && canonical[0] != NULL)
3705 b->addr_string = canonical[0];
3706 else if (addr_start)
3707 b->addr_string = savestring (addr_start, addr_end - addr_start);
3709 b->enable = enabled;
3710 b->disposition = tempflag ? del : donttouch;
3712 if (dll_pathname == NULL)
3713 b->dll_pathname = NULL;
3716 b->dll_pathname = (char *) xmalloc (strlen (dll_pathname) + 1);
3717 strcpy (b->dll_pathname, dll_pathname);
3722 do_cleanups (old_chain);
3726 create_solib_load_event_breakpoint (hookname, tempflag,
3727 dll_pathname, cond_string)
3733 solib_load_unload_1 (hookname, tempflag, dll_pathname,
3734 cond_string, bp_catch_load);
3738 create_solib_unload_event_breakpoint (hookname, tempflag,
3739 dll_pathname, cond_string)
3745 solib_load_unload_1 (hookname,tempflag, dll_pathname,
3746 cond_string, bp_catch_unload);
3750 create_fork_vfork_event_catchpoint (tempflag, cond_string, bp_kind)
3753 enum bptype bp_kind;
3755 struct symtab_and_line sal;
3756 struct breakpoint *b;
3757 int thread = -1; /* All threads. */
3764 b = set_raw_breakpoint (sal);
3765 set_breakpoint_count (breakpoint_count + 1);
3766 b->number = breakpoint_count;
3768 b->cond_string = (cond_string == NULL) ?
3769 NULL : savestring (cond_string, strlen (cond_string));
3771 b->addr_string = NULL;
3772 b->enable = enabled;
3773 b->disposition = tempflag ? del : donttouch;
3774 b->forked_inferior_pid = 0;
3782 create_fork_event_catchpoint (tempflag, cond_string)
3786 create_fork_vfork_event_catchpoint (tempflag, cond_string, bp_catch_fork);
3790 create_vfork_event_catchpoint (tempflag, cond_string)
3794 create_fork_vfork_event_catchpoint (tempflag, cond_string, bp_catch_vfork);
3798 create_exec_event_catchpoint (tempflag, cond_string)
3802 struct symtab_and_line sal;
3803 struct breakpoint *b;
3804 int thread = -1; /* All threads. */
3811 b = set_raw_breakpoint (sal);
3812 set_breakpoint_count (breakpoint_count + 1);
3813 b->number = breakpoint_count;
3815 b->cond_string = (cond_string == NULL) ?
3816 NULL : savestring (cond_string, strlen (cond_string));
3818 b->addr_string = NULL;
3819 b->enable = enabled;
3820 b->disposition = tempflag ? del : donttouch;
3822 b->type = bp_catch_exec;
3828 hw_breakpoint_used_count ()
3830 register struct breakpoint *b;
3835 if (b->type == bp_hardware_breakpoint && b->enable == enabled)
3843 hw_watchpoint_used_count (type, other_type_used)
3845 int *other_type_used;
3847 register struct breakpoint *b;
3850 *other_type_used = 0;
3853 if (b->enable == enabled)
3855 if (b->type == type)
3857 else if ((b->type == bp_hardware_watchpoint ||
3858 b->type == bp_read_watchpoint ||
3859 b->type == bp_access_watchpoint)
3860 && b->enable == enabled)
3861 *other_type_used = 1;
3867 /* Call this after hitting the longjmp() breakpoint. Use this to set
3868 a new breakpoint at the target of the jmp_buf.
3870 FIXME - This ought to be done by setting a temporary breakpoint
3871 that gets deleted automatically... */
3874 set_longjmp_resume_breakpoint (pc, frame)
3876 struct frame_info *frame;
3878 register struct breakpoint *b;
3881 if (b->type == bp_longjmp_resume)
3884 b->enable = enabled;
3886 b->frame = frame->frame;
3889 check_duplicates (b->address, b->section);
3895 disable_watchpoints_before_interactive_call_start ()
3897 struct breakpoint *b;
3901 if (((b->type == bp_watchpoint)
3902 || (b->type == bp_hardware_watchpoint)
3903 || (b->type == bp_read_watchpoint)
3904 || (b->type == bp_access_watchpoint)
3905 || ep_is_exception_catchpoint (b))
3906 && (b->enable == enabled))
3908 b->enable = call_disabled;
3909 check_duplicates (b->address, b->section);
3915 enable_watchpoints_after_interactive_call_stop ()
3917 struct breakpoint *b;
3921 if (((b->type == bp_watchpoint)
3922 || (b->type == bp_hardware_watchpoint)
3923 || (b->type == bp_read_watchpoint)
3924 || (b->type == bp_access_watchpoint)
3925 || ep_is_exception_catchpoint (b))
3926 && (b->enable == call_disabled))
3928 b->enable = enabled;
3929 check_duplicates (b->address, b->section);
3935 /* Set a breakpoint that will evaporate an end of command
3936 at address specified by SAL.
3937 Restrict it to frame FRAME if FRAME is nonzero. */
3940 set_momentary_breakpoint (sal, frame, type)
3941 struct symtab_and_line sal;
3942 struct frame_info *frame;
3945 register struct breakpoint *b;
3946 b = set_raw_breakpoint (sal);
3948 b->enable = enabled;
3949 b->disposition = donttouch;
3950 b->frame = (frame ? frame->frame : 0);
3952 /* If we're debugging a multi-threaded program, then we
3953 want momentary breakpoints to be active in only a
3954 single thread of control. */
3955 if (in_thread_list (inferior_pid))
3956 b->thread = pid_to_thread_id (inferior_pid);
3962 /* Tell the user we have just set a breakpoint B. */
3966 struct breakpoint *b;
3970 /* FIXME: This is misplaced; mention() is called by things (like hitting a
3971 watchpoint) other than breakpoint creation. It should be possible to
3972 clean this up and at the same time replace the random calls to
3973 breakpoint_changed with this hook, as has already been done for
3974 delete_breakpoint_hook and so on. */
3975 if (create_breakpoint_hook)
3976 create_breakpoint_hook (b);
3977 breakpoint_create_event (b->number);
3982 printf_filtered ("(apparently deleted?) Eventpoint %d: ", b->number);
3985 printf_filtered ("Watchpoint %d: ", b->number);
3986 print_expression (b->exp, gdb_stdout);
3988 case bp_hardware_watchpoint:
3989 printf_filtered ("Hardware watchpoint %d: ", b->number);
3990 print_expression (b->exp, gdb_stdout);
3992 case bp_read_watchpoint:
3993 printf_filtered ("Hardware read watchpoint %d: ", b->number);
3994 print_expression (b->exp, gdb_stdout);
3996 case bp_access_watchpoint:
3997 printf_filtered ("Hardware access (read/write) watchpoint %d: ",
3999 print_expression (b->exp, gdb_stdout);
4002 printf_filtered ("Breakpoint %d", b->number);
4005 case bp_hardware_breakpoint:
4006 printf_filtered ("Hardware assisted breakpoint %d", b->number);
4010 case bp_catch_unload:
4011 printf_filtered ("Catchpoint %d (%s %s)",
4013 (b->type == bp_catch_load) ? "load" : "unload",
4014 (b->dll_pathname != NULL) ?
4015 b->dll_pathname : "<any library>");
4018 case bp_catch_vfork:
4019 printf_filtered ("Catchpoint %d (%s)",
4021 (b->type == bp_catch_fork) ? "fork" : "vfork");
4024 printf_filtered ("Catchpoint %d (exec)",
4027 case bp_catch_catch:
4028 case bp_catch_throw:
4029 printf_filtered ("Catchpoint %d (%s)",
4031 (b->type == bp_catch_catch) ? "catch" : "throw");
4037 case bp_longjmp_resume:
4038 case bp_step_resume:
4039 case bp_through_sigtramp:
4041 case bp_watchpoint_scope:
4042 case bp_shlib_event:
4047 if (addressprint || b->source_file == NULL)
4049 printf_filtered (" at ");
4050 print_address_numeric (b->address, 1, gdb_stdout);
4053 printf_filtered (": file %s, line %d.",
4054 b->source_file, b->line_number);
4055 TUIDO (((TuiOpaqueFuncPtr) tui_vAllSetHasBreakAt, b, 1));
4056 TUIDO (((TuiOpaqueFuncPtr) tuiUpdateAllExecInfos));
4058 printf_filtered ("\n");
4062 /* Set a breakpoint according to ARG (function, linenum or *address)
4063 flag: first bit : 0 non-temporary, 1 temporary.
4064 second bit : 0 normal breakpoint, 1 hardware breakpoint. */
4067 break_command_1 (arg, flag, from_tty)
4071 int tempflag, hardwareflag;
4072 struct symtabs_and_lines sals;
4073 struct symtab_and_line sal;
4074 register struct expression *cond = 0;
4075 register struct breakpoint *b;
4077 /* Pointers in arg to the start, and one past the end, of the condition. */
4078 char *cond_start = NULL;
4079 char *cond_end = NULL;
4080 /* Pointers in arg to the start, and one past the end,
4081 of the address part. */
4082 char *addr_start = NULL;
4083 char *addr_end = NULL;
4084 struct cleanup *old_chain;
4085 struct cleanup *canonical_strings_chain = NULL;
4086 char **canonical = (char **) NULL;
4090 hardwareflag = flag & BP_HARDWAREFLAG;
4091 tempflag = flag & BP_TEMPFLAG;
4096 INIT_SAL (&sal); /* initialize to zeroes */
4098 /* If no arg given, or if first arg is 'if ', use the default breakpoint. */
4100 if (!arg || (arg[0] == 'i' && arg[1] == 'f'
4101 && (arg[2] == ' ' || arg[2] == '\t')))
4103 if (default_breakpoint_valid)
4105 sals.sals = (struct symtab_and_line *)
4106 xmalloc (sizeof (struct symtab_and_line));
4107 sal.pc = default_breakpoint_address;
4108 sal.line = default_breakpoint_line;
4109 sal.symtab = default_breakpoint_symtab;
4110 sal.section = find_pc_overlay (sal.pc);
4115 error ("No default breakpoint address now.");
4121 /* Force almost all breakpoints to be in terms of the
4122 current_source_symtab (which is decode_line_1's default). This
4123 should produce the results we want almost all of the time while
4124 leaving default_breakpoint_* alone. */
4125 if (default_breakpoint_valid
4126 && (!current_source_symtab
4127 || (arg && (*arg == '+' || *arg == '-'))))
4128 sals = decode_line_1 (&arg, 1, default_breakpoint_symtab,
4129 default_breakpoint_line, &canonical);
4131 sals = decode_line_1 (&arg, 1, (struct symtab *) NULL, 0, &canonical);
4139 /* Make sure that all storage allocated in decode_line_1 gets freed
4140 in case the following `for' loop errors out. */
4141 old_chain = make_cleanup (free, sals.sals);
4142 if (canonical != (char **) NULL)
4144 make_cleanup (free, canonical);
4145 canonical_strings_chain = make_cleanup (null_cleanup, 0);
4146 for (i = 0; i < sals.nelts; i++)
4148 if (canonical[i] != NULL)
4149 make_cleanup (free, canonical[i]);
4153 thread = -1; /* No specific thread yet */
4155 /* Resolve all line numbers to PC's, and verify that conditions
4156 can be parsed, before setting any breakpoints. */
4157 for (i = 0; i < sals.nelts; i++)
4159 char *tok, *end_tok;
4162 resolve_sal_pc (&sals.sals[i]);
4164 /* It's possible for the PC to be nonzero, but still an illegal
4165 value on some targets.
4167 For example, on HP-UX if you start gdb, and before running the
4168 inferior you try to set a breakpoint on a shared library function
4169 "foo" where the inferior doesn't call "foo" directly but does
4170 pass its address to another function call, then we do find a
4171 minimal symbol for the "foo", but it's address is invalid.
4172 (Appears to be an index into a table that the loader sets up
4173 when the inferior is run.)
4175 Give the target a chance to bless sals.sals[i].pc before we
4176 try to make a breakpoint for it. */
4177 if (PC_REQUIRES_RUN_BEFORE_USE (sals.sals[i].pc))
4179 error ("Cannot break on %s without a running program.",
4187 while (*tok == ' ' || *tok == '\t')
4192 while (*end_tok != ' ' && *end_tok != '\t' && *end_tok != '\000')
4195 toklen = end_tok - tok;
4197 if (toklen >= 1 && strncmp (tok, "if", toklen) == 0)
4199 tok = cond_start = end_tok + 1;
4200 cond = parse_exp_1 (&tok, block_for_pc (sals.sals[i].pc), 0);
4203 else if (toklen >= 1 && strncmp (tok, "thread", toklen) == 0)
4209 thread = strtol (tok, &tok, 0);
4211 error ("Junk after thread keyword.");
4212 if (!valid_thread_id (thread))
4213 error ("Unknown thread %d\n", thread);
4216 error ("Junk at end of arguments.");
4221 int i, target_resources_ok;
4223 i = hw_breakpoint_used_count ();
4224 target_resources_ok =
4225 TARGET_CAN_USE_HARDWARE_WATCHPOINT (bp_hardware_breakpoint,
4227 if (target_resources_ok == 0)
4228 error ("No hardware breakpoint support in the target.");
4229 else if (target_resources_ok < 0)
4230 error ("Hardware breakpoints used exceeds limit.");
4233 /* Remove the canonical strings from the cleanup, they are needed below. */
4234 if (canonical != (char **) NULL)
4235 discard_cleanups (canonical_strings_chain);
4237 /* Now set all the breakpoints. */
4238 for (i = 0; i < sals.nelts; i++)
4243 describe_other_breakpoints (sal.pc, sal.section);
4245 b = set_raw_breakpoint (sal);
4246 set_breakpoint_count (breakpoint_count + 1);
4247 b->number = breakpoint_count;
4248 b->type = hardwareflag ? bp_hardware_breakpoint : bp_breakpoint;
4252 /* If a canonical line spec is needed use that instead of the
4254 if (canonical != (char **) NULL && canonical[i] != NULL)
4255 b->addr_string = canonical[i];
4256 else if (addr_start)
4257 b->addr_string = savestring (addr_start, addr_end - addr_start);
4259 b->cond_string = savestring (cond_start, cond_end - cond_start);
4261 b->enable = enabled;
4262 b->disposition = tempflag ? del : donttouch;
4268 warning ("Multiple breakpoints were set.");
4269 warning ("Use the \"delete\" command to delete unwanted breakpoints.");
4271 do_cleanups (old_chain);
4275 break_at_finish_at_depth_command_1 (arg, flag, from_tty)
4280 struct frame_info *frame;
4281 CORE_ADDR low, high, selected_pc = 0;
4282 char *extra_args, *level_arg, *addr_string;
4283 int extra_args_len = 0, if_arg = 0;
4286 (arg[0] == 'i' && arg[1] == 'f' && (arg[2] == ' ' || arg[2] == '\t')))
4289 if (default_breakpoint_valid)
4293 selected_pc = selected_frame->pc;
4298 error ("No selected frame.");
4301 error ("No default breakpoint address now.");
4305 extra_args = strchr (arg, ' ');
4309 extra_args_len = strlen (extra_args);
4310 level_arg = (char *) xmalloc (extra_args - arg);
4311 strncpy (level_arg, arg, extra_args - arg - 1);
4312 level_arg[extra_args - arg - 1] = '\0';
4316 level_arg = (char *) xmalloc (strlen (arg) + 1);
4317 strcpy (level_arg, arg);
4320 frame = parse_frame_specification (level_arg);
4322 selected_pc = frame->pc;
4329 extra_args_len = strlen (arg);
4334 if (find_pc_partial_function (selected_pc, (char **) NULL, &low, &high))
4336 addr_string = (char *) xmalloc (26 + extra_args_len);
4338 sprintf (addr_string, "*0x%s %s", paddr_nz (high), extra_args);
4340 sprintf (addr_string, "*0x%s", paddr_nz (high));
4341 break_command_1 (addr_string, flag, from_tty);
4345 error ("No function contains the specified address");
4348 error ("Unable to set breakpoint at procedure exit");
4353 break_at_finish_command_1 (arg, flag, from_tty)
4358 char *addr_string, *break_string, *beg_addr_string;
4359 CORE_ADDR low, high;
4360 struct symtabs_and_lines sals;
4361 struct symtab_and_line sal;
4362 struct cleanup *old_chain;
4364 int extra_args_len = 0;
4368 (arg[0] == 'i' && arg[1] == 'f' && (arg[2] == ' ' || arg[2] == '\t')))
4370 if (default_breakpoint_valid)
4374 addr_string = (char *) xmalloc (15);
4375 sprintf (addr_string, "*0x%s", paddr_nz (selected_frame->pc));
4380 error ("No selected frame.");
4383 error ("No default breakpoint address now.");
4387 addr_string = (char *) xmalloc (strlen (arg) + 1);
4388 strcpy (addr_string, arg);
4394 extra_args_len = strlen (arg);
4398 /* get the stuff after the function name or address */
4399 extra_args = strchr (arg, ' ');
4403 extra_args_len = strlen (extra_args);
4410 beg_addr_string = addr_string;
4411 sals = decode_line_1 (&addr_string, 1, (struct symtab *) NULL, 0,
4414 free (beg_addr_string);
4415 old_chain = make_cleanup (free, sals.sals);
4416 for (i = 0; (i < sals.nelts); i++)
4419 if (find_pc_partial_function (sal.pc, (char **) NULL, &low, &high))
4421 break_string = (char *) xmalloc (extra_args_len + 26);
4423 sprintf (break_string, "*0x%s %s", paddr_nz (high), extra_args);
4425 sprintf (break_string, "*0x%s", paddr_nz (high));
4426 break_command_1 (break_string, flag, from_tty);
4427 free (break_string);
4430 error ("No function contains the specified address");
4434 warning ("Multiple breakpoints were set.\n");
4435 warning ("Use the \"delete\" command to delete unwanted breakpoints.");
4437 do_cleanups (old_chain);
4441 /* Helper function for break_command_1 and disassemble_command. */
4444 resolve_sal_pc (sal)
4445 struct symtab_and_line *sal;
4449 if (sal->pc == 0 && sal->symtab != NULL)
4451 if (!find_line_pc (sal->symtab, sal->line, &pc))
4452 error ("No line %d in file \"%s\".",
4453 sal->line, sal->symtab->filename);
4457 if (sal->section == 0 && sal->symtab != NULL)
4459 struct blockvector *bv;
4464 bv = blockvector_for_pc_sect (sal->pc, 0, &index, sal->symtab);
4467 b = BLOCKVECTOR_BLOCK (bv, index);
4468 sym = block_function (b);
4471 fixup_symbol_section (sym, sal->symtab->objfile);
4472 sal->section = SYMBOL_BFD_SECTION (sym);
4476 /* It really is worthwhile to have the section, so we'll just
4477 have to look harder. This case can be executed if we have
4478 line numbers but no functions (as can happen in assembly
4481 struct minimal_symbol *msym;
4483 msym = lookup_minimal_symbol_by_pc (sal->pc);
4485 sal->section = SYMBOL_BFD_SECTION (msym);
4492 break_command (arg, from_tty)
4496 break_command_1 (arg, 0, from_tty);
4500 break_at_finish_command (arg, from_tty)
4504 break_at_finish_command_1 (arg, 0, from_tty);
4508 break_at_finish_at_depth_command (arg, from_tty)
4512 break_at_finish_at_depth_command_1 (arg, 0, from_tty);
4516 tbreak_command (arg, from_tty)
4520 break_command_1 (arg, BP_TEMPFLAG, from_tty);
4524 tbreak_at_finish_command (arg, from_tty)
4528 break_at_finish_command_1 (arg, BP_TEMPFLAG, from_tty);
4532 hbreak_command (arg, from_tty)
4536 break_command_1 (arg, BP_HARDWAREFLAG, from_tty);
4540 thbreak_command (arg, from_tty)
4544 break_command_1 (arg, (BP_TEMPFLAG | BP_HARDWAREFLAG), from_tty);
4548 stop_command (arg, from_tty)
4552 printf_filtered ("Specify the type of breakpoint to set.\n\
4553 Usage: stop in <function | address>\n\
4558 stopin_command (arg, from_tty)
4564 if (arg == (char *) NULL)
4566 else if (*arg != '*')
4571 /* look for a ':'. If this is a line number specification, then
4572 say it is bad, otherwise, it should be an address or
4573 function/method name */
4574 while (*argptr && !hasColon)
4576 hasColon = (*argptr == ':');
4581 badInput = (*argptr != ':'); /* Not a class::method */
4583 badInput = isdigit (*arg); /* a simple line number */
4587 printf_filtered ("Usage: stop in <function | address>\n");
4589 break_command_1 (arg, 0, from_tty);
4593 stopat_command (arg, from_tty)
4599 if (arg == (char *) NULL || *arg == '*') /* no line number */
4606 /* look for a ':'. If there is a '::' then get out, otherwise
4607 it is probably a line number. */
4608 while (*argptr && !hasColon)
4610 hasColon = (*argptr == ':');
4615 badInput = (*argptr == ':'); /* we have class::method */
4617 badInput = !isdigit (*arg); /* not a line number */
4621 printf_filtered ("Usage: stop at <line>\n");
4623 break_command_1 (arg, 0, from_tty);
4627 /* accessflag: hw_write: watch write,
4628 hw_read: watch read,
4629 hw_access: watch access (read or write) */
4631 watch_command_1 (arg, accessflag, from_tty)
4636 struct breakpoint *b;
4637 struct symtab_and_line sal;
4638 struct expression *exp;
4639 struct block *exp_valid_block;
4640 struct value *val, *mark;
4641 struct frame_info *frame;
4642 struct frame_info *prev_frame = NULL;
4643 char *exp_start = NULL;
4644 char *exp_end = NULL;
4645 char *tok, *end_tok;
4647 char *cond_start = NULL;
4648 char *cond_end = NULL;
4649 struct expression *cond = NULL;
4650 int i, other_type_used, target_resources_ok = 0;
4651 enum bptype bp_type;
4654 INIT_SAL (&sal); /* initialize to zeroes */
4656 /* Parse arguments. */
4657 innermost_block = NULL;
4659 exp = parse_exp_1 (&arg, 0, 0);
4661 exp_valid_block = innermost_block;
4662 mark = value_mark ();
4663 val = evaluate_expression (exp);
4664 release_value (val);
4665 if (VALUE_LAZY (val))
4666 value_fetch_lazy (val);
4669 while (*tok == ' ' || *tok == '\t')
4673 while (*end_tok != ' ' && *end_tok != '\t' && *end_tok != '\000')
4676 toklen = end_tok - tok;
4677 if (toklen >= 1 && strncmp (tok, "if", toklen) == 0)
4679 tok = cond_start = end_tok + 1;
4680 cond = parse_exp_1 (&tok, 0, 0);
4684 error ("Junk at end of command.");
4686 if (accessflag == hw_read)
4687 bp_type = bp_read_watchpoint;
4688 else if (accessflag == hw_access)
4689 bp_type = bp_access_watchpoint;
4691 bp_type = bp_hardware_watchpoint;
4693 mem_cnt = can_use_hardware_watchpoint (val);
4694 if (mem_cnt == 0 && bp_type != bp_hardware_watchpoint)
4695 error ("Expression cannot be implemented with read/access watchpoint.");
4698 i = hw_watchpoint_used_count (bp_type, &other_type_used);
4699 target_resources_ok =
4700 TARGET_CAN_USE_HARDWARE_WATCHPOINT (bp_type, i + mem_cnt,
4702 if (target_resources_ok == 0 && bp_type != bp_hardware_watchpoint)
4703 error ("Target does not support this type of hardware watchpoint.");
4705 if (target_resources_ok < 0 && bp_type != bp_hardware_watchpoint)
4706 error ("Target can only support one kind of HW watchpoint at a time.");
4709 #if defined(HPUXHPPA)
4710 /* On HP-UX if you set a h/w
4711 watchpoint before the "run" command, the inferior dies with a e.g.,
4712 SIGILL once you start it. I initially believed this was due to a
4713 bad interaction between page protection traps and the initial
4714 startup sequence by the dynamic linker.
4716 However, I tried avoiding that by having HP-UX's implementation of
4717 TARGET_CAN_USE_HW_WATCHPOINT return FALSE if there was no inferior_pid
4718 yet, which forced slow watches before a "run" or "attach", and it
4719 still fails somewhere in the startup code.
4721 Until I figure out what's happening, I'm disallowing watches altogether
4722 before the "run" or "attach" command. We'll tell the user they must
4723 set watches after getting the program started. */
4724 if (!target_has_execution)
4726 warning ("can't do that without a running program; try \"break main\", \"run\" first");
4729 #endif /* HPUXHPPA */
4731 /* Now set up the breakpoint. */
4732 b = set_raw_breakpoint (sal);
4733 set_breakpoint_count (breakpoint_count + 1);
4734 b->number = breakpoint_count;
4735 b->disposition = donttouch;
4737 b->exp_valid_block = exp_valid_block;
4738 b->exp_string = savestring (exp_start, exp_end - exp_start);
4742 b->cond_string = savestring (cond_start, cond_end - cond_start);
4746 frame = block_innermost_frame (exp_valid_block);
4749 prev_frame = get_prev_frame (frame);
4750 b->watchpoint_frame = frame->frame;
4753 b->watchpoint_frame = (CORE_ADDR) 0;
4755 if (mem_cnt && target_resources_ok > 0)
4758 b->type = bp_watchpoint;
4760 /* If the expression is "local", then set up a "watchpoint scope"
4761 breakpoint at the point where we've left the scope of the watchpoint
4763 if (innermost_block)
4767 struct breakpoint *scope_breakpoint;
4768 struct symtab_and_line scope_sal;
4770 INIT_SAL (&scope_sal); /* initialize to zeroes */
4771 scope_sal.pc = get_frame_pc (prev_frame);
4772 scope_sal.section = find_pc_overlay (scope_sal.pc);
4774 scope_breakpoint = set_raw_breakpoint (scope_sal);
4775 set_breakpoint_count (breakpoint_count + 1);
4776 scope_breakpoint->number = breakpoint_count;
4778 scope_breakpoint->type = bp_watchpoint_scope;
4779 scope_breakpoint->enable = enabled;
4781 /* Automatically delete the breakpoint when it hits. */
4782 scope_breakpoint->disposition = del;
4784 /* Only break in the proper frame (help with recursion). */
4785 scope_breakpoint->frame = prev_frame->frame;
4787 /* Set the address at which we will stop. */
4788 scope_breakpoint->address = get_frame_pc (prev_frame);
4790 /* The scope breakpoint is related to the watchpoint. We
4791 will need to act on them together. */
4792 b->related_breakpoint = scope_breakpoint;
4795 value_free_to_mark (mark);
4799 /* Return count of locations need to be watched and can be handled
4800 in hardware. If the watchpoint can not be handled
4801 in hardware return zero. */
4803 #if !defined(TARGET_REGION_SIZE_OK_FOR_HW_WATCHPOINT)
4804 #define TARGET_REGION_SIZE_OK_FOR_HW_WATCHPOINT(BYTE_SIZE) \
4805 ((BYTE_SIZE) <= (REGISTER_SIZE))
4808 #if !defined(TARGET_REGION_OK_FOR_HW_WATCHPOINT)
4809 #define TARGET_REGION_OK_FOR_HW_WATCHPOINT(ADDR,LEN) \
4810 TARGET_REGION_SIZE_OK_FOR_HW_WATCHPOINT(LEN)
4814 can_use_hardware_watchpoint (v)
4817 int found_memory_cnt = 0;
4819 /* Did the user specifically forbid us to use hardware watchpoints? */
4820 if (!can_use_hw_watchpoints)
4823 /* Make sure that the value of the expression depends only upon
4824 memory contents, and values computed from them within GDB. If we
4825 find any register references or function calls, we can't use a
4826 hardware watchpoint.
4828 The idea here is that evaluating an expression generates a series
4829 of values, one holding the value of every subexpression. (The
4830 expression a*b+c has five subexpressions: a, b, a*b, c, and
4831 a*b+c.) GDB's values hold almost enough information to establish
4832 the criteria given above --- they identify memory lvalues,
4833 register lvalues, computed values, etcetera. So we can evaluate
4834 the expression, and then scan the chain of values that leaves
4835 behind to decide whether we can detect any possible change to the
4836 expression's final value using only hardware watchpoints.
4838 However, I don't think that the values returned by inferior
4839 function calls are special in any way. So this function may not
4840 notice that an expression involving an inferior function call
4841 can't be watched with hardware watchpoints. FIXME. */
4842 for (; v; v = v->next)
4844 if (VALUE_LVAL (v) == lval_memory)
4847 /* A lazy memory lvalue is one that GDB never needed to fetch;
4848 we either just used its address (e.g., `a' in `a.b') or
4849 we never needed it at all (e.g., `a' in `a,b'). */
4853 /* Ahh, memory we actually used! Check if we can cover
4854 it with hardware watchpoints. */
4855 CORE_ADDR vaddr = VALUE_ADDRESS (v) + VALUE_OFFSET (v);
4856 int len = TYPE_LENGTH (VALUE_TYPE (v));
4858 if (!TARGET_REGION_OK_FOR_HW_WATCHPOINT (vaddr, len))
4864 else if (v->lval != not_lval && v->modifiable == 0)
4865 return 0; /* ??? What does this represent? */
4866 else if (v->lval == lval_register)
4867 return 0; /* cannot watch a register with a HW watchpoint */
4870 /* The expression itself looks suitable for using a hardware
4871 watchpoint, but give the target machine a chance to reject it. */
4872 return found_memory_cnt;
4876 watch_command (arg, from_tty)
4880 watch_command_1 (arg, hw_write, from_tty);
4884 rwatch_command (arg, from_tty)
4888 watch_command_1 (arg, hw_read, from_tty);
4892 awatch_command (arg, from_tty)
4896 watch_command_1 (arg, hw_access, from_tty);
4900 /* Helper routines for the until_command routine in infcmd.c. Here
4901 because it uses the mechanisms of breakpoints. */
4903 /* This function is called by fetch_inferior_event via the
4904 cmd_continuation pointer, to complete the until command. It takes
4905 care of cleaning up the temporary breakpoints set up by the until
4908 until_break_command_continuation (struct continuation_arg *arg)
4910 /* Do all the exec cleanups, which at this point should only be the
4911 one set up in the first part of the until_break_command
4913 do_exec_cleanups (ALL_CLEANUPS);
4918 until_break_command (arg, from_tty)
4922 struct symtabs_and_lines sals;
4923 struct symtab_and_line sal;
4924 struct frame_info *prev_frame = get_prev_frame (selected_frame);
4925 struct breakpoint *breakpoint;
4926 struct cleanup *old_chain;
4928 clear_proceed_status ();
4930 /* Set a breakpoint where the user wants it and at return from
4933 if (default_breakpoint_valid)
4934 sals = decode_line_1 (&arg, 1, default_breakpoint_symtab,
4935 default_breakpoint_line, (char ***) NULL);
4937 sals = decode_line_1 (&arg, 1, (struct symtab *) NULL,
4938 0, (char ***) NULL);
4940 if (sals.nelts != 1)
4941 error ("Couldn't get information on specified line.");
4944 free ((PTR) sals.sals); /* malloc'd, so freed */
4947 error ("Junk at end of arguments.");
4949 resolve_sal_pc (&sal);
4951 breakpoint = set_momentary_breakpoint (sal, selected_frame, bp_until);
4953 if (!event_loop_p || !target_can_async_p ())
4954 old_chain = make_cleanup ((make_cleanup_func) delete_breakpoint,
4957 make_exec_cleanup ((make_cleanup_func) delete_breakpoint, breakpoint);
4959 /* If we are running asynchronously, and the target supports async
4960 execution, we are not waiting for the target to stop, in the call
4961 tp proceed, below. This means that we cannot delete the
4962 brekpoints until the target has actually stopped. The only place
4963 where we get a chance to do that is in fetch_inferior_event, so
4964 we must set things up for that. */
4966 if (event_loop_p && target_can_async_p ())
4968 /* In this case we don't need args for the continuation, because
4969 all it needs to do is do the cleanups in the
4970 exec_cleanup_chain, which will be only those inserted by this
4971 function. We can get away by using ALL_CLEANUPS. */
4972 add_continuation (until_break_command_continuation, NULL);
4975 /* Keep within the current frame */
4979 sal = find_pc_line (prev_frame->pc, 0);
4980 sal.pc = prev_frame->pc;
4981 breakpoint = set_momentary_breakpoint (sal, prev_frame, bp_until);
4982 if (!event_loop_p || !target_can_async_p ())
4983 make_cleanup ((make_cleanup_func) delete_breakpoint, breakpoint);
4985 make_exec_cleanup ((make_cleanup_func) delete_breakpoint, breakpoint);
4988 proceed (-1, TARGET_SIGNAL_DEFAULT, 0);
4989 /* Do the cleanups now, anly if we are not running asynchronously,
4990 of if we are, but the target is still synchronous. */
4991 if (!event_loop_p || !target_can_async_p ())
4992 do_cleanups (old_chain);
4996 /* These aren't used; I don't konw what they were for. */
4997 /* Set a breakpoint at the catch clause for NAME. */
4999 catch_breakpoint (name)
5005 disable_catch_breakpoint ()
5010 delete_catch_breakpoint ()
5015 enable_catch_breakpoint ()
5022 struct sal_chain *next;
5023 struct symtab_and_line sal;
5027 /* Not really used -- invocation in handle_gnu_4_16_catch_command
5028 had been commented out in the v.4.16 sources, and stays
5029 disabled there now because "catch NAME" syntax isn't allowed.
5031 /* This isn't used; I don't know what it was for. */
5032 /* For each catch clause identified in ARGS, run FUNCTION
5033 with that clause as an argument. */
5034 static struct symtabs_and_lines
5035 map_catch_names (args, function)
5039 register char *p = args;
5041 struct symtabs_and_lines sals;
5043 struct sal_chain *sal_chain = 0;
5047 error_no_arg ("one or more catch names");
5055 /* Don't swallow conditional part. */
5056 if (p1[0] == 'i' && p1[1] == 'f'
5057 && (p1[2] == ' ' || p1[2] == '\t'))
5063 while (isalnum (*p1) || *p1 == '_' || *p1 == '$')
5067 if (*p1 && *p1 != ' ' && *p1 != '\t')
5068 error ("Arguments must be catch names.");
5074 struct sal_chain *next = (struct sal_chain *)
5075 alloca (sizeof (struct sal_chain));
5076 next->next = sal_chain;
5077 next->sal = get_catch_sal (p);
5082 printf_unfiltered ("No catch clause for exception %s.\n", p);
5087 while (*p == ' ' || *p == '\t')
5093 /* This shares a lot of code with `print_frame_label_vars' from stack.c. */
5095 static struct symtabs_and_lines
5096 get_catch_sals (this_level_only)
5097 int this_level_only;
5099 register struct blockvector *bl;
5100 register struct block *block;
5101 int index, have_default = 0;
5103 struct symtabs_and_lines sals;
5104 struct sal_chain *sal_chain = 0;
5105 char *blocks_searched;
5107 /* Not sure whether an error message is always the correct response,
5108 but it's better than a core dump. */
5109 if (selected_frame == NULL)
5110 error ("No selected frame.");
5111 block = get_frame_block (selected_frame);
5112 pc = selected_frame->pc;
5118 error ("No symbol table info available.\n");
5120 bl = blockvector_for_pc (BLOCK_END (block) - 4, &index);
5121 blocks_searched = (char *) alloca (BLOCKVECTOR_NBLOCKS (bl) * sizeof (char));
5122 memset (blocks_searched, 0, BLOCKVECTOR_NBLOCKS (bl) * sizeof (char));
5126 CORE_ADDR end = BLOCK_END (block) - 4;
5129 if (bl != blockvector_for_pc (end, &index))
5130 error ("blockvector blotch");
5131 if (BLOCKVECTOR_BLOCK (bl, index) != block)
5132 error ("blockvector botch");
5133 last_index = BLOCKVECTOR_NBLOCKS (bl);
5136 /* Don't print out blocks that have gone by. */
5137 while (index < last_index
5138 && BLOCK_END (BLOCKVECTOR_BLOCK (bl, index)) < pc)
5141 while (index < last_index
5142 && BLOCK_END (BLOCKVECTOR_BLOCK (bl, index)) < end)
5144 if (blocks_searched[index] == 0)
5146 struct block *b = BLOCKVECTOR_BLOCK (bl, index);
5149 register struct symbol *sym;
5151 nsyms = BLOCK_NSYMS (b);
5153 for (i = 0; i < nsyms; i++)
5155 sym = BLOCK_SYM (b, i);
5156 if (STREQ (SYMBOL_NAME (sym), "default"))
5162 if (SYMBOL_CLASS (sym) == LOC_LABEL)
5164 struct sal_chain *next = (struct sal_chain *)
5165 alloca (sizeof (struct sal_chain));
5166 next->next = sal_chain;
5167 next->sal = find_pc_line (SYMBOL_VALUE_ADDRESS (sym),
5172 blocks_searched[index] = 1;
5178 if (sal_chain && this_level_only)
5181 /* After handling the function's top-level block, stop.
5182 Don't continue to its superblock, the block of
5183 per-file symbols. */
5184 if (BLOCK_FUNCTION (block))
5186 block = BLOCK_SUPERBLOCK (block);
5191 struct sal_chain *tmp_chain;
5193 /* Count the number of entries. */
5194 for (index = 0, tmp_chain = sal_chain; tmp_chain;
5195 tmp_chain = tmp_chain->next)
5199 sals.sals = (struct symtab_and_line *)
5200 xmalloc (index * sizeof (struct symtab_and_line));
5201 for (index = 0; sal_chain; sal_chain = sal_chain->next, index++)
5202 sals.sals[index] = sal_chain->sal;
5209 ep_skip_leading_whitespace (s)
5212 if ((s == NULL) || (*s == NULL))
5214 while (isspace (**s))
5218 /* This function examines a string, and attempts to find a token
5219 that might be an event name in the leading characters. If a
5220 possible match is found, a pointer to the last character of
5221 the token is returned. Else, NULL is returned. */
5224 ep_find_event_name_end (arg)
5228 char *event_name_end = NULL;
5230 /* If we could depend upon the presense of strrpbrk, we'd use that... */
5234 /* We break out of the loop when we find a token delimiter.
5235 Basically, we're looking for alphanumerics and underscores;
5236 anything else delimites the token. */
5239 if (!isalnum (*s) && (*s != '_'))
5245 return event_name_end;
5249 /* This function attempts to parse an optional "if <cond>" clause
5250 from the arg string. If one is not found, it returns NULL.
5252 Else, it returns a pointer to the condition string. (It does not
5253 attempt to evaluate the string against a particular block.) And,
5254 it updates arg to point to the first character following the parsed
5255 if clause in the arg string. */
5258 ep_parse_optional_if_clause (arg)
5263 if (((*arg)[0] != 'i') || ((*arg)[1] != 'f') || !isspace ((*arg)[2]))
5266 /* Skip the "if" keyword. */
5269 /* Skip any extra leading whitespace, and record the start of the
5270 condition string. */
5271 ep_skip_leading_whitespace (arg);
5274 /* Assume that the condition occupies the remainder of the arg string. */
5275 (*arg) += strlen (cond_string);
5280 /* This function attempts to parse an optional filename from the arg
5281 string. If one is not found, it returns NULL.
5283 Else, it returns a pointer to the parsed filename. (This function
5284 makes no attempt to verify that a file of that name exists, or is
5285 accessible.) And, it updates arg to point to the first character
5286 following the parsed filename in the arg string.
5288 Note that clients needing to preserve the returned filename for
5289 future access should copy it to their own buffers. */
5291 ep_parse_optional_filename (arg)
5294 static char filename[1024];
5299 if ((*arg_p == '\0') || isspace (*arg_p))
5317 /* Commands to deal with catching events, such as signals, exceptions,
5318 process start/exit, etc. */
5322 catch_fork, catch_vfork
5326 #if defined(CHILD_INSERT_FORK_CATCHPOINT) || defined(CHILD_INSERT_VFORK_CATCHPOINT)
5327 static void catch_fork_command_1 PARAMS ((catch_fork_kind fork_kind,
5333 catch_fork_command_1 (fork_kind, arg, tempflag, from_tty)
5334 catch_fork_kind fork_kind;
5339 char *cond_string = NULL;
5341 ep_skip_leading_whitespace (&arg);
5343 /* The allowed syntax is:
5345 catch [v]fork if <cond>
5347 First, check if there's an if clause. */
5348 cond_string = ep_parse_optional_if_clause (&arg);
5350 if ((*arg != '\0') && !isspace (*arg))
5351 error ("Junk at end of arguments.");
5353 /* If this target supports it, create a fork or vfork catchpoint
5354 and enable reporting of such events. */
5358 create_fork_event_catchpoint (tempflag, cond_string);
5361 create_vfork_event_catchpoint (tempflag, cond_string);
5364 error ("unsupported or unknown fork kind; cannot catch it");
5370 #if defined(CHILD_INSERT_EXEC_CATCHPOINT)
5372 catch_exec_command_1 (arg, tempflag, from_tty)
5377 char *cond_string = NULL;
5379 ep_skip_leading_whitespace (&arg);
5381 /* The allowed syntax is:
5383 catch exec if <cond>
5385 First, check if there's an if clause. */
5386 cond_string = ep_parse_optional_if_clause (&arg);
5388 if ((*arg != '\0') && !isspace (*arg))
5389 error ("Junk at end of arguments.");
5391 /* If this target supports it, create an exec catchpoint
5392 and enable reporting of such events. */
5393 create_exec_event_catchpoint (tempflag, cond_string);
5397 #if defined(SOLIB_ADD)
5399 catch_load_command_1 (arg, tempflag, from_tty)
5404 char *dll_pathname = NULL;
5405 char *cond_string = NULL;
5407 ep_skip_leading_whitespace (&arg);
5409 /* The allowed syntax is:
5411 catch load if <cond>
5412 catch load <filename>
5413 catch load <filename> if <cond>
5415 The user is not allowed to specify the <filename> after an
5418 We'll ignore the pathological case of a file named "if".
5420 First, check if there's an if clause. If so, then there
5421 cannot be a filename. */
5422 cond_string = ep_parse_optional_if_clause (&arg);
5424 /* If there was an if clause, then there cannot be a filename.
5425 Else, there might be a filename and an if clause. */
5426 if (cond_string == NULL)
5428 dll_pathname = ep_parse_optional_filename (&arg);
5429 ep_skip_leading_whitespace (&arg);
5430 cond_string = ep_parse_optional_if_clause (&arg);
5433 if ((*arg != '\0') && !isspace (*arg))
5434 error ("Junk at end of arguments.");
5436 /* Create a load breakpoint that only triggers when a load of
5437 the specified dll (or any dll, if no pathname was specified)
5439 SOLIB_CREATE_CATCH_LOAD_HOOK (inferior_pid, tempflag,
5440 dll_pathname, cond_string);
5444 catch_unload_command_1 (arg, tempflag, from_tty)
5449 char *dll_pathname = NULL;
5450 char *cond_string = NULL;
5452 ep_skip_leading_whitespace (&arg);
5454 /* The allowed syntax is:
5456 catch unload if <cond>
5457 catch unload <filename>
5458 catch unload <filename> if <cond>
5460 The user is not allowed to specify the <filename> after an
5463 We'll ignore the pathological case of a file named "if".
5465 First, check if there's an if clause. If so, then there
5466 cannot be a filename. */
5467 cond_string = ep_parse_optional_if_clause (&arg);
5469 /* If there was an if clause, then there cannot be a filename.
5470 Else, there might be a filename and an if clause. */
5471 if (cond_string == NULL)
5473 dll_pathname = ep_parse_optional_filename (&arg);
5474 ep_skip_leading_whitespace (&arg);
5475 cond_string = ep_parse_optional_if_clause (&arg);
5478 if ((*arg != '\0') && !isspace (*arg))
5479 error ("Junk at end of arguments.");
5481 /* Create an unload breakpoint that only triggers when an unload of
5482 the specified dll (or any dll, if no pathname was specified)
5484 SOLIB_CREATE_CATCH_UNLOAD_HOOK (inferior_pid, tempflag,
5485 dll_pathname, cond_string);
5487 #endif /* SOLIB_ADD */
5489 /* Commands to deal with catching exceptions. */
5491 /* Set a breakpoint at the specified callback routine for an
5492 exception event callback */
5495 create_exception_catchpoint (tempflag, cond_string, ex_event, sal)
5498 enum exception_event_kind ex_event;
5499 struct symtab_and_line *sal;
5501 struct breakpoint *b;
5502 int thread = -1; /* All threads. */
5504 if (!sal) /* no exception support? */
5507 b = set_raw_breakpoint (*sal);
5508 set_breakpoint_count (breakpoint_count + 1);
5509 b->number = breakpoint_count;
5511 b->cond_string = (cond_string == NULL) ?
5512 NULL : savestring (cond_string, strlen (cond_string));
5514 b->addr_string = NULL;
5515 b->enable = enabled;
5516 b->disposition = tempflag ? del : donttouch;
5519 case EX_EVENT_THROW:
5520 b->type = bp_catch_throw;
5522 case EX_EVENT_CATCH:
5523 b->type = bp_catch_catch;
5525 default: /* error condition */
5527 b->enable = disabled;
5528 error ("Internal error -- invalid catchpoint kind");
5533 /* Deal with "catch catch" and "catch throw" commands */
5536 catch_exception_command_1 (ex_event, arg, tempflag, from_tty)
5537 enum exception_event_kind ex_event;
5542 char *cond_string = NULL;
5543 struct symtab_and_line *sal = NULL;
5545 ep_skip_leading_whitespace (&arg);
5547 cond_string = ep_parse_optional_if_clause (&arg);
5549 if ((*arg != '\0') && !isspace (*arg))
5550 error ("Junk at end of arguments.");
5552 if ((ex_event != EX_EVENT_THROW) &&
5553 (ex_event != EX_EVENT_CATCH))
5554 error ("Unsupported or unknown exception event; cannot catch it");
5556 /* See if we can find a callback routine */
5557 sal = target_enable_exception_callback (ex_event, 1);
5561 /* We have callbacks from the runtime system for exceptions.
5562 Set a breakpoint on the sal found, if no errors */
5563 if (sal != (struct symtab_and_line *) -1)
5564 create_exception_catchpoint (tempflag, cond_string, ex_event, sal);
5566 return; /* something went wrong with setting up callbacks */
5570 /* No callbacks from runtime system for exceptions.
5571 Try GNU C++ exception breakpoints using labels in debug info. */
5572 if (ex_event == EX_EVENT_CATCH)
5574 handle_gnu_4_16_catch_command (arg, tempflag, from_tty);
5576 else if (ex_event == EX_EVENT_THROW)
5578 /* Set a breakpoint on __raise_exception () */
5580 warning ("Unsupported with this platform/compiler combination.");
5581 warning ("Perhaps you can achieve the effect you want by setting");
5582 warning ("a breakpoint on __raise_exception().");
5587 /* Cover routine to allow wrapping target_enable_exception_catchpoints
5588 inside a catch_errors */
5591 cover_target_enable_exception_callback (arg)
5594 args_for_catchpoint_enable *args = arg;
5595 struct symtab_and_line *sal;
5596 sal = target_enable_exception_callback (args->kind, args->enable);
5599 else if (sal == (struct symtab_and_line *) -1)
5602 return 1; /*is valid */
5607 /* This is the original v.4.16 and earlier version of the
5608 catch_command_1() function. Now that other flavours of "catch"
5609 have been introduced, and since exception handling can be handled
5610 in other ways (through target ops) also, this is used only for the
5611 GNU C++ exception handling system.
5612 Note: Only the "catch" flavour of GDB 4.16 is handled here. The
5613 "catch NAME" is now no longer allowed in catch_command_1(). Also,
5614 there was no code in GDB 4.16 for "catch throw".
5616 Called from catch_exception_command_1 () */
5620 handle_gnu_4_16_catch_command (arg, tempflag, from_tty)
5625 /* First, translate ARG into something we can deal with in terms
5628 struct symtabs_and_lines sals;
5629 struct symtab_and_line sal;
5630 register struct expression *cond = 0;
5631 register struct breakpoint *b;
5635 INIT_SAL (&sal); /* initialize to zeroes */
5637 /* If no arg given, or if first arg is 'if ', all active catch clauses
5638 are breakpointed. */
5640 if (!arg || (arg[0] == 'i' && arg[1] == 'f'
5641 && (arg[2] == ' ' || arg[2] == '\t')))
5643 /* Grab all active catch clauses. */
5644 sals = get_catch_sals (0);
5648 /* Grab selected catch clauses. */
5649 error ("catch NAME not implemented");
5652 /* Not sure why this code has been disabled. I'm leaving
5653 it disabled. We can never come here now anyway
5654 since we don't allow the "catch NAME" syntax.
5657 /* This isn't used; I don't know what it was for. */
5658 sals = map_catch_names (arg, catch_breakpoint);
5666 for (i = 0; i < sals.nelts; i++)
5668 resolve_sal_pc (&sals.sals[i]);
5672 if (arg[0] == 'i' && arg[1] == 'f'
5673 && (arg[2] == ' ' || arg[2] == '\t'))
5674 cond = parse_exp_1 ((arg += 2, &arg),
5675 block_for_pc (sals.sals[i].pc), 0);
5677 error ("Junk at end of arguments.");
5682 for (i = 0; i < sals.nelts; i++)
5687 describe_other_breakpoints (sal.pc, sal.section);
5689 b = set_raw_breakpoint (sal);
5690 set_breakpoint_count (breakpoint_count + 1);
5691 b->number = breakpoint_count;
5693 /* Important -- this is an ordinary breakpoint. For platforms
5694 with callback support for exceptions,
5695 create_exception_catchpoint() will create special bp types
5696 (bp_catch_catch and bp_catch_throw), and there is code in
5697 insert_breakpoints() and elsewhere that depends on that. */
5698 b->type = bp_breakpoint;
5701 b->enable = enabled;
5702 b->disposition = tempflag ? del : donttouch;
5709 warning ("Multiple breakpoints were set.");
5710 warning ("Use the \"delete\" command to delete unwanted breakpoints.");
5712 free ((PTR) sals.sals);
5716 /* This creates a temporary internal breakpoint
5717 just to placate infrun */
5718 static struct breakpoint *
5719 create_temp_exception_breakpoint (pc)
5722 struct symtab_and_line sal;
5723 struct breakpoint *b;
5730 b = set_raw_breakpoint (sal);
5732 error ("Internal error -- couldn't set temp exception breakpoint");
5734 b->type = bp_breakpoint;
5735 b->disposition = del;
5736 b->enable = enabled;
5738 b->number = internal_breakpoint_number--;
5744 catch_command_1 (arg, tempflag, from_tty)
5750 /* The first argument may be an event name, such as "start" or "load".
5751 If so, then handle it as such. If it doesn't match an event name,
5752 then attempt to interpret it as an exception name. (This latter is
5753 the v4.16-and-earlier GDB meaning of the "catch" command.)
5755 First, try to find the bounds of what might be an event name. */
5756 char *arg1_start = arg;
5760 if (arg1_start == NULL)
5762 /* Old behaviour was to use pre-v-4.16 syntax */
5763 /* catch_throw_command_1 (arg1_start, tempflag, from_tty); */
5765 /* Now, this is not allowed */
5766 error ("Catch requires an event name.");
5769 arg1_end = ep_find_event_name_end (arg1_start);
5770 if (arg1_end == NULL)
5771 error ("catch requires an event");
5772 arg1_length = arg1_end + 1 - arg1_start;
5774 /* Try to match what we found against known event names. */
5775 if (strncmp (arg1_start, "signal", arg1_length) == 0)
5777 error ("Catch of signal not yet implemented");
5779 else if (strncmp (arg1_start, "catch", arg1_length) == 0)
5781 catch_exception_command_1 (EX_EVENT_CATCH, arg1_end + 1,
5782 tempflag, from_tty);
5784 else if (strncmp (arg1_start, "throw", arg1_length) == 0)
5786 catch_exception_command_1 (EX_EVENT_THROW, arg1_end + 1,
5787 tempflag, from_tty);
5789 else if (strncmp (arg1_start, "thread_start", arg1_length) == 0)
5791 error ("Catch of thread_start not yet implemented");
5793 else if (strncmp (arg1_start, "thread_exit", arg1_length) == 0)
5795 error ("Catch of thread_exit not yet implemented");
5797 else if (strncmp (arg1_start, "thread_join", arg1_length) == 0)
5799 error ("Catch of thread_join not yet implemented");
5801 else if (strncmp (arg1_start, "start", arg1_length) == 0)
5803 error ("Catch of start not yet implemented");
5805 else if (strncmp (arg1_start, "exit", arg1_length) == 0)
5807 error ("Catch of exit not yet implemented");
5809 else if (strncmp (arg1_start, "fork", arg1_length) == 0)
5811 #if defined(CHILD_INSERT_FORK_CATCHPOINT)
5812 catch_fork_command_1 (catch_fork, arg1_end + 1, tempflag, from_tty);
5814 error ("Catch of fork not yet implemented");
5817 else if (strncmp (arg1_start, "vfork", arg1_length) == 0)
5819 #if defined(CHILD_INSERT_VFORK_CATCHPOINT)
5820 catch_fork_command_1 (catch_vfork, arg1_end + 1, tempflag, from_tty);
5822 error ("Catch of vfork not yet implemented");
5825 else if (strncmp (arg1_start, "exec", arg1_length) == 0)
5827 #if defined(CHILD_INSERT_EXEC_CATCHPOINT)
5828 catch_exec_command_1 (arg1_end + 1, tempflag, from_tty);
5830 error ("Catch of exec not yet implemented");
5833 else if (strncmp (arg1_start, "load", arg1_length) == 0)
5835 #if defined(SOLIB_ADD)
5836 catch_load_command_1 (arg1_end + 1, tempflag, from_tty);
5838 error ("Catch of load not implemented");
5841 else if (strncmp (arg1_start, "unload", arg1_length) == 0)
5843 #if defined(SOLIB_ADD)
5844 catch_unload_command_1 (arg1_end + 1, tempflag, from_tty);
5846 error ("Catch of load not implemented");
5849 else if (strncmp (arg1_start, "stop", arg1_length) == 0)
5851 error ("Catch of stop not yet implemented");
5854 /* This doesn't appear to be an event name */
5858 /* Pre-v.4.16 behaviour was to treat the argument
5859 as the name of an exception */
5860 /* catch_throw_command_1 (arg1_start, tempflag, from_tty); */
5861 /* Now this is not allowed */
5862 error ("Unknown event kind specified for catch");
5867 /* Used by the gui, could be made a worker for other things. */
5870 set_breakpoint_sal (sal)
5871 struct symtab_and_line sal;
5873 struct breakpoint *b;
5874 b = set_raw_breakpoint (sal);
5875 set_breakpoint_count (breakpoint_count + 1);
5876 b->number = breakpoint_count;
5877 b->type = bp_breakpoint;
5884 /* These aren't used; I don't know what they were for. */
5885 /* Disable breakpoints on all catch clauses described in ARGS. */
5887 disable_catch (args)
5890 /* Map the disable command to catch clauses described in ARGS. */
5893 /* Enable breakpoints on all catch clauses described in ARGS. */
5898 /* Map the disable command to catch clauses described in ARGS. */
5901 /* Delete breakpoints on all catch clauses in the active scope. */
5906 /* Map the delete command to catch clauses described in ARGS. */
5911 catch_command (arg, from_tty)
5915 catch_command_1 (arg, 0, from_tty);
5920 tcatch_command (arg, from_tty)
5924 catch_command_1 (arg, 1, from_tty);
5929 clear_command (arg, from_tty)
5933 register struct breakpoint *b, *b1;
5935 struct symtabs_and_lines sals;
5936 struct symtab_and_line sal;
5937 register struct breakpoint *found;
5942 sals = decode_line_spec (arg, 1);
5947 sals.sals = (struct symtab_and_line *)
5948 xmalloc (sizeof (struct symtab_and_line));
5949 INIT_SAL (&sal); /* initialize to zeroes */
5950 sal.line = default_breakpoint_line;
5951 sal.symtab = default_breakpoint_symtab;
5952 sal.pc = default_breakpoint_address;
5953 if (sal.symtab == 0)
5954 error ("No source file specified.");
5962 /* For each line spec given, delete bps which correspond
5963 to it. We do this in two loops: the first loop looks at
5964 the initial bp(s) in the chain which should be deleted,
5965 the second goes down the rest of the chain looking ahead
5966 one so it can take those bps off the chain without messing
5970 for (i = 0; i < sals.nelts; i++)
5972 /* If exact pc given, clear bpts at that pc.
5973 If line given (pc == 0), clear all bpts on specified line.
5974 If defaulting, clear all bpts on default line
5977 defaulting sal.pc != 0 tests to do
5982 1 0 <can't happen> */
5985 found = (struct breakpoint *) 0;
5988 while (breakpoint_chain
5989 /* Why don't we check here that this is not
5990 a watchpoint, etc., as we do below?
5991 I can't make it fail, but don't know
5992 what's stopping the failure: a watchpoint
5993 of the same address as "sal.pc" should
5994 wind up being deleted. */
5996 && (((sal.pc && (breakpoint_chain->address == sal.pc)) &&
5997 (overlay_debugging == 0 ||
5998 breakpoint_chain->section == sal.section))
5999 || ((default_match || (0 == sal.pc))
6000 && breakpoint_chain->source_file != NULL
6001 && sal.symtab != NULL
6002 && STREQ (breakpoint_chain->source_file, sal.symtab->filename)
6003 && breakpoint_chain->line_number == sal.line)))
6006 b1 = breakpoint_chain;
6007 breakpoint_chain = b1->next;
6015 && b->next->type != bp_none
6016 && b->next->type != bp_watchpoint
6017 && b->next->type != bp_hardware_watchpoint
6018 && b->next->type != bp_read_watchpoint
6019 && b->next->type != bp_access_watchpoint
6020 && (((sal.pc && (b->next->address == sal.pc)) &&
6021 (overlay_debugging == 0 ||
6022 b->next->section == sal.section))
6023 || ((default_match || (0 == sal.pc))
6024 && b->next->source_file != NULL
6025 && sal.symtab != NULL
6026 && STREQ (b->next->source_file, sal.symtab->filename)
6027 && b->next->line_number == sal.line)))
6040 error ("No breakpoint at %s.", arg);
6042 error ("No breakpoint at this line.");
6046 from_tty = 1; /* Always report if deleted more than one */
6048 printf_unfiltered ("Deleted breakpoint%s ", found->next ? "s" : "");
6049 breakpoints_changed ();
6053 printf_unfiltered ("%d ", found->number);
6055 delete_breakpoint (found);
6059 putchar_unfiltered ('\n');
6061 free ((PTR) sals.sals);
6064 /* Delete breakpoint in BS if they are `delete' breakpoints and
6065 all breakpoints that are marked for deletion, whether hit or not.
6066 This is called after any breakpoint is hit, or after errors. */
6069 breakpoint_auto_delete (bs)
6072 struct breakpoint *b, *temp;
6074 for (; bs; bs = bs->next)
6075 if (bs->breakpoint_at && bs->breakpoint_at->disposition == del
6077 delete_breakpoint (bs->breakpoint_at);
6079 ALL_BREAKPOINTS_SAFE (b, temp)
6081 if (b->disposition == del_at_next_stop)
6082 delete_breakpoint (b);
6086 /* Delete a breakpoint and clean up all traces of it in the data
6090 delete_breakpoint (bpt)
6091 struct breakpoint *bpt;
6093 register struct breakpoint *b;
6097 error ("Internal error (attempted to delete a NULL breakpoint)");
6100 /* Has this bp already been deleted? This can happen because multiple
6101 lists can hold pointers to bp's. bpstat lists are especial culprits.
6103 One example of this happening is a watchpoint's scope bp. When the
6104 scope bp triggers, we notice that the watchpoint is out of scope, and
6105 delete it. We also delete its scope bp. But the scope bp is marked
6106 "auto-deleting", and is already on a bpstat. That bpstat is then
6107 checked for auto-deleting bp's, which are deleted.
6109 A real solution to this problem might involve reference counts in bp's,
6110 and/or giving them pointers back to their referencing bpstat's, and
6111 teaching delete_breakpoint to only free a bp's storage when no more
6112 references were extent. A cheaper bandaid was chosen. */
6113 if (bpt->type == bp_none)
6116 if (delete_breakpoint_hook)
6117 delete_breakpoint_hook (bpt);
6118 breakpoint_delete_event (bpt->number);
6121 remove_breakpoint (bpt, mark_uninserted);
6123 if (breakpoint_chain == bpt)
6124 breakpoint_chain = bpt->next;
6126 /* If we have callback-style exception catchpoints, don't go through
6127 the adjustments to the C++ runtime library etc. if the inferior
6128 isn't actually running. target_enable_exception_callback for a
6129 null target ops vector gives an undesirable error message, so we
6130 check here and avoid it. Since currently (1997-09-17) only HP-UX aCC's
6131 exceptions are supported in this way, it's OK for now. FIXME */
6132 if (ep_is_exception_catchpoint (bpt) && target_has_execution)
6134 static char message1[] = "Error in deleting catchpoint %d:\n";
6135 static char message[sizeof (message1) + 30];
6136 args_for_catchpoint_enable args;
6138 /* Format possible error msg */
6139 sprintf (message, message1, bpt->number);
6140 args.kind = bpt->type == bp_catch_catch ?
6141 EX_EVENT_CATCH : EX_EVENT_THROW;
6143 catch_errors (cover_target_enable_exception_callback, &args,
6144 message, RETURN_MASK_ALL);
6151 b->next = bpt->next;
6155 /* Before turning off the visuals for the bp, check to see that
6156 there are no other bps at the same address. */
6163 clearIt = (b->address != bpt->address);
6170 TUIDO (((TuiOpaqueFuncPtr) tui_vAllSetHasBreakAt, bpt, 0));
6171 TUIDO (((TuiOpaqueFuncPtr) tuiUpdateAllExecInfos));
6175 check_duplicates (bpt->address, bpt->section);
6176 /* If this breakpoint was inserted, and there is another breakpoint
6177 at the same address, we need to insert the other breakpoint. */
6179 && bpt->type != bp_hardware_watchpoint
6180 && bpt->type != bp_read_watchpoint
6181 && bpt->type != bp_access_watchpoint
6182 && bpt->type != bp_catch_fork
6183 && bpt->type != bp_catch_vfork
6184 && bpt->type != bp_catch_exec)
6187 if (b->address == bpt->address
6188 && b->section == bpt->section
6190 && b->enable != disabled
6191 && b->enable != shlib_disabled
6192 && b->enable != call_disabled)
6196 /* We should never reach this point if there is a permanent
6197 breakpoint at the same address as the one being deleted.
6198 If there is a permanent breakpoint somewhere, it should
6199 always be the only one inserted. */
6200 if (b->enable == permanent)
6201 internal_error ("another breakpoint was inserted on top of "
6202 "a permanent breakpoint");
6204 if (b->type == bp_hardware_breakpoint)
6205 val = target_insert_hw_breakpoint (b->address, b->shadow_contents);
6207 val = target_insert_breakpoint (b->address, b->shadow_contents);
6211 target_terminal_ours_for_output ();
6212 warning ("Cannot insert breakpoint %d:", b->number);
6213 memory_error (val, b->address); /* which bombs us out */
6220 free_command_lines (&bpt->commands);
6223 if (bpt->cond_string != NULL)
6224 free (bpt->cond_string);
6225 if (bpt->addr_string != NULL)
6226 free (bpt->addr_string);
6227 if (bpt->exp != NULL)
6229 if (bpt->exp_string != NULL)
6230 free (bpt->exp_string);
6231 if (bpt->val != NULL)
6232 value_free (bpt->val);
6233 if (bpt->source_file != NULL)
6234 free (bpt->source_file);
6235 if (bpt->dll_pathname != NULL)
6236 free (bpt->dll_pathname);
6237 if (bpt->triggered_dll_pathname != NULL)
6238 free (bpt->triggered_dll_pathname);
6239 if (bpt->exec_pathname != NULL)
6240 free (bpt->exec_pathname);
6242 /* Be sure no bpstat's are pointing at it after it's been freed. */
6243 /* FIXME, how can we find all bpstat's?
6244 We just check stop_bpstat for now. */
6245 for (bs = stop_bpstat; bs; bs = bs->next)
6246 if (bs->breakpoint_at == bpt)
6248 bs->breakpoint_at = NULL;
6250 /* we'd call bpstat_clear_actions, but that free's stuff and due
6251 to the multiple pointers pointing to one item with no
6252 reference counts found anywhere through out the bpstat's (how
6253 do you spell fragile?), we don't want to free things twice --
6254 better a memory leak than a corrupt malloc pool! */
6255 bs->commands = NULL;
6258 /* On the chance that someone will soon try again to delete this same
6259 bp, we mark it as deleted before freeing its storage. */
6260 bpt->type = bp_none;
6266 delete_command (arg, from_tty)
6270 struct breakpoint *b, *temp;
6274 int breaks_to_delete = 0;
6276 /* Delete all breakpoints if no argument.
6277 Do not delete internal or call-dummy breakpoints, these
6278 have to be deleted with an explicit breakpoint number argument. */
6281 if (b->type != bp_call_dummy &&
6282 b->type != bp_shlib_event &&
6284 breaks_to_delete = 1;
6287 /* Ask user only if there are some breakpoints to delete. */
6289 || (breaks_to_delete && query ("Delete all breakpoints? ")))
6291 ALL_BREAKPOINTS_SAFE (b, temp)
6293 if (b->type != bp_call_dummy &&
6294 b->type != bp_shlib_event &&
6296 delete_breakpoint (b);
6301 map_breakpoint_numbers (arg, delete_breakpoint);
6304 /* Reset a breakpoint given it's struct breakpoint * BINT.
6305 The value we return ends up being the return value from catch_errors.
6306 Unused in this case. */
6309 breakpoint_re_set_one (bint)
6312 /* get past catch_errs */
6313 struct breakpoint *b = (struct breakpoint *) bint;
6316 struct symtabs_and_lines sals;
6318 enum enable save_enable;
6323 warning ("attempted to reset apparently deleted breakpoint #%d?",
6327 case bp_hardware_breakpoint:
6329 case bp_catch_unload:
6330 if (b->addr_string == NULL)
6332 /* Anything without a string can't be re-set. */
6333 delete_breakpoint (b);
6336 /* In case we have a problem, disable this breakpoint. We'll restore
6337 its status if we succeed. */
6338 save_enable = b->enable;
6339 b->enable = disabled;
6341 set_language (b->language);
6342 input_radix = b->input_radix;
6344 sals = decode_line_1 (&s, 1, (struct symtab *) NULL, 0, (char ***) NULL);
6345 for (i = 0; i < sals.nelts; i++)
6347 resolve_sal_pc (&sals.sals[i]);
6349 /* Reparse conditions, they might contain references to the
6351 if (b->cond_string != NULL)
6355 free ((PTR) b->cond);
6356 b->cond = parse_exp_1 (&s, block_for_pc (sals.sals[i].pc), 0);
6359 /* We need to re-set the breakpoint if the address changes... */
6360 if (b->address != sals.sals[i].pc
6361 /* ...or new and old breakpoints both have source files, and
6362 the source file name or the line number changes... */
6363 || (b->source_file != NULL
6364 && sals.sals[i].symtab != NULL
6365 && (!STREQ (b->source_file, sals.sals[i].symtab->filename)
6366 || b->line_number != sals.sals[i].line)
6368 /* ...or we switch between having a source file and not having
6370 || ((b->source_file == NULL) != (sals.sals[i].symtab == NULL))
6373 if (b->source_file != NULL)
6374 free (b->source_file);
6375 if (sals.sals[i].symtab == NULL)
6376 b->source_file = NULL;
6379 savestring (sals.sals[i].symtab->filename,
6380 strlen (sals.sals[i].symtab->filename));
6381 b->line_number = sals.sals[i].line;
6382 b->address = sals.sals[i].pc;
6384 /* Used to check for duplicates here, but that can
6385 cause trouble, as it doesn't check for disable
6390 /* Might be better to do this just once per breakpoint_re_set,
6391 rather than once for every breakpoint. */
6392 breakpoints_changed ();
6394 b->section = sals.sals[i].section;
6395 b->enable = save_enable; /* Restore it, this worked. */
6398 /* Now that this is re-enabled, check_duplicates
6400 check_duplicates (b->address, b->section);
6403 free ((PTR) sals.sals);
6407 case bp_hardware_watchpoint:
6408 case bp_read_watchpoint:
6409 case bp_access_watchpoint:
6410 innermost_block = NULL;
6411 /* The issue arises of what context to evaluate this in. The
6412 same one as when it was set, but what does that mean when
6413 symbols have been re-read? We could save the filename and
6414 functionname, but if the context is more local than that, the
6415 best we could do would be something like how many levels deep
6416 and which index at that particular level, but that's going to
6417 be less stable than filenames or function names. */
6419 /* So for now, just use a global context. */
6421 free ((PTR) b->exp);
6422 b->exp = parse_expression (b->exp_string);
6423 b->exp_valid_block = innermost_block;
6424 mark = value_mark ();
6426 value_free (b->val);
6427 b->val = evaluate_expression (b->exp);
6428 release_value (b->val);
6429 if (VALUE_LAZY (b->val))
6430 value_fetch_lazy (b->val);
6432 if (b->cond_string != NULL)
6436 free ((PTR) b->cond);
6437 b->cond = parse_exp_1 (&s, (struct block *) 0, 0);
6439 if (b->enable == enabled)
6441 value_free_to_mark (mark);
6443 case bp_catch_catch:
6444 case bp_catch_throw:
6446 /* We needn't really do anything to reset these, since the mask
6447 that requests them is unaffected by e.g., new libraries being
6450 case bp_catch_vfork:
6455 printf_filtered ("Deleting unknown breakpoint type %d\n", b->type);
6457 /* Delete longjmp breakpoints, they will be reset later by
6458 breakpoint_re_set. */
6460 case bp_longjmp_resume:
6461 delete_breakpoint (b);
6464 /* This breakpoint is special, it's set up when the inferior
6465 starts and we really don't want to touch it. */
6466 case bp_shlib_event:
6468 /* Keep temporary breakpoints, which can be encountered when we step
6469 over a dlopen call and SOLIB_ADD is resetting the breakpoints.
6470 Otherwise these should have been blown away via the cleanup chain
6471 or by breakpoint_init_inferior when we rerun the executable. */
6474 case bp_watchpoint_scope:
6476 case bp_step_resume:
6483 /* Re-set all breakpoints after symbols have been re-loaded. */
6485 breakpoint_re_set ()
6487 struct breakpoint *b, *temp;
6488 enum language save_language;
6489 int save_input_radix;
6490 static char message1[] = "Error in re-setting breakpoint %d:\n";
6491 char message[sizeof (message1) + 30 /* slop */ ];
6493 save_language = current_language->la_language;
6494 save_input_radix = input_radix;
6495 ALL_BREAKPOINTS_SAFE (b, temp)
6497 /* Format possible error msg */
6498 sprintf (message, message1, b->number);
6499 catch_errors (breakpoint_re_set_one, b, message, RETURN_MASK_ALL);
6501 set_language (save_language);
6502 input_radix = save_input_radix;
6504 #ifdef GET_LONGJMP_TARGET
6505 create_longjmp_breakpoint ("longjmp");
6506 create_longjmp_breakpoint ("_longjmp");
6507 create_longjmp_breakpoint ("siglongjmp");
6508 create_longjmp_breakpoint ("_siglongjmp");
6509 create_longjmp_breakpoint (NULL);
6513 /* Took this out (temporarily at least), since it produces an extra
6514 blank line at startup. This messes up the gdbtests. -PB */
6515 /* Blank line to finish off all those mention() messages we just printed. */
6516 printf_filtered ("\n");
6520 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
6521 If from_tty is nonzero, it prints a message to that effect,
6522 which ends with a period (no newline). */
6524 /* Reset the thread number of this breakpoint:
6526 - If the breakpoint is for all threads, leave it as-is.
6527 - Else, reset it to the current thread for inferior_pid. */
6529 breakpoint_re_set_thread (b)
6530 struct breakpoint *b;
6532 if (b->thread != -1)
6534 if (in_thread_list (inferior_pid))
6535 b->thread = pid_to_thread_id (inferior_pid);
6540 set_ignore_count (bptnum, count, from_tty)
6541 int bptnum, count, from_tty;
6543 register struct breakpoint *b;
6549 if (b->number == bptnum)
6551 b->ignore_count = count;
6554 else if (count == 0)
6555 printf_filtered ("Will stop next time breakpoint %d is reached.",
6557 else if (count == 1)
6558 printf_filtered ("Will ignore next crossing of breakpoint %d.",
6561 printf_filtered ("Will ignore next %d crossings of breakpoint %d.",
6563 breakpoints_changed ();
6567 error ("No breakpoint number %d.", bptnum);
6570 /* Clear the ignore counts of all breakpoints. */
6572 breakpoint_clear_ignore_counts ()
6574 struct breakpoint *b;
6577 b->ignore_count = 0;
6580 /* Command to set ignore-count of breakpoint N to COUNT. */
6583 ignore_command (args, from_tty)
6591 error_no_arg ("a breakpoint number");
6593 num = get_number (&p);
6595 error ("bad breakpoint number: '%s'", args);
6597 error ("Second argument (specified ignore-count) is missing.");
6599 set_ignore_count (num,
6600 longest_to_int (value_as_long (parse_and_eval (p))),
6602 printf_filtered ("\n");
6603 breakpoints_changed ();
6606 /* Call FUNCTION on each of the breakpoints
6607 whose numbers are given in ARGS. */
6610 map_breakpoint_numbers (args, function)
6612 void (*function) PARAMS ((struct breakpoint *));
6614 register char *p = args;
6617 register struct breakpoint *b, *tmp;
6621 error_no_arg ("one or more breakpoint numbers");
6628 num = get_number_or_range (&p1);
6631 warning ("bad breakpoint number at or near '%s'", p);
6635 ALL_BREAKPOINTS_SAFE (b, tmp)
6636 if (b->number == num)
6638 struct breakpoint *related_breakpoint = b->related_breakpoint;
6641 if (related_breakpoint)
6642 function (related_breakpoint);
6646 printf_unfiltered ("No breakpoint number %d.\n", num);
6653 disable_breakpoint (bpt)
6654 struct breakpoint *bpt;
6656 /* Never disable a watchpoint scope breakpoint; we want to
6657 hit them when we leave scope so we can delete both the
6658 watchpoint and its scope breakpoint at that time. */
6659 if (bpt->type == bp_watchpoint_scope)
6662 /* You can't disable permanent breakpoints. */
6663 if (bpt->enable == permanent)
6666 bpt->enable = disabled;
6668 check_duplicates (bpt->address, bpt->section);
6670 if (modify_breakpoint_hook)
6671 modify_breakpoint_hook (bpt);
6672 breakpoint_modify_event (bpt->number);
6677 disable_command (args, from_tty)
6681 register struct breakpoint *bpt;
6683 ALL_BREAKPOINTS (bpt)
6687 warning ("attempted to disable apparently deleted breakpoint #%d?",
6692 case bp_catch_unload:
6694 case bp_catch_vfork:
6696 case bp_catch_catch:
6697 case bp_catch_throw:
6698 case bp_hardware_breakpoint:
6700 case bp_hardware_watchpoint:
6701 case bp_read_watchpoint:
6702 case bp_access_watchpoint:
6703 disable_breakpoint (bpt);
6708 map_breakpoint_numbers (args, disable_breakpoint);
6712 do_enable_breakpoint (bpt, disposition)
6713 struct breakpoint *bpt;
6714 enum bpdisp disposition;
6716 struct frame_info *save_selected_frame = NULL;
6717 int save_selected_frame_level = -1;
6718 int target_resources_ok, other_type_used;
6721 if (bpt->type == bp_hardware_breakpoint)
6724 i = hw_breakpoint_used_count ();
6725 target_resources_ok =
6726 TARGET_CAN_USE_HARDWARE_WATCHPOINT (bp_hardware_breakpoint,
6728 if (target_resources_ok == 0)
6729 error ("No hardware breakpoint support in the target.");
6730 else if (target_resources_ok < 0)
6731 error ("Hardware breakpoints used exceeds limit.");
6734 if (bpt->enable != permanent)
6735 bpt->enable = enabled;
6736 bpt->disposition = disposition;
6737 check_duplicates (bpt->address, bpt->section);
6738 breakpoints_changed ();
6740 if (bpt->type == bp_watchpoint ||
6741 bpt->type == bp_hardware_watchpoint ||
6742 bpt->type == bp_read_watchpoint ||
6743 bpt->type == bp_access_watchpoint)
6745 if (bpt->exp_valid_block != NULL)
6747 struct frame_info *fr =
6749 /* Ensure that we have the current frame. Else, this
6750 next query may pessimistically be answered as, "No,
6751 not within current scope". */
6752 get_current_frame ();
6753 fr = find_frame_addr_in_frame_chain (bpt->watchpoint_frame);
6757 Cannot enable watchpoint %d because the block in which its expression\n\
6758 is valid is not currently in scope.\n", bpt->number);
6759 bpt->enable = disabled;
6763 save_selected_frame = selected_frame;
6764 save_selected_frame_level = selected_frame_level;
6765 select_frame (fr, -1);
6768 value_free (bpt->val);
6769 mark = value_mark ();
6770 bpt->val = evaluate_expression (bpt->exp);
6771 release_value (bpt->val);
6772 if (VALUE_LAZY (bpt->val))
6773 value_fetch_lazy (bpt->val);
6775 if (bpt->type == bp_hardware_watchpoint ||
6776 bpt->type == bp_read_watchpoint ||
6777 bpt->type == bp_access_watchpoint)
6779 int i = hw_watchpoint_used_count (bpt->type, &other_type_used);
6780 int mem_cnt = can_use_hardware_watchpoint (bpt->val);
6782 /* Hack around 'unused var' error for some targets here */
6784 target_resources_ok = TARGET_CAN_USE_HARDWARE_WATCHPOINT (
6785 bpt->type, i + mem_cnt, other_type_used);
6786 /* we can consider of type is bp_hardware_watchpoint, convert to
6787 bp_watchpoint in the following condition */
6788 if (target_resources_ok < 0)
6791 Cannot enable watchpoint %d because target watch resources\n\
6792 have been allocated for other watchpoints.\n", bpt->number);
6793 bpt->enable = disabled;
6794 value_free_to_mark (mark);
6799 if (save_selected_frame_level >= 0)
6800 select_and_print_frame (save_selected_frame,
6801 save_selected_frame_level);
6802 value_free_to_mark (mark);
6804 if (modify_breakpoint_hook)
6805 modify_breakpoint_hook (bpt);
6806 breakpoint_modify_event (bpt->number);
6810 enable_breakpoint (bpt)
6811 struct breakpoint *bpt;
6813 do_enable_breakpoint (bpt, bpt->disposition);
6816 /* The enable command enables the specified breakpoints (or all defined
6817 breakpoints) so they once again become (or continue to be) effective
6818 in stopping the inferior. */
6822 enable_command (args, from_tty)
6826 register struct breakpoint *bpt;
6828 ALL_BREAKPOINTS (bpt)
6832 warning ("attempted to enable apparently deleted breakpoint #%d?",
6837 case bp_catch_unload:
6839 case bp_catch_vfork:
6841 case bp_catch_catch:
6842 case bp_catch_throw:
6843 case bp_hardware_breakpoint:
6845 case bp_hardware_watchpoint:
6846 case bp_read_watchpoint:
6847 case bp_access_watchpoint:
6848 enable_breakpoint (bpt);
6853 map_breakpoint_numbers (args, enable_breakpoint);
6857 enable_once_breakpoint (bpt)
6858 struct breakpoint *bpt;
6860 do_enable_breakpoint (bpt, disable);
6865 enable_once_command (args, from_tty)
6869 map_breakpoint_numbers (args, enable_once_breakpoint);
6873 enable_delete_breakpoint (bpt)
6874 struct breakpoint *bpt;
6876 do_enable_breakpoint (bpt, del);
6881 enable_delete_command (args, from_tty)
6885 map_breakpoint_numbers (args, enable_delete_breakpoint);
6888 /* Use default_breakpoint_'s, or nothing if they aren't valid. */
6890 struct symtabs_and_lines
6891 decode_line_spec_1 (string, funfirstline)
6895 struct symtabs_and_lines sals;
6897 error ("Empty line specification.");
6898 if (default_breakpoint_valid)
6899 sals = decode_line_1 (&string, funfirstline,
6900 default_breakpoint_symtab,
6901 default_breakpoint_line,
6904 sals = decode_line_1 (&string, funfirstline,
6905 (struct symtab *) NULL, 0, (char ***) NULL);
6907 error ("Junk at end of line specification: %s", string);
6912 _initialize_breakpoint ()
6914 struct cmd_list_element *c;
6916 breakpoint_chain = 0;
6917 /* Don't bother to call set_breakpoint_count. $bpnum isn't useful
6918 before a breakpoint is set. */
6919 breakpoint_count = 0;
6921 add_com ("ignore", class_breakpoint, ignore_command,
6922 "Set ignore-count of breakpoint number N to COUNT.\n\
6923 Usage is `ignore N COUNT'.");
6925 add_com_alias ("bc", "ignore", class_breakpoint, 1);
6927 add_com ("commands", class_breakpoint, commands_command,
6928 "Set commands to be executed when a breakpoint is hit.\n\
6929 Give breakpoint number as argument after \"commands\".\n\
6930 With no argument, the targeted breakpoint is the last one set.\n\
6931 The commands themselves follow starting on the next line.\n\
6932 Type a line containing \"end\" to indicate the end of them.\n\
6933 Give \"silent\" as the first line to make the breakpoint silent;\n\
6934 then no output is printed when it is hit, except what the commands print.");
6936 add_com ("condition", class_breakpoint, condition_command,
6937 "Specify breakpoint number N to break only if COND is true.\n\
6938 Usage is `condition N COND', where N is an integer and COND is an\n\
6939 expression to be evaluated whenever breakpoint N is reached. ");
6941 add_com ("tbreak", class_breakpoint, tbreak_command,
6942 "Set a temporary breakpoint. Args like \"break\" command.\n\
6943 Like \"break\" except the breakpoint is only temporary,\n\
6944 so it will be deleted when hit. Equivalent to \"break\" followed\n\
6945 by using \"enable delete\" on the breakpoint number.");
6946 add_com ("txbreak", class_breakpoint, tbreak_at_finish_command,
6947 "Set temporary breakpoint at procedure exit. Either there should\n\
6948 be no argument or the argument must be a depth.\n");
6950 add_com ("hbreak", class_breakpoint, hbreak_command,
6951 "Set a hardware assisted breakpoint. Args like \"break\" command.\n\
6952 Like \"break\" except the breakpoint requires hardware support,\n\
6953 some target hardware may not have this support.");
6955 add_com ("thbreak", class_breakpoint, thbreak_command,
6956 "Set a temporary hardware assisted breakpoint. Args like \"break\" command.\n\
6957 Like \"hbreak\" except the breakpoint is only temporary,\n\
6958 so it will be deleted when hit.");
6960 add_prefix_cmd ("enable", class_breakpoint, enable_command,
6961 "Enable some breakpoints.\n\
6962 Give breakpoint numbers (separated by spaces) as arguments.\n\
6963 With no subcommand, breakpoints are enabled until you command otherwise.\n\
6964 This is used to cancel the effect of the \"disable\" command.\n\
6965 With a subcommand you can enable temporarily.",
6966 &enablelist, "enable ", 1, &cmdlist);
6968 add_com ("ab", class_breakpoint, enable_command,
6969 "Enable some breakpoints.\n\
6970 Give breakpoint numbers (separated by spaces) as arguments.\n\
6971 With no subcommand, breakpoints are enabled until you command otherwise.\n\
6972 This is used to cancel the effect of the \"disable\" command.\n\
6973 With a subcommand you can enable temporarily.");
6975 add_com_alias ("en", "enable", class_breakpoint, 1);
6977 add_abbrev_prefix_cmd ("breakpoints", class_breakpoint, enable_command,
6978 "Enable some breakpoints.\n\
6979 Give breakpoint numbers (separated by spaces) as arguments.\n\
6980 This is used to cancel the effect of the \"disable\" command.\n\
6981 May be abbreviated to simply \"enable\".\n",
6982 &enablebreaklist, "enable breakpoints ", 1, &enablelist);
6984 add_cmd ("once", no_class, enable_once_command,
6985 "Enable breakpoints for one hit. Give breakpoint numbers.\n\
6986 If a breakpoint is hit while enabled in this fashion, it becomes disabled.",
6989 add_cmd ("delete", no_class, enable_delete_command,
6990 "Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
6991 If a breakpoint is hit while enabled in this fashion, it is deleted.",
6994 add_cmd ("delete", no_class, enable_delete_command,
6995 "Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
6996 If a breakpoint is hit while enabled in this fashion, it is deleted.",
6999 add_cmd ("once", no_class, enable_once_command,
7000 "Enable breakpoints for one hit. Give breakpoint numbers.\n\
7001 If a breakpoint is hit while enabled in this fashion, it becomes disabled.",
7004 add_prefix_cmd ("disable", class_breakpoint, disable_command,
7005 "Disable some breakpoints.\n\
7006 Arguments are breakpoint numbers with spaces in between.\n\
7007 To disable all breakpoints, give no argument.\n\
7008 A disabled breakpoint is not forgotten, but has no effect until reenabled.",
7009 &disablelist, "disable ", 1, &cmdlist);
7010 add_com_alias ("dis", "disable", class_breakpoint, 1);
7011 add_com_alias ("disa", "disable", class_breakpoint, 1);
7013 add_com ("sb", class_breakpoint, disable_command,
7014 "Disable some breakpoints.\n\
7015 Arguments are breakpoint numbers with spaces in between.\n\
7016 To disable all breakpoints, give no argument.\n\
7017 A disabled breakpoint is not forgotten, but has no effect until reenabled.");
7019 add_cmd ("breakpoints", class_alias, disable_command,
7020 "Disable some breakpoints.\n\
7021 Arguments are breakpoint numbers with spaces in between.\n\
7022 To disable all breakpoints, give no argument.\n\
7023 A disabled breakpoint is not forgotten, but has no effect until reenabled.\n\
7024 This command may be abbreviated \"disable\".",
7027 add_prefix_cmd ("delete", class_breakpoint, delete_command,
7028 "Delete some breakpoints or auto-display expressions.\n\
7029 Arguments are breakpoint numbers with spaces in between.\n\
7030 To delete all breakpoints, give no argument.\n\
7032 Also a prefix command for deletion of other GDB objects.\n\
7033 The \"unset\" command is also an alias for \"delete\".",
7034 &deletelist, "delete ", 1, &cmdlist);
7035 add_com_alias ("d", "delete", class_breakpoint, 1);
7037 add_com ("db", class_breakpoint, delete_command,
7038 "Delete some breakpoints.\n\
7039 Arguments are breakpoint numbers with spaces in between.\n\
7040 To delete all breakpoints, give no argument.\n");
7042 add_cmd ("breakpoints", class_alias, delete_command,
7043 "Delete some breakpoints or auto-display expressions.\n\
7044 Arguments are breakpoint numbers with spaces in between.\n\
7045 To delete all breakpoints, give no argument.\n\
7046 This command may be abbreviated \"delete\".",
7049 add_com ("clear", class_breakpoint, clear_command,
7050 concat ("Clear breakpoint at specified line or function.\n\
7051 Argument may be line number, function name, or \"*\" and an address.\n\
7052 If line number is specified, all breakpoints in that line are cleared.\n\
7053 If function is specified, breakpoints at beginning of function are cleared.\n\
7054 If an address is specified, breakpoints at that address are cleared.\n\n",
7055 "With no argument, clears all breakpoints in the line that the selected frame\n\
7058 See also the \"delete\" command which clears breakpoints by number.", NULL));
7060 add_com ("break", class_breakpoint, break_command,
7061 concat ("Set breakpoint at specified line or function.\n\
7062 Argument may be line number, function name, or \"*\" and an address.\n\
7063 If line number is specified, break at start of code for that line.\n\
7064 If function is specified, break at start of code for that function.\n\
7065 If an address is specified, break at that exact address.\n",
7066 "With no arg, uses current execution address of selected stack frame.\n\
7067 This is useful for breaking on return to a stack frame.\n\
7069 Multiple breakpoints at one place are permitted, and useful if conditional.\n\
7071 Do \"help breakpoints\" for info on other commands dealing with breakpoints.", NULL));
7072 add_com_alias ("b", "break", class_run, 1);
7073 add_com_alias ("br", "break", class_run, 1);
7074 add_com_alias ("bre", "break", class_run, 1);
7075 add_com_alias ("brea", "break", class_run, 1);
7077 add_com ("xbreak", class_breakpoint, break_at_finish_command,
7078 concat ("Set breakpoint at procedure exit. \n\
7079 Argument may be function name, or \"*\" and an address.\n\
7080 If function is specified, break at end of code for that function.\n\
7081 If an address is specified, break at the end of the function that contains \n\
7082 that exact address.\n",
7083 "With no arg, uses current execution address of selected stack frame.\n\
7084 This is useful for breaking on return to a stack frame.\n\
7086 Multiple breakpoints at one place are permitted, and useful if conditional.\n\
7088 Do \"help breakpoints\" for info on other commands dealing with breakpoints.", NULL));
7089 add_com_alias ("xb", "xbreak", class_breakpoint, 1);
7090 add_com_alias ("xbr", "xbreak", class_breakpoint, 1);
7091 add_com_alias ("xbre", "xbreak", class_breakpoint, 1);
7092 add_com_alias ("xbrea", "xbreak", class_breakpoint, 1);
7096 add_com_alias ("ba", "break", class_breakpoint, 1);
7097 add_com_alias ("bu", "ubreak", class_breakpoint, 1);
7098 add_com ("bx", class_breakpoint, break_at_finish_at_depth_command,
7099 "Set breakpoint at procedure exit. Either there should\n\
7100 be no argument or the argument must be a depth.\n");
7105 add_abbrev_prefix_cmd ("stop", class_breakpoint, stop_command,
7106 "Break in function/address or break at a line in the current file.",
7107 &stoplist, "stop ", 1, &cmdlist);
7108 add_cmd ("in", class_breakpoint, stopin_command,
7109 "Break in function or address.\n", &stoplist);
7110 add_cmd ("at", class_breakpoint, stopat_command,
7111 "Break at a line in the current file.\n", &stoplist);
7112 add_com ("status", class_info, breakpoints_info,
7113 concat ("Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
7114 The \"Type\" column indicates one of:\n\
7115 \tbreakpoint - normal breakpoint\n\
7116 \twatchpoint - watchpoint\n\
7117 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
7118 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
7119 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
7120 address and file/line number respectively.\n\n",
7121 "Convenience variable \"$_\" and default examine address for \"x\"\n\
7122 are set to the address of the last breakpoint listed.\n\n\
7123 Convenience variable \"$bpnum\" contains the number of the last\n\
7124 breakpoint set.", NULL));
7127 add_info ("breakpoints", breakpoints_info,
7128 concat ("Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
7129 The \"Type\" column indicates one of:\n\
7130 \tbreakpoint - normal breakpoint\n\
7131 \twatchpoint - watchpoint\n\
7132 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
7133 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
7134 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
7135 address and file/line number respectively.\n\n",
7136 "Convenience variable \"$_\" and default examine address for \"x\"\n\
7137 are set to the address of the last breakpoint listed.\n\n\
7138 Convenience variable \"$bpnum\" contains the number of the last\n\
7139 breakpoint set.", NULL));
7142 add_com ("lb", class_breakpoint, breakpoints_info,
7143 concat ("Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
7144 The \"Type\" column indicates one of:\n\
7145 \tbreakpoint - normal breakpoint\n\
7146 \twatchpoint - watchpoint\n\
7147 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
7148 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
7149 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
7150 address and file/line number respectively.\n\n",
7151 "Convenience variable \"$_\" and default examine address for \"x\"\n\
7152 are set to the address of the last breakpoint listed.\n\n\
7153 Convenience variable \"$bpnum\" contains the number of the last\n\
7154 breakpoint set.", NULL));
7156 add_cmd ("breakpoints", class_maintenance, maintenance_info_breakpoints,
7157 concat ("Status of all breakpoints, or breakpoint number NUMBER.\n\
7158 The \"Type\" column indicates one of:\n\
7159 \tbreakpoint - normal breakpoint\n\
7160 \twatchpoint - watchpoint\n\
7161 \tlongjmp - internal breakpoint used to step through longjmp()\n\
7162 \tlongjmp resume - internal breakpoint at the target of longjmp()\n\
7163 \tuntil - internal breakpoint used by the \"until\" command\n\
7164 \tfinish - internal breakpoint used by the \"finish\" command\n",
7165 "The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
7166 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
7167 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
7168 address and file/line number respectively.\n\n",
7169 "Convenience variable \"$_\" and default examine address for \"x\"\n\
7170 are set to the address of the last breakpoint listed.\n\n\
7171 Convenience variable \"$bpnum\" contains the number of the last\n\
7172 breakpoint set.", NULL),
7173 &maintenanceinfolist);
7175 add_com ("catch", class_breakpoint, catch_command,
7176 "Set catchpoints to catch events.\n\
7177 Raised signals may be caught:\n\
7178 \tcatch signal - all signals\n\
7179 \tcatch signal <signame> - a particular signal\n\
7180 Raised exceptions may be caught:\n\
7181 \tcatch throw - all exceptions, when thrown\n\
7182 \tcatch throw <exceptname> - a particular exception, when thrown\n\
7183 \tcatch catch - all exceptions, when caught\n\
7184 \tcatch catch <exceptname> - a particular exception, when caught\n\
7185 Thread or process events may be caught:\n\
7186 \tcatch thread_start - any threads, just after creation\n\
7187 \tcatch thread_exit - any threads, just before expiration\n\
7188 \tcatch thread_join - any threads, just after joins\n\
7189 Process events may be caught:\n\
7190 \tcatch start - any processes, just after creation\n\
7191 \tcatch exit - any processes, just before expiration\n\
7192 \tcatch fork - calls to fork()\n\
7193 \tcatch vfork - calls to vfork()\n\
7194 \tcatch exec - calls to exec()\n\
7195 Dynamically-linked library events may be caught:\n\
7196 \tcatch load - loads of any library\n\
7197 \tcatch load <libname> - loads of a particular library\n\
7198 \tcatch unload - unloads of any library\n\
7199 \tcatch unload <libname> - unloads of a particular library\n\
7200 The act of your program's execution stopping may also be caught:\n\
7202 C++ exceptions may be caught:\n\
7203 \tcatch throw - all exceptions, when thrown\n\
7204 \tcatch catch - all exceptions, when caught\n\
7206 Do \"help set follow-fork-mode\" for info on debugging your program\n\
7207 after a fork or vfork is caught.\n\n\
7208 Do \"help breakpoints\" for info on other commands dealing with breakpoints.");
7210 add_com ("tcatch", class_breakpoint, tcatch_command,
7211 "Set temporary catchpoints to catch events.\n\
7212 Args like \"catch\" command.\n\
7213 Like \"catch\" except the catchpoint is only temporary,\n\
7214 so it will be deleted when hit. Equivalent to \"catch\" followed\n\
7215 by using \"enable delete\" on the catchpoint number.");
7217 add_com ("watch", class_breakpoint, watch_command,
7218 "Set a watchpoint for an expression.\n\
7219 A watchpoint stops execution of your program whenever the value of\n\
7220 an expression changes.");
7222 add_com ("rwatch", class_breakpoint, rwatch_command,
7223 "Set a read watchpoint for an expression.\n\
7224 A watchpoint stops execution of your program whenever the value of\n\
7225 an expression is read.");
7227 add_com ("awatch", class_breakpoint, awatch_command,
7228 "Set a watchpoint for an expression.\n\
7229 A watchpoint stops execution of your program whenever the value of\n\
7230 an expression is either read or written.");
7232 add_info ("watchpoints", breakpoints_info,
7233 "Synonym for ``info breakpoints''.");
7236 c = add_set_cmd ("can-use-hw-watchpoints", class_support, var_zinteger,
7237 (char *) &can_use_hw_watchpoints,
7238 "Set debugger's willingness to use watchpoint hardware.\n\
7239 If zero, gdb will not use hardware for new watchpoints, even if\n\
7240 such is available. (However, any hardware watchpoints that were\n\
7241 created before setting this to nonzero, will continue to use watchpoint\n\
7244 add_show_from_set (c, &showlist);
7246 can_use_hw_watchpoints = 1;