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 /* This is the normal print_it function for a bpstat. In the future,
695 much of this logic could (should?) be moved to bpstat_stop_status,
696 by having it set different print_it functions. */
702 /* bs->breakpoint_at can be NULL if it was a momentary breakpoint
703 which has since been deleted. */
704 if (bs->breakpoint_at == NULL
705 || (bs->breakpoint_at->type != bp_breakpoint
706 && bs->breakpoint_at->type != bp_watchpoint))
709 if (bs->breakpoint_at->type == bp_breakpoint)
711 /* I think the user probably only wants to see one breakpoint
712 number, not all of them. */
713 printf_filtered ("\nBreakpoint %d, ", bs->breakpoint_at->number);
717 if (bs->old_val != NULL)
719 printf_filtered ("\nWatchpoint %d, ", bs->breakpoint_at->number);
720 print_expression (bs->breakpoint_at->exp, stdout);
721 printf_filtered ("\nOld value = ");
722 value_print (bs->old_val, stdout, 0, Val_pretty_default);
723 printf_filtered ("\nNew value = ");
724 value_print (bs->breakpoint_at->val, stdout, 0,
726 printf_filtered ("\n");
727 value_free (bs->old_val);
731 /* We can't deal with it. Maybe another member of the bpstat chain can. */
735 /* Print a message indicating what happened. Returns nonzero to
736 say that only the source line should be printed after this (zero
737 return means print the frame as well as the source line). */
738 /* Currently we always return zero. */
748 val = (*bs->print_it) (bs);
752 /* Maybe another breakpoint in the chain caused us to stop.
753 (Currently all watchpoints go on the bpstat whether hit or
754 not. That probably could (should) be changed, provided care is taken
755 with respect to bpstat_explains_signal). */
757 return bpstat_print (bs->next);
759 /* We reached the end of the chain without printing anything. */
763 /* Evaluate the expression EXP and return 1 if value is zero.
764 This is used inside a catch_errors to evaluate the breakpoint condition.
765 The argument is a "struct expression *" that has been cast to char * to
766 make it pass through catch_errors. */
769 breakpoint_cond_eval (exp)
772 return !value_true (evaluate_expression ((struct expression *)exp));
775 /* Allocate a new bpstat and chain it to the current one. */
778 bpstat_alloc (b, cbs)
779 register struct breakpoint *b;
780 bpstat cbs; /* Current "bs" value */
784 bs = (bpstat) xmalloc (sizeof (*bs));
786 bs->breakpoint_at = b;
787 /* If the condition is false, etc., don't do the commands. */
790 bs->print_it = print_it_normal;
794 /* Possible return values for watchpoint_check (this can't be an enum
795 because of check_errors). */
796 /* The watchpoint has been disabled. */
797 #define WP_DISABLED 1
798 /* The value has changed. */
799 #define WP_VALUE_CHANGED 2
800 /* The value has not changed. */
801 #define WP_VALUE_NOT_CHANGED 3
803 /* Check watchpoint condition. */
808 bpstat bs = (bpstat) p;
810 int within_current_scope;
811 if (bs->breakpoint_at->exp_valid_block != NULL)
812 within_current_scope =
813 contained_in (get_selected_block (), bs->breakpoint_at->exp_valid_block);
815 within_current_scope = 1;
817 if (within_current_scope)
819 /* We use value_{,free_to_}mark because it could be a
820 *long* time before we return to the command level and
821 call free_all_values. */
822 /* But couldn't we just call free_all_values instead? */
824 value mark = value_mark ();
825 value new_val = evaluate_expression (bs->breakpoint_at->exp);
826 if (!value_equal (bs->breakpoint_at->val, new_val))
828 release_value (new_val);
829 value_free_to_mark (mark);
830 bs->old_val = bs->breakpoint_at->val;
831 bs->breakpoint_at->val = new_val;
832 /* We will stop here */
833 return WP_VALUE_CHANGED;
837 /* Nothing changed, don't do anything. */
838 value_free_to_mark (mark);
839 /* We won't stop here */
840 return WP_VALUE_NOT_CHANGED;
845 /* This seems like the only logical thing to do because
846 if we temporarily ignored the watchpoint, then when
847 we reenter the block in which it is valid it contains
848 garbage (in the case of a function, it may have two
849 garbage values, one before and one after the prologue).
850 So we can't even detect the first assignment to it and
851 watch after that (since the garbage may or may not equal
852 the first value assigned). */
853 bs->breakpoint_at->enable = disabled;
855 Watchpoint %d disabled because the program has left the block in\n\
856 which its expression is valid.\n", bs->breakpoint_at->number);
861 /* This is used when everything which needs to be printed has
862 already been printed. But we still want to print the frame. */
870 /* This is used when nothing should be printed for this bpstat entry. */
879 /* Determine whether we stopped at a breakpoint, etc, or whether we
880 don't understand this stop. Result is a chain of bpstat's such that:
882 if we don't understand the stop, the result is a null pointer.
884 if we understand why we stopped, the result is not null, and
885 the first element of the chain contains summary "stop" and
886 "print" flags for the whole chain.
888 Each element of the chain refers to a particular breakpoint or
889 watchpoint at which we have stopped. (We may have stopped for
890 several reasons concurrently.)
892 Each element of the chain has valid next, breakpoint_at,
893 commands, FIXME??? fields.
899 bpstat_stop_status (pc, frame_address)
901 FRAME_ADDR frame_address;
903 register struct breakpoint *b;
905 #if DECR_PC_AFTER_BREAK != 0 || defined (SHIFT_INST_REGS)
906 /* True if we've hit a breakpoint (as opposed to a watchpoint). */
907 int real_breakpoint = 0;
909 /* Root of the chain of bpstat's */
910 struct bpstat root_bs[1];
911 /* Pointer to the last thing in the chain currently. */
914 /* Get the address where the breakpoint would have been. */
915 bp_addr = *pc - DECR_PC_AFTER_BREAK;
919 if (b->enable == disabled)
922 if (b->type != bp_watchpoint && b->address != bp_addr)
925 /* Come here if it's a watchpoint, or if the break address matches */
927 bs = bpstat_alloc (b, bs); /* Alloc a bpstat to explain stop */
932 if (b->type == bp_watchpoint)
934 static char message1[] =
935 "Error evaluating expression for watchpoint %d\n";
936 char message[sizeof (message1) + 30 /* slop */];
937 sprintf (message, message1, b->number);
938 switch (catch_errors (watchpoint_check, (char *) bs, message))
941 /* We've already printed what needs to be printed. */
942 bs->print_it = print_it_done;
945 case WP_VALUE_CHANGED:
948 case WP_VALUE_NOT_CHANGED:
950 bs->print_it = print_it_noop;
957 /* Error from catch_errors. */
958 b->enable = disabled;
959 printf_filtered ("Watchpoint %d disabled.\n", b->number);
960 /* We've already printed what needs to be printed. */
961 bs->print_it = print_it_done;
966 #if DECR_PC_AFTER_BREAK != 0 || defined (SHIFT_INST_REGS)
971 if (b->frame && b->frame != frame_address)
979 /* Need to select the frame, with all that implies
980 so that the conditions will have the right context. */
981 select_frame (get_current_frame (), 0);
983 = catch_errors (breakpoint_cond_eval, (char *)(b->cond),
984 "Error in testing breakpoint condition:\n");
985 /* FIXME-someday, should give breakpoint # */
988 if (b->cond && value_is_zero)
992 else if (b->ignore_count > 0)
999 /* We will stop here */
1000 if (b->disposition == disable)
1001 b->enable = disabled;
1002 bs->commands = b->commands;
1005 if (bs->commands && STREQ ("silent", bs->commands->line))
1007 bs->commands = bs->commands->next;
1012 /* Print nothing for this entry if we dont stop or if we dont print. */
1013 if (bs->stop == 0 || bs->print == 0)
1014 bs->print_it = print_it_noop;
1017 bs->next = NULL; /* Terminate the chain */
1018 bs = root_bs->next; /* Re-grab the head of the chain */
1019 #if DECR_PC_AFTER_BREAK != 0 || defined (SHIFT_INST_REGS)
1022 if (real_breakpoint)
1025 #if defined (SHIFT_INST_REGS)
1027 CORE_ADDR pc = read_register (PC_REGNUM);
1028 CORE_ADDR npc = read_register (NPC_REGNUM);
1031 write_register (NNPC_REGNUM, npc);
1032 write_register (NPC_REGNUM, pc);
1035 #else /* No SHIFT_INST_REGS. */
1037 #endif /* No SHIFT_INST_REGS. */
1040 #endif /* DECR_PC_AFTER_BREAK != 0. */
1044 /* Tell what to do about this bpstat. */
1049 /* Classify each bpstat as one of the following. */
1051 /* There was a watchpoint, but we're not stopping. */
1054 /* There was a watchpoint, stop but don't print. */
1057 /* There was a watchpoint, stop and print. */
1060 /* There was a breakpoint but we're not stopping. */
1063 /* There was a breakpoint, stop but don't print. */
1066 /* There was a breakpoint, stop and print. */
1069 /* We hit the longjmp breakpoint. */
1072 /* We hit the longjmp_resume breakpoint. */
1075 /* This is just used to count how many enums there are. */
1079 /* Here is the table which drives this routine. So that we can
1080 format it pretty, we define some abbreviations for the
1081 enum bpstat_what codes. */
1082 #define keep_c BPSTAT_WHAT_KEEP_CHECKING
1083 #define stop_s BPSTAT_WHAT_STOP_SILENT
1084 #define stop_n BPSTAT_WHAT_STOP_NOISY
1085 #define single BPSTAT_WHAT_SINGLE
1086 #define setlr BPSTAT_WHAT_SET_LONGJMP_RESUME
1087 #define clrlr BPSTAT_WHAT_CLEAR_LONGJMP_RESUME
1088 #define clrlrs BPSTAT_WHAT_CLEAR_LONGJMP_RESUME_SINGLE
1089 /* "Can't happen." Might want to print an error message.
1090 abort() is not out of the question, but chances are GDB is just
1091 a bit confused, not unusable. */
1092 #define err BPSTAT_WHAT_STOP_NOISY
1094 /* Given an old action and a class, come up with a new action. */
1095 static const enum bpstat_what
1096 table[(int)class_last][(int)BPSTAT_WHAT_LAST] =
1099 /* keep_c stop_s stop_n single setlr clrlr clrlrs */
1101 /*wp_nostop*/ {keep_c, stop_s, stop_n, single, setlr , clrlr , clrlrs},
1102 /*wp_silent*/ {stop_s, stop_s, stop_n, stop_s, stop_s, stop_s, stop_s},
1103 /*wp_noisy*/ {stop_n, stop_n, stop_n, stop_n, stop_n, stop_n, stop_n},
1104 /*bp_nostop*/ {single, stop_s, stop_n, single, setlr , clrlrs, clrlrs},
1105 /*bp_silent*/ {stop_s, stop_s, stop_n, stop_s, stop_s, stop_s, stop_s},
1106 /*bp_noisy*/ {stop_n, stop_n, stop_n, stop_n, stop_n, stop_n, stop_n},
1107 /*long_jump*/ {setlr , stop_s, stop_n, setlr , err , err , err },
1108 /*long_resume*/ {clrlr , stop_s, stop_n, clrlrs, err , err , err }
1118 enum bpstat_what current_action = BPSTAT_WHAT_KEEP_CHECKING;
1120 for (; bs != NULL; bs = bs->next)
1122 enum class bs_class;
1123 if (bs->breakpoint_at == NULL)
1124 /* I suspect this can happen if it was a momentary breakpoint
1125 which has since been deleted. */
1127 switch (bs->breakpoint_at->type)
1135 bs_class = bp_noisy;
1137 bs_class = bp_silent;
1140 bs_class = bp_nostop;
1146 bs_class = wp_noisy;
1148 bs_class = wp_silent;
1151 bs_class = wp_nostop;
1154 bs_class = long_jump;
1156 case bp_longjmp_resume:
1157 bs_class = long_resume;
1160 current_action = table[(int)bs_class][(int)current_action];
1162 return current_action;
1165 /* Nonzero if we should step constantly (e.g. watchpoints on machines
1166 without hardware support). This isn't related to a specific bpstat,
1167 just to things like whether watchpoints are set. */
1170 bpstat_should_step ()
1172 struct breakpoint *b;
1174 if (b->enable == enabled && b->type == bp_watchpoint)
1179 /* Print information on breakpoint number BNUM, or -1 if all.
1180 If WATCHPOINTS is zero, process only breakpoints; if WATCHPOINTS
1181 is nonzero, process only watchpoints. */
1184 breakpoint_1 (bnum, allflag)
1188 register struct breakpoint *b;
1189 register struct command_line *l;
1190 register struct symbol *sym;
1191 CORE_ADDR last_addr = (CORE_ADDR)-1;
1192 int found_a_breakpoint = 0;
1193 static char *bptypes[] = {"breakpoint", "until", "finish", "watchpoint",
1194 "longjmp", "longjmp resume"};
1195 static char *bpdisps[] = {"del", "dis", "keep"};
1196 static char bpenables[] = "ny";
1198 if (!breakpoint_chain)
1200 printf_filtered ("No breakpoints or watchpoints.\n");
1206 || bnum == b->number)
1208 /* We only print out user settable breakpoints unless the allflag is set. */
1210 && b->type != bp_breakpoint
1211 && b->type != bp_watchpoint)
1214 if (!found_a_breakpoint++)
1215 printf_filtered ("Num Type Disp Enb %sWhat\n",
1216 addressprint ? "Address " : "");
1218 printf_filtered ("%-3d %-14s %-4s %-3c ",
1220 bptypes[(int)b->type],
1221 bpdisps[(int)b->disposition],
1222 bpenables[(int)b->enable]);
1226 print_expression (b->exp, stdout);
1232 case bp_longjmp_resume:
1234 printf_filtered ("%s ", local_hex_string_custom(b->address, "08"));
1236 last_addr = b->address;
1239 sym = find_pc_function (b->address);
1242 fputs_filtered ("in ", stdout);
1243 fputs_filtered (SYMBOL_SOURCE_NAME (sym), stdout);
1244 fputs_filtered (" at ", stdout);
1246 fputs_filtered (b->symtab->filename, stdout);
1247 printf_filtered (":%d", b->line_number);
1250 print_address_symbolic (b->address, stdout, demangle, " ");
1253 printf_filtered ("\n");
1256 printf_filtered ("\tstop only in stack frame at %s\n",
1257 local_hex_string(b->frame));
1260 printf_filtered ("\tstop only if ");
1261 print_expression (b->cond, stdout);
1262 printf_filtered ("\n");
1264 if (b->ignore_count)
1265 printf_filtered ("\tignore next %d hits\n", b->ignore_count);
1266 if ((l = b->commands))
1269 fputs_filtered ("\t", stdout);
1270 fputs_filtered (l->line, stdout);
1271 fputs_filtered ("\n", stdout);
1276 if (!found_a_breakpoint
1278 printf_filtered ("No breakpoint or watchpoint number %d.\n", bnum);
1280 /* Compare against (CORE_ADDR)-1 in case some compiler decides
1281 that a comparison of an unsigned with -1 is always false. */
1282 if (last_addr != (CORE_ADDR)-1)
1283 set_next_address (last_addr);
1288 breakpoints_info (bnum_exp, from_tty)
1295 bnum = parse_and_eval_address (bnum_exp);
1297 breakpoint_1 (bnum, 0);
1300 #if MAINTENANCE_CMDS
1304 maintenance_info_breakpoints (bnum_exp, from_tty)
1311 bnum = parse_and_eval_address (bnum_exp);
1313 breakpoint_1 (bnum, 1);
1318 /* Print a message describing any breakpoints set at PC. */
1321 describe_other_breakpoints (pc)
1322 register CORE_ADDR pc;
1324 register int others = 0;
1325 register struct breakpoint *b;
1328 if (b->address == pc)
1332 printf ("Note: breakpoint%s ", (others > 1) ? "s" : "");
1334 if (b->address == pc)
1339 (b->enable == disabled) ? " (disabled)" : "",
1340 (others > 1) ? "," : ((others == 1) ? " and" : ""));
1342 printf ("also set at pc %s.\n", local_hex_string(pc));
1346 /* Set the default place to put a breakpoint
1347 for the `break' command with no arguments. */
1350 set_default_breakpoint (valid, addr, symtab, line)
1353 struct symtab *symtab;
1356 default_breakpoint_valid = valid;
1357 default_breakpoint_address = addr;
1358 default_breakpoint_symtab = symtab;
1359 default_breakpoint_line = line;
1362 /* Rescan breakpoints at address ADDRESS,
1363 marking the first one as "first" and any others as "duplicates".
1364 This is so that the bpt instruction is only inserted once. */
1367 check_duplicates (address)
1370 register struct breakpoint *b;
1371 register int count = 0;
1373 if (address == 0) /* Watchpoints are uninteresting */
1377 if (b->enable != disabled && b->address == address)
1380 b->duplicate = count > 1;
1384 /* Low level routine to set a breakpoint.
1385 Takes as args the three things that every breakpoint must have.
1386 Returns the breakpoint object so caller can set other things.
1387 Does not set the breakpoint number!
1388 Does not print anything.
1390 ==> This routine should not be called if there is a chance of later
1391 error(); otherwise it leaves a bogus breakpoint on the chain. Validate
1392 your arguments BEFORE calling this routine! */
1394 static struct breakpoint *
1395 set_raw_breakpoint (sal)
1396 struct symtab_and_line sal;
1398 register struct breakpoint *b, *b1;
1400 b = (struct breakpoint *) xmalloc (sizeof (struct breakpoint));
1401 memset (b, 0, sizeof (*b));
1402 b->address = sal.pc;
1403 b->symtab = sal.symtab;
1404 b->line_number = sal.line;
1405 b->enable = enabled;
1408 b->ignore_count = 0;
1412 /* Add this breakpoint to the end of the chain
1413 so that a list of breakpoints will come out in order
1414 of increasing numbers. */
1416 b1 = breakpoint_chain;
1418 breakpoint_chain = b;
1426 check_duplicates (sal.pc);
1432 create_longjmp_breakpoint(func_name)
1435 struct symtab_and_line sal;
1436 struct breakpoint *b;
1437 static int internal_breakpoint_number = -1;
1439 if (func_name != NULL)
1441 struct minimal_symbol *m;
1443 m = lookup_minimal_symbol(func_name, (struct objfile *)NULL);
1445 sal.pc = SYMBOL_VALUE_ADDRESS (m);
1455 b = set_raw_breakpoint(sal);
1458 b->type = func_name != NULL ? bp_longjmp : bp_longjmp_resume;
1459 b->disposition = donttouch;
1460 b->enable = disabled;
1463 b->addr_string = strsave(func_name);
1464 b->number = internal_breakpoint_number--;
1467 /* Call this routine when stepping and nexting to enable a breakpoint if we do
1468 a longjmp(). When we hit that breakpoint, call
1469 set_longjmp_resume_breakpoint() to figure out where we are going. */
1472 enable_longjmp_breakpoint()
1474 register struct breakpoint *b;
1477 if (b->type == bp_longjmp)
1479 b->enable = enabled;
1480 check_duplicates (b->address);
1485 disable_longjmp_breakpoint()
1487 register struct breakpoint *b;
1490 if ( b->type == bp_longjmp
1491 || b->type == bp_longjmp_resume)
1493 b->enable = disabled;
1494 check_duplicates (b->address);
1498 /* Call this after hitting the longjmp() breakpoint. Use this to set a new
1499 breakpoint at the target of the jmp_buf.
1501 FIXME - This ought to be done by setting a temporary breakpoint that gets
1502 deleted automatically...
1506 set_longjmp_resume_breakpoint(pc, frame)
1510 register struct breakpoint *b;
1513 if (b->type == bp_longjmp_resume)
1516 b->enable = enabled;
1518 b->frame = FRAME_FP(frame);
1521 check_duplicates (b->address);
1526 /* Set a breakpoint that will evaporate an end of command
1527 at address specified by SAL.
1528 Restrict it to frame FRAME if FRAME is nonzero. */
1531 set_momentary_breakpoint (sal, frame, type)
1532 struct symtab_and_line sal;
1536 register struct breakpoint *b;
1537 b = set_raw_breakpoint (sal);
1539 b->enable = enabled;
1540 b->disposition = donttouch;
1541 b->frame = (frame ? FRAME_FP (frame) : 0);
1547 clear_momentary_breakpoints ()
1549 register struct breakpoint *b;
1551 if (b->disposition == delete)
1553 delete_breakpoint (b);
1559 /* Tell the user we have just set a breakpoint B. */
1562 struct breakpoint *b;
1567 printf_filtered ("Watchpoint %d: ", b->number);
1568 print_expression (b->exp, stdout);
1571 printf_filtered ("Breakpoint %d at %s", b->number,
1572 local_hex_string(b->address));
1574 printf_filtered (": file %s, line %d.",
1575 b->symtab->filename, b->line_number);
1580 case bp_longjmp_resume:
1583 printf_filtered ("\n");
1587 /* Nobody calls this currently. */
1588 /* Set a breakpoint from a symtab and line.
1589 If TEMPFLAG is nonzero, it is a temporary breakpoint.
1590 ADDR_STRING is a malloc'd string holding the name of where we are
1591 setting the breakpoint. This is used later to re-set it after the
1592 program is relinked and symbols are reloaded.
1593 Print the same confirmation messages that the breakpoint command prints. */
1596 set_breakpoint (s, line, tempflag, addr_string)
1602 register struct breakpoint *b;
1603 struct symtab_and_line sal;
1608 resolve_sal_pc (&sal); /* Might error out */
1609 describe_other_breakpoints (sal.pc);
1611 b = set_raw_breakpoint (sal);
1612 set_breakpoint_count (breakpoint_count + 1);
1613 b->number = breakpoint_count;
1614 b->type = bp_breakpoint;
1616 b->addr_string = addr_string;
1617 b->enable = enabled;
1618 b->disposition = tempflag ? delete : donttouch;
1624 /* Set a breakpoint according to ARG (function, linenum or *address)
1625 and make it temporary if TEMPFLAG is nonzero. */
1628 break_command_1 (arg, tempflag, from_tty)
1630 int tempflag, from_tty;
1632 struct symtabs_and_lines sals;
1633 struct symtab_and_line sal;
1634 register struct expression *cond = 0;
1635 register struct breakpoint *b;
1637 /* Pointers in arg to the start, and one past the end, of the condition. */
1638 char *cond_start = NULL;
1640 /* Pointers in arg to the start, and one past the end,
1641 of the address part. */
1642 char *addr_start = NULL;
1650 sal.line = sal.pc = sal.end = 0;
1653 /* If no arg given, or if first arg is 'if ', use the default breakpoint. */
1655 if (!arg || (arg[0] == 'i' && arg[1] == 'f'
1656 && (arg[2] == ' ' || arg[2] == '\t')))
1658 if (default_breakpoint_valid)
1660 sals.sals = (struct symtab_and_line *)
1661 xmalloc (sizeof (struct symtab_and_line));
1662 sal.pc = default_breakpoint_address;
1663 sal.line = default_breakpoint_line;
1664 sal.symtab = default_breakpoint_symtab;
1669 error ("No default breakpoint address now.");
1675 /* Force almost all breakpoints to be in terms of the
1676 current_source_symtab (which is decode_line_1's default). This
1677 should produce the results we want almost all of the time while
1678 leaving default_breakpoint_* alone. */
1679 if (default_breakpoint_valid
1680 && (!current_source_symtab
1681 || (arg && (*arg == '+' || *arg == '-'))))
1682 sals = decode_line_1 (&arg, 1, default_breakpoint_symtab,
1683 default_breakpoint_line);
1685 sals = decode_line_1 (&arg, 1, (struct symtab *)NULL, 0);
1693 /* Resolve all line numbers to PC's, and verify that conditions
1694 can be parsed, before setting any breakpoints. */
1695 for (i = 0; i < sals.nelts; i++)
1697 resolve_sal_pc (&sals.sals[i]);
1701 if (arg[0] == 'i' && arg[1] == 'f'
1702 && (arg[2] == ' ' || arg[2] == '\t'))
1706 cond = parse_exp_1 (&arg, block_for_pc (sals.sals[i].pc), 0);
1710 error ("Junk at end of arguments.");
1714 /* Now set all the breakpoints. */
1715 for (i = 0; i < sals.nelts; i++)
1720 describe_other_breakpoints (sal.pc);
1722 b = set_raw_breakpoint (sal);
1723 set_breakpoint_count (breakpoint_count + 1);
1724 b->number = breakpoint_count;
1725 b->type = bp_breakpoint;
1728 /* FIXME: We should add the filename if this is a static function
1729 and probably if it is a line number (the line numbers could
1730 have changed when we re-read symbols; possibly better to disable
1731 the breakpoint in that case). */
1733 b->addr_string = savestring (addr_start, addr_end - addr_start);
1735 b->cond_string = savestring (cond_start, cond_end - cond_start);
1737 b->enable = enabled;
1738 b->disposition = tempflag ? delete : donttouch;
1745 printf ("Multiple breakpoints were set.\n");
1746 printf ("Use the \"delete\" command to delete unwanted breakpoints.\n");
1748 free ((PTR)sals.sals);
1751 /* Helper function for break_command_1 and disassemble_command. */
1754 resolve_sal_pc (sal)
1755 struct symtab_and_line *sal;
1759 if (sal->pc == 0 && sal->symtab != 0)
1761 pc = find_line_pc (sal->symtab, sal->line);
1763 error ("No line %d in file \"%s\".",
1764 sal->line, sal->symtab->filename);
1770 break_command (arg, from_tty)
1774 break_command_1 (arg, 0, from_tty);
1778 tbreak_command (arg, from_tty)
1782 break_command_1 (arg, 1, from_tty);
1787 watch_command (arg, from_tty)
1791 struct breakpoint *b;
1792 struct symtab_and_line sal;
1793 struct expression *exp;
1794 struct block *exp_valid_block;
1801 /* Parse arguments. */
1802 innermost_block = NULL;
1803 exp = parse_expression (arg);
1804 exp_valid_block = innermost_block;
1805 val = evaluate_expression (exp);
1806 release_value (val);
1807 if (VALUE_LAZY (val))
1808 value_fetch_lazy (val);
1810 /* Now set up the breakpoint. */
1811 b = set_raw_breakpoint (sal);
1812 set_breakpoint_count (breakpoint_count + 1);
1813 b->number = breakpoint_count;
1814 b->type = bp_watchpoint;
1815 b->disposition = donttouch;
1817 b->exp_valid_block = exp_valid_block;
1820 b->cond_string = NULL;
1821 b->exp_string = savestring (arg, strlen (arg));
1826 * Helper routine for the until_command routine in infcmd.c. Here
1827 * because it uses the mechanisms of breakpoints.
1831 until_break_command (arg, from_tty)
1835 struct symtabs_and_lines sals;
1836 struct symtab_and_line sal;
1837 FRAME prev_frame = get_prev_frame (selected_frame);
1838 struct breakpoint *breakpoint;
1839 struct cleanup *old_chain;
1841 clear_proceed_status ();
1843 /* Set a breakpoint where the user wants it and at return from
1846 if (default_breakpoint_valid)
1847 sals = decode_line_1 (&arg, 1, default_breakpoint_symtab,
1848 default_breakpoint_line);
1850 sals = decode_line_1 (&arg, 1, (struct symtab *)NULL, 0);
1852 if (sals.nelts != 1)
1853 error ("Couldn't get information on specified line.");
1856 free ((PTR)sals.sals); /* malloc'd, so freed */
1859 error ("Junk at end of arguments.");
1861 resolve_sal_pc (&sal);
1863 breakpoint = set_momentary_breakpoint (sal, selected_frame, bp_until);
1865 old_chain = make_cleanup(delete_breakpoint, breakpoint);
1867 /* Keep within the current frame */
1871 struct frame_info *fi;
1873 fi = get_frame_info (prev_frame);
1874 sal = find_pc_line (fi->pc, 0);
1876 breakpoint = set_momentary_breakpoint (sal, prev_frame, bp_until);
1877 make_cleanup(delete_breakpoint, breakpoint);
1880 proceed (-1, -1, 0);
1881 do_cleanups(old_chain);
1885 /* These aren't used; I don't konw what they were for. */
1886 /* Set a breakpoint at the catch clause for NAME. */
1888 catch_breakpoint (name)
1894 disable_catch_breakpoint ()
1899 delete_catch_breakpoint ()
1904 enable_catch_breakpoint ()
1911 struct sal_chain *next;
1912 struct symtab_and_line sal;
1916 /* This isn't used; I don't know what it was for. */
1917 /* For each catch clause identified in ARGS, run FUNCTION
1918 with that clause as an argument. */
1919 static struct symtabs_and_lines
1920 map_catch_names (args, function)
1924 register char *p = args;
1926 struct symtabs_and_lines sals;
1928 struct sal_chain *sal_chain = 0;
1932 error_no_arg ("one or more catch names");
1940 /* Don't swallow conditional part. */
1941 if (p1[0] == 'i' && p1[1] == 'f'
1942 && (p1[2] == ' ' || p1[2] == '\t'))
1948 while (isalnum (*p1) || *p1 == '_' || *p1 == '$')
1952 if (*p1 && *p1 != ' ' && *p1 != '\t')
1953 error ("Arguments must be catch names.");
1959 struct sal_chain *next
1960 = (struct sal_chain *)alloca (sizeof (struct sal_chain));
1961 next->next = sal_chain;
1962 next->sal = get_catch_sal (p);
1967 printf ("No catch clause for exception %s.\n", p);
1972 while (*p == ' ' || *p == '\t') p++;
1977 /* This shares a lot of code with `print_frame_label_vars' from stack.c. */
1979 static struct symtabs_and_lines
1980 get_catch_sals (this_level_only)
1981 int this_level_only;
1983 register struct blockvector *bl;
1984 register struct block *block;
1985 int index, have_default = 0;
1986 struct frame_info *fi;
1988 struct symtabs_and_lines sals;
1989 struct sal_chain *sal_chain = 0;
1990 char *blocks_searched;
1992 /* Not sure whether an error message is always the correct response,
1993 but it's better than a core dump. */
1994 if (selected_frame == NULL)
1995 error ("No selected frame.");
1996 block = get_frame_block (selected_frame);
1997 fi = get_frame_info (selected_frame);
2004 error ("No symbol table info available.\n");
2006 bl = blockvector_for_pc (BLOCK_END (block) - 4, &index);
2007 blocks_searched = (char *) alloca (BLOCKVECTOR_NBLOCKS (bl) * sizeof (char));
2008 memset (blocks_searched, 0, BLOCKVECTOR_NBLOCKS (bl) * sizeof (char));
2012 CORE_ADDR end = BLOCK_END (block) - 4;
2015 if (bl != blockvector_for_pc (end, &index))
2016 error ("blockvector blotch");
2017 if (BLOCKVECTOR_BLOCK (bl, index) != block)
2018 error ("blockvector botch");
2019 last_index = BLOCKVECTOR_NBLOCKS (bl);
2022 /* Don't print out blocks that have gone by. */
2023 while (index < last_index
2024 && BLOCK_END (BLOCKVECTOR_BLOCK (bl, index)) < pc)
2027 while (index < last_index
2028 && BLOCK_END (BLOCKVECTOR_BLOCK (bl, index)) < end)
2030 if (blocks_searched[index] == 0)
2032 struct block *b = BLOCKVECTOR_BLOCK (bl, index);
2035 register struct symbol *sym;
2037 nsyms = BLOCK_NSYMS (b);
2039 for (i = 0; i < nsyms; i++)
2041 sym = BLOCK_SYM (b, i);
2042 if (STREQ (SYMBOL_NAME (sym), "default"))
2048 if (SYMBOL_CLASS (sym) == LOC_LABEL)
2050 struct sal_chain *next = (struct sal_chain *)
2051 alloca (sizeof (struct sal_chain));
2052 next->next = sal_chain;
2053 next->sal = find_pc_line (SYMBOL_VALUE_ADDRESS (sym), 0);
2057 blocks_searched[index] = 1;
2063 if (sal_chain && this_level_only)
2066 /* After handling the function's top-level block, stop.
2067 Don't continue to its superblock, the block of
2068 per-file symbols. */
2069 if (BLOCK_FUNCTION (block))
2071 block = BLOCK_SUPERBLOCK (block);
2076 struct sal_chain *tmp_chain;
2078 /* Count the number of entries. */
2079 for (index = 0, tmp_chain = sal_chain; tmp_chain;
2080 tmp_chain = tmp_chain->next)
2084 sals.sals = (struct symtab_and_line *)
2085 xmalloc (index * sizeof (struct symtab_and_line));
2086 for (index = 0; sal_chain; sal_chain = sal_chain->next, index++)
2087 sals.sals[index] = sal_chain->sal;
2093 /* Commands to deal with catching exceptions. */
2096 catch_command_1 (arg, tempflag, from_tty)
2101 /* First, translate ARG into something we can deal with in terms
2104 struct symtabs_and_lines sals;
2105 struct symtab_and_line sal;
2106 register struct expression *cond = 0;
2107 register struct breakpoint *b;
2111 sal.line = sal.pc = sal.end = 0;
2114 /* If no arg given, or if first arg is 'if ', all active catch clauses
2115 are breakpointed. */
2117 if (!arg || (arg[0] == 'i' && arg[1] == 'f'
2118 && (arg[2] == ' ' || arg[2] == '\t')))
2120 /* Grab all active catch clauses. */
2121 sals = get_catch_sals (0);
2125 /* Grab selected catch clauses. */
2126 error ("catch NAME not implemeneted");
2128 /* This isn't used; I don't know what it was for. */
2129 sals = map_catch_names (arg, catch_breakpoint);
2137 for (i = 0; i < sals.nelts; i++)
2139 resolve_sal_pc (&sals.sals[i]);
2143 if (arg[0] == 'i' && arg[1] == 'f'
2144 && (arg[2] == ' ' || arg[2] == '\t'))
2145 cond = parse_exp_1 ((arg += 2, &arg),
2146 block_for_pc (sals.sals[i].pc), 0);
2148 error ("Junk at end of arguments.");
2153 for (i = 0; i < sals.nelts; i++)
2158 describe_other_breakpoints (sal.pc);
2160 b = set_raw_breakpoint (sal);
2161 set_breakpoint_count (breakpoint_count + 1);
2162 b->number = breakpoint_count;
2163 b->type = bp_breakpoint;
2165 b->enable = enabled;
2166 b->disposition = tempflag ? delete : donttouch;
2168 printf ("Breakpoint %d at %s", b->number, local_hex_string(b->address));
2170 printf (": file %s, line %d.", b->symtab->filename, b->line_number);
2176 printf ("Multiple breakpoints were set.\n");
2177 printf ("Use the \"delete\" command to delete unwanted breakpoints.\n");
2179 free ((PTR)sals.sals);
2183 /* These aren't used; I don't know what they were for. */
2184 /* Disable breakpoints on all catch clauses described in ARGS. */
2186 disable_catch (args)
2189 /* Map the disable command to catch clauses described in ARGS. */
2192 /* Enable breakpoints on all catch clauses described in ARGS. */
2197 /* Map the disable command to catch clauses described in ARGS. */
2200 /* Delete breakpoints on all catch clauses in the active scope. */
2205 /* Map the delete command to catch clauses described in ARGS. */
2210 catch_command (arg, from_tty)
2214 catch_command_1 (arg, 0, from_tty);
2218 clear_command (arg, from_tty)
2222 register struct breakpoint *b, *b1;
2223 struct symtabs_and_lines sals;
2224 struct symtab_and_line sal;
2225 register struct breakpoint *found;
2230 sals = decode_line_spec (arg, 1);
2234 sals.sals = (struct symtab_and_line *) xmalloc (sizeof (struct symtab_and_line));
2235 sal.line = default_breakpoint_line;
2236 sal.symtab = default_breakpoint_symtab;
2238 if (sal.symtab == 0)
2239 error ("No source file specified.");
2245 for (i = 0; i < sals.nelts; i++)
2247 /* If exact pc given, clear bpts at that pc.
2248 But if sal.pc is zero, clear all bpts on specified line. */
2250 found = (struct breakpoint *) 0;
2251 while (breakpoint_chain
2252 && (sal.pc ? breakpoint_chain->address == sal.pc
2253 : (breakpoint_chain->symtab == sal.symtab
2254 && breakpoint_chain->line_number == sal.line)))
2256 b1 = breakpoint_chain;
2257 breakpoint_chain = b1->next;
2264 && b->next->type != bp_watchpoint
2265 && (sal.pc ? b->next->address == sal.pc
2266 : (b->next->symtab == sal.symtab
2267 && b->next->line_number == sal.line)))
2278 error ("No breakpoint at %s.", arg);
2280 error ("No breakpoint at this line.");
2283 if (found->next) from_tty = 1; /* Always report if deleted more than one */
2284 if (from_tty) printf ("Deleted breakpoint%s ", found->next ? "s" : "");
2287 if (from_tty) printf ("%d ", found->number);
2289 delete_breakpoint (found);
2292 if (from_tty) putchar ('\n');
2294 free ((PTR)sals.sals);
2297 /* Delete breakpoint in BS if they are `delete' breakpoints.
2298 This is called after any breakpoint is hit, or after errors. */
2301 breakpoint_auto_delete (bs)
2304 for (; bs; bs = bs->next)
2305 if (bs->breakpoint_at && bs->breakpoint_at->disposition == delete)
2306 delete_breakpoint (bs->breakpoint_at);
2309 /* Delete a breakpoint and clean up all traces of it in the data structures. */
2312 delete_breakpoint (bpt)
2313 struct breakpoint *bpt;
2315 register struct breakpoint *b;
2319 target_remove_breakpoint(bpt->address, bpt->shadow_contents);
2321 if (breakpoint_chain == bpt)
2322 breakpoint_chain = bpt->next;
2327 b->next = bpt->next;
2331 check_duplicates (bpt->address);
2333 free_command_lines (&bpt->commands);
2335 free ((PTR)bpt->cond);
2336 if (bpt->cond_string != NULL)
2337 free ((PTR)bpt->cond_string);
2338 if (bpt->addr_string != NULL)
2339 free ((PTR)bpt->addr_string);
2340 if (bpt->exp_string != NULL)
2341 free ((PTR)bpt->exp_string);
2343 if (xgdb_verbose && bpt->type == bp_breakpoint)
2344 printf ("breakpoint #%d deleted\n", bpt->number);
2346 /* Be sure no bpstat's are pointing at it after it's been freed. */
2347 /* FIXME, how can we find all bpstat's? We just check stop_bpstat for now. */
2348 for (bs = stop_bpstat; bs; bs = bs->next)
2349 if (bs->breakpoint_at == bpt)
2350 bs->breakpoint_at = NULL;
2355 delete_command (arg, from_tty)
2362 /* Ask user only if there are some breakpoints to delete. */
2364 || (breakpoint_chain && query ("Delete all breakpoints? ", 0, 0)))
2366 /* No arg; clear all breakpoints. */
2367 while (breakpoint_chain)
2368 delete_breakpoint (breakpoint_chain);
2372 map_breakpoint_numbers (arg, delete_breakpoint);
2375 /* Reset a breakpoint given it's struct breakpoint * BINT.
2376 The value we return ends up being the return value from catch_errors.
2377 Unused in this case. */
2380 breakpoint_re_set_one (bint)
2383 struct breakpoint *b = (struct breakpoint *)bint; /* get past catch_errs */
2385 struct symtabs_and_lines sals;
2387 enum enable save_enable;
2392 if (b->addr_string == NULL)
2394 /* Anything without a string can't be re-set. */
2395 delete_breakpoint (b);
2398 /* In case we have a problem, disable this breakpoint. We'll restore
2399 its status if we succeed. */
2400 save_enable = b->enable;
2401 b->enable = disabled;
2404 sals = decode_line_1 (&s, 1, (struct symtab *)NULL, 0);
2405 for (i = 0; i < sals.nelts; i++)
2407 resolve_sal_pc (&sals.sals[i]);
2408 if (b->symtab != sals.sals[i].symtab
2409 || b->line_number != sals.sals[i].line
2410 || b->address != sals.sals[i].pc)
2412 b->symtab = sals.sals[i].symtab;
2413 b->line_number = sals.sals[i].line;
2414 b->address = sals.sals[i].pc;
2416 if (b->cond_string != NULL)
2420 free ((PTR)b->cond);
2421 b->cond = parse_exp_1 (&s, block_for_pc (sals.sals[i].pc), 0);
2424 check_duplicates (b->address);
2428 b->enable = save_enable; /* Restore it, this worked. */
2430 free ((PTR)sals.sals);
2434 innermost_block = NULL;
2435 /* The issue arises of what context to evaluate this in. The same
2436 one as when it was set, but what does that mean when symbols have
2437 been re-read? We could save the filename and functionname, but
2438 if the context is more local than that, the best we could do would
2439 be something like how many levels deep and which index at that
2440 particular level, but that's going to be less stable than filenames
2441 or functionnames. */
2442 /* So for now, just use a global context. */
2443 b->exp = parse_expression (b->exp_string);
2444 b->exp_valid_block = innermost_block;
2445 b->val = evaluate_expression (b->exp);
2446 release_value (b->val);
2447 if (VALUE_LAZY (b->val))
2448 value_fetch_lazy (b->val);
2450 if (b->cond_string != NULL)
2453 b->cond = parse_exp_1 (&s, (struct block *)0, 0);
2455 if (b->enable == enabled)
2460 printf_filtered ("Deleting unknown breakpoint type %d\n", b->type);
2465 case bp_longjmp_resume:
2466 delete_breakpoint (b);
2473 /* Re-set all breakpoints after symbols have been re-loaded. */
2475 breakpoint_re_set ()
2477 struct breakpoint *b, *temp;
2478 static char message1[] = "Error in re-setting breakpoint %d:\n";
2479 char message[sizeof (message1) + 30 /* slop */];
2481 /* If we have no current source symtab, and we have any breakpoints,
2482 go through the work of making a source context. */
2483 if (current_source_symtab == NULL && breakpoint_chain != 0)
2485 select_source_symtab (NULL);
2488 ALL_BREAKPOINTS_SAFE (b, temp)
2490 sprintf (message, message1, b->number); /* Format possible error msg */
2491 catch_errors (breakpoint_re_set_one, (char *) b, message);
2494 create_longjmp_breakpoint("longjmp");
2495 create_longjmp_breakpoint("_longjmp");
2496 create_longjmp_breakpoint("siglongjmp");
2497 create_longjmp_breakpoint(NULL);
2500 /* Took this out (temporaliy at least), since it produces an extra
2501 blank line at startup. This messes up the gdbtests. -PB */
2502 /* Blank line to finish off all those mention() messages we just printed. */
2503 printf_filtered ("\n");
2507 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
2508 If from_tty is nonzero, it prints a message to that effect,
2509 which ends with a period (no newline). */
2512 set_ignore_count (bptnum, count, from_tty)
2513 int bptnum, count, from_tty;
2515 register struct breakpoint *b;
2521 if (b->number == bptnum)
2523 b->ignore_count = count;
2526 else if (count == 0)
2527 printf_filtered ("Will stop next time breakpoint %d is reached.",
2529 else if (count == 1)
2530 printf_filtered ("Will ignore next crossing of breakpoint %d.",
2533 printf_filtered ("Will ignore next %d crossings of breakpoint %d.",
2538 error ("No breakpoint number %d.", bptnum);
2541 /* Clear the ignore counts of all breakpoints. */
2543 breakpoint_clear_ignore_counts ()
2545 struct breakpoint *b;
2548 b->ignore_count = 0;
2551 /* Command to set ignore-count of breakpoint N to COUNT. */
2554 ignore_command (args, from_tty)
2562 error_no_arg ("a breakpoint number");
2564 num = get_number (&p);
2567 error ("Second argument (specified ignore-count) is missing.");
2569 set_ignore_count (num,
2570 longest_to_int (value_as_long (parse_and_eval (p))),
2572 printf_filtered ("\n");
2575 /* Call FUNCTION on each of the breakpoints
2576 whose numbers are given in ARGS. */
2579 map_breakpoint_numbers (args, function)
2581 void (*function) PARAMS ((struct breakpoint *));
2583 register char *p = args;
2586 register struct breakpoint *b;
2589 error_no_arg ("one or more breakpoint numbers");
2595 num = get_number (&p1);
2598 if (b->number == num)
2603 printf ("No breakpoint number %d.\n", num);
2610 enable_breakpoint (bpt)
2611 struct breakpoint *bpt;
2613 bpt->enable = enabled;
2615 if (xgdb_verbose && bpt->type == bp_breakpoint)
2616 printf ("breakpoint #%d enabled\n", bpt->number);
2618 check_duplicates (bpt->address);
2619 if (bpt->type == bp_watchpoint)
2621 if (bpt->exp_valid_block != NULL
2622 && !contained_in (get_selected_block (), bpt->exp_valid_block))
2625 Cannot enable watchpoint %d because the block in which its expression\n\
2626 is valid is not currently in scope.\n", bpt->number);
2627 bpt->enable = disabled;
2631 value_free (bpt->val);
2633 bpt->val = evaluate_expression (bpt->exp);
2634 release_value (bpt->val);
2635 if (VALUE_LAZY (bpt->val))
2636 value_fetch_lazy (bpt->val);
2642 enable_command (args, from_tty)
2646 struct breakpoint *bpt;
2648 ALL_BREAKPOINTS (bpt)
2653 enable_breakpoint (bpt);
2658 map_breakpoint_numbers (args, enable_breakpoint);
2662 disable_breakpoint (bpt)
2663 struct breakpoint *bpt;
2665 bpt->enable = disabled;
2667 if (xgdb_verbose && bpt->type == bp_breakpoint)
2668 printf_filtered ("breakpoint #%d disabled\n", bpt->number);
2670 check_duplicates (bpt->address);
2675 disable_command (args, from_tty)
2679 register struct breakpoint *bpt;
2681 ALL_BREAKPOINTS (bpt)
2686 disable_breakpoint (bpt);
2691 map_breakpoint_numbers (args, disable_breakpoint);
2695 enable_once_breakpoint (bpt)
2696 struct breakpoint *bpt;
2698 bpt->enable = enabled;
2699 bpt->disposition = disable;
2701 check_duplicates (bpt->address);
2706 enable_once_command (args, from_tty)
2710 map_breakpoint_numbers (args, enable_once_breakpoint);
2714 enable_delete_breakpoint (bpt)
2715 struct breakpoint *bpt;
2717 bpt->enable = enabled;
2718 bpt->disposition = delete;
2720 check_duplicates (bpt->address);
2725 enable_delete_command (args, from_tty)
2729 map_breakpoint_numbers (args, enable_delete_breakpoint);
2733 * Use default_breakpoint_'s, or nothing if they aren't valid.
2735 struct symtabs_and_lines
2736 decode_line_spec_1 (string, funfirstline)
2740 struct symtabs_and_lines sals;
2742 error ("Empty line specification.");
2743 if (default_breakpoint_valid)
2744 sals = decode_line_1 (&string, funfirstline,
2745 default_breakpoint_symtab, default_breakpoint_line);
2747 sals = decode_line_1 (&string, funfirstline, (struct symtab *)NULL, 0);
2749 error ("Junk at end of line specification: %s", string);
2754 _initialize_breakpoint ()
2756 breakpoint_chain = 0;
2757 /* Don't bother to call set_breakpoint_count. $bpnum isn't useful
2758 before a breakpoint is set. */
2759 breakpoint_count = 0;
2761 add_com ("ignore", class_breakpoint, ignore_command,
2762 "Set ignore-count of breakpoint number N to COUNT.");
2764 add_com ("commands", class_breakpoint, commands_command,
2765 "Set commands to be executed when a breakpoint is hit.\n\
2766 Give breakpoint number as argument after \"commands\".\n\
2767 With no argument, the targeted breakpoint is the last one set.\n\
2768 The commands themselves follow starting on the next line.\n\
2769 Type a line containing \"end\" to indicate the end of them.\n\
2770 Give \"silent\" as the first line to make the breakpoint silent;\n\
2771 then no output is printed when it is hit, except what the commands print.");
2773 add_com ("condition", class_breakpoint, condition_command,
2774 "Specify breakpoint number N to break only if COND is true.\n\
2775 N is an integer; COND is an expression to be evaluated whenever\n\
2776 breakpoint N is reached. ");
2778 add_com ("tbreak", class_breakpoint, tbreak_command,
2779 "Set a temporary breakpoint. Args like \"break\" command.\n\
2780 Like \"break\" except the breakpoint is only enabled temporarily,\n\
2781 so it will be disabled when hit. Equivalent to \"break\" followed\n\
2782 by using \"enable once\" on the breakpoint number.");
2784 add_prefix_cmd ("enable", class_breakpoint, enable_command,
2785 "Enable some breakpoints.\n\
2786 Give breakpoint numbers (separated by spaces) as arguments.\n\
2787 With no subcommand, breakpoints are enabled until you command otherwise.\n\
2788 This is used to cancel the effect of the \"disable\" command.\n\
2789 With a subcommand you can enable temporarily.",
2790 &enablelist, "enable ", 1, &cmdlist);
2792 add_abbrev_prefix_cmd ("breakpoints", class_breakpoint, enable_command,
2793 "Enable some breakpoints.\n\
2794 Give breakpoint numbers (separated by spaces) as arguments.\n\
2795 This is used to cancel the effect of the \"disable\" command.\n\
2796 May be abbreviated to simply \"enable\".\n",
2797 &enablebreaklist, "enable breakpoints ", 1, &enablelist);
2799 add_cmd ("once", no_class, enable_once_command,
2800 "Enable breakpoints for one hit. Give breakpoint numbers.\n\
2801 If a breakpoint is hit while enabled in this fashion, it becomes disabled.\n\
2802 See the \"tbreak\" command which sets a breakpoint and enables it once.",
2805 add_cmd ("delete", no_class, enable_delete_command,
2806 "Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
2807 If a breakpoint is hit while enabled in this fashion, it is deleted.",
2810 add_cmd ("delete", no_class, enable_delete_command,
2811 "Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
2812 If a breakpoint is hit while enabled in this fashion, it is deleted.",
2815 add_cmd ("once", no_class, enable_once_command,
2816 "Enable breakpoints for one hit. Give breakpoint numbers.\n\
2817 If a breakpoint is hit while enabled in this fashion, it becomes disabled.\n\
2818 See the \"tbreak\" command which sets a breakpoint and enables it once.",
2821 add_prefix_cmd ("disable", class_breakpoint, disable_command,
2822 "Disable some breakpoints.\n\
2823 Arguments are breakpoint numbers with spaces in between.\n\
2824 To disable all breakpoints, give no argument.\n\
2825 A disabled breakpoint is not forgotten, but has no effect until reenabled.",
2826 &disablelist, "disable ", 1, &cmdlist);
2827 add_com_alias ("dis", "disable", class_breakpoint, 1);
2828 add_com_alias ("disa", "disable", class_breakpoint, 1);
2830 add_cmd ("breakpoints", class_alias, disable_command,
2831 "Disable some breakpoints.\n\
2832 Arguments are breakpoint numbers with spaces in between.\n\
2833 To disable all breakpoints, give no argument.\n\
2834 A disabled breakpoint is not forgotten, but has no effect until reenabled.\n\
2835 This command may be abbreviated \"disable\".",
2838 add_prefix_cmd ("delete", class_breakpoint, delete_command,
2839 "Delete some breakpoints or auto-display expressions.\n\
2840 Arguments are breakpoint numbers with spaces in between.\n\
2841 To delete all breakpoints, give no argument.\n\
2843 Also a prefix command for deletion of other GDB objects.\n\
2844 The \"unset\" command is also an alias for \"delete\".",
2845 &deletelist, "delete ", 1, &cmdlist);
2846 add_com_alias ("d", "delete", class_breakpoint, 1);
2848 add_cmd ("breakpoints", class_alias, delete_command,
2849 "Delete some breakpoints or auto-display expressions.\n\
2850 Arguments are breakpoint numbers with spaces in between.\n\
2851 To delete all breakpoints, give no argument.\n\
2852 This command may be abbreviated \"delete\".",
2855 add_com ("clear", class_breakpoint, clear_command,
2856 "Clear breakpoint at specified line or function.\n\
2857 Argument may be line number, function name, or \"*\" and an address.\n\
2858 If line number is specified, all breakpoints in that line are cleared.\n\
2859 If function is specified, breakpoints at beginning of function are cleared.\n\
2860 If an address is specified, breakpoints at that address are cleared.\n\n\
2861 With no argument, clears all breakpoints in the line that the selected frame\n\
2864 See also the \"delete\" command which clears breakpoints by number.");
2866 add_com ("break", class_breakpoint, break_command,
2867 "Set breakpoint at specified line or function.\n\
2868 Argument may be line number, function name, or \"*\" and an address.\n\
2869 If line number is specified, break at start of code for that line.\n\
2870 If function is specified, break at start of code for that function.\n\
2871 If an address is specified, break at that exact address.\n\
2872 With no arg, uses current execution address of selected stack frame.\n\
2873 This is useful for breaking on return to a stack frame.\n\
2875 Multiple breakpoints at one place are permitted, and useful if conditional.\n\
2877 Do \"help breakpoints\" for info on other commands dealing with breakpoints.");
2878 add_com_alias ("b", "break", class_run, 1);
2879 add_com_alias ("br", "break", class_run, 1);
2880 add_com_alias ("bre", "break", class_run, 1);
2881 add_com_alias ("brea", "break", class_run, 1);
2883 add_info ("breakpoints", breakpoints_info,
2884 "Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
2885 The \"Type\" column indicates one of:\n\
2886 \tbreakpoint - normal breakpoint\n\
2887 \twatchpoint - watchpoint\n\
2888 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
2889 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
2890 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
2891 address and file/line number respectively.\n\n\
2892 Convenience variable \"$_\" and default examine address for \"x\"\n\
2893 are set to the address of the last breakpoint listed.\n\n\
2894 Convenience variable \"$bpnum\" contains the number of the last\n\
2897 #if MAINTENANCE_CMDS
2899 add_cmd ("breakpoints", class_maintenance, maintenance_info_breakpoints,
2900 "Status of all breakpoints, or breakpoint number NUMBER.\n\
2901 The \"Type\" column indicates one of:\n\
2902 \tbreakpoint - normal breakpoint\n\
2903 \twatchpoint - watchpoint\n\
2904 \tlongjmp - internal breakpoint used to step through longjmp()\n\
2905 \tlongjmp resume - internal breakpoint at the target of longjmp()\n\
2906 \tuntil - internal breakpoint used by the \"until\" command\n\
2907 \tfinish - internal breakpoint used by the \"finish\" command\n\
2908 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
2909 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
2910 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
2911 address and file/line number respectively.\n\n\
2912 Convenience variable \"$_\" and default examine address for \"x\"\n\
2913 are set to the address of the last breakpoint listed.\n\n\
2914 Convenience variable \"$bpnum\" contains the number of the last\n\
2916 &maintenanceinfolist);
2918 #endif /* MAINTENANCE_CMDS */
2920 add_com ("catch", class_breakpoint, catch_command,
2921 "Set breakpoints to catch exceptions that are raised.\n\
2922 Argument may be a single exception to catch, multiple exceptions\n\
2923 to catch, or the default exception \"default\". If no arguments\n\
2924 are given, breakpoints are set at all exception handlers catch clauses\n\
2925 within the current scope.\n\
2927 A condition specified for the catch applies to all breakpoints set\n\
2928 with this command\n\
2930 Do \"help breakpoints\" for info on other commands dealing with breakpoints.");
2932 add_com ("watch", class_breakpoint, watch_command,
2933 "Set a watchpoint for an expression.\n\
2934 A watchpoint stops execution of your program whenever the value of\n\
2935 an expression changes.");
2937 add_info ("watchpoints", breakpoints_info,
2938 "Synonym for ``info breakpoints''.");
2941 /* OK, when we call objfile_relocate, we need to relocate breakpoints
2942 too. breakpoint_re_set is not a good choice--for example, if
2943 addr_string contains just a line number without a file name the
2944 breakpoint might get set in a different file. In general, there is
2945 no need to go all the way back to the user's string (though this might
2946 work if some effort were made to canonicalize it), since symtabs and
2947 everything except addresses are still valid.
2949 Probably the best way to solve this is to have each breakpoint save
2950 the objfile and the section number that was used to set it (if set
2951 by "*addr", probably it is best to use find_pc_line to get a symtab
2952 and use the objfile and block_line_section for that symtab). Then
2953 objfile_relocate can call fixup_breakpoints with the objfile and
2954 the new_offsets, and it can relocate only the appropriate breakpoints. */
2956 #ifdef IBM6000_TARGET
2957 /* But for now, just kludge it based on the concept that before an
2958 objfile is relocated the breakpoint is below 0x10000000, and afterwards
2959 it is higher, so that way we only relocate each breakpoint once. */
2962 fixup_breakpoints (low, high, delta)
2967 struct breakpoint *b;
2971 if (b->address >= low && b->address <= high)
2972 b->address += delta;