1 /* Everything about breakpoints, for GDB.
2 Copyright 1986, 1987, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996
3 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
25 #include "breakpoint.h"
27 #include "expression.h"
33 #include "gdbthread.h"
36 #include "gdb_string.h"
40 /* local function prototypes */
43 catch_command_1
PARAMS ((char *, int, int));
46 enable_delete_command
PARAMS ((char *, int));
49 enable_delete_breakpoint
PARAMS ((struct breakpoint
*));
52 enable_once_command
PARAMS ((char *, int));
55 enable_once_breakpoint
PARAMS ((struct breakpoint
*));
58 disable_command
PARAMS ((char *, int));
61 enable_command
PARAMS ((char *, int));
64 map_breakpoint_numbers
PARAMS ((char *, void (*)(struct breakpoint
*)));
67 ignore_command
PARAMS ((char *, int));
70 breakpoint_re_set_one
PARAMS ((char *));
73 delete_command
PARAMS ((char *, int));
76 clear_command
PARAMS ((char *, int));
79 catch_command
PARAMS ((char *, int));
81 static struct symtabs_and_lines
82 get_catch_sals
PARAMS ((int));
85 watch_command
PARAMS ((char *, int));
88 can_use_hardware_watchpoint
PARAMS ((struct value
*));
91 tbreak_command
PARAMS ((char *, int));
94 break_command_1
PARAMS ((char *, int, int));
97 mention
PARAMS ((struct breakpoint
*));
99 static struct breakpoint
*
100 set_raw_breakpoint
PARAMS ((struct symtab_and_line
));
103 check_duplicates
PARAMS ((CORE_ADDR
));
106 describe_other_breakpoints
PARAMS ((CORE_ADDR
));
109 breakpoints_info
PARAMS ((char *, int));
112 breakpoint_1
PARAMS ((int, int));
115 bpstat_alloc
PARAMS ((struct breakpoint
*, bpstat
));
118 breakpoint_cond_eval
PARAMS ((char *));
121 cleanup_executing_breakpoints
PARAMS ((int));
124 commands_command
PARAMS ((char *, int));
127 condition_command
PARAMS ((char *, int));
130 get_number
PARAMS ((char **));
133 set_breakpoint_count
PARAMS ((int));
136 remove_breakpoint
PARAMS ((struct breakpoint
*));
138 extern int addressprint
; /* Print machine addresses? */
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 /* True if breakpoint hit counts should be displayed in breakpoint info. */
156 int show_breakpoint_hit_counts
= 1;
158 /* Chain of all breakpoints defined. */
160 struct breakpoint
*breakpoint_chain
;
162 /* Number of last breakpoint made. */
164 static int breakpoint_count
;
166 /* Set breakpoint count to NUM. */
169 set_breakpoint_count (num
)
172 breakpoint_count
= num
;
173 set_internalvar (lookup_internalvar ("bpnum"),
174 value_from_longest (builtin_type_int
, (LONGEST
) num
));
177 /* Used in run_command to zero the hit count when a new run starts. */
180 clear_breakpoint_hit_counts ()
182 struct breakpoint
*b
;
188 /* Default address, symtab and line to put a breakpoint at
189 for "break" command with no arg.
190 if default_breakpoint_valid is zero, the other three are
191 not valid, and "break" with no arg is an error.
193 This set by print_stack_frame, which calls set_default_breakpoint. */
195 int default_breakpoint_valid
;
196 CORE_ADDR default_breakpoint_address
;
197 struct symtab
*default_breakpoint_symtab
;
198 int default_breakpoint_line
;
200 /* *PP is a string denoting a breakpoint. Get the number of the breakpoint.
201 Advance *PP after the string and any trailing whitespace.
203 Currently the string can either be a number or "$" followed by the name
204 of a convenience variable. Making it an expression wouldn't work well
205 for map_breakpoint_numbers (e.g. "4 + 5 + 6"). */
214 /* Empty line means refer to the last breakpoint. */
215 return breakpoint_count
;
218 /* Make a copy of the name, so we can null-terminate it
219 to pass to lookup_internalvar(). */
224 while (isalnum (*p
) || *p
== '_')
226 varname
= (char *) alloca (p
- start
+ 1);
227 strncpy (varname
, start
, p
- start
);
228 varname
[p
- start
] = '\0';
229 val
= value_of_internalvar (lookup_internalvar (varname
));
230 if (TYPE_CODE (VALUE_TYPE (val
)) != TYPE_CODE_INT
)
232 "Convenience variables used to specify breakpoints must have integer values."
234 retval
= (int) value_as_long (val
);
240 while (*p
>= '0' && *p
<= '9')
243 /* There is no number here. (e.g. "cond a == b"). */
244 error_no_arg ("breakpoint number");
247 if (!(isspace (*p
) || *p
== '\0'))
248 error ("breakpoint number expected");
255 /* condition N EXP -- set break condition of breakpoint N to EXP. */
258 condition_command (arg
, from_tty
)
262 register struct breakpoint
*b
;
267 error_no_arg ("breakpoint number");
270 bnum
= get_number (&p
);
273 if (b
->number
== bnum
)
280 if (b
->cond_string
!= NULL
)
281 free ((PTR
)b
->cond_string
);
286 b
->cond_string
= NULL
;
288 printf_filtered ("Breakpoint %d now unconditional.\n", bnum
);
293 /* I don't know if it matters whether this is the string the user
294 typed in or the decompiled expression. */
295 b
->cond_string
= savestring (arg
, strlen (arg
));
296 b
->cond
= parse_exp_1 (&arg
, block_for_pc (b
->address
), 0);
298 error ("Junk at end of expression");
300 breakpoints_changed ();
304 error ("No breakpoint number %d.", bnum
);
309 commands_command (arg
, from_tty
)
313 register struct breakpoint
*b
;
316 struct command_line
*l
;
318 /* If we allowed this, we would have problems with when to
319 free the storage, if we change the commands currently
322 if (executing_breakpoint_commands
)
323 error ("Can't use the \"commands\" command among a breakpoint's commands.");
326 bnum
= get_number (&p
);
328 error ("Unexpected extra arguments following breakpoint number.");
331 if (b
->number
== bnum
)
334 sprintf (tmpbuf
, "Type commands for when breakpoint %d is hit, one per line.", bnum
);
335 l
= read_command_lines (tmpbuf
, from_tty
);
336 free_command_lines (&b
->commands
);
338 breakpoints_changed ();
341 error ("No breakpoint number %d.", bnum
);
344 extern int memory_breakpoint_size
; /* from mem-break.c */
346 /* Like target_read_memory() but if breakpoints are inserted, return
347 the shadow contents instead of the breakpoints themselves.
349 Read "memory data" from whatever target or inferior we have.
350 Returns zero if successful, errno value if not. EIO is used
351 for address out of bounds. If breakpoints are inserted, returns
352 shadow contents, not the breakpoints themselves. From breakpoint.c. */
355 read_memory_nobpt (memaddr
, myaddr
, len
)
361 struct breakpoint
*b
;
363 if (memory_breakpoint_size
< 0)
364 /* No breakpoints on this machine. FIXME: This should be
365 dependent on the debugging target. Probably want
366 target_insert_breakpoint to return a size, saying how many
367 bytes of the shadow contents are used, or perhaps have
368 something like target_xfer_shadow. */
369 return target_read_memory (memaddr
, myaddr
, len
);
373 if (b
->type
== bp_watchpoint
374 || b
->type
== bp_hardware_watchpoint
375 || b
->type
== bp_read_watchpoint
376 || b
->type
== bp_access_watchpoint
379 else if (b
->address
+ memory_breakpoint_size
<= memaddr
)
380 /* The breakpoint is entirely before the chunk of memory
383 else if (b
->address
>= memaddr
+ len
)
384 /* The breakpoint is entirely after the chunk of memory we
389 /* Copy the breakpoint from the shadow contents, and recurse
390 for the things before and after. */
392 /* Addresses and length of the part of the breakpoint that
394 CORE_ADDR membpt
= b
->address
;
395 unsigned int bptlen
= memory_breakpoint_size
;
396 /* Offset within shadow_contents. */
399 if (membpt
< memaddr
)
401 /* Only copy the second part of the breakpoint. */
402 bptlen
-= memaddr
- membpt
;
403 bptoffset
= memaddr
- membpt
;
407 if (membpt
+ bptlen
> memaddr
+ len
)
409 /* Only copy the first part of the breakpoint. */
410 bptlen
-= (membpt
+ bptlen
) - (memaddr
+ len
);
413 memcpy (myaddr
+ membpt
- memaddr
,
414 b
->shadow_contents
+ bptoffset
, bptlen
);
416 if (membpt
> memaddr
)
418 /* Copy the section of memory before the breakpoint. */
419 status
= read_memory_nobpt (memaddr
, myaddr
, membpt
- memaddr
);
424 if (membpt
+ bptlen
< memaddr
+ len
)
426 /* Copy the section of memory after the breakpoint. */
427 status
= read_memory_nobpt
429 myaddr
+ membpt
+ bptlen
- memaddr
,
430 memaddr
+ len
- (membpt
+ bptlen
));
437 /* Nothing overlaps. Just call read_memory_noerr. */
438 return target_read_memory (memaddr
, myaddr
, len
);
441 /* insert_breakpoints is used when starting or continuing the program.
442 remove_breakpoints is used when the program stops.
443 Both return zero if successful,
444 or an `errno' value if could not write the inferior. */
447 insert_breakpoints ()
449 register struct breakpoint
*b
, *temp
;
451 int disabled_breaks
= 0;
453 ALL_BREAKPOINTS_SAFE (b
, temp
)
454 if (b
->type
!= bp_watchpoint
455 && b
->type
!= bp_hardware_watchpoint
456 && b
->type
!= bp_read_watchpoint
457 && b
->type
!= bp_access_watchpoint
458 && b
->enable
!= disabled
459 && b
->enable
!= shlib_disabled
463 if (b
->type
== bp_hardware_breakpoint
)
464 val
= target_insert_hw_breakpoint(b
->address
, b
->shadow_contents
);
466 val
= target_insert_breakpoint(b
->address
, b
->shadow_contents
);
469 /* Can't set the breakpoint. */
470 #if defined (DISABLE_UNSETTABLE_BREAK)
471 if (DISABLE_UNSETTABLE_BREAK (b
->address
))
474 b
->enable
= shlib_disabled
;
475 if (!disabled_breaks
)
477 target_terminal_ours_for_output ();
478 fprintf_unfiltered (gdb_stderr
,
479 "Cannot insert breakpoint %d:\n", b
->number
);
480 printf_filtered ("Temporarily disabling shared library breakpoints:\n");
483 printf_filtered ("%d ", b
->number
);
488 target_terminal_ours_for_output ();
489 fprintf_unfiltered (gdb_stderr
, "Cannot insert breakpoint %d:\n", b
->number
);
490 #ifdef ONE_PROCESS_WRITETEXT
491 fprintf_unfiltered (gdb_stderr
,
492 "The same program may be running in another process.\n");
494 memory_error (val
, b
->address
); /* which bombs us out */
500 else if ((b
->type
== bp_hardware_watchpoint
||
501 b
->type
== bp_read_watchpoint
||
502 b
->type
== bp_access_watchpoint
)
503 && b
->enable
== enabled
507 struct frame_info
*saved_frame
;
508 int saved_level
, within_current_scope
;
509 value_ptr mark
= value_mark ();
512 /* Save the current frame and level so we can restore it after
513 evaluating the watchpoint expression on its own frame. */
514 saved_frame
= selected_frame
;
515 saved_level
= selected_frame_level
;
517 /* Determine if the watchpoint is within scope. */
518 if (b
->exp_valid_block
== NULL
)
519 within_current_scope
= 1;
522 struct frame_info
*fi
=
523 find_frame_addr_in_frame_chain (b
->watchpoint_frame
);
524 within_current_scope
= (fi
!= NULL
);
525 if (within_current_scope
)
526 select_frame (fi
, -1);
529 if (within_current_scope
)
531 /* Evaluate the expression and cut the chain of values
532 produced off from the value chain. */
533 v
= evaluate_expression (b
->exp
);
534 value_release_to_mark (mark
);
539 /* Look at each value on the value chain. */
540 for ( ; v
; v
=v
->next
)
542 /* If it's a memory location, then we must watch it. */
543 if (v
->lval
== lval_memory
)
547 addr
= VALUE_ADDRESS (v
) + VALUE_OFFSET (v
);
548 len
= TYPE_LENGTH (VALUE_TYPE (v
));
550 if (b
->type
== bp_read_watchpoint
)
552 else if (b
->type
== bp_access_watchpoint
)
555 val
= target_insert_watchpoint (addr
, len
, type
);
564 /* Failure to insert a watchpoint on any memory value in the
565 value chain brings us here. */
567 warning ("Hardware watchpoint %d: Could not insert watchpoint\n",
573 Hardware watchpoint %d deleted because the program has left the block in\n\
574 which its expression is valid.\n", b
->number
);
575 if (b
->related_breakpoint
)
577 b
->related_breakpoint
->enable
= disable
;
578 b
->related_breakpoint
->disposition
= del_at_next_stop
;
581 b
->disposition
= del_at_next_stop
;
584 /* Restore the frame and level. */
585 select_frame (saved_frame
, saved_level
);
588 printf_filtered ("\n");
594 remove_breakpoints ()
596 register struct breakpoint
*b
;
603 val
= remove_breakpoint (b
);
613 remove_breakpoint (b
)
614 struct breakpoint
*b
;
618 if (b
->type
!= bp_watchpoint
619 && b
->type
!= bp_hardware_watchpoint
620 && b
->type
!= bp_read_watchpoint
621 && b
->type
!= bp_access_watchpoint
)
623 if (b
->type
== bp_hardware_breakpoint
)
624 val
= target_remove_hw_breakpoint(b
->address
, b
->shadow_contents
);
626 val
= target_remove_breakpoint(b
->address
, b
->shadow_contents
);
631 else if ((b
->type
== bp_hardware_watchpoint
||
632 b
->type
== bp_read_watchpoint
||
633 b
->type
== bp_access_watchpoint
)
634 && b
->enable
== enabled
640 /* Walk down the saved value chain. */
641 for (v
= b
->val_chain
; v
; v
= v
->next
)
643 /* For each memory reference remove the watchpoint
645 if (v
->lval
== lval_memory
)
649 addr
= VALUE_ADDRESS (v
) + VALUE_OFFSET (v
);
650 len
= TYPE_LENGTH (VALUE_TYPE (v
));
651 val
= target_remove_watchpoint (addr
, len
, b
->type
);
657 /* Failure to remove any of the hardware watchpoints comes here. */
659 warning ("Hardware watchpoint %d: Could not remove watchpoint\n",
662 /* Free the saved value chain. We will construct a new one
663 the next time the watchpoint is inserted. */
664 for (v
= b
->val_chain
; v
; v
= n
)
674 /* Clear the "inserted" flag in all breakpoints. */
677 mark_breakpoints_out ()
679 register struct breakpoint
*b
;
685 /* Clear the "inserted" flag in all breakpoints and delete any breakpoints
686 which should go away between runs of the program. */
689 breakpoint_init_inferior ()
691 register struct breakpoint
*b
, *temp
;
693 ALL_BREAKPOINTS_SAFE (b
, temp
)
700 case bp_watchpoint_scope
:
702 /* If the call dummy breakpoint is at the entry point it will
703 cause problems when the inferior is rerun, so we better
706 Also get rid of scope breakpoints. */
707 delete_breakpoint (b
);
711 case bp_hardware_watchpoint
:
712 case bp_read_watchpoint
:
713 case bp_access_watchpoint
:
715 /* Likewise for watchpoints on local expressions. */
716 if (b
->exp_valid_block
!= NULL
)
717 delete_breakpoint (b
);
726 /* breakpoint_here_p (PC) returns 1 if an enabled breakpoint exists at PC.
727 When continuing from a location with a breakpoint,
728 we actually single step once before calling insert_breakpoints. */
731 breakpoint_here_p (pc
)
734 register struct breakpoint
*b
;
737 if (b
->enable
!= disabled
738 && b
->enable
!= shlib_disabled
745 /* Return nonzero if FRAME is a dummy frame. We can't use PC_IN_CALL_DUMMY
746 because figuring out the saved SP would take too much time, at least using
747 get_saved_register on the 68k. This means that for this function to
748 work right a port must use the bp_call_dummy breakpoint. */
751 frame_in_dummy (frame
)
752 struct frame_info
*frame
;
754 struct breakpoint
*b
;
759 static unsigned LONGEST dummy
[] = CALL_DUMMY
;
761 if (b
->type
== bp_call_dummy
762 && b
->frame
== frame
->frame
764 /* We need to check the PC as well as the frame on the sparc,
765 for signals.exp in the testsuite. */
768 - sizeof (dummy
) / sizeof (LONGEST
) * REGISTER_SIZE
))
769 && frame
->pc
<= b
->address
)
772 #endif /* CALL_DUMMY */
776 /* breakpoint_match_thread (PC, PID) returns true if the breakpoint at PC
777 is valid for process/thread PID. */
780 breakpoint_thread_match (pc
, pid
)
784 struct breakpoint
*b
;
787 thread
= pid_to_thread_id (pid
);
790 if (b
->enable
!= disabled
791 && b
->enable
!= shlib_disabled
793 && (b
->thread
== -1 || b
->thread
== thread
))
800 /* bpstat stuff. External routines' interfaces are documented
803 /* Clear a bpstat so that it says we are not at any breakpoint.
804 Also free any storage that is part of a bpstat. */
819 if (p
->old_val
!= NULL
)
820 value_free (p
->old_val
);
827 /* Return a copy of a bpstat. Like "bs1 = bs2" but all storage that
828 is part of the bpstat is copied as well. */
836 bpstat retval
= NULL
;
841 for (; bs
!= NULL
; bs
= bs
->next
)
843 tmp
= (bpstat
) xmalloc (sizeof (*tmp
));
844 memcpy (tmp
, bs
, sizeof (*tmp
));
846 /* This is the first thing in the chain. */
856 /* Find the bpstat associated with this breakpoint */
859 bpstat_find_breakpoint(bsp
, breakpoint
)
861 struct breakpoint
*breakpoint
;
863 if (bsp
== NULL
) return NULL
;
865 for (;bsp
!= NULL
; bsp
= bsp
->next
) {
866 if (bsp
->breakpoint_at
== breakpoint
) return bsp
;
871 /* Return the breakpoint number of the first breakpoint we are stopped
872 at. *BSP upon return is a bpstat which points to the remaining
873 breakpoints stopped at (but which is not guaranteed to be good for
874 anything but further calls to bpstat_num).
875 Return 0 if passed a bpstat which does not indicate any breakpoints. */
881 struct breakpoint
*b
;
884 return 0; /* No more breakpoint values */
887 b
= (*bsp
)->breakpoint_at
;
890 return -1; /* breakpoint that's been deleted since */
892 return b
->number
; /* We have its number */
896 /* Modify BS so that the actions will not be performed. */
899 bpstat_clear_actions (bs
)
902 for (; bs
!= NULL
; bs
= bs
->next
)
905 if (bs
->old_val
!= NULL
)
907 value_free (bs
->old_val
);
913 /* Stub for cleaning up our state if we error-out of a breakpoint command */
916 cleanup_executing_breakpoints (ignore
)
919 executing_breakpoint_commands
= 0;
922 /* Execute all the commands associated with all the breakpoints at this
923 location. Any of these commands could cause the process to proceed
924 beyond this point, etc. We look out for such changes by checking
925 the global "breakpoint_proceeded" after each command. */
928 bpstat_do_actions (bsp
)
932 struct cleanup
*old_chain
;
933 struct command_line
*cmd
;
935 executing_breakpoint_commands
= 1;
936 old_chain
= make_cleanup (cleanup_executing_breakpoints
, 0);
941 breakpoint_proceeded
= 0;
942 for (; bs
!= NULL
; bs
= bs
->next
)
947 execute_control_command (cmd
);
950 if (breakpoint_proceeded
)
951 /* The inferior is proceeded by the command; bomb out now.
952 The bpstat chain has been blown away by wait_for_inferior.
953 But since execution has stopped again, there is a new bpstat
954 to look at, so start over. */
960 executing_breakpoint_commands
= 0;
961 discard_cleanups (old_chain
);
964 /* This is the normal print_it function for a bpstat. In the future,
965 much of this logic could (should?) be moved to bpstat_stop_status,
966 by having it set different print_it functions. */
972 /* bs->breakpoint_at can be NULL if it was a momentary breakpoint
973 which has since been deleted. */
974 if (bs
->breakpoint_at
== NULL
975 || (bs
->breakpoint_at
->type
!= bp_breakpoint
976 && bs
->breakpoint_at
->type
!= bp_hardware_breakpoint
977 && bs
->breakpoint_at
->type
!= bp_watchpoint
978 && bs
->breakpoint_at
->type
!= bp_read_watchpoint
979 && bs
->breakpoint_at
->type
!= bp_access_watchpoint
980 && bs
->breakpoint_at
->type
!= bp_hardware_watchpoint
))
983 if (bs
->breakpoint_at
->type
== bp_breakpoint
||
984 bs
->breakpoint_at
->type
== bp_hardware_breakpoint
)
986 /* I think the user probably only wants to see one breakpoint
987 number, not all of them. */
988 annotate_breakpoint (bs
->breakpoint_at
->number
);
989 printf_filtered ("\nBreakpoint %d, ", bs
->breakpoint_at
->number
);
992 else if ((bs
->old_val
!= NULL
) &&
993 (bs
->breakpoint_at
->type
== bp_watchpoint
||
994 bs
->breakpoint_at
->type
== bp_access_watchpoint
||
995 bs
->breakpoint_at
->type
== bp_hardware_watchpoint
))
997 annotate_watchpoint (bs
->breakpoint_at
->number
);
998 mention (bs
->breakpoint_at
);
999 printf_filtered ("\nOld value = ");
1000 value_print (bs
->old_val
, gdb_stdout
, 0, Val_pretty_default
);
1001 printf_filtered ("\nNew value = ");
1002 value_print (bs
->breakpoint_at
->val
, gdb_stdout
, 0,
1003 Val_pretty_default
);
1004 printf_filtered ("\n");
1005 value_free (bs
->old_val
);
1007 /* More than one watchpoint may have been triggered. */
1010 else if (bs
->breakpoint_at
->type
== bp_access_watchpoint
||
1011 bs
->breakpoint_at
->type
== bp_read_watchpoint
)
1013 mention (bs
->breakpoint_at
);
1014 printf_filtered ("\nValue = ");
1015 value_print (bs
->breakpoint_at
->val
, gdb_stdout
, 0,
1016 Val_pretty_default
);
1017 printf_filtered ("\n");
1020 /* We can't deal with it. Maybe another member of the bpstat chain can. */
1024 /* Print a message indicating what happened. Returns nonzero to
1025 say that only the source line should be printed after this (zero
1026 return means print the frame as well as the source line). */
1027 /* Currently we always return zero. */
1037 val
= (*bs
->print_it
) (bs
);
1041 /* Maybe another breakpoint in the chain caused us to stop.
1042 (Currently all watchpoints go on the bpstat whether hit or
1043 not. That probably could (should) be changed, provided care is taken
1044 with respect to bpstat_explains_signal). */
1046 return bpstat_print (bs
->next
);
1048 /* We reached the end of the chain without printing anything. */
1052 /* Evaluate the expression EXP and return 1 if value is zero.
1053 This is used inside a catch_errors to evaluate the breakpoint condition.
1054 The argument is a "struct expression *" that has been cast to char * to
1055 make it pass through catch_errors. */
1058 breakpoint_cond_eval (exp
)
1061 value_ptr mark
= value_mark ();
1062 int i
= !value_true (evaluate_expression ((struct expression
*)exp
));
1063 value_free_to_mark (mark
);
1067 /* Allocate a new bpstat and chain it to the current one. */
1070 bpstat_alloc (b
, cbs
)
1071 register struct breakpoint
*b
;
1072 bpstat cbs
; /* Current "bs" value */
1076 bs
= (bpstat
) xmalloc (sizeof (*bs
));
1078 bs
->breakpoint_at
= b
;
1079 /* If the condition is false, etc., don't do the commands. */
1080 bs
->commands
= NULL
;
1082 bs
->print_it
= print_it_normal
;
1086 /* Possible return values for watchpoint_check (this can't be an enum
1087 because of check_errors). */
1088 /* The watchpoint has been deleted. */
1089 #define WP_DELETED 1
1090 /* The value has changed. */
1091 #define WP_VALUE_CHANGED 2
1092 /* The value has not changed. */
1093 #define WP_VALUE_NOT_CHANGED 3
1095 #define BP_TEMPFLAG 1
1096 #define BP_HARDWAREFLAG 2
1098 /* Check watchpoint condition. */
1101 watchpoint_check (p
)
1104 bpstat bs
= (bpstat
) p
;
1105 struct breakpoint
*b
;
1106 struct frame_info
*fr
;
1107 int within_current_scope
;
1109 b
= bs
->breakpoint_at
;
1111 if (b
->exp_valid_block
== NULL
)
1112 within_current_scope
= 1;
1115 /* There is no current frame at this moment. If we're going to have
1116 any chance of handling watchpoints on local variables, we'll need
1117 the frame chain (so we can determine if we're in scope). */
1118 reinit_frame_cache();
1119 fr
= find_frame_addr_in_frame_chain (b
->watchpoint_frame
);
1120 within_current_scope
= (fr
!= NULL
);
1121 if (within_current_scope
)
1122 /* If we end up stopping, the current frame will get selected
1123 in normal_stop. So this call to select_frame won't affect
1125 select_frame (fr
, -1);
1128 if (within_current_scope
)
1130 /* We use value_{,free_to_}mark because it could be a
1131 *long* time before we return to the command level and
1132 call free_all_values. We can't call free_all_values because
1133 we might be in the middle of evaluating a function call. */
1135 value_ptr mark
= value_mark ();
1136 value_ptr new_val
= evaluate_expression (bs
->breakpoint_at
->exp
);
1137 if (!value_equal (b
->val
, new_val
))
1139 release_value (new_val
);
1140 value_free_to_mark (mark
);
1141 bs
->old_val
= b
->val
;
1143 /* We will stop here */
1144 return WP_VALUE_CHANGED
;
1148 /* Nothing changed, don't do anything. */
1149 value_free_to_mark (mark
);
1150 /* We won't stop here */
1151 return WP_VALUE_NOT_CHANGED
;
1156 /* This seems like the only logical thing to do because
1157 if we temporarily ignored the watchpoint, then when
1158 we reenter the block in which it is valid it contains
1159 garbage (in the case of a function, it may have two
1160 garbage values, one before and one after the prologue).
1161 So we can't even detect the first assignment to it and
1162 watch after that (since the garbage may or may not equal
1163 the first value assigned). */
1165 Watchpoint %d deleted because the program has left the block in\n\
1166 which its expression is valid.\n", bs
->breakpoint_at
->number
);
1167 if (b
->related_breakpoint
)
1169 b
->related_breakpoint
->enable
= disable
;
1170 b
->related_breakpoint
->disposition
= del_at_next_stop
;
1172 b
->enable
= disable
;
1173 b
->disposition
= del_at_next_stop
;
1179 /* This is used when everything which needs to be printed has
1180 already been printed. But we still want to print the frame. */
1188 /* This is used when nothing should be printed for this bpstat entry. */
1197 /* Get a bpstat associated with having just stopped at address *PC
1198 and frame address CORE_ADDRESS. Update *PC to point at the
1199 breakpoint (if we hit a breakpoint). NOT_A_BREAKPOINT is nonzero
1200 if this is known to not be a real breakpoint (it could still be a
1201 watchpoint, though). */
1203 /* Determine whether we stopped at a breakpoint, etc, or whether we
1204 don't understand this stop. Result is a chain of bpstat's such that:
1206 if we don't understand the stop, the result is a null pointer.
1208 if we understand why we stopped, the result is not null.
1210 Each element of the chain refers to a particular breakpoint or
1211 watchpoint at which we have stopped. (We may have stopped for
1212 several reasons concurrently.)
1214 Each element of the chain has valid next, breakpoint_at,
1215 commands, FIXME??? fields.
1220 bpstat_stop_status (pc
, not_a_breakpoint
)
1222 int not_a_breakpoint
;
1224 register struct breakpoint
*b
, *temp
;
1226 #if DECR_PC_AFTER_BREAK != 0 || defined (SHIFT_INST_REGS)
1227 /* True if we've hit a breakpoint (as opposed to a watchpoint). */
1228 int real_breakpoint
= 0;
1230 /* Root of the chain of bpstat's */
1231 struct bpstats root_bs
[1];
1232 /* Pointer to the last thing in the chain currently. */
1233 bpstat bs
= root_bs
;
1234 static char message1
[] =
1235 "Error evaluating expression for watchpoint %d\n";
1236 char message
[sizeof (message1
) + 30 /* slop */];
1238 /* Get the address where the breakpoint would have been. */
1239 bp_addr
= *pc
- DECR_PC_AFTER_BREAK
;
1241 ALL_BREAKPOINTS_SAFE (b
, temp
)
1243 if (b
->enable
== disabled
1244 || b
->enable
== shlib_disabled
)
1247 if (b
->type
!= bp_watchpoint
1248 && b
->type
!= bp_hardware_watchpoint
1249 && b
->type
!= bp_read_watchpoint
1250 && b
->type
!= bp_access_watchpoint
1251 && b
->type
!= bp_hardware_breakpoint
1252 && b
->address
!= bp_addr
)
1255 if (b
->type
== bp_hardware_breakpoint
1256 && b
->address
!= (bp_addr
- DECR_PC_AFTER_HW_BREAK
))
1259 if (b
->type
!= bp_watchpoint
1260 && b
->type
!= bp_hardware_watchpoint
1261 && b
->type
!= bp_read_watchpoint
1262 && b
->type
!= bp_access_watchpoint
1263 && not_a_breakpoint
)
1266 /* Come here if it's a watchpoint, or if the break address matches */
1270 bs
= bpstat_alloc (b
, bs
); /* Alloc a bpstat to explain stop */
1275 sprintf (message
, message1
, b
->number
);
1276 if (b
->type
== bp_watchpoint
|| b
->type
== bp_hardware_watchpoint
)
1278 switch (catch_errors (watchpoint_check
, (char *) bs
, message
,
1282 /* We've already printed what needs to be printed. */
1283 bs
->print_it
= print_it_done
;
1286 case WP_VALUE_CHANGED
:
1289 case WP_VALUE_NOT_CHANGED
:
1291 bs
->print_it
= print_it_noop
;
1298 /* Error from catch_errors. */
1299 printf_filtered ("Watchpoint %d deleted.\n", b
->number
);
1300 if (b
->related_breakpoint
)
1302 b
->related_breakpoint
->enable
= disable
;
1303 b
->related_breakpoint
->disposition
= del_at_next_stop
;
1305 b
->enable
= disable
;
1306 b
->disposition
= del_at_next_stop
;
1307 /* We've already printed what needs to be printed. */
1308 bs
->print_it
= print_it_done
;
1314 else if (b
->type
== bp_read_watchpoint
|| b
->type
== bp_access_watchpoint
)
1320 addr
= target_stopped_data_address();
1321 if (addr
== 0) continue;
1322 for (v
= b
->val_chain
; v
; v
= v
->next
)
1324 if (v
->lval
== lval_memory
)
1328 vaddr
= VALUE_ADDRESS (v
) + VALUE_OFFSET (v
);
1334 switch (catch_errors (watchpoint_check
, (char *) bs
, message
,
1338 /* We've already printed what needs to be printed. */
1339 bs
->print_it
= print_it_done
;
1342 case WP_VALUE_CHANGED
:
1343 case WP_VALUE_NOT_CHANGED
:
1349 /* Error from catch_errors. */
1350 printf_filtered ("Watchpoint %d deleted.\n", b
->number
);
1351 if (b
->related_breakpoint
)
1353 b
->related_breakpoint
->enable
= disable
;
1354 b
->related_breakpoint
->disposition
= del_at_next_stop
;
1356 b
->enable
= disable
;
1357 b
->disposition
= del_at_next_stop
;
1358 /* We've already printed what needs to be printed. */
1359 bs
->print_it
= print_it_done
;
1363 #if DECR_PC_AFTER_BREAK != 0 || defined (SHIFT_INST_REGS)
1365 real_breakpoint
= 1;
1368 if (b
->frame
&& b
->frame
!= (get_current_frame ())->frame
)
1372 int value_is_zero
= 0;
1376 /* Need to select the frame, with all that implies
1377 so that the conditions will have the right context. */
1378 select_frame (get_current_frame (), 0);
1380 = catch_errors (breakpoint_cond_eval
, (char *)(b
->cond
),
1381 "Error in testing breakpoint condition:\n",
1383 /* FIXME-someday, should give breakpoint # */
1386 if (b
->cond
&& value_is_zero
)
1390 else if (b
->ignore_count
> 0)
1397 /* We will stop here */
1398 if (b
->disposition
== disable
)
1399 b
->enable
= disabled
;
1400 bs
->commands
= b
->commands
;
1403 if (bs
->commands
&& STREQ ("silent", bs
->commands
->line
))
1405 bs
->commands
= bs
->commands
->next
;
1410 /* Print nothing for this entry if we dont stop or if we dont print. */
1411 if (bs
->stop
== 0 || bs
->print
== 0)
1412 bs
->print_it
= print_it_noop
;
1415 bs
->next
= NULL
; /* Terminate the chain */
1416 bs
= root_bs
->next
; /* Re-grab the head of the chain */
1417 #if DECR_PC_AFTER_BREAK != 0 || defined (SHIFT_INST_REGS)
1420 if (real_breakpoint
)
1423 #if defined (SHIFT_INST_REGS)
1425 #else /* No SHIFT_INST_REGS. */
1427 #endif /* No SHIFT_INST_REGS. */
1430 #endif /* DECR_PC_AFTER_BREAK != 0. */
1432 /* The value of a hardware watchpoint hasn't changed, but the
1433 intermediate memory locations we are watching may have. */
1434 if (bs
&& ! bs
->stop
&&
1435 (bs
->breakpoint_at
->type
== bp_hardware_watchpoint
||
1436 bs
->breakpoint_at
->type
== bp_read_watchpoint
||
1437 bs
->breakpoint_at
->type
== bp_access_watchpoint
))
1439 remove_breakpoints ();
1440 insert_breakpoints ();
1445 /* Tell what to do about this bpstat. */
1450 /* Classify each bpstat as one of the following. */
1452 /* This bpstat element has no effect on the main_action. */
1455 /* There was a watchpoint, stop but don't print. */
1458 /* There was a watchpoint, stop and print. */
1461 /* There was a breakpoint but we're not stopping. */
1464 /* There was a breakpoint, stop but don't print. */
1467 /* There was a breakpoint, stop and print. */
1470 /* We hit the longjmp breakpoint. */
1473 /* We hit the longjmp_resume breakpoint. */
1476 /* We hit the step_resume breakpoint. */
1479 /* We hit the through_sigtramp breakpoint. */
1482 /* We hit the shared library event breakpoint. */
1485 /* This is just used to count how many enums there are. */
1489 /* Here is the table which drives this routine. So that we can
1490 format it pretty, we define some abbreviations for the
1491 enum bpstat_what codes. */
1492 #define kc BPSTAT_WHAT_KEEP_CHECKING
1493 #define ss BPSTAT_WHAT_STOP_SILENT
1494 #define sn BPSTAT_WHAT_STOP_NOISY
1495 #define sgl BPSTAT_WHAT_SINGLE
1496 #define slr BPSTAT_WHAT_SET_LONGJMP_RESUME
1497 #define clr BPSTAT_WHAT_CLEAR_LONGJMP_RESUME
1498 #define clrs BPSTAT_WHAT_CLEAR_LONGJMP_RESUME_SINGLE
1499 #define sr BPSTAT_WHAT_STEP_RESUME
1500 #define ts BPSTAT_WHAT_THROUGH_SIGTRAMP
1501 #define shl BPSTAT_WHAT_CHECK_SHLIBS
1503 /* "Can't happen." Might want to print an error message.
1504 abort() is not out of the question, but chances are GDB is just
1505 a bit confused, not unusable. */
1506 #define err BPSTAT_WHAT_STOP_NOISY
1508 /* Given an old action and a class, come up with a new action. */
1509 /* One interesting property of this table is that wp_silent is the same
1510 as bp_silent and wp_noisy is the same as bp_noisy. That is because
1511 after stopping, the check for whether to step over a breakpoint
1512 (BPSTAT_WHAT_SINGLE type stuff) is handled in proceed() without
1513 reference to how we stopped. We retain separate wp_silent and bp_silent
1514 codes in case we want to change that someday. */
1516 /* step_resume entries: a step resume breakpoint overrides another
1517 breakpoint of signal handling (see comment in wait_for_inferior
1518 at first IN_SIGTRAMP where we set the step_resume breakpoint). */
1519 /* We handle the through_sigtramp_breakpoint the same way; having both
1520 one of those and a step_resume_breakpoint is probably very rare (?). */
1522 static const enum bpstat_what_main_action
1523 table
[(int)class_last
][(int)BPSTAT_WHAT_LAST
] =
1526 /* kc ss sn sgl slr clr clrs sr ts shl
1528 /*no_effect*/ {kc
, ss
, sn
, sgl
, slr
, clr
, clrs
, sr
, ts
, shl
},
1529 /*wp_silent*/ {ss
, ss
, sn
, ss
, ss
, ss
, ss
, sr
, ts
, shl
},
1530 /*wp_noisy*/ {sn
, sn
, sn
, sn
, sn
, sn
, sn
, sr
, ts
, shl
},
1531 /*bp_nostop*/ {sgl
, ss
, sn
, sgl
, slr
, clrs
, clrs
, sr
, ts
, shl
},
1532 /*bp_silent*/ {ss
, ss
, sn
, ss
, ss
, ss
, ss
, sr
, ts
, shl
},
1533 /*bp_noisy*/ {sn
, sn
, sn
, sn
, sn
, sn
, sn
, sr
, ts
, shl
},
1534 /*long_jump*/ {slr
, ss
, sn
, slr
, err
, err
, err
, sr
, ts
, shl
},
1535 /*long_resume*/ {clr
, ss
, sn
, clrs
, err
, err
, err
, sr
, ts
, shl
},
1536 /*step_resume*/ {sr
, sr
, sr
, sr
, sr
, sr
, sr
, sr
, ts
, shl
},
1537 /*through_sig*/ {ts
, ts
, ts
, ts
, ts
, ts
, ts
, ts
, ts
, shl
},
1538 /*shlib*/ {shl
, shl
, shl
, shl
, shl
, shl
, shl
, shl
, ts
, shl
}
1551 enum bpstat_what_main_action current_action
= BPSTAT_WHAT_KEEP_CHECKING
;
1552 struct bpstat_what retval
;
1554 retval
.call_dummy
= 0;
1555 for (; bs
!= NULL
; bs
= bs
->next
)
1557 enum class bs_class
= no_effect
;
1558 if (bs
->breakpoint_at
== NULL
)
1559 /* I suspect this can happen if it was a momentary breakpoint
1560 which has since been deleted. */
1562 switch (bs
->breakpoint_at
->type
)
1565 case bp_hardware_breakpoint
:
1571 bs_class
= bp_noisy
;
1573 bs_class
= bp_silent
;
1576 bs_class
= bp_nostop
;
1579 case bp_hardware_watchpoint
:
1580 case bp_read_watchpoint
:
1581 case bp_access_watchpoint
:
1585 bs_class
= wp_noisy
;
1587 bs_class
= wp_silent
;
1590 /* There was a watchpoint, but we're not stopping. This requires
1591 no further action. */
1592 bs_class
= no_effect
;
1595 bs_class
= long_jump
;
1597 case bp_longjmp_resume
:
1598 bs_class
= long_resume
;
1600 case bp_step_resume
:
1603 bs_class
= step_resume
;
1606 /* It is for the wrong frame. */
1607 bs_class
= bp_nostop
;
1609 case bp_through_sigtramp
:
1610 bs_class
= through_sig
;
1612 case bp_watchpoint_scope
:
1613 bs_class
= bp_nostop
;
1615 case bp_shlib_event
:
1616 bs_class
= shlib_event
;
1619 /* Make sure the action is stop (silent or noisy), so infrun.c
1620 pops the dummy frame. */
1621 bs_class
= bp_silent
;
1622 retval
.call_dummy
= 1;
1625 current_action
= table
[(int)bs_class
][(int)current_action
];
1627 retval
.main_action
= current_action
;
1631 /* Nonzero if we should step constantly (e.g. watchpoints on machines
1632 without hardware support). This isn't related to a specific bpstat,
1633 just to things like whether watchpoints are set. */
1636 bpstat_should_step ()
1638 struct breakpoint
*b
;
1640 if (b
->enable
== enabled
&& b
->type
== bp_watchpoint
)
1645 /* Print information on breakpoint number BNUM, or -1 if all.
1646 If WATCHPOINTS is zero, process only breakpoints; if WATCHPOINTS
1647 is nonzero, process only watchpoints. */
1650 breakpoint_1 (bnum
, allflag
)
1654 register struct breakpoint
*b
;
1655 register struct command_line
*l
;
1656 register struct symbol
*sym
;
1657 CORE_ADDR last_addr
= (CORE_ADDR
)-1;
1658 int found_a_breakpoint
= 0;
1659 static char *bptypes
[] = {"breakpoint", "hw breakpoint",
1660 "until", "finish", "watchpoint",
1661 "hw watchpoint", "read watchpoint",
1662 "acc watchpoint", "longjmp",
1663 "longjmp resume", "step resume",
1665 "watchpoint scope", "call dummy",
1667 static char *bpdisps
[] = {"del", "dstp", "dis", "keep"};
1668 static char bpenables
[] = "ny";
1669 char wrap_indent
[80];
1673 || bnum
== b
->number
)
1675 /* We only print out user settable breakpoints unless the allflag is set. */
1677 && b
->type
!= bp_breakpoint
1678 && b
->type
!= bp_hardware_breakpoint
1679 && b
->type
!= bp_watchpoint
1680 && b
->type
!= bp_read_watchpoint
1681 && b
->type
!= bp_access_watchpoint
1682 && b
->type
!= bp_hardware_watchpoint
)
1685 if (!found_a_breakpoint
++)
1687 annotate_breakpoints_headers ();
1690 printf_filtered ("Num ");
1692 printf_filtered ("Type ");
1694 printf_filtered ("Disp ");
1696 printf_filtered ("Enb ");
1700 printf_filtered ("Address ");
1703 printf_filtered ("What\n");
1705 annotate_breakpoints_table ();
1710 printf_filtered ("%-3d ", b
->number
);
1712 printf_filtered ("%-14s ", bptypes
[(int)b
->type
]);
1714 printf_filtered ("%-4s ", bpdisps
[(int)b
->disposition
]);
1716 printf_filtered ("%-3c ", bpenables
[(int)b
->enable
]);
1718 strcpy (wrap_indent
, " ");
1720 strcat (wrap_indent
, " ");
1724 case bp_hardware_watchpoint
:
1725 case bp_read_watchpoint
:
1726 case bp_access_watchpoint
:
1727 /* Field 4, the address, is omitted (which makes the columns
1728 not line up too nicely with the headers, but the effect
1729 is relatively readable). */
1731 print_expression (b
->exp
, gdb_stdout
);
1735 case bp_hardware_breakpoint
:
1739 case bp_longjmp_resume
:
1740 case bp_step_resume
:
1741 case bp_through_sigtramp
:
1742 case bp_watchpoint_scope
:
1744 case bp_shlib_event
:
1748 /* FIXME-32x64: need a print_address_numeric with
1752 local_hex_string_custom
1753 ((unsigned long) b
->address
, "08l"));
1758 last_addr
= b
->address
;
1761 sym
= find_pc_function (b
->address
);
1764 fputs_filtered ("in ", gdb_stdout
);
1765 fputs_filtered (SYMBOL_SOURCE_NAME (sym
), gdb_stdout
);
1766 wrap_here (wrap_indent
);
1767 fputs_filtered (" at ", gdb_stdout
);
1769 fputs_filtered (b
->source_file
, gdb_stdout
);
1770 printf_filtered (":%d", b
->line_number
);
1773 print_address_symbolic (b
->address
, gdb_stdout
, demangle
, " ");
1777 printf_filtered ("\n");
1783 printf_filtered ("\tstop only in stack frame at ");
1784 print_address_numeric (b
->frame
, 1, gdb_stdout
);
1785 printf_filtered ("\n");
1792 printf_filtered ("\tstop only if ");
1793 print_expression (b
->cond
, gdb_stdout
);
1794 printf_filtered ("\n");
1797 if (show_breakpoint_hit_counts
&& b
->hit_count
)
1799 /* FIXME should make an annotation for this */
1801 printf_filtered ("\tbreakpoint already hit %d time%s\n",
1802 b
->hit_count
, (b
->hit_count
== 1 ? "" : "s"));
1805 if (b
->ignore_count
)
1809 printf_filtered ("\tignore next %d hits\n", b
->ignore_count
);
1812 if ((l
= b
->commands
))
1818 print_command_line (l
, 4);
1824 if (!found_a_breakpoint
)
1827 printf_filtered ("No breakpoints or watchpoints.\n");
1829 printf_filtered ("No breakpoint or watchpoint number %d.\n", bnum
);
1832 /* Compare against (CORE_ADDR)-1 in case some compiler decides
1833 that a comparison of an unsigned with -1 is always false. */
1834 if (last_addr
!= (CORE_ADDR
)-1)
1835 set_next_address (last_addr
);
1837 annotate_breakpoints_table_end ();
1842 breakpoints_info (bnum_exp
, from_tty
)
1849 bnum
= parse_and_eval_address (bnum_exp
);
1851 breakpoint_1 (bnum
, 0);
1854 #if MAINTENANCE_CMDS
1858 maintenance_info_breakpoints (bnum_exp
, from_tty
)
1865 bnum
= parse_and_eval_address (bnum_exp
);
1867 breakpoint_1 (bnum
, 1);
1872 /* Print a message describing any breakpoints set at PC. */
1875 describe_other_breakpoints (pc
)
1876 register CORE_ADDR pc
;
1878 register int others
= 0;
1879 register struct breakpoint
*b
;
1882 if (b
->address
== pc
)
1886 printf_filtered ("Note: breakpoint%s ", (others
> 1) ? "s" : "");
1888 if (b
->address
== pc
)
1894 ((b
->enable
== disabled
|| b
->enable
== shlib_disabled
)
1895 ? " (disabled)" : ""),
1896 (others
> 1) ? "," : ((others
== 1) ? " and" : ""));
1898 printf_filtered ("also set at pc ");
1899 print_address_numeric (pc
, 1, gdb_stdout
);
1900 printf_filtered (".\n");
1904 /* Set the default place to put a breakpoint
1905 for the `break' command with no arguments. */
1908 set_default_breakpoint (valid
, addr
, symtab
, line
)
1911 struct symtab
*symtab
;
1914 default_breakpoint_valid
= valid
;
1915 default_breakpoint_address
= addr
;
1916 default_breakpoint_symtab
= symtab
;
1917 default_breakpoint_line
= line
;
1920 /* Rescan breakpoints at address ADDRESS,
1921 marking the first one as "first" and any others as "duplicates".
1922 This is so that the bpt instruction is only inserted once. */
1925 check_duplicates (address
)
1928 register struct breakpoint
*b
;
1929 register int count
= 0;
1931 if (address
== 0) /* Watchpoints are uninteresting */
1935 if (b
->enable
!= disabled
1936 && b
->enable
!= shlib_disabled
1937 && b
->address
== address
)
1940 b
->duplicate
= count
> 1;
1944 /* Low level routine to set a breakpoint.
1945 Takes as args the three things that every breakpoint must have.
1946 Returns the breakpoint object so caller can set other things.
1947 Does not set the breakpoint number!
1948 Does not print anything.
1950 ==> This routine should not be called if there is a chance of later
1951 error(); otherwise it leaves a bogus breakpoint on the chain. Validate
1952 your arguments BEFORE calling this routine! */
1954 static struct breakpoint
*
1955 set_raw_breakpoint (sal
)
1956 struct symtab_and_line sal
;
1958 register struct breakpoint
*b
, *b1
;
1960 b
= (struct breakpoint
*) xmalloc (sizeof (struct breakpoint
));
1961 memset (b
, 0, sizeof (*b
));
1962 b
->address
= sal
.pc
;
1963 if (sal
.symtab
== NULL
)
1964 b
->source_file
= NULL
;
1966 b
->source_file
= savestring (sal
.symtab
->filename
,
1967 strlen (sal
.symtab
->filename
));
1968 b
->language
= current_language
->la_language
;
1969 b
->input_radix
= input_radix
;
1971 b
->line_number
= sal
.line
;
1972 b
->enable
= enabled
;
1975 b
->ignore_count
= 0;
1979 /* Add this breakpoint to the end of the chain
1980 so that a list of breakpoints will come out in order
1981 of increasing numbers. */
1983 b1
= breakpoint_chain
;
1985 breakpoint_chain
= b
;
1993 check_duplicates (sal
.pc
);
1994 breakpoints_changed ();
1999 static int internal_breakpoint_number
= -1;
2001 #ifdef GET_LONGJMP_TARGET
2004 create_longjmp_breakpoint (func_name
)
2007 struct symtab_and_line sal
;
2008 struct breakpoint
*b
;
2010 if (func_name
!= NULL
)
2012 struct minimal_symbol
*m
;
2014 m
= lookup_minimal_symbol_text (func_name
, NULL
, (struct objfile
*)NULL
);
2016 sal
.pc
= SYMBOL_VALUE_ADDRESS (m
);
2026 b
= set_raw_breakpoint (sal
);
2029 b
->type
= func_name
!= NULL
? bp_longjmp
: bp_longjmp_resume
;
2030 b
->disposition
= donttouch
;
2031 b
->enable
= disabled
;
2034 b
->addr_string
= strsave(func_name
);
2035 b
->number
= internal_breakpoint_number
--;
2038 #endif /* #ifdef GET_LONGJMP_TARGET */
2040 /* Call this routine when stepping and nexting to enable a breakpoint if we do
2041 a longjmp(). When we hit that breakpoint, call
2042 set_longjmp_resume_breakpoint() to figure out where we are going. */
2045 enable_longjmp_breakpoint()
2047 register struct breakpoint
*b
;
2050 if (b
->type
== bp_longjmp
)
2052 b
->enable
= enabled
;
2053 check_duplicates (b
->address
);
2058 disable_longjmp_breakpoint()
2060 register struct breakpoint
*b
;
2063 if ( b
->type
== bp_longjmp
2064 || b
->type
== bp_longjmp_resume
)
2066 b
->enable
= disabled
;
2067 check_duplicates (b
->address
);
2073 remove_solib_event_breakpoints ()
2075 register struct breakpoint
*b
, *temp
;
2077 ALL_BREAKPOINTS_SAFE (b
, temp
)
2078 if (b
->type
== bp_shlib_event
)
2079 delete_breakpoint (b
);
2083 create_solib_event_breakpoint (address
)
2086 struct breakpoint
*b
;
2087 struct symtab_and_line sal
;
2092 b
= set_raw_breakpoint (sal
);
2093 b
->number
= internal_breakpoint_number
--;
2094 b
->disposition
= donttouch
;
2095 b
->type
= bp_shlib_event
;
2098 /* Try to reenable any breakpoints in shared libraries. */
2100 re_enable_breakpoints_in_shlibs ()
2102 struct breakpoint
*b
;
2105 if (b
->enable
== shlib_disabled
)
2109 /* Do not reenable the breakpoint if the shared library
2110 is still not mapped in. */
2111 if (target_read_memory (b
->address
, buf
, 1) == 0)
2112 b
->enable
= enabled
;
2119 hw_breakpoint_used_count()
2121 register struct breakpoint
*b
;
2126 if (b
->type
== bp_hardware_breakpoint
&& b
->enable
== enabled
)
2134 hw_watchpoint_used_count(type
, other_type_used
)
2136 int *other_type_used
;
2138 register struct breakpoint
*b
;
2141 *other_type_used
= 0;
2144 if (b
->enable
== enabled
)
2146 if (b
->type
== type
) i
++;
2147 else if ((b
->type
== bp_hardware_watchpoint
||
2148 b
->type
== bp_read_watchpoint
||
2149 b
->type
== bp_access_watchpoint
)
2150 && b
->enable
== enabled
)
2151 *other_type_used
= 1;
2157 /* Call this after hitting the longjmp() breakpoint. Use this to set a new
2158 breakpoint at the target of the jmp_buf.
2160 FIXME - This ought to be done by setting a temporary breakpoint that gets
2161 deleted automatically...
2165 set_longjmp_resume_breakpoint(pc
, frame
)
2167 struct frame_info
*frame
;
2169 register struct breakpoint
*b
;
2172 if (b
->type
== bp_longjmp_resume
)
2175 b
->enable
= enabled
;
2177 b
->frame
= frame
->frame
;
2180 check_duplicates (b
->address
);
2185 /* Set a breakpoint that will evaporate an end of command
2186 at address specified by SAL.
2187 Restrict it to frame FRAME if FRAME is nonzero. */
2190 set_momentary_breakpoint (sal
, frame
, type
)
2191 struct symtab_and_line sal
;
2192 struct frame_info
*frame
;
2195 register struct breakpoint
*b
;
2196 b
= set_raw_breakpoint (sal
);
2198 b
->enable
= enabled
;
2199 b
->disposition
= donttouch
;
2200 b
->frame
= (frame
? frame
->frame
: 0);
2202 /* If we're debugging a multi-threaded program, then we
2203 want momentary breakpoints to be active in only a
2204 single thread of control. */
2205 if (in_thread_list (inferior_pid
))
2206 b
->thread
= pid_to_thread_id (inferior_pid
);
2212 /* Tell the user we have just set a breakpoint B. */
2216 struct breakpoint
*b
;
2220 /* FIXME: This is misplaced; mention() is called by things (like hitting a
2221 watchpoint) other than breakpoint creation. It should be possible to
2222 clean this up and at the same time replace the random calls to
2223 breakpoint_changed with this hook, as has already been done for
2224 delete_breakpoint_hook and so on. */
2225 if (create_breakpoint_hook
)
2226 create_breakpoint_hook (b
);
2231 printf_filtered ("Watchpoint %d: ", b
->number
);
2232 print_expression (b
->exp
, gdb_stdout
);
2234 case bp_hardware_watchpoint
:
2235 printf_filtered ("Hardware watchpoint %d: ", b
->number
);
2236 print_expression (b
->exp
, gdb_stdout
);
2238 case bp_read_watchpoint
:
2239 printf_filtered ("Hardware read watchpoint %d: ", b
->number
);
2240 print_expression (b
->exp
, gdb_stdout
);
2242 case bp_access_watchpoint
:
2243 printf_filtered ("Hardware access(read/write) watchpoint %d: ",b
->number
);
2244 print_expression (b
->exp
, gdb_stdout
);
2247 printf_filtered ("Breakpoint %d", b
->number
);
2250 case bp_hardware_breakpoint
:
2251 printf_filtered ("Hardware assisted breakpoint %d", b
->number
);
2257 case bp_longjmp_resume
:
2258 case bp_step_resume
:
2259 case bp_through_sigtramp
:
2261 case bp_watchpoint_scope
:
2262 case bp_shlib_event
:
2267 if (addressprint
|| b
->source_file
== NULL
)
2269 printf_filtered (" at ");
2270 print_address_numeric (b
->address
, 1, gdb_stdout
);
2273 printf_filtered (": file %s, line %d.",
2274 b
->source_file
, b
->line_number
);
2276 printf_filtered ("\n");
2280 /* Set a breakpoint according to ARG (function, linenum or *address)
2281 flag: first bit : 0 non-temporary, 1 temporary.
2282 second bit : 0 normal breakpoint, 1 hardware breakpoint. */
2285 break_command_1 (arg
, flag
, from_tty
)
2289 int tempflag
, hardwareflag
;
2290 struct symtabs_and_lines sals
;
2291 struct symtab_and_line sal
;
2292 register struct expression
*cond
= 0;
2293 register struct breakpoint
*b
;
2295 /* Pointers in arg to the start, and one past the end, of the condition. */
2296 char *cond_start
= NULL
;
2297 char *cond_end
= NULL
;
2298 /* Pointers in arg to the start, and one past the end,
2299 of the address part. */
2300 char *addr_start
= NULL
;
2301 char *addr_end
= NULL
;
2302 struct cleanup
*old_chain
;
2303 struct cleanup
*canonical_strings_chain
= NULL
;
2304 char **canonical
= (char **)NULL
;
2308 hardwareflag
= flag
& BP_HARDWAREFLAG
;
2309 tempflag
= flag
& BP_TEMPFLAG
;
2314 sal
.line
= sal
.pc
= sal
.end
= 0;
2317 /* If no arg given, or if first arg is 'if ', use the default breakpoint. */
2319 if (!arg
|| (arg
[0] == 'i' && arg
[1] == 'f'
2320 && (arg
[2] == ' ' || arg
[2] == '\t')))
2322 if (default_breakpoint_valid
)
2324 sals
.sals
= (struct symtab_and_line
*)
2325 xmalloc (sizeof (struct symtab_and_line
));
2326 sal
.pc
= default_breakpoint_address
;
2327 sal
.line
= default_breakpoint_line
;
2328 sal
.symtab
= default_breakpoint_symtab
;
2333 error ("No default breakpoint address now.");
2339 /* Force almost all breakpoints to be in terms of the
2340 current_source_symtab (which is decode_line_1's default). This
2341 should produce the results we want almost all of the time while
2342 leaving default_breakpoint_* alone. */
2343 if (default_breakpoint_valid
2344 && (!current_source_symtab
2345 || (arg
&& (*arg
== '+' || *arg
== '-'))))
2346 sals
= decode_line_1 (&arg
, 1, default_breakpoint_symtab
,
2347 default_breakpoint_line
, &canonical
);
2349 sals
= decode_line_1 (&arg
, 1, (struct symtab
*)NULL
, 0, &canonical
);
2357 /* Make sure that all storage allocated in decode_line_1 gets freed in case
2358 the following `for' loop errors out. */
2359 old_chain
= make_cleanup (free
, sals
.sals
);
2360 if (canonical
!= (char **)NULL
)
2362 make_cleanup (free
, canonical
);
2363 canonical_strings_chain
= make_cleanup (null_cleanup
, 0);
2364 for (i
= 0; i
< sals
.nelts
; i
++)
2366 if (canonical
[i
] != NULL
)
2367 make_cleanup (free
, canonical
[i
]);
2371 thread
= -1; /* No specific thread yet */
2373 /* Resolve all line numbers to PC's, and verify that conditions
2374 can be parsed, before setting any breakpoints. */
2375 for (i
= 0; i
< sals
.nelts
; i
++)
2377 char *tok
, *end_tok
;
2380 resolve_sal_pc (&sals
.sals
[i
]);
2386 while (*tok
== ' ' || *tok
== '\t')
2391 while (*end_tok
!= ' ' && *end_tok
!= '\t' && *end_tok
!= '\000')
2394 toklen
= end_tok
- tok
;
2396 if (toklen
>= 1 && strncmp (tok
, "if", toklen
) == 0)
2398 tok
= cond_start
= end_tok
+ 1;
2399 cond
= parse_exp_1 (&tok
, block_for_pc (sals
.sals
[i
].pc
), 0);
2402 else if (toklen
>= 1 && strncmp (tok
, "thread", toklen
) == 0)
2408 thread
= strtol (tok
, &tok
, 0);
2410 error ("Junk after thread keyword.");
2411 if (!valid_thread_id (thread
))
2412 error ("Unknown thread %d\n", thread
);
2415 error ("Junk at end of arguments.");
2420 int i
, target_resources_ok
;
2422 i
= hw_breakpoint_used_count ();
2423 target_resources_ok
= TARGET_CAN_USE_HARDWARE_WATCHPOINT (
2424 bp_hardware_breakpoint
, i
+ sals
.nelts
, 0);
2425 if (target_resources_ok
== 0)
2426 error ("No hardware breakpoint support in the target.");
2427 else if (target_resources_ok
< 0)
2428 error ("Hardware breakpoints used exceeds limit.");
2431 /* Remove the canonical strings from the cleanup, they are needed below. */
2432 if (canonical
!= (char **)NULL
)
2433 discard_cleanups (canonical_strings_chain
);
2435 /* Now set all the breakpoints. */
2436 for (i
= 0; i
< sals
.nelts
; i
++)
2441 describe_other_breakpoints (sal
.pc
);
2443 b
= set_raw_breakpoint (sal
);
2444 set_breakpoint_count (breakpoint_count
+ 1);
2445 b
->number
= breakpoint_count
;
2446 b
->type
= hardwareflag
? bp_hardware_breakpoint
: bp_breakpoint
;
2450 /* If a canonical line spec is needed use that instead of the
2452 if (canonical
!= (char **)NULL
&& canonical
[i
] != NULL
)
2453 b
->addr_string
= canonical
[i
];
2454 else if (addr_start
)
2455 b
->addr_string
= savestring (addr_start
, addr_end
- addr_start
);
2457 b
->cond_string
= savestring (cond_start
, cond_end
- cond_start
);
2459 b
->enable
= enabled
;
2460 b
->disposition
= tempflag
? del
: donttouch
;
2467 printf_filtered ("Multiple breakpoints were set.\n");
2468 printf_filtered ("Use the \"delete\" command to delete unwanted breakpoints.\n");
2470 do_cleanups (old_chain
);
2473 /* Helper function for break_command_1 and disassemble_command. */
2476 resolve_sal_pc (sal
)
2477 struct symtab_and_line
*sal
;
2481 if (sal
->pc
== 0 && sal
->symtab
!= 0)
2483 pc
= find_line_pc (sal
->symtab
, sal
->line
);
2485 error ("No line %d in file \"%s\".",
2486 sal
->line
, sal
->symtab
->filename
);
2492 break_command (arg
, from_tty
)
2496 break_command_1 (arg
, 0, from_tty
);
2500 tbreak_command (arg
, from_tty
)
2504 break_command_1 (arg
, BP_TEMPFLAG
, from_tty
);
2508 hbreak_command (arg
, from_tty
)
2512 break_command_1 (arg
, BP_HARDWAREFLAG
, from_tty
);
2516 thbreak_command (arg
, from_tty
)
2520 break_command_1 (arg
, (BP_TEMPFLAG
| BP_HARDWAREFLAG
), from_tty
);
2524 /* accessflag: 0: watch write, 1: watch read, 2: watch access(read or write)
2527 watch_command_1 (arg
, accessflag
, from_tty
)
2532 struct breakpoint
*b
;
2533 struct symtab_and_line sal
;
2534 struct expression
*exp
;
2535 struct block
*exp_valid_block
;
2536 struct value
*val
, *mark
;
2537 struct frame_info
*frame
, *prev_frame
;
2538 char *exp_start
= NULL
;
2539 char *exp_end
= NULL
;
2540 char *tok
, *end_tok
;
2542 char *cond_start
= NULL
;
2543 char *cond_end
= NULL
;
2544 struct expression
*cond
= NULL
;
2545 int i
, other_type_used
, target_resources_ok
;
2546 enum bptype bp_type
;
2553 /* Parse arguments. */
2554 innermost_block
= NULL
;
2556 exp
= parse_exp_1 (&arg
, 0, 0);
2558 exp_valid_block
= innermost_block
;
2559 mark
= value_mark ();
2560 val
= evaluate_expression (exp
);
2561 release_value (val
);
2562 if (VALUE_LAZY (val
))
2563 value_fetch_lazy (val
);
2566 while (*tok
== ' ' || *tok
== '\t')
2570 while (*end_tok
!= ' ' && *end_tok
!= '\t' && *end_tok
!= '\000')
2573 toklen
= end_tok
- tok
;
2574 if (toklen
>= 1 && strncmp (tok
, "if", toklen
) == 0)
2576 tok
= cond_start
= end_tok
+ 1;
2577 cond
= parse_exp_1 (&tok
, 0, 0);
2581 error("Junk at end of command.");
2583 if (accessflag
== 1) bp_type
= bp_read_watchpoint
;
2584 else if (accessflag
== 2) bp_type
= bp_access_watchpoint
;
2585 else bp_type
= bp_hardware_watchpoint
;
2587 mem_cnt
= can_use_hardware_watchpoint (val
);
2588 if (mem_cnt
== 0 && bp_type
!= bp_hardware_watchpoint
)
2589 error ("Expression cannot be implemented with read/access watchpoint.");
2591 i
= hw_watchpoint_used_count (bp_type
, &other_type_used
);
2592 target_resources_ok
= TARGET_CAN_USE_HARDWARE_WATCHPOINT(
2593 bp_type
, i
+ mem_cnt
, other_type_used
);
2594 if (target_resources_ok
== 0 && bp_type
!= bp_hardware_watchpoint
)
2595 error ("Target does not have this type of hardware watchpoint support.");
2596 if (target_resources_ok
< 0 && bp_type
!= bp_hardware_watchpoint
)
2597 error ("Target resources have been allocated for other types of watchpoints.");
2600 /* Now set up the breakpoint. */
2601 b
= set_raw_breakpoint (sal
);
2602 set_breakpoint_count (breakpoint_count
+ 1);
2603 b
->number
= breakpoint_count
;
2604 b
->disposition
= donttouch
;
2606 b
->exp_valid_block
= exp_valid_block
;
2607 b
->exp_string
= savestring (exp_start
, exp_end
- exp_start
);
2611 b
->cond_string
= savestring (cond_start
, cond_end
- cond_start
);
2615 frame
= block_innermost_frame (exp_valid_block
);
2618 prev_frame
= get_prev_frame (frame
);
2619 b
->watchpoint_frame
= frame
->frame
;
2622 b
->watchpoint_frame
= (CORE_ADDR
)0;
2624 if (mem_cnt
&& target_resources_ok
> 0)
2627 b
->type
= bp_watchpoint
;
2629 /* If the expression is "local", then set up a "watchpoint scope"
2630 breakpoint at the point where we've left the scope of the watchpoint
2632 if (innermost_block
)
2634 struct breakpoint
*scope_breakpoint
;
2635 struct symtab_and_line scope_sal
;
2639 scope_sal
.pc
= get_frame_pc (prev_frame
);
2640 scope_sal
.symtab
= NULL
;
2643 scope_breakpoint
= set_raw_breakpoint (scope_sal
);
2644 set_breakpoint_count (breakpoint_count
+ 1);
2645 scope_breakpoint
->number
= breakpoint_count
;
2647 scope_breakpoint
->type
= bp_watchpoint_scope
;
2648 scope_breakpoint
->enable
= enabled
;
2650 /* Automatically delete the breakpoint when it hits. */
2651 scope_breakpoint
->disposition
= del
;
2653 /* Only break in the proper frame (help with recursion). */
2654 scope_breakpoint
->frame
= prev_frame
->frame
;
2656 /* Set the address at which we will stop. */
2657 scope_breakpoint
->address
= get_frame_pc (prev_frame
);
2659 /* The scope breakpoint is related to the watchpoint. We
2660 will need to act on them together. */
2661 b
->related_breakpoint
= scope_breakpoint
;
2664 value_free_to_mark (mark
);
2668 /* Return count of locations need to be watched and can be handled
2669 in hardware. If the watchpoint can not be handled
2670 in hardware return zero. */
2673 can_use_hardware_watchpoint (v
)
2676 int found_memory_cnt
= 0;
2678 /* Make sure all the intermediate values are in memory. Also make sure
2679 we found at least one memory expression. Guards against watch 0x12345,
2680 which is meaningless, but could cause errors if one tries to insert a
2681 hardware watchpoint for the constant expression. */
2682 for ( ; v
; v
= v
->next
)
2684 if (v
->lval
== lval_memory
)
2686 if (TYPE_LENGTH (VALUE_TYPE (v
)) <= REGISTER_SIZE
)
2689 else if (v
->lval
!= not_lval
&& v
->modifiable
== 0)
2693 /* The expression itself looks suitable for using a hardware
2694 watchpoint, but give the target machine a chance to reject it. */
2695 return found_memory_cnt
;
2698 static void watch_command (arg
, from_tty
)
2702 watch_command_1 (arg
, 0, from_tty
);
2705 static void rwatch_command (arg
, from_tty
)
2709 watch_command_1 (arg
, 1, from_tty
);
2712 static void awatch_command (arg
, from_tty
)
2716 watch_command_1 (arg
, 2, from_tty
);
2720 /* Helper routine for the until_command routine in infcmd.c. Here
2721 because it uses the mechanisms of breakpoints. */
2725 until_break_command (arg
, from_tty
)
2729 struct symtabs_and_lines sals
;
2730 struct symtab_and_line sal
;
2731 struct frame_info
*prev_frame
= get_prev_frame (selected_frame
);
2732 struct breakpoint
*breakpoint
;
2733 struct cleanup
*old_chain
;
2735 clear_proceed_status ();
2737 /* Set a breakpoint where the user wants it and at return from
2740 if (default_breakpoint_valid
)
2741 sals
= decode_line_1 (&arg
, 1, default_breakpoint_symtab
,
2742 default_breakpoint_line
, (char ***)NULL
);
2744 sals
= decode_line_1 (&arg
, 1, (struct symtab
*)NULL
, 0, (char ***)NULL
);
2746 if (sals
.nelts
!= 1)
2747 error ("Couldn't get information on specified line.");
2750 free ((PTR
)sals
.sals
); /* malloc'd, so freed */
2753 error ("Junk at end of arguments.");
2755 resolve_sal_pc (&sal
);
2757 breakpoint
= set_momentary_breakpoint (sal
, selected_frame
, bp_until
);
2759 old_chain
= make_cleanup(delete_breakpoint
, breakpoint
);
2761 /* Keep within the current frame */
2765 sal
= find_pc_line (prev_frame
->pc
, 0);
2766 sal
.pc
= prev_frame
->pc
;
2767 breakpoint
= set_momentary_breakpoint (sal
, prev_frame
, bp_until
);
2768 make_cleanup(delete_breakpoint
, breakpoint
);
2771 proceed (-1, TARGET_SIGNAL_DEFAULT
, 0);
2772 do_cleanups(old_chain
);
2776 /* These aren't used; I don't konw what they were for. */
2777 /* Set a breakpoint at the catch clause for NAME. */
2779 catch_breakpoint (name
)
2785 disable_catch_breakpoint ()
2790 delete_catch_breakpoint ()
2795 enable_catch_breakpoint ()
2802 struct sal_chain
*next
;
2803 struct symtab_and_line sal
;
2807 /* This isn't used; I don't know what it was for. */
2808 /* For each catch clause identified in ARGS, run FUNCTION
2809 with that clause as an argument. */
2810 static struct symtabs_and_lines
2811 map_catch_names (args
, function
)
2815 register char *p
= args
;
2817 struct symtabs_and_lines sals
;
2819 struct sal_chain
*sal_chain
= 0;
2823 error_no_arg ("one or more catch names");
2831 /* Don't swallow conditional part. */
2832 if (p1
[0] == 'i' && p1
[1] == 'f'
2833 && (p1
[2] == ' ' || p1
[2] == '\t'))
2839 while (isalnum (*p1
) || *p1
== '_' || *p1
== '$')
2843 if (*p1
&& *p1
!= ' ' && *p1
!= '\t')
2844 error ("Arguments must be catch names.");
2850 struct sal_chain
*next
2851 = (struct sal_chain
*)alloca (sizeof (struct sal_chain
));
2852 next
->next
= sal_chain
;
2853 next
->sal
= get_catch_sal (p
);
2858 printf_unfiltered ("No catch clause for exception %s.\n", p
);
2863 while (*p
== ' ' || *p
== '\t') p
++;
2868 /* This shares a lot of code with `print_frame_label_vars' from stack.c. */
2870 static struct symtabs_and_lines
2871 get_catch_sals (this_level_only
)
2872 int this_level_only
;
2874 register struct blockvector
*bl
;
2875 register struct block
*block
;
2876 int index
, have_default
= 0;
2878 struct symtabs_and_lines sals
;
2879 struct sal_chain
*sal_chain
= 0;
2880 char *blocks_searched
;
2882 /* Not sure whether an error message is always the correct response,
2883 but it's better than a core dump. */
2884 if (selected_frame
== NULL
)
2885 error ("No selected frame.");
2886 block
= get_frame_block (selected_frame
);
2887 pc
= selected_frame
->pc
;
2893 error ("No symbol table info available.\n");
2895 bl
= blockvector_for_pc (BLOCK_END (block
) - 4, &index
);
2896 blocks_searched
= (char *) alloca (BLOCKVECTOR_NBLOCKS (bl
) * sizeof (char));
2897 memset (blocks_searched
, 0, BLOCKVECTOR_NBLOCKS (bl
) * sizeof (char));
2901 CORE_ADDR end
= BLOCK_END (block
) - 4;
2904 if (bl
!= blockvector_for_pc (end
, &index
))
2905 error ("blockvector blotch");
2906 if (BLOCKVECTOR_BLOCK (bl
, index
) != block
)
2907 error ("blockvector botch");
2908 last_index
= BLOCKVECTOR_NBLOCKS (bl
);
2911 /* Don't print out blocks that have gone by. */
2912 while (index
< last_index
2913 && BLOCK_END (BLOCKVECTOR_BLOCK (bl
, index
)) < pc
)
2916 while (index
< last_index
2917 && BLOCK_END (BLOCKVECTOR_BLOCK (bl
, index
)) < end
)
2919 if (blocks_searched
[index
] == 0)
2921 struct block
*b
= BLOCKVECTOR_BLOCK (bl
, index
);
2924 register struct symbol
*sym
;
2926 nsyms
= BLOCK_NSYMS (b
);
2928 for (i
= 0; i
< nsyms
; i
++)
2930 sym
= BLOCK_SYM (b
, i
);
2931 if (STREQ (SYMBOL_NAME (sym
), "default"))
2937 if (SYMBOL_CLASS (sym
) == LOC_LABEL
)
2939 struct sal_chain
*next
= (struct sal_chain
*)
2940 alloca (sizeof (struct sal_chain
));
2941 next
->next
= sal_chain
;
2942 next
->sal
= find_pc_line (SYMBOL_VALUE_ADDRESS (sym
), 0);
2946 blocks_searched
[index
] = 1;
2952 if (sal_chain
&& this_level_only
)
2955 /* After handling the function's top-level block, stop.
2956 Don't continue to its superblock, the block of
2957 per-file symbols. */
2958 if (BLOCK_FUNCTION (block
))
2960 block
= BLOCK_SUPERBLOCK (block
);
2965 struct sal_chain
*tmp_chain
;
2967 /* Count the number of entries. */
2968 for (index
= 0, tmp_chain
= sal_chain
; tmp_chain
;
2969 tmp_chain
= tmp_chain
->next
)
2973 sals
.sals
= (struct symtab_and_line
*)
2974 xmalloc (index
* sizeof (struct symtab_and_line
));
2975 for (index
= 0; sal_chain
; sal_chain
= sal_chain
->next
, index
++)
2976 sals
.sals
[index
] = sal_chain
->sal
;
2982 /* Commands to deal with catching exceptions. */
2985 catch_command_1 (arg
, tempflag
, from_tty
)
2990 /* First, translate ARG into something we can deal with in terms
2993 struct symtabs_and_lines sals
;
2994 struct symtab_and_line sal
;
2995 register struct expression
*cond
= 0;
2996 register struct breakpoint
*b
;
3000 sal
.line
= sal
.pc
= sal
.end
= 0;
3003 /* If no arg given, or if first arg is 'if ', all active catch clauses
3004 are breakpointed. */
3006 if (!arg
|| (arg
[0] == 'i' && arg
[1] == 'f'
3007 && (arg
[2] == ' ' || arg
[2] == '\t')))
3009 /* Grab all active catch clauses. */
3010 sals
= get_catch_sals (0);
3014 /* Grab selected catch clauses. */
3015 error ("catch NAME not implemented");
3017 /* This isn't used; I don't know what it was for. */
3018 sals
= map_catch_names (arg
, catch_breakpoint
);
3026 for (i
= 0; i
< sals
.nelts
; i
++)
3028 resolve_sal_pc (&sals
.sals
[i
]);
3032 if (arg
[0] == 'i' && arg
[1] == 'f'
3033 && (arg
[2] == ' ' || arg
[2] == '\t'))
3034 cond
= parse_exp_1 ((arg
+= 2, &arg
),
3035 block_for_pc (sals
.sals
[i
].pc
), 0);
3037 error ("Junk at end of arguments.");
3042 for (i
= 0; i
< sals
.nelts
; i
++)
3047 describe_other_breakpoints (sal
.pc
);
3049 b
= set_raw_breakpoint (sal
);
3050 set_breakpoint_count (breakpoint_count
+ 1);
3051 b
->number
= breakpoint_count
;
3052 b
->type
= bp_breakpoint
;
3054 b
->enable
= enabled
;
3055 b
->disposition
= tempflag
? del
: donttouch
;
3062 printf_unfiltered ("Multiple breakpoints were set.\n");
3063 printf_unfiltered ("Use the \"delete\" command to delete unwanted breakpoints.\n");
3065 free ((PTR
)sals
.sals
);
3068 /* Used by the gui, could be made a worker for other things. */
3071 set_breakpoint_sal (sal
)
3072 struct symtab_and_line sal
;
3074 struct breakpoint
*b
;
3075 b
= set_raw_breakpoint (sal
);
3076 set_breakpoint_count (breakpoint_count
+ 1);
3077 b
->number
= breakpoint_count
;
3078 b
->type
= bp_breakpoint
;
3085 /* These aren't used; I don't know what they were for. */
3086 /* Disable breakpoints on all catch clauses described in ARGS. */
3088 disable_catch (args
)
3091 /* Map the disable command to catch clauses described in ARGS. */
3094 /* Enable breakpoints on all catch clauses described in ARGS. */
3099 /* Map the disable command to catch clauses described in ARGS. */
3102 /* Delete breakpoints on all catch clauses in the active scope. */
3107 /* Map the delete command to catch clauses described in ARGS. */
3112 catch_command (arg
, from_tty
)
3116 catch_command_1 (arg
, 0, from_tty
);
3120 clear_command (arg
, from_tty
)
3124 register struct breakpoint
*b
, *b1
;
3125 struct symtabs_and_lines sals
;
3126 struct symtab_and_line sal
;
3127 register struct breakpoint
*found
;
3132 sals
= decode_line_spec (arg
, 1);
3136 sals
.sals
= (struct symtab_and_line
*) xmalloc (sizeof (struct symtab_and_line
));
3137 sal
.line
= default_breakpoint_line
;
3138 sal
.symtab
= default_breakpoint_symtab
;
3140 if (sal
.symtab
== 0)
3141 error ("No source file specified.");
3147 for (i
= 0; i
< sals
.nelts
; i
++)
3149 /* If exact pc given, clear bpts at that pc.
3150 But if sal.pc is zero, clear all bpts on specified line. */
3152 found
= (struct breakpoint
*) 0;
3153 while (breakpoint_chain
3155 ? breakpoint_chain
->address
== sal
.pc
3156 : (breakpoint_chain
->source_file
!= NULL
3157 && sal
.symtab
!= NULL
3158 && STREQ (breakpoint_chain
->source_file
,
3159 sal
.symtab
->filename
)
3160 && breakpoint_chain
->line_number
== sal
.line
)))
3162 b1
= breakpoint_chain
;
3163 breakpoint_chain
= b1
->next
;
3170 && b
->next
->type
!= bp_watchpoint
3171 && b
->next
->type
!= bp_hardware_watchpoint
3172 && b
->next
->type
!= bp_read_watchpoint
3173 && b
->next
->type
!= bp_access_watchpoint
3175 ? b
->next
->address
== sal
.pc
3176 : (b
->next
->source_file
!= NULL
3177 && sal
.symtab
!= NULL
3178 && STREQ (b
->next
->source_file
, sal
.symtab
->filename
)
3179 && b
->next
->line_number
== sal
.line
)))
3190 error ("No breakpoint at %s.", arg
);
3192 error ("No breakpoint at this line.");
3195 if (found
->next
) from_tty
= 1; /* Always report if deleted more than one */
3196 if (from_tty
) printf_unfiltered ("Deleted breakpoint%s ", found
->next
? "s" : "");
3197 breakpoints_changed ();
3200 if (from_tty
) printf_unfiltered ("%d ", found
->number
);
3202 delete_breakpoint (found
);
3205 if (from_tty
) putchar_unfiltered ('\n');
3207 free ((PTR
)sals
.sals
);
3210 /* Delete breakpoint in BS if they are `delete' breakpoints and
3211 all breakpoints that are marked for deletion, whether hit or not.
3212 This is called after any breakpoint is hit, or after errors. */
3215 breakpoint_auto_delete (bs
)
3218 struct breakpoint
*b
, *temp
;
3220 for (; bs
; bs
= bs
->next
)
3221 if (bs
->breakpoint_at
&& bs
->breakpoint_at
->disposition
== del
3223 delete_breakpoint (bs
->breakpoint_at
);
3225 ALL_BREAKPOINTS_SAFE (b
, temp
)
3227 if (b
->disposition
== del_at_next_stop
)
3228 delete_breakpoint (b
);
3232 /* Delete a breakpoint and clean up all traces of it in the data structures. */
3235 delete_breakpoint (bpt
)
3236 struct breakpoint
*bpt
;
3238 register struct breakpoint
*b
;
3241 if (delete_breakpoint_hook
)
3242 delete_breakpoint_hook (bpt
);
3245 remove_breakpoint (bpt
);
3247 if (breakpoint_chain
== bpt
)
3248 breakpoint_chain
= bpt
->next
;
3253 b
->next
= bpt
->next
;
3257 check_duplicates (bpt
->address
);
3258 /* If this breakpoint was inserted, and there is another breakpoint
3259 at the same address, we need to insert the other breakpoint. */
3261 && bpt
->type
!= bp_hardware_watchpoint
3262 && bpt
->type
!= bp_read_watchpoint
3263 && bpt
->type
!= bp_access_watchpoint
)
3266 if (b
->address
== bpt
->address
3268 && b
->enable
!= disabled
3269 && b
->enable
!= shlib_disabled
)
3272 val
= target_insert_breakpoint (b
->address
, b
->shadow_contents
);
3275 target_terminal_ours_for_output ();
3276 fprintf_unfiltered (gdb_stderr
, "Cannot insert breakpoint %d:\n", b
->number
);
3277 memory_error (val
, b
->address
); /* which bombs us out */
3284 free_command_lines (&bpt
->commands
);
3287 if (bpt
->cond_string
!= NULL
)
3288 free (bpt
->cond_string
);
3289 if (bpt
->addr_string
!= NULL
)
3290 free (bpt
->addr_string
);
3291 if (bpt
->exp
!= NULL
)
3293 if (bpt
->exp_string
!= NULL
)
3294 free (bpt
->exp_string
);
3295 if (bpt
->val
!= NULL
)
3296 value_free (bpt
->val
);
3297 if (bpt
->source_file
!= NULL
)
3298 free (bpt
->source_file
);
3300 /* Be sure no bpstat's are pointing at it after it's been freed. */
3301 /* FIXME, how can we find all bpstat's?
3302 We just check stop_bpstat for now. */
3303 for (bs
= stop_bpstat
; bs
; bs
= bs
->next
)
3304 if (bs
->breakpoint_at
== bpt
)
3305 bs
->breakpoint_at
= NULL
;
3310 delete_command (arg
, from_tty
)
3317 /* Ask user only if there are some breakpoints to delete. */
3319 || (breakpoint_chain
&& query ("Delete all breakpoints? ")))
3321 /* No arg; clear all breakpoints. */
3322 while (breakpoint_chain
)
3323 delete_breakpoint (breakpoint_chain
);
3327 map_breakpoint_numbers (arg
, delete_breakpoint
);
3330 /* Reset a breakpoint given it's struct breakpoint * BINT.
3331 The value we return ends up being the return value from catch_errors.
3332 Unused in this case. */
3335 breakpoint_re_set_one (bint
)
3338 struct breakpoint
*b
= (struct breakpoint
*)bint
; /* get past catch_errs */
3341 struct symtabs_and_lines sals
;
3343 enum enable save_enable
;
3348 case bp_hardware_breakpoint
:
3349 if (b
->addr_string
== NULL
)
3351 /* Anything without a string can't be re-set. */
3352 delete_breakpoint (b
);
3355 /* In case we have a problem, disable this breakpoint. We'll restore
3356 its status if we succeed. */
3357 save_enable
= b
->enable
;
3358 b
->enable
= disabled
;
3360 set_language (b
->language
);
3361 input_radix
= b
->input_radix
;
3363 sals
= decode_line_1 (&s
, 1, (struct symtab
*)NULL
, 0, (char ***)NULL
);
3364 for (i
= 0; i
< sals
.nelts
; i
++)
3366 resolve_sal_pc (&sals
.sals
[i
]);
3368 /* Reparse conditions, they might contain references to the
3370 if (b
->cond_string
!= NULL
)
3374 free ((PTR
)b
->cond
);
3375 b
->cond
= parse_exp_1 (&s
, block_for_pc (sals
.sals
[i
].pc
), 0);
3378 /* We need to re-set the breakpoint if the address changes...*/
3379 if (b
->address
!= sals
.sals
[i
].pc
3380 /* ...or new and old breakpoints both have source files, and
3381 the source file name or the line number changes... */
3382 || (b
->source_file
!= NULL
3383 && sals
.sals
[i
].symtab
!= NULL
3384 && (!STREQ (b
->source_file
, sals
.sals
[i
].symtab
->filename
)
3385 || b
->line_number
!= sals
.sals
[i
].line
)
3387 /* ...or we switch between having a source file and not having
3389 || ((b
->source_file
== NULL
) != (sals
.sals
[i
].symtab
== NULL
))
3392 if (b
->source_file
!= NULL
)
3393 free (b
->source_file
);
3394 if (sals
.sals
[i
].symtab
== NULL
)
3395 b
->source_file
= NULL
;
3398 savestring (sals
.sals
[i
].symtab
->filename
,
3399 strlen (sals
.sals
[i
].symtab
->filename
));
3400 b
->line_number
= sals
.sals
[i
].line
;
3401 b
->address
= sals
.sals
[i
].pc
;
3403 check_duplicates (b
->address
);
3407 /* Might be better to do this just once per breakpoint_re_set,
3408 rather than once for every breakpoint. */
3409 breakpoints_changed ();
3411 b
->enable
= save_enable
; /* Restore it, this worked. */
3413 free ((PTR
)sals
.sals
);
3417 case bp_hardware_watchpoint
:
3418 case bp_read_watchpoint
:
3419 case bp_access_watchpoint
:
3420 innermost_block
= NULL
;
3421 /* The issue arises of what context to evaluate this in. The same
3422 one as when it was set, but what does that mean when symbols have
3423 been re-read? We could save the filename and functionname, but
3424 if the context is more local than that, the best we could do would
3425 be something like how many levels deep and which index at that
3426 particular level, but that's going to be less stable than filenames
3427 or functionnames. */
3428 /* So for now, just use a global context. */
3431 b
->exp
= parse_expression (b
->exp_string
);
3432 b
->exp_valid_block
= innermost_block
;
3433 mark
= value_mark ();
3435 value_free (b
->val
);
3436 b
->val
= evaluate_expression (b
->exp
);
3437 release_value (b
->val
);
3438 if (VALUE_LAZY (b
->val
))
3439 value_fetch_lazy (b
->val
);
3441 if (b
->cond_string
!= NULL
)
3445 free ((PTR
)b
->cond
);
3446 b
->cond
= parse_exp_1 (&s
, (struct block
*)0, 0);
3448 if (b
->enable
== enabled
)
3450 value_free_to_mark (mark
);
3454 printf_filtered ("Deleting unknown breakpoint type %d\n", b
->type
);
3456 /* Delete longjmp breakpoints, they will be reset later by
3457 breakpoint_re_set. */
3459 case bp_longjmp_resume
:
3460 delete_breakpoint (b
);
3463 /* This breakpoint is special, it's set up when the inferior
3464 starts and we really don't want to touch it. */
3465 case bp_shlib_event
:
3467 /* Keep temporary breakpoints, which can be encountered when we step
3468 over a dlopen call and SOLIB_ADD is resetting the breakpoints.
3469 Otherwise these should have been blown away via the cleanup chain
3470 or by breakpoint_init_inferior when we rerun the executable. */
3473 case bp_watchpoint_scope
:
3475 case bp_step_resume
:
3482 /* Re-set all breakpoints after symbols have been re-loaded. */
3484 breakpoint_re_set ()
3486 struct breakpoint
*b
, *temp
;
3487 enum language save_language
;
3488 int save_input_radix
;
3489 static char message1
[] = "Error in re-setting breakpoint %d:\n";
3490 char message
[sizeof (message1
) + 30 /* slop */];
3492 save_language
= current_language
->la_language
;
3493 save_input_radix
= input_radix
;
3494 ALL_BREAKPOINTS_SAFE (b
, temp
)
3496 sprintf (message
, message1
, b
->number
); /* Format possible error msg */
3497 catch_errors (breakpoint_re_set_one
, (char *) b
, message
,
3500 set_language (save_language
);
3501 input_radix
= save_input_radix
;
3503 #ifdef GET_LONGJMP_TARGET
3504 create_longjmp_breakpoint ("longjmp");
3505 create_longjmp_breakpoint ("_longjmp");
3506 create_longjmp_breakpoint ("siglongjmp");
3507 create_longjmp_breakpoint (NULL
);
3511 /* Took this out (temporarily at least), since it produces an extra
3512 blank line at startup. This messes up the gdbtests. -PB */
3513 /* Blank line to finish off all those mention() messages we just printed. */
3514 printf_filtered ("\n");
3518 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
3519 If from_tty is nonzero, it prints a message to that effect,
3520 which ends with a period (no newline). */
3523 set_ignore_count (bptnum
, count
, from_tty
)
3524 int bptnum
, count
, from_tty
;
3526 register struct breakpoint
*b
;
3532 if (b
->number
== bptnum
)
3534 b
->ignore_count
= count
;
3537 else if (count
== 0)
3538 printf_filtered ("Will stop next time breakpoint %d is reached.",
3540 else if (count
== 1)
3541 printf_filtered ("Will ignore next crossing of breakpoint %d.",
3544 printf_filtered ("Will ignore next %d crossings of breakpoint %d.",
3546 breakpoints_changed ();
3550 error ("No breakpoint number %d.", bptnum
);
3553 /* Clear the ignore counts of all breakpoints. */
3555 breakpoint_clear_ignore_counts ()
3557 struct breakpoint
*b
;
3560 b
->ignore_count
= 0;
3563 /* Command to set ignore-count of breakpoint N to COUNT. */
3566 ignore_command (args
, from_tty
)
3574 error_no_arg ("a breakpoint number");
3576 num
= get_number (&p
);
3579 error ("Second argument (specified ignore-count) is missing.");
3581 set_ignore_count (num
,
3582 longest_to_int (value_as_long (parse_and_eval (p
))),
3584 printf_filtered ("\n");
3585 breakpoints_changed ();
3588 /* Call FUNCTION on each of the breakpoints
3589 whose numbers are given in ARGS. */
3592 map_breakpoint_numbers (args
, function
)
3594 void (*function
) PARAMS ((struct breakpoint
*));
3596 register char *p
= args
;
3599 register struct breakpoint
*b
;
3602 error_no_arg ("one or more breakpoint numbers");
3608 num
= get_number (&p1
);
3611 if (b
->number
== num
)
3613 struct breakpoint
*related_breakpoint
= b
->related_breakpoint
;
3615 if (related_breakpoint
)
3616 function (related_breakpoint
);
3619 printf_unfiltered ("No breakpoint number %d.\n", num
);
3626 disable_breakpoint (bpt
)
3627 struct breakpoint
*bpt
;
3629 /* Never disable a watchpoint scope breakpoint; we want to
3630 hit them when we leave scope so we can delete both the
3631 watchpoint and its scope breakpoint at that time. */
3632 if (bpt
->type
== bp_watchpoint_scope
)
3635 bpt
->enable
= disabled
;
3637 check_duplicates (bpt
->address
);
3639 if (modify_breakpoint_hook
)
3640 modify_breakpoint_hook (bpt
);
3645 disable_command (args
, from_tty
)
3649 register struct breakpoint
*bpt
;
3651 ALL_BREAKPOINTS (bpt
)
3655 case bp_hardware_breakpoint
:
3657 case bp_hardware_watchpoint
:
3658 case bp_read_watchpoint
:
3659 case bp_access_watchpoint
:
3660 disable_breakpoint (bpt
);
3665 map_breakpoint_numbers (args
, disable_breakpoint
);
3669 do_enable_breakpoint (bpt
, disposition
)
3670 struct breakpoint
*bpt
;
3671 enum bpdisp disposition
;
3673 struct frame_info
*save_selected_frame
= NULL
;
3674 int save_selected_frame_level
= -1;
3675 int target_resources_ok
, other_type_used
;
3678 if (bpt
->type
== bp_hardware_breakpoint
)
3681 i
= hw_breakpoint_used_count();
3682 target_resources_ok
= TARGET_CAN_USE_HARDWARE_WATCHPOINT(
3683 bp_hardware_breakpoint
, i
+1, 0);
3684 if (target_resources_ok
== 0)
3685 error ("No hardware breakpoint support in the target.");
3686 else if (target_resources_ok
< 0)
3687 error ("Hardware breakpoints used exceeds limit.");
3690 bpt
->enable
= enabled
;
3691 bpt
->disposition
= disposition
;
3692 check_duplicates (bpt
->address
);
3693 breakpoints_changed ();
3695 if (bpt
->type
== bp_watchpoint
|| bpt
->type
== bp_hardware_watchpoint
||
3696 bpt
->type
== bp_read_watchpoint
|| bpt
->type
== bp_access_watchpoint
)
3698 if (bpt
->exp_valid_block
!= NULL
)
3700 struct frame_info
*fr
=
3701 find_frame_addr_in_frame_chain (bpt
->watchpoint_frame
);
3705 Cannot enable watchpoint %d because the block in which its expression\n\
3706 is valid is not currently in scope.\n", bpt
->number
);
3707 bpt
->enable
= disabled
;
3711 save_selected_frame
= selected_frame
;
3712 save_selected_frame_level
= selected_frame_level
;
3713 select_frame (fr
, -1);
3716 value_free (bpt
->val
);
3717 mark
= value_mark ();
3718 bpt
->val
= evaluate_expression (bpt
->exp
);
3719 release_value (bpt
->val
);
3720 if (VALUE_LAZY (bpt
->val
))
3721 value_fetch_lazy (bpt
->val
);
3723 if (bpt
->type
== bp_hardware_watchpoint
||
3724 bpt
->type
== bp_read_watchpoint
||
3725 bpt
->type
== bp_access_watchpoint
)
3727 int i
= hw_watchpoint_used_count (bpt
->type
, &other_type_used
);
3728 int mem_cnt
= can_use_hardware_watchpoint (bpt
->val
);
3730 target_resources_ok
= TARGET_CAN_USE_HARDWARE_WATCHPOINT(
3731 bpt
->type
, i
+ mem_cnt
, other_type_used
);
3732 /* we can consider of type is bp_hardware_watchpoint, convert to
3733 bp_watchpoint in the following condition */
3734 if (target_resources_ok
< 0)
3737 Cannot enable watchpoint %d because target watch resources\n\
3738 have been allocated for other watchpoints.\n", bpt
->number
);
3739 bpt
->enable
= disabled
;
3740 value_free_to_mark (mark
);
3745 if (save_selected_frame_level
>= 0)
3746 select_frame (save_selected_frame
, save_selected_frame_level
);
3747 value_free_to_mark (mark
);
3749 if (modify_breakpoint_hook
)
3750 modify_breakpoint_hook (bpt
);
3754 enable_breakpoint (bpt
)
3755 struct breakpoint
*bpt
;
3757 do_enable_breakpoint (bpt
, donttouch
);
3760 /* The enable command enables the specified breakpoints (or all defined
3761 breakpoints) so they once again become (or continue to be) effective
3762 in stopping the inferior. */
3766 enable_command (args
, from_tty
)
3770 register struct breakpoint
*bpt
;
3772 ALL_BREAKPOINTS (bpt
)
3776 case bp_hardware_breakpoint
:
3778 case bp_hardware_watchpoint
:
3779 case bp_read_watchpoint
:
3780 case bp_access_watchpoint
:
3781 enable_breakpoint (bpt
);
3786 map_breakpoint_numbers (args
, enable_breakpoint
);
3790 enable_once_breakpoint (bpt
)
3791 struct breakpoint
*bpt
;
3793 do_enable_breakpoint (bpt
, disable
);
3798 enable_once_command (args
, from_tty
)
3802 map_breakpoint_numbers (args
, enable_once_breakpoint
);
3806 enable_delete_breakpoint (bpt
)
3807 struct breakpoint
*bpt
;
3809 do_enable_breakpoint (bpt
, del
);
3814 enable_delete_command (args
, from_tty
)
3818 map_breakpoint_numbers (args
, enable_delete_breakpoint
);
3821 /* Use default_breakpoint_'s, or nothing if they aren't valid. */
3823 struct symtabs_and_lines
3824 decode_line_spec_1 (string
, funfirstline
)
3828 struct symtabs_and_lines sals
;
3830 error ("Empty line specification.");
3831 if (default_breakpoint_valid
)
3832 sals
= decode_line_1 (&string
, funfirstline
,
3833 default_breakpoint_symtab
, default_breakpoint_line
,
3836 sals
= decode_line_1 (&string
, funfirstline
,
3837 (struct symtab
*)NULL
, 0, (char ***)NULL
);
3839 error ("Junk at end of line specification: %s", string
);
3844 _initialize_breakpoint ()
3846 breakpoint_chain
= 0;
3847 /* Don't bother to call set_breakpoint_count. $bpnum isn't useful
3848 before a breakpoint is set. */
3849 breakpoint_count
= 0;
3851 add_com ("ignore", class_breakpoint
, ignore_command
,
3852 "Set ignore-count of breakpoint number N to COUNT.\n\
3853 Usage is `ignore N COUNT'.");
3855 add_com ("commands", class_breakpoint
, commands_command
,
3856 "Set commands to be executed when a breakpoint is hit.\n\
3857 Give breakpoint number as argument after \"commands\".\n\
3858 With no argument, the targeted breakpoint is the last one set.\n\
3859 The commands themselves follow starting on the next line.\n\
3860 Type a line containing \"end\" to indicate the end of them.\n\
3861 Give \"silent\" as the first line to make the breakpoint silent;\n\
3862 then no output is printed when it is hit, except what the commands print.");
3864 add_com ("condition", class_breakpoint
, condition_command
,
3865 "Specify breakpoint number N to break only if COND is true.\n\
3866 Usage is `condition N COND', where N is an integer and COND is an\n\
3867 expression to be evaluated whenever breakpoint N is reached. ");
3869 add_com ("tbreak", class_breakpoint
, tbreak_command
,
3870 "Set a temporary breakpoint. Args like \"break\" command.\n\
3871 Like \"break\" except the breakpoint is only temporary,\n\
3872 so it will be deleted when hit. Equivalent to \"break\" followed\n\
3873 by using \"enable delete\" on the breakpoint number.");
3875 add_com ("hbreak", class_breakpoint
, hbreak_command
,
3876 "Set a hardware assisted breakpoint. Args like \"break\" command.\n\
3877 Like \"break\" except the breakpoint requires hardware support,\n\
3878 some target hardware may not have this support.");
3880 add_com ("thbreak", class_breakpoint
, thbreak_command
,
3881 "Set a temporary hardware assisted breakpoint. Args like \"break\" command.\n\
3882 Like \"hbreak\" except the breakpoint is only temporary,\n\
3883 so it will be deleted when hit.");
3885 add_prefix_cmd ("enable", class_breakpoint
, enable_command
,
3886 "Enable some breakpoints.\n\
3887 Give breakpoint numbers (separated by spaces) as arguments.\n\
3888 With no subcommand, breakpoints are enabled until you command otherwise.\n\
3889 This is used to cancel the effect of the \"disable\" command.\n\
3890 With a subcommand you can enable temporarily.",
3891 &enablelist
, "enable ", 1, &cmdlist
);
3893 add_abbrev_prefix_cmd ("breakpoints", class_breakpoint
, enable_command
,
3894 "Enable some breakpoints.\n\
3895 Give breakpoint numbers (separated by spaces) as arguments.\n\
3896 This is used to cancel the effect of the \"disable\" command.\n\
3897 May be abbreviated to simply \"enable\".\n",
3898 &enablebreaklist
, "enable breakpoints ", 1, &enablelist
);
3900 add_cmd ("once", no_class
, enable_once_command
,
3901 "Enable breakpoints for one hit. Give breakpoint numbers.\n\
3902 If a breakpoint is hit while enabled in this fashion, it becomes disabled.",
3905 add_cmd ("delete", no_class
, enable_delete_command
,
3906 "Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
3907 If a breakpoint is hit while enabled in this fashion, it is deleted.",
3910 add_cmd ("delete", no_class
, enable_delete_command
,
3911 "Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
3912 If a breakpoint is hit while enabled in this fashion, it is deleted.",
3915 add_cmd ("once", no_class
, enable_once_command
,
3916 "Enable breakpoints for one hit. Give breakpoint numbers.\n\
3917 If a breakpoint is hit while enabled in this fashion, it becomes disabled.",
3920 add_prefix_cmd ("disable", class_breakpoint
, disable_command
,
3921 "Disable some breakpoints.\n\
3922 Arguments are breakpoint numbers with spaces in between.\n\
3923 To disable all breakpoints, give no argument.\n\
3924 A disabled breakpoint is not forgotten, but has no effect until reenabled.",
3925 &disablelist
, "disable ", 1, &cmdlist
);
3926 add_com_alias ("dis", "disable", class_breakpoint
, 1);
3927 add_com_alias ("disa", "disable", class_breakpoint
, 1);
3929 add_cmd ("breakpoints", class_alias
, disable_command
,
3930 "Disable some breakpoints.\n\
3931 Arguments are breakpoint numbers with spaces in between.\n\
3932 To disable all breakpoints, give no argument.\n\
3933 A disabled breakpoint is not forgotten, but has no effect until reenabled.\n\
3934 This command may be abbreviated \"disable\".",
3937 add_prefix_cmd ("delete", class_breakpoint
, delete_command
,
3938 "Delete some breakpoints or auto-display expressions.\n\
3939 Arguments are breakpoint numbers with spaces in between.\n\
3940 To delete all breakpoints, give no argument.\n\
3942 Also a prefix command for deletion of other GDB objects.\n\
3943 The \"unset\" command is also an alias for \"delete\".",
3944 &deletelist
, "delete ", 1, &cmdlist
);
3945 add_com_alias ("d", "delete", class_breakpoint
, 1);
3947 add_cmd ("breakpoints", class_alias
, delete_command
,
3948 "Delete some breakpoints or auto-display expressions.\n\
3949 Arguments are breakpoint numbers with spaces in between.\n\
3950 To delete all breakpoints, give no argument.\n\
3951 This command may be abbreviated \"delete\".",
3954 add_com ("clear", class_breakpoint
, clear_command
,
3955 concat ("Clear breakpoint at specified line or function.\n\
3956 Argument may be line number, function name, or \"*\" and an address.\n\
3957 If line number is specified, all breakpoints in that line are cleared.\n\
3958 If function is specified, breakpoints at beginning of function are cleared.\n\
3959 If an address is specified, breakpoints at that address are cleared.\n\n",
3960 "With no argument, clears all breakpoints in the line that the selected frame\n\
3963 See also the \"delete\" command which clears breakpoints by number.", NULL
));
3965 add_com ("break", class_breakpoint
, break_command
,
3966 concat ("Set breakpoint at specified line or function.\n\
3967 Argument may be line number, function name, or \"*\" and an address.\n\
3968 If line number is specified, break at start of code for that line.\n\
3969 If function is specified, break at start of code for that function.\n\
3970 If an address is specified, break at that exact address.\n",
3971 "With no arg, uses current execution address of selected stack frame.\n\
3972 This is useful for breaking on return to a stack frame.\n\
3974 Multiple breakpoints at one place are permitted, and useful if conditional.\n\
3976 Do \"help breakpoints\" for info on other commands dealing with breakpoints.", NULL
));
3977 add_com_alias ("b", "break", class_run
, 1);
3978 add_com_alias ("br", "break", class_run
, 1);
3979 add_com_alias ("bre", "break", class_run
, 1);
3980 add_com_alias ("brea", "break", class_run
, 1);
3982 add_info ("breakpoints", breakpoints_info
,
3983 concat ("Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
3984 The \"Type\" column indicates one of:\n\
3985 \tbreakpoint - normal breakpoint\n\
3986 \twatchpoint - watchpoint\n\
3987 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
3988 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
3989 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
3990 address and file/line number respectively.\n\n",
3991 "Convenience variable \"$_\" and default examine address for \"x\"\n\
3992 are set to the address of the last breakpoint listed.\n\n\
3993 Convenience variable \"$bpnum\" contains the number of the last\n\
3994 breakpoint set.", NULL
));
3996 #if MAINTENANCE_CMDS
3998 add_cmd ("breakpoints", class_maintenance
, maintenance_info_breakpoints
,
3999 concat ("Status of all breakpoints, or breakpoint number NUMBER.\n\
4000 The \"Type\" column indicates one of:\n\
4001 \tbreakpoint - normal breakpoint\n\
4002 \twatchpoint - watchpoint\n\
4003 \tlongjmp - internal breakpoint used to step through longjmp()\n\
4004 \tlongjmp resume - internal breakpoint at the target of longjmp()\n\
4005 \tuntil - internal breakpoint used by the \"until\" command\n\
4006 \tfinish - internal breakpoint used by the \"finish\" command\n",
4007 "The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
4008 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
4009 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
4010 address and file/line number respectively.\n\n",
4011 "Convenience variable \"$_\" and default examine address for \"x\"\n\
4012 are set to the address of the last breakpoint listed.\n\n\
4013 Convenience variable \"$bpnum\" contains the number of the last\n\
4014 breakpoint set.", NULL
),
4015 &maintenanceinfolist
);
4017 #endif /* MAINTENANCE_CMDS */
4019 add_com ("catch", class_breakpoint
, catch_command
,
4020 "Set breakpoints to catch exceptions that are raised.\n\
4021 Argument may be a single exception to catch, multiple exceptions\n\
4022 to catch, or the default exception \"default\". If no arguments\n\
4023 are given, breakpoints are set at all exception handlers catch clauses\n\
4024 within the current scope.\n\
4026 A condition specified for the catch applies to all breakpoints set\n\
4027 with this command\n\
4029 Do \"help breakpoints\" for info on other commands dealing with breakpoints.");
4031 add_com ("watch", class_breakpoint
, watch_command
,
4032 "Set a watchpoint for an expression.\n\
4033 A watchpoint stops execution of your program whenever the value of\n\
4034 an expression changes.");
4036 add_com ("rwatch", class_breakpoint
, rwatch_command
,
4037 "Set a read watchpoint for an expression.\n\
4038 A watchpoint stops execution of your program whenever the value of\n\
4039 an expression is read.");
4041 add_com ("awatch", class_breakpoint
, awatch_command
,
4042 "Set a watchpoint for an expression.\n\
4043 A watchpoint stops execution of your program whenever the value of\n\
4044 an expression is either read or written.");
4046 add_info ("watchpoints", breakpoints_info
,
4047 "Synonym for ``info breakpoints''.");