1 /* Everything about breakpoints, for GDB.
2 Copyright 1986, 1987, 1989, 1990, 1991, 1992 Free Software Foundation, Inc.
4 This file is part of GDB.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
24 #include "breakpoint.h"
26 #include "expression.h"
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 disable_breakpoint
PARAMS ((struct breakpoint
*));
64 enable_command
PARAMS ((char *, int));
67 enable_breakpoint
PARAMS ((struct breakpoint
*));
70 map_breakpoint_numbers
PARAMS ((char *, void (*)(struct breakpoint
*)));
73 ignore_command
PARAMS ((char *, int));
76 breakpoint_re_set_one
PARAMS ((char *));
79 delete_command
PARAMS ((char *, int));
82 clear_command
PARAMS ((char *, int));
85 catch_command
PARAMS ((char *, int));
87 static struct symtabs_and_lines
88 get_catch_sals
PARAMS ((int));
91 watch_command
PARAMS ((char *, int));
94 can_use_hardware_watchpoint
PARAMS ((struct breakpoint
*));
97 tbreak_command
PARAMS ((char *, int));
100 break_command_1
PARAMS ((char *, int, int));
103 mention
PARAMS ((struct breakpoint
*));
105 static struct breakpoint
*
106 set_raw_breakpoint
PARAMS ((struct symtab_and_line
));
109 check_duplicates
PARAMS ((CORE_ADDR
));
112 describe_other_breakpoints
PARAMS ((CORE_ADDR
));
115 breakpoints_info
PARAMS ((char *, int));
118 breakpoint_1
PARAMS ((int, int));
121 bpstat_alloc
PARAMS ((struct breakpoint
*, bpstat
));
124 breakpoint_cond_eval
PARAMS ((char *));
127 cleanup_executing_breakpoints
PARAMS ((int));
130 commands_command
PARAMS ((char *, int));
133 condition_command
PARAMS ((char *, int));
136 get_number
PARAMS ((char **));
139 set_breakpoint_count
PARAMS ((int));
142 remove_breakpoint
PARAMS ((struct breakpoint
*));
144 extern int addressprint
; /* Print machine addresses? */
145 extern int demangle
; /* Print de-mangled symbol names? */
147 /* Are we executing breakpoint commands? */
148 static int executing_breakpoint_commands
;
150 /* Walk the following statement or block through all breakpoints.
151 ALL_BREAKPOINTS_SAFE does so even if the statment deletes the current
154 #define ALL_BREAKPOINTS(b) for (b = breakpoint_chain; b; b = b->next)
156 #define ALL_BREAKPOINTS_SAFE(b,tmp) \
157 for (b = breakpoint_chain; \
158 b? (tmp=b->next, 1): 0; \
161 /* By default no support for hardware watchpoints is assumed. */
162 #ifndef TARGET_CAN_USE_HARDWARE_WATCHPOINT
163 #define TARGET_CAN_USE_HARDWARE_WATCHPOINT(B) 0
164 #define target_remove_watchpoint(ADDR,LEN) -1
165 #define target_insert_watchpoint(ADDR,LEN) -1
168 /* Chain of all breakpoints defined. */
170 static struct breakpoint
*breakpoint_chain
;
172 /* Number of last breakpoint made. */
174 static int breakpoint_count
;
176 /* Set breakpoint count to NUM. */
178 set_breakpoint_count (num
)
181 breakpoint_count
= num
;
182 set_internalvar (lookup_internalvar ("bpnum"),
183 value_from_longest (builtin_type_int
, (LONGEST
) num
));
186 /* Default address, symtab and line to put a breakpoint at
187 for "break" command with no arg.
188 if default_breakpoint_valid is zero, the other three are
189 not valid, and "break" with no arg is an error.
191 This set by print_stack_frame, which calls set_default_breakpoint. */
193 int default_breakpoint_valid
;
194 CORE_ADDR default_breakpoint_address
;
195 struct symtab
*default_breakpoint_symtab
;
196 int default_breakpoint_line
;
198 /* *PP is a string denoting a breakpoint. Get the number of the breakpoint.
199 Advance *PP after the string and any trailing whitespace.
201 Currently the string can either be a number or "$" followed by the name
202 of a convenience variable. Making it an expression wouldn't work well
203 for map_breakpoint_numbers (e.g. "4 + 5 + 6"). */
212 /* Empty line means refer to the last breakpoint. */
213 return breakpoint_count
;
216 /* Make a copy of the name, so we can null-terminate it
217 to pass to lookup_internalvar(). */
222 while (isalnum (*p
) || *p
== '_')
224 varname
= (char *) alloca (p
- start
+ 1);
225 strncpy (varname
, start
, p
- start
);
226 varname
[p
- start
] = '\0';
227 val
= value_of_internalvar (lookup_internalvar (varname
));
228 if (TYPE_CODE (VALUE_TYPE (val
)) != TYPE_CODE_INT
)
230 "Convenience variables used to specify breakpoints must have integer values."
232 retval
= (int) value_as_long (val
);
238 while (*p
>= '0' && *p
<= '9')
241 /* There is no number here. (e.g. "cond a == b"). */
242 error_no_arg ("breakpoint number");
245 if (!(isspace (*p
) || *p
== '\0'))
246 error ("breakpoint number expected");
253 /* condition N EXP -- set break condition of breakpoint N to EXP. */
256 condition_command (arg
, from_tty
)
260 register struct breakpoint
*b
;
265 error_no_arg ("breakpoint number");
268 bnum
= get_number (&p
);
271 if (b
->number
== bnum
)
278 if (b
->cond_string
!= NULL
)
279 free ((PTR
)b
->cond_string
);
284 b
->cond_string
= NULL
;
286 printf_filtered ("Breakpoint %d now unconditional.\n", bnum
);
291 /* I don't know if it matters whether this is the string the user
292 typed in or the decompiled expression. */
293 b
->cond_string
= savestring (arg
, strlen (arg
));
294 b
->cond
= parse_exp_1 (&arg
, block_for_pc (b
->address
), 0);
296 error ("Junk at end of expression");
301 error ("No breakpoint number %d.", bnum
);
306 commands_command (arg
, from_tty
)
310 register struct breakpoint
*b
;
313 struct command_line
*l
;
315 /* If we allowed this, we would have problems with when to
316 free the storage, if we change the commands currently
319 if (executing_breakpoint_commands
)
320 error ("Can't use the \"commands\" command among a breakpoint's commands.");
323 bnum
= get_number (&p
);
325 error ("Unexpected extra arguments following breakpoint number.");
328 if (b
->number
== bnum
)
330 if (from_tty
&& input_from_terminal_p ())
331 printf_filtered ("Type commands for when breakpoint %d is hit, one per line.\n\
332 End with a line saying just \"end\".\n", bnum
);
333 l
= read_command_lines ();
334 free_command_lines (&b
->commands
);
336 breakpoints_changed ();
339 error ("No breakpoint number %d.", bnum
);
342 extern int memory_breakpoint_size
; /* from mem-break.c */
344 /* Like target_read_memory() but if breakpoints are inserted, return
345 the shadow contents instead of the breakpoints themselves.
347 Read "memory data" from whatever target or inferior we have.
348 Returns zero if successful, errno value if not. EIO is used
349 for address out of bounds. If breakpoints are inserted, returns
350 shadow contents, not the breakpoints themselves. From breakpoint.c. */
353 read_memory_nobpt (memaddr
, myaddr
, len
)
359 struct breakpoint
*b
;
361 if (memory_breakpoint_size
< 0)
362 /* No breakpoints on this machine. FIXME: This should be
363 dependent on the debugging target. Probably want
364 target_insert_breakpoint to return a size, saying how many
365 bytes of the shadow contents are used, or perhaps have
366 something like target_xfer_shadow. */
367 return target_read_memory (memaddr
, myaddr
, len
);
371 if (b
->type
== bp_watchpoint
372 || b
->type
== bp_hardware_watchpoint
375 else if (b
->address
+ memory_breakpoint_size
<= memaddr
)
376 /* The breakpoint is entirely before the chunk of memory
379 else if (b
->address
>= memaddr
+ len
)
380 /* The breakpoint is entirely after the chunk of memory we
385 /* Copy the breakpoint from the shadow contents, and recurse
386 for the things before and after. */
388 /* Addresses and length of the part of the breakpoint that
390 CORE_ADDR membpt
= b
->address
;
391 unsigned int bptlen
= memory_breakpoint_size
;
392 /* Offset within shadow_contents. */
395 if (membpt
< memaddr
)
397 /* Only copy the second part of the breakpoint. */
398 bptlen
-= memaddr
- membpt
;
399 bptoffset
= memaddr
- membpt
;
403 if (membpt
+ bptlen
> memaddr
+ len
)
405 /* Only copy the first part of the breakpoint. */
406 bptlen
-= (membpt
+ bptlen
) - (memaddr
+ len
);
409 memcpy (myaddr
+ membpt
- memaddr
,
410 b
->shadow_contents
+ bptoffset
, bptlen
);
412 if (membpt
> memaddr
)
414 /* Copy the section of memory before the breakpoint. */
415 status
= read_memory_nobpt (memaddr
, myaddr
, membpt
- memaddr
);
420 if (membpt
+ bptlen
< memaddr
+ len
)
422 /* Copy the section of memory after the breakpoint. */
423 status
= read_memory_nobpt
425 myaddr
+ membpt
+ bptlen
- memaddr
,
426 memaddr
+ len
- (membpt
+ bptlen
));
433 /* Nothing overlaps. Just call read_memory_noerr. */
434 return target_read_memory (memaddr
, myaddr
, len
);
437 /* insert_breakpoints is used when starting or continuing the program.
438 remove_breakpoints is used when the program stops.
439 Both return zero if successful,
440 or an `errno' value if could not write the inferior. */
443 insert_breakpoints ()
445 register struct breakpoint
*b
;
447 int disabled_breaks
= 0;
450 if (b
->type
!= bp_watchpoint
451 && b
->type
!= bp_hardware_watchpoint
452 && b
->enable
!= disabled
456 val
= target_insert_breakpoint(b
->address
, b
->shadow_contents
);
459 /* Can't set the breakpoint. */
460 #if defined (DISABLE_UNSETTABLE_BREAK)
461 if (DISABLE_UNSETTABLE_BREAK (b
->address
))
464 b
->enable
= disabled
;
465 if (!disabled_breaks
)
467 target_terminal_ours_for_output ();
468 fprintf_unfiltered (gdb_stderr
,
469 "Cannot insert breakpoint %d:\n", b
->number
);
470 printf_filtered ("Disabling shared library breakpoints:\n");
473 printf_filtered ("%d ", b
->number
);
478 target_terminal_ours_for_output ();
479 fprintf_unfiltered (gdb_stderr
, "Cannot insert breakpoint %d:\n", b
->number
);
480 #ifdef ONE_PROCESS_WRITETEXT
481 fprintf_unfiltered (gdb_stderr
,
482 "The same program may be running in another process.\n");
484 memory_error (val
, b
->address
); /* which bombs us out */
490 else if (b
->type
== bp_hardware_watchpoint
491 && b
->enable
== enabled
496 int saved_level
, within_current_scope
;
497 value_ptr mark
= value_mark ();
500 /* Save the current frame and level so we can restore it after
501 evaluating the watchpoint expression on its own frame. */
502 saved_frame
= selected_frame
;
503 saved_level
= selected_frame_level
;
505 /* Determine if the watchpoint is within scope. */
506 if (b
->exp_valid_block
== NULL
)
507 within_current_scope
= 1;
510 FRAME fr
= find_frame_addr_in_frame_chain (b
->watchpoint_frame
);
511 within_current_scope
= (fr
!= NULL
);
512 if (within_current_scope
)
513 select_frame (fr
, -1);
516 if (within_current_scope
)
518 /* Evaluate the expression and cut the chain of values
519 produced off from the value chain. */
520 v
= evaluate_expression (b
->exp
);
521 value_release_to_mark (mark
);
526 /* Look at each value on the value chain. */
527 for ( ; v
; v
=v
->next
)
529 /* If it's a memory location, then we must watch it. */
530 if (v
->lval
== lval_memory
)
534 addr
= VALUE_ADDRESS (v
) + VALUE_OFFSET (v
);
535 len
= TYPE_LENGTH (VALUE_TYPE (v
));
536 val
= target_insert_watchpoint (addr
, len
);
545 /* Failure to insert a watchpoint on any memory value in the
546 value chain brings us here. */
548 warning ("Hardware watchpoint %d: Could not insert watchpoint\n",
554 Hardware watchpoint %d deleted because the program has left the block in\n\
555 which its expression is valid.\n", b
->number
);
556 if (b
->related_breakpoint
)
557 delete_breakpoint (b
->related_breakpoint
);
558 delete_breakpoint (b
);
561 /* Restore the frame and level. */
562 select_frame (saved_frame
, saved_level
);
565 printf_filtered ("\n");
571 remove_breakpoints ()
573 register struct breakpoint
*b
;
580 val
= remove_breakpoint (b
);
590 remove_breakpoint (b
)
591 struct breakpoint
*b
;
595 if (b
->type
!= bp_watchpoint
596 && b
->type
!= bp_hardware_watchpoint
)
598 val
= target_remove_breakpoint(b
->address
, b
->shadow_contents
);
603 else if (b
->type
== bp_hardware_watchpoint
604 && b
->enable
== enabled
610 /* Walk down the saved value chain. */
611 for (v
= b
->val_chain
; v
; v
= v
->next
)
613 /* For each memory reference remove the watchpoint
615 if (v
->lval
== lval_memory
)
619 addr
= VALUE_ADDRESS (v
) + VALUE_OFFSET (v
);
620 len
= TYPE_LENGTH (VALUE_TYPE (v
));
621 val
= target_remove_watchpoint (addr
, len
);
627 /* Failure to remove any of the hardware watchpoints comes here. */
629 error ("Hardware watchpoint %d: Could not remove watchpoint\n",
632 /* Free the saved value chain. We will construct a new one
633 the next time the watchpoint is inserted. */
634 for (v
= b
->val_chain
; v
; v
= n
)
644 /* Clear the "inserted" flag in all breakpoints. */
647 mark_breakpoints_out ()
649 register struct breakpoint
*b
;
655 /* Clear the "inserted" flag in all breakpoints and delete any breakpoints
656 which should go away between runs of the program. */
659 breakpoint_init_inferior ()
661 register struct breakpoint
*b
, *temp
;
663 ALL_BREAKPOINTS_SAFE (b
, temp
)
667 /* If the call dummy breakpoint is at the entry point it will
668 cause problems when the inferior is rerun, so we better
670 if (b
->type
== bp_call_dummy
)
671 delete_breakpoint (b
);
673 /* Likewise for scope breakpoints. */
674 if (b
->type
== bp_watchpoint_scope
)
675 delete_breakpoint (b
);
677 /* Likewise for watchpoints on local expressions. */
678 if ((b
->type
== bp_watchpoint
|| b
->type
== bp_hardware_watchpoint
)
679 && b
->exp_valid_block
!= NULL
)
680 delete_breakpoint (b
);
684 /* breakpoint_here_p (PC) returns 1 if an enabled breakpoint exists at PC.
685 When continuing from a location with a breakpoint,
686 we actually single step once before calling insert_breakpoints. */
689 breakpoint_here_p (pc
)
692 register struct breakpoint
*b
;
695 if (b
->enable
!= disabled
&& b
->address
== pc
)
701 /* Return nonzero if FRAME is a dummy frame. We can't use PC_IN_CALL_DUMMY
702 because figuring out the saved SP would take too much time, at least using
703 get_saved_register on the 68k. This means that for this function to
704 work right a port must use the bp_call_dummy breakpoint. */
707 frame_in_dummy (frame
)
710 struct breakpoint
*b
;
715 static unsigned LONGEST dummy
[] = CALL_DUMMY
;
717 if (b
->type
== bp_call_dummy
718 && b
->frame
== frame
->frame
720 /* We need to check the PC as well as the frame on the sparc,
721 for signals.exp in the testsuite. */
724 - sizeof (dummy
) / sizeof (LONGEST
) * REGISTER_SIZE
))
725 && frame
->pc
<= b
->address
)
728 #endif /* CALL_DUMMY */
732 /* breakpoint_match_thread (PC, PID) returns true if the breakpoint at PC
733 is valid for process/thread PID. */
736 breakpoint_thread_match (pc
, pid
)
740 struct breakpoint
*b
;
743 thread
= pid_to_thread_id (pid
);
746 if (b
->enable
!= disabled
748 && (b
->thread
== -1 || b
->thread
== thread
))
755 /* bpstat stuff. External routines' interfaces are documented
758 /* Clear a bpstat so that it says we are not at any breakpoint.
759 Also free any storage that is part of a bpstat. */
774 if (p
->old_val
!= NULL
)
775 value_free (p
->old_val
);
782 /* Return a copy of a bpstat. Like "bs1 = bs2" but all storage that
783 is part of the bpstat is copied as well. */
791 bpstat retval
= NULL
;
796 for (; bs
!= NULL
; bs
= bs
->next
)
798 tmp
= (bpstat
) xmalloc (sizeof (*tmp
));
799 memcpy (tmp
, bs
, sizeof (*tmp
));
801 /* This is the first thing in the chain. */
811 /* Find the bpstat associated with this breakpoint */
814 bpstat_find_breakpoint(bsp
, breakpoint
)
816 struct breakpoint
*breakpoint
;
818 if (bsp
== NULL
) return NULL
;
820 for (;bsp
!= NULL
; bsp
= bsp
->next
) {
821 if (bsp
->breakpoint_at
== breakpoint
) return bsp
;
826 /* Return the breakpoint number of the first breakpoint we are stopped
827 at. *BSP upon return is a bpstat which points to the remaining
828 breakpoints stopped at (but which is not guaranteed to be good for
829 anything but further calls to bpstat_num).
830 Return 0 if passed a bpstat which does not indicate any breakpoints. */
836 struct breakpoint
*b
;
839 return 0; /* No more breakpoint values */
842 b
= (*bsp
)->breakpoint_at
;
845 return -1; /* breakpoint that's been deleted since */
847 return b
->number
; /* We have its number */
851 /* Modify BS so that the actions will not be performed. */
854 bpstat_clear_actions (bs
)
857 for (; bs
!= NULL
; bs
= bs
->next
)
860 if (bs
->old_val
!= NULL
)
862 value_free (bs
->old_val
);
868 /* Stub for cleaning up our state if we error-out of a breakpoint command */
871 cleanup_executing_breakpoints (ignore
)
874 executing_breakpoint_commands
= 0;
877 /* Execute all the commands associated with all the breakpoints at this
878 location. Any of these commands could cause the process to proceed
879 beyond this point, etc. We look out for such changes by checking
880 the global "breakpoint_proceeded" after each command. */
883 bpstat_do_actions (bsp
)
887 struct cleanup
*old_chain
;
889 executing_breakpoint_commands
= 1;
890 old_chain
= make_cleanup (cleanup_executing_breakpoints
, 0);
895 breakpoint_proceeded
= 0;
896 for (; bs
!= NULL
; bs
= bs
->next
)
900 char *line
= bs
->commands
->line
;
901 bs
->commands
= bs
->commands
->next
;
902 execute_command (line
, 0);
903 /* If the inferior is proceeded by the command, bomb out now.
904 The bpstat chain has been blown away by wait_for_inferior.
905 But since execution has stopped again, there is a new bpstat
906 to look at, so start over. */
907 if (breakpoint_proceeded
)
912 executing_breakpoint_commands
= 0;
913 discard_cleanups (old_chain
);
916 /* This is the normal print_it function for a bpstat. In the future,
917 much of this logic could (should?) be moved to bpstat_stop_status,
918 by having it set different print_it functions. */
924 /* bs->breakpoint_at can be NULL if it was a momentary breakpoint
925 which has since been deleted. */
926 if (bs
->breakpoint_at
== NULL
927 || (bs
->breakpoint_at
->type
!= bp_breakpoint
928 && bs
->breakpoint_at
->type
!= bp_watchpoint
929 && bs
->breakpoint_at
->type
!= bp_hardware_watchpoint
))
932 if (bs
->breakpoint_at
->type
== bp_breakpoint
)
934 /* I think the user probably only wants to see one breakpoint
935 number, not all of them. */
936 annotate_breakpoint (bs
->breakpoint_at
->number
);
937 printf_filtered ("\nBreakpoint %d, ", bs
->breakpoint_at
->number
);
941 if (bs
->old_val
!= NULL
)
943 annotate_watchpoint (bs
->breakpoint_at
->number
);
944 printf_filtered ("\nWatchpoint %d, ", bs
->breakpoint_at
->number
);
945 print_expression (bs
->breakpoint_at
->exp
, gdb_stdout
);
946 printf_filtered ("\nOld value = ");
947 value_print (bs
->old_val
, gdb_stdout
, 0, Val_pretty_default
);
948 printf_filtered ("\nNew value = ");
949 value_print (bs
->breakpoint_at
->val
, gdb_stdout
, 0,
951 printf_filtered ("\n");
952 value_free (bs
->old_val
);
954 /* More than one watchpoint may have been triggered. */
957 /* We can't deal with it. Maybe another member of the bpstat chain can. */
961 /* Print a message indicating what happened. Returns nonzero to
962 say that only the source line should be printed after this (zero
963 return means print the frame as well as the source line). */
964 /* Currently we always return zero. */
974 val
= (*bs
->print_it
) (bs
);
978 /* Maybe another breakpoint in the chain caused us to stop.
979 (Currently all watchpoints go on the bpstat whether hit or
980 not. That probably could (should) be changed, provided care is taken
981 with respect to bpstat_explains_signal). */
983 return bpstat_print (bs
->next
);
985 /* We reached the end of the chain without printing anything. */
989 /* Evaluate the expression EXP and return 1 if value is zero.
990 This is used inside a catch_errors to evaluate the breakpoint condition.
991 The argument is a "struct expression *" that has been cast to char * to
992 make it pass through catch_errors. */
995 breakpoint_cond_eval (exp
)
998 return !value_true (evaluate_expression ((struct expression
*)exp
));
1001 /* Allocate a new bpstat and chain it to the current one. */
1004 bpstat_alloc (b
, cbs
)
1005 register struct breakpoint
*b
;
1006 bpstat cbs
; /* Current "bs" value */
1010 bs
= (bpstat
) xmalloc (sizeof (*bs
));
1012 bs
->breakpoint_at
= b
;
1013 /* If the condition is false, etc., don't do the commands. */
1014 bs
->commands
= NULL
;
1016 bs
->print_it
= print_it_normal
;
1022 /* Possible return values for watchpoint_check (this can't be an enum
1023 because of check_errors). */
1024 /* The watchpoint has been deleted. */
1025 #define WP_DELETED 1
1026 /* The value has changed. */
1027 #define WP_VALUE_CHANGED 2
1028 /* The value has not changed. */
1029 #define WP_VALUE_NOT_CHANGED 3
1031 /* Check watchpoint condition. */
1033 watchpoint_check (p
)
1036 bpstat bs
= (bpstat
) p
;
1037 FRAME saved_frame
, fr
;
1038 int within_current_scope
, saved_level
;
1040 /* Save the current frame and level so we can restore it after
1041 evaluating the watchpoint expression on its own frame. */
1042 saved_frame
= selected_frame
;
1043 saved_level
= selected_frame_level
;
1045 if (bs
->breakpoint_at
->exp_valid_block
== NULL
)
1046 within_current_scope
= 1;
1049 fr
= find_frame_addr_in_frame_chain (bs
->breakpoint_at
->watchpoint_frame
);
1050 within_current_scope
= (fr
!= NULL
);
1051 if (within_current_scope
)
1052 /* If we end up stopping, the current frame will get selected
1053 in normal_stop. So this call to select_frame won't affect
1055 select_frame (fr
, -1);
1058 if (within_current_scope
)
1060 /* We use value_{,free_to_}mark because it could be a
1061 *long* time before we return to the command level and
1062 call free_all_values. We can't call free_all_values because
1063 we might be in the middle of evaluating a function call. */
1065 value_ptr mark
= value_mark ();
1066 value_ptr new_val
= evaluate_expression (bs
->breakpoint_at
->exp
);
1067 if (!value_equal (bs
->breakpoint_at
->val
, new_val
))
1069 release_value (new_val
);
1070 value_free_to_mark (mark
);
1071 bs
->old_val
= bs
->breakpoint_at
->val
;
1072 bs
->breakpoint_at
->val
= new_val
;
1073 /* We will stop here */
1074 select_frame (saved_frame
, saved_level
);
1075 return WP_VALUE_CHANGED
;
1079 /* Nothing changed, don't do anything. */
1080 value_free_to_mark (mark
);
1081 /* We won't stop here */
1082 select_frame (saved_frame
, saved_level
);
1083 return WP_VALUE_NOT_CHANGED
;
1088 /* This seems like the only logical thing to do because
1089 if we temporarily ignored the watchpoint, then when
1090 we reenter the block in which it is valid it contains
1091 garbage (in the case of a function, it may have two
1092 garbage values, one before and one after the prologue).
1093 So we can't even detect the first assignment to it and
1094 watch after that (since the garbage may or may not equal
1095 the first value assigned). */
1097 Watchpoint %d deleted because the program has left the block in\n\
1098 which its expression is valid.\n", bs
->breakpoint_at
->number
);
1099 if (bs
->breakpoint_at
->related_breakpoint
)
1100 delete_breakpoint (bs
->breakpoint_at
->related_breakpoint
);
1101 delete_breakpoint (bs
->breakpoint_at
);
1103 select_frame (saved_frame
, saved_level
);
1108 /* This is used when everything which needs to be printed has
1109 already been printed. But we still want to print the frame. */
1117 /* This is used when nothing should be printed for this bpstat entry. */
1126 /* Get a bpstat associated with having just stopped at address *PC
1127 and frame address FRAME_ADDRESS. Update *PC to point at the
1128 breakpoint (if we hit a breakpoint). NOT_A_BREAKPOINT is nonzero
1129 if this is known to not be a real breakpoint (it could still be a
1130 watchpoint, though). */
1132 /* Determine whether we stopped at a breakpoint, etc, or whether we
1133 don't understand this stop. Result is a chain of bpstat's such that:
1135 if we don't understand the stop, the result is a null pointer.
1137 if we understand why we stopped, the result is not null.
1139 Each element of the chain refers to a particular breakpoint or
1140 watchpoint at which we have stopped. (We may have stopped for
1141 several reasons concurrently.)
1143 Each element of the chain has valid next, breakpoint_at,
1144 commands, FIXME??? fields.
1149 bpstat_stop_status (pc
, frame_address
, not_a_breakpoint
)
1151 FRAME_ADDR frame_address
;
1152 int not_a_breakpoint
;
1154 register struct breakpoint
*b
;
1156 #if DECR_PC_AFTER_BREAK != 0 || defined (SHIFT_INST_REGS)
1157 /* True if we've hit a breakpoint (as opposed to a watchpoint). */
1158 int real_breakpoint
= 0;
1160 /* Root of the chain of bpstat's */
1161 struct bpstat root_bs
[1];
1162 /* Pointer to the last thing in the chain currently. */
1163 bpstat bs
= root_bs
;
1165 /* Get the address where the breakpoint would have been. */
1166 bp_addr
= *pc
- DECR_PC_AFTER_BREAK
;
1170 if (b
->enable
== disabled
)
1173 if (b
->type
!= bp_watchpoint
1174 && b
->type
!= bp_hardware_watchpoint
1175 && b
->address
!= bp_addr
)
1178 if (b
->type
!= bp_watchpoint
1179 && b
->type
!= bp_hardware_watchpoint
1180 && not_a_breakpoint
)
1183 /* Come here if it's a watchpoint, or if the break address matches */
1185 bs
= bpstat_alloc (b
, bs
); /* Alloc a bpstat to explain stop */
1190 if (b
->type
== bp_watchpoint
|| b
->type
== bp_hardware_watchpoint
)
1192 static char message1
[] =
1193 "Error evaluating expression for watchpoint %d\n";
1194 char message
[sizeof (message1
) + 30 /* slop */];
1195 sprintf (message
, message1
, b
->number
);
1196 switch (catch_errors (watchpoint_check
, (char *) bs
, message
,
1200 /* We've already printed what needs to be printed. */
1201 bs
->print_it
= print_it_done
;
1204 case WP_VALUE_CHANGED
:
1207 case WP_VALUE_NOT_CHANGED
:
1209 bs
->print_it
= print_it_noop
;
1216 /* Error from catch_errors. */
1217 printf_filtered ("Watchpoint %d deleted.\n", b
->number
);
1218 if (b
->related_breakpoint
)
1219 delete_breakpoint (b
->related_breakpoint
);
1220 delete_breakpoint (b
);
1221 /* We've already printed what needs to be printed. */
1222 bs
->print_it
= print_it_done
;
1228 #if DECR_PC_AFTER_BREAK != 0 || defined (SHIFT_INST_REGS)
1230 real_breakpoint
= 1;
1233 if (b
->frame
&& b
->frame
!= frame_address
)
1237 int value_is_zero
= 0;
1241 /* Need to select the frame, with all that implies
1242 so that the conditions will have the right context. */
1243 select_frame (get_current_frame (), 0);
1245 = catch_errors (breakpoint_cond_eval
, (char *)(b
->cond
),
1246 "Error in testing breakpoint condition:\n",
1248 /* FIXME-someday, should give breakpoint # */
1251 if (b
->cond
&& value_is_zero
)
1255 else if (b
->ignore_count
> 0)
1262 /* We will stop here */
1263 if (b
->disposition
== disable
)
1264 b
->enable
= disabled
;
1265 bs
->commands
= b
->commands
;
1268 if (bs
->commands
&& STREQ ("silent", bs
->commands
->line
))
1270 bs
->commands
= bs
->commands
->next
;
1275 /* Print nothing for this entry if we dont stop or if we dont print. */
1276 if (bs
->stop
== 0 || bs
->print
== 0)
1277 bs
->print_it
= print_it_noop
;
1280 bs
->next
= NULL
; /* Terminate the chain */
1281 bs
= root_bs
->next
; /* Re-grab the head of the chain */
1282 #if DECR_PC_AFTER_BREAK != 0 || defined (SHIFT_INST_REGS)
1285 if (real_breakpoint
)
1288 #if defined (SHIFT_INST_REGS)
1290 #else /* No SHIFT_INST_REGS. */
1292 #endif /* No SHIFT_INST_REGS. */
1295 #endif /* DECR_PC_AFTER_BREAK != 0. */
1297 /* The value of a hardware watchpoint hasn't changed, but the
1298 intermediate memory locations we are watching may have. */
1299 if (bs
&& ! bs
->stop
1300 && bs
->breakpoint_at
->type
== bp_hardware_watchpoint
)
1302 remove_breakpoints ();
1303 insert_breakpoints ();
1308 /* Tell what to do about this bpstat. */
1313 /* Classify each bpstat as one of the following. */
1315 /* This bpstat element has no effect on the main_action. */
1318 /* There was a watchpoint, stop but don't print. */
1321 /* There was a watchpoint, stop and print. */
1324 /* There was a breakpoint but we're not stopping. */
1327 /* There was a breakpoint, stop but don't print. */
1330 /* There was a breakpoint, stop and print. */
1333 /* We hit the longjmp breakpoint. */
1336 /* We hit the longjmp_resume breakpoint. */
1339 /* We hit the step_resume breakpoint. */
1342 /* We hit the through_sigtramp breakpoint. */
1345 /* This is just used to count how many enums there are. */
1349 /* Here is the table which drives this routine. So that we can
1350 format it pretty, we define some abbreviations for the
1351 enum bpstat_what codes. */
1352 #define keep_c BPSTAT_WHAT_KEEP_CHECKING
1353 #define stop_s BPSTAT_WHAT_STOP_SILENT
1354 #define stop_n BPSTAT_WHAT_STOP_NOISY
1355 #define single BPSTAT_WHAT_SINGLE
1356 #define setlr BPSTAT_WHAT_SET_LONGJMP_RESUME
1357 #define clrlr BPSTAT_WHAT_CLEAR_LONGJMP_RESUME
1358 #define clrlrs BPSTAT_WHAT_CLEAR_LONGJMP_RESUME_SINGLE
1359 #define sr BPSTAT_WHAT_STEP_RESUME
1360 #define ts BPSTAT_WHAT_THROUGH_SIGTRAMP
1362 /* "Can't happen." Might want to print an error message.
1363 abort() is not out of the question, but chances are GDB is just
1364 a bit confused, not unusable. */
1365 #define err BPSTAT_WHAT_STOP_NOISY
1367 /* Given an old action and a class, come up with a new action. */
1368 /* One interesting property of this table is that wp_silent is the same
1369 as bp_silent and wp_noisy is the same as bp_noisy. That is because
1370 after stopping, the check for whether to step over a breakpoint
1371 (BPSTAT_WHAT_SINGLE type stuff) is handled in proceed() without
1372 reference to how we stopped. We retain separate wp_silent and bp_silent
1373 codes in case we want to change that someday. */
1375 /* step_resume entries: a step resume breakpoint overrides another
1376 breakpoint of signal handling (see comment in wait_for_inferior
1377 at first IN_SIGTRAMP where we set the step_resume breakpoint). */
1378 /* We handle the through_sigtramp_breakpoint the same way; having both
1379 one of those and a step_resume_breakpoint is probably very rare (?). */
1381 static const enum bpstat_what_main_action
1382 table
[(int)class_last
][(int)BPSTAT_WHAT_LAST
] =
1385 /* keep_c stop_s stop_n single setlr clrlr clrlrs sr ts
1387 /*no_effect*/ {keep_c
,stop_s
,stop_n
,single
, setlr
, clrlr
, clrlrs
, sr
, ts
},
1388 /*wp_silent*/ {stop_s
,stop_s
,stop_n
,stop_s
, stop_s
, stop_s
, stop_s
, sr
, ts
},
1389 /*wp_noisy*/ {stop_n
,stop_n
,stop_n
,stop_n
, stop_n
, stop_n
, stop_n
, sr
, ts
},
1390 /*bp_nostop*/ {single
,stop_s
,stop_n
,single
, setlr
, clrlrs
, clrlrs
, sr
, ts
},
1391 /*bp_silent*/ {stop_s
,stop_s
,stop_n
,stop_s
, stop_s
, stop_s
, stop_s
, sr
, ts
},
1392 /*bp_noisy*/ {stop_n
,stop_n
,stop_n
,stop_n
, stop_n
, stop_n
, stop_n
, sr
, ts
},
1393 /*long_jump*/ {setlr
,stop_s
,stop_n
,setlr
, err
, err
, err
, sr
, ts
},
1394 /*long_resume*/ {clrlr
,stop_s
,stop_n
,clrlrs
, err
, err
, err
, sr
, ts
},
1395 /*step_resume*/ {sr
,sr
,sr
,sr
, sr
, sr
, sr
, sr
, ts
},
1396 /*through_sig*/ {ts
,ts
,ts
,ts
, ts
, ts
, ts
, ts
, ts
}
1408 enum bpstat_what_main_action current_action
= BPSTAT_WHAT_KEEP_CHECKING
;
1409 struct bpstat_what retval
;
1411 retval
.call_dummy
= 0;
1412 for (; bs
!= NULL
; bs
= bs
->next
)
1414 enum class bs_class
= no_effect
;
1415 if (bs
->breakpoint_at
== NULL
)
1416 /* I suspect this can happen if it was a momentary breakpoint
1417 which has since been deleted. */
1419 switch (bs
->breakpoint_at
->type
)
1427 bs_class
= bp_noisy
;
1429 bs_class
= bp_silent
;
1432 bs_class
= bp_nostop
;
1435 case bp_hardware_watchpoint
:
1439 bs_class
= wp_noisy
;
1441 bs_class
= wp_silent
;
1444 /* There was a watchpoint, but we're not stopping. This requires
1445 no further action. */
1446 bs_class
= no_effect
;
1449 bs_class
= long_jump
;
1451 case bp_longjmp_resume
:
1452 bs_class
= long_resume
;
1454 case bp_step_resume
:
1457 bs_class
= step_resume
;
1460 /* It is for the wrong frame. */
1461 bs_class
= bp_nostop
;
1463 case bp_through_sigtramp
:
1464 bs_class
= through_sig
;
1466 case bp_watchpoint_scope
:
1467 bs_class
= bp_nostop
;
1471 /* Make sure the action is stop (silent or noisy), so infrun.c
1472 pops the dummy frame. */
1473 bs_class
= bp_silent
;
1474 retval
.call_dummy
= 1;
1477 current_action
= table
[(int)bs_class
][(int)current_action
];
1479 retval
.main_action
= current_action
;
1483 /* Nonzero if we should step constantly (e.g. watchpoints on machines
1484 without hardware support). This isn't related to a specific bpstat,
1485 just to things like whether watchpoints are set. */
1488 bpstat_should_step ()
1490 struct breakpoint
*b
;
1492 if (b
->enable
== enabled
&& b
->type
== bp_watchpoint
)
1497 /* Print information on breakpoint number BNUM, or -1 if all.
1498 If WATCHPOINTS is zero, process only breakpoints; if WATCHPOINTS
1499 is nonzero, process only watchpoints. */
1502 breakpoint_1 (bnum
, allflag
)
1506 register struct breakpoint
*b
;
1507 register struct command_line
*l
;
1508 register struct symbol
*sym
;
1509 CORE_ADDR last_addr
= (CORE_ADDR
)-1;
1510 int found_a_breakpoint
= 0;
1511 static char *bptypes
[] = {"breakpoint", "until", "finish", "watchpoint",
1512 "hardware watchpoint", "longjmp",
1513 "longjmp resume", "step resume",
1514 "watchpoint scope", "call dummy" };
1515 static char *bpdisps
[] = {"del", "dis", "keep"};
1516 static char bpenables
[] = "ny";
1517 char wrap_indent
[80];
1521 || bnum
== b
->number
)
1523 /* We only print out user settable breakpoints unless the allflag is set. */
1525 && b
->type
!= bp_breakpoint
1526 && b
->type
!= bp_watchpoint
1527 && b
->type
!= bp_hardware_watchpoint
)
1530 if (!found_a_breakpoint
++)
1532 annotate_breakpoints_headers ();
1535 printf_filtered ("Num ");
1537 printf_filtered ("Type ");
1539 printf_filtered ("Disp ");
1541 printf_filtered ("Enb ");
1545 printf_filtered ("Address ");
1548 printf_filtered ("What\n");
1550 annotate_breakpoints_table ();
1555 printf_filtered ("%-3d ", b
->number
);
1557 printf_filtered ("%-14s ", bptypes
[(int)b
->type
]);
1559 printf_filtered ("%-4s ", bpdisps
[(int)b
->disposition
]);
1561 printf_filtered ("%-3c ", bpenables
[(int)b
->enable
]);
1563 strcpy (wrap_indent
, " ");
1565 strcat (wrap_indent
, " ");
1569 case bp_hardware_watchpoint
:
1570 /* Field 4, the address, is omitted (which makes the columns
1571 not line up too nicely with the headers, but the effect
1572 is relatively readable). */
1574 print_expression (b
->exp
, gdb_stdout
);
1581 case bp_longjmp_resume
:
1582 case bp_step_resume
:
1583 case bp_through_sigtramp
:
1584 case bp_watchpoint_scope
:
1589 /* FIXME-32x64: need a print_address_numeric with
1593 local_hex_string_custom
1594 ((unsigned long) b
->address
, "08l"));
1599 last_addr
= b
->address
;
1602 sym
= find_pc_function (b
->address
);
1605 fputs_filtered ("in ", gdb_stdout
);
1606 fputs_filtered (SYMBOL_SOURCE_NAME (sym
), gdb_stdout
);
1607 wrap_here (wrap_indent
);
1608 fputs_filtered (" at ", gdb_stdout
);
1610 fputs_filtered (b
->source_file
, gdb_stdout
);
1611 printf_filtered (":%d", b
->line_number
);
1614 print_address_symbolic (b
->address
, gdb_stdout
, demangle
, " ");
1618 printf_filtered ("\n");
1624 printf_filtered ("\tstop only in stack frame at ");
1625 print_address_numeric (b
->frame
, 1, gdb_stdout
);
1626 printf_filtered ("\n");
1633 printf_filtered ("\tstop only if ");
1634 print_expression (b
->cond
, gdb_stdout
);
1635 printf_filtered ("\n");
1638 if (b
->ignore_count
)
1642 printf_filtered ("\tignore next %d hits\n", b
->ignore_count
);
1645 if ((l
= b
->commands
))
1651 fputs_filtered ("\t", gdb_stdout
);
1652 fputs_filtered (l
->line
, gdb_stdout
);
1653 fputs_filtered ("\n", gdb_stdout
);
1659 if (!found_a_breakpoint
)
1662 printf_filtered ("No breakpoints or watchpoints.\n");
1664 printf_filtered ("No breakpoint or watchpoint number %d.\n", bnum
);
1667 /* Compare against (CORE_ADDR)-1 in case some compiler decides
1668 that a comparison of an unsigned with -1 is always false. */
1669 if (last_addr
!= (CORE_ADDR
)-1)
1670 set_next_address (last_addr
);
1672 annotate_breakpoints_table_end ();
1677 breakpoints_info (bnum_exp
, from_tty
)
1684 bnum
= parse_and_eval_address (bnum_exp
);
1686 breakpoint_1 (bnum
, 0);
1689 #if MAINTENANCE_CMDS
1693 maintenance_info_breakpoints (bnum_exp
, from_tty
)
1700 bnum
= parse_and_eval_address (bnum_exp
);
1702 breakpoint_1 (bnum
, 1);
1707 /* Print a message describing any breakpoints set at PC. */
1710 describe_other_breakpoints (pc
)
1711 register CORE_ADDR pc
;
1713 register int others
= 0;
1714 register struct breakpoint
*b
;
1717 if (b
->address
== pc
)
1721 printf_filtered ("Note: breakpoint%s ", (others
> 1) ? "s" : "");
1723 if (b
->address
== pc
)
1729 (b
->enable
== disabled
) ? " (disabled)" : "",
1730 (others
> 1) ? "," : ((others
== 1) ? " and" : ""));
1732 printf_filtered ("also set at pc ");
1733 print_address_numeric (pc
, 1, gdb_stdout
);
1734 printf_filtered (".\n");
1738 /* Set the default place to put a breakpoint
1739 for the `break' command with no arguments. */
1742 set_default_breakpoint (valid
, addr
, symtab
, line
)
1745 struct symtab
*symtab
;
1748 default_breakpoint_valid
= valid
;
1749 default_breakpoint_address
= addr
;
1750 default_breakpoint_symtab
= symtab
;
1751 default_breakpoint_line
= line
;
1754 /* Rescan breakpoints at address ADDRESS,
1755 marking the first one as "first" and any others as "duplicates".
1756 This is so that the bpt instruction is only inserted once. */
1759 check_duplicates (address
)
1762 register struct breakpoint
*b
;
1763 register int count
= 0;
1765 if (address
== 0) /* Watchpoints are uninteresting */
1769 if (b
->enable
!= disabled
&& b
->address
== address
)
1772 b
->duplicate
= count
> 1;
1776 /* Low level routine to set a breakpoint.
1777 Takes as args the three things that every breakpoint must have.
1778 Returns the breakpoint object so caller can set other things.
1779 Does not set the breakpoint number!
1780 Does not print anything.
1782 ==> This routine should not be called if there is a chance of later
1783 error(); otherwise it leaves a bogus breakpoint on the chain. Validate
1784 your arguments BEFORE calling this routine! */
1786 static struct breakpoint
*
1787 set_raw_breakpoint (sal
)
1788 struct symtab_and_line sal
;
1790 register struct breakpoint
*b
, *b1
;
1792 b
= (struct breakpoint
*) xmalloc (sizeof (struct breakpoint
));
1793 memset (b
, 0, sizeof (*b
));
1794 b
->address
= sal
.pc
;
1795 if (sal
.symtab
== NULL
)
1796 b
->source_file
= NULL
;
1798 b
->source_file
= savestring (sal
.symtab
->filename
,
1799 strlen (sal
.symtab
->filename
));
1801 b
->line_number
= sal
.line
;
1802 b
->enable
= enabled
;
1805 b
->ignore_count
= 0;
1809 /* Add this breakpoint to the end of the chain
1810 so that a list of breakpoints will come out in order
1811 of increasing numbers. */
1813 b1
= breakpoint_chain
;
1815 breakpoint_chain
= b
;
1823 check_duplicates (sal
.pc
);
1824 breakpoints_changed ();
1830 create_longjmp_breakpoint(func_name
)
1833 struct symtab_and_line sal
;
1834 struct breakpoint
*b
;
1835 static int internal_breakpoint_number
= -1;
1837 if (func_name
!= NULL
)
1839 struct minimal_symbol
*m
;
1841 m
= lookup_minimal_symbol(func_name
, (struct objfile
*)NULL
);
1843 sal
.pc
= SYMBOL_VALUE_ADDRESS (m
);
1853 b
= set_raw_breakpoint(sal
);
1856 b
->type
= func_name
!= NULL
? bp_longjmp
: bp_longjmp_resume
;
1857 b
->disposition
= donttouch
;
1858 b
->enable
= disabled
;
1861 b
->addr_string
= strsave(func_name
);
1862 b
->number
= internal_breakpoint_number
--;
1865 /* Call this routine when stepping and nexting to enable a breakpoint if we do
1866 a longjmp(). When we hit that breakpoint, call
1867 set_longjmp_resume_breakpoint() to figure out where we are going. */
1870 enable_longjmp_breakpoint()
1872 register struct breakpoint
*b
;
1875 if (b
->type
== bp_longjmp
)
1877 b
->enable
= enabled
;
1878 check_duplicates (b
->address
);
1883 disable_longjmp_breakpoint()
1885 register struct breakpoint
*b
;
1888 if ( b
->type
== bp_longjmp
1889 || b
->type
== bp_longjmp_resume
)
1891 b
->enable
= disabled
;
1892 check_duplicates (b
->address
);
1896 /* Call this after hitting the longjmp() breakpoint. Use this to set a new
1897 breakpoint at the target of the jmp_buf.
1899 FIXME - This ought to be done by setting a temporary breakpoint that gets
1900 deleted automatically...
1904 set_longjmp_resume_breakpoint(pc
, frame
)
1908 register struct breakpoint
*b
;
1911 if (b
->type
== bp_longjmp_resume
)
1914 b
->enable
= enabled
;
1916 b
->frame
= FRAME_FP(frame
);
1919 check_duplicates (b
->address
);
1924 /* Set a breakpoint that will evaporate an end of command
1925 at address specified by SAL.
1926 Restrict it to frame FRAME if FRAME is nonzero. */
1929 set_momentary_breakpoint (sal
, frame
, type
)
1930 struct symtab_and_line sal
;
1934 register struct breakpoint
*b
;
1935 b
= set_raw_breakpoint (sal
);
1937 b
->enable
= enabled
;
1938 b
->disposition
= donttouch
;
1939 b
->frame
= (frame
? FRAME_FP (frame
) : 0);
1945 clear_momentary_breakpoints ()
1947 register struct breakpoint
*b
;
1949 if (b
->disposition
== delete)
1951 delete_breakpoint (b
);
1957 /* Tell the user we have just set a breakpoint B. */
1960 struct breakpoint
*b
;
1965 printf_filtered ("Watchpoint %d: ", b
->number
);
1966 print_expression (b
->exp
, gdb_stdout
);
1968 case bp_hardware_watchpoint
:
1969 printf_filtered ("Hardware watchpoint %d: ", b
->number
);
1970 print_expression (b
->exp
, gdb_stdout
);
1973 printf_filtered ("Breakpoint %d at ", b
->number
);
1974 print_address_numeric (b
->address
, 1, gdb_stdout
);
1976 printf_filtered (": file %s, line %d.",
1977 b
->source_file
, b
->line_number
);
1982 case bp_longjmp_resume
:
1983 case bp_step_resume
:
1984 case bp_through_sigtramp
:
1986 case bp_watchpoint_scope
:
1989 printf_filtered ("\n");
1993 /* Nobody calls this currently. */
1994 /* Set a breakpoint from a symtab and line.
1995 If TEMPFLAG is nonzero, it is a temporary breakpoint.
1996 ADDR_STRING is a malloc'd string holding the name of where we are
1997 setting the breakpoint. This is used later to re-set it after the
1998 program is relinked and symbols are reloaded.
1999 Print the same confirmation messages that the breakpoint command prints. */
2002 set_breakpoint (s
, line
, tempflag
, addr_string
)
2008 register struct breakpoint
*b
;
2009 struct symtab_and_line sal
;
2014 resolve_sal_pc (&sal
); /* Might error out */
2015 describe_other_breakpoints (sal
.pc
);
2017 b
= set_raw_breakpoint (sal
);
2018 set_breakpoint_count (breakpoint_count
+ 1);
2019 b
->number
= breakpoint_count
;
2020 b
->type
= bp_breakpoint
;
2022 b
->addr_string
= addr_string
;
2023 b
->enable
= enabled
;
2024 b
->disposition
= tempflag
? delete : donttouch
;
2030 /* Set a breakpoint according to ARG (function, linenum or *address)
2031 and make it temporary if TEMPFLAG is nonzero. */
2034 break_command_1 (arg
, tempflag
, from_tty
)
2036 int tempflag
, from_tty
;
2038 struct symtabs_and_lines sals
;
2039 struct symtab_and_line sal
;
2040 register struct expression
*cond
= 0;
2041 register struct breakpoint
*b
;
2043 /* Pointers in arg to the start, and one past the end, of the condition. */
2044 char *cond_start
= NULL
;
2045 char *cond_end
= NULL
;
2046 /* Pointers in arg to the start, and one past the end,
2047 of the address part. */
2048 char *addr_start
= NULL
;
2049 char *addr_end
= NULL
;
2050 struct cleanup
*old_chain
;
2051 struct cleanup
*canonical_strings_chain
= NULL
;
2052 char **canonical
= (char **)NULL
;
2059 sal
.line
= sal
.pc
= sal
.end
= 0;
2062 /* If no arg given, or if first arg is 'if ', use the default breakpoint. */
2064 if (!arg
|| (arg
[0] == 'i' && arg
[1] == 'f'
2065 && (arg
[2] == ' ' || arg
[2] == '\t')))
2067 if (default_breakpoint_valid
)
2069 sals
.sals
= (struct symtab_and_line
*)
2070 xmalloc (sizeof (struct symtab_and_line
));
2071 sal
.pc
= default_breakpoint_address
;
2072 sal
.line
= default_breakpoint_line
;
2073 sal
.symtab
= default_breakpoint_symtab
;
2078 error ("No default breakpoint address now.");
2084 /* Force almost all breakpoints to be in terms of the
2085 current_source_symtab (which is decode_line_1's default). This
2086 should produce the results we want almost all of the time while
2087 leaving default_breakpoint_* alone. */
2088 if (default_breakpoint_valid
2089 && (!current_source_symtab
2090 || (arg
&& (*arg
== '+' || *arg
== '-'))))
2091 sals
= decode_line_1 (&arg
, 1, default_breakpoint_symtab
,
2092 default_breakpoint_line
, &canonical
);
2094 sals
= decode_line_1 (&arg
, 1, (struct symtab
*)NULL
, 0, &canonical
);
2102 /* Make sure that all storage allocated in decode_line_1 gets freed in case
2103 the following `for' loop errors out. */
2104 old_chain
= make_cleanup (free
, sals
.sals
);
2105 if (canonical
!= (char **)NULL
)
2107 make_cleanup (free
, canonical
);
2108 canonical_strings_chain
= make_cleanup (null_cleanup
, 0);
2109 for (i
= 0; i
< sals
.nelts
; i
++)
2111 if (canonical
[i
] != NULL
)
2112 make_cleanup (free
, canonical
[i
]);
2116 thread
= -1; /* No specific thread yet */
2118 /* Resolve all line numbers to PC's, and verify that conditions
2119 can be parsed, before setting any breakpoints. */
2120 for (i
= 0; i
< sals
.nelts
; i
++)
2122 char *tok
, *end_tok
;
2125 resolve_sal_pc (&sals
.sals
[i
]);
2131 while (*tok
== ' ' || *tok
== '\t')
2136 while (*end_tok
!= ' ' && *end_tok
!= '\t' && *end_tok
!= '\000')
2139 toklen
= end_tok
- tok
;
2141 if (toklen
>= 1 && strncmp (tok
, "if", toklen
) == 0)
2143 tok
= cond_start
= end_tok
+ 1;
2144 cond
= parse_exp_1 (&tok
, block_for_pc (sals
.sals
[i
].pc
), 0);
2147 else if (toklen
>= 1 && strncmp (tok
, "thread", toklen
) == 0)
2153 thread
= strtol (tok
, &tok
, 0);
2155 error ("Junk after thread keyword.");
2156 if (!valid_thread_id (thread
))
2157 error ("Unknown thread %d\n", thread
);
2160 error ("Junk at end of arguments.");
2164 /* Remove the canonical strings from the cleanup, they are needed below. */
2165 if (canonical
!= (char **)NULL
)
2166 discard_cleanups (canonical_strings_chain
);
2168 /* Now set all the breakpoints. */
2169 for (i
= 0; i
< sals
.nelts
; i
++)
2174 describe_other_breakpoints (sal
.pc
);
2176 b
= set_raw_breakpoint (sal
);
2177 set_breakpoint_count (breakpoint_count
+ 1);
2178 b
->number
= breakpoint_count
;
2179 b
->type
= bp_breakpoint
;
2183 /* If a canonical line spec is needed use that instead of the
2185 if (canonical
!= (char **)NULL
&& canonical
[i
] != NULL
)
2186 b
->addr_string
= canonical
[i
];
2187 else if (addr_start
)
2188 b
->addr_string
= savestring (addr_start
, addr_end
- addr_start
);
2190 b
->cond_string
= savestring (cond_start
, cond_end
- cond_start
);
2192 b
->enable
= enabled
;
2193 b
->disposition
= tempflag
? delete : donttouch
;
2200 printf_filtered ("Multiple breakpoints were set.\n");
2201 printf_filtered ("Use the \"delete\" command to delete unwanted breakpoints.\n");
2203 do_cleanups (old_chain
);
2206 /* Helper function for break_command_1 and disassemble_command. */
2209 resolve_sal_pc (sal
)
2210 struct symtab_and_line
*sal
;
2214 if (sal
->pc
== 0 && sal
->symtab
!= 0)
2216 pc
= find_line_pc (sal
->symtab
, sal
->line
);
2218 error ("No line %d in file \"%s\".",
2219 sal
->line
, sal
->symtab
->filename
);
2225 break_command (arg
, from_tty
)
2229 break_command_1 (arg
, 0, from_tty
);
2233 tbreak_command (arg
, from_tty
)
2237 break_command_1 (arg
, 1, from_tty
);
2242 watch_command (arg
, from_tty
)
2246 struct breakpoint
*b
;
2247 struct symtab_and_line sal
;
2248 struct expression
*exp
;
2249 struct block
*exp_valid_block
;
2251 FRAME frame
, prev_frame
;
2257 /* Parse arguments. */
2258 innermost_block
= NULL
;
2259 exp
= parse_expression (arg
);
2260 exp_valid_block
= innermost_block
;
2261 val
= evaluate_expression (exp
);
2262 release_value (val
);
2263 if (VALUE_LAZY (val
))
2264 value_fetch_lazy (val
);
2266 /* Now set up the breakpoint. */
2267 b
= set_raw_breakpoint (sal
);
2268 set_breakpoint_count (breakpoint_count
+ 1);
2269 b
->number
= breakpoint_count
;
2270 b
->disposition
= donttouch
;
2272 b
->exp_valid_block
= exp_valid_block
;
2275 b
->cond_string
= NULL
;
2276 b
->exp_string
= savestring (arg
, strlen (arg
));
2278 frame
= block_innermost_frame (exp_valid_block
);
2281 prev_frame
= get_prev_frame (frame
);
2282 b
->watchpoint_frame
= FRAME_FP (frame
);
2285 b
->watchpoint_frame
= (CORE_ADDR
)0;
2287 if (can_use_hardware_watchpoint (b
))
2288 b
->type
= bp_hardware_watchpoint
;
2290 b
->type
= bp_watchpoint
;
2292 /* If the expression is "local", then set up a "watchpoint scope"
2293 breakpoint at the point where we've left the scope of the watchpoint
2295 if (innermost_block
)
2297 struct breakpoint
*scope_breakpoint
;
2298 struct symtab_and_line scope_sal
;
2302 scope_sal
.pc
= get_frame_pc (prev_frame
);
2303 scope_sal
.symtab
= NULL
;
2306 scope_breakpoint
= set_raw_breakpoint (scope_sal
);
2307 set_breakpoint_count (breakpoint_count
+ 1);
2308 scope_breakpoint
->number
= breakpoint_count
;
2310 scope_breakpoint
->type
= bp_watchpoint_scope
;
2311 scope_breakpoint
->enable
= enabled
;
2313 /* Automatically delete the breakpoint when it hits. */
2314 scope_breakpoint
->disposition
= delete;
2316 /* Only break in the proper frame (help with recursion). */
2317 scope_breakpoint
->frame
= prev_frame
->frame
;
2319 /* Set the address at which we will stop. */
2320 scope_breakpoint
->address
= get_frame_pc (prev_frame
);
2322 /* The scope breakpoint is related to the watchpoint. We
2323 will need to act on them together. */
2324 b
->related_breakpoint
= scope_breakpoint
;
2331 /* Return nonzero if the watchpoint described by B can be handled
2332 completely in hardware. If the watchpoint can not be handled
2333 in hardware return zero. */
2336 can_use_hardware_watchpoint (b
)
2337 struct breakpoint
*b
;
2339 value_ptr mark
= value_mark ();
2340 value_ptr v
= evaluate_expression (b
->exp
);
2341 int found_memory
= 0;
2343 /* Make sure all the intermediate values are in memory. Also make sure
2344 we found at least one memory expression. Guards against watch 0x12345,
2345 which is meaningless, but could cause errors if one tries to insert a
2346 hardware watchpoint for the constant expression. */
2347 for ( ; v
!= mark
; v
= v
->next
)
2349 if (!(v
->lval
== lval_memory
)
2350 || v
->lval
== not_lval
2351 || (v
->lval
!= not_lval
2352 && v
->modifiable
== 0))
2355 if (v
->lval
== lval_memory
)
2359 /* The expression itself looks suitable for using a hardware
2360 watchpoint, but give the target machine a chance to reject it. */
2361 return found_memory
&& TARGET_CAN_USE_HARDWARE_WATCHPOINT (b
);
2366 * Helper routine for the until_command routine in infcmd.c. Here
2367 * because it uses the mechanisms of breakpoints.
2371 until_break_command (arg
, from_tty
)
2375 struct symtabs_and_lines sals
;
2376 struct symtab_and_line sal
;
2377 FRAME prev_frame
= get_prev_frame (selected_frame
);
2378 struct breakpoint
*breakpoint
;
2379 struct cleanup
*old_chain
;
2381 clear_proceed_status ();
2383 /* Set a breakpoint where the user wants it and at return from
2386 if (default_breakpoint_valid
)
2387 sals
= decode_line_1 (&arg
, 1, default_breakpoint_symtab
,
2388 default_breakpoint_line
, (char ***)NULL
);
2390 sals
= decode_line_1 (&arg
, 1, (struct symtab
*)NULL
, 0, (char ***)NULL
);
2392 if (sals
.nelts
!= 1)
2393 error ("Couldn't get information on specified line.");
2396 free ((PTR
)sals
.sals
); /* malloc'd, so freed */
2399 error ("Junk at end of arguments.");
2401 resolve_sal_pc (&sal
);
2403 breakpoint
= set_momentary_breakpoint (sal
, selected_frame
, bp_until
);
2405 old_chain
= make_cleanup(delete_breakpoint
, breakpoint
);
2407 /* Keep within the current frame */
2411 struct frame_info
*fi
;
2413 fi
= get_frame_info (prev_frame
);
2414 sal
= find_pc_line (fi
->pc
, 0);
2416 breakpoint
= set_momentary_breakpoint (sal
, prev_frame
, bp_until
);
2417 make_cleanup(delete_breakpoint
, breakpoint
);
2420 proceed (-1, TARGET_SIGNAL_DEFAULT
, 0);
2421 do_cleanups(old_chain
);
2425 /* These aren't used; I don't konw what they were for. */
2426 /* Set a breakpoint at the catch clause for NAME. */
2428 catch_breakpoint (name
)
2434 disable_catch_breakpoint ()
2439 delete_catch_breakpoint ()
2444 enable_catch_breakpoint ()
2451 struct sal_chain
*next
;
2452 struct symtab_and_line sal
;
2456 /* This isn't used; I don't know what it was for. */
2457 /* For each catch clause identified in ARGS, run FUNCTION
2458 with that clause as an argument. */
2459 static struct symtabs_and_lines
2460 map_catch_names (args
, function
)
2464 register char *p
= args
;
2466 struct symtabs_and_lines sals
;
2468 struct sal_chain
*sal_chain
= 0;
2472 error_no_arg ("one or more catch names");
2480 /* Don't swallow conditional part. */
2481 if (p1
[0] == 'i' && p1
[1] == 'f'
2482 && (p1
[2] == ' ' || p1
[2] == '\t'))
2488 while (isalnum (*p1
) || *p1
== '_' || *p1
== '$')
2492 if (*p1
&& *p1
!= ' ' && *p1
!= '\t')
2493 error ("Arguments must be catch names.");
2499 struct sal_chain
*next
2500 = (struct sal_chain
*)alloca (sizeof (struct sal_chain
));
2501 next
->next
= sal_chain
;
2502 next
->sal
= get_catch_sal (p
);
2507 printf_unfiltered ("No catch clause for exception %s.\n", p
);
2512 while (*p
== ' ' || *p
== '\t') p
++;
2517 /* This shares a lot of code with `print_frame_label_vars' from stack.c. */
2519 static struct symtabs_and_lines
2520 get_catch_sals (this_level_only
)
2521 int this_level_only
;
2523 register struct blockvector
*bl
;
2524 register struct block
*block
;
2525 int index
, have_default
= 0;
2526 struct frame_info
*fi
;
2528 struct symtabs_and_lines sals
;
2529 struct sal_chain
*sal_chain
= 0;
2530 char *blocks_searched
;
2532 /* Not sure whether an error message is always the correct response,
2533 but it's better than a core dump. */
2534 if (selected_frame
== NULL
)
2535 error ("No selected frame.");
2536 block
= get_frame_block (selected_frame
);
2537 fi
= get_frame_info (selected_frame
);
2544 error ("No symbol table info available.\n");
2546 bl
= blockvector_for_pc (BLOCK_END (block
) - 4, &index
);
2547 blocks_searched
= (char *) alloca (BLOCKVECTOR_NBLOCKS (bl
) * sizeof (char));
2548 memset (blocks_searched
, 0, BLOCKVECTOR_NBLOCKS (bl
) * sizeof (char));
2552 CORE_ADDR end
= BLOCK_END (block
) - 4;
2555 if (bl
!= blockvector_for_pc (end
, &index
))
2556 error ("blockvector blotch");
2557 if (BLOCKVECTOR_BLOCK (bl
, index
) != block
)
2558 error ("blockvector botch");
2559 last_index
= BLOCKVECTOR_NBLOCKS (bl
);
2562 /* Don't print out blocks that have gone by. */
2563 while (index
< last_index
2564 && BLOCK_END (BLOCKVECTOR_BLOCK (bl
, index
)) < pc
)
2567 while (index
< last_index
2568 && BLOCK_END (BLOCKVECTOR_BLOCK (bl
, index
)) < end
)
2570 if (blocks_searched
[index
] == 0)
2572 struct block
*b
= BLOCKVECTOR_BLOCK (bl
, index
);
2575 register struct symbol
*sym
;
2577 nsyms
= BLOCK_NSYMS (b
);
2579 for (i
= 0; i
< nsyms
; i
++)
2581 sym
= BLOCK_SYM (b
, i
);
2582 if (STREQ (SYMBOL_NAME (sym
), "default"))
2588 if (SYMBOL_CLASS (sym
) == LOC_LABEL
)
2590 struct sal_chain
*next
= (struct sal_chain
*)
2591 alloca (sizeof (struct sal_chain
));
2592 next
->next
= sal_chain
;
2593 next
->sal
= find_pc_line (SYMBOL_VALUE_ADDRESS (sym
), 0);
2597 blocks_searched
[index
] = 1;
2603 if (sal_chain
&& this_level_only
)
2606 /* After handling the function's top-level block, stop.
2607 Don't continue to its superblock, the block of
2608 per-file symbols. */
2609 if (BLOCK_FUNCTION (block
))
2611 block
= BLOCK_SUPERBLOCK (block
);
2616 struct sal_chain
*tmp_chain
;
2618 /* Count the number of entries. */
2619 for (index
= 0, tmp_chain
= sal_chain
; tmp_chain
;
2620 tmp_chain
= tmp_chain
->next
)
2624 sals
.sals
= (struct symtab_and_line
*)
2625 xmalloc (index
* sizeof (struct symtab_and_line
));
2626 for (index
= 0; sal_chain
; sal_chain
= sal_chain
->next
, index
++)
2627 sals
.sals
[index
] = sal_chain
->sal
;
2633 /* Commands to deal with catching exceptions. */
2636 catch_command_1 (arg
, tempflag
, from_tty
)
2641 /* First, translate ARG into something we can deal with in terms
2644 struct symtabs_and_lines sals
;
2645 struct symtab_and_line sal
;
2646 register struct expression
*cond
= 0;
2647 register struct breakpoint
*b
;
2651 sal
.line
= sal
.pc
= sal
.end
= 0;
2654 /* If no arg given, or if first arg is 'if ', all active catch clauses
2655 are breakpointed. */
2657 if (!arg
|| (arg
[0] == 'i' && arg
[1] == 'f'
2658 && (arg
[2] == ' ' || arg
[2] == '\t')))
2660 /* Grab all active catch clauses. */
2661 sals
= get_catch_sals (0);
2665 /* Grab selected catch clauses. */
2666 error ("catch NAME not implemented");
2668 /* This isn't used; I don't know what it was for. */
2669 sals
= map_catch_names (arg
, catch_breakpoint
);
2677 for (i
= 0; i
< sals
.nelts
; i
++)
2679 resolve_sal_pc (&sals
.sals
[i
]);
2683 if (arg
[0] == 'i' && arg
[1] == 'f'
2684 && (arg
[2] == ' ' || arg
[2] == '\t'))
2685 cond
= parse_exp_1 ((arg
+= 2, &arg
),
2686 block_for_pc (sals
.sals
[i
].pc
), 0);
2688 error ("Junk at end of arguments.");
2693 for (i
= 0; i
< sals
.nelts
; i
++)
2698 describe_other_breakpoints (sal
.pc
);
2700 b
= set_raw_breakpoint (sal
);
2701 set_breakpoint_count (breakpoint_count
+ 1);
2702 b
->number
= breakpoint_count
;
2703 b
->type
= bp_breakpoint
;
2705 b
->enable
= enabled
;
2706 b
->disposition
= tempflag
? delete : donttouch
;
2713 printf_unfiltered ("Multiple breakpoints were set.\n");
2714 printf_unfiltered ("Use the \"delete\" command to delete unwanted breakpoints.\n");
2716 free ((PTR
)sals
.sals
);
2720 /* These aren't used; I don't know what they were for. */
2721 /* Disable breakpoints on all catch clauses described in ARGS. */
2723 disable_catch (args
)
2726 /* Map the disable command to catch clauses described in ARGS. */
2729 /* Enable breakpoints on all catch clauses described in ARGS. */
2734 /* Map the disable command to catch clauses described in ARGS. */
2737 /* Delete breakpoints on all catch clauses in the active scope. */
2742 /* Map the delete command to catch clauses described in ARGS. */
2747 catch_command (arg
, from_tty
)
2751 catch_command_1 (arg
, 0, from_tty
);
2755 clear_command (arg
, from_tty
)
2759 register struct breakpoint
*b
, *b1
;
2760 struct symtabs_and_lines sals
;
2761 struct symtab_and_line sal
;
2762 register struct breakpoint
*found
;
2767 sals
= decode_line_spec (arg
, 1);
2771 sals
.sals
= (struct symtab_and_line
*) xmalloc (sizeof (struct symtab_and_line
));
2772 sal
.line
= default_breakpoint_line
;
2773 sal
.symtab
= default_breakpoint_symtab
;
2775 if (sal
.symtab
== 0)
2776 error ("No source file specified.");
2782 for (i
= 0; i
< sals
.nelts
; i
++)
2784 /* If exact pc given, clear bpts at that pc.
2785 But if sal.pc is zero, clear all bpts on specified line. */
2787 found
= (struct breakpoint
*) 0;
2788 while (breakpoint_chain
2790 ? breakpoint_chain
->address
== sal
.pc
2791 : (breakpoint_chain
->source_file
!= NULL
2792 && sal
.symtab
!= NULL
2793 && STREQ (breakpoint_chain
->source_file
,
2794 sal
.symtab
->filename
)
2795 && breakpoint_chain
->line_number
== sal
.line
)))
2797 b1
= breakpoint_chain
;
2798 breakpoint_chain
= b1
->next
;
2805 && b
->next
->type
!= bp_watchpoint
2806 && b
->next
->type
!= bp_hardware_watchpoint
2808 ? b
->next
->address
== sal
.pc
2809 : (b
->next
->source_file
!= NULL
2810 && sal
.symtab
!= NULL
2811 && STREQ (b
->next
->source_file
, sal
.symtab
->filename
)
2812 && b
->next
->line_number
== sal
.line
)))
2823 error ("No breakpoint at %s.", arg
);
2825 error ("No breakpoint at this line.");
2828 if (found
->next
) from_tty
= 1; /* Always report if deleted more than one */
2829 if (from_tty
) printf_unfiltered ("Deleted breakpoint%s ", found
->next
? "s" : "");
2830 breakpoints_changed ();
2833 if (from_tty
) printf_unfiltered ("%d ", found
->number
);
2835 delete_breakpoint (found
);
2838 if (from_tty
) putchar_unfiltered ('\n');
2840 free ((PTR
)sals
.sals
);
2843 /* Delete breakpoint in BS if they are `delete' breakpoints.
2844 This is called after any breakpoint is hit, or after errors. */
2847 breakpoint_auto_delete (bs
)
2850 for (; bs
; bs
= bs
->next
)
2851 if (bs
->breakpoint_at
&& bs
->breakpoint_at
->disposition
== delete
2853 delete_breakpoint (bs
->breakpoint_at
);
2856 /* Delete a breakpoint and clean up all traces of it in the data structures. */
2859 delete_breakpoint (bpt
)
2860 struct breakpoint
*bpt
;
2862 register struct breakpoint
*b
;
2866 remove_breakpoint (bpt
);
2868 if (breakpoint_chain
== bpt
)
2869 breakpoint_chain
= bpt
->next
;
2874 b
->next
= bpt
->next
;
2878 check_duplicates (bpt
->address
);
2879 /* If this breakpoint was inserted, and there is another breakpoint
2880 at the same address, we need to insert the other breakpoint. */
2882 && bpt
->type
!= bp_hardware_watchpoint
)
2885 if (b
->address
== bpt
->address
2887 && b
->enable
!= disabled
)
2890 val
= target_insert_breakpoint (b
->address
, b
->shadow_contents
);
2893 target_terminal_ours_for_output ();
2894 fprintf_unfiltered (gdb_stderr
, "Cannot insert breakpoint %d:\n", b
->number
);
2895 memory_error (val
, b
->address
); /* which bombs us out */
2902 free_command_lines (&bpt
->commands
);
2905 if (bpt
->cond_string
!= NULL
)
2906 free (bpt
->cond_string
);
2907 if (bpt
->addr_string
!= NULL
)
2908 free (bpt
->addr_string
);
2909 if (bpt
->exp_string
!= NULL
)
2910 free (bpt
->exp_string
);
2911 if (bpt
->source_file
!= NULL
)
2912 free (bpt
->source_file
);
2914 breakpoints_changed ();
2916 /* Be sure no bpstat's are pointing at it after it's been freed. */
2917 /* FIXME, how can we find all bpstat's?
2918 We just check stop_bpstat for now. */
2919 for (bs
= stop_bpstat
; bs
; bs
= bs
->next
)
2920 if (bs
->breakpoint_at
== bpt
)
2921 bs
->breakpoint_at
= NULL
;
2926 delete_command (arg
, from_tty
)
2933 /* Ask user only if there are some breakpoints to delete. */
2935 || (breakpoint_chain
&& query ("Delete all breakpoints? ", 0, 0)))
2937 /* No arg; clear all breakpoints. */
2938 while (breakpoint_chain
)
2939 delete_breakpoint (breakpoint_chain
);
2943 map_breakpoint_numbers (arg
, delete_breakpoint
);
2946 /* Reset a breakpoint given it's struct breakpoint * BINT.
2947 The value we return ends up being the return value from catch_errors.
2948 Unused in this case. */
2951 breakpoint_re_set_one (bint
)
2954 struct breakpoint
*b
= (struct breakpoint
*)bint
; /* get past catch_errs */
2956 struct symtabs_and_lines sals
;
2958 enum enable save_enable
;
2963 if (b
->addr_string
== NULL
)
2965 /* Anything without a string can't be re-set. */
2966 delete_breakpoint (b
);
2969 /* In case we have a problem, disable this breakpoint. We'll restore
2970 its status if we succeed. */
2971 save_enable
= b
->enable
;
2972 b
->enable
= disabled
;
2975 sals
= decode_line_1 (&s
, 1, (struct symtab
*)NULL
, 0, (char ***)NULL
);
2976 for (i
= 0; i
< sals
.nelts
; i
++)
2978 resolve_sal_pc (&sals
.sals
[i
]);
2980 /* Reparse conditions, they might contain references to the
2982 if (b
->cond_string
!= NULL
)
2986 free ((PTR
)b
->cond
);
2987 b
->cond
= parse_exp_1 (&s
, block_for_pc (sals
.sals
[i
].pc
), 0);
2990 /* We need to re-set the breakpoint if the address changes...*/
2991 if (b
->address
!= sals
.sals
[i
].pc
2992 /* ...or new and old breakpoints both have source files, and
2993 the source file name or the line number changes... */
2994 || (b
->source_file
!= NULL
2995 && sals
.sals
[i
].symtab
!= NULL
2996 && (!STREQ (b
->source_file
, sals
.sals
[i
].symtab
->filename
)
2997 || b
->line_number
!= sals
.sals
[i
].line
)
2999 /* ...or we switch between having a source file and not having
3001 || ((b
->source_file
== NULL
) != (sals
.sals
[i
].symtab
== NULL
))
3004 if (b
->source_file
!= NULL
)
3005 free (b
->source_file
);
3006 if (sals
.sals
[i
].symtab
== NULL
)
3007 b
->source_file
= NULL
;
3010 savestring (sals
.sals
[i
].symtab
->filename
,
3011 strlen (sals
.sals
[i
].symtab
->filename
));
3012 b
->line_number
= sals
.sals
[i
].line
;
3013 b
->address
= sals
.sals
[i
].pc
;
3015 check_duplicates (b
->address
);
3019 /* Might be better to do this just once per breakpoint_re_set,
3020 rather than once for every breakpoint. */
3021 breakpoints_changed ();
3023 b
->enable
= save_enable
; /* Restore it, this worked. */
3025 free ((PTR
)sals
.sals
);
3029 case bp_hardware_watchpoint
:
3030 innermost_block
= NULL
;
3031 /* The issue arises of what context to evaluate this in. The same
3032 one as when it was set, but what does that mean when symbols have
3033 been re-read? We could save the filename and functionname, but
3034 if the context is more local than that, the best we could do would
3035 be something like how many levels deep and which index at that
3036 particular level, but that's going to be less stable than filenames
3037 or functionnames. */
3038 /* So for now, just use a global context. */
3039 b
->exp
= parse_expression (b
->exp_string
);
3040 b
->exp_valid_block
= innermost_block
;
3041 b
->val
= evaluate_expression (b
->exp
);
3042 release_value (b
->val
);
3043 if (VALUE_LAZY (b
->val
))
3044 value_fetch_lazy (b
->val
);
3046 if (b
->cond_string
!= NULL
)
3049 b
->cond
= parse_exp_1 (&s
, (struct block
*)0, 0);
3051 if (b
->enable
== enabled
)
3056 printf_filtered ("Deleting unknown breakpoint type %d\n", b
->type
);
3061 case bp_longjmp_resume
:
3062 case bp_watchpoint_scope
:
3064 delete_breakpoint (b
);
3071 /* Re-set all breakpoints after symbols have been re-loaded. */
3073 breakpoint_re_set ()
3075 struct breakpoint
*b
, *temp
;
3076 static char message1
[] = "Error in re-setting breakpoint %d:\n";
3077 char message
[sizeof (message1
) + 30 /* slop */];
3079 ALL_BREAKPOINTS_SAFE (b
, temp
)
3081 sprintf (message
, message1
, b
->number
); /* Format possible error msg */
3082 catch_errors (breakpoint_re_set_one
, (char *) b
, message
,
3086 create_longjmp_breakpoint("longjmp");
3087 create_longjmp_breakpoint("_longjmp");
3088 create_longjmp_breakpoint("siglongjmp");
3089 create_longjmp_breakpoint(NULL
);
3092 /* Took this out (temporaliy at least), since it produces an extra
3093 blank line at startup. This messes up the gdbtests. -PB */
3094 /* Blank line to finish off all those mention() messages we just printed. */
3095 printf_filtered ("\n");
3099 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
3100 If from_tty is nonzero, it prints a message to that effect,
3101 which ends with a period (no newline). */
3104 set_ignore_count (bptnum
, count
, from_tty
)
3105 int bptnum
, count
, from_tty
;
3107 register struct breakpoint
*b
;
3113 if (b
->number
== bptnum
)
3115 b
->ignore_count
= count
;
3118 else if (count
== 0)
3119 printf_filtered ("Will stop next time breakpoint %d is reached.",
3121 else if (count
== 1)
3122 printf_filtered ("Will ignore next crossing of breakpoint %d.",
3125 printf_filtered ("Will ignore next %d crossings of breakpoint %d.",
3127 breakpoints_changed ();
3131 error ("No breakpoint number %d.", bptnum
);
3134 /* Clear the ignore counts of all breakpoints. */
3136 breakpoint_clear_ignore_counts ()
3138 struct breakpoint
*b
;
3141 b
->ignore_count
= 0;
3144 /* Command to set ignore-count of breakpoint N to COUNT. */
3147 ignore_command (args
, from_tty
)
3155 error_no_arg ("a breakpoint number");
3157 num
= get_number (&p
);
3160 error ("Second argument (specified ignore-count) is missing.");
3162 set_ignore_count (num
,
3163 longest_to_int (value_as_long (parse_and_eval (p
))),
3165 printf_filtered ("\n");
3166 breakpoints_changed ();
3169 /* Call FUNCTION on each of the breakpoints
3170 whose numbers are given in ARGS. */
3173 map_breakpoint_numbers (args
, function
)
3175 void (*function
) PARAMS ((struct breakpoint
*));
3177 register char *p
= args
;
3180 register struct breakpoint
*b
;
3183 error_no_arg ("one or more breakpoint numbers");
3189 num
= get_number (&p1
);
3192 if (b
->number
== num
)
3194 struct breakpoint
*related_breakpoint
= b
->related_breakpoint
;
3196 if (related_breakpoint
)
3197 function (related_breakpoint
);
3200 printf_unfiltered ("No breakpoint number %d.\n", num
);
3207 enable_breakpoint (bpt
)
3208 struct breakpoint
*bpt
;
3210 FRAME save_selected_frame
= NULL
;
3211 int save_selected_frame_level
= -1;
3213 bpt
->enable
= enabled
;
3215 breakpoints_changed ();
3217 check_duplicates (bpt
->address
);
3218 if (bpt
->type
== bp_watchpoint
|| bpt
->type
== bp_hardware_watchpoint
)
3220 if (bpt
->exp_valid_block
!= NULL
)
3222 FRAME fr
= find_frame_addr_in_frame_chain (bpt
->watchpoint_frame
);
3226 Cannot enable watchpoint %d because the block in which its expression\n\
3227 is valid is not currently in scope.\n", bpt
->number
);
3228 bpt
->enable
= disabled
;
3232 save_selected_frame
= selected_frame
;
3233 save_selected_frame_level
= selected_frame_level
;
3234 select_frame (fr
, -1);
3237 value_free (bpt
->val
);
3239 bpt
->val
= evaluate_expression (bpt
->exp
);
3240 release_value (bpt
->val
);
3241 if (VALUE_LAZY (bpt
->val
))
3242 value_fetch_lazy (bpt
->val
);
3244 if (save_selected_frame_level
>= 0)
3245 select_frame (save_selected_frame
, save_selected_frame_level
);
3251 enable_command (args
, from_tty
)
3255 struct breakpoint
*bpt
;
3257 ALL_BREAKPOINTS (bpt
)
3262 case bp_hardware_watchpoint
:
3263 enable_breakpoint (bpt
);
3268 map_breakpoint_numbers (args
, enable_breakpoint
);
3272 disable_breakpoint (bpt
)
3273 struct breakpoint
*bpt
;
3275 /* Never disable a watchpoint scope breakpoint; we want to
3276 hit them when we leave scope so we can delete both the
3277 watchpoint and its scope breakpoint at that time. */
3278 if (bpt
->type
== bp_watchpoint_scope
)
3281 bpt
->enable
= disabled
;
3283 breakpoints_changed ();
3285 check_duplicates (bpt
->address
);
3290 disable_command (args
, from_tty
)
3294 register struct breakpoint
*bpt
;
3296 ALL_BREAKPOINTS (bpt
)
3301 case bp_hardware_watchpoint
:
3302 disable_breakpoint (bpt
);
3307 map_breakpoint_numbers (args
, disable_breakpoint
);
3311 enable_once_breakpoint (bpt
)
3312 struct breakpoint
*bpt
;
3314 bpt
->enable
= enabled
;
3315 bpt
->disposition
= disable
;
3317 check_duplicates (bpt
->address
);
3318 breakpoints_changed ();
3323 enable_once_command (args
, from_tty
)
3327 map_breakpoint_numbers (args
, enable_once_breakpoint
);
3331 enable_delete_breakpoint (bpt
)
3332 struct breakpoint
*bpt
;
3334 bpt
->enable
= enabled
;
3335 bpt
->disposition
= delete;
3337 check_duplicates (bpt
->address
);
3338 breakpoints_changed ();
3343 enable_delete_command (args
, from_tty
)
3347 map_breakpoint_numbers (args
, enable_delete_breakpoint
);
3351 * Use default_breakpoint_'s, or nothing if they aren't valid.
3353 struct symtabs_and_lines
3354 decode_line_spec_1 (string
, funfirstline
)
3358 struct symtabs_and_lines sals
;
3360 error ("Empty line specification.");
3361 if (default_breakpoint_valid
)
3362 sals
= decode_line_1 (&string
, funfirstline
,
3363 default_breakpoint_symtab
, default_breakpoint_line
,
3366 sals
= decode_line_1 (&string
, funfirstline
,
3367 (struct symtab
*)NULL
, 0, (char ***)NULL
);
3369 error ("Junk at end of line specification: %s", string
);
3374 _initialize_breakpoint ()
3376 breakpoint_chain
= 0;
3377 /* Don't bother to call set_breakpoint_count. $bpnum isn't useful
3378 before a breakpoint is set. */
3379 breakpoint_count
= 0;
3381 add_com ("ignore", class_breakpoint
, ignore_command
,
3382 "Set ignore-count of breakpoint number N to COUNT.");
3384 add_com ("commands", class_breakpoint
, commands_command
,
3385 "Set commands to be executed when a breakpoint is hit.\n\
3386 Give breakpoint number as argument after \"commands\".\n\
3387 With no argument, the targeted breakpoint is the last one set.\n\
3388 The commands themselves follow starting on the next line.\n\
3389 Type a line containing \"end\" to indicate the end of them.\n\
3390 Give \"silent\" as the first line to make the breakpoint silent;\n\
3391 then no output is printed when it is hit, except what the commands print.");
3393 add_com ("condition", class_breakpoint
, condition_command
,
3394 "Specify breakpoint number N to break only if COND is true.\n\
3395 N is an integer; COND is an expression to be evaluated whenever\n\
3396 breakpoint N is reached. ");
3398 add_com ("tbreak", class_breakpoint
, tbreak_command
,
3399 "Set a temporary breakpoint. Args like \"break\" command.\n\
3400 Like \"break\" except the breakpoint is only temporary,\n\
3401 so it will be deleted when hit. Equivalent to \"break\" followed\n\
3402 by using \"enable delete\" on the breakpoint number.");
3404 add_prefix_cmd ("enable", class_breakpoint
, enable_command
,
3405 "Enable some breakpoints.\n\
3406 Give breakpoint numbers (separated by spaces) as arguments.\n\
3407 With no subcommand, breakpoints are enabled until you command otherwise.\n\
3408 This is used to cancel the effect of the \"disable\" command.\n\
3409 With a subcommand you can enable temporarily.",
3410 &enablelist
, "enable ", 1, &cmdlist
);
3412 add_abbrev_prefix_cmd ("breakpoints", class_breakpoint
, enable_command
,
3413 "Enable some breakpoints.\n\
3414 Give breakpoint numbers (separated by spaces) as arguments.\n\
3415 This is used to cancel the effect of the \"disable\" command.\n\
3416 May be abbreviated to simply \"enable\".\n",
3417 &enablebreaklist
, "enable breakpoints ", 1, &enablelist
);
3419 add_cmd ("once", no_class
, enable_once_command
,
3420 "Enable breakpoints for one hit. Give breakpoint numbers.\n\
3421 If a breakpoint is hit while enabled in this fashion, it becomes disabled.",
3424 add_cmd ("delete", no_class
, enable_delete_command
,
3425 "Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
3426 If a breakpoint is hit while enabled in this fashion, it is deleted.",
3429 add_cmd ("delete", no_class
, enable_delete_command
,
3430 "Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
3431 If a breakpoint is hit while enabled in this fashion, it is deleted.",
3434 add_cmd ("once", no_class
, enable_once_command
,
3435 "Enable breakpoints for one hit. Give breakpoint numbers.\n\
3436 If a breakpoint is hit while enabled in this fashion, it becomes disabled.",
3439 add_prefix_cmd ("disable", class_breakpoint
, disable_command
,
3440 "Disable some breakpoints.\n\
3441 Arguments are breakpoint numbers with spaces in between.\n\
3442 To disable all breakpoints, give no argument.\n\
3443 A disabled breakpoint is not forgotten, but has no effect until reenabled.",
3444 &disablelist
, "disable ", 1, &cmdlist
);
3445 add_com_alias ("dis", "disable", class_breakpoint
, 1);
3446 add_com_alias ("disa", "disable", class_breakpoint
, 1);
3448 add_cmd ("breakpoints", class_alias
, disable_command
,
3449 "Disable some breakpoints.\n\
3450 Arguments are breakpoint numbers with spaces in between.\n\
3451 To disable all breakpoints, give no argument.\n\
3452 A disabled breakpoint is not forgotten, but has no effect until reenabled.\n\
3453 This command may be abbreviated \"disable\".",
3456 add_prefix_cmd ("delete", class_breakpoint
, delete_command
,
3457 "Delete some breakpoints or auto-display expressions.\n\
3458 Arguments are breakpoint numbers with spaces in between.\n\
3459 To delete all breakpoints, give no argument.\n\
3461 Also a prefix command for deletion of other GDB objects.\n\
3462 The \"unset\" command is also an alias for \"delete\".",
3463 &deletelist
, "delete ", 1, &cmdlist
);
3464 add_com_alias ("d", "delete", class_breakpoint
, 1);
3466 add_cmd ("breakpoints", class_alias
, delete_command
,
3467 "Delete some breakpoints or auto-display expressions.\n\
3468 Arguments are breakpoint numbers with spaces in between.\n\
3469 To delete all breakpoints, give no argument.\n\
3470 This command may be abbreviated \"delete\".",
3473 add_com ("clear", class_breakpoint
, clear_command
,
3474 "Clear breakpoint at specified line or function.\n\
3475 Argument may be line number, function name, or \"*\" and an address.\n\
3476 If line number is specified, all breakpoints in that line are cleared.\n\
3477 If function is specified, breakpoints at beginning of function are cleared.\n\
3478 If an address is specified, breakpoints at that address are cleared.\n\n\
3479 With no argument, clears all breakpoints in the line that the selected frame\n\
3482 See also the \"delete\" command which clears breakpoints by number.");
3484 add_com ("break", class_breakpoint
, break_command
,
3485 "Set breakpoint at specified line or function.\n\
3486 Argument may be line number, function name, or \"*\" and an address.\n\
3487 If line number is specified, break at start of code for that line.\n\
3488 If function is specified, break at start of code for that function.\n\
3489 If an address is specified, break at that exact address.\n\
3490 With no arg, uses current execution address of selected stack frame.\n\
3491 This is useful for breaking on return to a stack frame.\n\
3493 Multiple breakpoints at one place are permitted, and useful if conditional.\n\
3495 Do \"help breakpoints\" for info on other commands dealing with breakpoints.");
3496 add_com_alias ("b", "break", class_run
, 1);
3497 add_com_alias ("br", "break", class_run
, 1);
3498 add_com_alias ("bre", "break", class_run
, 1);
3499 add_com_alias ("brea", "break", class_run
, 1);
3501 add_info ("breakpoints", breakpoints_info
,
3502 "Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
3503 The \"Type\" column indicates one of:\n\
3504 \tbreakpoint - normal breakpoint\n\
3505 \twatchpoint - watchpoint\n\
3506 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
3507 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
3508 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
3509 address and file/line number respectively.\n\n\
3510 Convenience variable \"$_\" and default examine address for \"x\"\n\
3511 are set to the address of the last breakpoint listed.\n\n\
3512 Convenience variable \"$bpnum\" contains the number of the last\n\
3515 #if MAINTENANCE_CMDS
3517 add_cmd ("breakpoints", class_maintenance
, maintenance_info_breakpoints
,
3518 "Status of all breakpoints, or breakpoint number NUMBER.\n\
3519 The \"Type\" column indicates one of:\n\
3520 \tbreakpoint - normal breakpoint\n\
3521 \twatchpoint - watchpoint\n\
3522 \tlongjmp - internal breakpoint used to step through longjmp()\n\
3523 \tlongjmp resume - internal breakpoint at the target of longjmp()\n\
3524 \tuntil - internal breakpoint used by the \"until\" command\n\
3525 \tfinish - internal breakpoint used by the \"finish\" command\n\
3526 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
3527 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
3528 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
3529 address and file/line number respectively.\n\n\
3530 Convenience variable \"$_\" and default examine address for \"x\"\n\
3531 are set to the address of the last breakpoint listed.\n\n\
3532 Convenience variable \"$bpnum\" contains the number of the last\n\
3534 &maintenanceinfolist
);
3536 #endif /* MAINTENANCE_CMDS */
3538 add_com ("catch", class_breakpoint
, catch_command
,
3539 "Set breakpoints to catch exceptions that are raised.\n\
3540 Argument may be a single exception to catch, multiple exceptions\n\
3541 to catch, or the default exception \"default\". If no arguments\n\
3542 are given, breakpoints are set at all exception handlers catch clauses\n\
3543 within the current scope.\n\
3545 A condition specified for the catch applies to all breakpoints set\n\
3546 with this command\n\
3548 Do \"help breakpoints\" for info on other commands dealing with breakpoints.");
3550 add_com ("watch", class_breakpoint
, watch_command
,
3551 "Set a watchpoint for an expression.\n\
3552 A watchpoint stops execution of your program whenever the value of\n\
3553 an expression changes.");
3555 add_info ("watchpoints", breakpoints_info
,
3556 "Synonym for ``info breakpoints''.");
3559 /* OK, when we call objfile_relocate, we need to relocate breakpoints
3560 too. breakpoint_re_set is not a good choice--for example, if
3561 addr_string contains just a line number without a file name the
3562 breakpoint might get set in a different file. In general, there is
3563 no need to go all the way back to the user's string (though this might
3564 work if some effort were made to canonicalize it), since symtabs and
3565 everything except addresses are still valid.
3567 Probably the best way to solve this is to have each breakpoint save
3568 the objfile and the section number that was used to set it (if set
3569 by "*addr", probably it is best to use find_pc_line to get a symtab
3570 and use the objfile and block_line_section for that symtab). Then
3571 objfile_relocate can call fixup_breakpoints with the objfile and
3572 the new_offsets, and it can relocate only the appropriate breakpoints. */
3574 #ifdef IBM6000_TARGET
3575 /* But for now, just kludge it based on the concept that before an
3576 objfile is relocated the breakpoint is below 0x10000000, and afterwards
3577 it is higher, so that way we only relocate each breakpoint once. */
3580 fixup_breakpoints (low
, high
, delta
)
3585 struct breakpoint
*b
;
3589 if (b
->address
>= low
&& b
->address
<= high
)
3590 b
->address
+= delta
;