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. FIXME: This should be
351 dependent on the debugging target. Probably want
352 target_insert_breakpoint to return a size, saying how many
353 bytes of the shadow contents are used, or perhaps have
354 something like target_xfer_shadow. */
355 return target_read_memory (memaddr
, myaddr
, len
);
359 if (b
->type
== bp_watchpoint
|| !b
->inserted
)
361 else if (b
->address
+ memory_breakpoint_size
<= memaddr
)
362 /* The breakpoint is entirely before the chunk of memory
365 else if (b
->address
>= memaddr
+ len
)
366 /* The breakpoint is entirely after the chunk of memory we
371 /* Copy the breakpoint from the shadow contents, and recurse
372 for the things before and after. */
374 /* Addresses and length of the part of the breakpoint that
376 CORE_ADDR membpt
= b
->address
;
377 unsigned int bptlen
= memory_breakpoint_size
;
378 /* Offset within shadow_contents. */
381 if (membpt
< memaddr
)
383 /* Only copy the second part of the breakpoint. */
384 bptlen
-= memaddr
- membpt
;
385 bptoffset
= memaddr
- membpt
;
389 if (membpt
+ bptlen
> memaddr
+ len
)
391 /* Only copy the first part of the breakpoint. */
392 bptlen
-= (membpt
+ bptlen
) - (memaddr
+ len
);
395 memcpy (myaddr
+ membpt
- memaddr
,
396 b
->shadow_contents
+ bptoffset
, bptlen
);
398 if (membpt
> memaddr
)
400 /* Copy the section of memory before the breakpoint. */
401 status
= read_memory_nobpt (memaddr
, myaddr
, membpt
- memaddr
);
406 if (membpt
+ bptlen
< memaddr
+ len
)
408 /* Copy the section of memory after the breakpoint. */
409 status
= read_memory_nobpt
411 myaddr
+ membpt
+ bptlen
- memaddr
,
412 memaddr
+ len
- (membpt
+ bptlen
));
419 /* Nothing overlaps. Just call read_memory_noerr. */
420 return target_read_memory (memaddr
, myaddr
, len
);
423 /* insert_breakpoints is used when starting or continuing the program.
424 remove_breakpoints is used when the program stops.
425 Both return zero if successful,
426 or an `errno' value if could not write the inferior. */
429 insert_breakpoints ()
431 register struct breakpoint
*b
;
433 int disabled_breaks
= 0;
436 if (b
->type
!= bp_watchpoint
437 && b
->enable
!= disabled
441 val
= target_insert_breakpoint(b
->address
, b
->shadow_contents
);
444 /* Can't set the breakpoint. */
445 #if defined (DISABLE_UNSETTABLE_BREAK)
446 if (DISABLE_UNSETTABLE_BREAK (b
->address
))
449 b
->enable
= disabled
;
450 if (!disabled_breaks
)
453 "Cannot insert breakpoint %d:\n", b
->number
);
454 printf_filtered ("Disabling shared library breakpoints:\n");
457 printf_filtered ("%d ", b
->number
);
462 fprintf (stderr
, "Cannot insert breakpoint %d:\n", b
->number
);
463 #ifdef ONE_PROCESS_WRITETEXT
465 "The same program may be running in another process.\n");
467 memory_error (val
, b
->address
); /* which bombs us out */
474 printf_filtered ("\n");
479 remove_breakpoints ()
481 register struct breakpoint
*b
;
484 #ifdef BREAKPOINT_DEBUG
485 printf ("Removing breakpoints.\n");
486 #endif /* BREAKPOINT_DEBUG */
489 if (b
->type
!= bp_watchpoint
&& b
->inserted
)
491 val
= target_remove_breakpoint(b
->address
, b
->shadow_contents
);
495 #ifdef BREAKPOINT_DEBUG
496 printf ("Removed breakpoint at %s",
497 local_hex_string(b
->address
));
498 printf (", shadow %s",
499 local_hex_string(b
->shadow_contents
[0]));
501 local_hex_string(b
->shadow_contents
[1]));
502 #endif /* BREAKPOINT_DEBUG */
508 /* Clear the "inserted" flag in all breakpoints.
509 This is done when the inferior is loaded. */
512 mark_breakpoints_out ()
514 register struct breakpoint
*b
;
520 /* breakpoint_here_p (PC) returns 1 if an enabled breakpoint exists at PC.
521 When continuing from a location with a breakpoint,
522 we actually single step once before calling insert_breakpoints. */
525 breakpoint_here_p (pc
)
528 register struct breakpoint
*b
;
531 if (b
->enable
!= disabled
&& b
->address
== pc
)
537 /* bpstat stuff. External routines' interfaces are documented
540 /* Clear a bpstat so that it says we are not at any breakpoint.
541 Also free any storage that is part of a bpstat. */
556 if (p
->old_val
!= NULL
)
557 value_free (p
->old_val
);
564 /* Return a copy of a bpstat. Like "bs1 = bs2" but all storage that
565 is part of the bpstat is copied as well. */
573 bpstat retval
= NULL
;
578 for (; bs
!= NULL
; bs
= bs
->next
)
580 tmp
= (bpstat
) xmalloc (sizeof (*tmp
));
581 memcpy (tmp
, bs
, sizeof (*tmp
));
583 /* This is the first thing in the chain. */
593 /* Find the bpstat associated with this breakpoint */
596 bpstat_find_breakpoint(bsp
, breakpoint
)
598 struct breakpoint
*breakpoint
;
600 if (bsp
== NULL
) return NULL
;
602 for (;bsp
!= NULL
; bsp
= bsp
->next
) {
603 if (bsp
->breakpoint_at
== breakpoint
) return bsp
;
608 /* Return the breakpoint number of the first breakpoint we are stopped
609 at. *BSP upon return is a bpstat which points to the remaining
610 breakpoints stopped at (but which is not guaranteed to be good for
611 anything but further calls to bpstat_num).
612 Return 0 if passed a bpstat which does not indicate any breakpoints. */
618 struct breakpoint
*b
;
621 return 0; /* No more breakpoint values */
624 b
= (*bsp
)->breakpoint_at
;
627 return -1; /* breakpoint that's been deleted since */
629 return b
->number
; /* We have its number */
633 /* Modify BS so that the actions will not be performed. */
636 bpstat_clear_actions (bs
)
639 for (; bs
!= NULL
; bs
= bs
->next
)
642 if (bs
->old_val
!= NULL
)
644 value_free (bs
->old_val
);
650 /* Stub for cleaning up our state if we error-out of a breakpoint command */
653 cleanup_executing_breakpoints (ignore
)
656 executing_breakpoint_commands
= 0;
659 /* Execute all the commands associated with all the breakpoints at this
660 location. Any of these commands could cause the process to proceed
661 beyond this point, etc. We look out for such changes by checking
662 the global "breakpoint_proceeded" after each command. */
665 bpstat_do_actions (bsp
)
669 struct cleanup
*old_chain
;
671 executing_breakpoint_commands
= 1;
672 old_chain
= make_cleanup (cleanup_executing_breakpoints
, 0);
677 breakpoint_proceeded
= 0;
678 for (; bs
!= NULL
; bs
= bs
->next
)
682 char *line
= bs
->commands
->line
;
683 bs
->commands
= bs
->commands
->next
;
684 execute_command (line
, 0);
685 /* If the inferior is proceeded by the command, bomb out now.
686 The bpstat chain has been blown away by wait_for_inferior.
687 But since execution has stopped again, there is a new bpstat
688 to look at, so start over. */
689 if (breakpoint_proceeded
)
694 executing_breakpoint_commands
= 0;
695 discard_cleanups (old_chain
);
698 /* This is the normal print_it function for a bpstat. In the future,
699 much of this logic could (should?) be moved to bpstat_stop_status,
700 by having it set different print_it functions. */
706 /* bs->breakpoint_at can be NULL if it was a momentary breakpoint
707 which has since been deleted. */
708 if (bs
->breakpoint_at
== NULL
709 || (bs
->breakpoint_at
->type
!= bp_breakpoint
710 && bs
->breakpoint_at
->type
!= bp_watchpoint
))
713 if (bs
->breakpoint_at
->type
== bp_breakpoint
)
715 /* I think the user probably only wants to see one breakpoint
716 number, not all of them. */
717 printf_filtered ("\nBreakpoint %d, ", bs
->breakpoint_at
->number
);
721 if (bs
->old_val
!= NULL
)
723 printf_filtered ("\nWatchpoint %d, ", bs
->breakpoint_at
->number
);
724 print_expression (bs
->breakpoint_at
->exp
, stdout
);
725 printf_filtered ("\nOld value = ");
726 value_print (bs
->old_val
, stdout
, 0, Val_pretty_default
);
727 printf_filtered ("\nNew value = ");
728 value_print (bs
->breakpoint_at
->val
, stdout
, 0,
730 printf_filtered ("\n");
731 value_free (bs
->old_val
);
735 /* We can't deal with it. Maybe another member of the bpstat chain can. */
739 /* Print a message indicating what happened. Returns nonzero to
740 say that only the source line should be printed after this (zero
741 return means print the frame as well as the source line). */
742 /* Currently we always return zero. */
752 val
= (*bs
->print_it
) (bs
);
756 /* Maybe another breakpoint in the chain caused us to stop.
757 (Currently all watchpoints go on the bpstat whether hit or
758 not. That probably could (should) be changed, provided care is taken
759 with respect to bpstat_explains_signal). */
761 return bpstat_print (bs
->next
);
763 /* We reached the end of the chain without printing anything. */
767 /* Evaluate the expression EXP and return 1 if value is zero.
768 This is used inside a catch_errors to evaluate the breakpoint condition.
769 The argument is a "struct expression *" that has been cast to char * to
770 make it pass through catch_errors. */
773 breakpoint_cond_eval (exp
)
776 return !value_true (evaluate_expression ((struct expression
*)exp
));
779 /* Allocate a new bpstat and chain it to the current one. */
782 bpstat_alloc (b
, cbs
)
783 register struct breakpoint
*b
;
784 bpstat cbs
; /* Current "bs" value */
788 bs
= (bpstat
) xmalloc (sizeof (*bs
));
790 bs
->breakpoint_at
= b
;
791 /* If the condition is false, etc., don't do the commands. */
794 bs
->print_it
= print_it_normal
;
798 /* Return the frame which we can use to evaluate the expression
799 whose valid block is valid_block, or NULL if not in scope.
801 This whole concept is probably not the way to do things (it is incredibly
802 slow being the main reason, not to mention fragile (e.g. the sparc
803 frame pointer being fetched as 0 bug causes it to stop)). Instead,
804 introduce a version of "struct frame" which survives over calls to the
805 inferior, but which is better than FRAME_ADDR in the sense that it lets
806 us evaluate expressions relative to that frame (on some machines, it
807 can just be a FRAME_ADDR). Save one of those instead of (or in addition
808 to) the exp_valid_block, and then use it to evaluate the watchpoint
809 expression, with no need to do all this backtracing every time.
811 Or better yet, what if it just copied the struct frame and its next
812 frame? Off the top of my head, I would think that would work
813 because things like (a29k) rsize and msize, or (sparc) bottom just
814 depend on the frame, and aren't going to be different just because
815 the inferior has done something. Trying to recalculate them
816 strikes me as a lot of work, possibly even impossible. Saving the
817 next frame is needed at least on a29k, where get_saved_register
818 uses fi->next->saved_msp. For figuring out whether that frame is
819 still on the stack, I guess this needs to be machine-specific (e.g.
822 read_fp () INNER_THAN watchpoint_frame->frame
824 would generally work.
826 Of course the scope of the expression could be less than a whole
827 function; perhaps if the innermost frame is the one which the
828 watchpoint is relative to (another machine-specific thing, usually
830 FRAMELESS_FUNCTION_INVOCATION (get_current_frame(), fromleaf)
831 read_fp () == wp_frame->frame
834 ), *then* it could do a
836 contained_in (get_current_block (), wp->exp_valid_block).
841 within_scope (valid_block
)
842 struct block
*valid_block
;
844 FRAME fr
= get_current_frame ();
845 struct frame_info
*fi
= get_frame_info (fr
);
846 CORE_ADDR func_start
;
848 /* If caller_pc_valid is true, we are stepping through
849 a function prologue, which is bounded by callee_func_start
850 (inclusive) and callee_prologue_end (exclusive).
851 caller_pc is the pc of the caller.
853 Yes, this is hairy. */
854 static int caller_pc_valid
= 0;
855 static CORE_ADDR caller_pc
;
856 static CORE_ADDR callee_func_start
;
857 static CORE_ADDR callee_prologue_end
;
859 find_pc_partial_function (fi
->pc
, (PTR
)NULL
, &func_start
, (CORE_ADDR
*)NULL
);
860 func_start
+= FUNCTION_START_OFFSET
;
861 if (fi
->pc
== func_start
)
863 /* We just called a function. The only other case I
864 can think of where the pc would equal the pc of the
865 start of a function is a frameless function (i.e.
866 no prologue) where we branch back to the start
867 of the function. In that case, SKIP_PROLOGUE won't
868 find one, and we'll clear caller_pc_valid a few lines
871 caller_pc
= SAVED_PC_AFTER_CALL (fr
);
872 callee_func_start
= func_start
;
873 SKIP_PROLOGUE (func_start
);
874 callee_prologue_end
= func_start
;
878 if (fi
->pc
< callee_func_start
879 || fi
->pc
>= callee_prologue_end
)
883 if (contained_in (block_for_pc (caller_pc_valid
890 fr
= get_prev_frame (fr
);
892 /* If any active frame is in the exp_valid_block, then it's
893 OK. Note that this might not be the same invocation of
894 the exp_valid_block that we were watching a little while
895 ago, or the same one as when the watchpoint was set (e.g.
896 we are watching a local variable in a recursive function.
897 When we return from a recursive invocation, then we are
898 suddenly watching a different instance of the variable).
900 At least for now I am going to consider this a feature. */
901 for (; fr
!= NULL
; fr
= get_prev_frame (fr
))
903 fi
= get_frame_info (fr
);
904 if (contained_in (block_for_pc (fi
->pc
),
913 /* Possible return values for watchpoint_check (this can't be an enum
914 because of check_errors). */
915 /* The watchpoint has been disabled. */
916 #define WP_DISABLED 1
917 /* The value has changed. */
918 #define WP_VALUE_CHANGED 2
919 /* The value has not changed. */
920 #define WP_VALUE_NOT_CHANGED 3
922 /* Check watchpoint condition. */
927 bpstat bs
= (bpstat
) p
;
930 int within_current_scope
;
931 if (bs
->breakpoint_at
->exp_valid_block
== NULL
)
932 within_current_scope
= 1;
935 fr
= within_scope (bs
->breakpoint_at
->exp_valid_block
);
936 within_current_scope
= fr
!= NULL
;
937 if (within_current_scope
)
938 /* If we end up stopping, the current frame will get selected
939 in normal_stop. So this call to select_frame won't affect
941 select_frame (fr
, -1);
944 if (within_current_scope
)
946 /* We use value_{,free_to_}mark because it could be a
947 *long* time before we return to the command level and
948 call free_all_values. */
949 /* But couldn't we just call free_all_values instead? */
951 value mark
= value_mark ();
952 value new_val
= evaluate_expression (bs
->breakpoint_at
->exp
);
953 if (!value_equal (bs
->breakpoint_at
->val
, new_val
))
955 release_value (new_val
);
956 value_free_to_mark (mark
);
957 bs
->old_val
= bs
->breakpoint_at
->val
;
958 bs
->breakpoint_at
->val
= new_val
;
959 /* We will stop here */
960 return WP_VALUE_CHANGED
;
964 /* Nothing changed, don't do anything. */
965 value_free_to_mark (mark
);
966 /* We won't stop here */
967 return WP_VALUE_NOT_CHANGED
;
972 /* This seems like the only logical thing to do because
973 if we temporarily ignored the watchpoint, then when
974 we reenter the block in which it is valid it contains
975 garbage (in the case of a function, it may have two
976 garbage values, one before and one after the prologue).
977 So we can't even detect the first assignment to it and
978 watch after that (since the garbage may or may not equal
979 the first value assigned). */
980 bs
->breakpoint_at
->enable
= disabled
;
982 Watchpoint %d disabled because the program has left the block in\n\
983 which its expression is valid.\n", bs
->breakpoint_at
->number
);
988 /* This is used when everything which needs to be printed has
989 already been printed. But we still want to print the frame. */
997 /* This is used when nothing should be printed for this bpstat entry. */
1006 /* Determine whether we stopped at a breakpoint, etc, or whether we
1007 don't understand this stop. Result is a chain of bpstat's such that:
1009 if we don't understand the stop, the result is a null pointer.
1011 if we understand why we stopped, the result is not null, and
1012 the first element of the chain contains summary "stop" and
1013 "print" flags for the whole chain.
1015 Each element of the chain refers to a particular breakpoint or
1016 watchpoint at which we have stopped. (We may have stopped for
1017 several reasons concurrently.)
1019 Each element of the chain has valid next, breakpoint_at,
1020 commands, FIXME??? fields.
1026 bpstat_stop_status (pc
, frame_address
)
1028 FRAME_ADDR frame_address
;
1030 register struct breakpoint
*b
;
1032 #if DECR_PC_AFTER_BREAK != 0 || defined (SHIFT_INST_REGS)
1033 /* True if we've hit a breakpoint (as opposed to a watchpoint). */
1034 int real_breakpoint
= 0;
1036 /* Root of the chain of bpstat's */
1037 struct bpstat root_bs
[1];
1038 /* Pointer to the last thing in the chain currently. */
1039 bpstat bs
= root_bs
;
1041 /* Get the address where the breakpoint would have been. */
1042 bp_addr
= *pc
- DECR_PC_AFTER_BREAK
;
1046 if (b
->enable
== disabled
)
1049 if (b
->type
!= bp_watchpoint
&& b
->address
!= bp_addr
)
1052 /* Come here if it's a watchpoint, or if the break address matches */
1054 bs
= bpstat_alloc (b
, bs
); /* Alloc a bpstat to explain stop */
1059 if (b
->type
== bp_watchpoint
)
1061 static char message1
[] =
1062 "Error evaluating expression for watchpoint %d\n";
1063 char message
[sizeof (message1
) + 30 /* slop */];
1064 sprintf (message
, message1
, b
->number
);
1065 switch (catch_errors (watchpoint_check
, (char *) bs
, message
,
1069 /* We've already printed what needs to be printed. */
1070 bs
->print_it
= print_it_done
;
1073 case WP_VALUE_CHANGED
:
1076 case WP_VALUE_NOT_CHANGED
:
1078 bs
->print_it
= print_it_noop
;
1085 /* Error from catch_errors. */
1086 b
->enable
= disabled
;
1087 printf_filtered ("Watchpoint %d disabled.\n", b
->number
);
1088 /* We've already printed what needs to be printed. */
1089 bs
->print_it
= print_it_done
;
1094 #if DECR_PC_AFTER_BREAK != 0 || defined (SHIFT_INST_REGS)
1096 real_breakpoint
= 1;
1099 if (b
->frame
&& b
->frame
!= frame_address
)
1103 int value_is_zero
= 0;
1107 /* Need to select the frame, with all that implies
1108 so that the conditions will have the right context. */
1109 select_frame (get_current_frame (), 0);
1111 = catch_errors (breakpoint_cond_eval
, (char *)(b
->cond
),
1112 "Error in testing breakpoint condition:\n",
1114 /* FIXME-someday, should give breakpoint # */
1117 if (b
->cond
&& value_is_zero
)
1121 else if (b
->ignore_count
> 0)
1128 /* We will stop here */
1129 if (b
->disposition
== disable
)
1130 b
->enable
= disabled
;
1131 bs
->commands
= b
->commands
;
1134 if (bs
->commands
&& STREQ ("silent", bs
->commands
->line
))
1136 bs
->commands
= bs
->commands
->next
;
1141 /* Print nothing for this entry if we dont stop or if we dont print. */
1142 if (bs
->stop
== 0 || bs
->print
== 0)
1143 bs
->print_it
= print_it_noop
;
1146 bs
->next
= NULL
; /* Terminate the chain */
1147 bs
= root_bs
->next
; /* Re-grab the head of the chain */
1148 #if DECR_PC_AFTER_BREAK != 0 || defined (SHIFT_INST_REGS)
1151 if (real_breakpoint
)
1154 #if defined (SHIFT_INST_REGS)
1156 CORE_ADDR pc
= read_register (PC_REGNUM
);
1157 CORE_ADDR npc
= read_register (NPC_REGNUM
);
1160 write_register (NNPC_REGNUM
, npc
);
1161 write_register (NPC_REGNUM
, pc
);
1164 #else /* No SHIFT_INST_REGS. */
1166 #endif /* No SHIFT_INST_REGS. */
1169 #endif /* DECR_PC_AFTER_BREAK != 0. */
1173 /* Tell what to do about this bpstat. */
1178 /* Classify each bpstat as one of the following. */
1180 /* This bpstat element has no effect on the main_action. */
1183 /* There was a watchpoint, stop but don't print. */
1186 /* There was a watchpoint, stop and print. */
1189 /* There was a breakpoint but we're not stopping. */
1192 /* There was a breakpoint, stop but don't print. */
1195 /* There was a breakpoint, stop and print. */
1198 /* We hit the longjmp breakpoint. */
1201 /* We hit the longjmp_resume breakpoint. */
1204 /* This is just used to count how many enums there are. */
1208 /* Here is the table which drives this routine. So that we can
1209 format it pretty, we define some abbreviations for the
1210 enum bpstat_what codes. */
1211 #define keep_c BPSTAT_WHAT_KEEP_CHECKING
1212 #define stop_s BPSTAT_WHAT_STOP_SILENT
1213 #define stop_n BPSTAT_WHAT_STOP_NOISY
1214 #define single BPSTAT_WHAT_SINGLE
1215 #define setlr BPSTAT_WHAT_SET_LONGJMP_RESUME
1216 #define clrlr BPSTAT_WHAT_CLEAR_LONGJMP_RESUME
1217 #define clrlrs BPSTAT_WHAT_CLEAR_LONGJMP_RESUME_SINGLE
1218 /* "Can't happen." Might want to print an error message.
1219 abort() is not out of the question, but chances are GDB is just
1220 a bit confused, not unusable. */
1221 #define err BPSTAT_WHAT_STOP_NOISY
1223 /* Given an old action and a class, come up with a new action. */
1224 /* One interesting property of this table is that wp_silent is the same
1225 as bp_silent and wp_noisy is the same as bp_noisy. That is because
1226 after stopping, the check for whether to step over a breakpoint
1227 (BPSTAT_WHAT_SINGLE type stuff) is handled in proceed() without
1228 reference to how we stopped. We retain separate wp_silent and bp_silent
1229 codes in case we want to change that someday. */
1230 static const enum bpstat_what_main_action
1231 table
[(int)class_last
][(int)BPSTAT_WHAT_LAST
] =
1234 /* keep_c stop_s stop_n single setlr clrlr clrlrs */
1236 /*no_effect*/ {keep_c
, stop_s
, stop_n
, single
, setlr
, clrlr
, clrlrs
},
1237 /*wp_silent*/ {stop_s
, stop_s
, stop_n
, stop_s
, stop_s
, stop_s
, stop_s
},
1238 /*wp_noisy*/ {stop_n
, stop_n
, stop_n
, stop_n
, stop_n
, stop_n
, stop_n
},
1239 /*bp_nostop*/ {single
, stop_s
, stop_n
, single
, setlr
, clrlrs
, clrlrs
},
1240 /*bp_silent*/ {stop_s
, stop_s
, stop_n
, stop_s
, stop_s
, stop_s
, stop_s
},
1241 /*bp_noisy*/ {stop_n
, stop_n
, stop_n
, stop_n
, stop_n
, stop_n
, stop_n
},
1242 /*long_jump*/ {setlr
, stop_s
, stop_n
, setlr
, err
, err
, err
},
1243 /*long_resume*/ {clrlr
, stop_s
, stop_n
, clrlrs
, err
, err
, err
}
1253 enum bpstat_what_main_action current_action
= BPSTAT_WHAT_KEEP_CHECKING
;
1254 struct bpstat_what retval
;
1256 for (; bs
!= NULL
; bs
= bs
->next
)
1258 enum class bs_class
= no_effect
;
1259 if (bs
->breakpoint_at
== NULL
)
1260 /* I suspect this can happen if it was a momentary breakpoint
1261 which has since been deleted. */
1263 switch (bs
->breakpoint_at
->type
)
1271 bs_class
= bp_noisy
;
1273 bs_class
= bp_silent
;
1276 bs_class
= bp_nostop
;
1282 bs_class
= wp_noisy
;
1284 bs_class
= wp_silent
;
1287 /* There was a watchpoint, but we're not stopping. This requires
1288 no further action. */
1289 bs_class
= no_effect
;
1292 bs_class
= long_jump
;
1294 case bp_longjmp_resume
:
1295 bs_class
= long_resume
;
1297 case bp_step_resume
:
1299 /* Need to temporarily disable this until we can fix the bug
1300 with nexting over a breakpoint with ->stop clear causing
1301 an infinite loop. For now, treat the breakpoint as having
1302 been hit even if the frame is wrong. */
1306 retval
.step_resume
= 1;
1307 /* We don't handle this via the main_action. */
1308 bs_class
= no_effect
;
1312 /* It is for the wrong frame. */
1313 bs_class
= bp_nostop
;
1317 /* Make sure the action is stop (silent or noisy), so infrun.c
1318 pops the dummy frame. */
1319 bs_class
= bp_silent
;
1320 retval
.call_dummy
= 1;
1323 current_action
= table
[(int)bs_class
][(int)current_action
];
1325 retval
.main_action
= current_action
;
1329 /* Nonzero if we should step constantly (e.g. watchpoints on machines
1330 without hardware support). This isn't related to a specific bpstat,
1331 just to things like whether watchpoints are set. */
1334 bpstat_should_step ()
1336 struct breakpoint
*b
;
1338 if (b
->enable
== enabled
&& b
->type
== bp_watchpoint
)
1343 /* Print information on breakpoint number BNUM, or -1 if all.
1344 If WATCHPOINTS is zero, process only breakpoints; if WATCHPOINTS
1345 is nonzero, process only watchpoints. */
1348 breakpoint_1 (bnum
, allflag
)
1352 register struct breakpoint
*b
;
1353 register struct command_line
*l
;
1354 register struct symbol
*sym
;
1355 CORE_ADDR last_addr
= (CORE_ADDR
)-1;
1356 int found_a_breakpoint
= 0;
1357 static char *bptypes
[] = {"breakpoint", "until", "finish", "watchpoint",
1358 "longjmp", "longjmp resume", "step resume",
1360 static char *bpdisps
[] = {"del", "dis", "keep"};
1361 static char bpenables
[] = "ny";
1362 char wrap_indent
[80];
1366 || bnum
== b
->number
)
1368 /* We only print out user settable breakpoints unless the allflag is set. */
1370 && b
->type
!= bp_breakpoint
1371 && b
->type
!= bp_watchpoint
)
1374 if (!found_a_breakpoint
++)
1375 printf_filtered ("Num Type Disp Enb %sWhat\n",
1376 addressprint
? "Address " : "");
1378 printf_filtered ("%-3d %-14s %-4s %-3c ",
1380 bptypes
[(int)b
->type
],
1381 bpdisps
[(int)b
->disposition
],
1382 bpenables
[(int)b
->enable
]);
1383 strcpy (wrap_indent
, " ");
1385 strcat (wrap_indent
, " ");
1389 print_expression (b
->exp
, stdout
);
1396 case bp_longjmp_resume
:
1397 case bp_step_resume
:
1400 printf_filtered ("%s ", local_hex_string_custom(b
->address
, "08"));
1402 last_addr
= b
->address
;
1405 sym
= find_pc_function (b
->address
);
1408 fputs_filtered ("in ", stdout
);
1409 fputs_filtered (SYMBOL_SOURCE_NAME (sym
), stdout
);
1410 wrap_here (wrap_indent
);
1411 fputs_filtered (" at ", stdout
);
1413 fputs_filtered (b
->source_file
, stdout
);
1414 printf_filtered (":%d", b
->line_number
);
1417 print_address_symbolic (b
->address
, stdout
, demangle
, " ");
1421 printf_filtered ("\n");
1424 printf_filtered ("\tstop only in stack frame at %s\n",
1425 local_hex_string(b
->frame
));
1428 printf_filtered ("\tstop only if ");
1429 print_expression (b
->cond
, stdout
);
1430 printf_filtered ("\n");
1432 if (b
->ignore_count
)
1433 printf_filtered ("\tignore next %d hits\n", b
->ignore_count
);
1434 if ((l
= b
->commands
))
1437 fputs_filtered ("\t", stdout
);
1438 fputs_filtered (l
->line
, stdout
);
1439 fputs_filtered ("\n", stdout
);
1444 if (!found_a_breakpoint
)
1447 printf_filtered ("No breakpoints or watchpoints.\n");
1449 printf_filtered ("No breakpoint or watchpoint number %d.\n", bnum
);
1452 /* Compare against (CORE_ADDR)-1 in case some compiler decides
1453 that a comparison of an unsigned with -1 is always false. */
1454 if (last_addr
!= (CORE_ADDR
)-1)
1455 set_next_address (last_addr
);
1460 breakpoints_info (bnum_exp
, from_tty
)
1467 bnum
= parse_and_eval_address (bnum_exp
);
1469 breakpoint_1 (bnum
, 0);
1472 #if MAINTENANCE_CMDS
1476 maintenance_info_breakpoints (bnum_exp
, from_tty
)
1483 bnum
= parse_and_eval_address (bnum_exp
);
1485 breakpoint_1 (bnum
, 1);
1490 /* Print a message describing any breakpoints set at PC. */
1493 describe_other_breakpoints (pc
)
1494 register CORE_ADDR pc
;
1496 register int others
= 0;
1497 register struct breakpoint
*b
;
1500 if (b
->address
== pc
)
1504 printf ("Note: breakpoint%s ", (others
> 1) ? "s" : "");
1506 if (b
->address
== pc
)
1511 (b
->enable
== disabled
) ? " (disabled)" : "",
1512 (others
> 1) ? "," : ((others
== 1) ? " and" : ""));
1514 printf ("also set at pc %s.\n", local_hex_string(pc
));
1518 /* Set the default place to put a breakpoint
1519 for the `break' command with no arguments. */
1522 set_default_breakpoint (valid
, addr
, symtab
, line
)
1525 struct symtab
*symtab
;
1528 default_breakpoint_valid
= valid
;
1529 default_breakpoint_address
= addr
;
1530 default_breakpoint_symtab
= symtab
;
1531 default_breakpoint_line
= line
;
1534 /* Rescan breakpoints at address ADDRESS,
1535 marking the first one as "first" and any others as "duplicates".
1536 This is so that the bpt instruction is only inserted once. */
1539 check_duplicates (address
)
1542 register struct breakpoint
*b
;
1543 register int count
= 0;
1545 if (address
== 0) /* Watchpoints are uninteresting */
1549 if (b
->enable
!= disabled
&& b
->address
== address
)
1552 b
->duplicate
= count
> 1;
1556 /* Low level routine to set a breakpoint.
1557 Takes as args the three things that every breakpoint must have.
1558 Returns the breakpoint object so caller can set other things.
1559 Does not set the breakpoint number!
1560 Does not print anything.
1562 ==> This routine should not be called if there is a chance of later
1563 error(); otherwise it leaves a bogus breakpoint on the chain. Validate
1564 your arguments BEFORE calling this routine! */
1566 static struct breakpoint
*
1567 set_raw_breakpoint (sal
)
1568 struct symtab_and_line sal
;
1570 register struct breakpoint
*b
, *b1
;
1572 b
= (struct breakpoint
*) xmalloc (sizeof (struct breakpoint
));
1573 memset (b
, 0, sizeof (*b
));
1574 b
->address
= sal
.pc
;
1575 if (sal
.symtab
== NULL
)
1576 b
->source_file
= NULL
;
1578 b
->source_file
= savestring (sal
.symtab
->filename
,
1579 strlen (sal
.symtab
->filename
));
1580 b
->line_number
= sal
.line
;
1581 b
->enable
= enabled
;
1584 b
->ignore_count
= 0;
1588 /* Add this breakpoint to the end of the chain
1589 so that a list of breakpoints will come out in order
1590 of increasing numbers. */
1592 b1
= breakpoint_chain
;
1594 breakpoint_chain
= b
;
1602 check_duplicates (sal
.pc
);
1608 create_longjmp_breakpoint(func_name
)
1611 struct symtab_and_line sal
;
1612 struct breakpoint
*b
;
1613 static int internal_breakpoint_number
= -1;
1615 if (func_name
!= NULL
)
1617 struct minimal_symbol
*m
;
1619 m
= lookup_minimal_symbol(func_name
, (struct objfile
*)NULL
);
1621 sal
.pc
= SYMBOL_VALUE_ADDRESS (m
);
1631 b
= set_raw_breakpoint(sal
);
1634 b
->type
= func_name
!= NULL
? bp_longjmp
: bp_longjmp_resume
;
1635 b
->disposition
= donttouch
;
1636 b
->enable
= disabled
;
1639 b
->addr_string
= strsave(func_name
);
1640 b
->number
= internal_breakpoint_number
--;
1643 /* Call this routine when stepping and nexting to enable a breakpoint if we do
1644 a longjmp(). When we hit that breakpoint, call
1645 set_longjmp_resume_breakpoint() to figure out where we are going. */
1648 enable_longjmp_breakpoint()
1650 register struct breakpoint
*b
;
1653 if (b
->type
== bp_longjmp
)
1655 b
->enable
= enabled
;
1656 check_duplicates (b
->address
);
1661 disable_longjmp_breakpoint()
1663 register struct breakpoint
*b
;
1666 if ( b
->type
== bp_longjmp
1667 || b
->type
== bp_longjmp_resume
)
1669 b
->enable
= disabled
;
1670 check_duplicates (b
->address
);
1674 /* Call this after hitting the longjmp() breakpoint. Use this to set a new
1675 breakpoint at the target of the jmp_buf.
1677 FIXME - This ought to be done by setting a temporary breakpoint that gets
1678 deleted automatically...
1682 set_longjmp_resume_breakpoint(pc
, frame
)
1686 register struct breakpoint
*b
;
1689 if (b
->type
== bp_longjmp_resume
)
1692 b
->enable
= enabled
;
1694 b
->frame
= FRAME_FP(frame
);
1697 check_duplicates (b
->address
);
1702 /* Set a breakpoint that will evaporate an end of command
1703 at address specified by SAL.
1704 Restrict it to frame FRAME if FRAME is nonzero. */
1707 set_momentary_breakpoint (sal
, frame
, type
)
1708 struct symtab_and_line sal
;
1712 register struct breakpoint
*b
;
1713 b
= set_raw_breakpoint (sal
);
1715 b
->enable
= enabled
;
1716 b
->disposition
= donttouch
;
1717 b
->frame
= (frame
? FRAME_FP (frame
) : 0);
1723 clear_momentary_breakpoints ()
1725 register struct breakpoint
*b
;
1727 if (b
->disposition
== delete)
1729 delete_breakpoint (b
);
1735 /* Tell the user we have just set a breakpoint B. */
1738 struct breakpoint
*b
;
1743 printf_filtered ("Watchpoint %d: ", b
->number
);
1744 print_expression (b
->exp
, stdout
);
1747 printf_filtered ("Breakpoint %d at %s", b
->number
,
1748 local_hex_string(b
->address
));
1750 printf_filtered (": file %s, line %d.",
1751 b
->source_file
, b
->line_number
);
1756 case bp_longjmp_resume
:
1757 case bp_step_resume
:
1760 printf_filtered ("\n");
1764 /* Nobody calls this currently. */
1765 /* Set a breakpoint from a symtab and line.
1766 If TEMPFLAG is nonzero, it is a temporary breakpoint.
1767 ADDR_STRING is a malloc'd string holding the name of where we are
1768 setting the breakpoint. This is used later to re-set it after the
1769 program is relinked and symbols are reloaded.
1770 Print the same confirmation messages that the breakpoint command prints. */
1773 set_breakpoint (s
, line
, tempflag
, addr_string
)
1779 register struct breakpoint
*b
;
1780 struct symtab_and_line sal
;
1785 resolve_sal_pc (&sal
); /* Might error out */
1786 describe_other_breakpoints (sal
.pc
);
1788 b
= set_raw_breakpoint (sal
);
1789 set_breakpoint_count (breakpoint_count
+ 1);
1790 b
->number
= breakpoint_count
;
1791 b
->type
= bp_breakpoint
;
1793 b
->addr_string
= addr_string
;
1794 b
->enable
= enabled
;
1795 b
->disposition
= tempflag
? delete : donttouch
;
1801 /* Set a breakpoint according to ARG (function, linenum or *address)
1802 and make it temporary if TEMPFLAG is nonzero. */
1805 break_command_1 (arg
, tempflag
, from_tty
)
1807 int tempflag
, from_tty
;
1809 struct symtabs_and_lines sals
;
1810 struct symtab_and_line sal
;
1811 register struct expression
*cond
= 0;
1812 register struct breakpoint
*b
;
1814 /* Pointers in arg to the start, and one past the end, of the condition. */
1815 char *cond_start
= NULL
;
1816 char *cond_end
= NULL
;
1817 /* Pointers in arg to the start, and one past the end,
1818 of the address part. */
1819 char *addr_start
= NULL
;
1820 char *addr_end
= NULL
;
1821 struct cleanup
*old_chain
;
1822 struct cleanup
*canonical_strings_chain
= NULL
;
1823 char **canonical
= (char **)NULL
;
1830 sal
.line
= sal
.pc
= sal
.end
= 0;
1833 /* If no arg given, or if first arg is 'if ', use the default breakpoint. */
1835 if (!arg
|| (arg
[0] == 'i' && arg
[1] == 'f'
1836 && (arg
[2] == ' ' || arg
[2] == '\t')))
1838 if (default_breakpoint_valid
)
1840 sals
.sals
= (struct symtab_and_line
*)
1841 xmalloc (sizeof (struct symtab_and_line
));
1842 sal
.pc
= default_breakpoint_address
;
1843 sal
.line
= default_breakpoint_line
;
1844 sal
.symtab
= default_breakpoint_symtab
;
1849 error ("No default breakpoint address now.");
1855 /* Force almost all breakpoints to be in terms of the
1856 current_source_symtab (which is decode_line_1's default). This
1857 should produce the results we want almost all of the time while
1858 leaving default_breakpoint_* alone. */
1859 if (default_breakpoint_valid
1860 && (!current_source_symtab
1861 || (arg
&& (*arg
== '+' || *arg
== '-'))))
1862 sals
= decode_line_1 (&arg
, 1, default_breakpoint_symtab
,
1863 default_breakpoint_line
, &canonical
);
1865 sals
= decode_line_1 (&arg
, 1, (struct symtab
*)NULL
, 0, &canonical
);
1873 /* Make sure that all storage allocated in decode_line_1 gets freed in case
1874 the following `for' loop errors out. */
1875 old_chain
= make_cleanup (free
, sals
.sals
);
1876 if (canonical
!= (char **)NULL
)
1878 make_cleanup (free
, canonical
);
1879 canonical_strings_chain
= make_cleanup (null_cleanup
, 0);
1880 for (i
= 0; i
< sals
.nelts
; i
++)
1882 if (canonical
[i
] != NULL
)
1883 make_cleanup (free
, canonical
[i
]);
1887 /* Resolve all line numbers to PC's, and verify that conditions
1888 can be parsed, before setting any breakpoints. */
1889 for (i
= 0; i
< sals
.nelts
; i
++)
1891 resolve_sal_pc (&sals
.sals
[i
]);
1895 if (arg
[0] == 'i' && arg
[1] == 'f'
1896 && (arg
[2] == ' ' || arg
[2] == '\t'))
1900 cond
= parse_exp_1 (&arg
, block_for_pc (sals
.sals
[i
].pc
), 0);
1904 error ("Junk at end of arguments.");
1908 /* Remove the canonical strings from the cleanup, they are needed below. */
1909 if (canonical
!= (char **)NULL
)
1910 discard_cleanups (canonical_strings_chain
);
1912 /* Now set all the breakpoints. */
1913 for (i
= 0; i
< sals
.nelts
; i
++)
1918 describe_other_breakpoints (sal
.pc
);
1920 b
= set_raw_breakpoint (sal
);
1921 set_breakpoint_count (breakpoint_count
+ 1);
1922 b
->number
= breakpoint_count
;
1923 b
->type
= bp_breakpoint
;
1926 /* If a canonical line spec is needed use that instead of the
1928 if (canonical
!= (char **)NULL
&& canonical
[i
] != NULL
)
1929 b
->addr_string
= canonical
[i
];
1930 else if (addr_start
)
1931 b
->addr_string
= savestring (addr_start
, addr_end
- addr_start
);
1933 b
->cond_string
= savestring (cond_start
, cond_end
- cond_start
);
1935 b
->enable
= enabled
;
1936 b
->disposition
= tempflag
? delete : donttouch
;
1943 printf ("Multiple breakpoints were set.\n");
1944 printf ("Use the \"delete\" command to delete unwanted breakpoints.\n");
1946 do_cleanups (old_chain
);
1949 /* Helper function for break_command_1 and disassemble_command. */
1952 resolve_sal_pc (sal
)
1953 struct symtab_and_line
*sal
;
1957 if (sal
->pc
== 0 && sal
->symtab
!= 0)
1959 pc
= find_line_pc (sal
->symtab
, sal
->line
);
1961 error ("No line %d in file \"%s\".",
1962 sal
->line
, sal
->symtab
->filename
);
1968 break_command (arg
, from_tty
)
1972 break_command_1 (arg
, 0, from_tty
);
1976 tbreak_command (arg
, from_tty
)
1980 break_command_1 (arg
, 1, from_tty
);
1985 watch_command (arg
, from_tty
)
1989 struct breakpoint
*b
;
1990 struct symtab_and_line sal
;
1991 struct expression
*exp
;
1992 struct block
*exp_valid_block
;
1999 /* Parse arguments. */
2000 innermost_block
= NULL
;
2001 exp
= parse_expression (arg
);
2002 exp_valid_block
= innermost_block
;
2003 val
= evaluate_expression (exp
);
2004 release_value (val
);
2005 if (VALUE_LAZY (val
))
2006 value_fetch_lazy (val
);
2008 /* Now set up the breakpoint. */
2009 b
= set_raw_breakpoint (sal
);
2010 set_breakpoint_count (breakpoint_count
+ 1);
2011 b
->number
= breakpoint_count
;
2012 b
->type
= bp_watchpoint
;
2013 b
->disposition
= donttouch
;
2015 b
->exp_valid_block
= exp_valid_block
;
2018 b
->cond_string
= NULL
;
2019 b
->exp_string
= savestring (arg
, strlen (arg
));
2024 * Helper routine for the until_command routine in infcmd.c. Here
2025 * because it uses the mechanisms of breakpoints.
2029 until_break_command (arg
, from_tty
)
2033 struct symtabs_and_lines sals
;
2034 struct symtab_and_line sal
;
2035 FRAME prev_frame
= get_prev_frame (selected_frame
);
2036 struct breakpoint
*breakpoint
;
2037 struct cleanup
*old_chain
;
2039 clear_proceed_status ();
2041 /* Set a breakpoint where the user wants it and at return from
2044 if (default_breakpoint_valid
)
2045 sals
= decode_line_1 (&arg
, 1, default_breakpoint_symtab
,
2046 default_breakpoint_line
, (char ***)NULL
);
2048 sals
= decode_line_1 (&arg
, 1, (struct symtab
*)NULL
, 0, (char ***)NULL
);
2050 if (sals
.nelts
!= 1)
2051 error ("Couldn't get information on specified line.");
2054 free ((PTR
)sals
.sals
); /* malloc'd, so freed */
2057 error ("Junk at end of arguments.");
2059 resolve_sal_pc (&sal
);
2061 breakpoint
= set_momentary_breakpoint (sal
, selected_frame
, bp_until
);
2063 old_chain
= make_cleanup(delete_breakpoint
, breakpoint
);
2065 /* Keep within the current frame */
2069 struct frame_info
*fi
;
2071 fi
= get_frame_info (prev_frame
);
2072 sal
= find_pc_line (fi
->pc
, 0);
2074 breakpoint
= set_momentary_breakpoint (sal
, prev_frame
, bp_until
);
2075 make_cleanup(delete_breakpoint
, breakpoint
);
2078 proceed (-1, -1, 0);
2079 do_cleanups(old_chain
);
2083 /* These aren't used; I don't konw what they were for. */
2084 /* Set a breakpoint at the catch clause for NAME. */
2086 catch_breakpoint (name
)
2092 disable_catch_breakpoint ()
2097 delete_catch_breakpoint ()
2102 enable_catch_breakpoint ()
2109 struct sal_chain
*next
;
2110 struct symtab_and_line sal
;
2114 /* This isn't used; I don't know what it was for. */
2115 /* For each catch clause identified in ARGS, run FUNCTION
2116 with that clause as an argument. */
2117 static struct symtabs_and_lines
2118 map_catch_names (args
, function
)
2122 register char *p
= args
;
2124 struct symtabs_and_lines sals
;
2126 struct sal_chain
*sal_chain
= 0;
2130 error_no_arg ("one or more catch names");
2138 /* Don't swallow conditional part. */
2139 if (p1
[0] == 'i' && p1
[1] == 'f'
2140 && (p1
[2] == ' ' || p1
[2] == '\t'))
2146 while (isalnum (*p1
) || *p1
== '_' || *p1
== '$')
2150 if (*p1
&& *p1
!= ' ' && *p1
!= '\t')
2151 error ("Arguments must be catch names.");
2157 struct sal_chain
*next
2158 = (struct sal_chain
*)alloca (sizeof (struct sal_chain
));
2159 next
->next
= sal_chain
;
2160 next
->sal
= get_catch_sal (p
);
2165 printf ("No catch clause for exception %s.\n", p
);
2170 while (*p
== ' ' || *p
== '\t') p
++;
2175 /* This shares a lot of code with `print_frame_label_vars' from stack.c. */
2177 static struct symtabs_and_lines
2178 get_catch_sals (this_level_only
)
2179 int this_level_only
;
2181 register struct blockvector
*bl
;
2182 register struct block
*block
;
2183 int index
, have_default
= 0;
2184 struct frame_info
*fi
;
2186 struct symtabs_and_lines sals
;
2187 struct sal_chain
*sal_chain
= 0;
2188 char *blocks_searched
;
2190 /* Not sure whether an error message is always the correct response,
2191 but it's better than a core dump. */
2192 if (selected_frame
== NULL
)
2193 error ("No selected frame.");
2194 block
= get_frame_block (selected_frame
);
2195 fi
= get_frame_info (selected_frame
);
2202 error ("No symbol table info available.\n");
2204 bl
= blockvector_for_pc (BLOCK_END (block
) - 4, &index
);
2205 blocks_searched
= (char *) alloca (BLOCKVECTOR_NBLOCKS (bl
) * sizeof (char));
2206 memset (blocks_searched
, 0, BLOCKVECTOR_NBLOCKS (bl
) * sizeof (char));
2210 CORE_ADDR end
= BLOCK_END (block
) - 4;
2213 if (bl
!= blockvector_for_pc (end
, &index
))
2214 error ("blockvector blotch");
2215 if (BLOCKVECTOR_BLOCK (bl
, index
) != block
)
2216 error ("blockvector botch");
2217 last_index
= BLOCKVECTOR_NBLOCKS (bl
);
2220 /* Don't print out blocks that have gone by. */
2221 while (index
< last_index
2222 && BLOCK_END (BLOCKVECTOR_BLOCK (bl
, index
)) < pc
)
2225 while (index
< last_index
2226 && BLOCK_END (BLOCKVECTOR_BLOCK (bl
, index
)) < end
)
2228 if (blocks_searched
[index
] == 0)
2230 struct block
*b
= BLOCKVECTOR_BLOCK (bl
, index
);
2233 register struct symbol
*sym
;
2235 nsyms
= BLOCK_NSYMS (b
);
2237 for (i
= 0; i
< nsyms
; i
++)
2239 sym
= BLOCK_SYM (b
, i
);
2240 if (STREQ (SYMBOL_NAME (sym
), "default"))
2246 if (SYMBOL_CLASS (sym
) == LOC_LABEL
)
2248 struct sal_chain
*next
= (struct sal_chain
*)
2249 alloca (sizeof (struct sal_chain
));
2250 next
->next
= sal_chain
;
2251 next
->sal
= find_pc_line (SYMBOL_VALUE_ADDRESS (sym
), 0);
2255 blocks_searched
[index
] = 1;
2261 if (sal_chain
&& this_level_only
)
2264 /* After handling the function's top-level block, stop.
2265 Don't continue to its superblock, the block of
2266 per-file symbols. */
2267 if (BLOCK_FUNCTION (block
))
2269 block
= BLOCK_SUPERBLOCK (block
);
2274 struct sal_chain
*tmp_chain
;
2276 /* Count the number of entries. */
2277 for (index
= 0, tmp_chain
= sal_chain
; tmp_chain
;
2278 tmp_chain
= tmp_chain
->next
)
2282 sals
.sals
= (struct symtab_and_line
*)
2283 xmalloc (index
* sizeof (struct symtab_and_line
));
2284 for (index
= 0; sal_chain
; sal_chain
= sal_chain
->next
, index
++)
2285 sals
.sals
[index
] = sal_chain
->sal
;
2291 /* Commands to deal with catching exceptions. */
2294 catch_command_1 (arg
, tempflag
, from_tty
)
2299 /* First, translate ARG into something we can deal with in terms
2302 struct symtabs_and_lines sals
;
2303 struct symtab_and_line sal
;
2304 register struct expression
*cond
= 0;
2305 register struct breakpoint
*b
;
2309 sal
.line
= sal
.pc
= sal
.end
= 0;
2312 /* If no arg given, or if first arg is 'if ', all active catch clauses
2313 are breakpointed. */
2315 if (!arg
|| (arg
[0] == 'i' && arg
[1] == 'f'
2316 && (arg
[2] == ' ' || arg
[2] == '\t')))
2318 /* Grab all active catch clauses. */
2319 sals
= get_catch_sals (0);
2323 /* Grab selected catch clauses. */
2324 error ("catch NAME not implemented");
2326 /* This isn't used; I don't know what it was for. */
2327 sals
= map_catch_names (arg
, catch_breakpoint
);
2335 for (i
= 0; i
< sals
.nelts
; i
++)
2337 resolve_sal_pc (&sals
.sals
[i
]);
2341 if (arg
[0] == 'i' && arg
[1] == 'f'
2342 && (arg
[2] == ' ' || arg
[2] == '\t'))
2343 cond
= parse_exp_1 ((arg
+= 2, &arg
),
2344 block_for_pc (sals
.sals
[i
].pc
), 0);
2346 error ("Junk at end of arguments.");
2351 for (i
= 0; i
< sals
.nelts
; i
++)
2356 describe_other_breakpoints (sal
.pc
);
2358 b
= set_raw_breakpoint (sal
);
2359 set_breakpoint_count (breakpoint_count
+ 1);
2360 b
->number
= breakpoint_count
;
2361 b
->type
= bp_breakpoint
;
2363 b
->enable
= enabled
;
2364 b
->disposition
= tempflag
? delete : donttouch
;
2371 printf ("Multiple breakpoints were set.\n");
2372 printf ("Use the \"delete\" command to delete unwanted breakpoints.\n");
2374 free ((PTR
)sals
.sals
);
2378 /* These aren't used; I don't know what they were for. */
2379 /* Disable breakpoints on all catch clauses described in ARGS. */
2381 disable_catch (args
)
2384 /* Map the disable command to catch clauses described in ARGS. */
2387 /* Enable breakpoints on all catch clauses described in ARGS. */
2392 /* Map the disable command to catch clauses described in ARGS. */
2395 /* Delete breakpoints on all catch clauses in the active scope. */
2400 /* Map the delete command to catch clauses described in ARGS. */
2405 catch_command (arg
, from_tty
)
2409 catch_command_1 (arg
, 0, from_tty
);
2413 clear_command (arg
, from_tty
)
2417 register struct breakpoint
*b
, *b1
;
2418 struct symtabs_and_lines sals
;
2419 struct symtab_and_line sal
;
2420 register struct breakpoint
*found
;
2425 sals
= decode_line_spec (arg
, 1);
2429 sals
.sals
= (struct symtab_and_line
*) xmalloc (sizeof (struct symtab_and_line
));
2430 sal
.line
= default_breakpoint_line
;
2431 sal
.symtab
= default_breakpoint_symtab
;
2433 if (sal
.symtab
== 0)
2434 error ("No source file specified.");
2440 for (i
= 0; i
< sals
.nelts
; i
++)
2442 /* If exact pc given, clear bpts at that pc.
2443 But if sal.pc is zero, clear all bpts on specified line. */
2445 found
= (struct breakpoint
*) 0;
2446 while (breakpoint_chain
2448 ? breakpoint_chain
->address
== sal
.pc
2449 : (breakpoint_chain
->source_file
!= NULL
2450 && sal
.symtab
!= NULL
2451 && STREQ (breakpoint_chain
->source_file
,
2452 sal
.symtab
->filename
)
2453 && breakpoint_chain
->line_number
== sal
.line
)))
2455 b1
= breakpoint_chain
;
2456 breakpoint_chain
= b1
->next
;
2463 && b
->next
->type
!= bp_watchpoint
2465 ? b
->next
->address
== sal
.pc
2466 : (b
->next
->source_file
!= NULL
2467 && sal
.symtab
!= NULL
2468 && STREQ (b
->next
->source_file
, sal
.symtab
->filename
)
2469 && b
->next
->line_number
== sal
.line
)))
2480 error ("No breakpoint at %s.", arg
);
2482 error ("No breakpoint at this line.");
2485 if (found
->next
) from_tty
= 1; /* Always report if deleted more than one */
2486 if (from_tty
) printf ("Deleted breakpoint%s ", found
->next
? "s" : "");
2489 if (from_tty
) printf ("%d ", found
->number
);
2491 delete_breakpoint (found
);
2494 if (from_tty
) putchar ('\n');
2496 free ((PTR
)sals
.sals
);
2499 /* Delete breakpoint in BS if they are `delete' breakpoints.
2500 This is called after any breakpoint is hit, or after errors. */
2503 breakpoint_auto_delete (bs
)
2506 for (; bs
; bs
= bs
->next
)
2507 if (bs
->breakpoint_at
&& bs
->breakpoint_at
->disposition
== delete)
2508 delete_breakpoint (bs
->breakpoint_at
);
2511 /* Delete a breakpoint and clean up all traces of it in the data structures. */
2514 delete_breakpoint (bpt
)
2515 struct breakpoint
*bpt
;
2517 register struct breakpoint
*b
;
2521 target_remove_breakpoint(bpt
->address
, bpt
->shadow_contents
);
2523 if (breakpoint_chain
== bpt
)
2524 breakpoint_chain
= bpt
->next
;
2529 b
->next
= bpt
->next
;
2533 check_duplicates (bpt
->address
);
2534 /* If this breakpoint was inserted, and there is another breakpoint
2535 at the same address, we need to insert the other breakpoint. */
2539 if (b
->address
== bpt
->address
&& !b
->duplicate
)
2542 val
= target_insert_breakpoint (b
->address
, b
->shadow_contents
);
2545 fprintf (stderr
, "Cannot insert breakpoint %d:\n", b
->number
);
2546 memory_error (val
, b
->address
); /* which bombs us out */
2553 free_command_lines (&bpt
->commands
);
2556 if (bpt
->cond_string
!= NULL
)
2557 free (bpt
->cond_string
);
2558 if (bpt
->addr_string
!= NULL
)
2559 free (bpt
->addr_string
);
2560 if (bpt
->exp_string
!= NULL
)
2561 free (bpt
->exp_string
);
2562 if (bpt
->source_file
!= NULL
)
2563 free (bpt
->source_file
);
2565 if (xgdb_verbose
&& bpt
->type
== bp_breakpoint
)
2566 printf ("breakpoint #%d deleted\n", bpt
->number
);
2568 /* Be sure no bpstat's are pointing at it after it's been freed. */
2569 /* FIXME, how can we find all bpstat's? We just check stop_bpstat for now. */
2570 for (bs
= stop_bpstat
; bs
; bs
= bs
->next
)
2571 if (bs
->breakpoint_at
== bpt
)
2572 bs
->breakpoint_at
= NULL
;
2577 delete_command (arg
, from_tty
)
2584 /* Ask user only if there are some breakpoints to delete. */
2586 || (breakpoint_chain
&& query ("Delete all breakpoints? ", 0, 0)))
2588 /* No arg; clear all breakpoints. */
2589 while (breakpoint_chain
)
2590 delete_breakpoint (breakpoint_chain
);
2594 map_breakpoint_numbers (arg
, delete_breakpoint
);
2597 /* Reset a breakpoint given it's struct breakpoint * BINT.
2598 The value we return ends up being the return value from catch_errors.
2599 Unused in this case. */
2602 breakpoint_re_set_one (bint
)
2605 struct breakpoint
*b
= (struct breakpoint
*)bint
; /* get past catch_errs */
2607 struct symtabs_and_lines sals
;
2609 enum enable save_enable
;
2614 if (b
->addr_string
== NULL
)
2616 /* Anything without a string can't be re-set. */
2617 delete_breakpoint (b
);
2620 /* In case we have a problem, disable this breakpoint. We'll restore
2621 its status if we succeed. */
2622 save_enable
= b
->enable
;
2623 b
->enable
= disabled
;
2626 sals
= decode_line_1 (&s
, 1, (struct symtab
*)NULL
, 0, (char ***)NULL
);
2627 for (i
= 0; i
< sals
.nelts
; i
++)
2629 resolve_sal_pc (&sals
.sals
[i
]);
2631 /* Reparse conditions, they might contain references to the
2633 if (b
->cond_string
!= NULL
)
2637 free ((PTR
)b
->cond
);
2638 b
->cond
= parse_exp_1 (&s
, block_for_pc (sals
.sals
[i
].pc
), 0);
2641 /* We need to re-set the breakpoint if the address changes...*/
2642 if (b
->address
!= sals
.sals
[i
].pc
2643 /* ...or new and old breakpoints both have source files, and
2644 the source file name or the line number changes... */
2645 || (b
->source_file
!= NULL
2646 && sals
.sals
[i
].symtab
!= NULL
2647 && (!STREQ (b
->source_file
, sals
.sals
[i
].symtab
->filename
)
2648 || b
->line_number
!= sals
.sals
[i
].line
)
2650 /* ...or we switch between having a source file and not having
2652 || ((b
->source_file
== NULL
) != (sals
.sals
[i
].symtab
== NULL
))
2655 if (b
->source_file
!= NULL
)
2656 free (b
->source_file
);
2657 if (sals
.sals
[i
].symtab
== NULL
)
2658 b
->source_file
= NULL
;
2661 savestring (sals
.sals
[i
].symtab
->filename
,
2662 strlen (sals
.sals
[i
].symtab
->filename
));
2663 b
->line_number
= sals
.sals
[i
].line
;
2664 b
->address
= sals
.sals
[i
].pc
;
2666 check_duplicates (b
->address
);
2670 b
->enable
= save_enable
; /* Restore it, this worked. */
2672 free ((PTR
)sals
.sals
);
2676 innermost_block
= NULL
;
2677 /* The issue arises of what context to evaluate this in. The same
2678 one as when it was set, but what does that mean when symbols have
2679 been re-read? We could save the filename and functionname, but
2680 if the context is more local than that, the best we could do would
2681 be something like how many levels deep and which index at that
2682 particular level, but that's going to be less stable than filenames
2683 or functionnames. */
2684 /* So for now, just use a global context. */
2685 b
->exp
= parse_expression (b
->exp_string
);
2686 b
->exp_valid_block
= innermost_block
;
2687 b
->val
= evaluate_expression (b
->exp
);
2688 release_value (b
->val
);
2689 if (VALUE_LAZY (b
->val
))
2690 value_fetch_lazy (b
->val
);
2692 if (b
->cond_string
!= NULL
)
2695 b
->cond
= parse_exp_1 (&s
, (struct block
*)0, 0);
2697 if (b
->enable
== enabled
)
2702 printf_filtered ("Deleting unknown breakpoint type %d\n", b
->type
);
2707 case bp_longjmp_resume
:
2708 delete_breakpoint (b
);
2715 /* Re-set all breakpoints after symbols have been re-loaded. */
2717 breakpoint_re_set ()
2719 struct breakpoint
*b
, *temp
;
2720 static char message1
[] = "Error in re-setting breakpoint %d:\n";
2721 char message
[sizeof (message1
) + 30 /* slop */];
2723 ALL_BREAKPOINTS_SAFE (b
, temp
)
2725 sprintf (message
, message1
, b
->number
); /* Format possible error msg */
2726 catch_errors (breakpoint_re_set_one
, (char *) b
, message
,
2730 create_longjmp_breakpoint("longjmp");
2731 create_longjmp_breakpoint("_longjmp");
2732 create_longjmp_breakpoint("siglongjmp");
2733 create_longjmp_breakpoint(NULL
);
2736 /* Took this out (temporaliy at least), since it produces an extra
2737 blank line at startup. This messes up the gdbtests. -PB */
2738 /* Blank line to finish off all those mention() messages we just printed. */
2739 printf_filtered ("\n");
2743 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
2744 If from_tty is nonzero, it prints a message to that effect,
2745 which ends with a period (no newline). */
2748 set_ignore_count (bptnum
, count
, from_tty
)
2749 int bptnum
, count
, from_tty
;
2751 register struct breakpoint
*b
;
2757 if (b
->number
== bptnum
)
2759 b
->ignore_count
= count
;
2762 else if (count
== 0)
2763 printf_filtered ("Will stop next time breakpoint %d is reached.",
2765 else if (count
== 1)
2766 printf_filtered ("Will ignore next crossing of breakpoint %d.",
2769 printf_filtered ("Will ignore next %d crossings of breakpoint %d.",
2774 error ("No breakpoint number %d.", bptnum
);
2777 /* Clear the ignore counts of all breakpoints. */
2779 breakpoint_clear_ignore_counts ()
2781 struct breakpoint
*b
;
2784 b
->ignore_count
= 0;
2787 /* Command to set ignore-count of breakpoint N to COUNT. */
2790 ignore_command (args
, from_tty
)
2798 error_no_arg ("a breakpoint number");
2800 num
= get_number (&p
);
2803 error ("Second argument (specified ignore-count) is missing.");
2805 set_ignore_count (num
,
2806 longest_to_int (value_as_long (parse_and_eval (p
))),
2808 printf_filtered ("\n");
2811 /* Call FUNCTION on each of the breakpoints
2812 whose numbers are given in ARGS. */
2815 map_breakpoint_numbers (args
, function
)
2817 void (*function
) PARAMS ((struct breakpoint
*));
2819 register char *p
= args
;
2822 register struct breakpoint
*b
;
2825 error_no_arg ("one or more breakpoint numbers");
2831 num
= get_number (&p1
);
2834 if (b
->number
== num
)
2839 printf ("No breakpoint number %d.\n", num
);
2846 enable_breakpoint (bpt
)
2847 struct breakpoint
*bpt
;
2849 FRAME save_selected_frame
= NULL
;
2850 int save_selected_frame_level
= -1;
2852 bpt
->enable
= enabled
;
2854 if (xgdb_verbose
&& bpt
->type
== bp_breakpoint
)
2855 printf ("breakpoint #%d enabled\n", bpt
->number
);
2857 check_duplicates (bpt
->address
);
2858 if (bpt
->type
== bp_watchpoint
)
2860 if (bpt
->exp_valid_block
!= NULL
)
2862 FRAME fr
= within_scope (bpt
->exp_valid_block
);
2866 Cannot enable watchpoint %d because the block in which its expression\n\
2867 is valid is not currently in scope.\n", bpt
->number
);
2868 bpt
->enable
= disabled
;
2871 save_selected_frame
= selected_frame
;
2872 save_selected_frame_level
= selected_frame_level
;
2873 select_frame (fr
, -1);
2876 value_free (bpt
->val
);
2878 bpt
->val
= evaluate_expression (bpt
->exp
);
2879 release_value (bpt
->val
);
2880 if (VALUE_LAZY (bpt
->val
))
2881 value_fetch_lazy (bpt
->val
);
2883 if (save_selected_frame_level
>= 0)
2884 select_frame (save_selected_frame
, save_selected_frame_level
);
2890 enable_command (args
, from_tty
)
2894 struct breakpoint
*bpt
;
2896 ALL_BREAKPOINTS (bpt
)
2901 enable_breakpoint (bpt
);
2906 map_breakpoint_numbers (args
, enable_breakpoint
);
2910 disable_breakpoint (bpt
)
2911 struct breakpoint
*bpt
;
2913 bpt
->enable
= disabled
;
2915 if (xgdb_verbose
&& bpt
->type
== bp_breakpoint
)
2916 printf_filtered ("breakpoint #%d disabled\n", bpt
->number
);
2918 check_duplicates (bpt
->address
);
2923 disable_command (args
, from_tty
)
2927 register struct breakpoint
*bpt
;
2929 ALL_BREAKPOINTS (bpt
)
2934 disable_breakpoint (bpt
);
2939 map_breakpoint_numbers (args
, disable_breakpoint
);
2943 enable_once_breakpoint (bpt
)
2944 struct breakpoint
*bpt
;
2946 bpt
->enable
= enabled
;
2947 bpt
->disposition
= disable
;
2949 check_duplicates (bpt
->address
);
2954 enable_once_command (args
, from_tty
)
2958 map_breakpoint_numbers (args
, enable_once_breakpoint
);
2962 enable_delete_breakpoint (bpt
)
2963 struct breakpoint
*bpt
;
2965 bpt
->enable
= enabled
;
2966 bpt
->disposition
= delete;
2968 check_duplicates (bpt
->address
);
2973 enable_delete_command (args
, from_tty
)
2977 map_breakpoint_numbers (args
, enable_delete_breakpoint
);
2981 * Use default_breakpoint_'s, or nothing if they aren't valid.
2983 struct symtabs_and_lines
2984 decode_line_spec_1 (string
, funfirstline
)
2988 struct symtabs_and_lines sals
;
2990 error ("Empty line specification.");
2991 if (default_breakpoint_valid
)
2992 sals
= decode_line_1 (&string
, funfirstline
,
2993 default_breakpoint_symtab
, default_breakpoint_line
,
2996 sals
= decode_line_1 (&string
, funfirstline
,
2997 (struct symtab
*)NULL
, 0, (char ***)NULL
);
2999 error ("Junk at end of line specification: %s", string
);
3004 _initialize_breakpoint ()
3006 breakpoint_chain
= 0;
3007 /* Don't bother to call set_breakpoint_count. $bpnum isn't useful
3008 before a breakpoint is set. */
3009 breakpoint_count
= 0;
3011 add_com ("ignore", class_breakpoint
, ignore_command
,
3012 "Set ignore-count of breakpoint number N to COUNT.");
3014 add_com ("commands", class_breakpoint
, commands_command
,
3015 "Set commands to be executed when a breakpoint is hit.\n\
3016 Give breakpoint number as argument after \"commands\".\n\
3017 With no argument, the targeted breakpoint is the last one set.\n\
3018 The commands themselves follow starting on the next line.\n\
3019 Type a line containing \"end\" to indicate the end of them.\n\
3020 Give \"silent\" as the first line to make the breakpoint silent;\n\
3021 then no output is printed when it is hit, except what the commands print.");
3023 add_com ("condition", class_breakpoint
, condition_command
,
3024 "Specify breakpoint number N to break only if COND is true.\n\
3025 N is an integer; COND is an expression to be evaluated whenever\n\
3026 breakpoint N is reached. ");
3028 add_com ("tbreak", class_breakpoint
, tbreak_command
,
3029 "Set a temporary breakpoint. Args like \"break\" command.\n\
3030 Like \"break\" except the breakpoint is only enabled temporarily,\n\
3031 so it will be disabled when hit. Equivalent to \"break\" followed\n\
3032 by using \"enable once\" on the breakpoint number.");
3034 add_prefix_cmd ("enable", class_breakpoint
, enable_command
,
3035 "Enable some breakpoints.\n\
3036 Give breakpoint numbers (separated by spaces) as arguments.\n\
3037 With no subcommand, breakpoints are enabled until you command otherwise.\n\
3038 This is used to cancel the effect of the \"disable\" command.\n\
3039 With a subcommand you can enable temporarily.",
3040 &enablelist
, "enable ", 1, &cmdlist
);
3042 add_abbrev_prefix_cmd ("breakpoints", class_breakpoint
, enable_command
,
3043 "Enable some breakpoints.\n\
3044 Give breakpoint numbers (separated by spaces) as arguments.\n\
3045 This is used to cancel the effect of the \"disable\" command.\n\
3046 May be abbreviated to simply \"enable\".\n",
3047 &enablebreaklist
, "enable breakpoints ", 1, &enablelist
);
3049 add_cmd ("once", no_class
, enable_once_command
,
3050 "Enable breakpoints for one hit. Give breakpoint numbers.\n\
3051 If a breakpoint is hit while enabled in this fashion, it becomes disabled.\n\
3052 See the \"tbreak\" command which sets a breakpoint and enables it once.",
3055 add_cmd ("delete", no_class
, enable_delete_command
,
3056 "Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
3057 If a breakpoint is hit while enabled in this fashion, it is deleted.",
3060 add_cmd ("delete", no_class
, enable_delete_command
,
3061 "Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
3062 If a breakpoint is hit while enabled in this fashion, it is deleted.",
3065 add_cmd ("once", no_class
, enable_once_command
,
3066 "Enable breakpoints for one hit. Give breakpoint numbers.\n\
3067 If a breakpoint is hit while enabled in this fashion, it becomes disabled.\n\
3068 See the \"tbreak\" command which sets a breakpoint and enables it once.",
3071 add_prefix_cmd ("disable", class_breakpoint
, disable_command
,
3072 "Disable some breakpoints.\n\
3073 Arguments are breakpoint numbers with spaces in between.\n\
3074 To disable all breakpoints, give no argument.\n\
3075 A disabled breakpoint is not forgotten, but has no effect until reenabled.",
3076 &disablelist
, "disable ", 1, &cmdlist
);
3077 add_com_alias ("dis", "disable", class_breakpoint
, 1);
3078 add_com_alias ("disa", "disable", class_breakpoint
, 1);
3080 add_cmd ("breakpoints", class_alias
, disable_command
,
3081 "Disable some breakpoints.\n\
3082 Arguments are breakpoint numbers with spaces in between.\n\
3083 To disable all breakpoints, give no argument.\n\
3084 A disabled breakpoint is not forgotten, but has no effect until reenabled.\n\
3085 This command may be abbreviated \"disable\".",
3088 add_prefix_cmd ("delete", class_breakpoint
, delete_command
,
3089 "Delete some breakpoints or auto-display expressions.\n\
3090 Arguments are breakpoint numbers with spaces in between.\n\
3091 To delete all breakpoints, give no argument.\n\
3093 Also a prefix command for deletion of other GDB objects.\n\
3094 The \"unset\" command is also an alias for \"delete\".",
3095 &deletelist
, "delete ", 1, &cmdlist
);
3096 add_com_alias ("d", "delete", class_breakpoint
, 1);
3098 add_cmd ("breakpoints", class_alias
, delete_command
,
3099 "Delete some breakpoints or auto-display expressions.\n\
3100 Arguments are breakpoint numbers with spaces in between.\n\
3101 To delete all breakpoints, give no argument.\n\
3102 This command may be abbreviated \"delete\".",
3105 add_com ("clear", class_breakpoint
, clear_command
,
3106 "Clear breakpoint at specified line or function.\n\
3107 Argument may be line number, function name, or \"*\" and an address.\n\
3108 If line number is specified, all breakpoints in that line are cleared.\n\
3109 If function is specified, breakpoints at beginning of function are cleared.\n\
3110 If an address is specified, breakpoints at that address are cleared.\n\n\
3111 With no argument, clears all breakpoints in the line that the selected frame\n\
3114 See also the \"delete\" command which clears breakpoints by number.");
3116 add_com ("break", class_breakpoint
, break_command
,
3117 "Set breakpoint at specified line or function.\n\
3118 Argument may be line number, function name, or \"*\" and an address.\n\
3119 If line number is specified, break at start of code for that line.\n\
3120 If function is specified, break at start of code for that function.\n\
3121 If an address is specified, break at that exact address.\n\
3122 With no arg, uses current execution address of selected stack frame.\n\
3123 This is useful for breaking on return to a stack frame.\n\
3125 Multiple breakpoints at one place are permitted, and useful if conditional.\n\
3127 Do \"help breakpoints\" for info on other commands dealing with breakpoints.");
3128 add_com_alias ("b", "break", class_run
, 1);
3129 add_com_alias ("br", "break", class_run
, 1);
3130 add_com_alias ("bre", "break", class_run
, 1);
3131 add_com_alias ("brea", "break", class_run
, 1);
3133 add_info ("breakpoints", breakpoints_info
,
3134 "Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
3135 The \"Type\" column indicates one of:\n\
3136 \tbreakpoint - normal breakpoint\n\
3137 \twatchpoint - watchpoint\n\
3138 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
3139 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
3140 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
3141 address and file/line number respectively.\n\n\
3142 Convenience variable \"$_\" and default examine address for \"x\"\n\
3143 are set to the address of the last breakpoint listed.\n\n\
3144 Convenience variable \"$bpnum\" contains the number of the last\n\
3147 #if MAINTENANCE_CMDS
3149 add_cmd ("breakpoints", class_maintenance
, maintenance_info_breakpoints
,
3150 "Status of all breakpoints, or breakpoint number NUMBER.\n\
3151 The \"Type\" column indicates one of:\n\
3152 \tbreakpoint - normal breakpoint\n\
3153 \twatchpoint - watchpoint\n\
3154 \tlongjmp - internal breakpoint used to step through longjmp()\n\
3155 \tlongjmp resume - internal breakpoint at the target of longjmp()\n\
3156 \tuntil - internal breakpoint used by the \"until\" command\n\
3157 \tfinish - internal breakpoint used by the \"finish\" command\n\
3158 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
3159 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
3160 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
3161 address and file/line number respectively.\n\n\
3162 Convenience variable \"$_\" and default examine address for \"x\"\n\
3163 are set to the address of the last breakpoint listed.\n\n\
3164 Convenience variable \"$bpnum\" contains the number of the last\n\
3166 &maintenanceinfolist
);
3168 #endif /* MAINTENANCE_CMDS */
3170 add_com ("catch", class_breakpoint
, catch_command
,
3171 "Set breakpoints to catch exceptions that are raised.\n\
3172 Argument may be a single exception to catch, multiple exceptions\n\
3173 to catch, or the default exception \"default\". If no arguments\n\
3174 are given, breakpoints are set at all exception handlers catch clauses\n\
3175 within the current scope.\n\
3177 A condition specified for the catch applies to all breakpoints set\n\
3178 with this command\n\
3180 Do \"help breakpoints\" for info on other commands dealing with breakpoints.");
3182 add_com ("watch", class_breakpoint
, watch_command
,
3183 "Set a watchpoint for an expression.\n\
3184 A watchpoint stops execution of your program whenever the value of\n\
3185 an expression changes.");
3187 add_info ("watchpoints", breakpoints_info
,
3188 "Synonym for ``info breakpoints''.");
3191 /* OK, when we call objfile_relocate, we need to relocate breakpoints
3192 too. breakpoint_re_set is not a good choice--for example, if
3193 addr_string contains just a line number without a file name the
3194 breakpoint might get set in a different file. In general, there is
3195 no need to go all the way back to the user's string (though this might
3196 work if some effort were made to canonicalize it), since symtabs and
3197 everything except addresses are still valid.
3199 Probably the best way to solve this is to have each breakpoint save
3200 the objfile and the section number that was used to set it (if set
3201 by "*addr", probably it is best to use find_pc_line to get a symtab
3202 and use the objfile and block_line_section for that symtab). Then
3203 objfile_relocate can call fixup_breakpoints with the objfile and
3204 the new_offsets, and it can relocate only the appropriate breakpoints. */
3206 #ifdef IBM6000_TARGET
3207 /* But for now, just kludge it based on the concept that before an
3208 objfile is relocated the breakpoint is below 0x10000000, and afterwards
3209 it is higher, so that way we only relocate each breakpoint once. */
3212 fixup_breakpoints (low
, high
, delta
)
3217 struct breakpoint
*b
;
3221 if (b
->address
>= low
&& b
->address
<= high
)
3222 b
->address
+= delta
;