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 ())
321 printf_filtered ("Type commands for when breakpoint %d is hit, one per line.\n\
322 End with a line saying just \"end\".\n", bnum
);
325 l
= read_command_lines ();
326 free_command_lines (&b
->commands
);
330 error ("No breakpoint number %d.", bnum
);
333 extern int memory_breakpoint_size
; /* from mem-break.c */
335 /* Like target_read_memory() but if breakpoints are inserted, return
336 the shadow contents instead of the breakpoints themselves.
338 Read "memory data" from whatever target or inferior we have.
339 Returns zero if successful, errno value if not. EIO is used
340 for address out of bounds. If breakpoints are inserted, returns
341 shadow contents, not the breakpoints themselves. From breakpoint.c. */
344 read_memory_nobpt (memaddr
, myaddr
, len
)
350 struct breakpoint
*b
;
352 if (memory_breakpoint_size
< 0)
353 /* No breakpoints on this machine. */
354 return target_read_memory (memaddr
, myaddr
, len
);
358 if (b
->type
== bp_watchpoint
|| !b
->inserted
)
360 else if (b
->address
+ memory_breakpoint_size
<= memaddr
)
361 /* The breakpoint is entirely before the chunk of memory
364 else if (b
->address
>= memaddr
+ len
)
365 /* The breakpoint is entirely after the chunk of memory we
370 /* Copy the breakpoint from the shadow contents, and recurse
371 for the things before and after. */
373 /* Addresses and length of the part of the breakpoint that
375 CORE_ADDR membpt
= b
->address
;
376 unsigned int bptlen
= memory_breakpoint_size
;
377 /* Offset within shadow_contents. */
380 if (membpt
< memaddr
)
382 /* Only copy the second part of the breakpoint. */
383 bptlen
-= memaddr
- membpt
;
384 bptoffset
= memaddr
- membpt
;
388 if (membpt
+ bptlen
> memaddr
+ len
)
390 /* Only copy the first part of the breakpoint. */
391 bptlen
-= (membpt
+ bptlen
) - (memaddr
+ len
);
394 (void) memcpy (myaddr
+ membpt
- memaddr
,
395 b
->shadow_contents
+ bptoffset
, bptlen
);
397 if (membpt
> memaddr
)
399 /* Copy the section of memory before the breakpoint. */
400 status
= read_memory_nobpt (memaddr
, myaddr
, membpt
- memaddr
);
405 if (membpt
+ bptlen
< memaddr
+ len
)
407 /* Copy the section of memory after the breakpoint. */
408 status
= read_memory_nobpt
410 myaddr
+ membpt
+ bptlen
- memaddr
,
411 memaddr
+ len
- (membpt
+ bptlen
));
418 /* Nothing overlaps. Just call read_memory_noerr. */
419 return target_read_memory (memaddr
, myaddr
, len
);
422 /* insert_breakpoints is used when starting or continuing the program.
423 remove_breakpoints is used when the program stops.
424 Both return zero if successful,
425 or an `errno' value if could not write the inferior. */
428 insert_breakpoints ()
430 register struct breakpoint
*b
;
432 int disabled_breaks
= 0;
435 if (b
->type
!= bp_watchpoint
436 && b
->enable
!= disabled
440 val
= target_insert_breakpoint(b
->address
, b
->shadow_contents
);
443 /* Can't set the breakpoint. */
444 #if defined (DISABLE_UNSETTABLE_BREAK)
445 if (DISABLE_UNSETTABLE_BREAK (b
->address
))
448 b
->enable
= disabled
;
449 if (!disabled_breaks
)
452 "Cannot insert breakpoint %d:\n", b
->number
);
453 printf_filtered ("Disabling shared library breakpoints:\n");
456 printf_filtered ("%d ", b
->number
);
461 fprintf (stderr
, "Cannot insert breakpoint %d:\n", b
->number
);
462 #ifdef ONE_PROCESS_WRITETEXT
464 "The same program may be running in another process.\n");
466 memory_error (val
, b
->address
); /* which bombs us out */
473 printf_filtered ("\n");
478 remove_breakpoints ()
480 register struct breakpoint
*b
;
483 #ifdef BREAKPOINT_DEBUG
484 printf ("Removing breakpoints.\n");
485 #endif /* BREAKPOINT_DEBUG */
488 if (b
->type
!= bp_watchpoint
&& b
->inserted
)
490 val
= target_remove_breakpoint(b
->address
, b
->shadow_contents
);
494 #ifdef BREAKPOINT_DEBUG
495 printf ("Removed breakpoint at %s",
496 local_hex_string(b
->address
));
497 printf (", shadow %s",
498 local_hex_string(b
->shadow_contents
[0]));
500 local_hex_string(b
->shadow_contents
[1]));
501 #endif /* BREAKPOINT_DEBUG */
507 /* Clear the "inserted" flag in all breakpoints.
508 This is done when the inferior is loaded. */
511 mark_breakpoints_out ()
513 register struct breakpoint
*b
;
519 /* breakpoint_here_p (PC) returns 1 if an enabled breakpoint exists at PC.
520 When continuing from a location with a breakpoint,
521 we actually single step once before calling insert_breakpoints. */
524 breakpoint_here_p (pc
)
527 register struct breakpoint
*b
;
530 if (b
->enable
!= disabled
&& b
->address
== pc
)
536 /* bpstat stuff. External routines' interfaces are documented
539 /* Clear a bpstat so that it says we are not at any breakpoint.
540 Also free any storage that is part of a bpstat. */
555 if (p
->old_val
!= NULL
)
556 value_free (p
->old_val
);
563 /* Return a copy of a bpstat. Like "bs1 = bs2" but all storage that
564 is part of the bpstat is copied as well. */
577 for (; bs
!= NULL
; bs
= bs
->next
)
579 tmp
= (bpstat
) xmalloc (sizeof (*tmp
));
580 (void) memcpy (tmp
, bs
, sizeof (*tmp
));
582 /* This is the first thing in the chain. */
592 /* Find the bpstat associated with this breakpoint */
595 bpstat_find_breakpoint(bsp
, breakpoint
)
597 struct breakpoint
*breakpoint
;
599 if (bsp
== NULL
) return NULL
;
601 for (;bsp
!= NULL
; bsp
= bsp
->next
) {
602 if (bsp
->breakpoint_at
== breakpoint
) return bsp
;
607 /* Return the breakpoint number of the first breakpoint we are stopped
608 at. *BSP upon return is a bpstat which points to the remaining
609 breakpoints stopped at (but which is not guaranteed to be good for
610 anything but further calls to bpstat_num).
611 Return 0 if passed a bpstat which does not indicate any breakpoints. */
617 struct breakpoint
*b
;
620 return 0; /* No more breakpoint values */
623 b
= (*bsp
)->breakpoint_at
;
626 return -1; /* breakpoint that's been deleted since */
628 return b
->number
; /* We have its number */
632 /* Modify BS so that the actions will not be performed. */
635 bpstat_clear_actions (bs
)
638 for (; bs
!= NULL
; bs
= bs
->next
)
641 if (bs
->old_val
!= NULL
)
643 value_free (bs
->old_val
);
649 /* Stub for cleaning up our state if we error-out of a breakpoint command */
652 cleanup_executing_breakpoints (ignore
)
655 executing_breakpoint_commands
= 0;
658 /* Execute all the commands associated with all the breakpoints at this
659 location. Any of these commands could cause the process to proceed
660 beyond this point, etc. We look out for such changes by checking
661 the global "breakpoint_proceeded" after each command. */
664 bpstat_do_actions (bsp
)
668 struct cleanup
*old_chain
;
670 executing_breakpoint_commands
= 1;
671 old_chain
= make_cleanup (cleanup_executing_breakpoints
, 0);
676 breakpoint_proceeded
= 0;
677 for (; bs
!= NULL
; bs
= bs
->next
)
681 char *line
= bs
->commands
->line
;
682 bs
->commands
= bs
->commands
->next
;
683 execute_command (line
, 0);
684 /* If the inferior is proceeded by the command, bomb out now.
685 The bpstat chain has been blown away by wait_for_inferior.
686 But since execution has stopped again, there is a new bpstat
687 to look at, so start over. */
688 if (breakpoint_proceeded
)
693 executing_breakpoint_commands
= 0;
694 discard_cleanups (old_chain
);
697 /* Print a message indicating what happened. Returns nonzero to
698 say that only the source line should be printed after this (zero
699 return means print the frame as well as the source line). */
705 /* bs->breakpoint_at can be NULL if it was a momentary breakpoint
706 which has since been deleted. */
708 || bs
->breakpoint_at
== NULL
709 || (bs
->breakpoint_at
->type
!= bp_breakpoint
710 && bs
->breakpoint_at
->type
!= bp_watchpoint
))
713 /* If bpstat_stop_status says don't print, OK, we won't. An example
714 circumstance is when we single-stepped for both a watchpoint and
715 for a "stepi" instruction. The bpstat says that the watchpoint
716 explains the stop, but we shouldn't print because the watchpoint's
717 value didn't change -- and the real reason we are stopping here
718 rather than continuing to step (as the watchpoint would've had us do)
719 is because of the "stepi". */
723 if (bs
->breakpoint_at
->type
== bp_breakpoint
)
725 /* I think the user probably only wants to see one breakpoint
726 number, not all of them. */
727 printf_filtered ("\nBreakpoint %d, ", bs
->breakpoint_at
->number
);
731 if (bs
->old_val
!= NULL
)
733 printf_filtered ("\nWatchpoint %d, ", bs
->breakpoint_at
->number
);
734 print_expression (bs
->breakpoint_at
->exp
, stdout
);
735 printf_filtered ("\nOld value = ");
736 value_print (bs
->old_val
, stdout
, 0, Val_pretty_default
);
737 printf_filtered ("\nNew value = ");
738 value_print (bs
->breakpoint_at
->val
, stdout
, 0,
740 printf_filtered ("\n");
741 value_free (bs
->old_val
);
746 /* Maybe another breakpoint in the chain caused us to stop.
747 (Currently all watchpoints go on the bpstat whether hit or
748 not. That probably could (should) be changed, provided care is taken
749 with respect to bpstat_explains_signal). */
751 return bpstat_print (bs
->next
);
753 fprintf_filtered (stderr
, "gdb internal error: in bpstat_print\n");
757 /* Evaluate the expression EXP and return 1 if value is zero.
758 This is used inside a catch_errors to evaluate the breakpoint condition.
759 The argument is a "struct expression *" that has been cast to char * to
760 make it pass through catch_errors. */
763 breakpoint_cond_eval (exp
)
766 return !value_true (evaluate_expression ((struct expression
*)exp
));
769 /* Allocate a new bpstat and chain it to the current one. */
772 bpstat_alloc (b
, cbs
)
773 register struct breakpoint
*b
;
774 bpstat cbs
; /* Current "bs" value */
778 bs
= (bpstat
) xmalloc (sizeof (*bs
));
780 bs
->breakpoint_at
= b
;
781 /* If the condition is false, etc., don't do the commands. */
783 bs
->momentary
= b
->disposition
== delete;
788 /* Determine whether we stopped at a breakpoint, etc, or whether we
789 don't understand this stop. Result is a chain of bpstat's such that:
791 if we don't understand the stop, the result is a null pointer.
793 if we understand why we stopped, the result is not null, and
794 the first element of the chain contains summary "stop" and
795 "print" flags for the whole chain.
797 Each element of the chain refers to a particular breakpoint or
798 watchpoint at which we have stopped. (We may have stopped for
801 Each element of the chain has valid next, breakpoint_at,
802 commands, FIXME??? fields.
808 bpstat_stop_status (pc
, frame_address
)
810 FRAME_ADDR frame_address
;
812 register struct breakpoint
*b
;
816 #if DECR_PC_AFTER_BREAK != 0 || defined (SHIFT_INST_REGS)
817 /* True if we've hit a breakpoint (as opposed to a watchpoint). */
818 int real_breakpoint
= 0;
820 /* Root of the chain of bpstat's */
821 struct bpstat root_bs
[1];
822 /* Pointer to the last thing in the chain currently. */
825 /* Get the address where the breakpoint would have been. */
826 bp_addr
= *pc
- DECR_PC_AFTER_BREAK
;
833 if (b
->enable
== disabled
)
836 if (b
->type
!= bp_watchpoint
&& b
->address
!= bp_addr
)
839 /* Come here if it's a watchpoint, or if the break address matches */
841 bs
= bpstat_alloc (b
, bs
); /* Alloc a bpstat to explain stop */
846 if (b
->type
== bp_watchpoint
)
848 int within_current_scope
;
849 if (b
->exp_valid_block
!= NULL
)
850 within_current_scope
=
851 contained_in (get_selected_block (), b
->exp_valid_block
);
853 within_current_scope
= 1;
855 if (within_current_scope
)
857 /* We use value_{,free_to_}mark because it could be a
858 *long* time before we return to the command level and
859 call free_all_values. */
861 value mark
= value_mark ();
862 value new_val
= evaluate_expression (b
->exp
);
863 if (!value_equal (b
->val
, new_val
))
865 release_value (new_val
);
866 value_free_to_mark (mark
);
867 bs
->old_val
= b
->val
;
869 /* We will stop here */
873 /* Nothing changed, don't do anything. */
874 value_free_to_mark (mark
);
876 /* We won't stop here */
881 /* This seems like the only logical thing to do because
882 if we temporarily ignored the watchpoint, then when
883 we reenter the block in which it is valid it contains
884 garbage (in the case of a function, it may have two
885 garbage values, one before and one after the prologue).
886 So we can't even detect the first assignment to it and
887 watch after that (since the garbage may or may not equal
888 the first value assigned). */
889 b
->enable
= disabled
;
891 Watchpoint %d disabled because the program has left the block in\n\
892 which its expression is valid.\n", b
->number
);
893 /* We won't stop here */
894 /* FIXME, maybe we should stop here!!! */
898 #if DECR_PC_AFTER_BREAK != 0 || defined (SHIFT_INST_REGS)
903 if (b
->frame
&& b
->frame
!= frame_address
)
911 /* Need to select the frame, with all that implies
912 so that the conditions will have the right context. */
913 select_frame (get_current_frame (), 0);
915 = catch_errors (breakpoint_cond_eval
, (char *)(b
->cond
),
916 "Error in testing breakpoint condition:\n");
917 /* FIXME-someday, should give breakpoint # */
920 if (b
->cond
&& value_is_zero
)
924 else if (b
->ignore_count
> 0)
931 /* We will stop here */
932 if (b
->disposition
== disable
)
933 b
->enable
= disabled
;
934 bs
->commands
= b
->commands
;
937 if (bs
->commands
&& !strcmp ("silent", bs
->commands
->line
))
939 bs
->commands
= bs
->commands
->next
;
950 bs
->next
= NULL
; /* Terminate the chain */
951 bs
= root_bs
->next
; /* Re-grab the head of the chain */
956 #if DECR_PC_AFTER_BREAK != 0 || defined (SHIFT_INST_REGS)
960 #if defined (SHIFT_INST_REGS)
962 CORE_ADDR pc
= read_register (PC_REGNUM
);
963 CORE_ADDR npc
= read_register (NPC_REGNUM
);
966 write_register (NNPC_REGNUM
, npc
);
967 write_register (NPC_REGNUM
, pc
);
970 #else /* No SHIFT_INST_REGS. */
972 #endif /* No SHIFT_INST_REGS. */
974 #endif /* DECR_PC_AFTER_BREAK != 0. */
979 /* Nonzero if we should step constantly (e.g. watchpoints on machines
980 without hardware support). This isn't related to a specific bpstat,
981 just to things like whether watchpoints are set. */
984 bpstat_should_step ()
986 struct breakpoint
*b
;
988 if (b
->enable
== enabled
&& b
->type
== bp_watchpoint
)
993 /* Print information on breakpoint number BNUM, or -1 if all.
994 If WATCHPOINTS is zero, process only breakpoints; if WATCHPOINTS
995 is nonzero, process only watchpoints. */
998 breakpoint_1 (bnum
, allflag
)
1002 register struct breakpoint
*b
;
1003 register struct command_line
*l
;
1004 register struct symbol
*sym
;
1005 CORE_ADDR last_addr
= (CORE_ADDR
)-1;
1006 int found_a_breakpoint
= 0;
1007 static char *bptypes
[] = {"breakpoint", "until", "finish", "watchpoint",
1008 "longjmp", "longjmp resume"};
1009 static char *bpdisps
[] = {"del", "dis", "keep"};
1010 static char bpenables
[] = "ny";
1012 if (!breakpoint_chain
)
1014 printf_filtered ("No breakpoints or watchpoints.\n");
1020 || bnum
== b
->number
)
1022 /* We only print out user settable breakpoints unless the allflag is set. */
1024 && b
->type
!= bp_breakpoint
1025 && b
->type
!= bp_watchpoint
)
1028 if (!found_a_breakpoint
++)
1029 printf_filtered ("Num Type Disp Enb %sWhat\n",
1030 addressprint
? "Address " : "");
1032 printf_filtered ("%-3d %-14s %-4s %-3c ",
1034 bptypes
[(int)b
->type
],
1035 bpdisps
[(int)b
->disposition
],
1036 bpenables
[(int)b
->enable
]);
1040 print_expression (b
->exp
, stdout
);
1046 case bp_longjmp_resume
:
1048 printf_filtered ("%s ", local_hex_string_custom(b
->address
, "08"));
1050 last_addr
= b
->address
;
1053 sym
= find_pc_function (b
->address
);
1056 fputs_filtered ("in ", stdout
);
1057 fputs_demangled (SYMBOL_NAME (sym
), stdout
,
1058 DMGL_ANSI
| DMGL_PARAMS
);
1059 fputs_filtered (" at ", stdout
);
1061 fputs_filtered (b
->symtab
->filename
, stdout
);
1062 printf_filtered (":%d", b
->line_number
);
1065 print_address_symbolic (b
->address
, stdout
, demangle
, " ");
1068 printf_filtered ("\n");
1071 printf_filtered ("\tstop only in stack frame at %s\n",
1072 local_hex_string(b
->frame
));
1075 printf_filtered ("\tstop only if ");
1076 print_expression (b
->cond
, stdout
);
1077 printf_filtered ("\n");
1079 if (b
->ignore_count
)
1080 printf_filtered ("\tignore next %d hits\n", b
->ignore_count
);
1081 if ((l
= b
->commands
))
1084 fputs_filtered ("\t", stdout
);
1085 fputs_filtered (l
->line
, stdout
);
1086 fputs_filtered ("\n", stdout
);
1091 if (!found_a_breakpoint
1093 printf_filtered ("No breakpoint or watchpoint number %d.\n", bnum
);
1095 /* Compare against (CORE_ADDR)-1 in case some compiler decides
1096 that a comparison of an unsigned with -1 is always false. */
1097 if (last_addr
!= (CORE_ADDR
)-1)
1098 set_next_address (last_addr
);
1103 breakpoints_info (bnum_exp
, from_tty
)
1110 bnum
= parse_and_eval_address (bnum_exp
);
1112 breakpoint_1 (bnum
, 0);
1117 all_breakpoints_info (bnum_exp
, from_tty
)
1124 bnum
= parse_and_eval_address (bnum_exp
);
1126 breakpoint_1 (bnum
, 1);
1129 /* Print a message describing any breakpoints set at PC. */
1132 describe_other_breakpoints (pc
)
1133 register CORE_ADDR pc
;
1135 register int others
= 0;
1136 register struct breakpoint
*b
;
1139 if (b
->address
== pc
)
1143 printf ("Note: breakpoint%s ", (others
> 1) ? "s" : "");
1145 if (b
->address
== pc
)
1150 (b
->enable
== disabled
) ? " (disabled)" : "",
1151 (others
> 1) ? "," : ((others
== 1) ? " and" : ""));
1153 printf ("also set at pc %s.\n", local_hex_string(pc
));
1157 /* Set the default place to put a breakpoint
1158 for the `break' command with no arguments. */
1161 set_default_breakpoint (valid
, addr
, symtab
, line
)
1164 struct symtab
*symtab
;
1167 default_breakpoint_valid
= valid
;
1168 default_breakpoint_address
= addr
;
1169 default_breakpoint_symtab
= symtab
;
1170 default_breakpoint_line
= line
;
1173 /* Rescan breakpoints at address ADDRESS,
1174 marking the first one as "first" and any others as "duplicates".
1175 This is so that the bpt instruction is only inserted once. */
1178 check_duplicates (address
)
1181 register struct breakpoint
*b
;
1182 register int count
= 0;
1184 if (address
== 0) /* Watchpoints are uninteresting */
1188 if (b
->enable
!= disabled
&& b
->address
== address
)
1191 b
->duplicate
= count
> 1;
1195 /* Low level routine to set a breakpoint.
1196 Takes as args the three things that every breakpoint must have.
1197 Returns the breakpoint object so caller can set other things.
1198 Does not set the breakpoint number!
1199 Does not print anything.
1201 ==> This routine should not be called if there is a chance of later
1202 error(); otherwise it leaves a bogus breakpoint on the chain. Validate
1203 your arguments BEFORE calling this routine! */
1205 static struct breakpoint
*
1206 set_raw_breakpoint (sal
)
1207 struct symtab_and_line sal
;
1209 register struct breakpoint
*b
, *b1
;
1211 b
= (struct breakpoint
*) xmalloc (sizeof (struct breakpoint
));
1212 (void) memset (b
, 0, sizeof (*b
));
1213 b
->address
= sal
.pc
;
1214 b
->symtab
= sal
.symtab
;
1215 b
->line_number
= sal
.line
;
1216 b
->enable
= enabled
;
1219 b
->ignore_count
= 0;
1223 /* Add this breakpoint to the end of the chain
1224 so that a list of breakpoints will come out in order
1225 of increasing numbers. */
1227 b1
= breakpoint_chain
;
1229 breakpoint_chain
= b
;
1237 check_duplicates (sal
.pc
);
1243 create_longjmp_breakpoint(func_name
)
1246 struct symtab_and_line sal
;
1247 struct breakpoint
*b
;
1248 static int internal_breakpoint_number
= -1;
1250 if (func_name
!= NULL
)
1252 struct minimal_symbol
*m
;
1254 m
= lookup_minimal_symbol(func_name
, (struct objfile
*)NULL
);
1256 sal
.pc
= m
->address
;
1266 b
= set_raw_breakpoint(sal
);
1269 b
->type
= func_name
!= NULL
? bp_longjmp
: bp_longjmp_resume
;
1270 b
->disposition
= donttouch
;
1271 b
->enable
= disabled
;
1274 b
->addr_string
= strsave(func_name
);
1275 b
->number
= internal_breakpoint_number
--;
1278 /* Call this routine when stepping and nexting to enable a breakpoint if we do
1279 a longjmp(). When we hit that breakpoint, call
1280 set_longjmp_resume_breakpoint() to figure out where we are going. */
1283 enable_longjmp_breakpoint()
1285 register struct breakpoint
*b
;
1288 if (b
->type
== bp_longjmp
)
1289 b
->enable
= enabled
;
1293 disable_longjmp_breakpoint()
1295 register struct breakpoint
*b
;
1298 if (b
->type
== bp_longjmp
1299 || b
->type
== bp_longjmp_resume
)
1300 b
->enable
= disabled
;
1303 /* Call this after hitting the longjmp() breakpoint. Use this to set a new
1304 breakpoint at the target of the jmp_buf.
1306 FIXME - This ought to be done by setting a temporary breakpoint that gets
1307 deleted automatically...
1311 set_longjmp_resume_breakpoint(pc
, frame
)
1315 register struct breakpoint
*b
;
1318 if (b
->type
== bp_longjmp_resume
)
1321 b
->enable
= enabled
;
1323 b
->frame
= FRAME_FP(frame
);
1330 /* Set a breakpoint that will evaporate an end of command
1331 at address specified by SAL.
1332 Restrict it to frame FRAME if FRAME is nonzero. */
1335 set_momentary_breakpoint (sal
, frame
, type
)
1336 struct symtab_and_line sal
;
1340 register struct breakpoint
*b
;
1341 b
= set_raw_breakpoint (sal
);
1343 b
->enable
= enabled
;
1344 b
->disposition
= donttouch
;
1345 b
->frame
= (frame
? FRAME_FP (frame
) : 0);
1351 clear_momentary_breakpoints ()
1353 register struct breakpoint
*b
;
1355 if (b
->disposition
== delete)
1357 delete_breakpoint (b
);
1363 /* Tell the user we have just set a breakpoint B. */
1366 struct breakpoint
*b
;
1371 printf_filtered ("Watchpoint %d: ", b
->number
);
1372 print_expression (b
->exp
, stdout
);
1375 printf_filtered ("Breakpoint %d at %s", b
->number
,
1376 local_hex_string(b
->address
));
1378 printf_filtered (": file %s, line %d.",
1379 b
->symtab
->filename
, b
->line_number
);
1384 case bp_longjmp_resume
:
1387 printf_filtered ("\n");
1391 /* Nobody calls this currently. */
1392 /* Set a breakpoint from a symtab and line.
1393 If TEMPFLAG is nonzero, it is a temporary breakpoint.
1394 ADDR_STRING is a malloc'd string holding the name of where we are
1395 setting the breakpoint. This is used later to re-set it after the
1396 program is relinked and symbols are reloaded.
1397 Print the same confirmation messages that the breakpoint command prints. */
1400 set_breakpoint (s
, line
, tempflag
, addr_string
)
1406 register struct breakpoint
*b
;
1407 struct symtab_and_line sal
;
1412 resolve_sal_pc (&sal
); /* Might error out */
1413 describe_other_breakpoints (sal
.pc
);
1415 b
= set_raw_breakpoint (sal
);
1416 set_breakpoint_count (breakpoint_count
+ 1);
1417 b
->number
= breakpoint_count
;
1418 b
->type
= bp_breakpoint
;
1420 b
->addr_string
= addr_string
;
1421 b
->enable
= enabled
;
1422 b
->disposition
= tempflag
? delete : donttouch
;
1428 /* Set a breakpoint according to ARG (function, linenum or *address)
1429 and make it temporary if TEMPFLAG is nonzero. */
1432 break_command_1 (arg
, tempflag
, from_tty
)
1434 int tempflag
, from_tty
;
1436 struct symtabs_and_lines sals
;
1437 struct symtab_and_line sal
;
1438 register struct expression
*cond
= 0;
1439 register struct breakpoint
*b
;
1441 /* Pointers in arg to the start, and one past the end, of the condition. */
1442 char *cond_start
= NULL
;
1444 /* Pointers in arg to the start, and one past the end,
1445 of the address part. */
1446 char *addr_start
= NULL
;
1454 sal
.line
= sal
.pc
= sal
.end
= 0;
1457 /* If no arg given, or if first arg is 'if ', use the default breakpoint. */
1459 if (!arg
|| (arg
[0] == 'i' && arg
[1] == 'f'
1460 && (arg
[2] == ' ' || arg
[2] == '\t')))
1462 if (default_breakpoint_valid
)
1464 sals
.sals
= (struct symtab_and_line
*)
1465 xmalloc (sizeof (struct symtab_and_line
));
1466 sal
.pc
= default_breakpoint_address
;
1467 sal
.line
= default_breakpoint_line
;
1468 sal
.symtab
= default_breakpoint_symtab
;
1473 error ("No default breakpoint address now.");
1479 /* Force almost all breakpoints to be in terms of the
1480 current_source_symtab (which is decode_line_1's default). This
1481 should produce the results we want almost all of the time while
1482 leaving default_breakpoint_* alone. */
1483 if (default_breakpoint_valid
1484 && (!current_source_symtab
1485 || (arg
&& (*arg
== '+' || *arg
== '-'))))
1486 sals
= decode_line_1 (&arg
, 1, default_breakpoint_symtab
,
1487 default_breakpoint_line
);
1489 sals
= decode_line_1 (&arg
, 1, (struct symtab
*)NULL
, 0);
1497 /* Resolve all line numbers to PC's, and verify that conditions
1498 can be parsed, before setting any breakpoints. */
1499 for (i
= 0; i
< sals
.nelts
; i
++)
1501 resolve_sal_pc (&sals
.sals
[i
]);
1505 if (arg
[0] == 'i' && arg
[1] == 'f'
1506 && (arg
[2] == ' ' || arg
[2] == '\t'))
1510 cond
= parse_exp_1 (&arg
, block_for_pc (sals
.sals
[i
].pc
), 0);
1514 error ("Junk at end of arguments.");
1518 /* Now set all the breakpoints. */
1519 for (i
= 0; i
< sals
.nelts
; i
++)
1524 describe_other_breakpoints (sal
.pc
);
1526 b
= set_raw_breakpoint (sal
);
1527 set_breakpoint_count (breakpoint_count
+ 1);
1528 b
->number
= breakpoint_count
;
1529 b
->type
= bp_breakpoint
;
1533 b
->addr_string
= savestring (addr_start
, addr_end
- addr_start
);
1535 b
->cond_string
= savestring (cond_start
, cond_end
- cond_start
);
1537 b
->enable
= enabled
;
1538 b
->disposition
= tempflag
? delete : donttouch
;
1545 printf ("Multiple breakpoints were set.\n");
1546 printf ("Use the \"delete\" command to delete unwanted breakpoints.\n");
1548 free ((PTR
)sals
.sals
);
1551 /* Helper function for break_command_1 and disassemble_command. */
1554 resolve_sal_pc (sal
)
1555 struct symtab_and_line
*sal
;
1559 if (sal
->pc
== 0 && sal
->symtab
!= 0)
1561 pc
= find_line_pc (sal
->symtab
, sal
->line
);
1563 error ("No line %d in file \"%s\".",
1564 sal
->line
, sal
->symtab
->filename
);
1570 break_command (arg
, from_tty
)
1574 break_command_1 (arg
, 0, from_tty
);
1578 tbreak_command (arg
, from_tty
)
1582 break_command_1 (arg
, 1, from_tty
);
1587 watch_command (arg
, from_tty
)
1591 struct breakpoint
*b
;
1592 struct symtab_and_line sal
;
1593 struct expression
*exp
;
1594 struct block
*exp_valid_block
;
1601 /* Parse arguments. */
1602 innermost_block
= NULL
;
1603 exp
= parse_expression (arg
);
1604 exp_valid_block
= innermost_block
;
1605 val
= evaluate_expression (exp
);
1606 release_value (val
);
1608 /* Now set up the breakpoint. */
1609 b
= set_raw_breakpoint (sal
);
1610 set_breakpoint_count (breakpoint_count
+ 1);
1611 b
->number
= breakpoint_count
;
1612 b
->type
= bp_watchpoint
;
1613 b
->disposition
= donttouch
;
1615 b
->exp_valid_block
= exp_valid_block
;
1618 b
->cond_string
= NULL
;
1623 * Helper routine for the until_command routine in infcmd.c. Here
1624 * because it uses the mechanisms of breakpoints.
1628 until_break_command (arg
, from_tty
)
1632 struct symtabs_and_lines sals
;
1633 struct symtab_and_line sal
;
1634 FRAME prev_frame
= get_prev_frame (selected_frame
);
1635 struct breakpoint
*breakpoint
;
1636 struct cleanup
*old_chain
;
1638 clear_proceed_status ();
1640 /* Set a breakpoint where the user wants it and at return from
1643 if (default_breakpoint_valid
)
1644 sals
= decode_line_1 (&arg
, 1, default_breakpoint_symtab
,
1645 default_breakpoint_line
);
1647 sals
= decode_line_1 (&arg
, 1, (struct symtab
*)NULL
, 0);
1649 if (sals
.nelts
!= 1)
1650 error ("Couldn't get information on specified line.");
1653 free ((PTR
)sals
.sals
); /* malloc'd, so freed */
1656 error ("Junk at end of arguments.");
1658 resolve_sal_pc (&sal
);
1660 breakpoint
= set_momentary_breakpoint (sal
, selected_frame
, bp_until
);
1662 old_chain
= make_cleanup(delete_breakpoint
, breakpoint
);
1664 /* Keep within the current frame */
1668 struct frame_info
*fi
;
1670 fi
= get_frame_info (prev_frame
);
1671 sal
= find_pc_line (fi
->pc
, 0);
1673 breakpoint
= set_momentary_breakpoint (sal
, prev_frame
, bp_until
);
1674 make_cleanup(delete_breakpoint
, breakpoint
);
1677 proceed (-1, -1, 0);
1678 do_cleanups(old_chain
);
1682 /* These aren't used; I don't konw what they were for. */
1683 /* Set a breakpoint at the catch clause for NAME. */
1685 catch_breakpoint (name
)
1691 disable_catch_breakpoint ()
1696 delete_catch_breakpoint ()
1701 enable_catch_breakpoint ()
1708 struct sal_chain
*next
;
1709 struct symtab_and_line sal
;
1713 /* This isn't used; I don't know what it was for. */
1714 /* For each catch clause identified in ARGS, run FUNCTION
1715 with that clause as an argument. */
1716 static struct symtabs_and_lines
1717 map_catch_names (args
, function
)
1721 register char *p
= args
;
1723 struct symtabs_and_lines sals
;
1725 struct sal_chain
*sal_chain
= 0;
1729 error_no_arg ("one or more catch names");
1737 /* Don't swallow conditional part. */
1738 if (p1
[0] == 'i' && p1
[1] == 'f'
1739 && (p1
[2] == ' ' || p1
[2] == '\t'))
1745 while (isalnum (*p1
) || *p1
== '_' || *p1
== '$')
1749 if (*p1
&& *p1
!= ' ' && *p1
!= '\t')
1750 error ("Arguments must be catch names.");
1756 struct sal_chain
*next
1757 = (struct sal_chain
*)alloca (sizeof (struct sal_chain
));
1758 next
->next
= sal_chain
;
1759 next
->sal
= get_catch_sal (p
);
1764 printf ("No catch clause for exception %s.\n", p
);
1769 while (*p
== ' ' || *p
== '\t') p
++;
1774 /* This shares a lot of code with `print_frame_label_vars' from stack.c. */
1776 static struct symtabs_and_lines
1777 get_catch_sals (this_level_only
)
1778 int this_level_only
;
1780 register struct blockvector
*bl
;
1781 register struct block
*block
;
1782 int index
, have_default
= 0;
1783 struct frame_info
*fi
;
1785 struct symtabs_and_lines sals
;
1786 struct sal_chain
*sal_chain
= 0;
1787 char *blocks_searched
;
1789 /* Not sure whether an error message is always the correct response,
1790 but it's better than a core dump. */
1791 if (selected_frame
== NULL
)
1792 error ("No selected frame.");
1793 block
= get_frame_block (selected_frame
);
1794 fi
= get_frame_info (selected_frame
);
1801 error ("No symbol table info available.\n");
1803 bl
= blockvector_for_pc (BLOCK_END (block
) - 4, &index
);
1804 blocks_searched
= (char *) alloca (BLOCKVECTOR_NBLOCKS (bl
) * sizeof (char));
1805 (void) memset (blocks_searched
, 0, BLOCKVECTOR_NBLOCKS (bl
) * sizeof (char));
1809 CORE_ADDR end
= BLOCK_END (block
) - 4;
1812 if (bl
!= blockvector_for_pc (end
, &index
))
1813 error ("blockvector blotch");
1814 if (BLOCKVECTOR_BLOCK (bl
, index
) != block
)
1815 error ("blockvector botch");
1816 last_index
= BLOCKVECTOR_NBLOCKS (bl
);
1819 /* Don't print out blocks that have gone by. */
1820 while (index
< last_index
1821 && BLOCK_END (BLOCKVECTOR_BLOCK (bl
, index
)) < pc
)
1824 while (index
< last_index
1825 && BLOCK_END (BLOCKVECTOR_BLOCK (bl
, index
)) < end
)
1827 if (blocks_searched
[index
] == 0)
1829 struct block
*b
= BLOCKVECTOR_BLOCK (bl
, index
);
1832 register struct symbol
*sym
;
1834 nsyms
= BLOCK_NSYMS (b
);
1836 for (i
= 0; i
< nsyms
; i
++)
1838 sym
= BLOCK_SYM (b
, i
);
1839 if (! strcmp (SYMBOL_NAME (sym
), "default"))
1845 if (SYMBOL_CLASS (sym
) == LOC_LABEL
)
1847 struct sal_chain
*next
= (struct sal_chain
*)
1848 alloca (sizeof (struct sal_chain
));
1849 next
->next
= sal_chain
;
1850 next
->sal
= find_pc_line (SYMBOL_VALUE_ADDRESS (sym
), 0);
1854 blocks_searched
[index
] = 1;
1860 if (sal_chain
&& this_level_only
)
1863 /* After handling the function's top-level block, stop.
1864 Don't continue to its superblock, the block of
1865 per-file symbols. */
1866 if (BLOCK_FUNCTION (block
))
1868 block
= BLOCK_SUPERBLOCK (block
);
1873 struct sal_chain
*tmp_chain
;
1875 /* Count the number of entries. */
1876 for (index
= 0, tmp_chain
= sal_chain
; tmp_chain
;
1877 tmp_chain
= tmp_chain
->next
)
1881 sals
.sals
= (struct symtab_and_line
*)
1882 xmalloc (index
* sizeof (struct symtab_and_line
));
1883 for (index
= 0; sal_chain
; sal_chain
= sal_chain
->next
, index
++)
1884 sals
.sals
[index
] = sal_chain
->sal
;
1890 /* Commands to deal with catching exceptions. */
1893 catch_command_1 (arg
, tempflag
, from_tty
)
1898 /* First, translate ARG into something we can deal with in terms
1901 struct symtabs_and_lines sals
;
1902 struct symtab_and_line sal
;
1903 register struct expression
*cond
= 0;
1904 register struct breakpoint
*b
;
1908 sal
.line
= sal
.pc
= sal
.end
= 0;
1911 /* If no arg given, or if first arg is 'if ', all active catch clauses
1912 are breakpointed. */
1914 if (!arg
|| (arg
[0] == 'i' && arg
[1] == 'f'
1915 && (arg
[2] == ' ' || arg
[2] == '\t')))
1917 /* Grab all active catch clauses. */
1918 sals
= get_catch_sals (0);
1922 /* Grab selected catch clauses. */
1923 error ("catch NAME not implemeneted");
1925 /* This isn't used; I don't know what it was for. */
1926 sals
= map_catch_names (arg
, catch_breakpoint
);
1934 for (i
= 0; i
< sals
.nelts
; i
++)
1936 resolve_sal_pc (&sals
.sals
[i
]);
1940 if (arg
[0] == 'i' && arg
[1] == 'f'
1941 && (arg
[2] == ' ' || arg
[2] == '\t'))
1942 cond
= parse_exp_1 ((arg
+= 2, &arg
),
1943 block_for_pc (sals
.sals
[i
].pc
), 0);
1945 error ("Junk at end of arguments.");
1950 for (i
= 0; i
< sals
.nelts
; i
++)
1955 describe_other_breakpoints (sal
.pc
);
1957 b
= set_raw_breakpoint (sal
);
1958 set_breakpoint_count (breakpoint_count
+ 1);
1959 b
->number
= breakpoint_count
;
1960 b
->type
= bp_breakpoint
;
1962 b
->enable
= enabled
;
1963 b
->disposition
= tempflag
? delete : donttouch
;
1965 printf ("Breakpoint %d at %s", b
->number
, local_hex_string(b
->address
));
1967 printf (": file %s, line %d.", b
->symtab
->filename
, b
->line_number
);
1973 printf ("Multiple breakpoints were set.\n");
1974 printf ("Use the \"delete\" command to delete unwanted breakpoints.\n");
1976 free ((PTR
)sals
.sals
);
1980 /* These aren't used; I don't know what they were for. */
1981 /* Disable breakpoints on all catch clauses described in ARGS. */
1983 disable_catch (args
)
1986 /* Map the disable command to catch clauses described in ARGS. */
1989 /* Enable breakpoints on all catch clauses described in ARGS. */
1994 /* Map the disable command to catch clauses described in ARGS. */
1997 /* Delete breakpoints on all catch clauses in the active scope. */
2002 /* Map the delete command to catch clauses described in ARGS. */
2007 catch_command (arg
, from_tty
)
2011 catch_command_1 (arg
, 0, from_tty
);
2015 clear_command (arg
, from_tty
)
2019 register struct breakpoint
*b
, *b1
;
2020 struct symtabs_and_lines sals
;
2021 struct symtab_and_line sal
;
2022 register struct breakpoint
*found
;
2027 sals
= decode_line_spec (arg
, 1);
2031 sals
.sals
= (struct symtab_and_line
*) xmalloc (sizeof (struct symtab_and_line
));
2032 sal
.line
= default_breakpoint_line
;
2033 sal
.symtab
= default_breakpoint_symtab
;
2035 if (sal
.symtab
== 0)
2036 error ("No source file specified.");
2042 for (i
= 0; i
< sals
.nelts
; i
++)
2044 /* If exact pc given, clear bpts at that pc.
2045 But if sal.pc is zero, clear all bpts on specified line. */
2047 found
= (struct breakpoint
*) 0;
2048 while (breakpoint_chain
2049 && (sal
.pc
? breakpoint_chain
->address
== sal
.pc
2050 : (breakpoint_chain
->symtab
== sal
.symtab
2051 && breakpoint_chain
->line_number
== sal
.line
)))
2053 b1
= breakpoint_chain
;
2054 breakpoint_chain
= b1
->next
;
2061 && b
->next
->type
!= bp_watchpoint
2062 && (sal
.pc
? b
->next
->address
== sal
.pc
2063 : (b
->next
->symtab
== sal
.symtab
2064 && b
->next
->line_number
== sal
.line
)))
2075 error ("No breakpoint at %s.", arg
);
2077 error ("No breakpoint at this line.");
2080 if (found
->next
) from_tty
= 1; /* Always report if deleted more than one */
2081 if (from_tty
) printf ("Deleted breakpoint%s ", found
->next
? "s" : "");
2084 if (from_tty
) printf ("%d ", found
->number
);
2086 delete_breakpoint (found
);
2089 if (from_tty
) putchar ('\n');
2091 free ((PTR
)sals
.sals
);
2094 /* Delete breakpoint in BS if they are `delete' breakpoints.
2095 This is called after any breakpoint is hit, or after errors. */
2098 breakpoint_auto_delete (bs
)
2101 for (; bs
; bs
= bs
->next
)
2102 if (bs
->breakpoint_at
&& bs
->breakpoint_at
->disposition
== delete)
2103 delete_breakpoint (bs
->breakpoint_at
);
2106 /* Delete a breakpoint and clean up all traces of it in the data structures. */
2109 delete_breakpoint (bpt
)
2110 struct breakpoint
*bpt
;
2112 register struct breakpoint
*b
;
2116 target_remove_breakpoint(bpt
->address
, bpt
->shadow_contents
);
2118 if (breakpoint_chain
== bpt
)
2119 breakpoint_chain
= bpt
->next
;
2124 b
->next
= bpt
->next
;
2128 check_duplicates (bpt
->address
);
2130 free_command_lines (&bpt
->commands
);
2132 free ((PTR
)bpt
->cond
);
2133 if (bpt
->cond_string
!= NULL
)
2134 free ((PTR
)bpt
->cond_string
);
2135 if (bpt
->addr_string
!= NULL
)
2136 free ((PTR
)bpt
->addr_string
);
2138 if (xgdb_verbose
&& bpt
->type
== bp_breakpoint
)
2139 printf ("breakpoint #%d deleted\n", bpt
->number
);
2141 /* Be sure no bpstat's are pointing at it after it's been freed. */
2142 /* FIXME, how can we find all bpstat's? We just check stop_bpstat for now. */
2143 for (bs
= stop_bpstat
; bs
; bs
= bs
->next
)
2144 if (bs
->breakpoint_at
== bpt
)
2145 bs
->breakpoint_at
= NULL
;
2150 delete_command (arg
, from_tty
)
2157 /* Ask user only if there are some breakpoints to delete. */
2159 || (breakpoint_chain
&& query ("Delete all breakpoints? ", 0, 0)))
2161 /* No arg; clear all breakpoints. */
2162 while (breakpoint_chain
)
2163 delete_breakpoint (breakpoint_chain
);
2167 map_breakpoint_numbers (arg
, delete_breakpoint
);
2170 /* Reset a breakpoint given it's struct breakpoint * BINT.
2171 The value we return ends up being the return value from catch_errors.
2172 Unused in this case. */
2175 breakpoint_re_set_one (bint
)
2178 struct breakpoint
*b
= (struct breakpoint
*)bint
; /* get past catch_errs */
2180 struct symtabs_and_lines sals
;
2182 enum enable save_enable
;
2187 if (b
->addr_string
== NULL
)
2189 /* Anything without a string can't be re-set. */
2190 delete_breakpoint (b
);
2193 /* In case we have a problem, disable this breakpoint. We'll restore
2194 its status if we succeed. */
2195 save_enable
= b
->enable
;
2196 b
->enable
= disabled
;
2199 sals
= decode_line_1 (&s
, 1, (struct symtab
*)NULL
, 0);
2200 for (i
= 0; i
< sals
.nelts
; i
++)
2202 resolve_sal_pc (&sals
.sals
[i
]);
2203 if (b
->symtab
!= sals
.sals
[i
].symtab
2204 || b
->line_number
!= sals
.sals
[i
].line
2205 || b
->address
!= sals
.sals
[i
].pc
)
2207 b
->symtab
= sals
.sals
[i
].symtab
;
2208 b
->line_number
= sals
.sals
[i
].line
;
2209 b
->address
= sals
.sals
[i
].pc
;
2211 if (b
->cond_string
!= NULL
)
2214 b
->cond
= parse_exp_1 (&s
, block_for_pc (sals
.sals
[i
].pc
), 0);
2217 check_duplicates (b
->address
);
2221 b
->enable
= save_enable
; /* Restore it, this worked. */
2223 free ((PTR
)sals
.sals
);
2226 /* FIXME! This is the wrong thing to do.... */
2227 delete_breakpoint (b
);
2230 printf_filtered ("Deleting unknown breakpoint type %d\n", b
->type
);
2234 case bp_longjmp_resume
:
2235 delete_breakpoint (b
);
2242 /* Re-set all breakpoints after symbols have been re-loaded. */
2244 breakpoint_re_set ()
2246 struct breakpoint
*b
, *temp
;
2247 static char message1
[] = "Error in re-setting breakpoint %d:\n";
2248 char message
[sizeof (message1
) + 30 /* slop */];
2250 ALL_BREAKPOINTS_SAFE (b
, temp
)
2252 sprintf (message
, message1
, b
->number
); /* Format possible error msg */
2253 (void) catch_errors (breakpoint_re_set_one
, (char *) b
, message
);
2256 create_longjmp_breakpoint("longjmp");
2257 create_longjmp_breakpoint("_longjmp");
2258 create_longjmp_breakpoint("siglongjmp");
2259 create_longjmp_breakpoint(NULL
);
2262 /* Took this out (temporaliy at least), since it produces an extra
2263 blank line at startup. This messes up the gdbtests. -PB */
2264 /* Blank line to finish off all those mention() messages we just printed. */
2265 printf_filtered ("\n");
2269 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
2270 If from_tty is nonzero, it prints a message to that effect,
2271 which ends with a period (no newline). */
2274 set_ignore_count (bptnum
, count
, from_tty
)
2275 int bptnum
, count
, from_tty
;
2277 register struct breakpoint
*b
;
2283 if (b
->number
== bptnum
)
2285 b
->ignore_count
= count
;
2288 else if (count
== 0)
2289 printf_filtered ("Will stop next time breakpoint %d is reached.",
2291 else if (count
== 1)
2292 printf_filtered ("Will ignore next crossing of breakpoint %d.",
2295 printf_filtered ("Will ignore next %d crossings of breakpoint %d.",
2300 error ("No breakpoint number %d.", bptnum
);
2303 /* Clear the ignore counts of all breakpoints. */
2305 breakpoint_clear_ignore_counts ()
2307 struct breakpoint
*b
;
2310 b
->ignore_count
= 0;
2313 /* Command to set ignore-count of breakpoint N to COUNT. */
2316 ignore_command (args
, from_tty
)
2324 error_no_arg ("a breakpoint number");
2326 num
= get_number (&p
);
2329 error ("Second argument (specified ignore-count) is missing.");
2331 set_ignore_count (num
,
2332 longest_to_int (value_as_long (parse_and_eval (p
))),
2334 printf_filtered ("\n");
2337 /* Call FUNCTION on each of the breakpoints
2338 whose numbers are given in ARGS. */
2341 map_breakpoint_numbers (args
, function
)
2343 void (*function
) PARAMS ((struct breakpoint
*));
2345 register char *p
= args
;
2348 register struct breakpoint
*b
;
2351 error_no_arg ("one or more breakpoint numbers");
2357 num
= get_number (&p1
);
2360 if (b
->number
== num
)
2365 printf ("No breakpoint number %d.\n", num
);
2372 enable_breakpoint (bpt
)
2373 struct breakpoint
*bpt
;
2375 bpt
->enable
= enabled
;
2377 if (xgdb_verbose
&& bpt
->type
== bp_breakpoint
)
2378 printf ("breakpoint #%d enabled\n", bpt
->number
);
2380 check_duplicates (bpt
->address
);
2381 if (bpt
->type
== bp_watchpoint
)
2383 if (bpt
->exp_valid_block
!= NULL
2384 && !contained_in (get_selected_block (), bpt
->exp_valid_block
))
2387 Cannot enable watchpoint %d because the block in which its expression\n\
2388 is valid is not currently in scope.\n", bpt
->number
);
2392 value_free (bpt
->val
);
2394 bpt
->val
= evaluate_expression (bpt
->exp
);
2395 release_value (bpt
->val
);
2401 enable_command (args
, from_tty
)
2405 struct breakpoint
*bpt
;
2407 ALL_BREAKPOINTS (bpt
)
2412 enable_breakpoint (bpt
);
2417 map_breakpoint_numbers (args
, enable_breakpoint
);
2421 disable_breakpoint (bpt
)
2422 struct breakpoint
*bpt
;
2424 bpt
->enable
= disabled
;
2426 if (xgdb_verbose
&& bpt
->type
== bp_breakpoint
)
2427 printf_filtered ("breakpoint #%d disabled\n", bpt
->number
);
2429 check_duplicates (bpt
->address
);
2434 disable_command (args
, from_tty
)
2438 register struct breakpoint
*bpt
;
2440 ALL_BREAKPOINTS (bpt
)
2445 disable_breakpoint (bpt
);
2450 map_breakpoint_numbers (args
, disable_breakpoint
);
2454 enable_once_breakpoint (bpt
)
2455 struct breakpoint
*bpt
;
2457 bpt
->enable
= enabled
;
2458 bpt
->disposition
= disable
;
2460 check_duplicates (bpt
->address
);
2465 enable_once_command (args
, from_tty
)
2469 map_breakpoint_numbers (args
, enable_once_breakpoint
);
2473 enable_delete_breakpoint (bpt
)
2474 struct breakpoint
*bpt
;
2476 bpt
->enable
= enabled
;
2477 bpt
->disposition
= delete;
2479 check_duplicates (bpt
->address
);
2484 enable_delete_command (args
, from_tty
)
2488 map_breakpoint_numbers (args
, enable_delete_breakpoint
);
2492 * Use default_breakpoint_'s, or nothing if they aren't valid.
2494 struct symtabs_and_lines
2495 decode_line_spec_1 (string
, funfirstline
)
2499 struct symtabs_and_lines sals
;
2501 error ("Empty line specification.");
2502 if (default_breakpoint_valid
)
2503 sals
= decode_line_1 (&string
, funfirstline
,
2504 default_breakpoint_symtab
, default_breakpoint_line
);
2506 sals
= decode_line_1 (&string
, funfirstline
, (struct symtab
*)NULL
, 0);
2508 error ("Junk at end of line specification: %s", string
);
2513 /* Chain containing all defined enable commands. */
2515 extern struct cmd_list_element
2516 *enablelist
, *disablelist
,
2517 *deletelist
, *enablebreaklist
;
2519 extern struct cmd_list_element
*cmdlist
;
2522 _initialize_breakpoint ()
2524 breakpoint_chain
= 0;
2525 /* Don't bother to call set_breakpoint_count. $bpnum isn't useful
2526 before a breakpoint is set. */
2527 breakpoint_count
= 0;
2529 add_com ("ignore", class_breakpoint
, ignore_command
,
2530 "Set ignore-count of breakpoint number N to COUNT.");
2532 add_com ("commands", class_breakpoint
, commands_command
,
2533 "Set commands to be executed when a breakpoint is hit.\n\
2534 Give breakpoint number as argument after \"commands\".\n\
2535 With no argument, the targeted breakpoint is the last one set.\n\
2536 The commands themselves follow starting on the next line.\n\
2537 Type a line containing \"end\" to indicate the end of them.\n\
2538 Give \"silent\" as the first line to make the breakpoint silent;\n\
2539 then no output is printed when it is hit, except what the commands print.");
2541 add_com ("condition", class_breakpoint
, condition_command
,
2542 "Specify breakpoint number N to break only if COND is true.\n\
2543 N is an integer; COND is an expression to be evaluated whenever\n\
2544 breakpoint N is reached. ");
2546 add_com ("tbreak", class_breakpoint
, tbreak_command
,
2547 "Set a temporary breakpoint. Args like \"break\" command.\n\
2548 Like \"break\" except the breakpoint is only enabled temporarily,\n\
2549 so it will be disabled when hit. Equivalent to \"break\" followed\n\
2550 by using \"enable once\" on the breakpoint number.");
2552 add_prefix_cmd ("enable", class_breakpoint
, enable_command
,
2553 "Enable some breakpoints.\n\
2554 Give breakpoint numbers (separated by spaces) as arguments.\n\
2555 With no subcommand, breakpoints are enabled until you command otherwise.\n\
2556 This is used to cancel the effect of the \"disable\" command.\n\
2557 With a subcommand you can enable temporarily.",
2558 &enablelist
, "enable ", 1, &cmdlist
);
2560 add_abbrev_prefix_cmd ("breakpoints", class_breakpoint
, enable_command
,
2561 "Enable some breakpoints.\n\
2562 Give breakpoint numbers (separated by spaces) as arguments.\n\
2563 This is used to cancel the effect of the \"disable\" command.\n\
2564 May be abbreviated to simply \"enable\".\n",
2565 &enablebreaklist
, "enable breakpoints ", 1, &enablelist
);
2567 add_cmd ("once", no_class
, enable_once_command
,
2568 "Enable breakpoints for one hit. Give breakpoint numbers.\n\
2569 If a breakpoint is hit while enabled in this fashion, it becomes disabled.\n\
2570 See the \"tbreak\" command which sets a breakpoint and enables it once.",
2573 add_cmd ("delete", no_class
, enable_delete_command
,
2574 "Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
2575 If a breakpoint is hit while enabled in this fashion, it is deleted.",
2578 add_cmd ("delete", no_class
, enable_delete_command
,
2579 "Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
2580 If a breakpoint is hit while enabled in this fashion, it is deleted.",
2583 add_cmd ("once", no_class
, enable_once_command
,
2584 "Enable breakpoints for one hit. Give breakpoint numbers.\n\
2585 If a breakpoint is hit while enabled in this fashion, it becomes disabled.\n\
2586 See the \"tbreak\" command which sets a breakpoint and enables it once.",
2589 add_prefix_cmd ("disable", class_breakpoint
, disable_command
,
2590 "Disable some breakpoints.\n\
2591 Arguments are breakpoint numbers with spaces in between.\n\
2592 To disable all breakpoints, give no argument.\n\
2593 A disabled breakpoint is not forgotten, but has no effect until reenabled.",
2594 &disablelist
, "disable ", 1, &cmdlist
);
2595 add_com_alias ("dis", "disable", class_breakpoint
, 1);
2596 add_com_alias ("disa", "disable", class_breakpoint
, 1);
2598 add_cmd ("breakpoints", class_alias
, disable_command
,
2599 "Disable some breakpoints.\n\
2600 Arguments are breakpoint numbers with spaces in between.\n\
2601 To disable all breakpoints, give no argument.\n\
2602 A disabled breakpoint is not forgotten, but has no effect until reenabled.\n\
2603 This command may be abbreviated \"disable\".",
2606 add_prefix_cmd ("delete", class_breakpoint
, delete_command
,
2607 "Delete some breakpoints or auto-display expressions.\n\
2608 Arguments are breakpoint numbers with spaces in between.\n\
2609 To delete all breakpoints, give no argument.\n\
2611 Also a prefix command for deletion of other GDB objects.\n\
2612 The \"unset\" command is also an alias for \"delete\".",
2613 &deletelist
, "delete ", 1, &cmdlist
);
2614 add_com_alias ("d", "delete", class_breakpoint
, 1);
2616 add_cmd ("breakpoints", class_alias
, delete_command
,
2617 "Delete some breakpoints or auto-display expressions.\n\
2618 Arguments are breakpoint numbers with spaces in between.\n\
2619 To delete all breakpoints, give no argument.\n\
2620 This command may be abbreviated \"delete\".",
2623 add_com ("clear", class_breakpoint
, clear_command
,
2624 "Clear breakpoint at specified line or function.\n\
2625 Argument may be line number, function name, or \"*\" and an address.\n\
2626 If line number is specified, all breakpoints in that line are cleared.\n\
2627 If function is specified, breakpoints at beginning of function are cleared.\n\
2628 If an address is specified, breakpoints at that address are cleared.\n\n\
2629 With no argument, clears all breakpoints in the line that the selected frame\n\
2632 See also the \"delete\" command which clears breakpoints by number.");
2634 add_com ("break", class_breakpoint
, break_command
,
2635 "Set 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, break at start of code for that line.\n\
2638 If function is specified, break at start of code for that function.\n\
2639 If an address is specified, break at that exact address.\n\
2640 With no arg, uses current execution address of selected stack frame.\n\
2641 This is useful for breaking on return to a stack frame.\n\
2643 Multiple breakpoints at one place are permitted, and useful if conditional.\n\
2645 Do \"help breakpoints\" for info on other commands dealing with breakpoints.");
2646 add_com_alias ("b", "break", class_run
, 1);
2647 add_com_alias ("br", "break", class_run
, 1);
2648 add_com_alias ("bre", "break", class_run
, 1);
2649 add_com_alias ("brea", "break", class_run
, 1);
2651 add_info ("breakpoints", breakpoints_info
,
2652 "Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
2653 The \"Type\" column indicates one of:\n\
2654 \tbreakpoint - normal breakpoint\n\
2655 \twatchpoint - watchpoint\n\
2656 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
2657 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
2658 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
2659 address and file/line number respectively.\n\n\
2660 Convenience variable \"$_\" and default examine address for \"x\"\n\
2661 are set to the address of the last breakpoint listed.\n\n\
2662 Convenience variable \"$bpnum\" contains the number of the last\n\
2665 add_info ("all-breakpoints", all_breakpoints_info
,
2666 "Status of all breakpoints, or breakpoint number NUMBER.\n\
2667 The \"Type\" column indicates one of:\n\
2668 \tbreakpoint - normal breakpoint\n\
2669 \twatchpoint - watchpoint\n\
2670 \tlongjmp - internal breakpoint used to step through longjmp()\n\
2671 \tlongjmp resume - internal breakpoint at the target of longjmp()\n\
2672 \tuntil - internal breakpoint used by the \"until\" command\n\
2673 \tfinish - internal breakpoint used by the \"finish\" command\n\
2674 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
2675 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
2676 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
2677 address and file/line number respectively.\n\n\
2678 Convenience variable \"$_\" and default examine address for \"x\"\n\
2679 are set to the address of the last breakpoint listed.\n\n\
2680 Convenience variable \"$bpnum\" contains the number of the last\n\
2683 add_com ("catch", class_breakpoint
, catch_command
,
2684 "Set breakpoints to catch exceptions that are raised.\n\
2685 Argument may be a single exception to catch, multiple exceptions\n\
2686 to catch, or the default exception \"default\". If no arguments\n\
2687 are given, breakpoints are set at all exception handlers catch clauses\n\
2688 within the current scope.\n\
2690 A condition specified for the catch applies to all breakpoints set\n\
2691 with this command\n\
2693 Do \"help breakpoints\" for info on other commands dealing with breakpoints.");
2695 add_com ("watch", class_breakpoint
, watch_command
,
2696 "Set a watchpoint for an expression.\n\
2697 A watchpoint stops execution of your program whenever the value of\n\
2698 an expression changes.");
2700 add_info ("watchpoints", breakpoints_info
,
2701 "Synonym for ``info breakpoints''.");
2705 /* Where should this function go? It is used by AIX only. FIXME. */
2707 /* Breakpoint address relocation used to be done in breakpoint_re_set(). That
2708 approach the following problem:
2710 before running the program, if a file is list, then a breakpoint is
2711 set (just the line number), then if we switch into another file and run
2712 the program, just a line number as a breakpoint address was not
2713 descriptive enough and breakpoint was ending up in a different file's
2716 I don't think any other platform has this breakpoint relocation problem, so this
2717 is not an issue for other platforms. */
2720 fixup_breakpoints (low
, high
, delta
)
2725 struct breakpoint
*b
;
2726 extern struct breakpoint
*breakpoint_chain
;
2730 if (b
->address
>= low
&& b
->address
<= high
)
2731 b
->address
+= delta
;