1 /* Everything about breakpoints, for GDB.
2 Copyright 1986, 1987, 1989, 1990, 1991, 1992 Free Software Foundation, Inc.
4 This file is part of GDB.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
24 #include "breakpoint.h"
26 #include "expression.h"
38 /* local function prototypes */
41 catch_command_1 PARAMS ((char *, int, int));
44 enable_delete_command PARAMS ((char *, int));
47 enable_delete_breakpoint PARAMS ((struct breakpoint *));
50 enable_once_command PARAMS ((char *, int));
53 enable_once_breakpoint PARAMS ((struct breakpoint *));
56 disable_command PARAMS ((char *, int));
59 disable_breakpoint PARAMS ((struct breakpoint *));
62 enable_command PARAMS ((char *, int));
65 enable_breakpoint PARAMS ((struct breakpoint *));
68 map_breakpoint_numbers PARAMS ((char *, void (*)(struct breakpoint *)));
71 ignore_command PARAMS ((char *, int));
74 breakpoint_re_set_one PARAMS ((char *));
77 delete_command PARAMS ((char *, int));
80 clear_command PARAMS ((char *, int));
83 catch_command PARAMS ((char *, int));
85 static struct symtabs_and_lines
86 get_catch_sals PARAMS ((int));
89 watch_command PARAMS ((char *, int));
92 tbreak_command PARAMS ((char *, int));
95 break_command_1 PARAMS ((char *, int, int));
98 mention PARAMS ((struct breakpoint *));
100 static struct breakpoint *
101 set_raw_breakpoint PARAMS ((struct symtab_and_line));
104 check_duplicates PARAMS ((CORE_ADDR));
107 describe_other_breakpoints PARAMS ((CORE_ADDR));
110 breakpoints_info PARAMS ((char *, int));
113 breakpoint_1 PARAMS ((int, int));
116 bpstat_alloc PARAMS ((struct breakpoint *, bpstat));
119 breakpoint_cond_eval PARAMS ((char *));
122 cleanup_executing_breakpoints PARAMS ((int));
125 commands_command PARAMS ((char *, int));
128 condition_command PARAMS ((char *, int));
131 get_number PARAMS ((char **));
134 set_breakpoint_count PARAMS ((int));
137 extern int addressprint; /* Print machine addresses? */
138 extern int demangle; /* Print de-mangled symbol names? */
140 /* Are we executing breakpoint commands? */
141 static int executing_breakpoint_commands;
143 /* Walk the following statement or block through all breakpoints.
144 ALL_BREAKPOINTS_SAFE does so even if the statment deletes the current
147 #define ALL_BREAKPOINTS(b) for (b = breakpoint_chain; b; b = b->next)
149 #define ALL_BREAKPOINTS_SAFE(b,tmp) \
150 for (b = breakpoint_chain; \
151 b? (tmp=b->next, 1): 0; \
154 /* Chain of all breakpoints defined. */
156 struct breakpoint *breakpoint_chain;
158 /* Number of last breakpoint made. */
160 static int breakpoint_count;
162 /* Set breakpoint count to NUM. */
164 set_breakpoint_count (num)
167 breakpoint_count = num;
168 set_internalvar (lookup_internalvar ("bpnum"),
169 value_from_longest (builtin_type_int, (LONGEST) num));
172 /* Default address, symtab and line to put a breakpoint at
173 for "break" command with no arg.
174 if default_breakpoint_valid is zero, the other three are
175 not valid, and "break" with no arg is an error.
177 This set by print_stack_frame, which calls set_default_breakpoint. */
179 int default_breakpoint_valid;
180 CORE_ADDR default_breakpoint_address;
181 struct symtab *default_breakpoint_symtab;
182 int default_breakpoint_line;
184 /* Flag indicating extra verbosity for xgdb. */
185 extern int xgdb_verbose;
187 /* *PP is a string denoting a breakpoint. Get the number of the breakpoint.
188 Advance *PP after the string and any trailing whitespace.
190 Currently the string can either be a number or "$" followed by the name
191 of a convenience variable. Making it an expression wouldn't work well
192 for map_breakpoint_numbers (e.g. "4 + 5 + 6"). */
201 /* Empty line means refer to the last breakpoint. */
202 return breakpoint_count;
205 /* Make a copy of the name, so we can null-terminate it
206 to pass to lookup_internalvar(). */
211 while (isalnum (*p) || *p == '_')
213 varname = (char *) alloca (p - start + 1);
214 strncpy (varname, start, p - start);
215 varname[p - start] = '\0';
216 val = value_of_internalvar (lookup_internalvar (varname));
217 if (TYPE_CODE (VALUE_TYPE (val)) != TYPE_CODE_INT)
219 "Convenience variables used to specify breakpoints must have integer values."
221 retval = (int) value_as_long (val);
227 while (*p >= '0' && *p <= '9')
230 /* There is no number here. (e.g. "cond a == b"). */
231 error_no_arg ("breakpoint number");
234 if (!(isspace (*p) || *p == '\0'))
235 error ("breakpoint number expected");
242 /* condition N EXP -- set break condition of breakpoint N to EXP. */
245 condition_command (arg, from_tty)
249 register struct breakpoint *b;
254 error_no_arg ("breakpoint number");
257 bnum = get_number (&p);
260 if (b->number == bnum)
267 if (b->cond_string != NULL)
268 free ((PTR)b->cond_string);
273 b->cond_string = NULL;
275 printf_filtered ("Breakpoint %d now unconditional.\n", bnum);
280 /* I don't know if it matters whether this is the string the user
281 typed in or the decompiled expression. */
282 b->cond_string = savestring (arg, strlen (arg));
283 b->cond = parse_exp_1 (&arg, block_for_pc (b->address), 0);
285 error ("Junk at end of expression");
290 error ("No breakpoint number %d.", bnum);
295 commands_command (arg, from_tty)
299 register struct breakpoint *b;
302 struct command_line *l;
304 /* If we allowed this, we would have problems with when to
305 free the storage, if we change the commands currently
308 if (executing_breakpoint_commands)
309 error ("Can't use the \"commands\" command among a breakpoint's commands.");
312 bnum = get_number (&p);
314 error ("Unexpected extra arguments following breakpoint number.");
317 if (b->number == bnum)
319 if (from_tty && input_from_terminal_p ())
320 printf_filtered ("Type commands for when breakpoint %d is hit, one per line.\n\
321 End with a line saying just \"end\".\n", bnum);
322 l = read_command_lines ();
323 free_command_lines (&b->commands);
327 error ("No breakpoint number %d.", bnum);
330 extern int memory_breakpoint_size; /* from mem-break.c */
332 /* Like target_read_memory() but if breakpoints are inserted, return
333 the shadow contents instead of the breakpoints themselves.
335 Read "memory data" from whatever target or inferior we have.
336 Returns zero if successful, errno value if not. EIO is used
337 for address out of bounds. If breakpoints are inserted, returns
338 shadow contents, not the breakpoints themselves. From breakpoint.c. */
341 read_memory_nobpt (memaddr, myaddr, len)
347 struct breakpoint *b;
349 if (memory_breakpoint_size < 0)
350 /* No breakpoints on this machine. */
351 return target_read_memory (memaddr, myaddr, len);
355 if (b->type == bp_watchpoint || !b->inserted)
357 else if (b->address + memory_breakpoint_size <= memaddr)
358 /* The breakpoint is entirely before the chunk of memory
361 else if (b->address >= memaddr + len)
362 /* The breakpoint is entirely after the chunk of memory we
367 /* Copy the breakpoint from the shadow contents, and recurse
368 for the things before and after. */
370 /* Addresses and length of the part of the breakpoint that
372 CORE_ADDR membpt = b->address;
373 unsigned int bptlen = memory_breakpoint_size;
374 /* Offset within shadow_contents. */
377 if (membpt < memaddr)
379 /* Only copy the second part of the breakpoint. */
380 bptlen -= memaddr - membpt;
381 bptoffset = memaddr - membpt;
385 if (membpt + bptlen > memaddr + len)
387 /* Only copy the first part of the breakpoint. */
388 bptlen -= (membpt + bptlen) - (memaddr + len);
391 memcpy (myaddr + membpt - memaddr,
392 b->shadow_contents + bptoffset, bptlen);
394 if (membpt > memaddr)
396 /* Copy the section of memory before the breakpoint. */
397 status = read_memory_nobpt (memaddr, myaddr, membpt - memaddr);
402 if (membpt + bptlen < memaddr + len)
404 /* Copy the section of memory after the breakpoint. */
405 status = read_memory_nobpt
407 myaddr + membpt + bptlen - memaddr,
408 memaddr + len - (membpt + bptlen));
415 /* Nothing overlaps. Just call read_memory_noerr. */
416 return target_read_memory (memaddr, myaddr, len);
419 /* insert_breakpoints is used when starting or continuing the program.
420 remove_breakpoints is used when the program stops.
421 Both return zero if successful,
422 or an `errno' value if could not write the inferior. */
425 insert_breakpoints ()
427 register struct breakpoint *b;
429 int disabled_breaks = 0;
432 if (b->type != bp_watchpoint
433 && b->enable != disabled
437 val = target_insert_breakpoint(b->address, b->shadow_contents);
440 /* Can't set the breakpoint. */
441 #if defined (DISABLE_UNSETTABLE_BREAK)
442 if (DISABLE_UNSETTABLE_BREAK (b->address))
445 b->enable = disabled;
446 if (!disabled_breaks)
449 "Cannot insert breakpoint %d:\n", b->number);
450 printf_filtered ("Disabling shared library breakpoints:\n");
453 printf_filtered ("%d ", b->number);
458 fprintf (stderr, "Cannot insert breakpoint %d:\n", b->number);
459 #ifdef ONE_PROCESS_WRITETEXT
461 "The same program may be running in another process.\n");
463 memory_error (val, b->address); /* which bombs us out */
470 printf_filtered ("\n");
475 remove_breakpoints ()
477 register struct breakpoint *b;
480 #ifdef BREAKPOINT_DEBUG
481 printf ("Removing breakpoints.\n");
482 #endif /* BREAKPOINT_DEBUG */
485 if (b->type != bp_watchpoint && b->inserted)
487 val = target_remove_breakpoint(b->address, b->shadow_contents);
491 #ifdef BREAKPOINT_DEBUG
492 printf ("Removed breakpoint at %s",
493 local_hex_string(b->address));
494 printf (", shadow %s",
495 local_hex_string(b->shadow_contents[0]));
497 local_hex_string(b->shadow_contents[1]));
498 #endif /* BREAKPOINT_DEBUG */
504 /* Clear the "inserted" flag in all breakpoints.
505 This is done when the inferior is loaded. */
508 mark_breakpoints_out ()
510 register struct breakpoint *b;
516 /* breakpoint_here_p (PC) returns 1 if an enabled breakpoint exists at PC.
517 When continuing from a location with a breakpoint,
518 we actually single step once before calling insert_breakpoints. */
521 breakpoint_here_p (pc)
524 register struct breakpoint *b;
527 if (b->enable != disabled && b->address == pc)
533 /* bpstat stuff. External routines' interfaces are documented
536 /* Clear a bpstat so that it says we are not at any breakpoint.
537 Also free any storage that is part of a bpstat. */
552 if (p->old_val != NULL)
553 value_free (p->old_val);
560 /* Return a copy of a bpstat. Like "bs1 = bs2" but all storage that
561 is part of the bpstat is copied as well. */
574 for (; bs != NULL; bs = bs->next)
576 tmp = (bpstat) xmalloc (sizeof (*tmp));
577 memcpy (tmp, bs, sizeof (*tmp));
579 /* This is the first thing in the chain. */
589 /* Find the bpstat associated with this breakpoint */
592 bpstat_find_breakpoint(bsp, breakpoint)
594 struct breakpoint *breakpoint;
596 if (bsp == NULL) return NULL;
598 for (;bsp != NULL; bsp = bsp->next) {
599 if (bsp->breakpoint_at == breakpoint) return bsp;
604 /* Return the breakpoint number of the first breakpoint we are stopped
605 at. *BSP upon return is a bpstat which points to the remaining
606 breakpoints stopped at (but which is not guaranteed to be good for
607 anything but further calls to bpstat_num).
608 Return 0 if passed a bpstat which does not indicate any breakpoints. */
614 struct breakpoint *b;
617 return 0; /* No more breakpoint values */
620 b = (*bsp)->breakpoint_at;
623 return -1; /* breakpoint that's been deleted since */
625 return b->number; /* We have its number */
629 /* Modify BS so that the actions will not be performed. */
632 bpstat_clear_actions (bs)
635 for (; bs != NULL; bs = bs->next)
638 if (bs->old_val != NULL)
640 value_free (bs->old_val);
646 /* Stub for cleaning up our state if we error-out of a breakpoint command */
649 cleanup_executing_breakpoints (ignore)
652 executing_breakpoint_commands = 0;
655 /* Execute all the commands associated with all the breakpoints at this
656 location. Any of these commands could cause the process to proceed
657 beyond this point, etc. We look out for such changes by checking
658 the global "breakpoint_proceeded" after each command. */
661 bpstat_do_actions (bsp)
665 struct cleanup *old_chain;
667 executing_breakpoint_commands = 1;
668 old_chain = make_cleanup (cleanup_executing_breakpoints, 0);
673 breakpoint_proceeded = 0;
674 for (; bs != NULL; bs = bs->next)
678 char *line = bs->commands->line;
679 bs->commands = bs->commands->next;
680 execute_command (line, 0);
681 /* If the inferior is proceeded by the command, bomb out now.
682 The bpstat chain has been blown away by wait_for_inferior.
683 But since execution has stopped again, there is a new bpstat
684 to look at, so start over. */
685 if (breakpoint_proceeded)
690 executing_breakpoint_commands = 0;
691 discard_cleanups (old_chain);
694 /* Print a message indicating what happened. Returns nonzero to
695 say that only the source line should be printed after this (zero
696 return means print the frame as well as the source line). */
702 /* bs->breakpoint_at can be NULL if it was a momentary breakpoint
703 which has since been deleted. */
705 || bs->breakpoint_at == NULL
706 || (bs->breakpoint_at->type != bp_breakpoint
707 && bs->breakpoint_at->type != bp_watchpoint))
710 /* If bpstat_stop_status says don't print, OK, we won't. An example
711 circumstance is when we single-stepped for both a watchpoint and
712 for a "stepi" instruction. The bpstat says that the watchpoint
713 explains the stop, but we shouldn't print because the watchpoint's
714 value didn't change -- and the real reason we are stopping here
715 rather than continuing to step (as the watchpoint would've had us do)
716 is because of the "stepi". */
720 if (bs->breakpoint_at->type == bp_breakpoint)
722 /* I think the user probably only wants to see one breakpoint
723 number, not all of them. */
724 printf_filtered ("\nBreakpoint %d, ", bs->breakpoint_at->number);
728 if (bs->old_val != NULL)
730 printf_filtered ("\nWatchpoint %d, ", bs->breakpoint_at->number);
731 print_expression (bs->breakpoint_at->exp, stdout);
732 printf_filtered ("\nOld value = ");
733 value_print (bs->old_val, stdout, 0, Val_pretty_default);
734 printf_filtered ("\nNew value = ");
735 value_print (bs->breakpoint_at->val, stdout, 0,
737 printf_filtered ("\n");
738 value_free (bs->old_val);
743 /* Maybe another breakpoint in the chain caused us to stop.
744 (Currently all watchpoints go on the bpstat whether hit or
745 not. That probably could (should) be changed, provided care is taken
746 with respect to bpstat_explains_signal). */
748 return bpstat_print (bs->next);
750 fprintf_filtered (stderr, "gdb internal error: in bpstat_print\n");
754 /* Evaluate the expression EXP and return 1 if value is zero.
755 This is used inside a catch_errors to evaluate the breakpoint condition.
756 The argument is a "struct expression *" that has been cast to char * to
757 make it pass through catch_errors. */
760 breakpoint_cond_eval (exp)
763 return !value_true (evaluate_expression ((struct expression *)exp));
766 /* Allocate a new bpstat and chain it to the current one. */
769 bpstat_alloc (b, cbs)
770 register struct breakpoint *b;
771 bpstat cbs; /* Current "bs" value */
775 bs = (bpstat) xmalloc (sizeof (*bs));
777 bs->breakpoint_at = b;
778 /* If the condition is false, etc., don't do the commands. */
780 bs->momentary = b->disposition == delete;
785 /* Determine whether we stopped at a breakpoint, etc, or whether we
786 don't understand this stop. Result is a chain of bpstat's such that:
788 if we don't understand the stop, the result is a null pointer.
790 if we understand why we stopped, the result is not null, and
791 the first element of the chain contains summary "stop" and
792 "print" flags for the whole chain.
794 Each element of the chain refers to a particular breakpoint or
795 watchpoint at which we have stopped. (We may have stopped for
798 Each element of the chain has valid next, breakpoint_at,
799 commands, FIXME??? fields.
805 bpstat_stop_status (pc, frame_address)
807 FRAME_ADDR frame_address;
809 register struct breakpoint *b;
813 #if DECR_PC_AFTER_BREAK != 0 || defined (SHIFT_INST_REGS)
814 /* True if we've hit a breakpoint (as opposed to a watchpoint). */
815 int real_breakpoint = 0;
817 /* Root of the chain of bpstat's */
818 struct bpstat root_bs[1];
819 /* Pointer to the last thing in the chain currently. */
822 /* Get the address where the breakpoint would have been. */
823 bp_addr = *pc - DECR_PC_AFTER_BREAK;
830 if (b->enable == disabled)
833 if (b->type != bp_watchpoint && b->address != bp_addr)
836 /* Come here if it's a watchpoint, or if the break address matches */
838 bs = bpstat_alloc (b, bs); /* Alloc a bpstat to explain stop */
843 if (b->type == bp_watchpoint)
845 int within_current_scope;
846 if (b->exp_valid_block != NULL)
847 within_current_scope =
848 contained_in (get_selected_block (), b->exp_valid_block);
850 within_current_scope = 1;
852 if (within_current_scope)
854 /* We use value_{,free_to_}mark because it could be a
855 *long* time before we return to the command level and
856 call free_all_values. */
858 value mark = value_mark ();
859 value new_val = evaluate_expression (b->exp);
860 if (!value_equal (b->val, new_val))
862 release_value (new_val);
863 value_free_to_mark (mark);
864 bs->old_val = b->val;
866 /* We will stop here */
870 /* Nothing changed, don't do anything. */
871 value_free_to_mark (mark);
873 /* We won't stop here */
878 /* This seems like the only logical thing to do because
879 if we temporarily ignored the watchpoint, then when
880 we reenter the block in which it is valid it contains
881 garbage (in the case of a function, it may have two
882 garbage values, one before and one after the prologue).
883 So we can't even detect the first assignment to it and
884 watch after that (since the garbage may or may not equal
885 the first value assigned). */
886 b->enable = disabled;
888 Watchpoint %d disabled because the program has left the block in\n\
889 which its expression is valid.\n", b->number);
890 /* We won't stop here */
891 /* FIXME, maybe we should stop here!!! */
895 #if DECR_PC_AFTER_BREAK != 0 || defined (SHIFT_INST_REGS)
900 if (b->frame && b->frame != frame_address)
908 /* Need to select the frame, with all that implies
909 so that the conditions will have the right context. */
910 select_frame (get_current_frame (), 0);
912 = catch_errors (breakpoint_cond_eval, (char *)(b->cond),
913 "Error in testing breakpoint condition:\n");
914 /* FIXME-someday, should give breakpoint # */
917 if (b->cond && value_is_zero)
921 else if (b->ignore_count > 0)
928 /* We will stop here */
929 if (b->disposition == disable)
930 b->enable = disabled;
931 bs->commands = b->commands;
934 if (bs->commands && !strcmp ("silent", bs->commands->line))
936 bs->commands = bs->commands->next;
947 bs->next = NULL; /* Terminate the chain */
948 bs = root_bs->next; /* Re-grab the head of the chain */
953 #if DECR_PC_AFTER_BREAK != 0 || defined (SHIFT_INST_REGS)
957 #if defined (SHIFT_INST_REGS)
959 CORE_ADDR pc = read_register (PC_REGNUM);
960 CORE_ADDR npc = read_register (NPC_REGNUM);
963 write_register (NNPC_REGNUM, npc);
964 write_register (NPC_REGNUM, pc);
967 #else /* No SHIFT_INST_REGS. */
969 #endif /* No SHIFT_INST_REGS. */
971 #endif /* DECR_PC_AFTER_BREAK != 0. */
976 /* Nonzero if we should step constantly (e.g. watchpoints on machines
977 without hardware support). This isn't related to a specific bpstat,
978 just to things like whether watchpoints are set. */
981 bpstat_should_step ()
983 struct breakpoint *b;
985 if (b->enable == enabled && b->type == bp_watchpoint)
990 /* Print information on breakpoint number BNUM, or -1 if all.
991 If WATCHPOINTS is zero, process only breakpoints; if WATCHPOINTS
992 is nonzero, process only watchpoints. */
995 breakpoint_1 (bnum, allflag)
999 register struct breakpoint *b;
1000 register struct command_line *l;
1001 register struct symbol *sym;
1002 CORE_ADDR last_addr = (CORE_ADDR)-1;
1003 int found_a_breakpoint = 0;
1004 static char *bptypes[] = {"breakpoint", "until", "finish", "watchpoint",
1005 "longjmp", "longjmp resume"};
1006 static char *bpdisps[] = {"del", "dis", "keep"};
1007 static char bpenables[] = "ny";
1009 if (!breakpoint_chain)
1011 printf_filtered ("No breakpoints or watchpoints.\n");
1017 || bnum == b->number)
1019 /* We only print out user settable breakpoints unless the allflag is set. */
1021 && b->type != bp_breakpoint
1022 && b->type != bp_watchpoint)
1025 if (!found_a_breakpoint++)
1026 printf_filtered ("Num Type Disp Enb %sWhat\n",
1027 addressprint ? "Address " : "");
1029 printf_filtered ("%-3d %-14s %-4s %-3c ",
1031 bptypes[(int)b->type],
1032 bpdisps[(int)b->disposition],
1033 bpenables[(int)b->enable]);
1037 print_expression (b->exp, stdout);
1043 case bp_longjmp_resume:
1045 printf_filtered ("%s ", local_hex_string_custom(b->address, "08"));
1047 last_addr = b->address;
1050 sym = find_pc_function (b->address);
1053 fputs_filtered ("in ", stdout);
1054 fputs_demangled (SYMBOL_NAME (sym), stdout,
1055 DMGL_ANSI | DMGL_PARAMS);
1056 fputs_filtered (" at ", stdout);
1058 fputs_filtered (b->symtab->filename, stdout);
1059 printf_filtered (":%d", b->line_number);
1062 print_address_symbolic (b->address, stdout, demangle, " ");
1065 printf_filtered ("\n");
1068 printf_filtered ("\tstop only in stack frame at %s\n",
1069 local_hex_string(b->frame));
1072 printf_filtered ("\tstop only if ");
1073 print_expression (b->cond, stdout);
1074 printf_filtered ("\n");
1076 if (b->ignore_count)
1077 printf_filtered ("\tignore next %d hits\n", b->ignore_count);
1078 if ((l = b->commands))
1081 fputs_filtered ("\t", stdout);
1082 fputs_filtered (l->line, stdout);
1083 fputs_filtered ("\n", stdout);
1088 if (!found_a_breakpoint
1090 printf_filtered ("No breakpoint or watchpoint number %d.\n", bnum);
1092 /* Compare against (CORE_ADDR)-1 in case some compiler decides
1093 that a comparison of an unsigned with -1 is always false. */
1094 if (last_addr != (CORE_ADDR)-1)
1095 set_next_address (last_addr);
1100 breakpoints_info (bnum_exp, from_tty)
1107 bnum = parse_and_eval_address (bnum_exp);
1109 breakpoint_1 (bnum, 0);
1112 #if MAINTENANCE_CMDS
1116 maintenance_info_breakpoints (bnum_exp, from_tty)
1123 bnum = parse_and_eval_address (bnum_exp);
1125 breakpoint_1 (bnum, 1);
1130 /* Print a message describing any breakpoints set at PC. */
1133 describe_other_breakpoints (pc)
1134 register CORE_ADDR pc;
1136 register int others = 0;
1137 register struct breakpoint *b;
1140 if (b->address == pc)
1144 printf ("Note: breakpoint%s ", (others > 1) ? "s" : "");
1146 if (b->address == pc)
1151 (b->enable == disabled) ? " (disabled)" : "",
1152 (others > 1) ? "," : ((others == 1) ? " and" : ""));
1154 printf ("also set at pc %s.\n", local_hex_string(pc));
1158 /* Set the default place to put a breakpoint
1159 for the `break' command with no arguments. */
1162 set_default_breakpoint (valid, addr, symtab, line)
1165 struct symtab *symtab;
1168 default_breakpoint_valid = valid;
1169 default_breakpoint_address = addr;
1170 default_breakpoint_symtab = symtab;
1171 default_breakpoint_line = line;
1174 /* Rescan breakpoints at address ADDRESS,
1175 marking the first one as "first" and any others as "duplicates".
1176 This is so that the bpt instruction is only inserted once. */
1179 check_duplicates (address)
1182 register struct breakpoint *b;
1183 register int count = 0;
1185 if (address == 0) /* Watchpoints are uninteresting */
1189 if (b->enable != disabled && b->address == address)
1192 b->duplicate = count > 1;
1196 /* Low level routine to set a breakpoint.
1197 Takes as args the three things that every breakpoint must have.
1198 Returns the breakpoint object so caller can set other things.
1199 Does not set the breakpoint number!
1200 Does not print anything.
1202 ==> This routine should not be called if there is a chance of later
1203 error(); otherwise it leaves a bogus breakpoint on the chain. Validate
1204 your arguments BEFORE calling this routine! */
1206 static struct breakpoint *
1207 set_raw_breakpoint (sal)
1208 struct symtab_and_line sal;
1210 register struct breakpoint *b, *b1;
1212 b = (struct breakpoint *) xmalloc (sizeof (struct breakpoint));
1213 memset (b, 0, sizeof (*b));
1214 b->address = sal.pc;
1215 b->symtab = sal.symtab;
1216 b->line_number = sal.line;
1217 b->enable = enabled;
1220 b->ignore_count = 0;
1224 /* Add this breakpoint to the end of the chain
1225 so that a list of breakpoints will come out in order
1226 of increasing numbers. */
1228 b1 = breakpoint_chain;
1230 breakpoint_chain = b;
1238 check_duplicates (sal.pc);
1244 create_longjmp_breakpoint(func_name)
1247 struct symtab_and_line sal;
1248 struct breakpoint *b;
1249 static int internal_breakpoint_number = -1;
1251 if (func_name != NULL)
1253 struct minimal_symbol *m;
1255 m = lookup_minimal_symbol(func_name, (struct objfile *)NULL);
1257 sal.pc = m->address;
1267 b = set_raw_breakpoint(sal);
1270 b->type = func_name != NULL ? bp_longjmp : bp_longjmp_resume;
1271 b->disposition = donttouch;
1272 b->enable = disabled;
1275 b->addr_string = strsave(func_name);
1276 b->number = internal_breakpoint_number--;
1279 /* Call this routine when stepping and nexting to enable a breakpoint if we do
1280 a longjmp(). When we hit that breakpoint, call
1281 set_longjmp_resume_breakpoint() to figure out where we are going. */
1284 enable_longjmp_breakpoint()
1286 register struct breakpoint *b;
1289 if (b->type == bp_longjmp)
1291 b->enable = enabled;
1292 check_duplicates (b->address);
1297 disable_longjmp_breakpoint()
1299 register struct breakpoint *b;
1302 if ( b->type == bp_longjmp
1303 || b->type == bp_longjmp_resume)
1305 b->enable = disabled;
1306 check_duplicates (b->address);
1310 /* Call this after hitting the longjmp() breakpoint. Use this to set a new
1311 breakpoint at the target of the jmp_buf.
1313 FIXME - This ought to be done by setting a temporary breakpoint that gets
1314 deleted automatically...
1318 set_longjmp_resume_breakpoint(pc, frame)
1322 register struct breakpoint *b;
1325 if (b->type == bp_longjmp_resume)
1328 b->enable = enabled;
1330 b->frame = FRAME_FP(frame);
1333 check_duplicates (b->address);
1338 /* Set a breakpoint that will evaporate an end of command
1339 at address specified by SAL.
1340 Restrict it to frame FRAME if FRAME is nonzero. */
1343 set_momentary_breakpoint (sal, frame, type)
1344 struct symtab_and_line sal;
1348 register struct breakpoint *b;
1349 b = set_raw_breakpoint (sal);
1351 b->enable = enabled;
1352 b->disposition = donttouch;
1353 b->frame = (frame ? FRAME_FP (frame) : 0);
1359 clear_momentary_breakpoints ()
1361 register struct breakpoint *b;
1363 if (b->disposition == delete)
1365 delete_breakpoint (b);
1371 /* Tell the user we have just set a breakpoint B. */
1374 struct breakpoint *b;
1379 printf_filtered ("Watchpoint %d: ", b->number);
1380 print_expression (b->exp, stdout);
1383 printf_filtered ("Breakpoint %d at %s", b->number,
1384 local_hex_string(b->address));
1386 printf_filtered (": file %s, line %d.",
1387 b->symtab->filename, b->line_number);
1392 case bp_longjmp_resume:
1395 printf_filtered ("\n");
1399 /* Nobody calls this currently. */
1400 /* Set a breakpoint from a symtab and line.
1401 If TEMPFLAG is nonzero, it is a temporary breakpoint.
1402 ADDR_STRING is a malloc'd string holding the name of where we are
1403 setting the breakpoint. This is used later to re-set it after the
1404 program is relinked and symbols are reloaded.
1405 Print the same confirmation messages that the breakpoint command prints. */
1408 set_breakpoint (s, line, tempflag, addr_string)
1414 register struct breakpoint *b;
1415 struct symtab_and_line sal;
1420 resolve_sal_pc (&sal); /* Might error out */
1421 describe_other_breakpoints (sal.pc);
1423 b = set_raw_breakpoint (sal);
1424 set_breakpoint_count (breakpoint_count + 1);
1425 b->number = breakpoint_count;
1426 b->type = bp_breakpoint;
1428 b->addr_string = addr_string;
1429 b->enable = enabled;
1430 b->disposition = tempflag ? delete : donttouch;
1436 /* Set a breakpoint according to ARG (function, linenum or *address)
1437 and make it temporary if TEMPFLAG is nonzero. */
1440 break_command_1 (arg, tempflag, from_tty)
1442 int tempflag, from_tty;
1444 struct symtabs_and_lines sals;
1445 struct symtab_and_line sal;
1446 register struct expression *cond = 0;
1447 register struct breakpoint *b;
1449 /* Pointers in arg to the start, and one past the end, of the condition. */
1450 char *cond_start = NULL;
1452 /* Pointers in arg to the start, and one past the end,
1453 of the address part. */
1454 char *addr_start = NULL;
1462 sal.line = sal.pc = sal.end = 0;
1465 /* If no arg given, or if first arg is 'if ', use the default breakpoint. */
1467 if (!arg || (arg[0] == 'i' && arg[1] == 'f'
1468 && (arg[2] == ' ' || arg[2] == '\t')))
1470 if (default_breakpoint_valid)
1472 sals.sals = (struct symtab_and_line *)
1473 xmalloc (sizeof (struct symtab_and_line));
1474 sal.pc = default_breakpoint_address;
1475 sal.line = default_breakpoint_line;
1476 sal.symtab = default_breakpoint_symtab;
1481 error ("No default breakpoint address now.");
1487 /* Force almost all breakpoints to be in terms of the
1488 current_source_symtab (which is decode_line_1's default). This
1489 should produce the results we want almost all of the time while
1490 leaving default_breakpoint_* alone. */
1491 if (default_breakpoint_valid
1492 && (!current_source_symtab
1493 || (arg && (*arg == '+' || *arg == '-'))))
1494 sals = decode_line_1 (&arg, 1, default_breakpoint_symtab,
1495 default_breakpoint_line);
1497 sals = decode_line_1 (&arg, 1, (struct symtab *)NULL, 0);
1505 /* Resolve all line numbers to PC's, and verify that conditions
1506 can be parsed, before setting any breakpoints. */
1507 for (i = 0; i < sals.nelts; i++)
1509 resolve_sal_pc (&sals.sals[i]);
1513 if (arg[0] == 'i' && arg[1] == 'f'
1514 && (arg[2] == ' ' || arg[2] == '\t'))
1518 cond = parse_exp_1 (&arg, block_for_pc (sals.sals[i].pc), 0);
1522 error ("Junk at end of arguments.");
1526 /* Now set all the breakpoints. */
1527 for (i = 0; i < sals.nelts; i++)
1532 describe_other_breakpoints (sal.pc);
1534 b = set_raw_breakpoint (sal);
1535 set_breakpoint_count (breakpoint_count + 1);
1536 b->number = breakpoint_count;
1537 b->type = bp_breakpoint;
1541 b->addr_string = savestring (addr_start, addr_end - addr_start);
1543 b->cond_string = savestring (cond_start, cond_end - cond_start);
1545 b->enable = enabled;
1546 b->disposition = tempflag ? delete : donttouch;
1553 printf ("Multiple breakpoints were set.\n");
1554 printf ("Use the \"delete\" command to delete unwanted breakpoints.\n");
1556 free ((PTR)sals.sals);
1559 /* Helper function for break_command_1 and disassemble_command. */
1562 resolve_sal_pc (sal)
1563 struct symtab_and_line *sal;
1567 if (sal->pc == 0 && sal->symtab != 0)
1569 pc = find_line_pc (sal->symtab, sal->line);
1571 error ("No line %d in file \"%s\".",
1572 sal->line, sal->symtab->filename);
1578 break_command (arg, from_tty)
1582 break_command_1 (arg, 0, from_tty);
1586 tbreak_command (arg, from_tty)
1590 break_command_1 (arg, 1, from_tty);
1595 watch_command (arg, from_tty)
1599 struct breakpoint *b;
1600 struct symtab_and_line sal;
1601 struct expression *exp;
1602 struct block *exp_valid_block;
1609 /* Parse arguments. */
1610 innermost_block = NULL;
1611 exp = parse_expression (arg);
1612 exp_valid_block = innermost_block;
1613 val = evaluate_expression (exp);
1614 release_value (val);
1616 /* Now set up the breakpoint. */
1617 b = set_raw_breakpoint (sal);
1618 set_breakpoint_count (breakpoint_count + 1);
1619 b->number = breakpoint_count;
1620 b->type = bp_watchpoint;
1621 b->disposition = donttouch;
1623 b->exp_valid_block = exp_valid_block;
1626 b->cond_string = NULL;
1631 * Helper routine for the until_command routine in infcmd.c. Here
1632 * because it uses the mechanisms of breakpoints.
1636 until_break_command (arg, from_tty)
1640 struct symtabs_and_lines sals;
1641 struct symtab_and_line sal;
1642 FRAME prev_frame = get_prev_frame (selected_frame);
1643 struct breakpoint *breakpoint;
1644 struct cleanup *old_chain;
1646 clear_proceed_status ();
1648 /* Set a breakpoint where the user wants it and at return from
1651 if (default_breakpoint_valid)
1652 sals = decode_line_1 (&arg, 1, default_breakpoint_symtab,
1653 default_breakpoint_line);
1655 sals = decode_line_1 (&arg, 1, (struct symtab *)NULL, 0);
1657 if (sals.nelts != 1)
1658 error ("Couldn't get information on specified line.");
1661 free ((PTR)sals.sals); /* malloc'd, so freed */
1664 error ("Junk at end of arguments.");
1666 resolve_sal_pc (&sal);
1668 breakpoint = set_momentary_breakpoint (sal, selected_frame, bp_until);
1670 old_chain = make_cleanup(delete_breakpoint, breakpoint);
1672 /* Keep within the current frame */
1676 struct frame_info *fi;
1678 fi = get_frame_info (prev_frame);
1679 sal = find_pc_line (fi->pc, 0);
1681 breakpoint = set_momentary_breakpoint (sal, prev_frame, bp_until);
1682 make_cleanup(delete_breakpoint, breakpoint);
1685 proceed (-1, -1, 0);
1686 do_cleanups(old_chain);
1690 /* These aren't used; I don't konw what they were for. */
1691 /* Set a breakpoint at the catch clause for NAME. */
1693 catch_breakpoint (name)
1699 disable_catch_breakpoint ()
1704 delete_catch_breakpoint ()
1709 enable_catch_breakpoint ()
1716 struct sal_chain *next;
1717 struct symtab_and_line sal;
1721 /* This isn't used; I don't know what it was for. */
1722 /* For each catch clause identified in ARGS, run FUNCTION
1723 with that clause as an argument. */
1724 static struct symtabs_and_lines
1725 map_catch_names (args, function)
1729 register char *p = args;
1731 struct symtabs_and_lines sals;
1733 struct sal_chain *sal_chain = 0;
1737 error_no_arg ("one or more catch names");
1745 /* Don't swallow conditional part. */
1746 if (p1[0] == 'i' && p1[1] == 'f'
1747 && (p1[2] == ' ' || p1[2] == '\t'))
1753 while (isalnum (*p1) || *p1 == '_' || *p1 == '$')
1757 if (*p1 && *p1 != ' ' && *p1 != '\t')
1758 error ("Arguments must be catch names.");
1764 struct sal_chain *next
1765 = (struct sal_chain *)alloca (sizeof (struct sal_chain));
1766 next->next = sal_chain;
1767 next->sal = get_catch_sal (p);
1772 printf ("No catch clause for exception %s.\n", p);
1777 while (*p == ' ' || *p == '\t') p++;
1782 /* This shares a lot of code with `print_frame_label_vars' from stack.c. */
1784 static struct symtabs_and_lines
1785 get_catch_sals (this_level_only)
1786 int this_level_only;
1788 register struct blockvector *bl;
1789 register struct block *block;
1790 int index, have_default = 0;
1791 struct frame_info *fi;
1793 struct symtabs_and_lines sals;
1794 struct sal_chain *sal_chain = 0;
1795 char *blocks_searched;
1797 /* Not sure whether an error message is always the correct response,
1798 but it's better than a core dump. */
1799 if (selected_frame == NULL)
1800 error ("No selected frame.");
1801 block = get_frame_block (selected_frame);
1802 fi = get_frame_info (selected_frame);
1809 error ("No symbol table info available.\n");
1811 bl = blockvector_for_pc (BLOCK_END (block) - 4, &index);
1812 blocks_searched = (char *) alloca (BLOCKVECTOR_NBLOCKS (bl) * sizeof (char));
1813 memset (blocks_searched, 0, BLOCKVECTOR_NBLOCKS (bl) * sizeof (char));
1817 CORE_ADDR end = BLOCK_END (block) - 4;
1820 if (bl != blockvector_for_pc (end, &index))
1821 error ("blockvector blotch");
1822 if (BLOCKVECTOR_BLOCK (bl, index) != block)
1823 error ("blockvector botch");
1824 last_index = BLOCKVECTOR_NBLOCKS (bl);
1827 /* Don't print out blocks that have gone by. */
1828 while (index < last_index
1829 && BLOCK_END (BLOCKVECTOR_BLOCK (bl, index)) < pc)
1832 while (index < last_index
1833 && BLOCK_END (BLOCKVECTOR_BLOCK (bl, index)) < end)
1835 if (blocks_searched[index] == 0)
1837 struct block *b = BLOCKVECTOR_BLOCK (bl, index);
1840 register struct symbol *sym;
1842 nsyms = BLOCK_NSYMS (b);
1844 for (i = 0; i < nsyms; i++)
1846 sym = BLOCK_SYM (b, i);
1847 if (! strcmp (SYMBOL_NAME (sym), "default"))
1853 if (SYMBOL_CLASS (sym) == LOC_LABEL)
1855 struct sal_chain *next = (struct sal_chain *)
1856 alloca (sizeof (struct sal_chain));
1857 next->next = sal_chain;
1858 next->sal = find_pc_line (SYMBOL_VALUE_ADDRESS (sym), 0);
1862 blocks_searched[index] = 1;
1868 if (sal_chain && this_level_only)
1871 /* After handling the function's top-level block, stop.
1872 Don't continue to its superblock, the block of
1873 per-file symbols. */
1874 if (BLOCK_FUNCTION (block))
1876 block = BLOCK_SUPERBLOCK (block);
1881 struct sal_chain *tmp_chain;
1883 /* Count the number of entries. */
1884 for (index = 0, tmp_chain = sal_chain; tmp_chain;
1885 tmp_chain = tmp_chain->next)
1889 sals.sals = (struct symtab_and_line *)
1890 xmalloc (index * sizeof (struct symtab_and_line));
1891 for (index = 0; sal_chain; sal_chain = sal_chain->next, index++)
1892 sals.sals[index] = sal_chain->sal;
1898 /* Commands to deal with catching exceptions. */
1901 catch_command_1 (arg, tempflag, from_tty)
1906 /* First, translate ARG into something we can deal with in terms
1909 struct symtabs_and_lines sals;
1910 struct symtab_and_line sal;
1911 register struct expression *cond = 0;
1912 register struct breakpoint *b;
1916 sal.line = sal.pc = sal.end = 0;
1919 /* If no arg given, or if first arg is 'if ', all active catch clauses
1920 are breakpointed. */
1922 if (!arg || (arg[0] == 'i' && arg[1] == 'f'
1923 && (arg[2] == ' ' || arg[2] == '\t')))
1925 /* Grab all active catch clauses. */
1926 sals = get_catch_sals (0);
1930 /* Grab selected catch clauses. */
1931 error ("catch NAME not implemeneted");
1933 /* This isn't used; I don't know what it was for. */
1934 sals = map_catch_names (arg, catch_breakpoint);
1942 for (i = 0; i < sals.nelts; i++)
1944 resolve_sal_pc (&sals.sals[i]);
1948 if (arg[0] == 'i' && arg[1] == 'f'
1949 && (arg[2] == ' ' || arg[2] == '\t'))
1950 cond = parse_exp_1 ((arg += 2, &arg),
1951 block_for_pc (sals.sals[i].pc), 0);
1953 error ("Junk at end of arguments.");
1958 for (i = 0; i < sals.nelts; i++)
1963 describe_other_breakpoints (sal.pc);
1965 b = set_raw_breakpoint (sal);
1966 set_breakpoint_count (breakpoint_count + 1);
1967 b->number = breakpoint_count;
1968 b->type = bp_breakpoint;
1970 b->enable = enabled;
1971 b->disposition = tempflag ? delete : donttouch;
1973 printf ("Breakpoint %d at %s", b->number, local_hex_string(b->address));
1975 printf (": file %s, line %d.", b->symtab->filename, b->line_number);
1981 printf ("Multiple breakpoints were set.\n");
1982 printf ("Use the \"delete\" command to delete unwanted breakpoints.\n");
1984 free ((PTR)sals.sals);
1988 /* These aren't used; I don't know what they were for. */
1989 /* Disable breakpoints on all catch clauses described in ARGS. */
1991 disable_catch (args)
1994 /* Map the disable command to catch clauses described in ARGS. */
1997 /* Enable breakpoints on all catch clauses described in ARGS. */
2002 /* Map the disable command to catch clauses described in ARGS. */
2005 /* Delete breakpoints on all catch clauses in the active scope. */
2010 /* Map the delete command to catch clauses described in ARGS. */
2015 catch_command (arg, from_tty)
2019 catch_command_1 (arg, 0, from_tty);
2023 clear_command (arg, from_tty)
2027 register struct breakpoint *b, *b1;
2028 struct symtabs_and_lines sals;
2029 struct symtab_and_line sal;
2030 register struct breakpoint *found;
2035 sals = decode_line_spec (arg, 1);
2039 sals.sals = (struct symtab_and_line *) xmalloc (sizeof (struct symtab_and_line));
2040 sal.line = default_breakpoint_line;
2041 sal.symtab = default_breakpoint_symtab;
2043 if (sal.symtab == 0)
2044 error ("No source file specified.");
2050 for (i = 0; i < sals.nelts; i++)
2052 /* If exact pc given, clear bpts at that pc.
2053 But if sal.pc is zero, clear all bpts on specified line. */
2055 found = (struct breakpoint *) 0;
2056 while (breakpoint_chain
2057 && (sal.pc ? breakpoint_chain->address == sal.pc
2058 : (breakpoint_chain->symtab == sal.symtab
2059 && breakpoint_chain->line_number == sal.line)))
2061 b1 = breakpoint_chain;
2062 breakpoint_chain = b1->next;
2069 && b->next->type != bp_watchpoint
2070 && (sal.pc ? b->next->address == sal.pc
2071 : (b->next->symtab == sal.symtab
2072 && b->next->line_number == sal.line)))
2083 error ("No breakpoint at %s.", arg);
2085 error ("No breakpoint at this line.");
2088 if (found->next) from_tty = 1; /* Always report if deleted more than one */
2089 if (from_tty) printf ("Deleted breakpoint%s ", found->next ? "s" : "");
2092 if (from_tty) printf ("%d ", found->number);
2094 delete_breakpoint (found);
2097 if (from_tty) putchar ('\n');
2099 free ((PTR)sals.sals);
2102 /* Delete breakpoint in BS if they are `delete' breakpoints.
2103 This is called after any breakpoint is hit, or after errors. */
2106 breakpoint_auto_delete (bs)
2109 for (; bs; bs = bs->next)
2110 if (bs->breakpoint_at && bs->breakpoint_at->disposition == delete)
2111 delete_breakpoint (bs->breakpoint_at);
2114 /* Delete a breakpoint and clean up all traces of it in the data structures. */
2117 delete_breakpoint (bpt)
2118 struct breakpoint *bpt;
2120 register struct breakpoint *b;
2124 target_remove_breakpoint(bpt->address, bpt->shadow_contents);
2126 if (breakpoint_chain == bpt)
2127 breakpoint_chain = bpt->next;
2132 b->next = bpt->next;
2136 check_duplicates (bpt->address);
2138 free_command_lines (&bpt->commands);
2140 free ((PTR)bpt->cond);
2141 if (bpt->cond_string != NULL)
2142 free ((PTR)bpt->cond_string);
2143 if (bpt->addr_string != NULL)
2144 free ((PTR)bpt->addr_string);
2146 if (xgdb_verbose && bpt->type == bp_breakpoint)
2147 printf ("breakpoint #%d deleted\n", bpt->number);
2149 /* Be sure no bpstat's are pointing at it after it's been freed. */
2150 /* FIXME, how can we find all bpstat's? We just check stop_bpstat for now. */
2151 for (bs = stop_bpstat; bs; bs = bs->next)
2152 if (bs->breakpoint_at == bpt)
2153 bs->breakpoint_at = NULL;
2158 delete_command (arg, from_tty)
2165 /* Ask user only if there are some breakpoints to delete. */
2167 || (breakpoint_chain && query ("Delete all breakpoints? ", 0, 0)))
2169 /* No arg; clear all breakpoints. */
2170 while (breakpoint_chain)
2171 delete_breakpoint (breakpoint_chain);
2175 map_breakpoint_numbers (arg, delete_breakpoint);
2178 /* Reset a breakpoint given it's struct breakpoint * BINT.
2179 The value we return ends up being the return value from catch_errors.
2180 Unused in this case. */
2183 breakpoint_re_set_one (bint)
2186 struct breakpoint *b = (struct breakpoint *)bint; /* get past catch_errs */
2188 struct symtabs_and_lines sals;
2190 enum enable save_enable;
2195 if (b->addr_string == NULL)
2197 /* Anything without a string can't be re-set. */
2198 delete_breakpoint (b);
2201 /* In case we have a problem, disable this breakpoint. We'll restore
2202 its status if we succeed. */
2203 save_enable = b->enable;
2204 b->enable = disabled;
2207 sals = decode_line_1 (&s, 1, (struct symtab *)NULL, 0);
2208 for (i = 0; i < sals.nelts; i++)
2210 resolve_sal_pc (&sals.sals[i]);
2211 if (b->symtab != sals.sals[i].symtab
2212 || b->line_number != sals.sals[i].line
2213 || b->address != sals.sals[i].pc)
2215 b->symtab = sals.sals[i].symtab;
2216 b->line_number = sals.sals[i].line;
2217 b->address = sals.sals[i].pc;
2219 if (b->cond_string != NULL)
2222 b->cond = parse_exp_1 (&s, block_for_pc (sals.sals[i].pc), 0);
2225 check_duplicates (b->address);
2229 b->enable = save_enable; /* Restore it, this worked. */
2231 free ((PTR)sals.sals);
2234 /* FIXME! This is the wrong thing to do.... */
2235 delete_breakpoint (b);
2238 printf_filtered ("Deleting unknown breakpoint type %d\n", b->type);
2242 case bp_longjmp_resume:
2243 delete_breakpoint (b);
2250 /* Re-set all breakpoints after symbols have been re-loaded. */
2252 breakpoint_re_set ()
2254 struct breakpoint *b, *temp;
2255 static char message1[] = "Error in re-setting breakpoint %d:\n";
2256 char message[sizeof (message1) + 30 /* slop */];
2258 /* If we have no current source symtab, and we have any breakpoints,
2259 go through the work of making a source context. */
2260 if (current_source_symtab == NULL)
2264 select_source_symtab (NULL);
2265 break; /* We only care if there are any, and
2266 don't need to do it N times. */
2270 ALL_BREAKPOINTS_SAFE (b, temp)
2272 sprintf (message, message1, b->number); /* Format possible error msg */
2273 catch_errors (breakpoint_re_set_one, (char *) b, message);
2276 create_longjmp_breakpoint("longjmp");
2277 create_longjmp_breakpoint("_longjmp");
2278 create_longjmp_breakpoint("siglongjmp");
2279 create_longjmp_breakpoint(NULL);
2282 /* Took this out (temporaliy at least), since it produces an extra
2283 blank line at startup. This messes up the gdbtests. -PB */
2284 /* Blank line to finish off all those mention() messages we just printed. */
2285 printf_filtered ("\n");
2289 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
2290 If from_tty is nonzero, it prints a message to that effect,
2291 which ends with a period (no newline). */
2294 set_ignore_count (bptnum, count, from_tty)
2295 int bptnum, count, from_tty;
2297 register struct breakpoint *b;
2303 if (b->number == bptnum)
2305 b->ignore_count = count;
2308 else if (count == 0)
2309 printf_filtered ("Will stop next time breakpoint %d is reached.",
2311 else if (count == 1)
2312 printf_filtered ("Will ignore next crossing of breakpoint %d.",
2315 printf_filtered ("Will ignore next %d crossings of breakpoint %d.",
2320 error ("No breakpoint number %d.", bptnum);
2323 /* Clear the ignore counts of all breakpoints. */
2325 breakpoint_clear_ignore_counts ()
2327 struct breakpoint *b;
2330 b->ignore_count = 0;
2333 /* Command to set ignore-count of breakpoint N to COUNT. */
2336 ignore_command (args, from_tty)
2344 error_no_arg ("a breakpoint number");
2346 num = get_number (&p);
2349 error ("Second argument (specified ignore-count) is missing.");
2351 set_ignore_count (num,
2352 longest_to_int (value_as_long (parse_and_eval (p))),
2354 printf_filtered ("\n");
2357 /* Call FUNCTION on each of the breakpoints
2358 whose numbers are given in ARGS. */
2361 map_breakpoint_numbers (args, function)
2363 void (*function) PARAMS ((struct breakpoint *));
2365 register char *p = args;
2368 register struct breakpoint *b;
2371 error_no_arg ("one or more breakpoint numbers");
2377 num = get_number (&p1);
2380 if (b->number == num)
2385 printf ("No breakpoint number %d.\n", num);
2392 enable_breakpoint (bpt)
2393 struct breakpoint *bpt;
2395 bpt->enable = enabled;
2397 if (xgdb_verbose && bpt->type == bp_breakpoint)
2398 printf ("breakpoint #%d enabled\n", bpt->number);
2400 check_duplicates (bpt->address);
2401 if (bpt->type == bp_watchpoint)
2403 if (bpt->exp_valid_block != NULL
2404 && !contained_in (get_selected_block (), bpt->exp_valid_block))
2407 Cannot enable watchpoint %d because the block in which its expression\n\
2408 is valid is not currently in scope.\n", bpt->number);
2412 value_free (bpt->val);
2414 bpt->val = evaluate_expression (bpt->exp);
2415 release_value (bpt->val);
2421 enable_command (args, from_tty)
2425 struct breakpoint *bpt;
2427 ALL_BREAKPOINTS (bpt)
2432 enable_breakpoint (bpt);
2437 map_breakpoint_numbers (args, enable_breakpoint);
2441 disable_breakpoint (bpt)
2442 struct breakpoint *bpt;
2444 bpt->enable = disabled;
2446 if (xgdb_verbose && bpt->type == bp_breakpoint)
2447 printf_filtered ("breakpoint #%d disabled\n", bpt->number);
2449 check_duplicates (bpt->address);
2454 disable_command (args, from_tty)
2458 register struct breakpoint *bpt;
2460 ALL_BREAKPOINTS (bpt)
2465 disable_breakpoint (bpt);
2470 map_breakpoint_numbers (args, disable_breakpoint);
2474 enable_once_breakpoint (bpt)
2475 struct breakpoint *bpt;
2477 bpt->enable = enabled;
2478 bpt->disposition = disable;
2480 check_duplicates (bpt->address);
2485 enable_once_command (args, from_tty)
2489 map_breakpoint_numbers (args, enable_once_breakpoint);
2493 enable_delete_breakpoint (bpt)
2494 struct breakpoint *bpt;
2496 bpt->enable = enabled;
2497 bpt->disposition = delete;
2499 check_duplicates (bpt->address);
2504 enable_delete_command (args, from_tty)
2508 map_breakpoint_numbers (args, enable_delete_breakpoint);
2512 * Use default_breakpoint_'s, or nothing if they aren't valid.
2514 struct symtabs_and_lines
2515 decode_line_spec_1 (string, funfirstline)
2519 struct symtabs_and_lines sals;
2521 error ("Empty line specification.");
2522 if (default_breakpoint_valid)
2523 sals = decode_line_1 (&string, funfirstline,
2524 default_breakpoint_symtab, default_breakpoint_line);
2526 sals = decode_line_1 (&string, funfirstline, (struct symtab *)NULL, 0);
2528 error ("Junk at end of line specification: %s", string);
2533 _initialize_breakpoint ()
2535 breakpoint_chain = 0;
2536 /* Don't bother to call set_breakpoint_count. $bpnum isn't useful
2537 before a breakpoint is set. */
2538 breakpoint_count = 0;
2540 add_com ("ignore", class_breakpoint, ignore_command,
2541 "Set ignore-count of breakpoint number N to COUNT.");
2543 add_com ("commands", class_breakpoint, commands_command,
2544 "Set commands to be executed when a breakpoint is hit.\n\
2545 Give breakpoint number as argument after \"commands\".\n\
2546 With no argument, the targeted breakpoint is the last one set.\n\
2547 The commands themselves follow starting on the next line.\n\
2548 Type a line containing \"end\" to indicate the end of them.\n\
2549 Give \"silent\" as the first line to make the breakpoint silent;\n\
2550 then no output is printed when it is hit, except what the commands print.");
2552 add_com ("condition", class_breakpoint, condition_command,
2553 "Specify breakpoint number N to break only if COND is true.\n\
2554 N is an integer; COND is an expression to be evaluated whenever\n\
2555 breakpoint N is reached. ");
2557 add_com ("tbreak", class_breakpoint, tbreak_command,
2558 "Set a temporary breakpoint. Args like \"break\" command.\n\
2559 Like \"break\" except the breakpoint is only enabled temporarily,\n\
2560 so it will be disabled when hit. Equivalent to \"break\" followed\n\
2561 by using \"enable once\" on the breakpoint number.");
2563 add_prefix_cmd ("enable", class_breakpoint, enable_command,
2564 "Enable some breakpoints.\n\
2565 Give breakpoint numbers (separated by spaces) as arguments.\n\
2566 With no subcommand, breakpoints are enabled until you command otherwise.\n\
2567 This is used to cancel the effect of the \"disable\" command.\n\
2568 With a subcommand you can enable temporarily.",
2569 &enablelist, "enable ", 1, &cmdlist);
2571 add_abbrev_prefix_cmd ("breakpoints", class_breakpoint, enable_command,
2572 "Enable some breakpoints.\n\
2573 Give breakpoint numbers (separated by spaces) as arguments.\n\
2574 This is used to cancel the effect of the \"disable\" command.\n\
2575 May be abbreviated to simply \"enable\".\n",
2576 &enablebreaklist, "enable breakpoints ", 1, &enablelist);
2578 add_cmd ("once", no_class, enable_once_command,
2579 "Enable breakpoints for one hit. Give breakpoint numbers.\n\
2580 If a breakpoint is hit while enabled in this fashion, it becomes disabled.\n\
2581 See the \"tbreak\" command which sets a breakpoint and enables it once.",
2584 add_cmd ("delete", no_class, enable_delete_command,
2585 "Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
2586 If a breakpoint is hit while enabled in this fashion, it is deleted.",
2589 add_cmd ("delete", no_class, enable_delete_command,
2590 "Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
2591 If a breakpoint is hit while enabled in this fashion, it is deleted.",
2594 add_cmd ("once", no_class, enable_once_command,
2595 "Enable breakpoints for one hit. Give breakpoint numbers.\n\
2596 If a breakpoint is hit while enabled in this fashion, it becomes disabled.\n\
2597 See the \"tbreak\" command which sets a breakpoint and enables it once.",
2600 add_prefix_cmd ("disable", class_breakpoint, disable_command,
2601 "Disable some breakpoints.\n\
2602 Arguments are breakpoint numbers with spaces in between.\n\
2603 To disable all breakpoints, give no argument.\n\
2604 A disabled breakpoint is not forgotten, but has no effect until reenabled.",
2605 &disablelist, "disable ", 1, &cmdlist);
2606 add_com_alias ("dis", "disable", class_breakpoint, 1);
2607 add_com_alias ("disa", "disable", class_breakpoint, 1);
2609 add_cmd ("breakpoints", class_alias, disable_command,
2610 "Disable some breakpoints.\n\
2611 Arguments are breakpoint numbers with spaces in between.\n\
2612 To disable all breakpoints, give no argument.\n\
2613 A disabled breakpoint is not forgotten, but has no effect until reenabled.\n\
2614 This command may be abbreviated \"disable\".",
2617 add_prefix_cmd ("delete", class_breakpoint, delete_command,
2618 "Delete some breakpoints or auto-display expressions.\n\
2619 Arguments are breakpoint numbers with spaces in between.\n\
2620 To delete all breakpoints, give no argument.\n\
2622 Also a prefix command for deletion of other GDB objects.\n\
2623 The \"unset\" command is also an alias for \"delete\".",
2624 &deletelist, "delete ", 1, &cmdlist);
2625 add_com_alias ("d", "delete", class_breakpoint, 1);
2627 add_cmd ("breakpoints", class_alias, delete_command,
2628 "Delete some breakpoints or auto-display expressions.\n\
2629 Arguments are breakpoint numbers with spaces in between.\n\
2630 To delete all breakpoints, give no argument.\n\
2631 This command may be abbreviated \"delete\".",
2634 add_com ("clear", class_breakpoint, clear_command,
2635 "Clear breakpoint at specified line or function.\n\
2636 Argument may be line number, function name, or \"*\" and an address.\n\
2637 If line number is specified, all breakpoints in that line are cleared.\n\
2638 If function is specified, breakpoints at beginning of function are cleared.\n\
2639 If an address is specified, breakpoints at that address are cleared.\n\n\
2640 With no argument, clears all breakpoints in the line that the selected frame\n\
2643 See also the \"delete\" command which clears breakpoints by number.");
2645 add_com ("break", class_breakpoint, break_command,
2646 "Set breakpoint at specified line or function.\n\
2647 Argument may be line number, function name, or \"*\" and an address.\n\
2648 If line number is specified, break at start of code for that line.\n\
2649 If function is specified, break at start of code for that function.\n\
2650 If an address is specified, break at that exact address.\n\
2651 With no arg, uses current execution address of selected stack frame.\n\
2652 This is useful for breaking on return to a stack frame.\n\
2654 Multiple breakpoints at one place are permitted, and useful if conditional.\n\
2656 Do \"help breakpoints\" for info on other commands dealing with breakpoints.");
2657 add_com_alias ("b", "break", class_run, 1);
2658 add_com_alias ("br", "break", class_run, 1);
2659 add_com_alias ("bre", "break", class_run, 1);
2660 add_com_alias ("brea", "break", class_run, 1);
2662 add_info ("breakpoints", breakpoints_info,
2663 "Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
2664 The \"Type\" column indicates one of:\n\
2665 \tbreakpoint - normal breakpoint\n\
2666 \twatchpoint - watchpoint\n\
2667 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
2668 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
2669 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
2670 address and file/line number respectively.\n\n\
2671 Convenience variable \"$_\" and default examine address for \"x\"\n\
2672 are set to the address of the last breakpoint listed.\n\n\
2673 Convenience variable \"$bpnum\" contains the number of the last\n\
2676 #if MAINTENANCE_CMDS
2678 add_cmd ("breakpoints", class_maintenance, maintenance_info_breakpoints,
2679 "Status of all breakpoints, or breakpoint number NUMBER.\n\
2680 The \"Type\" column indicates one of:\n\
2681 \tbreakpoint - normal breakpoint\n\
2682 \twatchpoint - watchpoint\n\
2683 \tlongjmp - internal breakpoint used to step through longjmp()\n\
2684 \tlongjmp resume - internal breakpoint at the target of longjmp()\n\
2685 \tuntil - internal breakpoint used by the \"until\" command\n\
2686 \tfinish - internal breakpoint used by the \"finish\" command\n\
2687 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
2688 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
2689 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
2690 address and file/line number respectively.\n\n\
2691 Convenience variable \"$_\" and default examine address for \"x\"\n\
2692 are set to the address of the last breakpoint listed.\n\n\
2693 Convenience variable \"$bpnum\" contains the number of the last\n\
2695 &maintenanceinfolist);
2697 #endif /* MAINTENANCE_CMDS */
2699 add_com ("catch", class_breakpoint, catch_command,
2700 "Set breakpoints to catch exceptions that are raised.\n\
2701 Argument may be a single exception to catch, multiple exceptions\n\
2702 to catch, or the default exception \"default\". If no arguments\n\
2703 are given, breakpoints are set at all exception handlers catch clauses\n\
2704 within the current scope.\n\
2706 A condition specified for the catch applies to all breakpoints set\n\
2707 with this command\n\
2709 Do \"help breakpoints\" for info on other commands dealing with breakpoints.");
2711 add_com ("watch", class_breakpoint, watch_command,
2712 "Set a watchpoint for an expression.\n\
2713 A watchpoint stops execution of your program whenever the value of\n\
2714 an expression changes.");
2716 add_info ("watchpoints", breakpoints_info,
2717 "Synonym for ``info breakpoints''.");
2720 #ifdef IBM6000_TARGET
2721 /* Where should this function go? It is used by AIX only. FIXME. */
2723 /* Breakpoint address relocation used to be done in breakpoint_re_set(). That
2724 approach the following problem:
2726 before running the program, if a file is list, then a breakpoint is
2727 set (just the line number), then if we switch into another file and run
2728 the program, just a line number as a breakpoint address was not
2729 descriptive enough and breakpoint was ending up in a different file's
2732 I don't think any other platform has this breakpoint relocation problem, so this
2733 is not an issue for other platforms. */
2736 fixup_breakpoints (low, high, delta)
2741 struct breakpoint *b;
2745 if (b->address >= low && b->address <= high)
2746 b->address += delta;