1 /* Everything about breakpoints, for GDB.
2 Copyright (C) 1986, 1987, 1989, 1990 Free Software Foundation, Inc.
4 This file is part of GDB.
6 GDB 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 1, or (at your option)
11 GDB 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 GDB; see the file COPYING. If not, write to
18 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
26 #include "breakpoint.h"
27 #include "expression.h"
37 extern int addressprint
; /* Print machine addresses? */
38 extern int demangle
; /* Print de-mangled symbol names? */
40 extern int catch_errors ();
41 extern void set_next_address (); /* ...for x/ command */
43 /* Are we executing breakpoint commands? */
44 static int executing_breakpoint_commands
;
46 /* States of enablement of breakpoint.
47 `temporary' means disable when hit.
48 `delete' means delete when hit. */
50 enum enable
{ disabled
, enabled
, temporary
, delete};
52 /* Not that the ->silent field is not currently used by any commands
53 (though the code is in there if it was to be, and set_raw_breakpoint
54 does set it to 0). I implemented it because I thought it would be
55 useful for a hack I had to put in; I'm going to leave it in because
56 I can see how there might be times when it would indeed be useful */
58 /* This is for a breakpoint or a watchpoint. */
62 struct breakpoint
*next
;
63 /* Number assigned to distinguish breakpoints. */
65 /* Address to break at, or NULL if not a breakpoint. */
67 /* Line number of this address. Redundant. Only matters if address
70 /* Symtab of file of this address. Redundant. Only matters if address
72 struct symtab
*symtab
;
73 /* Zero means disabled; remember the info but don't break here. */
75 /* Non-zero means a silent breakpoint (don't print frame info
78 /* Number of stops at this breakpoint that should
79 be continued automatically before really stopping. */
81 /* "Real" contents of byte where breakpoint has been inserted.
82 Valid only when breakpoints are in the program. Under the complete
83 control of the target insert_breakpoint and remove_breakpoint routines.
84 No other code should assume anything about the value(s) here. */
85 char shadow_contents
[BREAKPOINT_MAX
];
86 /* Nonzero if this breakpoint is now inserted. Only matters if address
89 /* Nonzero if this is not the first breakpoint in the list
90 for the given address. Only matters if address is non-NULL. */
92 /* Chain of command lines to execute when this breakpoint is hit. */
93 struct command_line
*commands
;
94 /* Stack depth (address of frame). If nonzero, break only if fp
97 /* Conditional. Break only if this expression's value is nonzero. */
98 struct expression
*cond
;
100 /* String we used to set the breakpoint (malloc'd). Only matters if
101 address is non-NULL. */
103 /* String form of the breakpoint condition (malloc'd), or NULL if there
107 /* The expression we are watching, or NULL if not a watchpoint. */
108 struct expression
*exp
;
109 /* The largest block within which it is valid, or NULL if it is
110 valid anywhere (e.g. consists just of global symbols). */
111 struct block
*exp_valid_block
;
112 /* Value of the watchpoint the last time we checked it. */
116 #define ALL_BREAKPOINTS(b) for (b = breakpoint_chain; b; b = b->next)
118 /* Chain of all breakpoints defined. */
120 struct breakpoint
*breakpoint_chain
;
122 /* Number of last breakpoint made. */
124 static int breakpoint_count
;
126 /* Set breakpoint count to NUM. */
128 set_breakpoint_count (num
)
131 breakpoint_count
= num
;
132 set_internalvar (lookup_internalvar ("bpnum"),
133 value_from_long (builtin_type_int
, (LONGEST
) num
));
136 /* Default address, symtab and line to put a breakpoint at
137 for "break" command with no arg.
138 if default_breakpoint_valid is zero, the other three are
139 not valid, and "break" with no arg is an error.
141 This set by print_stack_frame, which calls set_default_breakpoint. */
143 int default_breakpoint_valid
;
144 CORE_ADDR default_breakpoint_address
;
145 struct symtab
*default_breakpoint_symtab
;
146 int default_breakpoint_line
;
148 static void delete_breakpoint ();
149 void breakpoint_auto_delete ();
151 /* Flag indicating extra verbosity for xgdb. */
152 extern int xgdb_verbose
;
154 /* *PP is a string denoting a breakpoint. Get the number of the breakpoint.
155 Advance *PP after the string and any trailing whitespace.
157 Currently the string can either be a number or "$" followed by the name
158 of a convenience variable. Making it an expression wouldn't work well
159 for map_breakpoint_numbers (e.g. "4 + 5 + 6"). */
168 /* Empty line means refer to the last breakpoint. */
169 return breakpoint_count
;
172 /* Make a copy of the name, so we can null-terminate it
173 to pass to lookup_internalvar(). */
178 while (isalnum (*p
) || *p
== '_')
180 varname
= (char *) alloca (p
- start
+ 1);
181 strncpy (varname
, start
, p
- start
);
182 varname
[p
- start
] = '\0';
183 val
= value_of_internalvar (lookup_internalvar (varname
));
184 if (TYPE_CODE (VALUE_TYPE (val
)) != TYPE_CODE_INT
)
186 "Convenience variables used to specify breakpoints must have integer values."
188 retval
= (int) value_as_long (val
);
192 while (*p
>= '0' && *p
<= '9')
195 /* There is no number here. (e.g. "cond a == b"). */
196 error_no_arg ("breakpoint number");
199 if (!(isspace (*p
) || *p
== '\0'))
200 error ("breakpoint number expected");
207 /* condition N EXP -- set break condition of breakpoint N to EXP. */
210 condition_command (arg
, from_tty
)
214 register struct breakpoint
*b
;
219 error_no_arg ("breakpoint number");
222 bnum
= get_number (&p
);
225 if (b
->number
== bnum
)
232 if (b
->cond_string
!= NULL
)
233 free (b
->cond_string
);
238 b
->cond_string
= NULL
;
240 printf ("Breakpoint %d now unconditional.\n", bnum
);
245 /* I don't know if it matters whether this is the string the user
246 typed in or the decompiled expression. */
247 b
->cond_string
= savestring (arg
, strlen (arg
));
248 b
->cond
= parse_c_1 (&arg
, block_for_pc (b
->address
), 0);
250 error ("Junk at end of expression");
255 error ("No breakpoint number %d.", bnum
);
259 commands_command (arg
, from_tty
)
263 register struct breakpoint
*b
;
266 struct command_line
*l
;
268 /* If we allowed this, we would have problems with when to
269 free the storage, if we change the commands currently
272 if (executing_breakpoint_commands
)
273 error ("Can't use the \"commands\" command among a breakpoint's commands.");
276 bnum
= get_number (&p
);
278 error ("Unexpected extra arguments following breakpoint number.");
281 if (b
->number
== bnum
)
283 if (input_from_terminal_p ())
285 printf ("Type commands for when breakpoint %d is hit, one per line.\n\
286 End with a line saying just \"end\".\n", bnum
);
289 l
= read_command_lines ();
290 free_command_lines (&b
->commands
);
294 error ("No breakpoint number %d.", bnum
);
297 extern int memory_breakpoint_size
; /* from mem-break.c */
299 /* Like target_read_memory() but if breakpoints are inserted, return
300 the shadow contents instead of the breakpoints themselves. */
302 read_memory_nobpt (memaddr
, myaddr
, len
)
308 struct breakpoint
*b
;
310 if (memory_breakpoint_size
< 0)
311 /* No breakpoints on this machine. */
312 return target_read_memory (memaddr
, myaddr
, len
);
316 if (b
->address
== NULL
|| !b
->inserted
)
318 else if (b
->address
+ memory_breakpoint_size
<= memaddr
)
319 /* The breakpoint is entirely before the chunk of memory
322 else if (b
->address
>= memaddr
+ len
)
323 /* The breakpoint is entirely after the chunk of memory we
328 /* Copy the breakpoint from the shadow contents, and recurse
329 for the things before and after. */
331 /* Addresses and length of the part of the breakpoint that
333 CORE_ADDR membpt
= b
->address
;
334 unsigned int bptlen
= memory_breakpoint_size
;
335 /* Offset within shadow_contents. */
338 if (membpt
< memaddr
)
340 /* Only copy the second part of the breakpoint. */
341 bptlen
-= memaddr
- membpt
;
342 bptoffset
= memaddr
- membpt
;
346 if (membpt
+ bptlen
> memaddr
+ len
)
348 /* Only copy the first part of the breakpoint. */
349 bptlen
-= (membpt
+ bptlen
) - (memaddr
+ len
);
352 bcopy (b
->shadow_contents
+ bptoffset
,
353 myaddr
+ membpt
- memaddr
, bptlen
);
355 if (membpt
> memaddr
)
357 /* Copy the section of memory before the breakpoint. */
358 status
= read_memory_nobpt (memaddr
, myaddr
, membpt
- memaddr
);
363 if (membpt
+ bptlen
< memaddr
+ len
)
365 /* Copy the section of memory after the breakpoint. */
366 status
= read_memory_nobpt
368 myaddr
+ membpt
+ bptlen
- memaddr
,
369 memaddr
+ len
- (membpt
+ bptlen
));
376 /* Nothing overlaps. Just call read_memory_noerr. */
377 return target_read_memory (memaddr
, myaddr
, len
);
380 /* insert_breakpoints is used when starting or continuing the program.
381 remove_breakpoints is used when the program stops.
382 Both return zero if successful,
383 or an `errno' value if could not write the inferior. */
386 insert_breakpoints ()
388 register struct breakpoint
*b
;
390 int disabled_breaks
= 0;
393 if (b
->address
!= NULL
394 && b
->enable
!= disabled
398 val
= target_insert_breakpoint(b
->address
, b
->shadow_contents
);
401 /* Can't set the breakpoint. */
402 #if defined (DISABLE_UNSETTABLE_BREAK)
403 if (DISABLE_UNSETTABLE_BREAK (b
->address
))
406 b
->enable
= disabled
;
407 if (!disabled_breaks
)
410 "Cannot insert breakpoint %d:\n", b
->number
);
411 printf_filtered ("Disabling shared library breakpoints:\n");
414 printf_filtered ("%d ", b
->number
);
419 fprintf (stderr
, "Cannot insert breakpoint %d:\n", b
->number
);
420 memory_error (val
, b
->address
); /* which bombs us out */
427 printf_filtered ("\n");
432 remove_breakpoints ()
434 register struct breakpoint
*b
;
437 #ifdef BREAKPOINT_DEBUG
438 printf ("Removing breakpoints.\n");
439 #endif /* BREAKPOINT_DEBUG */
442 if (b
->address
!= NULL
&& b
->inserted
)
444 val
= target_remove_breakpoint(b
->address
, b
->shadow_contents
);
448 #ifdef BREAKPOINT_DEBUG
449 printf ("Removed breakpoint at 0x%x, shadow 0x%x, 0x%x.\n",
450 b
->address
, b
->shadow_contents
[0], b
->shadow_contents
[1]);
451 #endif /* BREAKPOINT_DEBUG */
457 /* Clear the "inserted" flag in all breakpoints.
458 This is done when the inferior is loaded. */
461 mark_breakpoints_out ()
463 register struct breakpoint
*b
;
469 /* breakpoint_here_p (PC) returns 1 if an enabled breakpoint exists at PC.
470 When continuing from a location with a breakpoint,
471 we actually single step once before calling insert_breakpoints. */
474 breakpoint_here_p (pc
)
477 register struct breakpoint
*b
;
480 if (b
->enable
!= disabled
&& b
->address
== pc
)
486 /* bpstat stuff. External routines' interfaces are documented
501 if (p
->old_val
!= NULL
)
502 value_free (p
->old_val
);
520 for (; bs
!= NULL
; bs
= bs
->next
)
522 tmp
= (bpstat
) xmalloc (sizeof (*tmp
));
523 bcopy (bs
, tmp
, sizeof (*tmp
));
525 /* This is the first thing in the chain. */
539 struct breakpoint
*b
;
542 return 0; /* No more breakpoint values */
545 b
= (*bsp
)->breakpoint_at
;
548 return -1; /* breakpoint that's been deleted since */
550 return b
->number
; /* We have its number */
555 bpstat_clear_actions (bs
)
558 for (; bs
!= NULL
; bs
= bs
->next
)
561 if (bs
->old_val
!= NULL
)
563 value_free (bs
->old_val
);
569 /* Execute all the commands associated with all the breakpoints at this
570 location. Any of these commands could cause the process to proceed
571 beyond this point, etc. We look out for such changes by checking
572 the global "breakpoint_proceeded" after each command. */
574 bpstat_do_actions (bsp
)
582 executing_breakpoint_commands
= 1;
583 breakpoint_proceeded
= 0;
584 for (; bs
!= NULL
; bs
= bs
->next
)
588 char *line
= bs
->commands
->line
;
589 bs
->commands
= bs
->commands
->next
;
590 execute_command (line
, 0);
591 /* If the inferior is proceeded by the command, bomb out now.
592 The bpstat chain has been blown away by wait_for_inferior.
593 But since execution has stopped again, there is a new bpstat
594 to look at, so start over. */
595 if (breakpoint_proceeded
)
599 clear_momentary_breakpoints ();
601 executing_breakpoint_commands
= 0;
608 /* bs->breakpoint_at can be NULL if it was a momentary breakpoint
609 which has since been deleted. */
610 if (bs
== NULL
|| bs
->breakpoint_at
== NULL
)
613 /* If bpstat_stop_status says don't print, OK, we won't. An example
614 circumstance is when we single-stepped for both a watchpoint and
615 for a "stepi" instruction. The bpstat says that the watchpoint
616 explains the stop, but we shouldn't print because the watchpoint's
617 value didn't change -- and the real reason we are stopping here
618 rather than continuing to step (as the watchpoint would've had us do)
619 is because of the "stepi". */
623 if (bs
->breakpoint_at
->address
!= NULL
)
625 /* I think the user probably only wants to see one breakpoint
626 number, not all of them. */
627 printf_filtered ("\nBreakpoint %d, ", bs
->breakpoint_at
->number
);
631 if (bs
->old_val
!= NULL
)
633 printf_filtered ("\nWatchpoint %d, ", bs
->breakpoint_at
->number
);
634 print_expression (bs
->breakpoint_at
->exp
, stdout
);
635 printf_filtered ("\nOld value = ");
636 value_print (bs
->old_val
, stdout
, 0, Val_pretty_default
);
637 printf_filtered ("\nNew value = ");
638 value_print (bs
->breakpoint_at
->val
, stdout
, 0,
640 printf_filtered ("\n");
641 value_free (bs
->old_val
);
646 /* Maybe another breakpoint in the chain caused us to stop.
647 (Currently all watchpoints go on the bpstat whether hit or
648 not. That probably could (should) be changed, provided care is taken
649 with respect to bpstat_explains_signal). */
651 return bpstat_print (bs
->next
);
653 fprintf_filtered (stderr
, "gdb internal error: in bpstat_print\n");
657 /* Evaluate the expression EXP and return 1 if value is zero.
658 This is used inside a catch_errors to evaluate the breakpoint condition.
659 The argument is a "struct expression *" that has been cast to int to
660 make it pass through catch_errors. */
663 breakpoint_cond_eval (exp
)
666 return value_zerop (evaluate_expression ((struct expression
*)exp
));
669 /* Allocate a new bpstat and chain it to the current one. */
672 bpstat_alloc (b
, cbs
)
673 register struct breakpoint
*b
;
674 bpstat cbs
; /* Current "bs" value */
678 bs
= (bpstat
) xmalloc (sizeof (*bs
));
680 bs
->breakpoint_at
= b
;
681 /* If the condition is false, etc., don't do the commands. */
683 bs
->momentary
= b
->number
== -3;
688 /* Determine whether we stopped at a breakpoint, etc, or whether we
689 don't understand this stop. Result is a chain of bpstat's such that:
691 if we don't understand the stop, the result is a null pointer.
693 if we understand why we stopped, the result is not null, and
694 the first element of the chain contains summary "stop" and
695 "print" flags for the whole chain.
697 Each element of the chain refers to a particular breakpoint or
698 watchpoint at which we have stopped. (We may have stopped for
701 Each element of the chain has valid next, breakpoint_at,
702 commands, FIXME??? fields.
708 bpstat_stop_status (pc
, frame_address
)
710 FRAME_ADDR frame_address
;
712 register struct breakpoint
*b
;
716 /* True if we've hit a breakpoint (as opposed to a watchpoint). */
717 int real_breakpoint
= 0;
718 /* Root of the chain of bpstat's */
719 struct bpstat__struct root_bs
[1];
720 /* Pointer to the last thing in the chain currently. */
723 /* Get the address where the breakpoint would have been. */
724 bp_addr
= *pc
- DECR_PC_AFTER_BREAK
;
731 if (b
->enable
== disabled
)
733 if (b
->address
!= NULL
&& b
->address
!= bp_addr
)
736 bs
= bpstat_alloc (b
, bs
); /* Alloc a bpstat to explain stop */
741 if (b
->exp
!= NULL
) /* Watchpoint */
743 int within_current_scope
;
744 if (b
->exp_valid_block
!= NULL
)
745 within_current_scope
=
746 contained_in (get_selected_block (), b
->exp_valid_block
);
748 within_current_scope
= 1;
750 if (within_current_scope
)
752 /* We use value_{,free_to_}mark because it could be a
753 *long* time before we return to the command level and
754 call free_all_values. */
756 value mark
= value_mark ();
757 value new_val
= evaluate_expression (b
->exp
);
758 if (!value_equal (b
->val
, new_val
))
760 release_value (new_val
);
761 value_free_to_mark (mark
);
762 bs
->old_val
= b
->val
;
764 /* We will stop here */
768 /* Nothing changed, don't do anything. */
769 value_free_to_mark (mark
);
771 /* We won't stop here */
776 /* This seems like the only logical thing to do because
777 if we temporarily ignored the watchpoint, then when
778 we reenter the block in which it is valid it contains
779 garbage (in the case of a function, it may have two
780 garbage values, one before and one after the prologue).
781 So we can't even detect the first assignment to it and
782 watch after that (since the garbage may or may not equal
783 the first value assigned). */
784 b
->enable
= disabled
;
786 Watchpoint %d disabled because the program has left the block in\n\
787 which its expression is valid.\n", b
->number
);
788 /* We won't stop here */
789 /* FIXME, maybe we should stop here!!! */
796 if (b
->frame
&& b
->frame
!= frame_address
)
804 /* Need to select the frame, with all that implies
805 so that the conditions will have the right context. */
806 select_frame (get_current_frame (), 0);
808 = catch_errors (breakpoint_cond_eval
, (int)(b
->cond
),
809 "Error occurred in testing breakpoint condition.");
812 if (b
->cond
&& value_zero
)
816 else if (b
->ignore_count
> 0)
823 /* We will stop here */
824 if (b
->enable
== temporary
)
825 b
->enable
= disabled
;
826 bs
->commands
= b
->commands
;
829 if (bs
->commands
&& !strcmp ("silent", bs
->commands
->line
))
831 bs
->commands
= bs
->commands
->next
;
842 bs
->next
= NULL
; /* Terminate the chain */
843 bs
= root_bs
->next
; /* Re-grab the head of the chain */
848 #if DECR_PC_AFTER_BREAK != 0 || defined (SHIFT_INST_REGS)
852 #if defined (SHIFT_INST_REGS)
854 CORE_ADDR pc
= read_register (PC_REGNUM
);
855 CORE_ADDR npc
= read_register (NPC_REGNUM
);
858 write_register (NNPC_REGNUM
, npc
);
859 write_register (NPC_REGNUM
, pc
);
862 #else /* No SHIFT_INST_REGS. */
864 #endif /* No SHIFT_INST_REGS. */
866 #endif /* DECR_PC_AFTER_BREAK != 0. */
872 bpstat_should_step ()
874 struct breakpoint
*b
;
876 if (b
->enable
!= disabled
&& b
->exp
!= NULL
)
881 /* Print information on breakpoint number BNUM, or -1 if all.
882 If WATCHPOINTS is zero, process only breakpoints; if WATCHPOINTS
883 is nonzero, process only watchpoints. */
886 breakpoint_1 (bnum
, watchpoints
)
890 register struct breakpoint
*b
;
891 register struct command_line
*l
;
892 register struct symbol
*sym
;
893 CORE_ADDR last_addr
= (CORE_ADDR
)-1;
894 int header_printed
= 0;
897 if (bnum
== -1 || bnum
== b
->number
)
899 if (b
->address
== NULL
&& !watchpoints
)
903 error ("That is a watchpoint, not a breakpoint.");
905 if (b
->address
!= NULL
&& watchpoints
)
909 error ("That is a breakpoint, not a watchpoint.");
915 printf_filtered (" Enb Expression\n");
916 else if (addressprint
)
917 printf_filtered (" Enb Address Where\n");
919 printf_filtered (" Enb Where\n");
923 printf_filtered ("#%-3d %c ", b
->number
, "nyod"[(int) b
->enable
]);
924 if (b
->address
== NULL
) {
925 printf_filtered (" ");
926 print_expression (b
->exp
, stdout
);
929 printf_filtered (" 0x%08x ", b
->address
);
931 last_addr
= b
->address
;
934 sym
= find_pc_function (b
->address
);
937 fputs_filtered (" in ", stdout
);
938 fputs_demangled (SYMBOL_NAME (sym
), stdout
, 1);
939 fputs_filtered (" at ", stdout
);
941 fputs_filtered (b
->symtab
->filename
, stdout
);
942 printf_filtered (":%d", b
->line_number
);
945 print_address_symbolic (b
->address
, stdout
, demangle
);
948 printf_filtered ("\n");
951 printf_filtered ("\tstop only in stack frame at 0x%x\n", b
->frame
);
954 printf_filtered ("\tstop only if ");
955 print_expression (b
->cond
, stdout
);
956 printf_filtered ("\n");
959 printf_filtered ("\tignore next %d hits\n", b
->ignore_count
);
960 if ((l
= b
->commands
))
963 fputs_filtered ("\t", stdout
);
964 fputs_filtered (l
->line
, stdout
);
965 fputs_filtered ("\n", stdout
);
972 char *which
= watchpoints
? "watch" : "break";
974 printf_filtered ("No %spoints.\n", which
);
976 printf_filtered ("No %spoint numbered %d.\n", which
, bnum
);
979 /* Compare against (CORE_ADDR)-1 in case some compiler decides
980 that a comparison of an unsigned with -1 is always false. */
981 if (last_addr
!= (CORE_ADDR
)-1)
982 set_next_address (last_addr
);
986 breakpoints_info (bnum_exp
, from_tty
)
993 bnum
= parse_and_eval_address (bnum_exp
);
995 breakpoint_1 (bnum
, 0);
999 watchpoints_info (bnum_exp
, from_tty
)
1006 bnum
= parse_and_eval_address (bnum_exp
);
1008 breakpoint_1 (bnum
, 1);
1011 /* Print a message describing any breakpoints set at PC. */
1014 describe_other_breakpoints (pc
)
1015 register CORE_ADDR pc
;
1017 register int others
= 0;
1018 register struct breakpoint
*b
;
1021 if (b
->address
== pc
)
1025 printf ("Note: breakpoint%s ", (others
> 1) ? "s" : "");
1027 if (b
->address
== pc
)
1032 (b
->enable
== disabled
) ? " (disabled)" : "",
1033 (others
> 1) ? "," : ((others
== 1) ? " and" : ""));
1035 printf ("also set at pc 0x%x.\n", pc
);
1039 /* Set the default place to put a breakpoint
1040 for the `break' command with no arguments. */
1043 set_default_breakpoint (valid
, addr
, symtab
, line
)
1046 struct symtab
*symtab
;
1049 default_breakpoint_valid
= valid
;
1050 default_breakpoint_address
= addr
;
1051 default_breakpoint_symtab
= symtab
;
1052 default_breakpoint_line
= line
;
1055 /* Rescan breakpoints at address ADDRESS,
1056 marking the first one as "first" and any others as "duplicates".
1057 This is so that the bpt instruction is only inserted once. */
1060 check_duplicates (address
)
1063 register struct breakpoint
*b
;
1064 register int count
= 0;
1066 if (address
== NULL
) /* Watchpoints are uninteresting */
1070 if (b
->enable
!= disabled
&& b
->address
== address
)
1073 b
->duplicate
= count
> 1;
1077 /* Low level routine to set a breakpoint.
1078 Takes as args the three things that every breakpoint must have.
1079 Returns the breakpoint object so caller can set other things.
1080 Does not set the breakpoint number!
1081 Does not print anything.
1083 ==> This routine should not be called if there is a chance of later
1084 error(); otherwise it leaves a bogus breakpoint on the chain. Validate
1085 your arguments BEFORE calling this routine! */
1087 static struct breakpoint
*
1088 set_raw_breakpoint (sal
)
1089 struct symtab_and_line sal
;
1091 register struct breakpoint
*b
, *b1
;
1093 b
= (struct breakpoint
*) xmalloc (sizeof (struct breakpoint
));
1094 bzero (b
, sizeof *b
);
1095 b
->address
= sal
.pc
;
1096 b
->symtab
= sal
.symtab
;
1097 b
->line_number
= sal
.line
;
1098 b
->enable
= enabled
;
1101 b
->ignore_count
= 0;
1105 /* Add this breakpoint to the end of the chain
1106 so that a list of breakpoints will come out in order
1107 of increasing numbers. */
1109 b1
= breakpoint_chain
;
1111 breakpoint_chain
= b
;
1119 check_duplicates (sal
.pc
);
1124 /* Set a breakpoint that will evaporate an end of command
1125 at address specified by SAL.
1126 Restrict it to frame FRAME if FRAME is nonzero. */
1129 set_momentary_breakpoint (sal
, frame
)
1130 struct symtab_and_line sal
;
1133 register struct breakpoint
*b
;
1134 b
= set_raw_breakpoint (sal
);
1137 b
->frame
= (frame
? FRAME_FP (frame
) : 0);
1141 clear_momentary_breakpoints ()
1143 register struct breakpoint
*b
;
1145 if (b
->number
== -3)
1147 delete_breakpoint (b
);
1152 /* Tell the user we have just set a breakpoint B. */
1155 struct breakpoint
*b
;
1159 printf_filtered ("Watchpoint %d: ", b
->number
);
1160 print_expression (b
->exp
, stdout
);
1164 printf_filtered ("Breakpoint %d at 0x%x", b
->number
, b
->address
);
1166 printf_filtered (": file %s, line %d.",
1167 b
->symtab
->filename
, b
->line_number
);
1169 printf_filtered ("\n");
1173 /* Nobody calls this currently. */
1174 /* Set a breakpoint from a symtab and line.
1175 If TEMPFLAG is nonzero, it is a temporary breakpoint.
1176 ADDR_STRING is a malloc'd string holding the name of where we are
1177 setting the breakpoint. This is used later to re-set it after the
1178 program is relinked and symbols are reloaded.
1179 Print the same confirmation messages that the breakpoint command prints. */
1182 set_breakpoint (s
, line
, tempflag
, addr_string
)
1188 register struct breakpoint
*b
;
1189 struct symtab_and_line sal
;
1193 sal
.pc
= find_line_pc (sal
.symtab
, sal
.line
);
1195 error ("No line %d in file \"%s\".\n", sal
.line
, sal
.symtab
->filename
);
1198 describe_other_breakpoints (sal
.pc
);
1200 b
= set_raw_breakpoint (sal
);
1201 set_breakpoint_count (breakpoint_count
+ 1);
1202 b
->number
= breakpoint_count
;
1204 b
->addr_string
= addr_string
;
1206 b
->enable
= temporary
;
1213 /* Set a breakpoint according to ARG (function, linenum or *address)
1214 and make it temporary if TEMPFLAG is nonzero. */
1217 break_command_1 (arg
, tempflag
, from_tty
)
1219 int tempflag
, from_tty
;
1221 struct symtabs_and_lines sals
;
1222 struct symtab_and_line sal
;
1223 register struct expression
*cond
= 0;
1224 register struct breakpoint
*b
;
1226 /* Pointers in arg to the start, and one past the end, of the condition. */
1227 char *cond_start
= NULL
;
1229 /* Pointers in arg to the start, and one past the end,
1230 of the address part. */
1231 char *addr_start
= NULL
;
1240 sal
.line
= sal
.pc
= sal
.end
= 0;
1243 /* If no arg given, or if first arg is 'if ', use the default breakpoint. */
1245 if (!arg
|| (arg
[0] == 'i' && arg
[1] == 'f'
1246 && (arg
[2] == ' ' || arg
[2] == '\t')))
1248 if (default_breakpoint_valid
)
1250 sals
.sals
= (struct symtab_and_line
*)
1251 xmalloc (sizeof (struct symtab_and_line
));
1252 sal
.pc
= default_breakpoint_address
;
1253 sal
.line
= default_breakpoint_line
;
1254 sal
.symtab
= default_breakpoint_symtab
;
1259 error ("No default breakpoint address now.");
1265 /* Force almost all breakpoints to be in terms of the
1266 current_source_symtab (which is decode_line_1's default). This
1267 should produce the results we want almost all of the time while
1268 leaving default_breakpoint_* alone. */
1269 if (default_breakpoint_valid
1270 && (!current_source_symtab
1271 || (arg
&& (*arg
== '+' || *arg
== '-'))))
1272 sals
= decode_line_1 (&arg
, 1, default_breakpoint_symtab
,
1273 default_breakpoint_line
);
1275 sals
= decode_line_1 (&arg
, 1, (struct symtab
*)NULL
, 0);
1283 for (i
= 0; i
< sals
.nelts
; i
++)
1286 if (sal
.pc
== 0 && sal
.symtab
!= 0)
1288 pc
= find_line_pc (sal
.symtab
, sal
.line
);
1290 error ("No line %d in file \"%s\".",
1291 sal
.line
, sal
.symtab
->filename
);
1298 if (arg
[0] == 'i' && arg
[1] == 'f'
1299 && (arg
[2] == ' ' || arg
[2] == '\t'))
1303 cond
= parse_c_1 (&arg
, block_for_pc (pc
), 0);
1307 error ("Junk at end of arguments.");
1309 sals
.sals
[i
].pc
= pc
;
1312 for (i
= 0; i
< sals
.nelts
; i
++)
1317 describe_other_breakpoints (sal
.pc
);
1319 b
= set_raw_breakpoint (sal
);
1320 set_breakpoint_count (breakpoint_count
+ 1);
1321 b
->number
= breakpoint_count
;
1325 b
->addr_string
= savestring (addr_start
, addr_end
- addr_start
);
1327 b
->cond_string
= savestring (cond_start
, cond_end
- cond_start
);
1330 b
->enable
= temporary
;
1337 printf ("Multiple breakpoints were set.\n");
1338 printf ("Use the \"delete\" command to delete unwanted breakpoints.\n");
1344 break_command (arg
, from_tty
)
1348 break_command_1 (arg
, 0, from_tty
);
1352 tbreak_command (arg
, from_tty
)
1356 break_command_1 (arg
, 1, from_tty
);
1360 watch_command (arg
, from_tty
)
1364 struct breakpoint
*b
;
1365 struct symtab_and_line sal
;
1366 struct expression
*exp
;
1367 struct block
*exp_valid_block
;
1374 /* Parse arguments. */
1375 innermost_block
= NULL
;
1376 exp
= parse_c_expression (arg
);
1377 exp_valid_block
= innermost_block
;
1378 val
= evaluate_expression (exp
);
1379 release_value (val
);
1381 /* Now set up the breakpoint. */
1382 b
= set_raw_breakpoint (sal
);
1383 set_breakpoint_count (breakpoint_count
+ 1);
1384 b
->number
= breakpoint_count
;
1386 b
->exp_valid_block
= exp_valid_block
;
1389 b
->cond_string
= NULL
;
1394 * Helper routine for the until_command routine in infcmd.c. Here
1395 * because it uses the mechanisms of breakpoints.
1398 until_break_command (arg
, from_tty
)
1402 struct symtabs_and_lines sals
;
1403 struct symtab_and_line sal
;
1404 FRAME prev_frame
= get_prev_frame (selected_frame
);
1406 clear_proceed_status ();
1408 /* Set a breakpoint where the user wants it and at return from
1411 if (default_breakpoint_valid
)
1412 sals
= decode_line_1 (&arg
, 1, default_breakpoint_symtab
,
1413 default_breakpoint_line
);
1415 sals
= decode_line_1 (&arg
, 1, (struct symtab
*)NULL
, 0);
1417 if (sals
.nelts
!= 1)
1418 error ("Couldn't get information on specified line.");
1421 free (sals
.sals
); /* malloc'd, so freed */
1424 error ("Junk at end of arguments.");
1426 if (sal
.pc
== 0 && sal
.symtab
!= 0)
1427 sal
.pc
= find_line_pc (sal
.symtab
, sal
.line
);
1430 error ("No line %d in file \"%s\".", sal
.line
, sal
.symtab
->filename
);
1432 set_momentary_breakpoint (sal
, selected_frame
);
1434 /* Keep within the current frame */
1438 struct frame_info
*fi
;
1440 fi
= get_frame_info (prev_frame
);
1441 sal
= find_pc_line (fi
->pc
, 0);
1443 set_momentary_breakpoint (sal
, prev_frame
);
1446 proceed (-1, -1, 0);
1449 /* Set a breakpoint at the catch clause for NAME. */
1451 catch_breakpoint (name
)
1457 disable_catch_breakpoint ()
1462 delete_catch_breakpoint ()
1467 enable_catch_breakpoint ()
1473 struct sal_chain
*next
;
1474 struct symtab_and_line sal
;
1477 /* For each catch clause identified in ARGS, run FUNCTION
1478 with that clause as an argument. */
1479 static struct symtabs_and_lines
1480 map_catch_names (args
, function
)
1484 register char *p
= args
;
1486 struct symtabs_and_lines sals
;
1487 struct sal_chain
*sal_chain
= 0;
1490 error_no_arg ("one or more catch names");
1498 /* Don't swallow conditional part. */
1499 if (p1
[0] == 'i' && p1
[1] == 'f'
1500 && (p1
[2] == ' ' || p1
[2] == '\t'))
1506 while (isalnum (*p1
) || *p1
== '_' || *p1
== '$')
1510 if (*p1
&& *p1
!= ' ' && *p1
!= '\t')
1511 error ("Arguments must be catch names.");
1517 struct sal_chain
*next
1518 = (struct sal_chain
*)alloca (sizeof (struct sal_chain
));
1519 next
->next
= sal_chain
;
1520 next
->sal
= get_catch_sal (p
);
1525 printf ("No catch clause for exception %s.\n", p
);
1528 while (*p
== ' ' || *p
== '\t') p
++;
1532 /* This shares a lot of code with `print_frame_label_vars' from stack.c. */
1534 static struct symtabs_and_lines
1535 get_catch_sals (this_level_only
)
1536 int this_level_only
;
1538 extern struct blockvector
*blockvector_for_pc ();
1539 register struct blockvector
*bl
;
1540 register struct block
*block
;
1541 int index
, have_default
= 0;
1542 struct frame_info
*fi
;
1544 struct symtabs_and_lines sals
;
1545 struct sal_chain
*sal_chain
= 0;
1546 char *blocks_searched
;
1548 /* Not sure whether an error message is always the correct response,
1549 but it's better than a core dump. */
1550 if (selected_frame
== NULL
)
1551 error ("No selected frame.");
1552 block
= get_frame_block (selected_frame
);
1553 fi
= get_frame_info (selected_frame
);
1560 error ("No symbol table info available.\n");
1562 bl
= blockvector_for_pc (BLOCK_END (block
) - 4, &index
);
1563 blocks_searched
= (char *) alloca (BLOCKVECTOR_NBLOCKS (bl
) * sizeof (char));
1564 bzero (blocks_searched
, BLOCKVECTOR_NBLOCKS (bl
) * sizeof (char));
1568 CORE_ADDR end
= BLOCK_END (block
) - 4;
1571 if (bl
!= blockvector_for_pc (end
, &index
))
1572 error ("blockvector blotch");
1573 if (BLOCKVECTOR_BLOCK (bl
, index
) != block
)
1574 error ("blockvector botch");
1575 last_index
= BLOCKVECTOR_NBLOCKS (bl
);
1578 /* Don't print out blocks that have gone by. */
1579 while (index
< last_index
1580 && BLOCK_END (BLOCKVECTOR_BLOCK (bl
, index
)) < pc
)
1583 while (index
< last_index
1584 && BLOCK_END (BLOCKVECTOR_BLOCK (bl
, index
)) < end
)
1586 if (blocks_searched
[index
] == 0)
1588 struct block
*b
= BLOCKVECTOR_BLOCK (bl
, index
);
1591 register struct symbol
*sym
;
1593 nsyms
= BLOCK_NSYMS (b
);
1595 for (i
= 0; i
< nsyms
; i
++)
1597 sym
= BLOCK_SYM (b
, i
);
1598 if (! strcmp (SYMBOL_NAME (sym
), "default"))
1604 if (SYMBOL_CLASS (sym
) == LOC_LABEL
)
1606 struct sal_chain
*next
= (struct sal_chain
*)
1607 alloca (sizeof (struct sal_chain
));
1608 next
->next
= sal_chain
;
1609 next
->sal
= find_pc_line (SYMBOL_VALUE_ADDRESS (sym
), 0);
1613 blocks_searched
[index
] = 1;
1619 if (sal_chain
&& this_level_only
)
1622 /* After handling the function's top-level block, stop.
1623 Don't continue to its superblock, the block of
1624 per-file symbols. */
1625 if (BLOCK_FUNCTION (block
))
1627 block
= BLOCK_SUPERBLOCK (block
);
1632 struct sal_chain
*tmp_chain
;
1634 /* Count the number of entries. */
1635 for (index
= 0, tmp_chain
= sal_chain
; tmp_chain
;
1636 tmp_chain
= tmp_chain
->next
)
1640 sals
.sals
= (struct symtab_and_line
*)
1641 xmalloc (index
* sizeof (struct symtab_and_line
));
1642 for (index
= 0; sal_chain
; sal_chain
= sal_chain
->next
, index
++)
1643 sals
.sals
[index
] = sal_chain
->sal
;
1649 /* Commands to deal with catching exceptions. */
1652 catch_command_1 (arg
, tempflag
, from_tty
)
1657 /* First, translate ARG into something we can deal with in terms
1660 struct symtabs_and_lines sals
;
1661 struct symtab_and_line sal
;
1662 register struct expression
*cond
= 0;
1663 register struct breakpoint
*b
;
1668 sal
.line
= sal
.pc
= sal
.end
= 0;
1671 /* If no arg given, or if first arg is 'if ', all active catch clauses
1672 are breakpointed. */
1674 if (!arg
|| (arg
[0] == 'i' && arg
[1] == 'f'
1675 && (arg
[2] == ' ' || arg
[2] == '\t')))
1677 /* Grab all active catch clauses. */
1678 sals
= get_catch_sals (0);
1682 /* Grab selected catch clauses. */
1683 error ("catch NAME not implemeneted");
1684 sals
= map_catch_names (arg
, catch_breakpoint
);
1691 for (i
= 0; i
< sals
.nelts
; i
++)
1694 if (sal
.pc
== 0 && sal
.symtab
!= 0)
1696 pc
= find_line_pc (sal
.symtab
, sal
.line
);
1698 error ("No line %d in file \"%s\".",
1699 sal
.line
, sal
.symtab
->filename
);
1706 if (arg
[0] == 'i' && arg
[1] == 'f'
1707 && (arg
[2] == ' ' || arg
[2] == '\t'))
1708 cond
= (struct expression
*) parse_c_1 ((arg
+= 2, &arg
),
1709 block_for_pc (pc
), 0);
1711 error ("Junk at end of arguments.");
1714 sals
.sals
[i
].pc
= pc
;
1717 for (i
= 0; i
< sals
.nelts
; i
++)
1722 describe_other_breakpoints (sal
.pc
);
1724 b
= set_raw_breakpoint (sal
);
1725 b
->number
= ++breakpoint_count
;
1728 b
->enable
= temporary
;
1730 printf ("Breakpoint %d at 0x%x", b
->number
, b
->address
);
1732 printf (": file %s, line %d.", b
->symtab
->filename
, b
->line_number
);
1738 printf ("Multiple breakpoints were set.\n");
1739 printf ("Use the \"delete\" command to delete unwanted breakpoints.\n");
1744 /* Disable breakpoints on all catch clauses described in ARGS. */
1746 disable_catch (args
)
1749 /* Map the disable command to catch clauses described in ARGS. */
1752 /* Enable breakpoints on all catch clauses described in ARGS. */
1757 /* Map the disable command to catch clauses described in ARGS. */
1760 /* Delete breakpoints on all catch clauses in the active scope. */
1765 /* Map the delete command to catch clauses described in ARGS. */
1769 catch_command (arg
, from_tty
)
1773 catch_command_1 (arg
, 0, from_tty
);
1777 clear_command (arg
, from_tty
)
1781 register struct breakpoint
*b
, *b1
;
1782 struct symtabs_and_lines sals
;
1783 struct symtab_and_line sal
;
1784 register struct breakpoint
*found
;
1789 sals
= decode_line_spec (arg
, 1);
1793 sals
.sals
= (struct symtab_and_line
*) xmalloc (sizeof (struct symtab_and_line
));
1794 sal
.line
= default_breakpoint_line
;
1795 sal
.symtab
= default_breakpoint_symtab
;
1797 if (sal
.symtab
== 0)
1798 error ("No source file specified.");
1804 for (i
= 0; i
< sals
.nelts
; i
++)
1806 /* If exact pc given, clear bpts at that pc.
1807 But if sal.pc is zero, clear all bpts on specified line. */
1809 found
= (struct breakpoint
*) 0;
1810 while (breakpoint_chain
1811 && (sal
.pc
? breakpoint_chain
->address
== sal
.pc
1812 : (breakpoint_chain
->symtab
== sal
.symtab
1813 && breakpoint_chain
->line_number
== sal
.line
)))
1815 b1
= breakpoint_chain
;
1816 breakpoint_chain
= b1
->next
;
1823 && b
->next
->address
!= NULL
1824 && (sal
.pc
? b
->next
->address
== sal
.pc
1825 : (b
->next
->symtab
== sal
.symtab
1826 && b
->next
->line_number
== sal
.line
)))
1837 error ("No breakpoint at %s.", arg
);
1839 error ("No breakpoint at this line.");
1842 if (found
->next
) from_tty
= 1; /* Always report if deleted more than one */
1843 if (from_tty
) printf ("Deleted breakpoint%s ", found
->next
? "s" : "");
1846 if (from_tty
) printf ("%d ", found
->number
);
1848 delete_breakpoint (found
);
1851 if (from_tty
) putchar ('\n');
1856 /* Delete breakpoint in BS if they are `delete' breakpoints.
1857 This is called after any breakpoint is hit, or after errors. */
1860 breakpoint_auto_delete (bs
)
1863 for (; bs
; bs
= bs
->next
)
1864 if (bs
->breakpoint_at
&& bs
->breakpoint_at
->enable
== delete)
1865 delete_breakpoint (bs
->breakpoint_at
);
1868 /* Delete a breakpoint and clean up all traces of it in the data structures. */
1871 delete_breakpoint (bpt
)
1872 struct breakpoint
*bpt
;
1874 register struct breakpoint
*b
;
1878 target_remove_breakpoint(bpt
->address
, bpt
->shadow_contents
);
1880 if (breakpoint_chain
== bpt
)
1881 breakpoint_chain
= bpt
->next
;
1886 b
->next
= bpt
->next
;
1890 check_duplicates (bpt
->address
);
1892 free_command_lines (&bpt
->commands
);
1895 if (bpt
->cond_string
!= NULL
)
1896 free (bpt
->cond_string
);
1897 if (bpt
->addr_string
!= NULL
)
1898 free (bpt
->addr_string
);
1900 if (xgdb_verbose
&& bpt
->number
>=0)
1901 printf ("breakpoint #%d deleted\n", bpt
->number
);
1903 /* Be sure no bpstat's are pointing at it after it's been freed. */
1904 /* FIXME, how can we find all bpstat's? We just check stop_bpstat for now. */
1905 for (bs
= stop_bpstat
; bs
; bs
= bs
->next
)
1906 if (bs
->breakpoint_at
== bpt
)
1907 bs
->breakpoint_at
= NULL
;
1911 static void map_breakpoint_numbers ();
1914 delete_command (arg
, from_tty
)
1921 /* Ask user only if there are some breakpoints to delete. */
1923 || (breakpoint_chain
&& query ("Delete all breakpoints? ", 0, 0)))
1925 /* No arg; clear all breakpoints. */
1926 while (breakpoint_chain
)
1927 delete_breakpoint (breakpoint_chain
);
1931 map_breakpoint_numbers (arg
, delete_breakpoint
);
1935 breakpoint_re_set_one (bint
)
1938 struct breakpoint
*b
= (struct breakpoint
*)bint
; /* get past catch_errs */
1940 struct symtabs_and_lines sals
;
1941 struct symtab_and_line sal
;
1944 if (b
->address
!= NULL
&& b
->addr_string
!= NULL
)
1947 sals
= decode_line_1 (&s
, 1, (struct symtab
*)NULL
, 0);
1948 for (i
= 0; i
< sals
.nelts
; i
++)
1952 b
->symtab
= sal
.symtab
;
1953 b
->line_number
= sal
.line
;
1954 if (sal
.pc
== 0 && sal
.symtab
!= 0)
1956 sal
.pc
= find_line_pc (sal
.symtab
, sal
.line
);
1958 error ("No line %d in file \"%s\".",
1959 sal
.line
, sal
.symtab
->filename
);
1961 b
->address
= sal
.pc
;
1963 if (b
->cond_string
!= NULL
)
1966 b
->cond
= parse_c_1 (&s
, block_for_pc (sal
.pc
), 0);
1969 check_duplicates (b
->address
);
1977 /* Anything without a string can't be re-set. */
1978 delete_breakpoint (b
);
1982 /* Re-set all breakpoints after symbols have been re-loaded. */
1984 breakpoint_re_set ()
1986 struct breakpoint
*b
;
1990 b
->symtab
= 0; /* Be sure we don't point to old dead symtab */
1991 (void) catch_errors (breakpoint_re_set_one
, (int) b
,
1992 "Error in re-setting breakpoint");
1995 /* Blank line to finish off all those mention() messages we just printed. */
1996 printf_filtered ("\n");
1999 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
2000 If from_tty is nonzero, it prints a message to that effect,
2001 which ends with a period (no newline). */
2004 set_ignore_count (bptnum
, count
, from_tty
)
2005 int bptnum
, count
, from_tty
;
2007 register struct breakpoint
*b
;
2013 if (b
->number
== bptnum
)
2015 b
->ignore_count
= count
;
2018 else if (count
== 0)
2019 printf ("Will stop next time breakpoint %d is reached.", bptnum
);
2020 else if (count
== 1)
2021 printf ("Will ignore next crossing of breakpoint %d.", bptnum
);
2023 printf ("Will ignore next %d crossings of breakpoint %d.",
2028 error ("No breakpoint number %d.", bptnum
);
2031 /* Clear the ignore counts of all breakpoints. */
2033 breakpoint_clear_ignore_counts ()
2035 struct breakpoint
*b
;
2038 b
->ignore_count
= 0;
2041 /* Command to set ignore-count of breakpoint N to COUNT. */
2044 ignore_command (args
, from_tty
)
2052 error_no_arg ("a breakpoint number");
2054 num
= get_number (&p
);
2057 error ("Second argument (specified ignore-count) is missing.");
2059 set_ignore_count (num
, parse_and_eval_address (p
), from_tty
);
2063 /* Call FUNCTION on each of the breakpoints
2064 whose numbers are given in ARGS. */
2067 map_breakpoint_numbers (args
, function
)
2069 void (*function
) ();
2071 register char *p
= args
;
2074 register struct breakpoint
*b
;
2077 error_no_arg ("one or more breakpoint numbers");
2083 num
= get_number (&p1
);
2086 if (b
->number
== num
)
2091 printf ("No breakpoint number %d.\n", num
);
2098 enable_breakpoint (bpt
)
2099 struct breakpoint
*bpt
;
2101 bpt
->enable
= enabled
;
2103 if (xgdb_verbose
&& bpt
->number
>= 0)
2104 printf ("breakpoint #%d enabled\n", bpt
->number
);
2106 check_duplicates (bpt
->address
);
2107 if (bpt
->val
!= NULL
)
2109 if (bpt
->exp_valid_block
!= NULL
2110 && !contained_in (get_selected_block (), bpt
->exp_valid_block
))
2113 Cannot enable watchpoint %d because the block in which its expression\n\
2114 is valid is not currently in scope.\n", bpt
->number
);
2118 value_free (bpt
->val
);
2120 bpt
->val
= evaluate_expression (bpt
->exp
);
2121 release_value (bpt
->val
);
2126 enable_command (args
, from_tty
)
2130 struct breakpoint
*bpt
;
2132 ALL_BREAKPOINTS (bpt
)
2133 enable_breakpoint (bpt
);
2135 map_breakpoint_numbers (args
, enable_breakpoint
);
2139 disable_breakpoint (bpt
)
2140 struct breakpoint
*bpt
;
2142 bpt
->enable
= disabled
;
2144 if (xgdb_verbose
&& bpt
->number
>= 0)
2145 printf ("breakpoint #%d disabled\n", bpt
->number
);
2147 check_duplicates (bpt
->address
);
2151 disable_command (args
, from_tty
)
2155 register struct breakpoint
*bpt
;
2157 ALL_BREAKPOINTS (bpt
)
2158 disable_breakpoint (bpt
);
2160 map_breakpoint_numbers (args
, disable_breakpoint
);
2164 enable_once_breakpoint (bpt
)
2165 struct breakpoint
*bpt
;
2167 bpt
->enable
= temporary
;
2169 check_duplicates (bpt
->address
);
2173 enable_once_command (args
, from_tty
)
2177 map_breakpoint_numbers (args
, enable_once_breakpoint
);
2181 enable_delete_breakpoint (bpt
)
2182 struct breakpoint
*bpt
;
2184 bpt
->enable
= delete;
2186 check_duplicates (bpt
->address
);
2190 enable_delete_command (args
, from_tty
)
2194 map_breakpoint_numbers (args
, enable_delete_breakpoint
);
2198 * Use default_breakpoint_'s, or nothing if they aren't valid.
2200 struct symtabs_and_lines
2201 decode_line_spec_1 (string
, funfirstline
)
2205 struct symtabs_and_lines sals
;
2207 error ("Empty line specification.");
2208 if (default_breakpoint_valid
)
2209 sals
= decode_line_1 (&string
, funfirstline
,
2210 default_breakpoint_symtab
, default_breakpoint_line
);
2212 sals
= decode_line_1 (&string
, funfirstline
, (struct symtab
*)NULL
, 0);
2214 error ("Junk at end of line specification: %s", string
);
2219 /* Chain containing all defined enable commands. */
2221 extern struct cmd_list_element
2222 *enablelist
, *disablelist
,
2223 *deletelist
, *enablebreaklist
;
2225 extern struct cmd_list_element
*cmdlist
;
2228 _initialize_breakpoint ()
2230 breakpoint_chain
= 0;
2231 /* Don't bother to call set_breakpoint_count. $bpnum isn't useful
2232 before a breakpoint is set. */
2233 breakpoint_count
= 0;
2235 add_com ("ignore", class_breakpoint
, ignore_command
,
2236 "Set ignore-count of breakpoint number N to COUNT.");
2238 add_com ("commands", class_breakpoint
, commands_command
,
2239 "Set commands to be executed when a breakpoint is hit.\n\
2240 Give breakpoint number as argument after \"commands\".\n\
2241 With no argument, the targeted breakpoint is the last one set.\n\
2242 The commands themselves follow starting on the next line.\n\
2243 Type a line containing \"end\" to indicate the end of them.\n\
2244 Give \"silent\" as the first line to make the breakpoint silent;\n\
2245 then no output is printed when it is hit, except what the commands print.");
2247 add_com ("condition", class_breakpoint
, condition_command
,
2248 "Specify breakpoint number N to break only if COND is true.\n\
2249 N is an integer; COND is a C expression to be evaluated whenever\n\
2250 breakpoint N is reached. Actually break only when COND is nonzero.");
2252 add_com ("tbreak", class_breakpoint
, tbreak_command
,
2253 "Set a temporary breakpoint. Args like \"break\" command.\n\
2254 Like \"break\" except the breakpoint is only enabled temporarily,\n\
2255 so it will be disabled when hit. Equivalent to \"break\" followed\n\
2256 by using \"enable once\" on the breakpoint number.");
2258 add_prefix_cmd ("enable", class_breakpoint
, enable_command
,
2259 "Enable some breakpoints.\n\
2260 Give breakpoint numbers (separated by spaces) as arguments.\n\
2261 With no subcommand, breakpoints are enabled until you command otherwise.\n\
2262 This is used to cancel the effect of the \"disable\" command.\n\
2263 With a subcommand you can enable temporarily.",
2264 &enablelist
, "enable ", 1, &cmdlist
);
2266 add_abbrev_prefix_cmd ("breakpoints", class_breakpoint
, enable_command
,
2267 "Enable some breakpoints.\n\
2268 Give breakpoint numbers (separated by spaces) as arguments.\n\
2269 This is used to cancel the effect of the \"disable\" command.\n\
2270 May be abbreviated to simply \"enable\".\n",
2271 &enablebreaklist
, "enable breakpoints ", 1, &enablelist
);
2273 add_cmd ("once", no_class
, enable_once_command
,
2274 "Enable breakpoints for one hit. Give breakpoint numbers.\n\
2275 If a breakpoint is hit while enabled in this fashion, it becomes disabled.\n\
2276 See the \"tbreak\" command which sets a breakpoint and enables it once.",
2279 add_cmd ("delete", no_class
, enable_delete_command
,
2280 "Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
2281 If a breakpoint is hit while enabled in this fashion, it is deleted.",
2284 add_cmd ("delete", no_class
, enable_delete_command
,
2285 "Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
2286 If a breakpoint is hit while enabled in this fashion, it is deleted.",
2289 add_cmd ("once", no_class
, enable_once_command
,
2290 "Enable breakpoints for one hit. Give breakpoint numbers.\n\
2291 If a breakpoint is hit while enabled in this fashion, it becomes disabled.\n\
2292 See the \"tbreak\" command which sets a breakpoint and enables it once.",
2295 add_prefix_cmd ("disable", class_breakpoint
, disable_command
,
2296 "Disable some breakpoints.\n\
2297 Arguments are breakpoint numbers with spaces in between.\n\
2298 To disable all breakpoints, give no argument.\n\
2299 A disabled breakpoint is not forgotten, but has no effect until reenabled.",
2300 &disablelist
, "disable ", 1, &cmdlist
);
2301 add_com_alias ("dis", "disable", class_breakpoint
, 1);
2302 add_com_alias ("disa", "disable", class_breakpoint
, 1);
2304 add_cmd ("breakpoints", class_alias
, disable_command
,
2305 "Disable some breakpoints.\n\
2306 Arguments are breakpoint numbers with spaces in between.\n\
2307 To disable all breakpoints, give no argument.\n\
2308 A disabled breakpoint is not forgotten, but has no effect until reenabled.\n\
2309 This command may be abbreviated \"disable\".",
2312 add_prefix_cmd ("delete", class_breakpoint
, delete_command
,
2313 "Delete some breakpoints or auto-display expressions.\n\
2314 Arguments are breakpoint numbers with spaces in between.\n\
2315 To delete all breakpoints, give no argument.\n\
2317 Also a prefix command for deletion of other GDB objects.\n\
2318 The \"unset\" command is also an alias for \"delete\".",
2319 &deletelist
, "delete ", 1, &cmdlist
);
2320 add_com_alias ("d", "delete", class_breakpoint
, 1);
2322 add_cmd ("breakpoints", class_alias
, delete_command
,
2323 "Delete some breakpoints or auto-display expressions.\n\
2324 Arguments are breakpoint numbers with spaces in between.\n\
2325 To delete all breakpoints, give no argument.\n\
2326 This command may be abbreviated \"delete\".",
2329 add_com ("clear", class_breakpoint
, clear_command
,
2330 "Clear breakpoint at specified line or function.\n\
2331 Argument may be line number, function name, or \"*\" and an address.\n\
2332 If line number is specified, all breakpoints in that line are cleared.\n\
2333 If function is specified, breakpoints at beginning of function are cleared.\n\
2334 If an address is specified, breakpoints at that address are cleared.\n\n\
2335 With no argument, clears all breakpoints in the line that the selected frame\n\
2338 See also the \"delete\" command which clears breakpoints by number.");
2340 add_com ("break", class_breakpoint
, break_command
,
2341 "Set breakpoint at specified line or function.\n\
2342 Argument may be line number, function name, or \"*\" and an address.\n\
2343 If line number is specified, break at start of code for that line.\n\
2344 If function is specified, break at start of code for that function.\n\
2345 If an address is specified, break at that exact address.\n\
2346 With no arg, uses current execution address of selected stack frame.\n\
2347 This is useful for breaking on return to a stack frame.\n\
2349 Multiple breakpoints at one place are permitted, and useful if conditional.\n\
2351 Do \"help breakpoints\" for info on other commands dealing with breakpoints.");
2352 add_com_alias ("b", "break", class_run
, 1);
2353 add_com_alias ("br", "break", class_run
, 1);
2354 add_com_alias ("bre", "break", class_run
, 1);
2355 add_com_alias ("brea", "break", class_run
, 1);
2357 add_info ("breakpoints", breakpoints_info
,
2358 "Status of all breakpoints, or breakpoint number NUMBER.\n\
2359 Second column is \"y\" for enabled breakpoint, \"n\" for disabled,\n\
2360 \"o\" for enabled once (disable when hit), \"d\" for enable but delete when hit.\n\
2361 Then come the address and the file/line number.\n\n\
2362 Convenience variable \"$_\" and default examine address for \"x\"\n\
2363 are set to the address of the last breakpoint listed.\n\n\
2364 Convenience variable \"$bpnum\" contains the number of the last\n\
2367 add_com ("catch", class_breakpoint
, catch_command
,
2368 "Set breakpoints to catch exceptions that are raised.\n\
2369 Argument may be a single exception to catch, multiple exceptions\n\
2370 to catch, or the default exception \"default\". If no arguments\n\
2371 are given, breakpoints are set at all exception handlers catch clauses\n\
2372 within the current scope.\n\
2374 A condition specified for the catch applies to all breakpoints set\n\
2375 with this command\n\
2377 Do \"help breakpoints\" for info on other commands dealing with breakpoints.");
2379 add_com ("watch", class_breakpoint
, watch_command
,
2380 "Set a watchpoint for an expression.\n\
2381 A watchpoint stops execution of your program whenever the value of\n\
2382 an expression changes.");
2384 add_info ("watchpoints", watchpoints_info
,
2385 "Status of all watchpoints, or watchpoint number NUMBER.\n\
2386 Second column is \"y\" for enabled watchpoints, \"n\" for disabled.");