1 /* Everything about breakpoints, for GDB.
2 Copyright 1986, 1987, 1989, 1990, 1991, 1992 Free Software Foundation, Inc.
4 This file is part of GDB.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
24 #include "breakpoint.h"
26 #include "expression.h"
38 /* local function prototypes */
41 catch_command_1
PARAMS ((char *, int, int));
44 enable_delete_command
PARAMS ((char *, int));
47 enable_delete_breakpoint
PARAMS ((struct breakpoint
*));
50 enable_once_command
PARAMS ((char *, int));
53 enable_once_breakpoint
PARAMS ((struct breakpoint
*));
56 disable_command
PARAMS ((char *, int));
59 disable_breakpoint
PARAMS ((struct breakpoint
*));
62 enable_command
PARAMS ((char *, int));
65 enable_breakpoint
PARAMS ((struct breakpoint
*));
68 map_breakpoint_numbers
PARAMS ((char *, void (*)(struct breakpoint
*)));
71 ignore_command
PARAMS ((char *, int));
74 breakpoint_re_set_one
PARAMS ((char *));
77 delete_command
PARAMS ((char *, int));
80 clear_command
PARAMS ((char *, int));
83 catch_command
PARAMS ((char *, int));
85 static struct symtabs_and_lines
86 get_catch_sals
PARAMS ((int));
89 watch_command
PARAMS ((char *, int));
92 tbreak_command
PARAMS ((char *, int));
95 break_command_1
PARAMS ((char *, int, int));
98 mention
PARAMS ((struct breakpoint
*));
100 static struct breakpoint
*
101 set_raw_breakpoint
PARAMS ((struct symtab_and_line
));
104 check_duplicates
PARAMS ((CORE_ADDR
));
107 describe_other_breakpoints
PARAMS ((CORE_ADDR
));
110 breakpoints_info
PARAMS ((char *, int));
113 breakpoint_1
PARAMS ((int, int));
116 bpstat_alloc
PARAMS ((struct breakpoint
*, bpstat
));
119 breakpoint_cond_eval
PARAMS ((char *));
122 cleanup_executing_breakpoints
PARAMS ((int));
125 commands_command
PARAMS ((char *, int));
128 condition_command
PARAMS ((char *, int));
131 get_number
PARAMS ((char **));
134 set_breakpoint_count
PARAMS ((int));
137 extern int addressprint
; /* Print machine addresses? */
138 extern int demangle
; /* Print de-mangled symbol names? */
140 /* Are we executing breakpoint commands? */
141 static int executing_breakpoint_commands
;
143 /* Walk the following statement or block through all breakpoints.
144 ALL_BREAKPOINTS_SAFE does so even if the statment deletes the current
147 #define ALL_BREAKPOINTS(b) for (b = breakpoint_chain; b; b = b->next)
149 #define ALL_BREAKPOINTS_SAFE(b,tmp) \
150 for (b = breakpoint_chain; \
151 b? (tmp=b->next, 1): 0; \
154 /* Chain of all breakpoints defined. */
156 struct breakpoint
*breakpoint_chain
;
158 /* Number of last breakpoint made. */
160 static int breakpoint_count
;
162 /* Set breakpoint count to NUM. */
164 set_breakpoint_count (num
)
167 breakpoint_count
= num
;
168 set_internalvar (lookup_internalvar ("bpnum"),
169 value_from_longest (builtin_type_int
, (LONGEST
) num
));
172 /* Default address, symtab and line to put a breakpoint at
173 for "break" command with no arg.
174 if default_breakpoint_valid is zero, the other three are
175 not valid, and "break" with no arg is an error.
177 This set by print_stack_frame, which calls set_default_breakpoint. */
179 int default_breakpoint_valid
;
180 CORE_ADDR default_breakpoint_address
;
181 struct symtab
*default_breakpoint_symtab
;
182 int default_breakpoint_line
;
184 /* Flag indicating extra verbosity for xgdb. */
185 extern int xgdb_verbose
;
187 /* *PP is a string denoting a breakpoint. Get the number of the breakpoint.
188 Advance *PP after the string and any trailing whitespace.
190 Currently the string can either be a number or "$" followed by the name
191 of a convenience variable. Making it an expression wouldn't work well
192 for map_breakpoint_numbers (e.g. "4 + 5 + 6"). */
201 /* Empty line means refer to the last breakpoint. */
202 return breakpoint_count
;
205 /* Make a copy of the name, so we can null-terminate it
206 to pass to lookup_internalvar(). */
211 while (isalnum (*p
) || *p
== '_')
213 varname
= (char *) alloca (p
- start
+ 1);
214 strncpy (varname
, start
, p
- start
);
215 varname
[p
- start
] = '\0';
216 val
= value_of_internalvar (lookup_internalvar (varname
));
217 if (TYPE_CODE (VALUE_TYPE (val
)) != TYPE_CODE_INT
)
219 "Convenience variables used to specify breakpoints must have integer values."
221 retval
= (int) value_as_long (val
);
227 while (*p
>= '0' && *p
<= '9')
230 /* There is no number here. (e.g. "cond a == b"). */
231 error_no_arg ("breakpoint number");
234 if (!(isspace (*p
) || *p
== '\0'))
235 error ("breakpoint number expected");
242 /* condition N EXP -- set break condition of breakpoint N to EXP. */
245 condition_command (arg
, from_tty
)
249 register struct breakpoint
*b
;
254 error_no_arg ("breakpoint number");
257 bnum
= get_number (&p
);
260 if (b
->number
== bnum
)
267 if (b
->cond_string
!= NULL
)
268 free ((PTR
)b
->cond_string
);
273 b
->cond_string
= NULL
;
275 printf_filtered ("Breakpoint %d now unconditional.\n", bnum
);
280 /* I don't know if it matters whether this is the string the user
281 typed in or the decompiled expression. */
282 b
->cond_string
= savestring (arg
, strlen (arg
));
283 b
->cond
= parse_exp_1 (&arg
, block_for_pc (b
->address
), 0);
285 error ("Junk at end of expression");
290 error ("No breakpoint number %d.", bnum
);
295 commands_command (arg
, from_tty
)
299 register struct breakpoint
*b
;
302 struct command_line
*l
;
304 /* If we allowed this, we would have problems with when to
305 free the storage, if we change the commands currently
308 if (executing_breakpoint_commands
)
309 error ("Can't use the \"commands\" command among a breakpoint's commands.");
312 bnum
= get_number (&p
);
314 error ("Unexpected extra arguments following breakpoint number.");
317 if (b
->number
== bnum
)
319 if (from_tty
&& input_from_terminal_p ())
320 printf_filtered ("Type commands for when breakpoint %d is hit, one per line.\n\
321 End with a line saying just \"end\".\n", bnum
);
322 l
= read_command_lines ();
323 free_command_lines (&b
->commands
);
327 error ("No breakpoint number %d.", bnum
);
330 extern int memory_breakpoint_size
; /* from mem-break.c */
332 /* Like target_read_memory() but if breakpoints are inserted, return
333 the shadow contents instead of the breakpoints themselves.
335 Read "memory data" from whatever target or inferior we have.
336 Returns zero if successful, errno value if not. EIO is used
337 for address out of bounds. If breakpoints are inserted, returns
338 shadow contents, not the breakpoints themselves. From breakpoint.c. */
341 read_memory_nobpt (memaddr
, myaddr
, len
)
347 struct breakpoint
*b
;
349 if (memory_breakpoint_size
< 0)
350 /* No breakpoints on this machine. */
351 return target_read_memory (memaddr
, myaddr
, len
);
355 if (b
->type
== bp_watchpoint
|| !b
->inserted
)
357 else if (b
->address
+ memory_breakpoint_size
<= memaddr
)
358 /* The breakpoint is entirely before the chunk of memory
361 else if (b
->address
>= memaddr
+ len
)
362 /* The breakpoint is entirely after the chunk of memory we
367 /* Copy the breakpoint from the shadow contents, and recurse
368 for the things before and after. */
370 /* Addresses and length of the part of the breakpoint that
372 CORE_ADDR membpt
= b
->address
;
373 unsigned int bptlen
= memory_breakpoint_size
;
374 /* Offset within shadow_contents. */
377 if (membpt
< memaddr
)
379 /* Only copy the second part of the breakpoint. */
380 bptlen
-= memaddr
- membpt
;
381 bptoffset
= memaddr
- membpt
;
385 if (membpt
+ bptlen
> memaddr
+ len
)
387 /* Only copy the first part of the breakpoint. */
388 bptlen
-= (membpt
+ bptlen
) - (memaddr
+ len
);
391 memcpy (myaddr
+ membpt
- memaddr
,
392 b
->shadow_contents
+ bptoffset
, bptlen
);
394 if (membpt
> memaddr
)
396 /* Copy the section of memory before the breakpoint. */
397 status
= read_memory_nobpt (memaddr
, myaddr
, membpt
- memaddr
);
402 if (membpt
+ bptlen
< memaddr
+ len
)
404 /* Copy the section of memory after the breakpoint. */
405 status
= read_memory_nobpt
407 myaddr
+ membpt
+ bptlen
- memaddr
,
408 memaddr
+ len
- (membpt
+ bptlen
));
415 /* Nothing overlaps. Just call read_memory_noerr. */
416 return target_read_memory (memaddr
, myaddr
, len
);
419 /* insert_breakpoints is used when starting or continuing the program.
420 remove_breakpoints is used when the program stops.
421 Both return zero if successful,
422 or an `errno' value if could not write the inferior. */
425 insert_breakpoints ()
427 register struct breakpoint
*b
;
429 int disabled_breaks
= 0;
432 if (b
->type
!= bp_watchpoint
433 && b
->enable
!= disabled
437 val
= target_insert_breakpoint(b
->address
, b
->shadow_contents
);
440 /* Can't set the breakpoint. */
441 #if defined (DISABLE_UNSETTABLE_BREAK)
442 if (DISABLE_UNSETTABLE_BREAK (b
->address
))
445 b
->enable
= disabled
;
446 if (!disabled_breaks
)
449 "Cannot insert breakpoint %d:\n", b
->number
);
450 printf_filtered ("Disabling shared library breakpoints:\n");
453 printf_filtered ("%d ", b
->number
);
458 fprintf (stderr
, "Cannot insert breakpoint %d:\n", b
->number
);
459 #ifdef ONE_PROCESS_WRITETEXT
461 "The same program may be running in another process.\n");
463 memory_error (val
, b
->address
); /* which bombs us out */
470 printf_filtered ("\n");
475 remove_breakpoints ()
477 register struct breakpoint
*b
;
480 #ifdef BREAKPOINT_DEBUG
481 printf ("Removing breakpoints.\n");
482 #endif /* BREAKPOINT_DEBUG */
485 if (b
->type
!= bp_watchpoint
&& b
->inserted
)
487 val
= target_remove_breakpoint(b
->address
, b
->shadow_contents
);
491 #ifdef BREAKPOINT_DEBUG
492 printf ("Removed breakpoint at %s",
493 local_hex_string(b
->address
));
494 printf (", shadow %s",
495 local_hex_string(b
->shadow_contents
[0]));
497 local_hex_string(b
->shadow_contents
[1]));
498 #endif /* BREAKPOINT_DEBUG */
504 /* Clear the "inserted" flag in all breakpoints.
505 This is done when the inferior is loaded. */
508 mark_breakpoints_out ()
510 register struct breakpoint
*b
;
516 /* breakpoint_here_p (PC) returns 1 if an enabled breakpoint exists at PC.
517 When continuing from a location with a breakpoint,
518 we actually single step once before calling insert_breakpoints. */
521 breakpoint_here_p (pc
)
524 register struct breakpoint
*b
;
527 if (b
->enable
!= disabled
&& b
->address
== pc
)
533 /* bpstat stuff. External routines' interfaces are documented
536 /* Clear a bpstat so that it says we are not at any breakpoint.
537 Also free any storage that is part of a bpstat. */
552 if (p
->old_val
!= NULL
)
553 value_free (p
->old_val
);
560 /* Return a copy of a bpstat. Like "bs1 = bs2" but all storage that
561 is part of the bpstat is copied as well. */
574 for (; bs
!= NULL
; bs
= bs
->next
)
576 tmp
= (bpstat
) xmalloc (sizeof (*tmp
));
577 memcpy (tmp
, bs
, sizeof (*tmp
));
579 /* This is the first thing in the chain. */
589 /* Find the bpstat associated with this breakpoint */
592 bpstat_find_breakpoint(bsp
, breakpoint
)
594 struct breakpoint
*breakpoint
;
596 if (bsp
== NULL
) return NULL
;
598 for (;bsp
!= NULL
; bsp
= bsp
->next
) {
599 if (bsp
->breakpoint_at
== breakpoint
) return bsp
;
604 /* Return the breakpoint number of the first breakpoint we are stopped
605 at. *BSP upon return is a bpstat which points to the remaining
606 breakpoints stopped at (but which is not guaranteed to be good for
607 anything but further calls to bpstat_num).
608 Return 0 if passed a bpstat which does not indicate any breakpoints. */
614 struct breakpoint
*b
;
617 return 0; /* No more breakpoint values */
620 b
= (*bsp
)->breakpoint_at
;
623 return -1; /* breakpoint that's been deleted since */
625 return b
->number
; /* We have its number */
629 /* Modify BS so that the actions will not be performed. */
632 bpstat_clear_actions (bs
)
635 for (; bs
!= NULL
; bs
= bs
->next
)
638 if (bs
->old_val
!= NULL
)
640 value_free (bs
->old_val
);
646 /* Stub for cleaning up our state if we error-out of a breakpoint command */
649 cleanup_executing_breakpoints (ignore
)
652 executing_breakpoint_commands
= 0;
655 /* Execute all the commands associated with all the breakpoints at this
656 location. Any of these commands could cause the process to proceed
657 beyond this point, etc. We look out for such changes by checking
658 the global "breakpoint_proceeded" after each command. */
661 bpstat_do_actions (bsp
)
665 struct cleanup
*old_chain
;
667 executing_breakpoint_commands
= 1;
668 old_chain
= make_cleanup (cleanup_executing_breakpoints
, 0);
673 breakpoint_proceeded
= 0;
674 for (; bs
!= NULL
; bs
= bs
->next
)
678 char *line
= bs
->commands
->line
;
679 bs
->commands
= bs
->commands
->next
;
680 execute_command (line
, 0);
681 /* If the inferior is proceeded by the command, bomb out now.
682 The bpstat chain has been blown away by wait_for_inferior.
683 But since execution has stopped again, there is a new bpstat
684 to look at, so start over. */
685 if (breakpoint_proceeded
)
690 executing_breakpoint_commands
= 0;
691 discard_cleanups (old_chain
);
694 /* This is the normal print_it function for a bpstat. In the future,
695 much of this logic could (should?) be moved to bpstat_stop_status,
696 by having it set different print_it functions. */
702 /* bs->breakpoint_at can be NULL if it was a momentary breakpoint
703 which has since been deleted. */
704 if (bs
->breakpoint_at
== NULL
705 || (bs
->breakpoint_at
->type
!= bp_breakpoint
706 && bs
->breakpoint_at
->type
!= bp_watchpoint
))
709 if (bs
->breakpoint_at
->type
== bp_breakpoint
)
711 /* I think the user probably only wants to see one breakpoint
712 number, not all of them. */
713 printf_filtered ("\nBreakpoint %d, ", bs
->breakpoint_at
->number
);
717 if (bs
->old_val
!= NULL
)
719 printf_filtered ("\nWatchpoint %d, ", bs
->breakpoint_at
->number
);
720 print_expression (bs
->breakpoint_at
->exp
, stdout
);
721 printf_filtered ("\nOld value = ");
722 value_print (bs
->old_val
, stdout
, 0, Val_pretty_default
);
723 printf_filtered ("\nNew value = ");
724 value_print (bs
->breakpoint_at
->val
, stdout
, 0,
726 printf_filtered ("\n");
727 value_free (bs
->old_val
);
731 /* We can't deal with it. Maybe another member of the bpstat chain can. */
735 /* Print a message indicating what happened. Returns nonzero to
736 say that only the source line should be printed after this (zero
737 return means print the frame as well as the source line). */
738 /* Currently we always return zero. */
748 val
= (*bs
->print_it
) (bs
);
752 /* Maybe another breakpoint in the chain caused us to stop.
753 (Currently all watchpoints go on the bpstat whether hit or
754 not. That probably could (should) be changed, provided care is taken
755 with respect to bpstat_explains_signal). */
757 return bpstat_print (bs
->next
);
759 /* We reached the end of the chain without printing anything. */
763 /* Evaluate the expression EXP and return 1 if value is zero.
764 This is used inside a catch_errors to evaluate the breakpoint condition.
765 The argument is a "struct expression *" that has been cast to char * to
766 make it pass through catch_errors. */
769 breakpoint_cond_eval (exp
)
772 return !value_true (evaluate_expression ((struct expression
*)exp
));
775 /* Allocate a new bpstat and chain it to the current one. */
778 bpstat_alloc (b
, cbs
)
779 register struct breakpoint
*b
;
780 bpstat cbs
; /* Current "bs" value */
784 bs
= (bpstat
) xmalloc (sizeof (*bs
));
786 bs
->breakpoint_at
= b
;
787 /* If the condition is false, etc., don't do the commands. */
790 bs
->print_it
= print_it_normal
;
794 /* Return the frame which we can use to evaluate the expression
795 whose valid block is valid_block, or NULL if not in scope.
797 This whole concept is probably not the way to do things (it is incredibly
798 slow being the main reason, not to mention fragile (e.g. the sparc
799 frame pointer being fetched as 0 bug causes it to stop)). Instead,
800 introduce a version of "struct frame" which survives over calls to the
801 inferior, but which is better than FRAME_ADDR in the sense that it lets
802 us evaluate expressions relative to that frame (on some machines, it
803 can just be a FRAME_ADDR). Save one of those instead of (or in addition
804 to) the exp_valid_block, and then use it to evaluate the watchpoint
805 expression, with no need to do all this backtracing every time.
807 Or better yet, what if it just copied the struct frame and its next
808 frame? Off the top of my head, I would think that would work
809 because things like (a29k) rsize and msize, or (sparc) bottom just
810 depend on the frame, and aren't going to be different just because
811 the inferior has done something. Trying to recalculate them
812 strikes me as a lot of work, possibly even impossible. Saving the
813 next frame is needed at least on a29k, where get_saved_register
814 uses fi->next->saved_msp. For figuring out whether that frame is
815 still on the stack, I guess this needs to be machine-specific (e.g.
818 read_fp () INNER_THAN watchpoint_frame->frame
820 would generally work.
822 Of course the scope of the expression could be less than a whole
823 function; perhaps if the innermost frame is the one which the
824 watchpoint is relative to (another machine-specific thing, usually
826 FRAMELESS_FUNCTION_INVOCATION (get_current_frame(), fromleaf)
827 read_fp () == wp_frame->frame
830 ), *then* it could do a
832 contained_in (get_current_block (), wp->exp_valid_block).
837 within_scope (valid_block
)
838 struct block
*valid_block
;
840 FRAME fr
= get_current_frame ();
841 struct frame_info
*fi
= get_frame_info (fr
);
842 CORE_ADDR func_start
;
844 /* If caller_pc_valid is true, we are stepping through
845 a function prologue, which is bounded by callee_func_start
846 (inclusive) and callee_prologue_end (exclusive).
847 caller_pc is the pc of the caller.
849 Yes, this is hairy. */
850 static int caller_pc_valid
= 0;
851 static CORE_ADDR caller_pc
;
852 static CORE_ADDR callee_func_start
;
853 static CORE_ADDR callee_prologue_end
;
855 find_pc_partial_function (fi
->pc
, (PTR
)NULL
, &func_start
);
856 func_start
+= FUNCTION_START_OFFSET
;
857 if (fi
->pc
== func_start
)
859 /* We just called a function. The only other case I
860 can think of where the pc would equal the pc of the
861 start of a function is a frameless function (i.e.
862 no prologue) where we branch back to the start
863 of the function. In that case, SKIP_PROLOGUE won't
864 find one, and we'll clear caller_pc_valid a few lines
867 caller_pc
= SAVED_PC_AFTER_CALL (fr
);
868 callee_func_start
= func_start
;
869 SKIP_PROLOGUE (func_start
);
870 callee_prologue_end
= func_start
;
874 if (fi
->pc
< callee_func_start
875 || fi
->pc
>= callee_prologue_end
)
879 if (contained_in (block_for_pc (caller_pc_valid
886 fr
= get_prev_frame (fr
);
888 /* If any active frame is in the exp_valid_block, then it's
889 OK. Note that this might not be the same invocation of
890 the exp_valid_block that we were watching a little while
891 ago, or the same one as when the watchpoint was set (e.g.
892 we are watching a local variable in a recursive function.
893 When we return from a recursive invocation, then we are
894 suddenly watching a different instance of the variable).
896 At least for now I am going to consider this a feature. */
897 for (; fr
!= NULL
; fr
= get_prev_frame (fr
))
899 fi
= get_frame_info (fr
);
900 if (contained_in (block_for_pc (fi
->pc
),
909 /* Possible return values for watchpoint_check (this can't be an enum
910 because of check_errors). */
911 /* The watchpoint has been disabled. */
912 #define WP_DISABLED 1
913 /* The value has changed. */
914 #define WP_VALUE_CHANGED 2
915 /* The value has not changed. */
916 #define WP_VALUE_NOT_CHANGED 3
918 /* Check watchpoint condition. */
923 bpstat bs
= (bpstat
) p
;
926 int within_current_scope
;
927 if (bs
->breakpoint_at
->exp_valid_block
== NULL
)
928 within_current_scope
= 1;
931 fr
= within_scope (bs
->breakpoint_at
->exp_valid_block
);
932 within_current_scope
= fr
!= NULL
;
933 if (within_current_scope
)
934 /* If we end up stopping, the current frame will get selected
935 in normal_stop. So this call to select_frame won't affect
937 select_frame (fr
, -1);
940 if (within_current_scope
)
942 /* We use value_{,free_to_}mark because it could be a
943 *long* time before we return to the command level and
944 call free_all_values. */
945 /* But couldn't we just call free_all_values instead? */
947 value mark
= value_mark ();
948 value new_val
= evaluate_expression (bs
->breakpoint_at
->exp
);
949 if (!value_equal (bs
->breakpoint_at
->val
, new_val
))
951 release_value (new_val
);
952 value_free_to_mark (mark
);
953 bs
->old_val
= bs
->breakpoint_at
->val
;
954 bs
->breakpoint_at
->val
= new_val
;
955 /* We will stop here */
956 return WP_VALUE_CHANGED
;
960 /* Nothing changed, don't do anything. */
961 value_free_to_mark (mark
);
962 /* We won't stop here */
963 return WP_VALUE_NOT_CHANGED
;
968 /* This seems like the only logical thing to do because
969 if we temporarily ignored the watchpoint, then when
970 we reenter the block in which it is valid it contains
971 garbage (in the case of a function, it may have two
972 garbage values, one before and one after the prologue).
973 So we can't even detect the first assignment to it and
974 watch after that (since the garbage may or may not equal
975 the first value assigned). */
976 bs
->breakpoint_at
->enable
= disabled
;
978 Watchpoint %d disabled because the program has left the block in\n\
979 which its expression is valid.\n", bs
->breakpoint_at
->number
);
984 /* This is used when everything which needs to be printed has
985 already been printed. But we still want to print the frame. */
993 /* This is used when nothing should be printed for this bpstat entry. */
1002 /* Determine whether we stopped at a breakpoint, etc, or whether we
1003 don't understand this stop. Result is a chain of bpstat's such that:
1005 if we don't understand the stop, the result is a null pointer.
1007 if we understand why we stopped, the result is not null, and
1008 the first element of the chain contains summary "stop" and
1009 "print" flags for the whole chain.
1011 Each element of the chain refers to a particular breakpoint or
1012 watchpoint at which we have stopped. (We may have stopped for
1013 several reasons concurrently.)
1015 Each element of the chain has valid next, breakpoint_at,
1016 commands, FIXME??? fields.
1022 bpstat_stop_status (pc
, frame_address
)
1024 FRAME_ADDR frame_address
;
1026 register struct breakpoint
*b
;
1028 #if DECR_PC_AFTER_BREAK != 0 || defined (SHIFT_INST_REGS)
1029 /* True if we've hit a breakpoint (as opposed to a watchpoint). */
1030 int real_breakpoint
= 0;
1032 /* Root of the chain of bpstat's */
1033 struct bpstat root_bs
[1];
1034 /* Pointer to the last thing in the chain currently. */
1035 bpstat bs
= root_bs
;
1037 /* Get the address where the breakpoint would have been. */
1038 bp_addr
= *pc
- DECR_PC_AFTER_BREAK
;
1042 if (b
->enable
== disabled
)
1045 if (b
->type
!= bp_watchpoint
&& b
->address
!= bp_addr
)
1048 /* Come here if it's a watchpoint, or if the break address matches */
1050 bs
= bpstat_alloc (b
, bs
); /* Alloc a bpstat to explain stop */
1055 if (b
->type
== bp_watchpoint
)
1057 static char message1
[] =
1058 "Error evaluating expression for watchpoint %d\n";
1059 char message
[sizeof (message1
) + 30 /* slop */];
1060 sprintf (message
, message1
, b
->number
);
1061 switch (catch_errors (watchpoint_check
, (char *) bs
, message
,
1065 /* We've already printed what needs to be printed. */
1066 bs
->print_it
= print_it_done
;
1069 case WP_VALUE_CHANGED
:
1072 case WP_VALUE_NOT_CHANGED
:
1074 bs
->print_it
= print_it_noop
;
1081 /* Error from catch_errors. */
1082 b
->enable
= disabled
;
1083 printf_filtered ("Watchpoint %d disabled.\n", b
->number
);
1084 /* We've already printed what needs to be printed. */
1085 bs
->print_it
= print_it_done
;
1090 #if DECR_PC_AFTER_BREAK != 0 || defined (SHIFT_INST_REGS)
1092 real_breakpoint
= 1;
1095 if (b
->frame
&& b
->frame
!= frame_address
)
1103 /* Need to select the frame, with all that implies
1104 so that the conditions will have the right context. */
1105 select_frame (get_current_frame (), 0);
1107 = catch_errors (breakpoint_cond_eval
, (char *)(b
->cond
),
1108 "Error in testing breakpoint condition:\n",
1110 /* FIXME-someday, should give breakpoint # */
1113 if (b
->cond
&& value_is_zero
)
1117 else if (b
->ignore_count
> 0)
1124 /* We will stop here */
1125 if (b
->disposition
== disable
)
1126 b
->enable
= disabled
;
1127 bs
->commands
= b
->commands
;
1130 if (bs
->commands
&& STREQ ("silent", bs
->commands
->line
))
1132 bs
->commands
= bs
->commands
->next
;
1137 /* Print nothing for this entry if we dont stop or if we dont print. */
1138 if (bs
->stop
== 0 || bs
->print
== 0)
1139 bs
->print_it
= print_it_noop
;
1142 bs
->next
= NULL
; /* Terminate the chain */
1143 bs
= root_bs
->next
; /* Re-grab the head of the chain */
1144 #if DECR_PC_AFTER_BREAK != 0 || defined (SHIFT_INST_REGS)
1147 if (real_breakpoint
)
1150 #if defined (SHIFT_INST_REGS)
1152 CORE_ADDR pc
= read_register (PC_REGNUM
);
1153 CORE_ADDR npc
= read_register (NPC_REGNUM
);
1156 write_register (NNPC_REGNUM
, npc
);
1157 write_register (NPC_REGNUM
, pc
);
1160 #else /* No SHIFT_INST_REGS. */
1162 #endif /* No SHIFT_INST_REGS. */
1165 #endif /* DECR_PC_AFTER_BREAK != 0. */
1169 /* Tell what to do about this bpstat. */
1174 /* Classify each bpstat as one of the following. */
1176 /* This bpstat element has no effect on the main_action. */
1179 /* There was a watchpoint, stop but don't print. */
1182 /* There was a watchpoint, stop and print. */
1185 /* There was a breakpoint but we're not stopping. */
1188 /* There was a breakpoint, stop but don't print. */
1191 /* There was a breakpoint, stop and print. */
1194 /* We hit the longjmp breakpoint. */
1197 /* We hit the longjmp_resume breakpoint. */
1200 /* This is just used to count how many enums there are. */
1204 /* Here is the table which drives this routine. So that we can
1205 format it pretty, we define some abbreviations for the
1206 enum bpstat_what codes. */
1207 #define keep_c BPSTAT_WHAT_KEEP_CHECKING
1208 #define stop_s BPSTAT_WHAT_STOP_SILENT
1209 #define stop_n BPSTAT_WHAT_STOP_NOISY
1210 #define single BPSTAT_WHAT_SINGLE
1211 #define setlr BPSTAT_WHAT_SET_LONGJMP_RESUME
1212 #define clrlr BPSTAT_WHAT_CLEAR_LONGJMP_RESUME
1213 #define clrlrs BPSTAT_WHAT_CLEAR_LONGJMP_RESUME_SINGLE
1214 /* "Can't happen." Might want to print an error message.
1215 abort() is not out of the question, but chances are GDB is just
1216 a bit confused, not unusable. */
1217 #define err BPSTAT_WHAT_STOP_NOISY
1219 /* Given an old action and a class, come up with a new action. */
1220 static const enum bpstat_what_main_action
1221 table
[(int)class_last
][(int)BPSTAT_WHAT_LAST
] =
1224 /* keep_c stop_s stop_n single setlr clrlr clrlrs */
1226 /*no_effect*/ {keep_c
, stop_s
, stop_n
, single
, setlr
, clrlr
, clrlrs
},
1227 /*wp_silent*/ {stop_s
, stop_s
, stop_n
, stop_s
, stop_s
, stop_s
, stop_s
},
1228 /*wp_noisy*/ {stop_n
, stop_n
, stop_n
, stop_n
, stop_n
, stop_n
, stop_n
},
1229 /*bp_nostop*/ {single
, stop_s
, stop_n
, single
, setlr
, clrlrs
, clrlrs
},
1230 /*bp_silent*/ {stop_s
, stop_s
, stop_n
, stop_s
, stop_s
, stop_s
, stop_s
},
1231 /*bp_noisy*/ {stop_n
, stop_n
, stop_n
, stop_n
, stop_n
, stop_n
, stop_n
},
1232 /*long_jump*/ {setlr
, stop_s
, stop_n
, setlr
, err
, err
, err
},
1233 /*long_resume*/ {clrlr
, stop_s
, stop_n
, clrlrs
, err
, err
, err
}
1243 enum bpstat_what_main_action current_action
= BPSTAT_WHAT_KEEP_CHECKING
;
1244 int found_step_resume
= 0;
1246 for (; bs
!= NULL
; bs
= bs
->next
)
1248 enum class bs_class
;
1249 if (bs
->breakpoint_at
== NULL
)
1250 /* I suspect this can happen if it was a momentary breakpoint
1251 which has since been deleted. */
1253 switch (bs
->breakpoint_at
->type
)
1261 bs_class
= bp_noisy
;
1263 bs_class
= bp_silent
;
1266 bs_class
= bp_nostop
;
1272 bs_class
= wp_noisy
;
1274 bs_class
= wp_silent
;
1277 /* There was a watchpoint, but we're not stopping. This requires
1278 no further action. */
1279 bs_class
= no_effect
;
1282 bs_class
= long_jump
;
1284 case bp_longjmp_resume
:
1285 bs_class
= long_resume
;
1287 case bp_step_resume
:
1289 /* Need to temporarily disable this until we can fix the bug
1290 with nexting over a breakpoint with ->stop clear causing
1291 an infinite loop. For now, treat the breakpoint as having
1292 been hit even if the frame is wrong. */
1296 found_step_resume
= 1;
1297 /* We don't handle this via the main_action. */
1298 bs_class
= no_effect
;
1302 /* It is for the wrong frame. */
1303 bs_class
= bp_nostop
;
1307 current_action
= table
[(int)bs_class
][(int)current_action
];
1310 struct bpstat_what retval
;
1311 retval
.main_action
= current_action
;
1312 retval
.step_resume
= found_step_resume
;
1317 /* Nonzero if we should step constantly (e.g. watchpoints on machines
1318 without hardware support). This isn't related to a specific bpstat,
1319 just to things like whether watchpoints are set. */
1322 bpstat_should_step ()
1324 struct breakpoint
*b
;
1326 if (b
->enable
== enabled
&& b
->type
== bp_watchpoint
)
1331 /* Print information on breakpoint number BNUM, or -1 if all.
1332 If WATCHPOINTS is zero, process only breakpoints; if WATCHPOINTS
1333 is nonzero, process only watchpoints. */
1336 breakpoint_1 (bnum
, allflag
)
1340 register struct breakpoint
*b
;
1341 register struct command_line
*l
;
1342 register struct symbol
*sym
;
1343 CORE_ADDR last_addr
= (CORE_ADDR
)-1;
1344 int found_a_breakpoint
= 0;
1345 static char *bptypes
[] = {"breakpoint", "until", "finish", "watchpoint",
1346 "longjmp", "longjmp resume"};
1347 static char *bpdisps
[] = {"del", "dis", "keep"};
1348 static char bpenables
[] = "ny";
1349 char wrap_indent
[80];
1351 if (!breakpoint_chain
)
1353 printf_filtered ("No breakpoints or watchpoints.\n");
1359 || bnum
== b
->number
)
1361 /* We only print out user settable breakpoints unless the allflag is set. */
1363 && b
->type
!= bp_breakpoint
1364 && b
->type
!= bp_watchpoint
)
1367 if (!found_a_breakpoint
++)
1368 printf_filtered ("Num Type Disp Enb %sWhat\n",
1369 addressprint
? "Address " : "");
1371 printf_filtered ("%-3d %-14s %-4s %-3c ",
1373 bptypes
[(int)b
->type
],
1374 bpdisps
[(int)b
->disposition
],
1375 bpenables
[(int)b
->enable
]);
1376 strcpy (wrap_indent
, " ");
1378 strcat (wrap_indent
, " ");
1382 print_expression (b
->exp
, stdout
);
1388 case bp_longjmp_resume
:
1390 printf_filtered ("%s ", local_hex_string_custom(b
->address
, "08"));
1392 last_addr
= b
->address
;
1395 sym
= find_pc_function (b
->address
);
1398 fputs_filtered ("in ", stdout
);
1399 fputs_filtered (SYMBOL_SOURCE_NAME (sym
), stdout
);
1400 wrap_here (wrap_indent
);
1401 fputs_filtered (" at ", stdout
);
1403 fputs_filtered (b
->symtab
->filename
, stdout
);
1404 printf_filtered (":%d", b
->line_number
);
1407 print_address_symbolic (b
->address
, stdout
, demangle
, " ");
1410 printf_filtered ("\n");
1413 printf_filtered ("\tstop only in stack frame at %s\n",
1414 local_hex_string(b
->frame
));
1417 printf_filtered ("\tstop only if ");
1418 print_expression (b
->cond
, stdout
);
1419 printf_filtered ("\n");
1421 if (b
->ignore_count
)
1422 printf_filtered ("\tignore next %d hits\n", b
->ignore_count
);
1423 if ((l
= b
->commands
))
1426 fputs_filtered ("\t", stdout
);
1427 fputs_filtered (l
->line
, stdout
);
1428 fputs_filtered ("\n", stdout
);
1433 if (!found_a_breakpoint
1435 printf_filtered ("No breakpoint or watchpoint number %d.\n", bnum
);
1437 /* Compare against (CORE_ADDR)-1 in case some compiler decides
1438 that a comparison of an unsigned with -1 is always false. */
1439 if (last_addr
!= (CORE_ADDR
)-1)
1440 set_next_address (last_addr
);
1445 breakpoints_info (bnum_exp
, from_tty
)
1452 bnum
= parse_and_eval_address (bnum_exp
);
1454 breakpoint_1 (bnum
, 0);
1457 #if MAINTENANCE_CMDS
1461 maintenance_info_breakpoints (bnum_exp
, from_tty
)
1468 bnum
= parse_and_eval_address (bnum_exp
);
1470 breakpoint_1 (bnum
, 1);
1475 /* Print a message describing any breakpoints set at PC. */
1478 describe_other_breakpoints (pc
)
1479 register CORE_ADDR pc
;
1481 register int others
= 0;
1482 register struct breakpoint
*b
;
1485 if (b
->address
== pc
)
1489 printf ("Note: breakpoint%s ", (others
> 1) ? "s" : "");
1491 if (b
->address
== pc
)
1496 (b
->enable
== disabled
) ? " (disabled)" : "",
1497 (others
> 1) ? "," : ((others
== 1) ? " and" : ""));
1499 printf ("also set at pc %s.\n", local_hex_string(pc
));
1503 /* Set the default place to put a breakpoint
1504 for the `break' command with no arguments. */
1507 set_default_breakpoint (valid
, addr
, symtab
, line
)
1510 struct symtab
*symtab
;
1513 default_breakpoint_valid
= valid
;
1514 default_breakpoint_address
= addr
;
1515 default_breakpoint_symtab
= symtab
;
1516 default_breakpoint_line
= line
;
1519 /* Rescan breakpoints at address ADDRESS,
1520 marking the first one as "first" and any others as "duplicates".
1521 This is so that the bpt instruction is only inserted once. */
1524 check_duplicates (address
)
1527 register struct breakpoint
*b
;
1528 register int count
= 0;
1530 if (address
== 0) /* Watchpoints are uninteresting */
1534 if (b
->enable
!= disabled
&& b
->address
== address
)
1537 b
->duplicate
= count
> 1;
1541 /* Low level routine to set a breakpoint.
1542 Takes as args the three things that every breakpoint must have.
1543 Returns the breakpoint object so caller can set other things.
1544 Does not set the breakpoint number!
1545 Does not print anything.
1547 ==> This routine should not be called if there is a chance of later
1548 error(); otherwise it leaves a bogus breakpoint on the chain. Validate
1549 your arguments BEFORE calling this routine! */
1551 static struct breakpoint
*
1552 set_raw_breakpoint (sal
)
1553 struct symtab_and_line sal
;
1555 register struct breakpoint
*b
, *b1
;
1557 b
= (struct breakpoint
*) xmalloc (sizeof (struct breakpoint
));
1558 memset (b
, 0, sizeof (*b
));
1559 b
->address
= sal
.pc
;
1560 b
->symtab
= sal
.symtab
;
1561 b
->line_number
= sal
.line
;
1562 b
->enable
= enabled
;
1565 b
->ignore_count
= 0;
1569 /* Add this breakpoint to the end of the chain
1570 so that a list of breakpoints will come out in order
1571 of increasing numbers. */
1573 b1
= breakpoint_chain
;
1575 breakpoint_chain
= b
;
1583 check_duplicates (sal
.pc
);
1589 create_longjmp_breakpoint(func_name
)
1592 struct symtab_and_line sal
;
1593 struct breakpoint
*b
;
1594 static int internal_breakpoint_number
= -1;
1596 if (func_name
!= NULL
)
1598 struct minimal_symbol
*m
;
1600 m
= lookup_minimal_symbol(func_name
, (struct objfile
*)NULL
);
1602 sal
.pc
= SYMBOL_VALUE_ADDRESS (m
);
1612 b
= set_raw_breakpoint(sal
);
1615 b
->type
= func_name
!= NULL
? bp_longjmp
: bp_longjmp_resume
;
1616 b
->disposition
= donttouch
;
1617 b
->enable
= disabled
;
1620 b
->addr_string
= strsave(func_name
);
1621 b
->number
= internal_breakpoint_number
--;
1624 /* Call this routine when stepping and nexting to enable a breakpoint if we do
1625 a longjmp(). When we hit that breakpoint, call
1626 set_longjmp_resume_breakpoint() to figure out where we are going. */
1629 enable_longjmp_breakpoint()
1631 register struct breakpoint
*b
;
1634 if (b
->type
== bp_longjmp
)
1636 b
->enable
= enabled
;
1637 check_duplicates (b
->address
);
1642 disable_longjmp_breakpoint()
1644 register struct breakpoint
*b
;
1647 if ( b
->type
== bp_longjmp
1648 || b
->type
== bp_longjmp_resume
)
1650 b
->enable
= disabled
;
1651 check_duplicates (b
->address
);
1655 /* Call this after hitting the longjmp() breakpoint. Use this to set a new
1656 breakpoint at the target of the jmp_buf.
1658 FIXME - This ought to be done by setting a temporary breakpoint that gets
1659 deleted automatically...
1663 set_longjmp_resume_breakpoint(pc
, frame
)
1667 register struct breakpoint
*b
;
1670 if (b
->type
== bp_longjmp_resume
)
1673 b
->enable
= enabled
;
1675 b
->frame
= FRAME_FP(frame
);
1678 check_duplicates (b
->address
);
1683 /* Set a breakpoint that will evaporate an end of command
1684 at address specified by SAL.
1685 Restrict it to frame FRAME if FRAME is nonzero. */
1688 set_momentary_breakpoint (sal
, frame
, type
)
1689 struct symtab_and_line sal
;
1693 register struct breakpoint
*b
;
1694 b
= set_raw_breakpoint (sal
);
1696 b
->enable
= enabled
;
1697 b
->disposition
= donttouch
;
1698 b
->frame
= (frame
? FRAME_FP (frame
) : 0);
1704 clear_momentary_breakpoints ()
1706 register struct breakpoint
*b
;
1708 if (b
->disposition
== delete)
1710 delete_breakpoint (b
);
1716 /* Tell the user we have just set a breakpoint B. */
1719 struct breakpoint
*b
;
1724 printf_filtered ("Watchpoint %d: ", b
->number
);
1725 print_expression (b
->exp
, stdout
);
1728 printf_filtered ("Breakpoint %d at %s", b
->number
,
1729 local_hex_string(b
->address
));
1731 printf_filtered (": file %s, line %d.",
1732 b
->symtab
->filename
, b
->line_number
);
1737 case bp_longjmp_resume
:
1740 printf_filtered ("\n");
1744 /* Nobody calls this currently. */
1745 /* Set a breakpoint from a symtab and line.
1746 If TEMPFLAG is nonzero, it is a temporary breakpoint.
1747 ADDR_STRING is a malloc'd string holding the name of where we are
1748 setting the breakpoint. This is used later to re-set it after the
1749 program is relinked and symbols are reloaded.
1750 Print the same confirmation messages that the breakpoint command prints. */
1753 set_breakpoint (s
, line
, tempflag
, addr_string
)
1759 register struct breakpoint
*b
;
1760 struct symtab_and_line sal
;
1765 resolve_sal_pc (&sal
); /* Might error out */
1766 describe_other_breakpoints (sal
.pc
);
1768 b
= set_raw_breakpoint (sal
);
1769 set_breakpoint_count (breakpoint_count
+ 1);
1770 b
->number
= breakpoint_count
;
1771 b
->type
= bp_breakpoint
;
1773 b
->addr_string
= addr_string
;
1774 b
->enable
= enabled
;
1775 b
->disposition
= tempflag
? delete : donttouch
;
1781 /* Set a breakpoint according to ARG (function, linenum or *address)
1782 and make it temporary if TEMPFLAG is nonzero. */
1785 break_command_1 (arg
, tempflag
, from_tty
)
1787 int tempflag
, from_tty
;
1789 struct symtabs_and_lines sals
;
1790 struct symtab_and_line sal
;
1791 register struct expression
*cond
= 0;
1792 register struct breakpoint
*b
;
1794 /* Pointers in arg to the start, and one past the end, of the condition. */
1795 char *cond_start
= NULL
;
1797 /* Pointers in arg to the start, and one past the end,
1798 of the address part. */
1799 char *addr_start
= NULL
;
1807 sal
.line
= sal
.pc
= sal
.end
= 0;
1810 /* If no arg given, or if first arg is 'if ', use the default breakpoint. */
1812 if (!arg
|| (arg
[0] == 'i' && arg
[1] == 'f'
1813 && (arg
[2] == ' ' || arg
[2] == '\t')))
1815 if (default_breakpoint_valid
)
1817 sals
.sals
= (struct symtab_and_line
*)
1818 xmalloc (sizeof (struct symtab_and_line
));
1819 sal
.pc
= default_breakpoint_address
;
1820 sal
.line
= default_breakpoint_line
;
1821 sal
.symtab
= default_breakpoint_symtab
;
1826 error ("No default breakpoint address now.");
1832 /* Force almost all breakpoints to be in terms of the
1833 current_source_symtab (which is decode_line_1's default). This
1834 should produce the results we want almost all of the time while
1835 leaving default_breakpoint_* alone. */
1836 if (default_breakpoint_valid
1837 && (!current_source_symtab
1838 || (arg
&& (*arg
== '+' || *arg
== '-'))))
1839 sals
= decode_line_1 (&arg
, 1, default_breakpoint_symtab
,
1840 default_breakpoint_line
);
1842 sals
= decode_line_1 (&arg
, 1, (struct symtab
*)NULL
, 0);
1850 /* Resolve all line numbers to PC's, and verify that conditions
1851 can be parsed, before setting any breakpoints. */
1852 for (i
= 0; i
< sals
.nelts
; i
++)
1854 resolve_sal_pc (&sals
.sals
[i
]);
1858 if (arg
[0] == 'i' && arg
[1] == 'f'
1859 && (arg
[2] == ' ' || arg
[2] == '\t'))
1863 cond
= parse_exp_1 (&arg
, block_for_pc (sals
.sals
[i
].pc
), 0);
1867 error ("Junk at end of arguments.");
1871 /* Now set all the breakpoints. */
1872 for (i
= 0; i
< sals
.nelts
; i
++)
1877 describe_other_breakpoints (sal
.pc
);
1879 b
= set_raw_breakpoint (sal
);
1880 set_breakpoint_count (breakpoint_count
+ 1);
1881 b
->number
= breakpoint_count
;
1882 b
->type
= bp_breakpoint
;
1885 /* FIXME: We should add the filename if this is a static function
1886 and probably if it is a line number (the line numbers could
1887 have changed when we re-read symbols; possibly better to disable
1888 the breakpoint in that case). */
1890 b
->addr_string
= savestring (addr_start
, addr_end
- addr_start
);
1892 b
->cond_string
= savestring (cond_start
, cond_end
- cond_start
);
1894 b
->enable
= enabled
;
1895 b
->disposition
= tempflag
? delete : donttouch
;
1902 printf ("Multiple breakpoints were set.\n");
1903 printf ("Use the \"delete\" command to delete unwanted breakpoints.\n");
1905 free ((PTR
)sals
.sals
);
1908 /* Helper function for break_command_1 and disassemble_command. */
1911 resolve_sal_pc (sal
)
1912 struct symtab_and_line
*sal
;
1916 if (sal
->pc
== 0 && sal
->symtab
!= 0)
1918 pc
= find_line_pc (sal
->symtab
, sal
->line
);
1920 error ("No line %d in file \"%s\".",
1921 sal
->line
, sal
->symtab
->filename
);
1927 break_command (arg
, from_tty
)
1931 break_command_1 (arg
, 0, from_tty
);
1935 tbreak_command (arg
, from_tty
)
1939 break_command_1 (arg
, 1, from_tty
);
1944 watch_command (arg
, from_tty
)
1948 struct breakpoint
*b
;
1949 struct symtab_and_line sal
;
1950 struct expression
*exp
;
1951 struct block
*exp_valid_block
;
1958 /* Parse arguments. */
1959 innermost_block
= NULL
;
1960 exp
= parse_expression (arg
);
1961 exp_valid_block
= innermost_block
;
1962 val
= evaluate_expression (exp
);
1963 release_value (val
);
1964 if (VALUE_LAZY (val
))
1965 value_fetch_lazy (val
);
1967 /* Now set up the breakpoint. */
1968 b
= set_raw_breakpoint (sal
);
1969 set_breakpoint_count (breakpoint_count
+ 1);
1970 b
->number
= breakpoint_count
;
1971 b
->type
= bp_watchpoint
;
1972 b
->disposition
= donttouch
;
1974 b
->exp_valid_block
= exp_valid_block
;
1977 b
->cond_string
= NULL
;
1978 b
->exp_string
= savestring (arg
, strlen (arg
));
1983 * Helper routine for the until_command routine in infcmd.c. Here
1984 * because it uses the mechanisms of breakpoints.
1988 until_break_command (arg
, from_tty
)
1992 struct symtabs_and_lines sals
;
1993 struct symtab_and_line sal
;
1994 FRAME prev_frame
= get_prev_frame (selected_frame
);
1995 struct breakpoint
*breakpoint
;
1996 struct cleanup
*old_chain
;
1998 clear_proceed_status ();
2000 /* Set a breakpoint where the user wants it and at return from
2003 if (default_breakpoint_valid
)
2004 sals
= decode_line_1 (&arg
, 1, default_breakpoint_symtab
,
2005 default_breakpoint_line
);
2007 sals
= decode_line_1 (&arg
, 1, (struct symtab
*)NULL
, 0);
2009 if (sals
.nelts
!= 1)
2010 error ("Couldn't get information on specified line.");
2013 free ((PTR
)sals
.sals
); /* malloc'd, so freed */
2016 error ("Junk at end of arguments.");
2018 resolve_sal_pc (&sal
);
2020 breakpoint
= set_momentary_breakpoint (sal
, selected_frame
, bp_until
);
2022 old_chain
= make_cleanup(delete_breakpoint
, breakpoint
);
2024 /* Keep within the current frame */
2028 struct frame_info
*fi
;
2030 fi
= get_frame_info (prev_frame
);
2031 sal
= find_pc_line (fi
->pc
, 0);
2033 breakpoint
= set_momentary_breakpoint (sal
, prev_frame
, bp_until
);
2034 make_cleanup(delete_breakpoint
, breakpoint
);
2037 proceed (-1, -1, 0);
2038 do_cleanups(old_chain
);
2042 /* These aren't used; I don't konw what they were for. */
2043 /* Set a breakpoint at the catch clause for NAME. */
2045 catch_breakpoint (name
)
2051 disable_catch_breakpoint ()
2056 delete_catch_breakpoint ()
2061 enable_catch_breakpoint ()
2068 struct sal_chain
*next
;
2069 struct symtab_and_line sal
;
2073 /* This isn't used; I don't know what it was for. */
2074 /* For each catch clause identified in ARGS, run FUNCTION
2075 with that clause as an argument. */
2076 static struct symtabs_and_lines
2077 map_catch_names (args
, function
)
2081 register char *p
= args
;
2083 struct symtabs_and_lines sals
;
2085 struct sal_chain
*sal_chain
= 0;
2089 error_no_arg ("one or more catch names");
2097 /* Don't swallow conditional part. */
2098 if (p1
[0] == 'i' && p1
[1] == 'f'
2099 && (p1
[2] == ' ' || p1
[2] == '\t'))
2105 while (isalnum (*p1
) || *p1
== '_' || *p1
== '$')
2109 if (*p1
&& *p1
!= ' ' && *p1
!= '\t')
2110 error ("Arguments must be catch names.");
2116 struct sal_chain
*next
2117 = (struct sal_chain
*)alloca (sizeof (struct sal_chain
));
2118 next
->next
= sal_chain
;
2119 next
->sal
= get_catch_sal (p
);
2124 printf ("No catch clause for exception %s.\n", p
);
2129 while (*p
== ' ' || *p
== '\t') p
++;
2134 /* This shares a lot of code with `print_frame_label_vars' from stack.c. */
2136 static struct symtabs_and_lines
2137 get_catch_sals (this_level_only
)
2138 int this_level_only
;
2140 register struct blockvector
*bl
;
2141 register struct block
*block
;
2142 int index
, have_default
= 0;
2143 struct frame_info
*fi
;
2145 struct symtabs_and_lines sals
;
2146 struct sal_chain
*sal_chain
= 0;
2147 char *blocks_searched
;
2149 /* Not sure whether an error message is always the correct response,
2150 but it's better than a core dump. */
2151 if (selected_frame
== NULL
)
2152 error ("No selected frame.");
2153 block
= get_frame_block (selected_frame
);
2154 fi
= get_frame_info (selected_frame
);
2161 error ("No symbol table info available.\n");
2163 bl
= blockvector_for_pc (BLOCK_END (block
) - 4, &index
);
2164 blocks_searched
= (char *) alloca (BLOCKVECTOR_NBLOCKS (bl
) * sizeof (char));
2165 memset (blocks_searched
, 0, BLOCKVECTOR_NBLOCKS (bl
) * sizeof (char));
2169 CORE_ADDR end
= BLOCK_END (block
) - 4;
2172 if (bl
!= blockvector_for_pc (end
, &index
))
2173 error ("blockvector blotch");
2174 if (BLOCKVECTOR_BLOCK (bl
, index
) != block
)
2175 error ("blockvector botch");
2176 last_index
= BLOCKVECTOR_NBLOCKS (bl
);
2179 /* Don't print out blocks that have gone by. */
2180 while (index
< last_index
2181 && BLOCK_END (BLOCKVECTOR_BLOCK (bl
, index
)) < pc
)
2184 while (index
< last_index
2185 && BLOCK_END (BLOCKVECTOR_BLOCK (bl
, index
)) < end
)
2187 if (blocks_searched
[index
] == 0)
2189 struct block
*b
= BLOCKVECTOR_BLOCK (bl
, index
);
2192 register struct symbol
*sym
;
2194 nsyms
= BLOCK_NSYMS (b
);
2196 for (i
= 0; i
< nsyms
; i
++)
2198 sym
= BLOCK_SYM (b
, i
);
2199 if (STREQ (SYMBOL_NAME (sym
), "default"))
2205 if (SYMBOL_CLASS (sym
) == LOC_LABEL
)
2207 struct sal_chain
*next
= (struct sal_chain
*)
2208 alloca (sizeof (struct sal_chain
));
2209 next
->next
= sal_chain
;
2210 next
->sal
= find_pc_line (SYMBOL_VALUE_ADDRESS (sym
), 0);
2214 blocks_searched
[index
] = 1;
2220 if (sal_chain
&& this_level_only
)
2223 /* After handling the function's top-level block, stop.
2224 Don't continue to its superblock, the block of
2225 per-file symbols. */
2226 if (BLOCK_FUNCTION (block
))
2228 block
= BLOCK_SUPERBLOCK (block
);
2233 struct sal_chain
*tmp_chain
;
2235 /* Count the number of entries. */
2236 for (index
= 0, tmp_chain
= sal_chain
; tmp_chain
;
2237 tmp_chain
= tmp_chain
->next
)
2241 sals
.sals
= (struct symtab_and_line
*)
2242 xmalloc (index
* sizeof (struct symtab_and_line
));
2243 for (index
= 0; sal_chain
; sal_chain
= sal_chain
->next
, index
++)
2244 sals
.sals
[index
] = sal_chain
->sal
;
2250 /* Commands to deal with catching exceptions. */
2253 catch_command_1 (arg
, tempflag
, from_tty
)
2258 /* First, translate ARG into something we can deal with in terms
2261 struct symtabs_and_lines sals
;
2262 struct symtab_and_line sal
;
2263 register struct expression
*cond
= 0;
2264 register struct breakpoint
*b
;
2268 sal
.line
= sal
.pc
= sal
.end
= 0;
2271 /* If no arg given, or if first arg is 'if ', all active catch clauses
2272 are breakpointed. */
2274 if (!arg
|| (arg
[0] == 'i' && arg
[1] == 'f'
2275 && (arg
[2] == ' ' || arg
[2] == '\t')))
2277 /* Grab all active catch clauses. */
2278 sals
= get_catch_sals (0);
2282 /* Grab selected catch clauses. */
2283 error ("catch NAME not implemented");
2285 /* This isn't used; I don't know what it was for. */
2286 sals
= map_catch_names (arg
, catch_breakpoint
);
2294 for (i
= 0; i
< sals
.nelts
; i
++)
2296 resolve_sal_pc (&sals
.sals
[i
]);
2300 if (arg
[0] == 'i' && arg
[1] == 'f'
2301 && (arg
[2] == ' ' || arg
[2] == '\t'))
2302 cond
= parse_exp_1 ((arg
+= 2, &arg
),
2303 block_for_pc (sals
.sals
[i
].pc
), 0);
2305 error ("Junk at end of arguments.");
2310 for (i
= 0; i
< sals
.nelts
; i
++)
2315 describe_other_breakpoints (sal
.pc
);
2317 b
= set_raw_breakpoint (sal
);
2318 set_breakpoint_count (breakpoint_count
+ 1);
2319 b
->number
= breakpoint_count
;
2320 b
->type
= bp_breakpoint
;
2322 b
->enable
= enabled
;
2323 b
->disposition
= tempflag
? delete : donttouch
;
2325 printf ("Breakpoint %d at %s", b
->number
, local_hex_string(b
->address
));
2327 printf (": file %s, line %d.", b
->symtab
->filename
, b
->line_number
);
2333 printf ("Multiple breakpoints were set.\n");
2334 printf ("Use the \"delete\" command to delete unwanted breakpoints.\n");
2336 free ((PTR
)sals
.sals
);
2340 /* These aren't used; I don't know what they were for. */
2341 /* Disable breakpoints on all catch clauses described in ARGS. */
2343 disable_catch (args
)
2346 /* Map the disable command to catch clauses described in ARGS. */
2349 /* Enable breakpoints on all catch clauses described in ARGS. */
2354 /* Map the disable command to catch clauses described in ARGS. */
2357 /* Delete breakpoints on all catch clauses in the active scope. */
2362 /* Map the delete command to catch clauses described in ARGS. */
2367 catch_command (arg
, from_tty
)
2371 catch_command_1 (arg
, 0, from_tty
);
2375 clear_command (arg
, from_tty
)
2379 register struct breakpoint
*b
, *b1
;
2380 struct symtabs_and_lines sals
;
2381 struct symtab_and_line sal
;
2382 register struct breakpoint
*found
;
2387 sals
= decode_line_spec (arg
, 1);
2391 sals
.sals
= (struct symtab_and_line
*) xmalloc (sizeof (struct symtab_and_line
));
2392 sal
.line
= default_breakpoint_line
;
2393 sal
.symtab
= default_breakpoint_symtab
;
2395 if (sal
.symtab
== 0)
2396 error ("No source file specified.");
2402 for (i
= 0; i
< sals
.nelts
; i
++)
2404 /* If exact pc given, clear bpts at that pc.
2405 But if sal.pc is zero, clear all bpts on specified line. */
2407 found
= (struct breakpoint
*) 0;
2408 while (breakpoint_chain
2409 && (sal
.pc
? breakpoint_chain
->address
== sal
.pc
2410 : (breakpoint_chain
->symtab
== sal
.symtab
2411 && breakpoint_chain
->line_number
== sal
.line
)))
2413 b1
= breakpoint_chain
;
2414 breakpoint_chain
= b1
->next
;
2421 && b
->next
->type
!= bp_watchpoint
2422 && (sal
.pc
? b
->next
->address
== sal
.pc
2423 : (b
->next
->symtab
== sal
.symtab
2424 && b
->next
->line_number
== sal
.line
)))
2435 error ("No breakpoint at %s.", arg
);
2437 error ("No breakpoint at this line.");
2440 if (found
->next
) from_tty
= 1; /* Always report if deleted more than one */
2441 if (from_tty
) printf ("Deleted breakpoint%s ", found
->next
? "s" : "");
2444 if (from_tty
) printf ("%d ", found
->number
);
2446 delete_breakpoint (found
);
2449 if (from_tty
) putchar ('\n');
2451 free ((PTR
)sals
.sals
);
2454 /* Delete breakpoint in BS if they are `delete' breakpoints.
2455 This is called after any breakpoint is hit, or after errors. */
2458 breakpoint_auto_delete (bs
)
2461 for (; bs
; bs
= bs
->next
)
2462 if (bs
->breakpoint_at
&& bs
->breakpoint_at
->disposition
== delete)
2463 delete_breakpoint (bs
->breakpoint_at
);
2466 /* Delete a breakpoint and clean up all traces of it in the data structures. */
2469 delete_breakpoint (bpt
)
2470 struct breakpoint
*bpt
;
2472 register struct breakpoint
*b
;
2476 target_remove_breakpoint(bpt
->address
, bpt
->shadow_contents
);
2478 if (breakpoint_chain
== bpt
)
2479 breakpoint_chain
= bpt
->next
;
2484 b
->next
= bpt
->next
;
2488 check_duplicates (bpt
->address
);
2489 /* If this breakpoint was inserted, and there is another breakpoint
2490 at the same address, we need to insert the other breakpoint. */
2494 if (b
->address
== bpt
->address
&& !b
->duplicate
)
2497 val
= target_insert_breakpoint (b
->address
, b
->shadow_contents
);
2500 fprintf (stderr
, "Cannot insert breakpoint %d:\n", b
->number
);
2501 memory_error (val
, b
->address
); /* which bombs us out */
2508 free_command_lines (&bpt
->commands
);
2510 free ((PTR
)bpt
->cond
);
2511 if (bpt
->cond_string
!= NULL
)
2512 free ((PTR
)bpt
->cond_string
);
2513 if (bpt
->addr_string
!= NULL
)
2514 free ((PTR
)bpt
->addr_string
);
2515 if (bpt
->exp_string
!= NULL
)
2516 free ((PTR
)bpt
->exp_string
);
2518 if (xgdb_verbose
&& bpt
->type
== bp_breakpoint
)
2519 printf ("breakpoint #%d deleted\n", bpt
->number
);
2521 /* Be sure no bpstat's are pointing at it after it's been freed. */
2522 /* FIXME, how can we find all bpstat's? We just check stop_bpstat for now. */
2523 for (bs
= stop_bpstat
; bs
; bs
= bs
->next
)
2524 if (bs
->breakpoint_at
== bpt
)
2525 bs
->breakpoint_at
= NULL
;
2530 delete_command (arg
, from_tty
)
2537 /* Ask user only if there are some breakpoints to delete. */
2539 || (breakpoint_chain
&& query ("Delete all breakpoints? ", 0, 0)))
2541 /* No arg; clear all breakpoints. */
2542 while (breakpoint_chain
)
2543 delete_breakpoint (breakpoint_chain
);
2547 map_breakpoint_numbers (arg
, delete_breakpoint
);
2550 /* Reset a breakpoint given it's struct breakpoint * BINT.
2551 The value we return ends up being the return value from catch_errors.
2552 Unused in this case. */
2555 breakpoint_re_set_one (bint
)
2558 struct breakpoint
*b
= (struct breakpoint
*)bint
; /* get past catch_errs */
2560 struct symtabs_and_lines sals
;
2562 enum enable save_enable
;
2567 if (b
->addr_string
== NULL
)
2569 /* Anything without a string can't be re-set. */
2570 delete_breakpoint (b
);
2573 /* In case we have a problem, disable this breakpoint. We'll restore
2574 its status if we succeed. */
2575 save_enable
= b
->enable
;
2576 b
->enable
= disabled
;
2579 sals
= decode_line_1 (&s
, 1, (struct symtab
*)NULL
, 0);
2580 for (i
= 0; i
< sals
.nelts
; i
++)
2582 resolve_sal_pc (&sals
.sals
[i
]);
2583 if (b
->symtab
!= sals
.sals
[i
].symtab
2584 || b
->line_number
!= sals
.sals
[i
].line
2585 || b
->address
!= sals
.sals
[i
].pc
)
2587 b
->symtab
= sals
.sals
[i
].symtab
;
2588 b
->line_number
= sals
.sals
[i
].line
;
2589 b
->address
= sals
.sals
[i
].pc
;
2591 if (b
->cond_string
!= NULL
)
2595 free ((PTR
)b
->cond
);
2596 b
->cond
= parse_exp_1 (&s
, block_for_pc (sals
.sals
[i
].pc
), 0);
2599 check_duplicates (b
->address
);
2603 b
->enable
= save_enable
; /* Restore it, this worked. */
2605 free ((PTR
)sals
.sals
);
2609 innermost_block
= NULL
;
2610 /* The issue arises of what context to evaluate this in. The same
2611 one as when it was set, but what does that mean when symbols have
2612 been re-read? We could save the filename and functionname, but
2613 if the context is more local than that, the best we could do would
2614 be something like how many levels deep and which index at that
2615 particular level, but that's going to be less stable than filenames
2616 or functionnames. */
2617 /* So for now, just use a global context. */
2618 b
->exp
= parse_expression (b
->exp_string
);
2619 b
->exp_valid_block
= innermost_block
;
2620 b
->val
= evaluate_expression (b
->exp
);
2621 release_value (b
->val
);
2622 if (VALUE_LAZY (b
->val
))
2623 value_fetch_lazy (b
->val
);
2625 if (b
->cond_string
!= NULL
)
2628 b
->cond
= parse_exp_1 (&s
, (struct block
*)0, 0);
2630 if (b
->enable
== enabled
)
2635 printf_filtered ("Deleting unknown breakpoint type %d\n", b
->type
);
2640 case bp_longjmp_resume
:
2641 delete_breakpoint (b
);
2648 /* Re-set all breakpoints after symbols have been re-loaded. */
2650 breakpoint_re_set ()
2652 struct breakpoint
*b
, *temp
;
2653 static char message1
[] = "Error in re-setting breakpoint %d:\n";
2654 char message
[sizeof (message1
) + 30 /* slop */];
2656 ALL_BREAKPOINTS_SAFE (b
, temp
)
2658 sprintf (message
, message1
, b
->number
); /* Format possible error msg */
2659 catch_errors (breakpoint_re_set_one
, (char *) b
, message
,
2663 create_longjmp_breakpoint("longjmp");
2664 create_longjmp_breakpoint("_longjmp");
2665 create_longjmp_breakpoint("siglongjmp");
2666 create_longjmp_breakpoint(NULL
);
2669 /* Took this out (temporaliy at least), since it produces an extra
2670 blank line at startup. This messes up the gdbtests. -PB */
2671 /* Blank line to finish off all those mention() messages we just printed. */
2672 printf_filtered ("\n");
2676 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
2677 If from_tty is nonzero, it prints a message to that effect,
2678 which ends with a period (no newline). */
2681 set_ignore_count (bptnum
, count
, from_tty
)
2682 int bptnum
, count
, from_tty
;
2684 register struct breakpoint
*b
;
2690 if (b
->number
== bptnum
)
2692 b
->ignore_count
= count
;
2695 else if (count
== 0)
2696 printf_filtered ("Will stop next time breakpoint %d is reached.",
2698 else if (count
== 1)
2699 printf_filtered ("Will ignore next crossing of breakpoint %d.",
2702 printf_filtered ("Will ignore next %d crossings of breakpoint %d.",
2707 error ("No breakpoint number %d.", bptnum
);
2710 /* Clear the ignore counts of all breakpoints. */
2712 breakpoint_clear_ignore_counts ()
2714 struct breakpoint
*b
;
2717 b
->ignore_count
= 0;
2720 /* Command to set ignore-count of breakpoint N to COUNT. */
2723 ignore_command (args
, from_tty
)
2731 error_no_arg ("a breakpoint number");
2733 num
= get_number (&p
);
2736 error ("Second argument (specified ignore-count) is missing.");
2738 set_ignore_count (num
,
2739 longest_to_int (value_as_long (parse_and_eval (p
))),
2741 printf_filtered ("\n");
2744 /* Call FUNCTION on each of the breakpoints
2745 whose numbers are given in ARGS. */
2748 map_breakpoint_numbers (args
, function
)
2750 void (*function
) PARAMS ((struct breakpoint
*));
2752 register char *p
= args
;
2755 register struct breakpoint
*b
;
2758 error_no_arg ("one or more breakpoint numbers");
2764 num
= get_number (&p1
);
2767 if (b
->number
== num
)
2772 printf ("No breakpoint number %d.\n", num
);
2779 enable_breakpoint (bpt
)
2780 struct breakpoint
*bpt
;
2782 FRAME save_selected_frame
;
2783 int save_selected_frame_level
= -1;
2785 bpt
->enable
= enabled
;
2787 if (xgdb_verbose
&& bpt
->type
== bp_breakpoint
)
2788 printf ("breakpoint #%d enabled\n", bpt
->number
);
2790 check_duplicates (bpt
->address
);
2791 if (bpt
->type
== bp_watchpoint
)
2793 if (bpt
->exp_valid_block
!= NULL
)
2795 FRAME fr
= within_scope (bpt
->exp_valid_block
);
2799 Cannot enable watchpoint %d because the block in which its expression\n\
2800 is valid is not currently in scope.\n", bpt
->number
);
2801 bpt
->enable
= disabled
;
2804 save_selected_frame
= selected_frame
;
2805 save_selected_frame_level
= selected_frame_level
;
2806 select_frame (fr
, -1);
2809 value_free (bpt
->val
);
2811 bpt
->val
= evaluate_expression (bpt
->exp
);
2812 release_value (bpt
->val
);
2813 if (VALUE_LAZY (bpt
->val
))
2814 value_fetch_lazy (bpt
->val
);
2816 if (save_selected_frame_level
>= 0)
2817 select_frame (save_selected_frame
, save_selected_frame_level
);
2823 enable_command (args
, from_tty
)
2827 struct breakpoint
*bpt
;
2829 ALL_BREAKPOINTS (bpt
)
2834 enable_breakpoint (bpt
);
2839 map_breakpoint_numbers (args
, enable_breakpoint
);
2843 disable_breakpoint (bpt
)
2844 struct breakpoint
*bpt
;
2846 bpt
->enable
= disabled
;
2848 if (xgdb_verbose
&& bpt
->type
== bp_breakpoint
)
2849 printf_filtered ("breakpoint #%d disabled\n", bpt
->number
);
2851 check_duplicates (bpt
->address
);
2856 disable_command (args
, from_tty
)
2860 register struct breakpoint
*bpt
;
2862 ALL_BREAKPOINTS (bpt
)
2867 disable_breakpoint (bpt
);
2872 map_breakpoint_numbers (args
, disable_breakpoint
);
2876 enable_once_breakpoint (bpt
)
2877 struct breakpoint
*bpt
;
2879 bpt
->enable
= enabled
;
2880 bpt
->disposition
= disable
;
2882 check_duplicates (bpt
->address
);
2887 enable_once_command (args
, from_tty
)
2891 map_breakpoint_numbers (args
, enable_once_breakpoint
);
2895 enable_delete_breakpoint (bpt
)
2896 struct breakpoint
*bpt
;
2898 bpt
->enable
= enabled
;
2899 bpt
->disposition
= delete;
2901 check_duplicates (bpt
->address
);
2906 enable_delete_command (args
, from_tty
)
2910 map_breakpoint_numbers (args
, enable_delete_breakpoint
);
2914 * Use default_breakpoint_'s, or nothing if they aren't valid.
2916 struct symtabs_and_lines
2917 decode_line_spec_1 (string
, funfirstline
)
2921 struct symtabs_and_lines sals
;
2923 error ("Empty line specification.");
2924 if (default_breakpoint_valid
)
2925 sals
= decode_line_1 (&string
, funfirstline
,
2926 default_breakpoint_symtab
, default_breakpoint_line
);
2928 sals
= decode_line_1 (&string
, funfirstline
, (struct symtab
*)NULL
, 0);
2930 error ("Junk at end of line specification: %s", string
);
2935 _initialize_breakpoint ()
2937 breakpoint_chain
= 0;
2938 /* Don't bother to call set_breakpoint_count. $bpnum isn't useful
2939 before a breakpoint is set. */
2940 breakpoint_count
= 0;
2942 add_com ("ignore", class_breakpoint
, ignore_command
,
2943 "Set ignore-count of breakpoint number N to COUNT.");
2945 add_com ("commands", class_breakpoint
, commands_command
,
2946 "Set commands to be executed when a breakpoint is hit.\n\
2947 Give breakpoint number as argument after \"commands\".\n\
2948 With no argument, the targeted breakpoint is the last one set.\n\
2949 The commands themselves follow starting on the next line.\n\
2950 Type a line containing \"end\" to indicate the end of them.\n\
2951 Give \"silent\" as the first line to make the breakpoint silent;\n\
2952 then no output is printed when it is hit, except what the commands print.");
2954 add_com ("condition", class_breakpoint
, condition_command
,
2955 "Specify breakpoint number N to break only if COND is true.\n\
2956 N is an integer; COND is an expression to be evaluated whenever\n\
2957 breakpoint N is reached. ");
2959 add_com ("tbreak", class_breakpoint
, tbreak_command
,
2960 "Set a temporary breakpoint. Args like \"break\" command.\n\
2961 Like \"break\" except the breakpoint is only enabled temporarily,\n\
2962 so it will be disabled when hit. Equivalent to \"break\" followed\n\
2963 by using \"enable once\" on the breakpoint number.");
2965 add_prefix_cmd ("enable", class_breakpoint
, enable_command
,
2966 "Enable some breakpoints.\n\
2967 Give breakpoint numbers (separated by spaces) as arguments.\n\
2968 With no subcommand, breakpoints are enabled until you command otherwise.\n\
2969 This is used to cancel the effect of the \"disable\" command.\n\
2970 With a subcommand you can enable temporarily.",
2971 &enablelist
, "enable ", 1, &cmdlist
);
2973 add_abbrev_prefix_cmd ("breakpoints", class_breakpoint
, enable_command
,
2974 "Enable some breakpoints.\n\
2975 Give breakpoint numbers (separated by spaces) as arguments.\n\
2976 This is used to cancel the effect of the \"disable\" command.\n\
2977 May be abbreviated to simply \"enable\".\n",
2978 &enablebreaklist
, "enable breakpoints ", 1, &enablelist
);
2980 add_cmd ("once", no_class
, enable_once_command
,
2981 "Enable breakpoints for one hit. Give breakpoint numbers.\n\
2982 If a breakpoint is hit while enabled in this fashion, it becomes disabled.\n\
2983 See the \"tbreak\" command which sets a breakpoint and enables it once.",
2986 add_cmd ("delete", no_class
, enable_delete_command
,
2987 "Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
2988 If a breakpoint is hit while enabled in this fashion, it is deleted.",
2991 add_cmd ("delete", no_class
, enable_delete_command
,
2992 "Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
2993 If a breakpoint is hit while enabled in this fashion, it is deleted.",
2996 add_cmd ("once", no_class
, enable_once_command
,
2997 "Enable breakpoints for one hit. Give breakpoint numbers.\n\
2998 If a breakpoint is hit while enabled in this fashion, it becomes disabled.\n\
2999 See the \"tbreak\" command which sets a breakpoint and enables it once.",
3002 add_prefix_cmd ("disable", class_breakpoint
, disable_command
,
3003 "Disable some breakpoints.\n\
3004 Arguments are breakpoint numbers with spaces in between.\n\
3005 To disable all breakpoints, give no argument.\n\
3006 A disabled breakpoint is not forgotten, but has no effect until reenabled.",
3007 &disablelist
, "disable ", 1, &cmdlist
);
3008 add_com_alias ("dis", "disable", class_breakpoint
, 1);
3009 add_com_alias ("disa", "disable", class_breakpoint
, 1);
3011 add_cmd ("breakpoints", class_alias
, disable_command
,
3012 "Disable some breakpoints.\n\
3013 Arguments are breakpoint numbers with spaces in between.\n\
3014 To disable all breakpoints, give no argument.\n\
3015 A disabled breakpoint is not forgotten, but has no effect until reenabled.\n\
3016 This command may be abbreviated \"disable\".",
3019 add_prefix_cmd ("delete", class_breakpoint
, delete_command
,
3020 "Delete some breakpoints or auto-display expressions.\n\
3021 Arguments are breakpoint numbers with spaces in between.\n\
3022 To delete all breakpoints, give no argument.\n\
3024 Also a prefix command for deletion of other GDB objects.\n\
3025 The \"unset\" command is also an alias for \"delete\".",
3026 &deletelist
, "delete ", 1, &cmdlist
);
3027 add_com_alias ("d", "delete", class_breakpoint
, 1);
3029 add_cmd ("breakpoints", class_alias
, delete_command
,
3030 "Delete some breakpoints or auto-display expressions.\n\
3031 Arguments are breakpoint numbers with spaces in between.\n\
3032 To delete all breakpoints, give no argument.\n\
3033 This command may be abbreviated \"delete\".",
3036 add_com ("clear", class_breakpoint
, clear_command
,
3037 "Clear breakpoint at specified line or function.\n\
3038 Argument may be line number, function name, or \"*\" and an address.\n\
3039 If line number is specified, all breakpoints in that line are cleared.\n\
3040 If function is specified, breakpoints at beginning of function are cleared.\n\
3041 If an address is specified, breakpoints at that address are cleared.\n\n\
3042 With no argument, clears all breakpoints in the line that the selected frame\n\
3045 See also the \"delete\" command which clears breakpoints by number.");
3047 add_com ("break", class_breakpoint
, break_command
,
3048 "Set breakpoint at specified line or function.\n\
3049 Argument may be line number, function name, or \"*\" and an address.\n\
3050 If line number is specified, break at start of code for that line.\n\
3051 If function is specified, break at start of code for that function.\n\
3052 If an address is specified, break at that exact address.\n\
3053 With no arg, uses current execution address of selected stack frame.\n\
3054 This is useful for breaking on return to a stack frame.\n\
3056 Multiple breakpoints at one place are permitted, and useful if conditional.\n\
3058 Do \"help breakpoints\" for info on other commands dealing with breakpoints.");
3059 add_com_alias ("b", "break", class_run
, 1);
3060 add_com_alias ("br", "break", class_run
, 1);
3061 add_com_alias ("bre", "break", class_run
, 1);
3062 add_com_alias ("brea", "break", class_run
, 1);
3064 add_info ("breakpoints", breakpoints_info
,
3065 "Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
3066 The \"Type\" column indicates one of:\n\
3067 \tbreakpoint - normal breakpoint\n\
3068 \twatchpoint - watchpoint\n\
3069 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
3070 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
3071 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
3072 address and file/line number respectively.\n\n\
3073 Convenience variable \"$_\" and default examine address for \"x\"\n\
3074 are set to the address of the last breakpoint listed.\n\n\
3075 Convenience variable \"$bpnum\" contains the number of the last\n\
3078 #if MAINTENANCE_CMDS
3080 add_cmd ("breakpoints", class_maintenance
, maintenance_info_breakpoints
,
3081 "Status of all breakpoints, or breakpoint number NUMBER.\n\
3082 The \"Type\" column indicates one of:\n\
3083 \tbreakpoint - normal breakpoint\n\
3084 \twatchpoint - watchpoint\n\
3085 \tlongjmp - internal breakpoint used to step through longjmp()\n\
3086 \tlongjmp resume - internal breakpoint at the target of longjmp()\n\
3087 \tuntil - internal breakpoint used by the \"until\" command\n\
3088 \tfinish - internal breakpoint used by the \"finish\" command\n\
3089 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
3090 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
3091 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
3092 address and file/line number respectively.\n\n\
3093 Convenience variable \"$_\" and default examine address for \"x\"\n\
3094 are set to the address of the last breakpoint listed.\n\n\
3095 Convenience variable \"$bpnum\" contains the number of the last\n\
3097 &maintenanceinfolist
);
3099 #endif /* MAINTENANCE_CMDS */
3101 add_com ("catch", class_breakpoint
, catch_command
,
3102 "Set breakpoints to catch exceptions that are raised.\n\
3103 Argument may be a single exception to catch, multiple exceptions\n\
3104 to catch, or the default exception \"default\". If no arguments\n\
3105 are given, breakpoints are set at all exception handlers catch clauses\n\
3106 within the current scope.\n\
3108 A condition specified for the catch applies to all breakpoints set\n\
3109 with this command\n\
3111 Do \"help breakpoints\" for info on other commands dealing with breakpoints.");
3113 add_com ("watch", class_breakpoint
, watch_command
,
3114 "Set a watchpoint for an expression.\n\
3115 A watchpoint stops execution of your program whenever the value of\n\
3116 an expression changes.");
3118 add_info ("watchpoints", breakpoints_info
,
3119 "Synonym for ``info breakpoints''.");
3122 /* OK, when we call objfile_relocate, we need to relocate breakpoints
3123 too. breakpoint_re_set is not a good choice--for example, if
3124 addr_string contains just a line number without a file name the
3125 breakpoint might get set in a different file. In general, there is
3126 no need to go all the way back to the user's string (though this might
3127 work if some effort were made to canonicalize it), since symtabs and
3128 everything except addresses are still valid.
3130 Probably the best way to solve this is to have each breakpoint save
3131 the objfile and the section number that was used to set it (if set
3132 by "*addr", probably it is best to use find_pc_line to get a symtab
3133 and use the objfile and block_line_section for that symtab). Then
3134 objfile_relocate can call fixup_breakpoints with the objfile and
3135 the new_offsets, and it can relocate only the appropriate breakpoints. */
3137 #ifdef IBM6000_TARGET
3138 /* But for now, just kludge it based on the concept that before an
3139 objfile is relocated the breakpoint is below 0x10000000, and afterwards
3140 it is higher, so that way we only relocate each breakpoint once. */
3143 fixup_breakpoints (low
, high
, delta
)
3148 struct breakpoint
*b
;
3152 if (b
->address
>= low
&& b
->address
<= high
)
3153 b
->address
+= delta
;