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"
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
)
333 if (from_tty
&& input_from_terminal_p ())
334 printf_filtered ("Type commands for when breakpoint %d is hit, one per line.\n\
335 End with a line saying just \"end\".\n", bnum
);
336 l
= read_command_lines ();
337 free_command_lines (&b
->commands
);
339 breakpoints_changed ();
342 error ("No breakpoint number %d.", bnum
);
345 extern int memory_breakpoint_size
; /* from mem-break.c */
347 /* Like target_read_memory() but if breakpoints are inserted, return
348 the shadow contents instead of the breakpoints themselves.
350 Read "memory data" from whatever target or inferior we have.
351 Returns zero if successful, errno value if not. EIO is used
352 for address out of bounds. If breakpoints are inserted, returns
353 shadow contents, not the breakpoints themselves. From breakpoint.c. */
356 read_memory_nobpt (memaddr
, myaddr
, len
)
362 struct breakpoint
*b
;
364 if (memory_breakpoint_size
< 0)
365 /* No breakpoints on this machine. FIXME: This should be
366 dependent on the debugging target. Probably want
367 target_insert_breakpoint to return a size, saying how many
368 bytes of the shadow contents are used, or perhaps have
369 something like target_xfer_shadow. */
370 return target_read_memory (memaddr
, myaddr
, len
);
374 if (b
->type
== bp_watchpoint
375 || b
->type
== bp_hardware_watchpoint
376 || b
->type
== bp_read_watchpoint
377 || b
->type
== bp_access_watchpoint
380 else if (b
->address
+ memory_breakpoint_size
<= memaddr
)
381 /* The breakpoint is entirely before the chunk of memory
384 else if (b
->address
>= memaddr
+ len
)
385 /* The breakpoint is entirely after the chunk of memory we
390 /* Copy the breakpoint from the shadow contents, and recurse
391 for the things before and after. */
393 /* Addresses and length of the part of the breakpoint that
395 CORE_ADDR membpt
= b
->address
;
396 unsigned int bptlen
= memory_breakpoint_size
;
397 /* Offset within shadow_contents. */
400 if (membpt
< memaddr
)
402 /* Only copy the second part of the breakpoint. */
403 bptlen
-= memaddr
- membpt
;
404 bptoffset
= memaddr
- membpt
;
408 if (membpt
+ bptlen
> memaddr
+ len
)
410 /* Only copy the first part of the breakpoint. */
411 bptlen
-= (membpt
+ bptlen
) - (memaddr
+ len
);
414 memcpy (myaddr
+ membpt
- memaddr
,
415 b
->shadow_contents
+ bptoffset
, bptlen
);
417 if (membpt
> memaddr
)
419 /* Copy the section of memory before the breakpoint. */
420 status
= read_memory_nobpt (memaddr
, myaddr
, membpt
- memaddr
);
425 if (membpt
+ bptlen
< memaddr
+ len
)
427 /* Copy the section of memory after the breakpoint. */
428 status
= read_memory_nobpt
430 myaddr
+ membpt
+ bptlen
- memaddr
,
431 memaddr
+ len
- (membpt
+ bptlen
));
438 /* Nothing overlaps. Just call read_memory_noerr. */
439 return target_read_memory (memaddr
, myaddr
, len
);
442 /* insert_breakpoints is used when starting or continuing the program.
443 remove_breakpoints is used when the program stops.
444 Both return zero if successful,
445 or an `errno' value if could not write the inferior. */
448 insert_breakpoints ()
450 register struct breakpoint
*b
, *temp
;
452 int disabled_breaks
= 0;
454 ALL_BREAKPOINTS_SAFE (b
, temp
)
455 if (b
->type
!= bp_watchpoint
456 && b
->type
!= bp_hardware_watchpoint
457 && b
->type
!= bp_read_watchpoint
458 && b
->type
!= bp_access_watchpoint
459 && b
->enable
!= disabled
460 && b
->enable
!= shlib_disabled
464 if (b
->type
== bp_hardware_breakpoint
)
465 val
= target_insert_hw_breakpoint(b
->address
, b
->shadow_contents
);
467 val
= target_insert_breakpoint(b
->address
, b
->shadow_contents
);
470 /* Can't set the breakpoint. */
471 #if defined (DISABLE_UNSETTABLE_BREAK)
472 if (DISABLE_UNSETTABLE_BREAK (b
->address
))
475 b
->enable
= shlib_disabled
;
476 if (!disabled_breaks
)
478 target_terminal_ours_for_output ();
479 fprintf_unfiltered (gdb_stderr
,
480 "Cannot insert breakpoint %d:\n", b
->number
);
481 printf_filtered ("Temporarily disabling shared library breakpoints:\n");
484 printf_filtered ("%d ", b
->number
);
489 target_terminal_ours_for_output ();
490 fprintf_unfiltered (gdb_stderr
, "Cannot insert breakpoint %d:\n", b
->number
);
491 #ifdef ONE_PROCESS_WRITETEXT
492 fprintf_unfiltered (gdb_stderr
,
493 "The same program may be running in another process.\n");
495 memory_error (val
, b
->address
); /* which bombs us out */
501 else if ((b
->type
== bp_hardware_watchpoint
||
502 b
->type
== bp_read_watchpoint
||
503 b
->type
== bp_access_watchpoint
)
504 && b
->enable
== enabled
508 struct frame_info
*saved_frame
;
509 int saved_level
, within_current_scope
;
510 value_ptr mark
= value_mark ();
513 /* Save the current frame and level so we can restore it after
514 evaluating the watchpoint expression on its own frame. */
515 saved_frame
= selected_frame
;
516 saved_level
= selected_frame_level
;
518 /* Determine if the watchpoint is within scope. */
519 if (b
->exp_valid_block
== NULL
)
520 within_current_scope
= 1;
523 struct frame_info
*fi
=
524 find_frame_addr_in_frame_chain (b
->watchpoint_frame
);
525 within_current_scope
= (fi
!= NULL
);
526 if (within_current_scope
)
527 select_frame (fi
, -1);
530 if (within_current_scope
)
532 /* Evaluate the expression and cut the chain of values
533 produced off from the value chain. */
534 v
= evaluate_expression (b
->exp
);
535 value_release_to_mark (mark
);
540 /* Look at each value on the value chain. */
541 for ( ; v
; v
=v
->next
)
543 /* If it's a memory location, then we must watch it. */
544 if (v
->lval
== lval_memory
)
548 addr
= VALUE_ADDRESS (v
) + VALUE_OFFSET (v
);
549 len
= TYPE_LENGTH (VALUE_TYPE (v
));
551 if (b
->type
== bp_read_watchpoint
)
553 else if (b
->type
== bp_access_watchpoint
)
556 val
= target_insert_watchpoint (addr
, len
, type
);
565 /* Failure to insert a watchpoint on any memory value in the
566 value chain brings us here. */
568 warning ("Hardware watchpoint %d: Could not insert watchpoint\n",
574 Hardware watchpoint %d deleted because the program has left the block in\n\
575 which its expression is valid.\n", b
->number
);
576 if (b
->related_breakpoint
)
577 delete_breakpoint (b
->related_breakpoint
);
578 delete_breakpoint (b
);
581 /* Restore the frame and level. */
582 select_frame (saved_frame
, saved_level
);
585 printf_filtered ("\n");
591 remove_breakpoints ()
593 register struct breakpoint
*b
;
600 val
= remove_breakpoint (b
);
610 remove_breakpoint (b
)
611 struct breakpoint
*b
;
615 if (b
->type
!= bp_watchpoint
616 && b
->type
!= bp_hardware_watchpoint
617 && b
->type
!= bp_read_watchpoint
618 && b
->type
!= bp_access_watchpoint
)
620 if (b
->type
== bp_hardware_breakpoint
)
621 val
= target_remove_hw_breakpoint(b
->address
, b
->shadow_contents
);
623 val
= target_remove_breakpoint(b
->address
, b
->shadow_contents
);
628 else if ((b
->type
== bp_hardware_watchpoint
||
629 b
->type
== bp_read_watchpoint
||
630 b
->type
== bp_access_watchpoint
)
631 && b
->enable
== enabled
637 /* Walk down the saved value chain. */
638 for (v
= b
->val_chain
; v
; v
= v
->next
)
640 /* For each memory reference remove the watchpoint
642 if (v
->lval
== lval_memory
)
646 addr
= VALUE_ADDRESS (v
) + VALUE_OFFSET (v
);
647 len
= TYPE_LENGTH (VALUE_TYPE (v
));
648 val
= target_remove_watchpoint (addr
, len
, b
->type
);
654 /* Failure to remove any of the hardware watchpoints comes here. */
656 warning ("Hardware watchpoint %d: Could not remove watchpoint\n",
659 /* Free the saved value chain. We will construct a new one
660 the next time the watchpoint is inserted. */
661 for (v
= b
->val_chain
; v
; v
= n
)
671 /* Clear the "inserted" flag in all breakpoints. */
674 mark_breakpoints_out ()
676 register struct breakpoint
*b
;
682 /* Clear the "inserted" flag in all breakpoints and delete any breakpoints
683 which should go away between runs of the program. */
686 breakpoint_init_inferior ()
688 register struct breakpoint
*b
, *temp
;
690 ALL_BREAKPOINTS_SAFE (b
, temp
)
694 /* If the call dummy breakpoint is at the entry point it will
695 cause problems when the inferior is rerun, so we better
697 if (b
->type
== bp_call_dummy
)
698 delete_breakpoint (b
);
700 /* Likewise for scope breakpoints. */
701 if (b
->type
== bp_watchpoint_scope
)
702 delete_breakpoint (b
);
704 /* Likewise for watchpoints on local expressions. */
705 if ((b
->type
== bp_watchpoint
|| b
->type
== bp_hardware_watchpoint
||
706 b
->type
== bp_read_watchpoint
|| b
->type
== bp_access_watchpoint
)
707 && b
->exp_valid_block
!= NULL
)
708 delete_breakpoint (b
);
712 /* breakpoint_here_p (PC) returns 1 if an enabled breakpoint exists at PC.
713 When continuing from a location with a breakpoint,
714 we actually single step once before calling insert_breakpoints. */
717 breakpoint_here_p (pc
)
720 register struct breakpoint
*b
;
723 if (b
->enable
!= disabled
724 && b
->enable
!= shlib_disabled
731 /* Return nonzero if FRAME is a dummy frame. We can't use PC_IN_CALL_DUMMY
732 because figuring out the saved SP would take too much time, at least using
733 get_saved_register on the 68k. This means that for this function to
734 work right a port must use the bp_call_dummy breakpoint. */
737 frame_in_dummy (frame
)
738 struct frame_info
*frame
;
740 struct breakpoint
*b
;
745 static unsigned LONGEST dummy
[] = CALL_DUMMY
;
747 if (b
->type
== bp_call_dummy
748 && b
->frame
== frame
->frame
750 /* We need to check the PC as well as the frame on the sparc,
751 for signals.exp in the testsuite. */
754 - sizeof (dummy
) / sizeof (LONGEST
) * REGISTER_SIZE
))
755 && frame
->pc
<= b
->address
)
758 #endif /* CALL_DUMMY */
762 /* breakpoint_match_thread (PC, PID) returns true if the breakpoint at PC
763 is valid for process/thread PID. */
766 breakpoint_thread_match (pc
, pid
)
770 struct breakpoint
*b
;
773 thread
= pid_to_thread_id (pid
);
776 if (b
->enable
!= disabled
777 && b
->enable
!= shlib_disabled
779 && (b
->thread
== -1 || b
->thread
== thread
))
786 /* bpstat stuff. External routines' interfaces are documented
789 /* Clear a bpstat so that it says we are not at any breakpoint.
790 Also free any storage that is part of a bpstat. */
805 if (p
->old_val
!= NULL
)
806 value_free (p
->old_val
);
813 /* Return a copy of a bpstat. Like "bs1 = bs2" but all storage that
814 is part of the bpstat is copied as well. */
822 bpstat retval
= NULL
;
827 for (; bs
!= NULL
; bs
= bs
->next
)
829 tmp
= (bpstat
) xmalloc (sizeof (*tmp
));
830 memcpy (tmp
, bs
, sizeof (*tmp
));
832 /* This is the first thing in the chain. */
842 /* Find the bpstat associated with this breakpoint */
845 bpstat_find_breakpoint(bsp
, breakpoint
)
847 struct breakpoint
*breakpoint
;
849 if (bsp
== NULL
) return NULL
;
851 for (;bsp
!= NULL
; bsp
= bsp
->next
) {
852 if (bsp
->breakpoint_at
== breakpoint
) return bsp
;
857 /* Return the breakpoint number of the first breakpoint we are stopped
858 at. *BSP upon return is a bpstat which points to the remaining
859 breakpoints stopped at (but which is not guaranteed to be good for
860 anything but further calls to bpstat_num).
861 Return 0 if passed a bpstat which does not indicate any breakpoints. */
867 struct breakpoint
*b
;
870 return 0; /* No more breakpoint values */
873 b
= (*bsp
)->breakpoint_at
;
876 return -1; /* breakpoint that's been deleted since */
878 return b
->number
; /* We have its number */
882 /* Modify BS so that the actions will not be performed. */
885 bpstat_clear_actions (bs
)
888 for (; bs
!= NULL
; bs
= bs
->next
)
891 if (bs
->old_val
!= NULL
)
893 value_free (bs
->old_val
);
899 /* Stub for cleaning up our state if we error-out of a breakpoint command */
902 cleanup_executing_breakpoints (ignore
)
905 executing_breakpoint_commands
= 0;
908 /* Execute all the commands associated with all the breakpoints at this
909 location. Any of these commands could cause the process to proceed
910 beyond this point, etc. We look out for such changes by checking
911 the global "breakpoint_proceeded" after each command. */
914 bpstat_do_actions (bsp
)
918 struct cleanup
*old_chain
;
919 struct command_line
*cmd
;
921 executing_breakpoint_commands
= 1;
922 old_chain
= make_cleanup (cleanup_executing_breakpoints
, 0);
927 breakpoint_proceeded
= 0;
928 for (; bs
!= NULL
; bs
= bs
->next
)
933 execute_control_command (cmd
);
936 if (breakpoint_proceeded
)
937 /* The inferior is proceeded by the command; bomb out now.
938 The bpstat chain has been blown away by wait_for_inferior.
939 But since execution has stopped again, there is a new bpstat
940 to look at, so start over. */
946 executing_breakpoint_commands
= 0;
947 discard_cleanups (old_chain
);
950 /* This is the normal print_it function for a bpstat. In the future,
951 much of this logic could (should?) be moved to bpstat_stop_status,
952 by having it set different print_it functions. */
958 /* bs->breakpoint_at can be NULL if it was a momentary breakpoint
959 which has since been deleted. */
960 if (bs
->breakpoint_at
== NULL
961 || (bs
->breakpoint_at
->type
!= bp_breakpoint
962 && bs
->breakpoint_at
->type
!= bp_hardware_breakpoint
963 && bs
->breakpoint_at
->type
!= bp_watchpoint
964 && bs
->breakpoint_at
->type
!= bp_read_watchpoint
965 && bs
->breakpoint_at
->type
!= bp_access_watchpoint
966 && bs
->breakpoint_at
->type
!= bp_hardware_watchpoint
))
969 if (bs
->breakpoint_at
->type
== bp_breakpoint
||
970 bs
->breakpoint_at
->type
== bp_hardware_breakpoint
)
972 /* I think the user probably only wants to see one breakpoint
973 number, not all of them. */
974 annotate_breakpoint (bs
->breakpoint_at
->number
);
975 printf_filtered ("\nBreakpoint %d, ", bs
->breakpoint_at
->number
);
978 else if ((bs
->old_val
!= NULL
) &&
979 (bs
->breakpoint_at
->type
== bp_watchpoint
||
980 bs
->breakpoint_at
->type
== bp_access_watchpoint
||
981 bs
->breakpoint_at
->type
== bp_hardware_watchpoint
))
983 annotate_watchpoint (bs
->breakpoint_at
->number
);
984 mention (bs
->breakpoint_at
);
985 printf_filtered ("\nOld value = ");
986 value_print (bs
->old_val
, gdb_stdout
, 0, Val_pretty_default
);
987 printf_filtered ("\nNew value = ");
988 value_print (bs
->breakpoint_at
->val
, gdb_stdout
, 0,
990 printf_filtered ("\n");
991 value_free (bs
->old_val
);
993 /* More than one watchpoint may have been triggered. */
996 else if (bs
->breakpoint_at
->type
== bp_access_watchpoint
||
997 bs
->breakpoint_at
->type
== bp_read_watchpoint
)
999 mention (bs
->breakpoint_at
);
1000 printf_filtered ("\nValue = ");
1001 value_print (bs
->breakpoint_at
->val
, gdb_stdout
, 0,
1002 Val_pretty_default
);
1003 printf_filtered ("\n");
1006 /* We can't deal with it. Maybe another member of the bpstat chain can. */
1010 /* Print a message indicating what happened. Returns nonzero to
1011 say that only the source line should be printed after this (zero
1012 return means print the frame as well as the source line). */
1013 /* Currently we always return zero. */
1023 val
= (*bs
->print_it
) (bs
);
1027 /* Maybe another breakpoint in the chain caused us to stop.
1028 (Currently all watchpoints go on the bpstat whether hit or
1029 not. That probably could (should) be changed, provided care is taken
1030 with respect to bpstat_explains_signal). */
1032 return bpstat_print (bs
->next
);
1034 /* We reached the end of the chain without printing anything. */
1038 /* Evaluate the expression EXP and return 1 if value is zero.
1039 This is used inside a catch_errors to evaluate the breakpoint condition.
1040 The argument is a "struct expression *" that has been cast to char * to
1041 make it pass through catch_errors. */
1044 breakpoint_cond_eval (exp
)
1047 value_ptr mark
= value_mark ();
1048 int i
= !value_true (evaluate_expression ((struct expression
*)exp
));
1049 value_free_to_mark (mark
);
1053 /* Allocate a new bpstat and chain it to the current one. */
1056 bpstat_alloc (b
, cbs
)
1057 register struct breakpoint
*b
;
1058 bpstat cbs
; /* Current "bs" value */
1062 bs
= (bpstat
) xmalloc (sizeof (*bs
));
1064 bs
->breakpoint_at
= b
;
1065 /* If the condition is false, etc., don't do the commands. */
1066 bs
->commands
= NULL
;
1068 bs
->print_it
= print_it_normal
;
1072 /* Possible return values for watchpoint_check (this can't be an enum
1073 because of check_errors). */
1074 /* The watchpoint has been deleted. */
1075 #define WP_DELETED 1
1076 /* The value has changed. */
1077 #define WP_VALUE_CHANGED 2
1078 /* The value has not changed. */
1079 #define WP_VALUE_NOT_CHANGED 3
1081 #define BP_TEMPFLAG 1
1082 #define BP_HARDWAREFLAG 2
1084 /* Check watchpoint condition. */
1087 watchpoint_check (p
)
1090 bpstat bs
= (bpstat
) p
;
1091 struct breakpoint
*b
;
1092 struct frame_info
*fr
;
1093 int within_current_scope
;
1095 b
= bs
->breakpoint_at
;
1097 if (b
->exp_valid_block
== NULL
)
1098 within_current_scope
= 1;
1101 /* There is no current frame at this moment. If we're going to have
1102 any chance of handling watchpoints on local variables, we'll need
1103 the frame chain (so we can determine if we're in scope). */
1104 reinit_frame_cache();
1105 fr
= find_frame_addr_in_frame_chain (b
->watchpoint_frame
);
1106 within_current_scope
= (fr
!= NULL
);
1107 if (within_current_scope
)
1108 /* If we end up stopping, the current frame will get selected
1109 in normal_stop. So this call to select_frame won't affect
1111 select_frame (fr
, -1);
1114 if (within_current_scope
)
1116 /* We use value_{,free_to_}mark because it could be a
1117 *long* time before we return to the command level and
1118 call free_all_values. We can't call free_all_values because
1119 we might be in the middle of evaluating a function call. */
1121 value_ptr mark
= value_mark ();
1122 value_ptr new_val
= evaluate_expression (bs
->breakpoint_at
->exp
);
1123 if (!value_equal (b
->val
, new_val
))
1125 release_value (new_val
);
1126 value_free_to_mark (mark
);
1127 bs
->old_val
= b
->val
;
1129 /* We will stop here */
1130 return WP_VALUE_CHANGED
;
1134 /* Nothing changed, don't do anything. */
1135 value_free_to_mark (mark
);
1136 /* We won't stop here */
1137 return WP_VALUE_NOT_CHANGED
;
1142 /* This seems like the only logical thing to do because
1143 if we temporarily ignored the watchpoint, then when
1144 we reenter the block in which it is valid it contains
1145 garbage (in the case of a function, it may have two
1146 garbage values, one before and one after the prologue).
1147 So we can't even detect the first assignment to it and
1148 watch after that (since the garbage may or may not equal
1149 the first value assigned). */
1151 Watchpoint %d deleted because the program has left the block in\n\
1152 which its expression is valid.\n", bs
->breakpoint_at
->number
);
1153 if (b
->related_breakpoint
)
1154 delete_breakpoint (b
->related_breakpoint
);
1155 delete_breakpoint (b
);
1161 /* This is used when everything which needs to be printed has
1162 already been printed. But we still want to print the frame. */
1170 /* This is used when nothing should be printed for this bpstat entry. */
1179 /* Get a bpstat associated with having just stopped at address *PC
1180 and frame address CORE_ADDRESS. Update *PC to point at the
1181 breakpoint (if we hit a breakpoint). NOT_A_BREAKPOINT is nonzero
1182 if this is known to not be a real breakpoint (it could still be a
1183 watchpoint, though). */
1185 /* Determine whether we stopped at a breakpoint, etc, or whether we
1186 don't understand this stop. Result is a chain of bpstat's such that:
1188 if we don't understand the stop, the result is a null pointer.
1190 if we understand why we stopped, the result is not null.
1192 Each element of the chain refers to a particular breakpoint or
1193 watchpoint at which we have stopped. (We may have stopped for
1194 several reasons concurrently.)
1196 Each element of the chain has valid next, breakpoint_at,
1197 commands, FIXME??? fields.
1202 bpstat_stop_status (pc
, not_a_breakpoint
)
1204 int not_a_breakpoint
;
1206 register struct breakpoint
*b
, *temp
;
1208 #if DECR_PC_AFTER_BREAK != 0 || defined (SHIFT_INST_REGS)
1209 /* True if we've hit a breakpoint (as opposed to a watchpoint). */
1210 int real_breakpoint
= 0;
1212 /* Root of the chain of bpstat's */
1213 struct bpstats root_bs
[1];
1214 /* Pointer to the last thing in the chain currently. */
1215 bpstat bs
= root_bs
;
1216 static char message1
[] =
1217 "Error evaluating expression for watchpoint %d\n";
1218 char message
[sizeof (message1
) + 30 /* slop */];
1220 /* Get the address where the breakpoint would have been. */
1221 bp_addr
= *pc
- DECR_PC_AFTER_BREAK
;
1223 ALL_BREAKPOINTS_SAFE (b
, temp
)
1225 if (b
->enable
== disabled
1226 || b
->enable
== shlib_disabled
)
1229 if (b
->type
!= bp_watchpoint
1230 && b
->type
!= bp_hardware_watchpoint
1231 && b
->type
!= bp_read_watchpoint
1232 && b
->type
!= bp_access_watchpoint
1233 && b
->type
!= bp_hardware_breakpoint
1234 && b
->address
!= bp_addr
)
1237 if (b
->type
== bp_hardware_breakpoint
1238 && b
->address
!= (bp_addr
- DECR_PC_AFTER_HW_BREAK
))
1241 if (b
->type
!= bp_watchpoint
1242 && b
->type
!= bp_hardware_watchpoint
1243 && b
->type
!= bp_read_watchpoint
1244 && b
->type
!= bp_access_watchpoint
1245 && not_a_breakpoint
)
1248 /* Come here if it's a watchpoint, or if the break address matches */
1252 bs
= bpstat_alloc (b
, bs
); /* Alloc a bpstat to explain stop */
1257 sprintf (message
, message1
, b
->number
);
1258 if (b
->type
== bp_watchpoint
|| b
->type
== bp_hardware_watchpoint
)
1260 switch (catch_errors (watchpoint_check
, (char *) bs
, message
,
1264 /* We've already printed what needs to be printed. */
1265 bs
->print_it
= print_it_done
;
1268 case WP_VALUE_CHANGED
:
1271 case WP_VALUE_NOT_CHANGED
:
1273 bs
->print_it
= print_it_noop
;
1280 /* Error from catch_errors. */
1281 printf_filtered ("Watchpoint %d deleted.\n", b
->number
);
1282 if (b
->related_breakpoint
)
1283 delete_breakpoint (b
->related_breakpoint
);
1284 delete_breakpoint (b
);
1285 /* We've already printed what needs to be printed. */
1286 bs
->print_it
= print_it_done
;
1292 else if (b
->type
== bp_read_watchpoint
|| b
->type
== bp_access_watchpoint
)
1298 addr
= target_stopped_data_address();
1299 if (addr
== 0) continue;
1300 for (v
= b
->val_chain
; v
; v
= v
->next
)
1302 if (v
->lval
== lval_memory
)
1306 vaddr
= VALUE_ADDRESS (v
) + VALUE_OFFSET (v
);
1312 switch (catch_errors (watchpoint_check
, (char *) bs
, message
,
1316 /* We've already printed what needs to be printed. */
1317 bs
->print_it
= print_it_done
;
1320 case WP_VALUE_CHANGED
:
1321 case WP_VALUE_NOT_CHANGED
:
1327 /* Error from catch_errors. */
1328 printf_filtered ("Watchpoint %d deleted.\n", b
->number
);
1329 if (b
->related_breakpoint
)
1330 delete_breakpoint (b
->related_breakpoint
);
1331 delete_breakpoint (b
);
1332 /* We've already printed what needs to be printed. */
1333 bs
->print_it
= print_it_done
;
1337 #if DECR_PC_AFTER_BREAK != 0 || defined (SHIFT_INST_REGS)
1339 real_breakpoint
= 1;
1342 if (b
->frame
&& b
->frame
!= (get_current_frame ())->frame
)
1346 int value_is_zero
= 0;
1350 /* Need to select the frame, with all that implies
1351 so that the conditions will have the right context. */
1352 select_frame (get_current_frame (), 0);
1354 = catch_errors (breakpoint_cond_eval
, (char *)(b
->cond
),
1355 "Error in testing breakpoint condition:\n",
1357 /* FIXME-someday, should give breakpoint # */
1360 if (b
->cond
&& value_is_zero
)
1364 else if (b
->ignore_count
> 0)
1371 /* We will stop here */
1372 if (b
->disposition
== disable
)
1373 b
->enable
= disabled
;
1374 bs
->commands
= b
->commands
;
1377 if (bs
->commands
&& STREQ ("silent", bs
->commands
->line
))
1379 bs
->commands
= bs
->commands
->next
;
1384 /* Print nothing for this entry if we dont stop or if we dont print. */
1385 if (bs
->stop
== 0 || bs
->print
== 0)
1386 bs
->print_it
= print_it_noop
;
1389 bs
->next
= NULL
; /* Terminate the chain */
1390 bs
= root_bs
->next
; /* Re-grab the head of the chain */
1391 #if DECR_PC_AFTER_BREAK != 0 || defined (SHIFT_INST_REGS)
1394 if (real_breakpoint
)
1397 #if defined (SHIFT_INST_REGS)
1399 #else /* No SHIFT_INST_REGS. */
1401 #endif /* No SHIFT_INST_REGS. */
1404 #endif /* DECR_PC_AFTER_BREAK != 0. */
1406 /* The value of a hardware watchpoint hasn't changed, but the
1407 intermediate memory locations we are watching may have. */
1408 if (bs
&& ! bs
->stop
&&
1409 (bs
->breakpoint_at
->type
== bp_hardware_watchpoint
||
1410 bs
->breakpoint_at
->type
== bp_read_watchpoint
||
1411 bs
->breakpoint_at
->type
== bp_access_watchpoint
))
1413 remove_breakpoints ();
1414 insert_breakpoints ();
1419 /* Tell what to do about this bpstat. */
1424 /* Classify each bpstat as one of the following. */
1426 /* This bpstat element has no effect on the main_action. */
1429 /* There was a watchpoint, stop but don't print. */
1432 /* There was a watchpoint, stop and print. */
1435 /* There was a breakpoint but we're not stopping. */
1438 /* There was a breakpoint, stop but don't print. */
1441 /* There was a breakpoint, stop and print. */
1444 /* We hit the longjmp breakpoint. */
1447 /* We hit the longjmp_resume breakpoint. */
1450 /* We hit the step_resume breakpoint. */
1453 /* We hit the through_sigtramp breakpoint. */
1456 /* We hit the shared library event breakpoint. */
1459 /* This is just used to count how many enums there are. */
1463 /* Here is the table which drives this routine. So that we can
1464 format it pretty, we define some abbreviations for the
1465 enum bpstat_what codes. */
1466 #define kc BPSTAT_WHAT_KEEP_CHECKING
1467 #define ss BPSTAT_WHAT_STOP_SILENT
1468 #define sn BPSTAT_WHAT_STOP_NOISY
1469 #define sgl BPSTAT_WHAT_SINGLE
1470 #define slr BPSTAT_WHAT_SET_LONGJMP_RESUME
1471 #define clr BPSTAT_WHAT_CLEAR_LONGJMP_RESUME
1472 #define clrs BPSTAT_WHAT_CLEAR_LONGJMP_RESUME_SINGLE
1473 #define sr BPSTAT_WHAT_STEP_RESUME
1474 #define ts BPSTAT_WHAT_THROUGH_SIGTRAMP
1475 #define shl BPSTAT_WHAT_CHECK_SHLIBS
1477 /* "Can't happen." Might want to print an error message.
1478 abort() is not out of the question, but chances are GDB is just
1479 a bit confused, not unusable. */
1480 #define err BPSTAT_WHAT_STOP_NOISY
1482 /* Given an old action and a class, come up with a new action. */
1483 /* One interesting property of this table is that wp_silent is the same
1484 as bp_silent and wp_noisy is the same as bp_noisy. That is because
1485 after stopping, the check for whether to step over a breakpoint
1486 (BPSTAT_WHAT_SINGLE type stuff) is handled in proceed() without
1487 reference to how we stopped. We retain separate wp_silent and bp_silent
1488 codes in case we want to change that someday. */
1490 /* step_resume entries: a step resume breakpoint overrides another
1491 breakpoint of signal handling (see comment in wait_for_inferior
1492 at first IN_SIGTRAMP where we set the step_resume breakpoint). */
1493 /* We handle the through_sigtramp_breakpoint the same way; having both
1494 one of those and a step_resume_breakpoint is probably very rare (?). */
1496 static const enum bpstat_what_main_action
1497 table
[(int)class_last
][(int)BPSTAT_WHAT_LAST
] =
1500 /* kc ss sn sgl slr clr clrs sr ts shl
1502 /*no_effect*/ {kc
, ss
, sn
, sgl
, slr
, clr
, clrs
, sr
, ts
, shl
},
1503 /*wp_silent*/ {ss
, ss
, sn
, ss
, ss
, ss
, ss
, sr
, ts
, shl
},
1504 /*wp_noisy*/ {sn
, sn
, sn
, sn
, sn
, sn
, sn
, sr
, ts
, shl
},
1505 /*bp_nostop*/ {sgl
, ss
, sn
, sgl
, slr
, clrs
, clrs
, sr
, ts
, shl
},
1506 /*bp_silent*/ {ss
, ss
, sn
, ss
, ss
, ss
, ss
, sr
, ts
, shl
},
1507 /*bp_noisy*/ {sn
, sn
, sn
, sn
, sn
, sn
, sn
, sr
, ts
, shl
},
1508 /*long_jump*/ {slr
, ss
, sn
, slr
, err
, err
, err
, sr
, ts
, shl
},
1509 /*long_resume*/ {clr
, ss
, sn
, clrs
, err
, err
, err
, sr
, ts
, shl
},
1510 /*step_resume*/ {sr
, sr
, sr
, sr
, sr
, sr
, sr
, sr
, ts
, shl
},
1511 /*through_sig*/ {ts
, ts
, ts
, ts
, ts
, ts
, ts
, ts
, ts
, shl
},
1512 /*shlib*/ {shl
, shl
, shl
, shl
, shl
, shl
, shl
, shl
, ts
, shl
}
1525 enum bpstat_what_main_action current_action
= BPSTAT_WHAT_KEEP_CHECKING
;
1526 struct bpstat_what retval
;
1528 retval
.call_dummy
= 0;
1529 for (; bs
!= NULL
; bs
= bs
->next
)
1531 enum class bs_class
= no_effect
;
1532 if (bs
->breakpoint_at
== NULL
)
1533 /* I suspect this can happen if it was a momentary breakpoint
1534 which has since been deleted. */
1536 switch (bs
->breakpoint_at
->type
)
1539 case bp_hardware_breakpoint
:
1545 bs_class
= bp_noisy
;
1547 bs_class
= bp_silent
;
1550 bs_class
= bp_nostop
;
1553 case bp_hardware_watchpoint
:
1554 case bp_read_watchpoint
:
1555 case bp_access_watchpoint
:
1559 bs_class
= wp_noisy
;
1561 bs_class
= wp_silent
;
1564 /* There was a watchpoint, but we're not stopping. This requires
1565 no further action. */
1566 bs_class
= no_effect
;
1569 bs_class
= long_jump
;
1571 case bp_longjmp_resume
:
1572 bs_class
= long_resume
;
1574 case bp_step_resume
:
1577 bs_class
= step_resume
;
1580 /* It is for the wrong frame. */
1581 bs_class
= bp_nostop
;
1583 case bp_through_sigtramp
:
1584 bs_class
= through_sig
;
1586 case bp_watchpoint_scope
:
1587 bs_class
= bp_nostop
;
1589 case bp_shlib_event
:
1590 bs_class
= shlib_event
;
1593 /* Make sure the action is stop (silent or noisy), so infrun.c
1594 pops the dummy frame. */
1595 bs_class
= bp_silent
;
1596 retval
.call_dummy
= 1;
1599 current_action
= table
[(int)bs_class
][(int)current_action
];
1601 retval
.main_action
= current_action
;
1605 /* Nonzero if we should step constantly (e.g. watchpoints on machines
1606 without hardware support). This isn't related to a specific bpstat,
1607 just to things like whether watchpoints are set. */
1610 bpstat_should_step ()
1612 struct breakpoint
*b
;
1614 if (b
->enable
== enabled
&& b
->type
== bp_watchpoint
)
1619 /* Print information on breakpoint number BNUM, or -1 if all.
1620 If WATCHPOINTS is zero, process only breakpoints; if WATCHPOINTS
1621 is nonzero, process only watchpoints. */
1624 breakpoint_1 (bnum
, allflag
)
1628 register struct breakpoint
*b
;
1629 register struct command_line
*l
;
1630 register struct symbol
*sym
;
1631 CORE_ADDR last_addr
= (CORE_ADDR
)-1;
1632 int found_a_breakpoint
= 0;
1633 static char *bptypes
[] = {"breakpoint", "hw breakpoint",
1634 "until", "finish", "watchpoint",
1635 "hw watchpoint", "read watchpoint",
1636 "acc watchpoint", "longjmp",
1637 "longjmp resume", "step resume",
1639 "watchpoint scope", "call dummy",
1641 static char *bpdisps
[] = {"del", "dis", "keep"};
1642 static char bpenables
[] = "ny";
1643 char wrap_indent
[80];
1647 || bnum
== b
->number
)
1649 /* We only print out user settable breakpoints unless the allflag is set. */
1651 && b
->type
!= bp_breakpoint
1652 && b
->type
!= bp_hardware_breakpoint
1653 && b
->type
!= bp_watchpoint
1654 && b
->type
!= bp_read_watchpoint
1655 && b
->type
!= bp_access_watchpoint
1656 && b
->type
!= bp_hardware_watchpoint
)
1659 if (!found_a_breakpoint
++)
1661 annotate_breakpoints_headers ();
1664 printf_filtered ("Num ");
1666 printf_filtered ("Type ");
1668 printf_filtered ("Disp ");
1670 printf_filtered ("Enb ");
1674 printf_filtered ("Address ");
1677 printf_filtered ("What\n");
1679 annotate_breakpoints_table ();
1684 printf_filtered ("%-3d ", b
->number
);
1686 printf_filtered ("%-14s ", bptypes
[(int)b
->type
]);
1688 printf_filtered ("%-4s ", bpdisps
[(int)b
->disposition
]);
1690 printf_filtered ("%-3c ", bpenables
[(int)b
->enable
]);
1692 strcpy (wrap_indent
, " ");
1694 strcat (wrap_indent
, " ");
1698 case bp_hardware_watchpoint
:
1699 case bp_read_watchpoint
:
1700 case bp_access_watchpoint
:
1701 /* Field 4, the address, is omitted (which makes the columns
1702 not line up too nicely with the headers, but the effect
1703 is relatively readable). */
1705 print_expression (b
->exp
, gdb_stdout
);
1709 case bp_hardware_breakpoint
:
1713 case bp_longjmp_resume
:
1714 case bp_step_resume
:
1715 case bp_through_sigtramp
:
1716 case bp_watchpoint_scope
:
1718 case bp_shlib_event
:
1722 /* FIXME-32x64: need a print_address_numeric with
1726 local_hex_string_custom
1727 ((unsigned long) b
->address
, "08l"));
1732 last_addr
= b
->address
;
1735 sym
= find_pc_function (b
->address
);
1738 fputs_filtered ("in ", gdb_stdout
);
1739 fputs_filtered (SYMBOL_SOURCE_NAME (sym
), gdb_stdout
);
1740 wrap_here (wrap_indent
);
1741 fputs_filtered (" at ", gdb_stdout
);
1743 fputs_filtered (b
->source_file
, gdb_stdout
);
1744 printf_filtered (":%d", b
->line_number
);
1747 print_address_symbolic (b
->address
, gdb_stdout
, demangle
, " ");
1751 printf_filtered ("\n");
1757 printf_filtered ("\tstop only in stack frame at ");
1758 print_address_numeric (b
->frame
, 1, gdb_stdout
);
1759 printf_filtered ("\n");
1766 printf_filtered ("\tstop only if ");
1767 print_expression (b
->cond
, gdb_stdout
);
1768 printf_filtered ("\n");
1771 if (show_breakpoint_hit_counts
&& b
->hit_count
)
1773 /* FIXME should make an annotation for this */
1775 printf_filtered ("\tbreakpoint already hit %d time%s\n",
1776 b
->hit_count
, (b
->hit_count
== 1 ? "" : "s"));
1779 if (b
->ignore_count
)
1783 printf_filtered ("\tignore next %d hits\n", b
->ignore_count
);
1786 if ((l
= b
->commands
))
1792 print_command_line (l
, 4);
1798 if (!found_a_breakpoint
)
1801 printf_filtered ("No breakpoints or watchpoints.\n");
1803 printf_filtered ("No breakpoint or watchpoint number %d.\n", bnum
);
1806 /* Compare against (CORE_ADDR)-1 in case some compiler decides
1807 that a comparison of an unsigned with -1 is always false. */
1808 if (last_addr
!= (CORE_ADDR
)-1)
1809 set_next_address (last_addr
);
1811 annotate_breakpoints_table_end ();
1816 breakpoints_info (bnum_exp
, from_tty
)
1823 bnum
= parse_and_eval_address (bnum_exp
);
1825 breakpoint_1 (bnum
, 0);
1828 #if MAINTENANCE_CMDS
1832 maintenance_info_breakpoints (bnum_exp
, from_tty
)
1839 bnum
= parse_and_eval_address (bnum_exp
);
1841 breakpoint_1 (bnum
, 1);
1846 /* Print a message describing any breakpoints set at PC. */
1849 describe_other_breakpoints (pc
)
1850 register CORE_ADDR pc
;
1852 register int others
= 0;
1853 register struct breakpoint
*b
;
1856 if (b
->address
== pc
)
1860 printf_filtered ("Note: breakpoint%s ", (others
> 1) ? "s" : "");
1862 if (b
->address
== pc
)
1868 ((b
->enable
== disabled
|| b
->enable
== shlib_disabled
)
1869 ? " (disabled)" : ""),
1870 (others
> 1) ? "," : ((others
== 1) ? " and" : ""));
1872 printf_filtered ("also set at pc ");
1873 print_address_numeric (pc
, 1, gdb_stdout
);
1874 printf_filtered (".\n");
1878 /* Set the default place to put a breakpoint
1879 for the `break' command with no arguments. */
1882 set_default_breakpoint (valid
, addr
, symtab
, line
)
1885 struct symtab
*symtab
;
1888 default_breakpoint_valid
= valid
;
1889 default_breakpoint_address
= addr
;
1890 default_breakpoint_symtab
= symtab
;
1891 default_breakpoint_line
= line
;
1894 /* Rescan breakpoints at address ADDRESS,
1895 marking the first one as "first" and any others as "duplicates".
1896 This is so that the bpt instruction is only inserted once. */
1899 check_duplicates (address
)
1902 register struct breakpoint
*b
;
1903 register int count
= 0;
1905 if (address
== 0) /* Watchpoints are uninteresting */
1909 if (b
->enable
!= disabled
1910 && b
->enable
!= shlib_disabled
1911 && b
->address
== address
)
1914 b
->duplicate
= count
> 1;
1918 /* Low level routine to set a breakpoint.
1919 Takes as args the three things that every breakpoint must have.
1920 Returns the breakpoint object so caller can set other things.
1921 Does not set the breakpoint number!
1922 Does not print anything.
1924 ==> This routine should not be called if there is a chance of later
1925 error(); otherwise it leaves a bogus breakpoint on the chain. Validate
1926 your arguments BEFORE calling this routine! */
1928 static struct breakpoint
*
1929 set_raw_breakpoint (sal
)
1930 struct symtab_and_line sal
;
1932 register struct breakpoint
*b
, *b1
;
1934 b
= (struct breakpoint
*) xmalloc (sizeof (struct breakpoint
));
1935 memset (b
, 0, sizeof (*b
));
1936 b
->address
= sal
.pc
;
1937 if (sal
.symtab
== NULL
)
1938 b
->source_file
= NULL
;
1940 b
->source_file
= savestring (sal
.symtab
->filename
,
1941 strlen (sal
.symtab
->filename
));
1942 b
->language
= current_language
->la_language
;
1943 b
->input_radix
= input_radix
;
1945 b
->line_number
= sal
.line
;
1946 b
->enable
= enabled
;
1949 b
->ignore_count
= 0;
1953 /* Add this breakpoint to the end of the chain
1954 so that a list of breakpoints will come out in order
1955 of increasing numbers. */
1957 b1
= breakpoint_chain
;
1959 breakpoint_chain
= b
;
1967 check_duplicates (sal
.pc
);
1968 breakpoints_changed ();
1973 static int internal_breakpoint_number
= -1;
1975 #ifdef GET_LONGJMP_TARGET
1978 create_longjmp_breakpoint (func_name
)
1981 struct symtab_and_line sal
;
1982 struct breakpoint
*b
;
1984 if (func_name
!= NULL
)
1986 struct minimal_symbol
*m
;
1988 m
= lookup_minimal_symbol_text (func_name
, NULL
, (struct objfile
*)NULL
);
1990 sal
.pc
= SYMBOL_VALUE_ADDRESS (m
);
2000 b
= set_raw_breakpoint (sal
);
2003 b
->type
= func_name
!= NULL
? bp_longjmp
: bp_longjmp_resume
;
2004 b
->disposition
= donttouch
;
2005 b
->enable
= disabled
;
2008 b
->addr_string
= strsave(func_name
);
2009 b
->number
= internal_breakpoint_number
--;
2012 #endif /* #ifdef GET_LONGJMP_TARGET */
2014 /* Call this routine when stepping and nexting to enable a breakpoint if we do
2015 a longjmp(). When we hit that breakpoint, call
2016 set_longjmp_resume_breakpoint() to figure out where we are going. */
2019 enable_longjmp_breakpoint()
2021 register struct breakpoint
*b
;
2024 if (b
->type
== bp_longjmp
)
2026 b
->enable
= enabled
;
2027 check_duplicates (b
->address
);
2032 disable_longjmp_breakpoint()
2034 register struct breakpoint
*b
;
2037 if ( b
->type
== bp_longjmp
2038 || b
->type
== bp_longjmp_resume
)
2040 b
->enable
= disabled
;
2041 check_duplicates (b
->address
);
2047 remove_solib_event_breakpoints ()
2049 register struct breakpoint
*b
, *temp
;
2051 ALL_BREAKPOINTS_SAFE (b
, temp
)
2052 if (b
->type
== bp_shlib_event
)
2053 delete_breakpoint (b
);
2057 create_solib_event_breakpoint (address
)
2060 struct breakpoint
*b
;
2061 struct symtab_and_line sal
;
2066 b
= set_raw_breakpoint (sal
);
2067 b
->number
= internal_breakpoint_number
--;
2068 b
->disposition
= donttouch
;
2069 b
->type
= bp_shlib_event
;
2072 /* Try to reenable any breakpoints in shared libraries. */
2074 re_enable_breakpoints_in_shlibs ()
2076 struct breakpoint
*b
;
2079 if (b
->enable
== shlib_disabled
)
2083 /* Do not reenable the breakpoint if the shared library
2084 is still not mapped in. */
2085 if (target_read_memory (b
->address
, buf
, 1) == 0)
2086 b
->enable
= enabled
;
2093 hw_breakpoint_used_count()
2095 register struct breakpoint
*b
;
2100 if (b
->type
== bp_hardware_breakpoint
&& b
->enable
== enabled
)
2108 hw_watchpoint_used_count(type
, other_type_used
)
2110 int *other_type_used
;
2112 register struct breakpoint
*b
;
2115 *other_type_used
= 0;
2118 if (b
->enable
== enabled
)
2120 if (b
->type
== type
) i
++;
2121 else if ((b
->type
== bp_hardware_watchpoint
||
2122 b
->type
== bp_read_watchpoint
||
2123 b
->type
== bp_access_watchpoint
)
2124 && b
->enable
== enabled
)
2125 *other_type_used
= 1;
2131 /* Call this after hitting the longjmp() breakpoint. Use this to set a new
2132 breakpoint at the target of the jmp_buf.
2134 FIXME - This ought to be done by setting a temporary breakpoint that gets
2135 deleted automatically...
2139 set_longjmp_resume_breakpoint(pc
, frame
)
2141 struct frame_info
*frame
;
2143 register struct breakpoint
*b
;
2146 if (b
->type
== bp_longjmp_resume
)
2149 b
->enable
= enabled
;
2151 b
->frame
= frame
->frame
;
2154 check_duplicates (b
->address
);
2159 /* Set a breakpoint that will evaporate an end of command
2160 at address specified by SAL.
2161 Restrict it to frame FRAME if FRAME is nonzero. */
2164 set_momentary_breakpoint (sal
, frame
, type
)
2165 struct symtab_and_line sal
;
2166 struct frame_info
*frame
;
2169 register struct breakpoint
*b
;
2170 b
= set_raw_breakpoint (sal
);
2172 b
->enable
= enabled
;
2173 b
->disposition
= donttouch
;
2174 b
->frame
= (frame
? frame
->frame
: 0);
2176 /* If we're debugging a multi-threaded program, then we
2177 want momentary breakpoints to be active in only a
2178 single thread of control. */
2179 if (in_thread_list (inferior_pid
))
2180 b
->thread
= pid_to_thread_id (inferior_pid
);
2187 clear_momentary_breakpoints ()
2189 register struct breakpoint
*b
, *temp
;
2190 ALL_BREAKPOINTS_SAFE (b
, temp
)
2191 if (b
->disposition
== delete)
2193 delete_breakpoint (b
);
2199 /* Tell the user we have just set a breakpoint B. */
2203 struct breakpoint
*b
;
2207 /* FIXME: This is misplaced; mention() is called by things (like hitting a
2208 watchpoint) other than breakpoint creation. It should be possible to
2209 clean this up and at the same time replace the random calls to
2210 breakpoint_changed with this hook, as has already been done for
2211 delete_breakpoint_hook and so on. */
2212 if (create_breakpoint_hook
)
2213 create_breakpoint_hook (b
);
2218 printf_filtered ("Watchpoint %d: ", b
->number
);
2219 print_expression (b
->exp
, gdb_stdout
);
2221 case bp_hardware_watchpoint
:
2222 printf_filtered ("Hardware watchpoint %d: ", b
->number
);
2223 print_expression (b
->exp
, gdb_stdout
);
2225 case bp_read_watchpoint
:
2226 printf_filtered ("Hardware read watchpoint %d: ", b
->number
);
2227 print_expression (b
->exp
, gdb_stdout
);
2229 case bp_access_watchpoint
:
2230 printf_filtered ("Hardware access(read/write) watchpoint %d: ",b
->number
);
2231 print_expression (b
->exp
, gdb_stdout
);
2234 printf_filtered ("Breakpoint %d", b
->number
);
2237 case bp_hardware_breakpoint
:
2238 printf_filtered ("Hardware assisted breakpoint %d", b
->number
);
2244 case bp_longjmp_resume
:
2245 case bp_step_resume
:
2246 case bp_through_sigtramp
:
2248 case bp_watchpoint_scope
:
2249 case bp_shlib_event
:
2254 if (addressprint
|| b
->source_file
== NULL
)
2256 printf_filtered (" at ");
2257 print_address_numeric (b
->address
, 1, gdb_stdout
);
2260 printf_filtered (": file %s, line %d.",
2261 b
->source_file
, b
->line_number
);
2263 printf_filtered ("\n");
2267 /* Nobody calls this currently. */
2268 /* Set a breakpoint from a symtab and line.
2269 If TEMPFLAG is nonzero, it is a temporary breakpoint.
2270 ADDR_STRING is a malloc'd string holding the name of where we are
2271 setting the breakpoint. This is used later to re-set it after the
2272 program is relinked and symbols are reloaded.
2273 Print the same confirmation messages that the breakpoint command prints. */
2276 set_breakpoint (s
, line
, tempflag
, addr_string
)
2282 register struct breakpoint
*b
;
2283 struct symtab_and_line sal
;
2288 resolve_sal_pc (&sal
); /* Might error out */
2289 describe_other_breakpoints (sal
.pc
);
2291 b
= set_raw_breakpoint (sal
);
2292 set_breakpoint_count (breakpoint_count
+ 1);
2293 b
->number
= breakpoint_count
;
2294 b
->type
= bp_breakpoint
;
2296 b
->addr_string
= addr_string
;
2297 b
->enable
= enabled
;
2298 b
->disposition
= tempflag
? delete : donttouch
;
2304 /* Set a breakpoint according to ARG (function, linenum or *address)
2305 flag: first bit : 0 non-temporary, 1 temporary.
2306 second bit : 0 normal breakpoint, 1 hardware breakpoint. */
2309 break_command_1 (arg
, flag
, from_tty
)
2313 int tempflag
, hardwareflag
;
2314 struct symtabs_and_lines sals
;
2315 struct symtab_and_line sal
;
2316 register struct expression
*cond
= 0;
2317 register struct breakpoint
*b
;
2319 /* Pointers in arg to the start, and one past the end, of the condition. */
2320 char *cond_start
= NULL
;
2321 char *cond_end
= NULL
;
2322 /* Pointers in arg to the start, and one past the end,
2323 of the address part. */
2324 char *addr_start
= NULL
;
2325 char *addr_end
= NULL
;
2326 struct cleanup
*old_chain
;
2327 struct cleanup
*canonical_strings_chain
= NULL
;
2328 char **canonical
= (char **)NULL
;
2332 hardwareflag
= flag
& BP_HARDWAREFLAG
;
2333 tempflag
= flag
& BP_TEMPFLAG
;
2338 sal
.line
= sal
.pc
= sal
.end
= 0;
2341 /* If no arg given, or if first arg is 'if ', use the default breakpoint. */
2343 if (!arg
|| (arg
[0] == 'i' && arg
[1] == 'f'
2344 && (arg
[2] == ' ' || arg
[2] == '\t')))
2346 if (default_breakpoint_valid
)
2348 sals
.sals
= (struct symtab_and_line
*)
2349 xmalloc (sizeof (struct symtab_and_line
));
2350 sal
.pc
= default_breakpoint_address
;
2351 sal
.line
= default_breakpoint_line
;
2352 sal
.symtab
= default_breakpoint_symtab
;
2357 error ("No default breakpoint address now.");
2363 /* Force almost all breakpoints to be in terms of the
2364 current_source_symtab (which is decode_line_1's default). This
2365 should produce the results we want almost all of the time while
2366 leaving default_breakpoint_* alone. */
2367 if (default_breakpoint_valid
2368 && (!current_source_symtab
2369 || (arg
&& (*arg
== '+' || *arg
== '-'))))
2370 sals
= decode_line_1 (&arg
, 1, default_breakpoint_symtab
,
2371 default_breakpoint_line
, &canonical
);
2373 sals
= decode_line_1 (&arg
, 1, (struct symtab
*)NULL
, 0, &canonical
);
2381 /* Make sure that all storage allocated in decode_line_1 gets freed in case
2382 the following `for' loop errors out. */
2383 old_chain
= make_cleanup (free
, sals
.sals
);
2384 if (canonical
!= (char **)NULL
)
2386 make_cleanup (free
, canonical
);
2387 canonical_strings_chain
= make_cleanup (null_cleanup
, 0);
2388 for (i
= 0; i
< sals
.nelts
; i
++)
2390 if (canonical
[i
] != NULL
)
2391 make_cleanup (free
, canonical
[i
]);
2395 thread
= -1; /* No specific thread yet */
2397 /* Resolve all line numbers to PC's, and verify that conditions
2398 can be parsed, before setting any breakpoints. */
2399 for (i
= 0; i
< sals
.nelts
; i
++)
2401 char *tok
, *end_tok
;
2404 resolve_sal_pc (&sals
.sals
[i
]);
2410 while (*tok
== ' ' || *tok
== '\t')
2415 while (*end_tok
!= ' ' && *end_tok
!= '\t' && *end_tok
!= '\000')
2418 toklen
= end_tok
- tok
;
2420 if (toklen
>= 1 && strncmp (tok
, "if", toklen
) == 0)
2422 tok
= cond_start
= end_tok
+ 1;
2423 cond
= parse_exp_1 (&tok
, block_for_pc (sals
.sals
[i
].pc
), 0);
2426 else if (toklen
>= 1 && strncmp (tok
, "thread", toklen
) == 0)
2432 thread
= strtol (tok
, &tok
, 0);
2434 error ("Junk after thread keyword.");
2435 if (!valid_thread_id (thread
))
2436 error ("Unknown thread %d\n", thread
);
2439 error ("Junk at end of arguments.");
2444 int i
, target_resources_ok
;
2446 i
= hw_breakpoint_used_count ();
2447 target_resources_ok
= TARGET_CAN_USE_HARDWARE_WATCHPOINT (
2448 bp_hardware_breakpoint
, i
+ sals
.nelts
, 0);
2449 if (target_resources_ok
== 0)
2450 error ("No hardware breakpoint support in the target.");
2451 else if (target_resources_ok
< 0)
2452 error ("Hardware breakpoints used exceeds limit.");
2455 /* Remove the canonical strings from the cleanup, they are needed below. */
2456 if (canonical
!= (char **)NULL
)
2457 discard_cleanups (canonical_strings_chain
);
2459 /* Now set all the breakpoints. */
2460 for (i
= 0; i
< sals
.nelts
; i
++)
2465 describe_other_breakpoints (sal
.pc
);
2467 b
= set_raw_breakpoint (sal
);
2468 set_breakpoint_count (breakpoint_count
+ 1);
2469 b
->number
= breakpoint_count
;
2470 b
->type
= hardwareflag
? bp_hardware_breakpoint
: bp_breakpoint
;
2474 /* If a canonical line spec is needed use that instead of the
2476 if (canonical
!= (char **)NULL
&& canonical
[i
] != NULL
)
2477 b
->addr_string
= canonical
[i
];
2478 else if (addr_start
)
2479 b
->addr_string
= savestring (addr_start
, addr_end
- addr_start
);
2481 b
->cond_string
= savestring (cond_start
, cond_end
- cond_start
);
2483 b
->enable
= enabled
;
2484 b
->disposition
= tempflag
? del
: donttouch
;
2491 printf_filtered ("Multiple breakpoints were set.\n");
2492 printf_filtered ("Use the \"delete\" command to delete unwanted breakpoints.\n");
2494 do_cleanups (old_chain
);
2497 /* Helper function for break_command_1 and disassemble_command. */
2500 resolve_sal_pc (sal
)
2501 struct symtab_and_line
*sal
;
2505 if (sal
->pc
== 0 && sal
->symtab
!= 0)
2507 pc
= find_line_pc (sal
->symtab
, sal
->line
);
2509 error ("No line %d in file \"%s\".",
2510 sal
->line
, sal
->symtab
->filename
);
2516 break_command (arg
, from_tty
)
2520 break_command_1 (arg
, 0, from_tty
);
2524 tbreak_command (arg
, from_tty
)
2528 break_command_1 (arg
, BP_TEMPFLAG
, from_tty
);
2532 hbreak_command (arg
, from_tty
)
2536 break_command_1 (arg
, BP_HARDWAREFLAG
, from_tty
);
2540 thbreak_command (arg
, from_tty
)
2544 break_command_1 (arg
, (BP_TEMPFLAG
| BP_HARDWAREFLAG
), from_tty
);
2548 /* accessflag: 0: watch write, 1: watch read, 2: watch access(read or write)
2551 watch_command_1 (arg
, accessflag
, from_tty
)
2556 struct breakpoint
*b
;
2557 struct symtab_and_line sal
;
2558 struct expression
*exp
;
2559 struct block
*exp_valid_block
;
2560 struct value
*val
, *mark
;
2561 struct frame_info
*frame
, *prev_frame
;
2562 char *exp_start
= NULL
;
2563 char *exp_end
= NULL
;
2564 char *tok
, *end_tok
;
2566 char *cond_start
= NULL
;
2567 char *cond_end
= NULL
;
2568 struct expression
*cond
= NULL
;
2569 int i
, other_type_used
, target_resources_ok
;
2570 enum bptype bp_type
;
2577 /* Parse arguments. */
2578 innermost_block
= NULL
;
2580 exp
= parse_exp_1 (&arg
, 0, 0);
2582 exp_valid_block
= innermost_block
;
2583 mark
= value_mark ();
2584 val
= evaluate_expression (exp
);
2585 release_value (val
);
2586 if (VALUE_LAZY (val
))
2587 value_fetch_lazy (val
);
2590 while (*tok
== ' ' || *tok
== '\t')
2594 while (*end_tok
!= ' ' && *end_tok
!= '\t' && *end_tok
!= '\000')
2597 toklen
= end_tok
- tok
;
2598 if (toklen
>= 1 && strncmp (tok
, "if", toklen
) == 0)
2600 tok
= cond_start
= end_tok
+ 1;
2601 cond
= parse_exp_1 (&tok
, 0, 0);
2605 error("Junk at end of command.");
2607 if (accessflag
== 1) bp_type
= bp_read_watchpoint
;
2608 else if (accessflag
== 2) bp_type
= bp_access_watchpoint
;
2609 else bp_type
= bp_hardware_watchpoint
;
2611 mem_cnt
= can_use_hardware_watchpoint (val
);
2612 if (mem_cnt
== 0 && bp_type
!= bp_hardware_watchpoint
)
2613 error ("Expression cannot be implemented with read/access watchpoint.");
2615 i
= hw_watchpoint_used_count (bp_type
, &other_type_used
);
2616 target_resources_ok
= TARGET_CAN_USE_HARDWARE_WATCHPOINT(
2617 bp_type
, i
+ mem_cnt
, other_type_used
);
2618 if (target_resources_ok
== 0 && bp_type
!= bp_hardware_watchpoint
)
2619 error ("Target does not have this type of hardware watchpoint support.");
2620 if (target_resources_ok
< 0 && bp_type
!= bp_hardware_watchpoint
)
2621 error ("Target resources have been allocated for other types of watchpoints.");
2624 /* Now set up the breakpoint. */
2625 b
= set_raw_breakpoint (sal
);
2626 set_breakpoint_count (breakpoint_count
+ 1);
2627 b
->number
= breakpoint_count
;
2628 b
->disposition
= donttouch
;
2630 b
->exp_valid_block
= exp_valid_block
;
2631 b
->exp_string
= savestring (exp_start
, exp_end
- exp_start
);
2635 b
->cond_string
= savestring (cond_start
, cond_end
- cond_start
);
2639 frame
= block_innermost_frame (exp_valid_block
);
2642 prev_frame
= get_prev_frame (frame
);
2643 b
->watchpoint_frame
= frame
->frame
;
2646 b
->watchpoint_frame
= (CORE_ADDR
)0;
2648 if (mem_cnt
&& target_resources_ok
> 0)
2651 b
->type
= bp_watchpoint
;
2653 /* If the expression is "local", then set up a "watchpoint scope"
2654 breakpoint at the point where we've left the scope of the watchpoint
2656 if (innermost_block
)
2658 struct breakpoint
*scope_breakpoint
;
2659 struct symtab_and_line scope_sal
;
2663 scope_sal
.pc
= get_frame_pc (prev_frame
);
2664 scope_sal
.symtab
= NULL
;
2667 scope_breakpoint
= set_raw_breakpoint (scope_sal
);
2668 set_breakpoint_count (breakpoint_count
+ 1);
2669 scope_breakpoint
->number
= breakpoint_count
;
2671 scope_breakpoint
->type
= bp_watchpoint_scope
;
2672 scope_breakpoint
->enable
= enabled
;
2674 /* Automatically delete the breakpoint when it hits. */
2675 scope_breakpoint
->disposition
= del
;
2677 /* Only break in the proper frame (help with recursion). */
2678 scope_breakpoint
->frame
= prev_frame
->frame
;
2680 /* Set the address at which we will stop. */
2681 scope_breakpoint
->address
= get_frame_pc (prev_frame
);
2683 /* The scope breakpoint is related to the watchpoint. We
2684 will need to act on them together. */
2685 b
->related_breakpoint
= scope_breakpoint
;
2688 value_free_to_mark (mark
);
2692 /* Return count of locations need to be watched and can be handled
2693 in hardware. If the watchpoint can not be handled
2694 in hardware return zero. */
2697 can_use_hardware_watchpoint (v
)
2700 int found_memory_cnt
= 0;
2702 /* Make sure all the intermediate values are in memory. Also make sure
2703 we found at least one memory expression. Guards against watch 0x12345,
2704 which is meaningless, but could cause errors if one tries to insert a
2705 hardware watchpoint for the constant expression. */
2706 for ( ; v
; v
= v
->next
)
2708 if (v
->lval
== lval_memory
)
2710 if (TYPE_LENGTH (VALUE_TYPE (v
)) <= REGISTER_SIZE
)
2713 else if (v
->lval
!= not_lval
&& v
->modifiable
== 0)
2717 /* The expression itself looks suitable for using a hardware
2718 watchpoint, but give the target machine a chance to reject it. */
2719 return found_memory_cnt
;
2722 static void watch_command (arg
, from_tty
)
2726 watch_command_1 (arg
, 0, from_tty
);
2729 static void rwatch_command (arg
, from_tty
)
2733 watch_command_1 (arg
, 1, from_tty
);
2736 static void awatch_command (arg
, from_tty
)
2740 watch_command_1 (arg
, 2, from_tty
);
2744 /* Helper routine for the until_command routine in infcmd.c. Here
2745 because it uses the mechanisms of breakpoints. */
2749 until_break_command (arg
, from_tty
)
2753 struct symtabs_and_lines sals
;
2754 struct symtab_and_line sal
;
2755 struct frame_info
*prev_frame
= get_prev_frame (selected_frame
);
2756 struct breakpoint
*breakpoint
;
2757 struct cleanup
*old_chain
;
2759 clear_proceed_status ();
2761 /* Set a breakpoint where the user wants it and at return from
2764 if (default_breakpoint_valid
)
2765 sals
= decode_line_1 (&arg
, 1, default_breakpoint_symtab
,
2766 default_breakpoint_line
, (char ***)NULL
);
2768 sals
= decode_line_1 (&arg
, 1, (struct symtab
*)NULL
, 0, (char ***)NULL
);
2770 if (sals
.nelts
!= 1)
2771 error ("Couldn't get information on specified line.");
2774 free ((PTR
)sals
.sals
); /* malloc'd, so freed */
2777 error ("Junk at end of arguments.");
2779 resolve_sal_pc (&sal
);
2781 breakpoint
= set_momentary_breakpoint (sal
, selected_frame
, bp_until
);
2783 old_chain
= make_cleanup(delete_breakpoint
, breakpoint
);
2785 /* Keep within the current frame */
2789 sal
= find_pc_line (prev_frame
->pc
, 0);
2790 sal
.pc
= prev_frame
->pc
;
2791 breakpoint
= set_momentary_breakpoint (sal
, prev_frame
, bp_until
);
2792 make_cleanup(delete_breakpoint
, breakpoint
);
2795 proceed (-1, TARGET_SIGNAL_DEFAULT
, 0);
2796 do_cleanups(old_chain
);
2800 /* These aren't used; I don't konw what they were for. */
2801 /* Set a breakpoint at the catch clause for NAME. */
2803 catch_breakpoint (name
)
2809 disable_catch_breakpoint ()
2814 delete_catch_breakpoint ()
2819 enable_catch_breakpoint ()
2826 struct sal_chain
*next
;
2827 struct symtab_and_line sal
;
2831 /* This isn't used; I don't know what it was for. */
2832 /* For each catch clause identified in ARGS, run FUNCTION
2833 with that clause as an argument. */
2834 static struct symtabs_and_lines
2835 map_catch_names (args
, function
)
2839 register char *p
= args
;
2841 struct symtabs_and_lines sals
;
2843 struct sal_chain
*sal_chain
= 0;
2847 error_no_arg ("one or more catch names");
2855 /* Don't swallow conditional part. */
2856 if (p1
[0] == 'i' && p1
[1] == 'f'
2857 && (p1
[2] == ' ' || p1
[2] == '\t'))
2863 while (isalnum (*p1
) || *p1
== '_' || *p1
== '$')
2867 if (*p1
&& *p1
!= ' ' && *p1
!= '\t')
2868 error ("Arguments must be catch names.");
2874 struct sal_chain
*next
2875 = (struct sal_chain
*)alloca (sizeof (struct sal_chain
));
2876 next
->next
= sal_chain
;
2877 next
->sal
= get_catch_sal (p
);
2882 printf_unfiltered ("No catch clause for exception %s.\n", p
);
2887 while (*p
== ' ' || *p
== '\t') p
++;
2892 /* This shares a lot of code with `print_frame_label_vars' from stack.c. */
2894 static struct symtabs_and_lines
2895 get_catch_sals (this_level_only
)
2896 int this_level_only
;
2898 register struct blockvector
*bl
;
2899 register struct block
*block
;
2900 int index
, have_default
= 0;
2902 struct symtabs_and_lines sals
;
2903 struct sal_chain
*sal_chain
= 0;
2904 char *blocks_searched
;
2906 /* Not sure whether an error message is always the correct response,
2907 but it's better than a core dump. */
2908 if (selected_frame
== NULL
)
2909 error ("No selected frame.");
2910 block
= get_frame_block (selected_frame
);
2911 pc
= selected_frame
->pc
;
2917 error ("No symbol table info available.\n");
2919 bl
= blockvector_for_pc (BLOCK_END (block
) - 4, &index
);
2920 blocks_searched
= (char *) alloca (BLOCKVECTOR_NBLOCKS (bl
) * sizeof (char));
2921 memset (blocks_searched
, 0, BLOCKVECTOR_NBLOCKS (bl
) * sizeof (char));
2925 CORE_ADDR end
= BLOCK_END (block
) - 4;
2928 if (bl
!= blockvector_for_pc (end
, &index
))
2929 error ("blockvector blotch");
2930 if (BLOCKVECTOR_BLOCK (bl
, index
) != block
)
2931 error ("blockvector botch");
2932 last_index
= BLOCKVECTOR_NBLOCKS (bl
);
2935 /* Don't print out blocks that have gone by. */
2936 while (index
< last_index
2937 && BLOCK_END (BLOCKVECTOR_BLOCK (bl
, index
)) < pc
)
2940 while (index
< last_index
2941 && BLOCK_END (BLOCKVECTOR_BLOCK (bl
, index
)) < end
)
2943 if (blocks_searched
[index
] == 0)
2945 struct block
*b
= BLOCKVECTOR_BLOCK (bl
, index
);
2948 register struct symbol
*sym
;
2950 nsyms
= BLOCK_NSYMS (b
);
2952 for (i
= 0; i
< nsyms
; i
++)
2954 sym
= BLOCK_SYM (b
, i
);
2955 if (STREQ (SYMBOL_NAME (sym
), "default"))
2961 if (SYMBOL_CLASS (sym
) == LOC_LABEL
)
2963 struct sal_chain
*next
= (struct sal_chain
*)
2964 alloca (sizeof (struct sal_chain
));
2965 next
->next
= sal_chain
;
2966 next
->sal
= find_pc_line (SYMBOL_VALUE_ADDRESS (sym
), 0);
2970 blocks_searched
[index
] = 1;
2976 if (sal_chain
&& this_level_only
)
2979 /* After handling the function's top-level block, stop.
2980 Don't continue to its superblock, the block of
2981 per-file symbols. */
2982 if (BLOCK_FUNCTION (block
))
2984 block
= BLOCK_SUPERBLOCK (block
);
2989 struct sal_chain
*tmp_chain
;
2991 /* Count the number of entries. */
2992 for (index
= 0, tmp_chain
= sal_chain
; tmp_chain
;
2993 tmp_chain
= tmp_chain
->next
)
2997 sals
.sals
= (struct symtab_and_line
*)
2998 xmalloc (index
* sizeof (struct symtab_and_line
));
2999 for (index
= 0; sal_chain
; sal_chain
= sal_chain
->next
, index
++)
3000 sals
.sals
[index
] = sal_chain
->sal
;
3006 /* Commands to deal with catching exceptions. */
3009 catch_command_1 (arg
, tempflag
, from_tty
)
3014 /* First, translate ARG into something we can deal with in terms
3017 struct symtabs_and_lines sals
;
3018 struct symtab_and_line sal
;
3019 register struct expression
*cond
= 0;
3020 register struct breakpoint
*b
;
3024 sal
.line
= sal
.pc
= sal
.end
= 0;
3027 /* If no arg given, or if first arg is 'if ', all active catch clauses
3028 are breakpointed. */
3030 if (!arg
|| (arg
[0] == 'i' && arg
[1] == 'f'
3031 && (arg
[2] == ' ' || arg
[2] == '\t')))
3033 /* Grab all active catch clauses. */
3034 sals
= get_catch_sals (0);
3038 /* Grab selected catch clauses. */
3039 error ("catch NAME not implemented");
3041 /* This isn't used; I don't know what it was for. */
3042 sals
= map_catch_names (arg
, catch_breakpoint
);
3050 for (i
= 0; i
< sals
.nelts
; i
++)
3052 resolve_sal_pc (&sals
.sals
[i
]);
3056 if (arg
[0] == 'i' && arg
[1] == 'f'
3057 && (arg
[2] == ' ' || arg
[2] == '\t'))
3058 cond
= parse_exp_1 ((arg
+= 2, &arg
),
3059 block_for_pc (sals
.sals
[i
].pc
), 0);
3061 error ("Junk at end of arguments.");
3066 for (i
= 0; i
< sals
.nelts
; i
++)
3071 describe_other_breakpoints (sal
.pc
);
3073 b
= set_raw_breakpoint (sal
);
3074 set_breakpoint_count (breakpoint_count
+ 1);
3075 b
->number
= breakpoint_count
;
3076 b
->type
= bp_breakpoint
;
3078 b
->enable
= enabled
;
3079 b
->disposition
= tempflag
? del
: donttouch
;
3086 printf_unfiltered ("Multiple breakpoints were set.\n");
3087 printf_unfiltered ("Use the \"delete\" command to delete unwanted breakpoints.\n");
3089 free ((PTR
)sals
.sals
);
3092 /* Used by the gui, could be made a worker for other things. */
3095 set_breakpoint_sal (sal
)
3096 struct symtab_and_line sal
;
3098 struct breakpoint
*b
;
3099 b
= set_raw_breakpoint (sal
);
3100 set_breakpoint_count (breakpoint_count
+ 1);
3101 b
->number
= breakpoint_count
;
3102 b
->type
= bp_breakpoint
;
3109 /* These aren't used; I don't know what they were for. */
3110 /* Disable breakpoints on all catch clauses described in ARGS. */
3112 disable_catch (args
)
3115 /* Map the disable command to catch clauses described in ARGS. */
3118 /* Enable breakpoints on all catch clauses described in ARGS. */
3123 /* Map the disable command to catch clauses described in ARGS. */
3126 /* Delete breakpoints on all catch clauses in the active scope. */
3131 /* Map the delete command to catch clauses described in ARGS. */
3136 catch_command (arg
, from_tty
)
3140 catch_command_1 (arg
, 0, from_tty
);
3144 clear_command (arg
, from_tty
)
3148 register struct breakpoint
*b
, *b1
;
3149 struct symtabs_and_lines sals
;
3150 struct symtab_and_line sal
;
3151 register struct breakpoint
*found
;
3156 sals
= decode_line_spec (arg
, 1);
3160 sals
.sals
= (struct symtab_and_line
*) xmalloc (sizeof (struct symtab_and_line
));
3161 sal
.line
= default_breakpoint_line
;
3162 sal
.symtab
= default_breakpoint_symtab
;
3164 if (sal
.symtab
== 0)
3165 error ("No source file specified.");
3171 for (i
= 0; i
< sals
.nelts
; i
++)
3173 /* If exact pc given, clear bpts at that pc.
3174 But if sal.pc is zero, clear all bpts on specified line. */
3176 found
= (struct breakpoint
*) 0;
3177 while (breakpoint_chain
3179 ? breakpoint_chain
->address
== sal
.pc
3180 : (breakpoint_chain
->source_file
!= NULL
3181 && sal
.symtab
!= NULL
3182 && STREQ (breakpoint_chain
->source_file
,
3183 sal
.symtab
->filename
)
3184 && breakpoint_chain
->line_number
== sal
.line
)))
3186 b1
= breakpoint_chain
;
3187 breakpoint_chain
= b1
->next
;
3194 && b
->next
->type
!= bp_watchpoint
3195 && b
->next
->type
!= bp_hardware_watchpoint
3196 && b
->next
->type
!= bp_read_watchpoint
3197 && b
->next
->type
!= bp_access_watchpoint
3199 ? b
->next
->address
== sal
.pc
3200 : (b
->next
->source_file
!= NULL
3201 && sal
.symtab
!= NULL
3202 && STREQ (b
->next
->source_file
, sal
.symtab
->filename
)
3203 && b
->next
->line_number
== sal
.line
)))
3214 error ("No breakpoint at %s.", arg
);
3216 error ("No breakpoint at this line.");
3219 if (found
->next
) from_tty
= 1; /* Always report if deleted more than one */
3220 if (from_tty
) printf_unfiltered ("Deleted breakpoint%s ", found
->next
? "s" : "");
3221 breakpoints_changed ();
3224 if (from_tty
) printf_unfiltered ("%d ", found
->number
);
3226 delete_breakpoint (found
);
3229 if (from_tty
) putchar_unfiltered ('\n');
3231 free ((PTR
)sals
.sals
);
3234 /* Delete breakpoint in BS if they are `delete' breakpoints.
3235 This is called after any breakpoint is hit, or after errors. */
3238 breakpoint_auto_delete (bs
)
3241 for (; bs
; bs
= bs
->next
)
3242 if (bs
->breakpoint_at
&& bs
->breakpoint_at
->disposition
== del
3244 delete_breakpoint (bs
->breakpoint_at
);
3247 /* Delete a breakpoint and clean up all traces of it in the data structures. */
3250 delete_breakpoint (bpt
)
3251 struct breakpoint
*bpt
;
3253 register struct breakpoint
*b
;
3256 if (delete_breakpoint_hook
)
3257 delete_breakpoint_hook (bpt
);
3260 remove_breakpoint (bpt
);
3262 if (breakpoint_chain
== bpt
)
3263 breakpoint_chain
= bpt
->next
;
3268 b
->next
= bpt
->next
;
3272 check_duplicates (bpt
->address
);
3273 /* If this breakpoint was inserted, and there is another breakpoint
3274 at the same address, we need to insert the other breakpoint. */
3276 && bpt
->type
!= bp_hardware_watchpoint
3277 && bpt
->type
!= bp_read_watchpoint
3278 && bpt
->type
!= bp_access_watchpoint
)
3281 if (b
->address
== bpt
->address
3283 && b
->enable
!= disabled
3284 && b
->enable
!= shlib_disabled
)
3287 val
= target_insert_breakpoint (b
->address
, b
->shadow_contents
);
3290 target_terminal_ours_for_output ();
3291 fprintf_unfiltered (gdb_stderr
, "Cannot insert breakpoint %d:\n", b
->number
);
3292 memory_error (val
, b
->address
); /* which bombs us out */
3299 free_command_lines (&bpt
->commands
);
3302 if (bpt
->cond_string
!= NULL
)
3303 free (bpt
->cond_string
);
3304 if (bpt
->addr_string
!= NULL
)
3305 free (bpt
->addr_string
);
3306 if (bpt
->exp
!= NULL
)
3308 if (bpt
->exp_string
!= NULL
)
3309 free (bpt
->exp_string
);
3310 if (bpt
->val
!= NULL
)
3311 value_free (bpt
->val
);
3312 if (bpt
->source_file
!= NULL
)
3313 free (bpt
->source_file
);
3315 /* Be sure no bpstat's are pointing at it after it's been freed. */
3316 /* FIXME, how can we find all bpstat's?
3317 We just check stop_bpstat for now. */
3318 for (bs
= stop_bpstat
; bs
; bs
= bs
->next
)
3319 if (bs
->breakpoint_at
== bpt
)
3320 bs
->breakpoint_at
= NULL
;
3325 delete_command (arg
, from_tty
)
3332 /* Ask user only if there are some breakpoints to delete. */
3334 || (breakpoint_chain
&& query ("Delete all breakpoints? ")))
3336 /* No arg; clear all breakpoints. */
3337 while (breakpoint_chain
)
3338 delete_breakpoint (breakpoint_chain
);
3342 map_breakpoint_numbers (arg
, delete_breakpoint
);
3345 /* Reset a breakpoint given it's struct breakpoint * BINT.
3346 The value we return ends up being the return value from catch_errors.
3347 Unused in this case. */
3350 breakpoint_re_set_one (bint
)
3353 struct breakpoint
*b
= (struct breakpoint
*)bint
; /* get past catch_errs */
3356 struct symtabs_and_lines sals
;
3358 enum enable save_enable
;
3363 case bp_hardware_breakpoint
:
3364 if (b
->addr_string
== NULL
)
3366 /* Anything without a string can't be re-set. */
3367 delete_breakpoint (b
);
3370 /* In case we have a problem, disable this breakpoint. We'll restore
3371 its status if we succeed. */
3372 save_enable
= b
->enable
;
3373 b
->enable
= disabled
;
3375 set_language (b
->language
);
3376 input_radix
= b
->input_radix
;
3378 sals
= decode_line_1 (&s
, 1, (struct symtab
*)NULL
, 0, (char ***)NULL
);
3379 for (i
= 0; i
< sals
.nelts
; i
++)
3381 resolve_sal_pc (&sals
.sals
[i
]);
3383 /* Reparse conditions, they might contain references to the
3385 if (b
->cond_string
!= NULL
)
3389 free ((PTR
)b
->cond
);
3390 b
->cond
= parse_exp_1 (&s
, block_for_pc (sals
.sals
[i
].pc
), 0);
3393 /* We need to re-set the breakpoint if the address changes...*/
3394 if (b
->address
!= sals
.sals
[i
].pc
3395 /* ...or new and old breakpoints both have source files, and
3396 the source file name or the line number changes... */
3397 || (b
->source_file
!= NULL
3398 && sals
.sals
[i
].symtab
!= NULL
3399 && (!STREQ (b
->source_file
, sals
.sals
[i
].symtab
->filename
)
3400 || b
->line_number
!= sals
.sals
[i
].line
)
3402 /* ...or we switch between having a source file and not having
3404 || ((b
->source_file
== NULL
) != (sals
.sals
[i
].symtab
== NULL
))
3407 if (b
->source_file
!= NULL
)
3408 free (b
->source_file
);
3409 if (sals
.sals
[i
].symtab
== NULL
)
3410 b
->source_file
= NULL
;
3413 savestring (sals
.sals
[i
].symtab
->filename
,
3414 strlen (sals
.sals
[i
].symtab
->filename
));
3415 b
->line_number
= sals
.sals
[i
].line
;
3416 b
->address
= sals
.sals
[i
].pc
;
3418 check_duplicates (b
->address
);
3422 /* Might be better to do this just once per breakpoint_re_set,
3423 rather than once for every breakpoint. */
3424 breakpoints_changed ();
3426 b
->enable
= save_enable
; /* Restore it, this worked. */
3428 free ((PTR
)sals
.sals
);
3432 case bp_hardware_watchpoint
:
3433 case bp_read_watchpoint
:
3434 case bp_access_watchpoint
:
3435 innermost_block
= NULL
;
3436 /* The issue arises of what context to evaluate this in. The same
3437 one as when it was set, but what does that mean when symbols have
3438 been re-read? We could save the filename and functionname, but
3439 if the context is more local than that, the best we could do would
3440 be something like how many levels deep and which index at that
3441 particular level, but that's going to be less stable than filenames
3442 or functionnames. */
3443 /* So for now, just use a global context. */
3446 b
->exp
= parse_expression (b
->exp_string
);
3447 b
->exp_valid_block
= innermost_block
;
3448 mark
= value_mark ();
3450 value_free (b
->val
);
3451 b
->val
= evaluate_expression (b
->exp
);
3452 release_value (b
->val
);
3453 if (VALUE_LAZY (b
->val
))
3454 value_fetch_lazy (b
->val
);
3456 if (b
->cond_string
!= NULL
)
3460 free ((PTR
)b
->cond
);
3461 b
->cond
= parse_exp_1 (&s
, (struct block
*)0, 0);
3463 if (b
->enable
== enabled
)
3465 value_free_to_mark (mark
);
3469 printf_filtered ("Deleting unknown breakpoint type %d\n", b
->type
);
3471 /* Delete longjmp breakpoints, they will be reset later by
3472 breakpoint_re_set. */
3474 case bp_longjmp_resume
:
3475 delete_breakpoint (b
);
3478 /* This breakpoint is special, it's set up when the inferior
3479 starts and we really don't want to touch it. */
3480 case bp_shlib_event
:
3482 /* Keep temporary breakpoints, which can be encountered when we step
3483 over a dlopen call and SOLIB_ADD is resetting the breakpoints.
3484 Otherwise these should have been blown away via the cleanup chain
3485 or by breakpoint_init_inferior when we rerun the executable. */
3488 case bp_watchpoint_scope
:
3490 case bp_step_resume
:
3497 /* Re-set all breakpoints after symbols have been re-loaded. */
3499 breakpoint_re_set ()
3501 struct breakpoint
*b
, *temp
;
3502 enum language save_language
;
3503 int save_input_radix
;
3504 static char message1
[] = "Error in re-setting breakpoint %d:\n";
3505 char message
[sizeof (message1
) + 30 /* slop */];
3507 save_language
= current_language
->la_language
;
3508 save_input_radix
= input_radix
;
3509 ALL_BREAKPOINTS_SAFE (b
, temp
)
3511 sprintf (message
, message1
, b
->number
); /* Format possible error msg */
3512 catch_errors (breakpoint_re_set_one
, (char *) b
, message
,
3515 set_language (save_language
);
3516 input_radix
= save_input_radix
;
3518 #ifdef GET_LONGJMP_TARGET
3519 create_longjmp_breakpoint ("longjmp");
3520 create_longjmp_breakpoint ("_longjmp");
3521 create_longjmp_breakpoint ("siglongjmp");
3522 create_longjmp_breakpoint (NULL
);
3526 /* Took this out (temporarily at least), since it produces an extra
3527 blank line at startup. This messes up the gdbtests. -PB */
3528 /* Blank line to finish off all those mention() messages we just printed. */
3529 printf_filtered ("\n");
3533 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
3534 If from_tty is nonzero, it prints a message to that effect,
3535 which ends with a period (no newline). */
3538 set_ignore_count (bptnum
, count
, from_tty
)
3539 int bptnum
, count
, from_tty
;
3541 register struct breakpoint
*b
;
3547 if (b
->number
== bptnum
)
3549 b
->ignore_count
= count
;
3552 else if (count
== 0)
3553 printf_filtered ("Will stop next time breakpoint %d is reached.",
3555 else if (count
== 1)
3556 printf_filtered ("Will ignore next crossing of breakpoint %d.",
3559 printf_filtered ("Will ignore next %d crossings of breakpoint %d.",
3561 breakpoints_changed ();
3565 error ("No breakpoint number %d.", bptnum
);
3568 /* Clear the ignore counts of all breakpoints. */
3570 breakpoint_clear_ignore_counts ()
3572 struct breakpoint
*b
;
3575 b
->ignore_count
= 0;
3578 /* Command to set ignore-count of breakpoint N to COUNT. */
3581 ignore_command (args
, from_tty
)
3589 error_no_arg ("a breakpoint number");
3591 num
= get_number (&p
);
3594 error ("Second argument (specified ignore-count) is missing.");
3596 set_ignore_count (num
,
3597 longest_to_int (value_as_long (parse_and_eval (p
))),
3599 printf_filtered ("\n");
3600 breakpoints_changed ();
3603 /* Call FUNCTION on each of the breakpoints
3604 whose numbers are given in ARGS. */
3607 map_breakpoint_numbers (args
, function
)
3609 void (*function
) PARAMS ((struct breakpoint
*));
3611 register char *p
= args
;
3614 register struct breakpoint
*b
;
3617 error_no_arg ("one or more breakpoint numbers");
3623 num
= get_number (&p1
);
3626 if (b
->number
== num
)
3628 struct breakpoint
*related_breakpoint
= b
->related_breakpoint
;
3630 if (related_breakpoint
)
3631 function (related_breakpoint
);
3634 printf_unfiltered ("No breakpoint number %d.\n", num
);
3641 enable_breakpoint (bpt
)
3642 struct breakpoint
*bpt
;
3644 struct frame_info
*save_selected_frame
= NULL
;
3645 int save_selected_frame_level
= -1;
3646 int target_resources_ok
, other_type_used
;
3649 if (bpt
->type
== bp_hardware_breakpoint
)
3652 i
= hw_breakpoint_used_count();
3653 target_resources_ok
= TARGET_CAN_USE_HARDWARE_WATCHPOINT(
3654 bp_hardware_breakpoint
, i
+1, 0);
3655 if (target_resources_ok
== 0)
3656 error ("No hardware breakpoint support in the target.");
3657 else if (target_resources_ok
< 0)
3658 error ("Hardware breakpoints used exceeds limit.");
3660 bpt
->enable
= enabled
;
3661 check_duplicates (bpt
->address
);
3663 if (bpt
->type
== bp_watchpoint
|| bpt
->type
== bp_hardware_watchpoint
||
3664 bpt
->type
== bp_read_watchpoint
|| bpt
->type
== bp_access_watchpoint
)
3666 if (bpt
->exp_valid_block
!= NULL
)
3668 struct frame_info
*fr
=
3669 find_frame_addr_in_frame_chain (bpt
->watchpoint_frame
);
3673 Cannot enable watchpoint %d because the block in which its expression\n\
3674 is valid is not currently in scope.\n", bpt
->number
);
3675 bpt
->enable
= disabled
;
3679 save_selected_frame
= selected_frame
;
3680 save_selected_frame_level
= selected_frame_level
;
3681 select_frame (fr
, -1);
3684 value_free (bpt
->val
);
3685 mark
= value_mark ();
3686 bpt
->val
= evaluate_expression (bpt
->exp
);
3687 release_value (bpt
->val
);
3688 if (VALUE_LAZY (bpt
->val
))
3689 value_fetch_lazy (bpt
->val
);
3691 if (bpt
->type
== bp_hardware_watchpoint
||
3692 bpt
->type
== bp_read_watchpoint
||
3693 bpt
->type
== bp_access_watchpoint
)
3695 int i
= hw_watchpoint_used_count (bpt
->type
, &other_type_used
);
3696 int mem_cnt
= can_use_hardware_watchpoint (bpt
->val
);
3698 target_resources_ok
= TARGET_CAN_USE_HARDWARE_WATCHPOINT(
3699 bpt
->type
, i
+ mem_cnt
, other_type_used
);
3700 /* we can consider of type is bp_hardware_watchpoint, convert to
3701 bp_watchpoint in the following condition */
3702 if (target_resources_ok
< 0)
3705 Cannot enable watchpoint %d because target watch resources\n\
3706 have been allocated for other watchpoints.\n", bpt
->number
);
3707 bpt
->enable
= disabled
;
3708 value_free_to_mark (mark
);
3713 if (save_selected_frame_level
>= 0)
3714 select_frame (save_selected_frame
, save_selected_frame_level
);
3715 value_free_to_mark (mark
);
3718 if (modify_breakpoint_hook
)
3719 modify_breakpoint_hook (bpt
);
3724 enable_command (args
, from_tty
)
3728 struct breakpoint
*bpt
;
3730 ALL_BREAKPOINTS (bpt
)
3734 case bp_hardware_breakpoint
:
3736 case bp_hardware_watchpoint
:
3737 case bp_read_watchpoint
:
3738 case bp_access_watchpoint
:
3739 enable_breakpoint (bpt
);
3744 map_breakpoint_numbers (args
, enable_breakpoint
);
3748 disable_breakpoint (bpt
)
3749 struct breakpoint
*bpt
;
3751 /* Never disable a watchpoint scope breakpoint; we want to
3752 hit them when we leave scope so we can delete both the
3753 watchpoint and its scope breakpoint at that time. */
3754 if (bpt
->type
== bp_watchpoint_scope
)
3757 bpt
->enable
= disabled
;
3759 check_duplicates (bpt
->address
);
3761 if (modify_breakpoint_hook
)
3762 modify_breakpoint_hook (bpt
);
3767 disable_command (args
, from_tty
)
3771 register struct breakpoint
*bpt
;
3773 ALL_BREAKPOINTS (bpt
)
3777 case bp_hardware_breakpoint
:
3779 case bp_hardware_watchpoint
:
3780 case bp_read_watchpoint
:
3781 case bp_access_watchpoint
:
3782 disable_breakpoint (bpt
);
3787 map_breakpoint_numbers (args
, disable_breakpoint
);
3791 enable_once_breakpoint (bpt
)
3792 struct breakpoint
*bpt
;
3794 struct frame_info
*save_selected_frame
= NULL
;
3795 int save_selected_frame_level
= -1;
3796 int target_resources_ok
, other_type_used
;
3799 if (bpt
->type
== bp_hardware_breakpoint
)
3802 i
= hw_breakpoint_used_count();
3803 target_resources_ok
= TARGET_CAN_USE_HARDWARE_WATCHPOINT(
3804 bp_hardware_breakpoint
, i
+1, 0);
3805 if (target_resources_ok
== 0)
3806 error ("No hardware breakpoint support in the target.");
3807 else if (target_resources_ok
< 0)
3808 error ("Hardware breakpoints used exceeds limit.");
3811 bpt
->enable
= enabled
;
3812 bpt
->disposition
= disable
;
3813 check_duplicates (bpt
->address
);
3814 breakpoints_changed ();
3816 if (bpt
->type
== bp_watchpoint
|| bpt
->type
== bp_hardware_watchpoint
||
3817 bpt
->type
== bp_read_watchpoint
|| bpt
->type
== bp_access_watchpoint
)
3819 if (bpt
->exp_valid_block
!= NULL
)
3821 struct frame_info
*fr
=
3822 find_frame_addr_in_frame_chain (bpt
->watchpoint_frame
);
3826 Cannot enable watchpoint %d because the block in which its expression\n\
3827 is valid is not currently in scope.\n", bpt
->number
);
3828 bpt
->enable
= disabled
;
3832 save_selected_frame
= selected_frame
;
3833 save_selected_frame_level
= selected_frame_level
;
3834 select_frame (fr
, -1);
3837 value_free (bpt
->val
);
3838 mark
= value_mark ();
3839 bpt
->val
= evaluate_expression (bpt
->exp
);
3840 release_value (bpt
->val
);
3841 if (VALUE_LAZY (bpt
->val
))
3842 value_fetch_lazy (bpt
->val
);
3844 if (bpt
->type
== bp_hardware_watchpoint
||
3845 bpt
->type
== bp_read_watchpoint
||
3846 bpt
->type
== bp_access_watchpoint
)
3848 int i
= hw_watchpoint_used_count (bpt
->type
, &other_type_used
);
3849 int mem_cnt
= can_use_hardware_watchpoint(bpt
->val
);
3850 target_resources_ok
= TARGET_CAN_USE_HARDWARE_WATCHPOINT(
3851 bpt
->type
, i
+mem_cnt
, other_type_used
);
3852 /* we can consider of type is bp_hardware_watchpoint, convert to
3853 bp_watchpoint in the following condition */
3854 if (target_resources_ok
< 0)
3857 Cannot enable watchpoint %d because target watch resources\n\
3858 have been allocated for other watchpoints.\n", bpt
->number
);
3859 bpt
->enable
= disabled
;
3860 value_free_to_mark (mark
);
3864 if (save_selected_frame_level
>= 0)
3865 select_frame (save_selected_frame
, save_selected_frame_level
);
3866 value_free_to_mark (mark
);
3872 enable_once_command (args
, from_tty
)
3876 map_breakpoint_numbers (args
, enable_once_breakpoint
);
3880 enable_delete_breakpoint (bpt
)
3881 struct breakpoint
*bpt
;
3883 bpt
->enable
= enabled
;
3884 bpt
->disposition
= del
;
3886 check_duplicates (bpt
->address
);
3887 breakpoints_changed ();
3892 enable_delete_command (args
, from_tty
)
3896 map_breakpoint_numbers (args
, enable_delete_breakpoint
);
3899 /* Use default_breakpoint_'s, or nothing if they aren't valid. */
3901 struct symtabs_and_lines
3902 decode_line_spec_1 (string
, funfirstline
)
3906 struct symtabs_and_lines sals
;
3908 error ("Empty line specification.");
3909 if (default_breakpoint_valid
)
3910 sals
= decode_line_1 (&string
, funfirstline
,
3911 default_breakpoint_symtab
, default_breakpoint_line
,
3914 sals
= decode_line_1 (&string
, funfirstline
,
3915 (struct symtab
*)NULL
, 0, (char ***)NULL
);
3917 error ("Junk at end of line specification: %s", string
);
3922 _initialize_breakpoint ()
3924 breakpoint_chain
= 0;
3925 /* Don't bother to call set_breakpoint_count. $bpnum isn't useful
3926 before a breakpoint is set. */
3927 breakpoint_count
= 0;
3929 add_com ("ignore", class_breakpoint
, ignore_command
,
3930 "Set ignore-count of breakpoint number N to COUNT.\n\
3931 Usage is `ignore N COUNT'.");
3933 add_com ("commands", class_breakpoint
, commands_command
,
3934 "Set commands to be executed when a breakpoint is hit.\n\
3935 Give breakpoint number as argument after \"commands\".\n\
3936 With no argument, the targeted breakpoint is the last one set.\n\
3937 The commands themselves follow starting on the next line.\n\
3938 Type a line containing \"end\" to indicate the end of them.\n\
3939 Give \"silent\" as the first line to make the breakpoint silent;\n\
3940 then no output is printed when it is hit, except what the commands print.");
3942 add_com ("condition", class_breakpoint
, condition_command
,
3943 "Specify breakpoint number N to break only if COND is true.\n\
3944 Usage is `condition N COND', where N is an integer and COND is an\n\
3945 expression to be evaluated whenever breakpoint N is reached. ");
3947 add_com ("tbreak", class_breakpoint
, tbreak_command
,
3948 "Set a temporary breakpoint. Args like \"break\" command.\n\
3949 Like \"break\" except the breakpoint is only temporary,\n\
3950 so it will be deleted when hit. Equivalent to \"break\" followed\n\
3951 by using \"enable delete\" on the breakpoint number.");
3953 add_com ("hbreak", class_breakpoint
, hbreak_command
,
3954 "Set a hardware assisted breakpoint. Args like \"break\" command.\n\
3955 Like \"break\" except the breakpoint requires hardware support,\n\
3956 some target hardware may not have this support.");
3958 add_com ("thbreak", class_breakpoint
, thbreak_command
,
3959 "Set a temporary hardware assisted breakpoint. Args like \"break\" command.\n\
3960 Like \"hbreak\" except the breakpoint is only temporary,\n\
3961 so it will be deleted when hit.");
3963 add_prefix_cmd ("enable", class_breakpoint
, enable_command
,
3964 "Enable some breakpoints.\n\
3965 Give breakpoint numbers (separated by spaces) as arguments.\n\
3966 With no subcommand, breakpoints are enabled until you command otherwise.\n\
3967 This is used to cancel the effect of the \"disable\" command.\n\
3968 With a subcommand you can enable temporarily.",
3969 &enablelist
, "enable ", 1, &cmdlist
);
3971 add_abbrev_prefix_cmd ("breakpoints", class_breakpoint
, enable_command
,
3972 "Enable some breakpoints.\n\
3973 Give breakpoint numbers (separated by spaces) as arguments.\n\
3974 This is used to cancel the effect of the \"disable\" command.\n\
3975 May be abbreviated to simply \"enable\".\n",
3976 &enablebreaklist
, "enable breakpoints ", 1, &enablelist
);
3978 add_cmd ("once", no_class
, enable_once_command
,
3979 "Enable breakpoints for one hit. Give breakpoint numbers.\n\
3980 If a breakpoint is hit while enabled in this fashion, it becomes disabled.",
3983 add_cmd ("delete", no_class
, enable_delete_command
,
3984 "Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
3985 If a breakpoint is hit while enabled in this fashion, it is deleted.",
3988 add_cmd ("delete", no_class
, enable_delete_command
,
3989 "Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
3990 If a breakpoint is hit while enabled in this fashion, it is deleted.",
3993 add_cmd ("once", no_class
, enable_once_command
,
3994 "Enable breakpoints for one hit. Give breakpoint numbers.\n\
3995 If a breakpoint is hit while enabled in this fashion, it becomes disabled.",
3998 add_prefix_cmd ("disable", class_breakpoint
, disable_command
,
3999 "Disable some breakpoints.\n\
4000 Arguments are breakpoint numbers with spaces in between.\n\
4001 To disable all breakpoints, give no argument.\n\
4002 A disabled breakpoint is not forgotten, but has no effect until reenabled.",
4003 &disablelist
, "disable ", 1, &cmdlist
);
4004 add_com_alias ("dis", "disable", class_breakpoint
, 1);
4005 add_com_alias ("disa", "disable", class_breakpoint
, 1);
4007 add_cmd ("breakpoints", class_alias
, disable_command
,
4008 "Disable some breakpoints.\n\
4009 Arguments are breakpoint numbers with spaces in between.\n\
4010 To disable all breakpoints, give no argument.\n\
4011 A disabled breakpoint is not forgotten, but has no effect until reenabled.\n\
4012 This command may be abbreviated \"disable\".",
4015 add_prefix_cmd ("delete", class_breakpoint
, delete_command
,
4016 "Delete some breakpoints or auto-display expressions.\n\
4017 Arguments are breakpoint numbers with spaces in between.\n\
4018 To delete all breakpoints, give no argument.\n\
4020 Also a prefix command for deletion of other GDB objects.\n\
4021 The \"unset\" command is also an alias for \"delete\".",
4022 &deletelist
, "delete ", 1, &cmdlist
);
4023 add_com_alias ("d", "delete", class_breakpoint
, 1);
4025 add_cmd ("breakpoints", class_alias
, delete_command
,
4026 "Delete some breakpoints or auto-display expressions.\n\
4027 Arguments are breakpoint numbers with spaces in between.\n\
4028 To delete all breakpoints, give no argument.\n\
4029 This command may be abbreviated \"delete\".",
4032 add_com ("clear", class_breakpoint
, clear_command
,
4033 concat ("Clear breakpoint at specified line or function.\n\
4034 Argument may be line number, function name, or \"*\" and an address.\n\
4035 If line number is specified, all breakpoints in that line are cleared.\n\
4036 If function is specified, breakpoints at beginning of function are cleared.\n\
4037 If an address is specified, breakpoints at that address are cleared.\n\n",
4038 "With no argument, clears all breakpoints in the line that the selected frame\n\
4041 See also the \"delete\" command which clears breakpoints by number.", NULL
));
4043 add_com ("break", class_breakpoint
, break_command
,
4044 concat ("Set breakpoint at specified line or function.\n\
4045 Argument may be line number, function name, or \"*\" and an address.\n\
4046 If line number is specified, break at start of code for that line.\n\
4047 If function is specified, break at start of code for that function.\n\
4048 If an address is specified, break at that exact address.\n",
4049 "With no arg, uses current execution address of selected stack frame.\n\
4050 This is useful for breaking on return to a stack frame.\n\
4052 Multiple breakpoints at one place are permitted, and useful if conditional.\n\
4054 Do \"help breakpoints\" for info on other commands dealing with breakpoints.", NULL
));
4055 add_com_alias ("b", "break", class_run
, 1);
4056 add_com_alias ("br", "break", class_run
, 1);
4057 add_com_alias ("bre", "break", class_run
, 1);
4058 add_com_alias ("brea", "break", class_run
, 1);
4060 add_info ("breakpoints", breakpoints_info
,
4061 concat ("Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
4062 The \"Type\" column indicates one of:\n\
4063 \tbreakpoint - normal breakpoint\n\
4064 \twatchpoint - watchpoint\n\
4065 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
4066 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
4067 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
4068 address and file/line number respectively.\n\n",
4069 "Convenience variable \"$_\" and default examine address for \"x\"\n\
4070 are set to the address of the last breakpoint listed.\n\n\
4071 Convenience variable \"$bpnum\" contains the number of the last\n\
4072 breakpoint set.", NULL
));
4074 #if MAINTENANCE_CMDS
4076 add_cmd ("breakpoints", class_maintenance
, maintenance_info_breakpoints
,
4077 concat ("Status of all breakpoints, or breakpoint number NUMBER.\n\
4078 The \"Type\" column indicates one of:\n\
4079 \tbreakpoint - normal breakpoint\n\
4080 \twatchpoint - watchpoint\n\
4081 \tlongjmp - internal breakpoint used to step through longjmp()\n\
4082 \tlongjmp resume - internal breakpoint at the target of longjmp()\n\
4083 \tuntil - internal breakpoint used by the \"until\" command\n\
4084 \tfinish - internal breakpoint used by the \"finish\" command\n",
4085 "The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
4086 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
4087 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
4088 address and file/line number respectively.\n\n",
4089 "Convenience variable \"$_\" and default examine address for \"x\"\n\
4090 are set to the address of the last breakpoint listed.\n\n\
4091 Convenience variable \"$bpnum\" contains the number of the last\n\
4092 breakpoint set.", NULL
),
4093 &maintenanceinfolist
);
4095 #endif /* MAINTENANCE_CMDS */
4097 add_com ("catch", class_breakpoint
, catch_command
,
4098 "Set breakpoints to catch exceptions that are raised.\n\
4099 Argument may be a single exception to catch, multiple exceptions\n\
4100 to catch, or the default exception \"default\". If no arguments\n\
4101 are given, breakpoints are set at all exception handlers catch clauses\n\
4102 within the current scope.\n\
4104 A condition specified for the catch applies to all breakpoints set\n\
4105 with this command\n\
4107 Do \"help breakpoints\" for info on other commands dealing with breakpoints.");
4109 add_com ("watch", class_breakpoint
, watch_command
,
4110 "Set a watchpoint for an expression.\n\
4111 A watchpoint stops execution of your program whenever the value of\n\
4112 an expression changes.");
4114 add_com ("rwatch", class_breakpoint
, rwatch_command
,
4115 "Set a read watchpoint for an expression.\n\
4116 A watchpoint stops execution of your program whenever the value of\n\
4117 an expression is read.");
4119 add_com ("awatch", class_breakpoint
, awatch_command
,
4120 "Set a watchpoint for an expression.\n\
4121 A watchpoint stops execution of your program whenever the value of\n\
4122 an expression is either read or written.");
4124 add_info ("watchpoints", breakpoints_info
,
4125 "Synonym for ``info breakpoints''.");