1 /* Everything about breakpoints, for GDB.
2 Copyright 1986, 87, 89, 90, 91, 92, 93, 94, 95, 96, 97, 1998
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, Boston, MA 02111-1307, USA. */
25 #include "breakpoint.h"
27 #include "expression.h"
33 #include "gdbthread.h"
36 #include "gdb_string.h"
42 /* local function prototypes */
45 catch_command_1 PARAMS ((char *, int, int));
48 enable_delete_command PARAMS ((char *, int));
51 enable_delete_breakpoint PARAMS ((struct breakpoint *));
54 enable_once_command PARAMS ((char *, int));
57 enable_once_breakpoint PARAMS ((struct breakpoint *));
60 disable_command PARAMS ((char *, int));
63 enable_command PARAMS ((char *, int));
66 map_breakpoint_numbers PARAMS ((char *, void (*)(struct breakpoint *)));
69 ignore_command PARAMS ((char *, int));
72 breakpoint_re_set_one PARAMS ((char *));
75 delete_command PARAMS ((char *, int));
78 clear_command PARAMS ((char *, int));
81 catch_command PARAMS ((char *, int));
83 static struct symtabs_and_lines
84 get_catch_sals PARAMS ((int));
87 watch_command PARAMS ((char *, int));
90 can_use_hardware_watchpoint PARAMS ((struct value *));
93 tbreak_command PARAMS ((char *, int));
96 break_command_1 PARAMS ((char *, int, int));
99 mention PARAMS ((struct breakpoint *));
102 set_raw_breakpoint PARAMS ((struct symtab_and_line));
105 check_duplicates PARAMS ((CORE_ADDR, asection *));
108 describe_other_breakpoints PARAMS ((CORE_ADDR, asection *));
111 breakpoints_info PARAMS ((char *, int));
114 breakpoint_1 PARAMS ((int, int));
117 bpstat_alloc PARAMS ((struct breakpoint *, bpstat));
120 breakpoint_cond_eval PARAMS ((char *));
123 cleanup_executing_breakpoints PARAMS ((PTR));
126 commands_command PARAMS ((char *, int));
129 condition_command PARAMS ((char *, int));
132 get_number PARAMS ((char **));
135 set_breakpoint_count PARAMS ((int));
138 remove_breakpoint PARAMS ((struct breakpoint *));
141 print_it_normal PARAMS ((bpstat));
144 watchpoint_check PARAMS ((char *));
147 print_it_done PARAMS ((bpstat));
150 print_it_noop PARAMS ((bpstat));
153 maintenance_info_breakpoints PARAMS ((char *, int));
155 #ifdef GET_LONGJMP_TARGET
157 create_longjmp_breakpoint PARAMS ((char *));
161 hw_breakpoint_used_count PARAMS ((void));
164 hw_watchpoint_used_count PARAMS ((enum bptype, int *));
167 hbreak_command PARAMS ((char *, int));
170 thbreak_command PARAMS ((char *, int));
173 watch_command_1 PARAMS ((char *, int, int));
176 rwatch_command PARAMS ((char *, int));
179 awatch_command PARAMS ((char *, int));
182 do_enable_breakpoint PARAMS ((struct breakpoint *, enum bpdisp));
184 extern int addressprint; /* Print machine addresses? */
186 #if defined (GET_LONGJMP_TARGET) || defined (SOLIB_ADD)
187 static int internal_breakpoint_number = -1;
190 /* Are we executing breakpoint commands? */
191 static int executing_breakpoint_commands;
193 /* Walk the following statement or block through all breakpoints.
194 ALL_BREAKPOINTS_SAFE does so even if the statment deletes the current
197 #define ALL_BREAKPOINTS(b) for (b = breakpoint_chain; b; b = b->next)
199 #define ALL_BREAKPOINTS_SAFE(b,tmp) \
200 for (b = breakpoint_chain; \
201 b? (tmp=b->next, 1): 0; \
204 /* True if SHIFT_INST_REGS defined, false otherwise. */
206 int must_shift_inst_regs =
207 #if defined(SHIFT_INST_REGS)
214 /* True if breakpoint hit counts should be displayed in breakpoint info. */
216 int show_breakpoint_hit_counts = 1;
218 /* Chain of all breakpoints defined. */
220 struct breakpoint *breakpoint_chain;
222 /* Number of last breakpoint made. */
224 int breakpoint_count;
226 /* Set breakpoint count to NUM. */
229 set_breakpoint_count (num)
232 breakpoint_count = num;
233 set_internalvar (lookup_internalvar ("bpnum"),
234 value_from_longest (builtin_type_int, (LONGEST) num));
237 /* Used in run_command to zero the hit count when a new run starts. */
240 clear_breakpoint_hit_counts ()
242 struct breakpoint *b;
248 /* Default address, symtab and line to put a breakpoint at
249 for "break" command with no arg.
250 if default_breakpoint_valid is zero, the other three are
251 not valid, and "break" with no arg is an error.
253 This set by print_stack_frame, which calls set_default_breakpoint. */
255 int default_breakpoint_valid;
256 CORE_ADDR default_breakpoint_address;
257 struct symtab *default_breakpoint_symtab;
258 int default_breakpoint_line;
260 /* *PP is a string denoting a breakpoint. Get the number of the breakpoint.
261 Advance *PP after the string and any trailing whitespace.
263 Currently the string can either be a number or "$" followed by the name
264 of a convenience variable. Making it an expression wouldn't work well
265 for map_breakpoint_numbers (e.g. "4 + 5 + 6"). */
274 /* Empty line means refer to the last breakpoint. */
275 return breakpoint_count;
278 /* Make a copy of the name, so we can null-terminate it
279 to pass to lookup_internalvar(). */
284 while (isalnum (*p) || *p == '_')
286 varname = (char *) alloca (p - start + 1);
287 strncpy (varname, start, p - start);
288 varname[p - start] = '\0';
289 val = value_of_internalvar (lookup_internalvar (varname));
290 if (TYPE_CODE (VALUE_TYPE (val)) != TYPE_CODE_INT)
292 "Convenience variables used to specify breakpoints must have integer values."
294 retval = (int) value_as_long (val);
300 while (*p >= '0' && *p <= '9')
303 /* There is no number here. (e.g. "cond a == b"). */
304 error_no_arg ("breakpoint number");
307 if (!(isspace (*p) || *p == '\0'))
308 error ("breakpoint number expected");
315 /* condition N EXP -- set break condition of breakpoint N to EXP. */
318 condition_command (arg, from_tty)
322 register struct breakpoint *b;
327 error_no_arg ("breakpoint number");
330 bnum = get_number (&p);
333 if (b->number == bnum)
340 if (b->cond_string != NULL)
341 free ((PTR)b->cond_string);
346 b->cond_string = NULL;
348 printf_filtered ("Breakpoint %d now unconditional.\n", bnum);
353 /* I don't know if it matters whether this is the string the user
354 typed in or the decompiled expression. */
355 b->cond_string = savestring (arg, strlen (arg));
356 b->cond = parse_exp_1 (&arg, block_for_pc (b->address), 0);
358 error ("Junk at end of expression");
360 breakpoints_changed ();
364 error ("No breakpoint number %d.", bnum);
369 commands_command (arg, from_tty)
373 register struct breakpoint *b;
376 struct command_line *l;
378 /* If we allowed this, we would have problems with when to
379 free the storage, if we change the commands currently
382 if (executing_breakpoint_commands)
383 error ("Can't use the \"commands\" command among a breakpoint's commands.");
386 bnum = get_number (&p);
388 error ("Unexpected extra arguments following breakpoint number.");
391 if (b->number == bnum)
394 sprintf (tmpbuf, "Type commands for when breakpoint %d is hit, one per line.", bnum);
395 l = read_command_lines (tmpbuf, from_tty);
396 free_command_lines (&b->commands);
398 breakpoints_changed ();
401 error ("No breakpoint number %d.", bnum);
404 extern int memory_breakpoint_size; /* from mem-break.c */
406 /* Like target_read_memory() but if breakpoints are inserted, return
407 the shadow contents instead of the breakpoints themselves.
409 Read "memory data" from whatever target or inferior we have.
410 Returns zero if successful, errno value if not. EIO is used
411 for address out of bounds. If breakpoints are inserted, returns
412 shadow contents, not the breakpoints themselves. From breakpoint.c. */
415 read_memory_nobpt (memaddr, myaddr, len)
421 struct breakpoint *b;
423 if (memory_breakpoint_size < 0)
424 /* No breakpoints on this machine. FIXME: This should be
425 dependent on the debugging target. Probably want
426 target_insert_breakpoint to return a size, saying how many
427 bytes of the shadow contents are used, or perhaps have
428 something like target_xfer_shadow. */
429 return target_read_memory (memaddr, myaddr, len);
433 if (b->type == bp_watchpoint
434 || b->type == bp_hardware_watchpoint
435 || b->type == bp_read_watchpoint
436 || b->type == bp_access_watchpoint
439 else if (b->address + memory_breakpoint_size <= memaddr)
440 /* The breakpoint is entirely before the chunk of memory
443 else if (b->address >= memaddr + len)
444 /* The breakpoint is entirely after the chunk of memory we
449 /* Copy the breakpoint from the shadow contents, and recurse
450 for the things before and after. */
452 /* Addresses and length of the part of the breakpoint that
454 CORE_ADDR membpt = b->address;
455 unsigned int bptlen = memory_breakpoint_size;
456 /* Offset within shadow_contents. */
459 if (membpt < memaddr)
461 /* Only copy the second part of the breakpoint. */
462 bptlen -= memaddr - membpt;
463 bptoffset = memaddr - membpt;
467 if (membpt + bptlen > memaddr + len)
469 /* Only copy the first part of the breakpoint. */
470 bptlen -= (membpt + bptlen) - (memaddr + len);
473 memcpy (myaddr + membpt - memaddr,
474 b->shadow_contents + bptoffset, bptlen);
476 if (membpt > memaddr)
478 /* Copy the section of memory before the breakpoint. */
479 status = read_memory_nobpt (memaddr, myaddr, membpt - memaddr);
484 if (membpt + bptlen < memaddr + len)
486 /* Copy the section of memory after the breakpoint. */
487 status = read_memory_nobpt
489 myaddr + membpt + bptlen - memaddr,
490 memaddr + len - (membpt + bptlen));
497 /* Nothing overlaps. Just call read_memory_noerr. */
498 return target_read_memory (memaddr, myaddr, len);
501 /* insert_breakpoints is used when starting or continuing the program.
502 remove_breakpoints is used when the program stops.
503 Both return zero if successful,
504 or an `errno' value if could not write the inferior. */
507 insert_breakpoints ()
509 register struct breakpoint *b, *temp;
511 int disabled_breaks = 0;
513 ALL_BREAKPOINTS_SAFE (b, temp)
514 if (b->type != bp_watchpoint
515 && b->type != bp_hardware_watchpoint
516 && b->type != bp_read_watchpoint
517 && b->type != bp_access_watchpoint
518 && b->enable != disabled
519 && b->enable != shlib_disabled
523 if (b->type == bp_hardware_breakpoint)
524 val = target_insert_hw_breakpoint(b->address, b->shadow_contents);
527 /* Check to see if breakpoint is in an overlay section;
528 if so, we should set the breakpoint at the LMA address.
529 Only if the section is currently mapped should we ALSO
530 set a break at the VMA address. */
531 if (overlay_debugging && b->section &&
532 section_is_overlay (b->section))
536 addr = overlay_unmapped_address (b->address, b->section);
537 val = target_insert_breakpoint (addr, b->shadow_contents);
538 /* This would be the time to check val, to see if the
539 breakpoint write to the load address succeeded.
540 However, this might be an ordinary occurrance, eg. if
541 the unmapped overlay is in ROM. */
542 val = 0; /* in case unmapped address failed */
543 if (section_is_mapped (b->section))
544 val = target_insert_breakpoint (b->address,
547 else /* ordinary (non-overlay) address */
548 val = target_insert_breakpoint(b->address, b->shadow_contents);
552 /* Can't set the breakpoint. */
553 #if defined (DISABLE_UNSETTABLE_BREAK)
554 if (DISABLE_UNSETTABLE_BREAK (b->address))
557 b->enable = shlib_disabled;
558 if (!disabled_breaks)
560 target_terminal_ours_for_output ();
561 fprintf_unfiltered (gdb_stderr,
562 "Cannot insert breakpoint %d:\n", b->number);
563 printf_filtered ("Temporarily disabling shared library breakpoints:\n");
566 printf_filtered ("%d ", b->number);
571 target_terminal_ours_for_output ();
572 fprintf_unfiltered (gdb_stderr, "Cannot insert breakpoint %d:\n", b->number);
573 #ifdef ONE_PROCESS_WRITETEXT
574 fprintf_unfiltered (gdb_stderr,
575 "The same program may be running in another process.\n");
577 memory_error (val, b->address); /* which bombs us out */
583 else if ((b->type == bp_hardware_watchpoint ||
584 b->type == bp_read_watchpoint ||
585 b->type == bp_access_watchpoint)
586 && b->enable == enabled
590 struct frame_info *saved_frame;
591 int saved_level, within_current_scope;
592 value_ptr mark = value_mark ();
595 /* Save the current frame and level so we can restore it after
596 evaluating the watchpoint expression on its own frame. */
597 saved_frame = selected_frame;
598 saved_level = selected_frame_level;
600 /* Determine if the watchpoint is within scope. */
601 if (b->exp_valid_block == NULL)
602 within_current_scope = 1;
605 struct frame_info *fi;
607 /* There might be no current frame at this moment if we are
608 resuming from a step over a breakpoint.
609 Set up current frame before trying to find the watchpoint
611 get_current_frame ();
612 fi = find_frame_addr_in_frame_chain (b->watchpoint_frame);
613 within_current_scope = (fi != NULL);
614 if (within_current_scope)
615 select_frame (fi, -1);
618 if (within_current_scope)
620 /* Evaluate the expression and cut the chain of values
621 produced off from the value chain. */
622 v = evaluate_expression (b->exp);
623 value_release_to_mark (mark);
628 /* Look at each value on the value chain. */
629 for ( ; v; v=v->next)
631 /* If it's a memory location, then we must watch it. */
632 if (v->lval == lval_memory)
636 addr = VALUE_ADDRESS (v) + VALUE_OFFSET (v);
637 len = TYPE_LENGTH (VALUE_TYPE (v));
639 if (b->type == bp_read_watchpoint)
641 else if (b->type == bp_access_watchpoint)
644 val = target_insert_watchpoint (addr, len, type);
653 /* Failure to insert a watchpoint on any memory value in the
654 value chain brings us here. */
656 warning ("Hardware watchpoint %d: Could not insert watchpoint\n",
662 Hardware watchpoint %d deleted because the program has left the block in\n\
663 which its expression is valid.\n", b->number);
664 if (b->related_breakpoint)
665 b->related_breakpoint->disposition = del_at_next_stop;
666 b->disposition = del_at_next_stop;
669 /* Restore the frame and level. */
670 select_frame (saved_frame, saved_level);
673 printf_filtered ("\n");
679 remove_breakpoints ()
681 register struct breakpoint *b;
688 val = remove_breakpoint (b);
698 remove_breakpoint (b)
699 struct breakpoint *b;
703 if (b->type != bp_watchpoint
704 && b->type != bp_hardware_watchpoint
705 && b->type != bp_read_watchpoint
706 && b->type != bp_access_watchpoint)
708 if (b->type == bp_hardware_breakpoint)
709 val = target_remove_hw_breakpoint(b->address, b->shadow_contents);
712 /* Check to see if breakpoint is in an overlay section;
713 if so, we should remove the breakpoint at the LMA address.
714 If that is not equal to the raw address, then we should
715 presumable remove the breakpoint there as well. */
716 if (overlay_debugging && b->section &&
717 section_is_overlay (b->section))
721 addr = overlay_unmapped_address (b->address, b->section);
722 val = target_remove_breakpoint (addr, b->shadow_contents);
723 /* This would be the time to check val, to see if the
724 shadow breakpoint write to the load address succeeded.
725 However, this might be an ordinary occurrance, eg. if
726 the unmapped overlay is in ROM. */
727 val = 0; /* in case unmapped address failed */
728 if (section_is_mapped (b->section))
729 val = target_remove_breakpoint (b->address,
732 else /* ordinary (non-overlay) address */
733 val = target_remove_breakpoint(b->address, b->shadow_contents);
739 else if ((b->type == bp_hardware_watchpoint ||
740 b->type == bp_read_watchpoint ||
741 b->type == bp_access_watchpoint)
742 && b->enable == enabled
748 /* Walk down the saved value chain. */
749 for (v = b->val_chain; v; v = v->next)
751 /* For each memory reference remove the watchpoint
753 if (v->lval == lval_memory)
757 addr = VALUE_ADDRESS (v) + VALUE_OFFSET (v);
758 len = TYPE_LENGTH (VALUE_TYPE (v));
760 if (b->type == bp_read_watchpoint)
762 else if (b->type == bp_access_watchpoint)
765 val = target_remove_watchpoint (addr, len, type);
771 /* Failure to remove any of the hardware watchpoints comes here. */
773 warning ("Hardware watchpoint %d: Could not remove watchpoint\n",
776 /* Free the saved value chain. We will construct a new one
777 the next time the watchpoint is inserted. */
778 for (v = b->val_chain; v; v = n)
788 /* Clear the "inserted" flag in all breakpoints. */
791 mark_breakpoints_out ()
793 register struct breakpoint *b;
799 /* Clear the "inserted" flag in all breakpoints and delete any breakpoints
800 which should go away between runs of the program. */
803 breakpoint_init_inferior ()
805 register struct breakpoint *b, *temp;
807 ALL_BREAKPOINTS_SAFE (b, temp)
814 case bp_watchpoint_scope:
816 /* If the call dummy breakpoint is at the entry point it will
817 cause problems when the inferior is rerun, so we better
820 Also get rid of scope breakpoints. */
821 delete_breakpoint (b);
825 case bp_hardware_watchpoint:
826 case bp_read_watchpoint:
827 case bp_access_watchpoint:
829 /* Likewise for watchpoints on local expressions. */
830 if (b->exp_valid_block != NULL)
831 delete_breakpoint (b);
840 /* breakpoint_here_p (PC) returns 1 if an enabled breakpoint exists at PC.
841 When continuing from a location with a breakpoint,
842 we actually single step once before calling insert_breakpoints. */
845 breakpoint_here_p (pc)
848 register struct breakpoint *b;
851 if (b->enable == enabled
852 && b->address == pc) /* bp is enabled and matches pc */
853 if (overlay_debugging &&
854 section_is_overlay (b->section) &&
855 !section_is_mapped (b->section))
856 continue; /* unmapped overlay -- can't be a match */
863 /* breakpoint_inserted_here_p (PC) is just like breakpoint_here_p(), but it
864 only returns true if there is actually a breakpoint inserted at PC. */
867 breakpoint_inserted_here_p (pc)
870 register struct breakpoint *b;
874 && b->address == pc) /* bp is inserted and matches pc */
875 if (overlay_debugging &&
876 section_is_overlay (b->section) &&
877 !section_is_mapped (b->section))
878 continue; /* unmapped overlay -- can't be a match */
885 /* Return nonzero if FRAME is a dummy frame. We can't use PC_IN_CALL_DUMMY
886 because figuring out the saved SP would take too much time, at least using
887 get_saved_register on the 68k. This means that for this function to
888 work right a port must use the bp_call_dummy breakpoint. */
891 frame_in_dummy (frame)
892 struct frame_info *frame;
895 #ifdef USE_GENERIC_DUMMY_FRAMES
896 return generic_pc_in_call_dummy (frame->pc, frame->frame);
898 struct breakpoint *b;
902 static ULONGEST dummy[] = CALL_DUMMY;
904 if (b->type == bp_call_dummy
905 && b->frame == frame->frame
907 /* We need to check the PC as well as the frame on the sparc,
908 for signals.exp in the testsuite. */
911 - sizeof (dummy) / sizeof (LONGEST) * REGISTER_SIZE))
912 && frame->pc <= b->address)
915 #endif /* GENERIC_DUMMY_FRAMES */
916 #endif /* CALL_DUMMY */
920 /* breakpoint_match_thread (PC, PID) returns true if the breakpoint at PC
921 is valid for process/thread PID. */
924 breakpoint_thread_match (pc, pid)
928 struct breakpoint *b;
931 thread = pid_to_thread_id (pid);
934 if (b->enable != disabled
935 && b->enable != shlib_disabled
937 && (b->thread == -1 || b->thread == thread))
938 if (overlay_debugging &&
939 section_is_overlay (b->section) &&
940 !section_is_mapped (b->section))
941 continue; /* unmapped overlay -- can't be a match */
949 /* bpstat stuff. External routines' interfaces are documented
952 /* Clear a bpstat so that it says we are not at any breakpoint.
953 Also free any storage that is part of a bpstat. */
968 if (p->old_val != NULL)
969 value_free (p->old_val);
976 /* Return a copy of a bpstat. Like "bs1 = bs2" but all storage that
977 is part of the bpstat is copied as well. */
985 bpstat retval = NULL;
990 for (; bs != NULL; bs = bs->next)
992 tmp = (bpstat) xmalloc (sizeof (*tmp));
993 memcpy (tmp, bs, sizeof (*tmp));
995 /* This is the first thing in the chain. */
1005 /* Find the bpstat associated with this breakpoint */
1008 bpstat_find_breakpoint(bsp, breakpoint)
1010 struct breakpoint *breakpoint;
1012 if (bsp == NULL) return NULL;
1014 for (;bsp != NULL; bsp = bsp->next) {
1015 if (bsp->breakpoint_at == breakpoint) return bsp;
1020 /* Return the breakpoint number of the first breakpoint we are stopped
1021 at. *BSP upon return is a bpstat which points to the remaining
1022 breakpoints stopped at (but which is not guaranteed to be good for
1023 anything but further calls to bpstat_num).
1024 Return 0 if passed a bpstat which does not indicate any breakpoints. */
1030 struct breakpoint *b;
1033 return 0; /* No more breakpoint values */
1036 b = (*bsp)->breakpoint_at;
1037 *bsp = (*bsp)->next;
1039 return -1; /* breakpoint that's been deleted since */
1041 return b->number; /* We have its number */
1045 /* Modify BS so that the actions will not be performed. */
1048 bpstat_clear_actions (bs)
1051 for (; bs != NULL; bs = bs->next)
1053 bs->commands = NULL;
1054 if (bs->old_val != NULL)
1056 value_free (bs->old_val);
1062 /* Stub for cleaning up our state if we error-out of a breakpoint command */
1065 cleanup_executing_breakpoints (ignore)
1068 executing_breakpoint_commands = 0;
1071 /* Execute all the commands associated with all the breakpoints at this
1072 location. Any of these commands could cause the process to proceed
1073 beyond this point, etc. We look out for such changes by checking
1074 the global "breakpoint_proceeded" after each command. */
1077 bpstat_do_actions (bsp)
1081 struct cleanup *old_chain;
1082 struct command_line *cmd;
1084 /* Avoid endless recursion if a `source' command is contained
1086 if (executing_breakpoint_commands)
1089 executing_breakpoint_commands = 1;
1090 old_chain = make_cleanup (cleanup_executing_breakpoints, 0);
1095 breakpoint_proceeded = 0;
1096 for (; bs != NULL; bs = bs->next)
1101 execute_control_command (cmd);
1104 if (breakpoint_proceeded)
1105 /* The inferior is proceeded by the command; bomb out now.
1106 The bpstat chain has been blown away by wait_for_inferior.
1107 But since execution has stopped again, there is a new bpstat
1108 to look at, so start over. */
1111 bs->commands = NULL;
1114 executing_breakpoint_commands = 0;
1115 discard_cleanups (old_chain);
1118 /* This is the normal print_it function for a bpstat. In the future,
1119 much of this logic could (should?) be moved to bpstat_stop_status,
1120 by having it set different print_it functions. */
1123 print_it_normal (bs)
1126 /* bs->breakpoint_at can be NULL if it was a momentary breakpoint
1127 which has since been deleted. */
1128 if (bs->breakpoint_at == NULL
1129 || (bs->breakpoint_at->type != bp_breakpoint
1130 && bs->breakpoint_at->type != bp_hardware_breakpoint
1131 && bs->breakpoint_at->type != bp_watchpoint
1132 && bs->breakpoint_at->type != bp_read_watchpoint
1133 && bs->breakpoint_at->type != bp_access_watchpoint
1134 && bs->breakpoint_at->type != bp_hardware_watchpoint))
1137 if (bs->breakpoint_at->type == bp_breakpoint ||
1138 bs->breakpoint_at->type == bp_hardware_breakpoint)
1140 /* I think the user probably only wants to see one breakpoint
1141 number, not all of them. */
1142 annotate_breakpoint (bs->breakpoint_at->number);
1143 printf_filtered ("\nBreakpoint %d, ", bs->breakpoint_at->number);
1146 else if ((bs->old_val != NULL) &&
1147 (bs->breakpoint_at->type == bp_watchpoint ||
1148 bs->breakpoint_at->type == bp_access_watchpoint ||
1149 bs->breakpoint_at->type == bp_hardware_watchpoint))
1151 annotate_watchpoint (bs->breakpoint_at->number);
1152 mention (bs->breakpoint_at);
1153 printf_filtered ("\nOld value = ");
1154 value_print (bs->old_val, gdb_stdout, 0, Val_pretty_default);
1155 printf_filtered ("\nNew value = ");
1156 value_print (bs->breakpoint_at->val, gdb_stdout, 0,
1157 Val_pretty_default);
1158 printf_filtered ("\n");
1159 value_free (bs->old_val);
1161 /* More than one watchpoint may have been triggered. */
1164 else if (bs->breakpoint_at->type == bp_access_watchpoint ||
1165 bs->breakpoint_at->type == bp_read_watchpoint)
1167 mention (bs->breakpoint_at);
1168 printf_filtered ("\nValue = ");
1169 value_print (bs->breakpoint_at->val, gdb_stdout, 0,
1170 Val_pretty_default);
1171 printf_filtered ("\n");
1174 /* We can't deal with it. Maybe another member of the bpstat chain can. */
1178 /* Print a message indicating what happened. Returns nonzero to
1179 say that only the source line should be printed after this (zero
1180 return means print the frame as well as the source line). */
1181 /* Currently we always return zero. */
1191 val = (*bs->print_it) (bs);
1195 /* Maybe another breakpoint in the chain caused us to stop.
1196 (Currently all watchpoints go on the bpstat whether hit or
1197 not. That probably could (should) be changed, provided care is taken
1198 with respect to bpstat_explains_signal). */
1200 return bpstat_print (bs->next);
1202 /* We reached the end of the chain without printing anything. */
1206 /* Evaluate the expression EXP and return 1 if value is zero.
1207 This is used inside a catch_errors to evaluate the breakpoint condition.
1208 The argument is a "struct expression *" that has been cast to char * to
1209 make it pass through catch_errors. */
1212 breakpoint_cond_eval (exp)
1215 value_ptr mark = value_mark ();
1216 int i = !value_true (evaluate_expression ((struct expression *)exp));
1217 value_free_to_mark (mark);
1221 /* Allocate a new bpstat and chain it to the current one. */
1224 bpstat_alloc (b, cbs)
1225 register struct breakpoint *b;
1226 bpstat cbs; /* Current "bs" value */
1230 bs = (bpstat) xmalloc (sizeof (*bs));
1232 bs->breakpoint_at = b;
1233 /* If the condition is false, etc., don't do the commands. */
1234 bs->commands = NULL;
1236 bs->print_it = print_it_normal;
1240 /* Possible return values for watchpoint_check (this can't be an enum
1241 because of check_errors). */
1242 /* The watchpoint has been deleted. */
1243 #define WP_DELETED 1
1244 /* The value has changed. */
1245 #define WP_VALUE_CHANGED 2
1246 /* The value has not changed. */
1247 #define WP_VALUE_NOT_CHANGED 3
1249 #define BP_TEMPFLAG 1
1250 #define BP_HARDWAREFLAG 2
1252 /* Check watchpoint condition. */
1255 watchpoint_check (p)
1258 bpstat bs = (bpstat) p;
1259 struct breakpoint *b;
1260 struct frame_info *fr;
1261 int within_current_scope;
1263 b = bs->breakpoint_at;
1265 if (b->exp_valid_block == NULL)
1266 within_current_scope = 1;
1269 /* There is no current frame at this moment. If we're going to have
1270 any chance of handling watchpoints on local variables, we'll need
1271 the frame chain (so we can determine if we're in scope). */
1272 reinit_frame_cache();
1273 fr = find_frame_addr_in_frame_chain (b->watchpoint_frame);
1274 within_current_scope = (fr != NULL);
1275 if (within_current_scope)
1276 /* If we end up stopping, the current frame will get selected
1277 in normal_stop. So this call to select_frame won't affect
1279 select_frame (fr, -1);
1282 if (within_current_scope)
1284 /* We use value_{,free_to_}mark because it could be a
1285 *long* time before we return to the command level and
1286 call free_all_values. We can't call free_all_values because
1287 we might be in the middle of evaluating a function call. */
1289 value_ptr mark = value_mark ();
1290 value_ptr new_val = evaluate_expression (bs->breakpoint_at->exp);
1291 if (!value_equal (b->val, new_val))
1293 release_value (new_val);
1294 value_free_to_mark (mark);
1295 bs->old_val = b->val;
1297 /* We will stop here */
1298 return WP_VALUE_CHANGED;
1302 /* Nothing changed, don't do anything. */
1303 value_free_to_mark (mark);
1304 /* We won't stop here */
1305 return WP_VALUE_NOT_CHANGED;
1310 /* This seems like the only logical thing to do because
1311 if we temporarily ignored the watchpoint, then when
1312 we reenter the block in which it is valid it contains
1313 garbage (in the case of a function, it may have two
1314 garbage values, one before and one after the prologue).
1315 So we can't even detect the first assignment to it and
1316 watch after that (since the garbage may or may not equal
1317 the first value assigned). */
1319 Watchpoint %d deleted because the program has left the block in\n\
1320 which its expression is valid.\n", bs->breakpoint_at->number);
1321 if (b->related_breakpoint)
1322 b->related_breakpoint->disposition = del_at_next_stop;
1323 b->disposition = del_at_next_stop;
1329 /* This is used when everything which needs to be printed has
1330 already been printed. But we still want to print the frame. */
1338 /* This is used when nothing should be printed for this bpstat entry. */
1347 /* Get a bpstat associated with having just stopped at address *PC
1348 and frame address CORE_ADDRESS. Update *PC to point at the
1349 breakpoint (if we hit a breakpoint). NOT_A_BREAKPOINT is nonzero
1350 if this is known to not be a real breakpoint (it could still be a
1351 watchpoint, though). */
1353 /* Determine whether we stopped at a breakpoint, etc, or whether we
1354 don't understand this stop. Result is a chain of bpstat's such that:
1356 if we don't understand the stop, the result is a null pointer.
1358 if we understand why we stopped, the result is not null.
1360 Each element of the chain refers to a particular breakpoint or
1361 watchpoint at which we have stopped. (We may have stopped for
1362 several reasons concurrently.)
1364 Each element of the chain has valid next, breakpoint_at,
1365 commands, FIXME??? fields.
1370 bpstat_stop_status (pc, not_a_breakpoint)
1372 int not_a_breakpoint;
1374 register struct breakpoint *b, *temp;
1376 /* True if we've hit a breakpoint (as opposed to a watchpoint). */
1377 int real_breakpoint = 0;
1378 /* Root of the chain of bpstat's */
1379 struct bpstats root_bs[1];
1380 /* Pointer to the last thing in the chain currently. */
1381 bpstat bs = root_bs;
1382 static char message1[] =
1383 "Error evaluating expression for watchpoint %d\n";
1384 char message[sizeof (message1) + 30 /* slop */];
1386 /* Get the address where the breakpoint would have been. */
1387 bp_addr = *pc - DECR_PC_AFTER_BREAK;
1389 ALL_BREAKPOINTS_SAFE (b, temp)
1391 if (b->enable == disabled
1392 || b->enable == shlib_disabled)
1395 if (b->type != bp_watchpoint
1396 && b->type != bp_hardware_watchpoint
1397 && b->type != bp_read_watchpoint
1398 && b->type != bp_access_watchpoint
1399 && b->type != bp_hardware_breakpoint) /* a non-watchpoint bp */
1400 if (b->address != bp_addr || /* address doesn't match or */
1401 (overlay_debugging && /* overlay doesn't match */
1402 section_is_overlay (b->section) &&
1403 !section_is_mapped (b->section)))
1406 if (b->type == bp_hardware_breakpoint
1407 && b->address != (bp_addr - DECR_PC_AFTER_HW_BREAK))
1410 if (b->type != bp_watchpoint
1411 && b->type != bp_hardware_watchpoint
1412 && b->type != bp_read_watchpoint
1413 && b->type != bp_access_watchpoint
1414 && not_a_breakpoint)
1417 /* Come here if it's a watchpoint, or if the break address matches */
1421 bs = bpstat_alloc (b, bs); /* Alloc a bpstat to explain stop */
1426 sprintf (message, message1, b->number);
1427 if (b->type == bp_watchpoint || b->type == bp_hardware_watchpoint)
1429 switch (catch_errors (watchpoint_check, (char *) bs, message,
1433 /* We've already printed what needs to be printed. */
1434 bs->print_it = print_it_done;
1437 case WP_VALUE_CHANGED:
1440 case WP_VALUE_NOT_CHANGED:
1442 bs->print_it = print_it_noop;
1444 --(b->hit_count); /* don't consider this a hit */
1450 /* Error from catch_errors. */
1451 printf_filtered ("Watchpoint %d deleted.\n", b->number);
1452 if (b->related_breakpoint)
1453 b->related_breakpoint->disposition = del_at_next_stop;
1454 b->disposition = del_at_next_stop;
1455 /* We've already printed what needs to be printed. */
1456 bs->print_it = print_it_done;
1462 else if (b->type == bp_read_watchpoint || b->type == bp_access_watchpoint)
1468 addr = target_stopped_data_address();
1469 if (addr == 0) continue;
1470 for (v = b->val_chain; v; v = v->next)
1472 if (v->lval == lval_memory)
1476 vaddr = VALUE_ADDRESS (v) + VALUE_OFFSET (v);
1482 switch (catch_errors (watchpoint_check, (char *) bs, message,
1486 /* We've already printed what needs to be printed. */
1487 bs->print_it = print_it_done;
1490 case WP_VALUE_CHANGED:
1491 case WP_VALUE_NOT_CHANGED:
1497 /* Error from catch_errors. */
1498 printf_filtered ("Watchpoint %d deleted.\n", b->number);
1499 if (b->related_breakpoint)
1500 b->related_breakpoint->disposition = del_at_next_stop;
1501 b->disposition = del_at_next_stop;
1502 /* We've already printed what needs to be printed. */
1503 bs->print_it = print_it_done;
1507 else if (DECR_PC_AFTER_BREAK != 0 || must_shift_inst_regs)
1508 real_breakpoint = 1;
1510 if (b->frame && b->frame != (get_current_frame ())->frame &&
1511 (b->type == bp_step_resume &&
1512 (get_current_frame ())->frame INNER_THAN b->frame))
1516 int value_is_zero = 0;
1520 /* Need to select the frame, with all that implies
1521 so that the conditions will have the right context. */
1522 select_frame (get_current_frame (), 0);
1524 = catch_errors (breakpoint_cond_eval, (char *)(b->cond),
1525 "Error in testing breakpoint condition:\n",
1527 /* FIXME-someday, should give breakpoint # */
1530 if (b->cond && value_is_zero)
1534 else if (b->ignore_count > 0)
1541 /* We will stop here */
1542 if (b->disposition == disable)
1543 b->enable = disabled;
1544 bs->commands = b->commands;
1547 if (bs->commands && STREQ ("silent", bs->commands->line))
1549 bs->commands = bs->commands->next;
1554 /* Print nothing for this entry if we dont stop or if we dont print. */
1555 if (bs->stop == 0 || bs->print == 0)
1556 bs->print_it = print_it_noop;
1559 bs->next = NULL; /* Terminate the chain */
1560 bs = root_bs->next; /* Re-grab the head of the chain */
1562 if ((DECR_PC_AFTER_BREAK != 0 || must_shift_inst_regs) && bs)
1564 if (real_breakpoint)
1567 #if defined (SHIFT_INST_REGS)
1569 #else /* No SHIFT_INST_REGS. */
1571 #endif /* No SHIFT_INST_REGS. */
1575 /* The value of a hardware watchpoint hasn't changed, but the
1576 intermediate memory locations we are watching may have. */
1577 if (bs && ! bs->stop &&
1578 (bs->breakpoint_at->type == bp_hardware_watchpoint ||
1579 bs->breakpoint_at->type == bp_read_watchpoint ||
1580 bs->breakpoint_at->type == bp_access_watchpoint))
1582 remove_breakpoints ();
1583 insert_breakpoints ();
1588 /* Tell what to do about this bpstat. */
1593 /* Classify each bpstat as one of the following. */
1595 /* This bpstat element has no effect on the main_action. */
1598 /* There was a watchpoint, stop but don't print. */
1601 /* There was a watchpoint, stop and print. */
1604 /* There was a breakpoint but we're not stopping. */
1607 /* There was a breakpoint, stop but don't print. */
1610 /* There was a breakpoint, stop and print. */
1613 /* We hit the longjmp breakpoint. */
1616 /* We hit the longjmp_resume breakpoint. */
1619 /* We hit the step_resume breakpoint. */
1622 /* We hit the through_sigtramp breakpoint. */
1625 /* We hit the shared library event breakpoint. */
1628 /* This is just used to count how many enums there are. */
1632 /* Here is the table which drives this routine. So that we can
1633 format it pretty, we define some abbreviations for the
1634 enum bpstat_what codes. */
1635 #define kc BPSTAT_WHAT_KEEP_CHECKING
1636 #define ss BPSTAT_WHAT_STOP_SILENT
1637 #define sn BPSTAT_WHAT_STOP_NOISY
1638 #define sgl BPSTAT_WHAT_SINGLE
1639 #define slr BPSTAT_WHAT_SET_LONGJMP_RESUME
1640 #define clr BPSTAT_WHAT_CLEAR_LONGJMP_RESUME
1641 #define clrs BPSTAT_WHAT_CLEAR_LONGJMP_RESUME_SINGLE
1642 #define sr BPSTAT_WHAT_STEP_RESUME
1643 #define ts BPSTAT_WHAT_THROUGH_SIGTRAMP
1644 #define shl BPSTAT_WHAT_CHECK_SHLIBS
1646 /* "Can't happen." Might want to print an error message.
1647 abort() is not out of the question, but chances are GDB is just
1648 a bit confused, not unusable. */
1649 #define err BPSTAT_WHAT_STOP_NOISY
1651 /* Given an old action and a class, come up with a new action. */
1652 /* One interesting property of this table is that wp_silent is the same
1653 as bp_silent and wp_noisy is the same as bp_noisy. That is because
1654 after stopping, the check for whether to step over a breakpoint
1655 (BPSTAT_WHAT_SINGLE type stuff) is handled in proceed() without
1656 reference to how we stopped. We retain separate wp_silent and bp_silent
1657 codes in case we want to change that someday. */
1659 /* step_resume entries: a step resume breakpoint overrides another
1660 breakpoint of signal handling (see comment in wait_for_inferior
1661 at first IN_SIGTRAMP where we set the step_resume breakpoint). */
1662 /* We handle the through_sigtramp_breakpoint the same way; having both
1663 one of those and a step_resume_breakpoint is probably very rare (?). */
1665 static const enum bpstat_what_main_action
1666 table[(int)class_last][(int)BPSTAT_WHAT_LAST] =
1669 /* kc ss sn sgl slr clr clrs sr ts shl
1671 /*no_effect*/ {kc, ss, sn, sgl, slr, clr, clrs, sr, ts, shl},
1672 /*wp_silent*/ {ss, ss, sn, ss, ss, ss, ss, sr, ts, shl},
1673 /*wp_noisy*/ {sn, sn, sn, sn, sn, sn, sn, sr, ts, shl},
1674 /*bp_nostop*/ {sgl, ss, sn, sgl, slr, clrs, clrs, sr, ts, shl},
1675 /*bp_silent*/ {ss, ss, sn, ss, ss, ss, ss, sr, ts, shl},
1676 /*bp_noisy*/ {sn, sn, sn, sn, sn, sn, sn, sr, ts, shl},
1677 /*long_jump*/ {slr, ss, sn, slr, err, err, err, sr, ts, shl},
1678 /*long_resume*/ {clr, ss, sn, clrs, err, err, err, sr, ts, shl},
1679 /*step_resume*/ {sr, sr, sr, sr, sr, sr, sr, sr, ts, shl},
1680 /*through_sig*/ {ts, ts, ts, ts, ts, ts, ts, ts, ts, shl},
1681 /*shlib*/ {shl, shl, shl, shl, shl, shl, shl, shl, ts, shl}
1694 enum bpstat_what_main_action current_action = BPSTAT_WHAT_KEEP_CHECKING;
1695 struct bpstat_what retval;
1697 retval.call_dummy = 0;
1698 for (; bs != NULL; bs = bs->next)
1700 enum class bs_class = no_effect;
1701 if (bs->breakpoint_at == NULL)
1702 /* I suspect this can happen if it was a momentary breakpoint
1703 which has since been deleted. */
1705 switch (bs->breakpoint_at->type)
1708 case bp_hardware_breakpoint:
1714 bs_class = bp_noisy;
1716 bs_class = bp_silent;
1719 bs_class = bp_nostop;
1722 case bp_hardware_watchpoint:
1723 case bp_read_watchpoint:
1724 case bp_access_watchpoint:
1728 bs_class = wp_noisy;
1730 bs_class = wp_silent;
1733 /* There was a watchpoint, but we're not stopping. This requires
1734 no further action. */
1735 bs_class = no_effect;
1738 bs_class = long_jump;
1740 case bp_longjmp_resume:
1741 bs_class = long_resume;
1743 case bp_step_resume:
1746 bs_class = step_resume;
1749 /* It is for the wrong frame. */
1750 bs_class = bp_nostop;
1752 case bp_through_sigtramp:
1753 bs_class = through_sig;
1755 case bp_watchpoint_scope:
1756 bs_class = bp_nostop;
1758 case bp_shlib_event:
1759 bs_class = shlib_event;
1762 /* Make sure the action is stop (silent or noisy), so infrun.c
1763 pops the dummy frame. */
1764 bs_class = bp_silent;
1765 retval.call_dummy = 1;
1768 current_action = table[(int)bs_class][(int)current_action];
1770 retval.main_action = current_action;
1774 /* Nonzero if we should step constantly (e.g. watchpoints on machines
1775 without hardware support). This isn't related to a specific bpstat,
1776 just to things like whether watchpoints are set. */
1779 bpstat_should_step ()
1781 struct breakpoint *b;
1783 if (b->enable == enabled && b->type == bp_watchpoint)
1788 /* Print information on breakpoint number BNUM, or -1 if all.
1789 If WATCHPOINTS is zero, process only breakpoints; if WATCHPOINTS
1790 is nonzero, process only watchpoints. */
1793 breakpoint_1 (bnum, allflag)
1797 register struct breakpoint *b;
1798 register struct command_line *l;
1799 register struct symbol *sym;
1800 CORE_ADDR last_addr = (CORE_ADDR)-1;
1801 int found_a_breakpoint = 0;
1802 static char *bptypes[] = {"breakpoint", "hw breakpoint",
1803 "until", "finish", "watchpoint",
1804 "hw watchpoint", "read watchpoint",
1805 "acc watchpoint", "longjmp",
1806 "longjmp resume", "step resume",
1808 "watchpoint scope", "call dummy",
1810 static char *bpdisps[] = {"del", "dstp", "dis", "keep"};
1811 static char bpenables[] = "nyn";
1812 char wrap_indent[80];
1816 || bnum == b->number)
1818 /* We only print out user settable breakpoints unless the allflag is set. */
1820 && b->type != bp_breakpoint
1821 && b->type != bp_hardware_breakpoint
1822 && b->type != bp_watchpoint
1823 && b->type != bp_read_watchpoint
1824 && b->type != bp_access_watchpoint
1825 && b->type != bp_hardware_watchpoint)
1828 if (!found_a_breakpoint++)
1830 annotate_breakpoints_headers ();
1833 printf_filtered ("Num ");
1835 printf_filtered ("Type ");
1837 printf_filtered ("Disp ");
1839 printf_filtered ("Enb ");
1843 printf_filtered ("Address ");
1846 printf_filtered ("What\n");
1848 annotate_breakpoints_table ();
1853 printf_filtered ("%-3d ", b->number);
1855 printf_filtered ("%-14s ", bptypes[(int)b->type]);
1857 printf_filtered ("%-4s ", bpdisps[(int)b->disposition]);
1859 printf_filtered ("%-3c ", bpenables[(int)b->enable]);
1861 strcpy (wrap_indent, " ");
1863 strcat (wrap_indent, " ");
1867 case bp_hardware_watchpoint:
1868 case bp_read_watchpoint:
1869 case bp_access_watchpoint:
1870 /* Field 4, the address, is omitted (which makes the columns
1871 not line up too nicely with the headers, but the effect
1872 is relatively readable). */
1874 print_expression (b->exp, gdb_stdout);
1878 case bp_hardware_breakpoint:
1882 case bp_longjmp_resume:
1883 case bp_step_resume:
1884 case bp_through_sigtramp:
1885 case bp_watchpoint_scope:
1887 case bp_shlib_event:
1891 /* FIXME-32x64: need a print_address_numeric with
1895 local_hex_string_custom
1896 ((unsigned long) b->address, "08l"));
1901 last_addr = b->address;
1904 sym = find_pc_sect_function (b->address, b->section);
1907 fputs_filtered ("in ", gdb_stdout);
1908 fputs_filtered (SYMBOL_SOURCE_NAME (sym), gdb_stdout);
1909 wrap_here (wrap_indent);
1910 fputs_filtered (" at ", gdb_stdout);
1912 fputs_filtered (b->source_file, gdb_stdout);
1913 printf_filtered (":%d", b->line_number);
1916 print_address_symbolic (b->address, gdb_stdout, demangle, " ");
1920 printf_filtered ("\n");
1926 printf_filtered ("\tstop only in stack frame at ");
1927 print_address_numeric (b->frame, 1, gdb_stdout);
1928 printf_filtered ("\n");
1935 printf_filtered ("\tstop only if ");
1936 print_expression (b->cond, gdb_stdout);
1937 printf_filtered ("\n");
1940 if (b->thread != -1)
1942 /* FIXME should make an annotation for this */
1943 printf_filtered ("\tstop only in thread %d\n", b->thread);
1946 if (show_breakpoint_hit_counts && b->hit_count)
1948 /* FIXME should make an annotation for this */
1950 printf_filtered ("\tbreakpoint already hit %d time%s\n",
1951 b->hit_count, (b->hit_count == 1 ? "" : "s"));
1954 if (b->ignore_count)
1958 printf_filtered ("\tignore next %d hits\n", b->ignore_count);
1961 if ((l = b->commands))
1967 print_command_line (l, 4);
1973 if (!found_a_breakpoint)
1976 printf_filtered ("No breakpoints or watchpoints.\n");
1978 printf_filtered ("No breakpoint or watchpoint number %d.\n", bnum);
1981 /* Compare against (CORE_ADDR)-1 in case some compiler decides
1982 that a comparison of an unsigned with -1 is always false. */
1983 if (last_addr != (CORE_ADDR)-1)
1984 set_next_address (last_addr);
1986 annotate_breakpoints_table_end ();
1991 breakpoints_info (bnum_exp, from_tty)
1998 bnum = parse_and_eval_address (bnum_exp);
2000 breakpoint_1 (bnum, 0);
2003 #if MAINTENANCE_CMDS
2007 maintenance_info_breakpoints (bnum_exp, from_tty)
2014 bnum = parse_and_eval_address (bnum_exp);
2016 breakpoint_1 (bnum, 1);
2021 /* Print a message describing any breakpoints set at PC. */
2024 describe_other_breakpoints (pc, section)
2028 register int others = 0;
2029 register struct breakpoint *b;
2032 if (b->address == pc)
2033 if (overlay_debugging == 0 ||
2034 b->section == section)
2038 printf_filtered ("Note: breakpoint%s ", (others > 1) ? "s" : "");
2040 if (b->address == pc)
2041 if (overlay_debugging == 0 ||
2042 b->section == section)
2048 ((b->enable == disabled || b->enable == shlib_disabled)
2049 ? " (disabled)" : ""),
2050 (others > 1) ? "," : ((others == 1) ? " and" : ""));
2052 printf_filtered ("also set at pc ");
2053 print_address_numeric (pc, 1, gdb_stdout);
2054 printf_filtered (".\n");
2058 /* Set the default place to put a breakpoint
2059 for the `break' command with no arguments. */
2062 set_default_breakpoint (valid, addr, symtab, line)
2065 struct symtab *symtab;
2068 default_breakpoint_valid = valid;
2069 default_breakpoint_address = addr;
2070 default_breakpoint_symtab = symtab;
2071 default_breakpoint_line = line;
2074 /* Rescan breakpoints at address ADDRESS,
2075 marking the first one as "first" and any others as "duplicates".
2076 This is so that the bpt instruction is only inserted once. */
2079 check_duplicates (address, section)
2083 register struct breakpoint *b;
2084 register int count = 0;
2086 if (address == 0) /* Watchpoints are uninteresting */
2090 if (b->enable != disabled
2091 && b->enable != shlib_disabled
2092 && b->address == address
2093 && (overlay_debugging == 0 || b->section == section))
2096 b->duplicate = count > 1;
2100 /* Low level routine to set a breakpoint.
2101 Takes as args the three things that every breakpoint must have.
2102 Returns the breakpoint object so caller can set other things.
2103 Does not set the breakpoint number!
2104 Does not print anything.
2106 ==> This routine should not be called if there is a chance of later
2107 error(); otherwise it leaves a bogus breakpoint on the chain. Validate
2108 your arguments BEFORE calling this routine! */
2111 set_raw_breakpoint (sal)
2112 struct symtab_and_line sal;
2114 register struct breakpoint *b, *b1;
2116 b = (struct breakpoint *) xmalloc (sizeof (struct breakpoint));
2117 memset (b, 0, sizeof (*b));
2118 b->address = sal.pc;
2119 if (sal.symtab == NULL)
2120 b->source_file = NULL;
2122 b->source_file = savestring (sal.symtab->filename,
2123 strlen (sal.symtab->filename));
2124 b->section = sal.section;
2125 b->language = current_language->la_language;
2126 b->input_radix = input_radix;
2128 b->line_number = sal.line;
2129 b->enable = enabled;
2132 b->ignore_count = 0;
2136 /* Add this breakpoint to the end of the chain
2137 so that a list of breakpoints will come out in order
2138 of increasing numbers. */
2140 b1 = breakpoint_chain;
2142 breakpoint_chain = b;
2150 check_duplicates (sal.pc, sal.section);
2151 breakpoints_changed ();
2156 #ifdef GET_LONGJMP_TARGET
2159 create_longjmp_breakpoint (func_name)
2162 struct symtab_and_line sal;
2163 struct breakpoint *b;
2165 INIT_SAL (&sal); /* initialize to zeroes */
2166 if (func_name != NULL)
2168 struct minimal_symbol *m;
2170 m = lookup_minimal_symbol_text (func_name, NULL, (struct objfile *)NULL);
2172 sal.pc = SYMBOL_VALUE_ADDRESS (m);
2176 sal.section = find_pc_overlay (sal.pc);
2177 b = set_raw_breakpoint (sal);
2180 b->type = func_name != NULL ? bp_longjmp : bp_longjmp_resume;
2181 b->disposition = donttouch;
2182 b->enable = disabled;
2185 b->addr_string = strsave(func_name);
2186 b->number = internal_breakpoint_number--;
2189 #endif /* #ifdef GET_LONGJMP_TARGET */
2191 /* Call this routine when stepping and nexting to enable a breakpoint if we do
2192 a longjmp(). When we hit that breakpoint, call
2193 set_longjmp_resume_breakpoint() to figure out where we are going. */
2196 enable_longjmp_breakpoint()
2198 register struct breakpoint *b;
2201 if (b->type == bp_longjmp)
2203 b->enable = enabled;
2204 check_duplicates (b->address, b->section);
2209 disable_longjmp_breakpoint()
2211 register struct breakpoint *b;
2214 if ( b->type == bp_longjmp
2215 || b->type == bp_longjmp_resume)
2217 b->enable = disabled;
2218 check_duplicates (b->address, b->section);
2224 remove_solib_event_breakpoints ()
2226 register struct breakpoint *b, *temp;
2228 ALL_BREAKPOINTS_SAFE (b, temp)
2229 if (b->type == bp_shlib_event)
2230 delete_breakpoint (b);
2234 create_solib_event_breakpoint (address)
2237 struct breakpoint *b;
2238 struct symtab_and_line sal;
2240 INIT_SAL (&sal); /* initialize to zeroes */
2242 sal.section = find_pc_overlay (sal.pc);
2243 b = set_raw_breakpoint (sal);
2244 b->number = internal_breakpoint_number--;
2245 b->disposition = donttouch;
2246 b->type = bp_shlib_event;
2249 /* Try to reenable any breakpoints in shared libraries. */
2251 re_enable_breakpoints_in_shlibs ()
2253 struct breakpoint *b;
2256 if (b->enable == shlib_disabled)
2260 /* Do not reenable the breakpoint if the shared library
2261 is still not mapped in. */
2262 if (target_read_memory (b->address, buf, 1) == 0)
2263 b->enable = enabled;
2270 hw_breakpoint_used_count()
2272 register struct breakpoint *b;
2277 if (b->type == bp_hardware_breakpoint && b->enable == enabled)
2285 hw_watchpoint_used_count(type, other_type_used)
2287 int *other_type_used;
2289 register struct breakpoint *b;
2292 *other_type_used = 0;
2295 if (b->enable == enabled)
2297 if (b->type == type) i++;
2298 else if ((b->type == bp_hardware_watchpoint ||
2299 b->type == bp_read_watchpoint ||
2300 b->type == bp_access_watchpoint)
2301 && b->enable == enabled)
2302 *other_type_used = 1;
2308 /* Call this after hitting the longjmp() breakpoint. Use this to set a new
2309 breakpoint at the target of the jmp_buf.
2311 FIXME - This ought to be done by setting a temporary breakpoint that gets
2312 deleted automatically...
2316 set_longjmp_resume_breakpoint(pc, frame)
2318 struct frame_info *frame;
2320 register struct breakpoint *b;
2323 if (b->type == bp_longjmp_resume)
2326 b->enable = enabled;
2328 b->frame = frame->frame;
2331 check_duplicates (b->address, b->section);
2336 /* Set a breakpoint that will evaporate an end of command
2337 at address specified by SAL.
2338 Restrict it to frame FRAME if FRAME is nonzero. */
2341 set_momentary_breakpoint (sal, frame, type)
2342 struct symtab_and_line sal;
2343 struct frame_info *frame;
2346 register struct breakpoint *b;
2347 b = set_raw_breakpoint (sal);
2349 b->enable = enabled;
2350 b->disposition = donttouch;
2351 b->frame = (frame ? frame->frame : 0);
2353 /* If we're debugging a multi-threaded program, then we
2354 want momentary breakpoints to be active in only a
2355 single thread of control. */
2356 if (in_thread_list (inferior_pid))
2357 b->thread = pid_to_thread_id (inferior_pid);
2363 /* Tell the user we have just set a breakpoint B. */
2367 struct breakpoint *b;
2371 /* FIXME: This is misplaced; mention() is called by things (like hitting a
2372 watchpoint) other than breakpoint creation. It should be possible to
2373 clean this up and at the same time replace the random calls to
2374 breakpoint_changed with this hook, as has already been done for
2375 delete_breakpoint_hook and so on. */
2376 if (create_breakpoint_hook)
2377 create_breakpoint_hook (b);
2382 printf_filtered ("Watchpoint %d: ", b->number);
2383 print_expression (b->exp, gdb_stdout);
2385 case bp_hardware_watchpoint:
2386 printf_filtered ("Hardware watchpoint %d: ", b->number);
2387 print_expression (b->exp, gdb_stdout);
2389 case bp_read_watchpoint:
2390 printf_filtered ("Hardware read watchpoint %d: ", b->number);
2391 print_expression (b->exp, gdb_stdout);
2393 case bp_access_watchpoint:
2394 printf_filtered ("Hardware access(read/write) watchpoint %d: ",b->number);
2395 print_expression (b->exp, gdb_stdout);
2398 printf_filtered ("Breakpoint %d", b->number);
2401 case bp_hardware_breakpoint:
2402 printf_filtered ("Hardware assisted breakpoint %d", b->number);
2408 case bp_longjmp_resume:
2409 case bp_step_resume:
2410 case bp_through_sigtramp:
2412 case bp_watchpoint_scope:
2413 case bp_shlib_event:
2418 if (addressprint || b->source_file == NULL)
2420 printf_filtered (" at ");
2421 print_address_numeric (b->address, 1, gdb_stdout);
2424 printf_filtered (": file %s, line %d.",
2425 b->source_file, b->line_number);
2427 printf_filtered ("\n");
2431 /* Set a breakpoint according to ARG (function, linenum or *address)
2432 flag: first bit : 0 non-temporary, 1 temporary.
2433 second bit : 0 normal breakpoint, 1 hardware breakpoint. */
2436 break_command_1 (arg, flag, from_tty)
2440 int tempflag, hardwareflag;
2441 struct symtabs_and_lines sals;
2442 struct symtab_and_line sal;
2443 register struct expression *cond = 0;
2444 register struct breakpoint *b;
2446 /* Pointers in arg to the start, and one past the end, of the condition. */
2447 char *cond_start = NULL;
2448 char *cond_end = NULL;
2449 /* Pointers in arg to the start, and one past the end,
2450 of the address part. */
2451 char *addr_start = NULL;
2452 char *addr_end = NULL;
2453 struct cleanup *old_chain;
2454 struct cleanup *canonical_strings_chain = NULL;
2455 char **canonical = (char **)NULL;
2459 hardwareflag = flag & BP_HARDWAREFLAG;
2460 tempflag = flag & BP_TEMPFLAG;
2465 INIT_SAL (&sal); /* initialize to zeroes */
2467 /* If no arg given, or if first arg is 'if ', use the default breakpoint. */
2469 if (!arg || (arg[0] == 'i' && arg[1] == 'f'
2470 && (arg[2] == ' ' || arg[2] == '\t')))
2472 if (default_breakpoint_valid)
2474 sals.sals = (struct symtab_and_line *)
2475 xmalloc (sizeof (struct symtab_and_line));
2476 sal.pc = default_breakpoint_address;
2477 sal.line = default_breakpoint_line;
2478 sal.symtab = default_breakpoint_symtab;
2479 sal.section = find_pc_overlay (sal.pc);
2484 error ("No default breakpoint address now.");
2490 /* Force almost all breakpoints to be in terms of the
2491 current_source_symtab (which is decode_line_1's default). This
2492 should produce the results we want almost all of the time while
2493 leaving default_breakpoint_* alone. */
2494 if (default_breakpoint_valid
2495 && (!current_source_symtab
2496 || (arg && (*arg == '+' || *arg == '-'))))
2497 sals = decode_line_1 (&arg, 1, default_breakpoint_symtab,
2498 default_breakpoint_line, &canonical);
2500 sals = decode_line_1 (&arg, 1, (struct symtab *)NULL, 0, &canonical);
2508 /* Make sure that all storage allocated in decode_line_1 gets freed in case
2509 the following `for' loop errors out. */
2510 old_chain = make_cleanup (free, sals.sals);
2511 if (canonical != (char **)NULL)
2513 make_cleanup (free, canonical);
2514 canonical_strings_chain = make_cleanup (null_cleanup, 0);
2515 for (i = 0; i < sals.nelts; i++)
2517 if (canonical[i] != NULL)
2518 make_cleanup (free, canonical[i]);
2522 thread = -1; /* No specific thread yet */
2524 /* Resolve all line numbers to PC's, and verify that conditions
2525 can be parsed, before setting any breakpoints. */
2526 for (i = 0; i < sals.nelts; i++)
2528 char *tok, *end_tok;
2531 resolve_sal_pc (&sals.sals[i]);
2537 while (*tok == ' ' || *tok == '\t')
2542 while (*end_tok != ' ' && *end_tok != '\t' && *end_tok != '\000')
2545 toklen = end_tok - tok;
2547 if (toklen >= 1 && strncmp (tok, "if", toklen) == 0)
2549 tok = cond_start = end_tok + 1;
2550 cond = parse_exp_1 (&tok, block_for_pc (sals.sals[i].pc), 0);
2553 else if (toklen >= 1 && strncmp (tok, "thread", toklen) == 0)
2559 thread = strtol (tok, &tok, 0);
2561 error ("Junk after thread keyword.");
2562 if (!valid_thread_id (thread))
2563 error ("Unknown thread %d\n", thread);
2566 error ("Junk at end of arguments.");
2571 int i, target_resources_ok;
2573 i = hw_breakpoint_used_count ();
2574 target_resources_ok = TARGET_CAN_USE_HARDWARE_WATCHPOINT (
2575 bp_hardware_breakpoint, i + sals.nelts, 0);
2576 if (target_resources_ok == 0)
2577 error ("No hardware breakpoint support in the target.");
2578 else if (target_resources_ok < 0)
2579 error ("Hardware breakpoints used exceeds limit.");
2582 /* Remove the canonical strings from the cleanup, they are needed below. */
2583 if (canonical != (char **)NULL)
2584 discard_cleanups (canonical_strings_chain);
2586 /* Now set all the breakpoints. */
2587 for (i = 0; i < sals.nelts; i++)
2592 describe_other_breakpoints (sal.pc, sal.section);
2594 b = set_raw_breakpoint (sal);
2595 set_breakpoint_count (breakpoint_count + 1);
2596 b->number = breakpoint_count;
2597 b->type = hardwareflag ? bp_hardware_breakpoint : bp_breakpoint;
2601 /* If a canonical line spec is needed use that instead of the
2603 if (canonical != (char **)NULL && canonical[i] != NULL)
2604 b->addr_string = canonical[i];
2605 else if (addr_start)
2606 b->addr_string = savestring (addr_start, addr_end - addr_start);
2608 b->cond_string = savestring (cond_start, cond_end - cond_start);
2610 b->enable = enabled;
2611 b->disposition = tempflag ? del : donttouch;
2617 printf_filtered ("Multiple breakpoints were set.\n");
2618 printf_filtered ("Use the \"delete\" command to delete unwanted breakpoints.\n");
2620 do_cleanups (old_chain);
2623 /* Helper function for break_command_1 and disassemble_command. */
2626 resolve_sal_pc (sal)
2627 struct symtab_and_line *sal;
2631 if (sal->pc == 0 && sal->symtab != NULL)
2633 if (!find_line_pc (sal->symtab, sal->line, &pc))
2634 error ("No line %d in file \"%s\".",
2635 sal->line, sal->symtab->filename);
2639 if (sal->section == 0 && sal->symtab != NULL)
2641 struct blockvector *bv;
2646 bv = blockvector_for_pc_sect (sal->pc, 0, &index, sal->symtab);
2649 b = BLOCKVECTOR_BLOCK (bv, index);
2650 sym = block_function (b);
2653 fixup_symbol_section (sym, sal->symtab->objfile);
2654 sal->section = SYMBOL_BFD_SECTION (sym);
2658 /* It really is worthwhile to have the section, so we'll just
2659 have to look harder. This case can be executed if we have
2660 line numbers but no functions (as can happen in assembly
2663 struct minimal_symbol *msym;
2665 msym = lookup_minimal_symbol_by_pc (sal->pc);
2667 sal->section = SYMBOL_BFD_SECTION (msym);
2674 break_command (arg, from_tty)
2678 break_command_1 (arg, 0, from_tty);
2682 tbreak_command (arg, from_tty)
2686 break_command_1 (arg, BP_TEMPFLAG, from_tty);
2690 hbreak_command (arg, from_tty)
2694 break_command_1 (arg, BP_HARDWAREFLAG, from_tty);
2698 thbreak_command (arg, from_tty)
2702 break_command_1 (arg, (BP_TEMPFLAG | BP_HARDWAREFLAG), from_tty);
2706 /* accessflag: 0: watch write, 1: watch read, 2: watch access(read or write)
2709 watch_command_1 (arg, accessflag, from_tty)
2714 struct breakpoint *b;
2715 struct symtab_and_line sal;
2716 struct expression *exp;
2717 struct block *exp_valid_block;
2718 struct value *val, *mark;
2719 struct frame_info *frame;
2720 struct frame_info *prev_frame = NULL;
2721 char *exp_start = NULL;
2722 char *exp_end = NULL;
2723 char *tok, *end_tok;
2725 char *cond_start = NULL;
2726 char *cond_end = NULL;
2727 struct expression *cond = NULL;
2728 int i, other_type_used, target_resources_ok = 0;
2729 enum bptype bp_type;
2732 INIT_SAL (&sal); /* initialize to zeroes */
2734 /* Parse arguments. */
2735 innermost_block = NULL;
2737 exp = parse_exp_1 (&arg, 0, 0);
2739 exp_valid_block = innermost_block;
2740 mark = value_mark ();
2741 val = evaluate_expression (exp);
2742 release_value (val);
2743 if (VALUE_LAZY (val))
2744 value_fetch_lazy (val);
2747 while (*tok == ' ' || *tok == '\t')
2751 while (*end_tok != ' ' && *end_tok != '\t' && *end_tok != '\000')
2754 toklen = end_tok - tok;
2755 if (toklen >= 1 && strncmp (tok, "if", toklen) == 0)
2757 tok = cond_start = end_tok + 1;
2758 cond = parse_exp_1 (&tok, 0, 0);
2762 error("Junk at end of command.");
2764 if (accessflag == 1) bp_type = bp_read_watchpoint;
2765 else if (accessflag == 2) bp_type = bp_access_watchpoint;
2766 else bp_type = bp_hardware_watchpoint;
2768 mem_cnt = can_use_hardware_watchpoint (val);
2769 if (mem_cnt == 0 && bp_type != bp_hardware_watchpoint)
2770 error ("Expression cannot be implemented with read/access watchpoint.");
2772 i = hw_watchpoint_used_count (bp_type, &other_type_used);
2773 target_resources_ok = TARGET_CAN_USE_HARDWARE_WATCHPOINT(
2774 bp_type, i + mem_cnt, other_type_used);
2775 if (target_resources_ok == 0 && bp_type != bp_hardware_watchpoint)
2776 error ("Target does not have this type of hardware watchpoint support.");
2777 if (target_resources_ok < 0 && bp_type != bp_hardware_watchpoint)
2778 error ("Target resources have been allocated for other types of watchpoints.");
2781 /* Now set up the breakpoint. */
2782 b = set_raw_breakpoint (sal);
2783 set_breakpoint_count (breakpoint_count + 1);
2784 b->number = breakpoint_count;
2785 b->disposition = donttouch;
2787 b->exp_valid_block = exp_valid_block;
2788 b->exp_string = savestring (exp_start, exp_end - exp_start);
2792 b->cond_string = savestring (cond_start, cond_end - cond_start);
2796 frame = block_innermost_frame (exp_valid_block);
2799 prev_frame = get_prev_frame (frame);
2800 b->watchpoint_frame = frame->frame;
2803 b->watchpoint_frame = (CORE_ADDR)0;
2805 if (mem_cnt && target_resources_ok > 0)
2808 b->type = bp_watchpoint;
2810 /* If the expression is "local", then set up a "watchpoint scope"
2811 breakpoint at the point where we've left the scope of the watchpoint
2813 if (innermost_block)
2817 struct breakpoint *scope_breakpoint;
2818 struct symtab_and_line scope_sal;
2820 INIT_SAL (&scope_sal); /* initialize to zeroes */
2821 scope_sal.pc = get_frame_pc (prev_frame);
2822 scope_sal.section = find_pc_overlay (scope_sal.pc);
2824 scope_breakpoint = set_raw_breakpoint (scope_sal);
2825 set_breakpoint_count (breakpoint_count + 1);
2826 scope_breakpoint->number = breakpoint_count;
2828 scope_breakpoint->type = bp_watchpoint_scope;
2829 scope_breakpoint->enable = enabled;
2831 /* Automatically delete the breakpoint when it hits. */
2832 scope_breakpoint->disposition = del;
2834 /* Only break in the proper frame (help with recursion). */
2835 scope_breakpoint->frame = prev_frame->frame;
2837 /* Set the address at which we will stop. */
2838 scope_breakpoint->address = get_frame_pc (prev_frame);
2840 /* The scope breakpoint is related to the watchpoint. We
2841 will need to act on them together. */
2842 b->related_breakpoint = scope_breakpoint;
2845 value_free_to_mark (mark);
2849 /* Return count of locations need to be watched and can be handled
2850 in hardware. If the watchpoint can not be handled
2851 in hardware return zero. */
2854 can_use_hardware_watchpoint (v)
2857 int found_memory_cnt = 0;
2859 /* Make sure all the intermediate values are in memory. Also make sure
2860 we found at least one memory expression. Guards against watch 0x12345,
2861 which is meaningless, but could cause errors if one tries to insert a
2862 hardware watchpoint for the constant expression. */
2863 for ( ; v; v = v->next)
2865 if (v->lval == lval_memory)
2867 if (TYPE_LENGTH (VALUE_TYPE (v)) <= REGISTER_SIZE)
2870 else if (v->lval != not_lval && v->modifiable == 0)
2874 /* The expression itself looks suitable for using a hardware
2875 watchpoint, but give the target machine a chance to reject it. */
2876 return found_memory_cnt;
2879 static void watch_command (arg, from_tty)
2883 watch_command_1 (arg, 0, from_tty);
2886 static void rwatch_command (arg, from_tty)
2890 watch_command_1 (arg, 1, from_tty);
2893 static void awatch_command (arg, from_tty)
2897 watch_command_1 (arg, 2, from_tty);
2901 /* Helper routine for the until_command routine in infcmd.c. Here
2902 because it uses the mechanisms of breakpoints. */
2906 until_break_command (arg, from_tty)
2910 struct symtabs_and_lines sals;
2911 struct symtab_and_line sal;
2912 struct frame_info *prev_frame = get_prev_frame (selected_frame);
2913 struct breakpoint *breakpoint;
2914 struct cleanup *old_chain;
2916 clear_proceed_status ();
2918 /* Set a breakpoint where the user wants it and at return from
2921 if (default_breakpoint_valid)
2922 sals = decode_line_1 (&arg, 1, default_breakpoint_symtab,
2923 default_breakpoint_line, (char ***)NULL);
2925 sals = decode_line_1 (&arg, 1, (struct symtab *)NULL, 0, (char ***)NULL);
2927 if (sals.nelts != 1)
2928 error ("Couldn't get information on specified line.");
2931 free ((PTR)sals.sals); /* malloc'd, so freed */
2934 error ("Junk at end of arguments.");
2936 resolve_sal_pc (&sal);
2938 breakpoint = set_momentary_breakpoint (sal, selected_frame, bp_until);
2940 old_chain = make_cleanup(delete_breakpoint, breakpoint);
2942 /* Keep within the current frame */
2946 sal = find_pc_line (prev_frame->pc, 0);
2947 sal.pc = prev_frame->pc;
2948 breakpoint = set_momentary_breakpoint (sal, prev_frame, bp_until);
2949 make_cleanup(delete_breakpoint, breakpoint);
2952 proceed (-1, TARGET_SIGNAL_DEFAULT, 0);
2953 do_cleanups(old_chain);
2957 /* These aren't used; I don't konw what they were for. */
2958 /* Set a breakpoint at the catch clause for NAME. */
2960 catch_breakpoint (name)
2966 disable_catch_breakpoint ()
2971 delete_catch_breakpoint ()
2976 enable_catch_breakpoint ()
2983 struct sal_chain *next;
2984 struct symtab_and_line sal;
2988 /* This isn't used; I don't know what it was for. */
2989 /* For each catch clause identified in ARGS, run FUNCTION
2990 with that clause as an argument. */
2991 static struct symtabs_and_lines
2992 map_catch_names (args, function)
2996 register char *p = args;
2998 struct symtabs_and_lines sals;
3000 struct sal_chain *sal_chain = 0;
3004 error_no_arg ("one or more catch names");
3012 /* Don't swallow conditional part. */
3013 if (p1[0] == 'i' && p1[1] == 'f'
3014 && (p1[2] == ' ' || p1[2] == '\t'))
3020 while (isalnum (*p1) || *p1 == '_' || *p1 == '$')
3024 if (*p1 && *p1 != ' ' && *p1 != '\t')
3025 error ("Arguments must be catch names.");
3031 struct sal_chain *next = (struct sal_chain *)
3032 alloca (sizeof (struct sal_chain));
3033 next->next = sal_chain;
3034 next->sal = get_catch_sal (p);
3039 printf_unfiltered ("No catch clause for exception %s.\n", p);
3044 while (*p == ' ' || *p == '\t') p++;
3049 /* This shares a lot of code with `print_frame_label_vars' from stack.c. */
3051 static struct symtabs_and_lines
3052 get_catch_sals (this_level_only)
3053 int this_level_only;
3055 register struct blockvector *bl;
3056 register struct block *block;
3057 int index, have_default = 0;
3059 struct symtabs_and_lines sals;
3060 struct sal_chain *sal_chain = 0;
3061 char *blocks_searched;
3063 /* Not sure whether an error message is always the correct response,
3064 but it's better than a core dump. */
3065 if (selected_frame == NULL)
3066 error ("No selected frame.");
3067 block = get_frame_block (selected_frame);
3068 pc = selected_frame->pc;
3074 error ("No symbol table info available.\n");
3076 bl = blockvector_for_pc (BLOCK_END (block) - 4, &index);
3077 blocks_searched = (char *) alloca (BLOCKVECTOR_NBLOCKS (bl) * sizeof (char));
3078 memset (blocks_searched, 0, BLOCKVECTOR_NBLOCKS (bl) * sizeof (char));
3082 CORE_ADDR end = BLOCK_END (block) - 4;
3085 if (bl != blockvector_for_pc (end, &index))
3086 error ("blockvector blotch");
3087 if (BLOCKVECTOR_BLOCK (bl, index) != block)
3088 error ("blockvector botch");
3089 last_index = BLOCKVECTOR_NBLOCKS (bl);
3092 /* Don't print out blocks that have gone by. */
3093 while (index < last_index
3094 && BLOCK_END (BLOCKVECTOR_BLOCK (bl, index)) < pc)
3097 while (index < last_index
3098 && BLOCK_END (BLOCKVECTOR_BLOCK (bl, index)) < end)
3100 if (blocks_searched[index] == 0)
3102 struct block *b = BLOCKVECTOR_BLOCK (bl, index);
3105 register struct symbol *sym;
3107 nsyms = BLOCK_NSYMS (b);
3109 for (i = 0; i < nsyms; i++)
3111 sym = BLOCK_SYM (b, i);
3112 if (STREQ (SYMBOL_NAME (sym), "default"))
3118 if (SYMBOL_CLASS (sym) == LOC_LABEL)
3120 struct sal_chain *next = (struct sal_chain *)
3121 alloca (sizeof (struct sal_chain));
3122 next->next = sal_chain;
3123 next->sal = find_pc_line (SYMBOL_VALUE_ADDRESS (sym), 0);
3127 blocks_searched[index] = 1;
3133 if (sal_chain && this_level_only)
3136 /* After handling the function's top-level block, stop.
3137 Don't continue to its superblock, the block of
3138 per-file symbols. */
3139 if (BLOCK_FUNCTION (block))
3141 block = BLOCK_SUPERBLOCK (block);
3146 struct sal_chain *tmp_chain;
3148 /* Count the number of entries. */
3149 for (index = 0, tmp_chain = sal_chain; tmp_chain;
3150 tmp_chain = tmp_chain->next)
3154 sals.sals = (struct symtab_and_line *)
3155 xmalloc (index * sizeof (struct symtab_and_line));
3156 for (index = 0; sal_chain; sal_chain = sal_chain->next, index++)
3157 sals.sals[index] = sal_chain->sal;
3163 /* Commands to deal with catching exceptions. */
3166 catch_command_1 (arg, tempflag, from_tty)
3171 /* First, translate ARG into something we can deal with in terms
3174 struct symtabs_and_lines sals;
3175 struct symtab_and_line sal;
3176 register struct expression *cond = 0;
3177 register struct breakpoint *b;
3181 INIT_SAL (&sal); /* initialize to zeroes */
3183 /* If no arg given, or if first arg is 'if ', all active catch clauses
3184 are breakpointed. */
3186 if (!arg || (arg[0] == 'i' && arg[1] == 'f'
3187 && (arg[2] == ' ' || arg[2] == '\t')))
3189 /* Grab all active catch clauses. */
3190 sals = get_catch_sals (0);
3194 /* Grab selected catch clauses. */
3195 error ("catch NAME not implemented");
3197 /* This isn't used; I don't know what it was for. */
3198 sals = map_catch_names (arg, catch_breakpoint);
3206 for (i = 0; i < sals.nelts; i++)
3208 resolve_sal_pc (&sals.sals[i]);
3212 if (arg[0] == 'i' && arg[1] == 'f'
3213 && (arg[2] == ' ' || arg[2] == '\t'))
3214 cond = parse_exp_1 ((arg += 2, &arg),
3215 block_for_pc (sals.sals[i].pc), 0);
3217 error ("Junk at end of arguments.");
3222 for (i = 0; i < sals.nelts; i++)
3227 describe_other_breakpoints (sal.pc, sal.section);
3229 b = set_raw_breakpoint (sal);
3230 set_breakpoint_count (breakpoint_count + 1);
3231 b->number = breakpoint_count;
3232 b->type = bp_breakpoint;
3234 b->enable = enabled;
3235 b->disposition = tempflag ? del : donttouch;
3242 printf_unfiltered ("Multiple breakpoints were set.\n");
3243 printf_unfiltered ("Use the \"delete\" command to delete unwanted breakpoints.\n");
3245 free ((PTR)sals.sals);
3248 /* Used by the gui, could be made a worker for other things. */
3251 set_breakpoint_sal (sal)
3252 struct symtab_and_line sal;
3254 struct breakpoint *b;
3255 b = set_raw_breakpoint (sal);
3256 set_breakpoint_count (breakpoint_count + 1);
3257 b->number = breakpoint_count;
3258 b->type = bp_breakpoint;
3265 /* These aren't used; I don't know what they were for. */
3266 /* Disable breakpoints on all catch clauses described in ARGS. */
3268 disable_catch (args)
3271 /* Map the disable command to catch clauses described in ARGS. */
3274 /* Enable breakpoints on all catch clauses described in ARGS. */
3279 /* Map the disable command to catch clauses described in ARGS. */
3282 /* Delete breakpoints on all catch clauses in the active scope. */
3287 /* Map the delete command to catch clauses described in ARGS. */
3292 catch_command (arg, from_tty)
3296 catch_command_1 (arg, 0, from_tty);
3300 clear_command (arg, from_tty)
3304 register struct breakpoint *b, *b1;
3305 struct symtabs_and_lines sals;
3306 struct symtab_and_line sal;
3307 register struct breakpoint *found;
3312 sals = decode_line_spec (arg, 1);
3316 sals.sals = (struct symtab_and_line *)
3317 xmalloc (sizeof (struct symtab_and_line));
3318 INIT_SAL (&sal); /* initialize to zeroes */
3319 sal.line = default_breakpoint_line;
3320 sal.symtab = default_breakpoint_symtab;
3321 if (sal.symtab == 0)
3322 error ("No source file specified.");
3328 for (i = 0; i < sals.nelts; i++)
3330 /* If exact pc given, clear bpts at that pc.
3331 But if sal.pc is zero, clear all bpts on specified line. */
3333 found = (struct breakpoint *) 0;
3335 while (breakpoint_chain
3337 ? (breakpoint_chain->address == sal.pc &&
3338 (overlay_debugging == 0 ||
3339 breakpoint_chain->section == sal.section))
3340 : (breakpoint_chain->source_file != NULL
3341 && sal.symtab != NULL
3342 && STREQ (breakpoint_chain->source_file,
3343 sal.symtab->filename)
3344 && breakpoint_chain->line_number == sal.line)))
3346 b1 = breakpoint_chain;
3347 breakpoint_chain = b1->next;
3354 && b->next->type != bp_watchpoint
3355 && b->next->type != bp_hardware_watchpoint
3356 && b->next->type != bp_read_watchpoint
3357 && b->next->type != bp_access_watchpoint
3359 ? (b->next->address == sal.pc &&
3360 (overlay_debugging == 0 ||
3361 b->next->section == sal.section))
3362 : (b->next->source_file != NULL
3363 && sal.symtab != NULL
3364 && STREQ (b->next->source_file, sal.symtab->filename)
3365 && b->next->line_number == sal.line)))
3376 error ("No breakpoint at %s.", arg);
3378 error ("No breakpoint at this line.");
3381 if (found->next) from_tty = 1; /* Always report if deleted more than one */
3382 if (from_tty) printf_unfiltered ("Deleted breakpoint%s ", found->next ? "s" : "");
3383 breakpoints_changed ();
3386 if (from_tty) printf_unfiltered ("%d ", found->number);
3388 delete_breakpoint (found);
3391 if (from_tty) putchar_unfiltered ('\n');
3393 free ((PTR)sals.sals);
3396 /* Delete breakpoint in BS if they are `delete' breakpoints and
3397 all breakpoints that are marked for deletion, whether hit or not.
3398 This is called after any breakpoint is hit, or after errors. */
3401 breakpoint_auto_delete (bs)
3404 struct breakpoint *b, *temp;
3406 for (; bs; bs = bs->next)
3407 if (bs->breakpoint_at && bs->breakpoint_at->disposition == del
3409 delete_breakpoint (bs->breakpoint_at);
3411 ALL_BREAKPOINTS_SAFE (b, temp)
3413 if (b->disposition == del_at_next_stop)
3414 delete_breakpoint (b);
3418 /* Delete a breakpoint and clean up all traces of it in the data structures. */
3421 delete_breakpoint (bpt)
3422 struct breakpoint *bpt;
3424 register struct breakpoint *b;
3427 if (delete_breakpoint_hook)
3428 delete_breakpoint_hook (bpt);
3431 remove_breakpoint (bpt);
3433 if (breakpoint_chain == bpt)
3434 breakpoint_chain = bpt->next;
3439 b->next = bpt->next;
3443 check_duplicates (bpt->address, bpt->section);
3444 /* If this breakpoint was inserted, and there is another breakpoint
3445 at the same address, we need to insert the other breakpoint. */
3447 && bpt->type != bp_hardware_watchpoint
3448 && bpt->type != bp_read_watchpoint
3449 && bpt->type != bp_access_watchpoint)
3452 if (b->address == bpt->address
3453 && b->section == bpt->section
3455 && b->enable != disabled
3456 && b->enable != shlib_disabled)
3459 val = target_insert_breakpoint (b->address, b->shadow_contents);
3462 target_terminal_ours_for_output ();
3463 fprintf_unfiltered (gdb_stderr, "Cannot insert breakpoint %d:\n", b->number);
3464 memory_error (val, b->address); /* which bombs us out */
3471 free_command_lines (&bpt->commands);
3474 if (bpt->cond_string != NULL)
3475 free (bpt->cond_string);
3476 if (bpt->addr_string != NULL)
3477 free (bpt->addr_string);
3478 if (bpt->exp != NULL)
3480 if (bpt->exp_string != NULL)
3481 free (bpt->exp_string);
3482 if (bpt->val != NULL)
3483 value_free (bpt->val);
3484 if (bpt->source_file != NULL)
3485 free (bpt->source_file);
3487 /* Be sure no bpstat's are pointing at it after it's been freed. */
3488 /* FIXME, how can we find all bpstat's?
3489 We just check stop_bpstat for now. */
3490 for (bs = stop_bpstat; bs; bs = bs->next)
3491 if (bs->breakpoint_at == bpt)
3492 bs->breakpoint_at = NULL;
3497 delete_command (arg, from_tty)
3501 struct breakpoint *b, *temp;
3505 int breaks_to_delete = 0;
3507 /* Delete all breakpoints if no argument.
3508 Do not delete internal or call-dummy breakpoints, these
3509 have to be deleted with an explicit breakpoint number argument. */
3512 if (b->type != bp_call_dummy && b->number >= 0)
3513 breaks_to_delete = 1;
3516 /* Ask user only if there are some breakpoints to delete. */
3518 || (breaks_to_delete && query ("Delete all breakpoints? ")))
3520 ALL_BREAKPOINTS_SAFE (b, temp)
3522 if (b->type != bp_call_dummy && b->number >= 0)
3523 delete_breakpoint (b);
3528 map_breakpoint_numbers (arg, delete_breakpoint);
3531 /* Reset a breakpoint given it's struct breakpoint * BINT.
3532 The value we return ends up being the return value from catch_errors.
3533 Unused in this case. */
3536 breakpoint_re_set_one (bint)
3539 struct breakpoint *b = (struct breakpoint *)bint; /* get past catch_errs */
3542 struct symtabs_and_lines sals;
3544 enum enable save_enable;
3549 case bp_hardware_breakpoint:
3550 if (b->addr_string == NULL)
3552 /* Anything without a string can't be re-set. */
3553 delete_breakpoint (b);
3556 /* In case we have a problem, disable this breakpoint. We'll restore
3557 its status if we succeed. */
3558 save_enable = b->enable;
3559 b->enable = disabled;
3561 set_language (b->language);
3562 input_radix = b->input_radix;
3564 sals = decode_line_1 (&s, 1, (struct symtab *)NULL, 0, (char ***)NULL);
3565 for (i = 0; i < sals.nelts; i++)
3567 resolve_sal_pc (&sals.sals[i]);
3569 /* Reparse conditions, they might contain references to the
3571 if (b->cond_string != NULL)
3575 free ((PTR)b->cond);
3576 b->cond = parse_exp_1 (&s, block_for_pc (sals.sals[i].pc), 0);
3579 /* We need to re-set the breakpoint if the address changes...*/
3580 if (b->address != sals.sals[i].pc
3581 /* ...or new and old breakpoints both have source files, and
3582 the source file name or the line number changes... */
3583 || (b->source_file != NULL
3584 && sals.sals[i].symtab != NULL
3585 && (!STREQ (b->source_file, sals.sals[i].symtab->filename)
3586 || b->line_number != sals.sals[i].line)
3588 /* ...or we switch between having a source file and not having
3590 || ((b->source_file == NULL) != (sals.sals[i].symtab == NULL))
3593 if (b->source_file != NULL)
3594 free (b->source_file);
3595 if (sals.sals[i].symtab == NULL)
3596 b->source_file = NULL;
3599 savestring (sals.sals[i].symtab->filename,
3600 strlen (sals.sals[i].symtab->filename));
3601 b->line_number = sals.sals[i].line;
3602 b->address = sals.sals[i].pc;
3603 check_duplicates (b->address, b->section);
3607 /* Might be better to do this just once per breakpoint_re_set,
3608 rather than once for every breakpoint. */
3609 breakpoints_changed ();
3611 b->section = sals.sals[i].section;
3612 b->enable = save_enable; /* Restore it, this worked. */
3614 free ((PTR)sals.sals);
3618 case bp_hardware_watchpoint:
3619 case bp_read_watchpoint:
3620 case bp_access_watchpoint:
3621 innermost_block = NULL;
3622 /* The issue arises of what context to evaluate this in. The same
3623 one as when it was set, but what does that mean when symbols have
3624 been re-read? We could save the filename and functionname, but
3625 if the context is more local than that, the best we could do would
3626 be something like how many levels deep and which index at that
3627 particular level, but that's going to be less stable than filenames
3628 or functionnames. */
3629 /* So for now, just use a global context. */
3632 b->exp = parse_expression (b->exp_string);
3633 b->exp_valid_block = innermost_block;
3634 mark = value_mark ();
3636 value_free (b->val);
3637 b->val = evaluate_expression (b->exp);
3638 release_value (b->val);
3639 if (VALUE_LAZY (b->val))
3640 value_fetch_lazy (b->val);
3642 if (b->cond_string != NULL)
3646 free ((PTR)b->cond);
3647 b->cond = parse_exp_1 (&s, (struct block *)0, 0);
3649 if (b->enable == enabled)
3651 value_free_to_mark (mark);
3655 printf_filtered ("Deleting unknown breakpoint type %d\n", b->type);
3657 /* Delete longjmp breakpoints, they will be reset later by
3658 breakpoint_re_set. */
3660 case bp_longjmp_resume:
3661 delete_breakpoint (b);
3664 /* This breakpoint is special, it's set up when the inferior
3665 starts and we really don't want to touch it. */
3666 case bp_shlib_event:
3668 /* Keep temporary breakpoints, which can be encountered when we step
3669 over a dlopen call and SOLIB_ADD is resetting the breakpoints.
3670 Otherwise these should have been blown away via the cleanup chain
3671 or by breakpoint_init_inferior when we rerun the executable. */
3674 case bp_watchpoint_scope:
3676 case bp_step_resume:
3683 /* Re-set all breakpoints after symbols have been re-loaded. */
3685 breakpoint_re_set ()
3687 struct breakpoint *b, *temp;
3688 enum language save_language;
3689 int save_input_radix;
3690 static char message1[] = "Error in re-setting breakpoint %d:\n";
3691 char message[sizeof (message1) + 30 /* slop */];
3693 save_language = current_language->la_language;
3694 save_input_radix = input_radix;
3695 ALL_BREAKPOINTS_SAFE (b, temp)
3697 sprintf (message, message1, b->number); /* Format possible error msg */
3698 catch_errors (breakpoint_re_set_one, (char *) b, message,
3701 set_language (save_language);
3702 input_radix = save_input_radix;
3704 #ifdef GET_LONGJMP_TARGET
3705 create_longjmp_breakpoint ("longjmp");
3706 create_longjmp_breakpoint ("_longjmp");
3707 create_longjmp_breakpoint ("siglongjmp");
3708 create_longjmp_breakpoint ("_siglongjmp");
3709 create_longjmp_breakpoint (NULL);
3713 /* Took this out (temporarily at least), since it produces an extra
3714 blank line at startup. This messes up the gdbtests. -PB */
3715 /* Blank line to finish off all those mention() messages we just printed. */
3716 printf_filtered ("\n");
3720 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
3721 If from_tty is nonzero, it prints a message to that effect,
3722 which ends with a period (no newline). */
3725 set_ignore_count (bptnum, count, from_tty)
3726 int bptnum, count, from_tty;
3728 register struct breakpoint *b;
3734 if (b->number == bptnum)
3736 b->ignore_count = count;
3739 else if (count == 0)
3740 printf_filtered ("Will stop next time breakpoint %d is reached.",
3742 else if (count == 1)
3743 printf_filtered ("Will ignore next crossing of breakpoint %d.",
3746 printf_filtered ("Will ignore next %d crossings of breakpoint %d.",
3748 breakpoints_changed ();
3752 error ("No breakpoint number %d.", bptnum);
3755 /* Clear the ignore counts of all breakpoints. */
3757 breakpoint_clear_ignore_counts ()
3759 struct breakpoint *b;
3762 b->ignore_count = 0;
3765 /* Command to set ignore-count of breakpoint N to COUNT. */
3768 ignore_command (args, from_tty)
3776 error_no_arg ("a breakpoint number");
3778 num = get_number (&p);
3781 error ("Second argument (specified ignore-count) is missing.");
3783 set_ignore_count (num,
3784 longest_to_int (value_as_long (parse_and_eval (p))),
3786 printf_filtered ("\n");
3787 breakpoints_changed ();
3790 /* Call FUNCTION on each of the breakpoints
3791 whose numbers are given in ARGS. */
3794 map_breakpoint_numbers (args, function)
3796 void (*function) PARAMS ((struct breakpoint *));
3798 register char *p = args;
3801 register struct breakpoint *b;
3804 error_no_arg ("one or more breakpoint numbers");
3810 num = get_number (&p1);
3813 if (b->number == num)
3815 struct breakpoint *related_breakpoint = b->related_breakpoint;
3817 if (related_breakpoint)
3818 function (related_breakpoint);
3821 printf_unfiltered ("No breakpoint number %d.\n", num);
3828 disable_breakpoint (bpt)
3829 struct breakpoint *bpt;
3831 /* Never disable a watchpoint scope breakpoint; we want to
3832 hit them when we leave scope so we can delete both the
3833 watchpoint and its scope breakpoint at that time. */
3834 if (bpt->type == bp_watchpoint_scope)
3837 bpt->enable = disabled;
3839 check_duplicates (bpt->address, bpt->section);
3841 if (modify_breakpoint_hook)
3842 modify_breakpoint_hook (bpt);
3847 disable_command (args, from_tty)
3851 register struct breakpoint *bpt;
3853 ALL_BREAKPOINTS (bpt)
3857 case bp_hardware_breakpoint:
3859 case bp_hardware_watchpoint:
3860 case bp_read_watchpoint:
3861 case bp_access_watchpoint:
3862 disable_breakpoint (bpt);
3867 map_breakpoint_numbers (args, disable_breakpoint);
3871 do_enable_breakpoint (bpt, disposition)
3872 struct breakpoint *bpt;
3873 enum bpdisp disposition;
3875 struct frame_info *save_selected_frame = NULL;
3876 int save_selected_frame_level = -1;
3877 int target_resources_ok, other_type_used;
3880 if (bpt->type == bp_hardware_breakpoint)
3883 i = hw_breakpoint_used_count();
3884 target_resources_ok = TARGET_CAN_USE_HARDWARE_WATCHPOINT(
3885 bp_hardware_breakpoint, i+1, 0);
3886 if (target_resources_ok == 0)
3887 error ("No hardware breakpoint support in the target.");
3888 else if (target_resources_ok < 0)
3889 error ("Hardware breakpoints used exceeds limit.");
3892 bpt->enable = enabled;
3893 bpt->disposition = disposition;
3894 check_duplicates (bpt->address, bpt->section);
3895 breakpoints_changed ();
3897 if (bpt->type == bp_watchpoint || bpt->type == bp_hardware_watchpoint ||
3898 bpt->type == bp_read_watchpoint || bpt->type == bp_access_watchpoint)
3900 if (bpt->exp_valid_block != NULL)
3902 struct frame_info *fr =
3903 find_frame_addr_in_frame_chain (bpt->watchpoint_frame);
3907 Cannot enable watchpoint %d because the block in which its expression\n\
3908 is valid is not currently in scope.\n", bpt->number);
3909 bpt->enable = disabled;
3913 save_selected_frame = selected_frame;
3914 save_selected_frame_level = selected_frame_level;
3915 select_frame (fr, -1);
3918 value_free (bpt->val);
3919 mark = value_mark ();
3920 bpt->val = evaluate_expression (bpt->exp);
3921 release_value (bpt->val);
3922 if (VALUE_LAZY (bpt->val))
3923 value_fetch_lazy (bpt->val);
3925 if (bpt->type == bp_hardware_watchpoint ||
3926 bpt->type == bp_read_watchpoint ||
3927 bpt->type == bp_access_watchpoint)
3929 int i = hw_watchpoint_used_count (bpt->type, &other_type_used);
3930 int mem_cnt = can_use_hardware_watchpoint (bpt->val);
3932 target_resources_ok = TARGET_CAN_USE_HARDWARE_WATCHPOINT(
3933 bpt->type, i + mem_cnt, other_type_used);
3934 /* we can consider of type is bp_hardware_watchpoint, convert to
3935 bp_watchpoint in the following condition */
3936 if (target_resources_ok < 0)
3939 Cannot enable watchpoint %d because target watch resources\n\
3940 have been allocated for other watchpoints.\n", bpt->number);
3941 bpt->enable = disabled;
3942 value_free_to_mark (mark);
3947 if (save_selected_frame_level >= 0)
3948 select_frame (save_selected_frame, save_selected_frame_level);
3949 value_free_to_mark (mark);
3951 if (modify_breakpoint_hook)
3952 modify_breakpoint_hook (bpt);
3956 enable_breakpoint (bpt)
3957 struct breakpoint *bpt;
3959 do_enable_breakpoint (bpt, bpt->disposition);
3962 /* The enable command enables the specified breakpoints (or all defined
3963 breakpoints) so they once again become (or continue to be) effective
3964 in stopping the inferior. */
3968 enable_command (args, from_tty)
3972 register struct breakpoint *bpt;
3974 ALL_BREAKPOINTS (bpt)
3978 case bp_hardware_breakpoint:
3980 case bp_hardware_watchpoint:
3981 case bp_read_watchpoint:
3982 case bp_access_watchpoint:
3983 enable_breakpoint (bpt);
3988 map_breakpoint_numbers (args, enable_breakpoint);
3992 enable_once_breakpoint (bpt)
3993 struct breakpoint *bpt;
3995 do_enable_breakpoint (bpt, disable);
4000 enable_once_command (args, from_tty)
4004 map_breakpoint_numbers (args, enable_once_breakpoint);
4008 enable_delete_breakpoint (bpt)
4009 struct breakpoint *bpt;
4011 do_enable_breakpoint (bpt, del);
4016 enable_delete_command (args, from_tty)
4020 map_breakpoint_numbers (args, enable_delete_breakpoint);
4023 /* Use default_breakpoint_'s, or nothing if they aren't valid. */
4025 struct symtabs_and_lines
4026 decode_line_spec_1 (string, funfirstline)
4030 struct symtabs_and_lines sals;
4032 error ("Empty line specification.");
4033 if (default_breakpoint_valid)
4034 sals = decode_line_1 (&string, funfirstline,
4035 default_breakpoint_symtab, default_breakpoint_line,
4038 sals = decode_line_1 (&string, funfirstline,
4039 (struct symtab *)NULL, 0, (char ***)NULL);
4041 error ("Junk at end of line specification: %s", string);
4046 _initialize_breakpoint ()
4048 breakpoint_chain = 0;
4049 /* Don't bother to call set_breakpoint_count. $bpnum isn't useful
4050 before a breakpoint is set. */
4051 breakpoint_count = 0;
4053 add_com ("ignore", class_breakpoint, ignore_command,
4054 "Set ignore-count of breakpoint number N to COUNT.\n\
4055 Usage is `ignore N COUNT'.");
4057 add_com ("commands", class_breakpoint, commands_command,
4058 "Set commands to be executed when a breakpoint is hit.\n\
4059 Give breakpoint number as argument after \"commands\".\n\
4060 With no argument, the targeted breakpoint is the last one set.\n\
4061 The commands themselves follow starting on the next line.\n\
4062 Type a line containing \"end\" to indicate the end of them.\n\
4063 Give \"silent\" as the first line to make the breakpoint silent;\n\
4064 then no output is printed when it is hit, except what the commands print.");
4066 add_com ("condition", class_breakpoint, condition_command,
4067 "Specify breakpoint number N to break only if COND is true.\n\
4068 Usage is `condition N COND', where N is an integer and COND is an\n\
4069 expression to be evaluated whenever breakpoint N is reached. ");
4071 add_com ("tbreak", class_breakpoint, tbreak_command,
4072 "Set a temporary breakpoint. Args like \"break\" command.\n\
4073 Like \"break\" except the breakpoint is only temporary,\n\
4074 so it will be deleted when hit. Equivalent to \"break\" followed\n\
4075 by using \"enable delete\" on the breakpoint number.");
4077 add_com ("hbreak", class_breakpoint, hbreak_command,
4078 "Set a hardware assisted breakpoint. Args like \"break\" command.\n\
4079 Like \"break\" except the breakpoint requires hardware support,\n\
4080 some target hardware may not have this support.");
4082 add_com ("thbreak", class_breakpoint, thbreak_command,
4083 "Set a temporary hardware assisted breakpoint. Args like \"break\" command.\n\
4084 Like \"hbreak\" except the breakpoint is only temporary,\n\
4085 so it will be deleted when hit.");
4087 add_prefix_cmd ("enable", class_breakpoint, enable_command,
4088 "Enable some breakpoints.\n\
4089 Give breakpoint numbers (separated by spaces) as arguments.\n\
4090 With no subcommand, breakpoints are enabled until you command otherwise.\n\
4091 This is used to cancel the effect of the \"disable\" command.\n\
4092 With a subcommand you can enable temporarily.",
4093 &enablelist, "enable ", 1, &cmdlist);
4095 add_com_alias ("en", "enable", class_breakpoint, 1);
4097 add_abbrev_prefix_cmd ("breakpoints", class_breakpoint, enable_command,
4098 "Enable some breakpoints.\n\
4099 Give breakpoint numbers (separated by spaces) as arguments.\n\
4100 This is used to cancel the effect of the \"disable\" command.\n\
4101 May be abbreviated to simply \"enable\".\n",
4102 &enablebreaklist, "enable breakpoints ", 1, &enablelist);
4104 add_cmd ("once", no_class, enable_once_command,
4105 "Enable breakpoints for one hit. Give breakpoint numbers.\n\
4106 If a breakpoint is hit while enabled in this fashion, it becomes disabled.",
4109 add_cmd ("delete", no_class, enable_delete_command,
4110 "Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
4111 If a breakpoint is hit while enabled in this fashion, it is deleted.",
4114 add_cmd ("delete", no_class, enable_delete_command,
4115 "Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
4116 If a breakpoint is hit while enabled in this fashion, it is deleted.",
4119 add_cmd ("once", no_class, enable_once_command,
4120 "Enable breakpoints for one hit. Give breakpoint numbers.\n\
4121 If a breakpoint is hit while enabled in this fashion, it becomes disabled.",
4124 add_prefix_cmd ("disable", class_breakpoint, disable_command,
4125 "Disable some breakpoints.\n\
4126 Arguments are breakpoint numbers with spaces in between.\n\
4127 To disable all breakpoints, give no argument.\n\
4128 A disabled breakpoint is not forgotten, but has no effect until reenabled.",
4129 &disablelist, "disable ", 1, &cmdlist);
4130 add_com_alias ("dis", "disable", class_breakpoint, 1);
4131 add_com_alias ("disa", "disable", class_breakpoint, 1);
4133 add_cmd ("breakpoints", class_alias, disable_command,
4134 "Disable some breakpoints.\n\
4135 Arguments are breakpoint numbers with spaces in between.\n\
4136 To disable all breakpoints, give no argument.\n\
4137 A disabled breakpoint is not forgotten, but has no effect until reenabled.\n\
4138 This command may be abbreviated \"disable\".",
4141 add_prefix_cmd ("delete", class_breakpoint, delete_command,
4142 "Delete some breakpoints or auto-display expressions.\n\
4143 Arguments are breakpoint numbers with spaces in between.\n\
4144 To delete all breakpoints, give no argument.\n\
4146 Also a prefix command for deletion of other GDB objects.\n\
4147 The \"unset\" command is also an alias for \"delete\".",
4148 &deletelist, "delete ", 1, &cmdlist);
4149 add_com_alias ("d", "delete", class_breakpoint, 1);
4151 add_cmd ("breakpoints", class_alias, delete_command,
4152 "Delete some breakpoints or auto-display expressions.\n\
4153 Arguments are breakpoint numbers with spaces in between.\n\
4154 To delete all breakpoints, give no argument.\n\
4155 This command may be abbreviated \"delete\".",
4158 add_com ("clear", class_breakpoint, clear_command,
4159 concat ("Clear breakpoint at specified line or function.\n\
4160 Argument may be line number, function name, or \"*\" and an address.\n\
4161 If line number is specified, all breakpoints in that line are cleared.\n\
4162 If function is specified, breakpoints at beginning of function are cleared.\n\
4163 If an address is specified, breakpoints at that address are cleared.\n\n",
4164 "With no argument, clears all breakpoints in the line that the selected frame\n\
4167 See also the \"delete\" command which clears breakpoints by number.", NULL));
4169 add_com ("break", class_breakpoint, break_command,
4170 concat ("Set breakpoint at specified line or function.\n\
4171 Argument may be line number, function name, or \"*\" and an address.\n\
4172 If line number is specified, break at start of code for that line.\n\
4173 If function is specified, break at start of code for that function.\n\
4174 If an address is specified, break at that exact address.\n",
4175 "With no arg, uses current execution address of selected stack frame.\n\
4176 This is useful for breaking on return to a stack frame.\n\
4178 Multiple breakpoints at one place are permitted, and useful if conditional.\n\
4180 Do \"help breakpoints\" for info on other commands dealing with breakpoints.", NULL));
4181 add_com_alias ("b", "break", class_run, 1);
4182 add_com_alias ("br", "break", class_run, 1);
4183 add_com_alias ("bre", "break", class_run, 1);
4184 add_com_alias ("brea", "break", class_run, 1);
4186 add_info ("breakpoints", breakpoints_info,
4187 concat ("Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
4188 The \"Type\" column indicates one of:\n\
4189 \tbreakpoint - normal breakpoint\n\
4190 \twatchpoint - watchpoint\n\
4191 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
4192 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
4193 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
4194 address and file/line number respectively.\n\n",
4195 "Convenience variable \"$_\" and default examine address for \"x\"\n\
4196 are set to the address of the last breakpoint listed.\n\n\
4197 Convenience variable \"$bpnum\" contains the number of the last\n\
4198 breakpoint set.", NULL));
4200 #if MAINTENANCE_CMDS
4202 add_cmd ("breakpoints", class_maintenance, maintenance_info_breakpoints,
4203 concat ("Status of all breakpoints, or breakpoint number NUMBER.\n\
4204 The \"Type\" column indicates one of:\n\
4205 \tbreakpoint - normal breakpoint\n\
4206 \twatchpoint - watchpoint\n\
4207 \tlongjmp - internal breakpoint used to step through longjmp()\n\
4208 \tlongjmp resume - internal breakpoint at the target of longjmp()\n\
4209 \tuntil - internal breakpoint used by the \"until\" command\n\
4210 \tfinish - internal breakpoint used by the \"finish\" command\n",
4211 "The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
4212 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
4213 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
4214 address and file/line number respectively.\n\n",
4215 "Convenience variable \"$_\" and default examine address for \"x\"\n\
4216 are set to the address of the last breakpoint listed.\n\n\
4217 Convenience variable \"$bpnum\" contains the number of the last\n\
4218 breakpoint set.", NULL),
4219 &maintenanceinfolist);
4221 #endif /* MAINTENANCE_CMDS */
4223 add_com ("catch", class_breakpoint, catch_command,
4224 "Set breakpoints to catch exceptions that are raised.\n\
4225 Argument may be a single exception to catch, multiple exceptions\n\
4226 to catch, or the default exception \"default\". If no arguments\n\
4227 are given, breakpoints are set at all exception handlers catch clauses\n\
4228 within the current scope.\n\
4230 A condition specified for the catch applies to all breakpoints set\n\
4231 with this command\n\
4233 Do \"help breakpoints\" for info on other commands dealing with breakpoints.");
4235 add_com ("watch", class_breakpoint, watch_command,
4236 "Set a watchpoint for an expression.\n\
4237 A watchpoint stops execution of your program whenever the value of\n\
4238 an expression changes.");
4240 add_com ("rwatch", class_breakpoint, rwatch_command,
4241 "Set a read watchpoint for an expression.\n\
4242 A watchpoint stops execution of your program whenever the value of\n\
4243 an expression is read.");
4245 add_com ("awatch", class_breakpoint, awatch_command,
4246 "Set a watchpoint for an expression.\n\
4247 A watchpoint stops execution of your program whenever the value of\n\
4248 an expression is either read or written.");
4250 add_info ("watchpoints", breakpoints_info,
4251 "Synonym for ``info breakpoints''.");