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((unsigned long) b
->address
));
498 printf (", shadow %s",
499 local_hex_string((unsigned long) b
->shadow_contents
[0]));
501 local_hex_string((unsigned long) b
->shadow_contents
[1]));
502 #endif /* BREAKPOINT_DEBUG */
508 /* Clear the "inserted" flag in all breakpoints. */
511 mark_breakpoints_out ()
513 register struct breakpoint
*b
;
519 /* Clear the "inserted" flag in all breakpoints and delete any breakpoints
520 which should go away between runs of the program. */
523 breakpoint_init_inferior ()
525 register struct breakpoint
*b
, *temp
;
527 ALL_BREAKPOINTS_SAFE (b
, temp
)
531 /* If the call dummy breakpoint is at the entry point it will
532 cause problems when the inferior is rerun, so we better
534 if (b
->type
== bp_call_dummy
)
535 delete_breakpoint (b
);
539 /* breakpoint_here_p (PC) returns 1 if an enabled breakpoint exists at PC.
540 When continuing from a location with a breakpoint,
541 we actually single step once before calling insert_breakpoints. */
544 breakpoint_here_p (pc
)
547 register struct breakpoint
*b
;
550 if (b
->enable
!= disabled
&& b
->address
== pc
)
556 /* bpstat stuff. External routines' interfaces are documented
559 /* Clear a bpstat so that it says we are not at any breakpoint.
560 Also free any storage that is part of a bpstat. */
575 if (p
->old_val
!= NULL
)
576 value_free (p
->old_val
);
583 /* Return a copy of a bpstat. Like "bs1 = bs2" but all storage that
584 is part of the bpstat is copied as well. */
592 bpstat retval
= NULL
;
597 for (; bs
!= NULL
; bs
= bs
->next
)
599 tmp
= (bpstat
) xmalloc (sizeof (*tmp
));
600 memcpy (tmp
, bs
, sizeof (*tmp
));
602 /* This is the first thing in the chain. */
612 /* Find the bpstat associated with this breakpoint */
615 bpstat_find_breakpoint(bsp
, breakpoint
)
617 struct breakpoint
*breakpoint
;
619 if (bsp
== NULL
) return NULL
;
621 for (;bsp
!= NULL
; bsp
= bsp
->next
) {
622 if (bsp
->breakpoint_at
== breakpoint
) return bsp
;
627 /* Return the breakpoint number of the first breakpoint we are stopped
628 at. *BSP upon return is a bpstat which points to the remaining
629 breakpoints stopped at (but which is not guaranteed to be good for
630 anything but further calls to bpstat_num).
631 Return 0 if passed a bpstat which does not indicate any breakpoints. */
637 struct breakpoint
*b
;
640 return 0; /* No more breakpoint values */
643 b
= (*bsp
)->breakpoint_at
;
646 return -1; /* breakpoint that's been deleted since */
648 return b
->number
; /* We have its number */
652 /* Modify BS so that the actions will not be performed. */
655 bpstat_clear_actions (bs
)
658 for (; bs
!= NULL
; bs
= bs
->next
)
661 if (bs
->old_val
!= NULL
)
663 value_free (bs
->old_val
);
669 /* Stub for cleaning up our state if we error-out of a breakpoint command */
672 cleanup_executing_breakpoints (ignore
)
675 executing_breakpoint_commands
= 0;
678 /* Execute all the commands associated with all the breakpoints at this
679 location. Any of these commands could cause the process to proceed
680 beyond this point, etc. We look out for such changes by checking
681 the global "breakpoint_proceeded" after each command. */
684 bpstat_do_actions (bsp
)
688 struct cleanup
*old_chain
;
690 executing_breakpoint_commands
= 1;
691 old_chain
= make_cleanup (cleanup_executing_breakpoints
, 0);
696 breakpoint_proceeded
= 0;
697 for (; bs
!= NULL
; bs
= bs
->next
)
701 char *line
= bs
->commands
->line
;
702 bs
->commands
= bs
->commands
->next
;
703 execute_command (line
, 0);
704 /* If the inferior is proceeded by the command, bomb out now.
705 The bpstat chain has been blown away by wait_for_inferior.
706 But since execution has stopped again, there is a new bpstat
707 to look at, so start over. */
708 if (breakpoint_proceeded
)
713 executing_breakpoint_commands
= 0;
714 discard_cleanups (old_chain
);
717 /* This is the normal print_it function for a bpstat. In the future,
718 much of this logic could (should?) be moved to bpstat_stop_status,
719 by having it set different print_it functions. */
725 /* bs->breakpoint_at can be NULL if it was a momentary breakpoint
726 which has since been deleted. */
727 if (bs
->breakpoint_at
== NULL
728 || (bs
->breakpoint_at
->type
!= bp_breakpoint
729 && bs
->breakpoint_at
->type
!= bp_watchpoint
))
732 if (bs
->breakpoint_at
->type
== bp_breakpoint
)
734 /* I think the user probably only wants to see one breakpoint
735 number, not all of them. */
736 printf_filtered ("\nBreakpoint %d, ", bs
->breakpoint_at
->number
);
740 if (bs
->old_val
!= NULL
)
742 printf_filtered ("\nWatchpoint %d, ", bs
->breakpoint_at
->number
);
743 print_expression (bs
->breakpoint_at
->exp
, stdout
);
744 printf_filtered ("\nOld value = ");
745 value_print (bs
->old_val
, stdout
, 0, Val_pretty_default
);
746 printf_filtered ("\nNew value = ");
747 value_print (bs
->breakpoint_at
->val
, stdout
, 0,
749 printf_filtered ("\n");
750 value_free (bs
->old_val
);
754 /* We can't deal with it. Maybe another member of the bpstat chain can. */
758 /* Print a message indicating what happened. Returns nonzero to
759 say that only the source line should be printed after this (zero
760 return means print the frame as well as the source line). */
761 /* Currently we always return zero. */
771 val
= (*bs
->print_it
) (bs
);
775 /* Maybe another breakpoint in the chain caused us to stop.
776 (Currently all watchpoints go on the bpstat whether hit or
777 not. That probably could (should) be changed, provided care is taken
778 with respect to bpstat_explains_signal). */
780 return bpstat_print (bs
->next
);
782 /* We reached the end of the chain without printing anything. */
786 /* Evaluate the expression EXP and return 1 if value is zero.
787 This is used inside a catch_errors to evaluate the breakpoint condition.
788 The argument is a "struct expression *" that has been cast to char * to
789 make it pass through catch_errors. */
792 breakpoint_cond_eval (exp
)
795 return !value_true (evaluate_expression ((struct expression
*)exp
));
798 /* Allocate a new bpstat and chain it to the current one. */
801 bpstat_alloc (b
, cbs
)
802 register struct breakpoint
*b
;
803 bpstat cbs
; /* Current "bs" value */
807 bs
= (bpstat
) xmalloc (sizeof (*bs
));
809 bs
->breakpoint_at
= b
;
810 /* If the condition is false, etc., don't do the commands. */
813 bs
->print_it
= print_it_normal
;
817 /* Return the frame which we can use to evaluate the expression
818 whose valid block is valid_block, or NULL if not in scope.
820 This whole concept is probably not the way to do things (it is incredibly
821 slow being the main reason, not to mention fragile (e.g. the sparc
822 frame pointer being fetched as 0 bug causes it to stop)). Instead,
823 introduce a version of "struct frame" which survives over calls to the
824 inferior, but which is better than FRAME_ADDR in the sense that it lets
825 us evaluate expressions relative to that frame (on some machines, it
826 can just be a FRAME_ADDR). Save one of those instead of (or in addition
827 to) the exp_valid_block, and then use it to evaluate the watchpoint
828 expression, with no need to do all this backtracing every time.
830 Or better yet, what if it just copied the struct frame and its next
831 frame? Off the top of my head, I would think that would work
832 because things like (a29k) rsize and msize, or (sparc) bottom just
833 depend on the frame, and aren't going to be different just because
834 the inferior has done something. Trying to recalculate them
835 strikes me as a lot of work, possibly even impossible. Saving the
836 next frame is needed at least on a29k, where get_saved_register
837 uses fi->next->saved_msp. For figuring out whether that frame is
838 still on the stack, I guess this needs to be machine-specific (e.g.
841 read_fp () INNER_THAN watchpoint_frame->frame
843 would generally work.
845 Of course the scope of the expression could be less than a whole
846 function; perhaps if the innermost frame is the one which the
847 watchpoint is relative to (another machine-specific thing, usually
849 FRAMELESS_FUNCTION_INVOCATION (get_current_frame(), fromleaf)
850 read_fp () == wp_frame->frame
853 ), *then* it could do a
855 contained_in (get_current_block (), wp->exp_valid_block).
860 within_scope (valid_block
)
861 struct block
*valid_block
;
863 FRAME fr
= get_current_frame ();
864 struct frame_info
*fi
= get_frame_info (fr
);
865 CORE_ADDR func_start
;
867 /* If caller_pc_valid is true, we are stepping through
868 a function prologue, which is bounded by callee_func_start
869 (inclusive) and callee_prologue_end (exclusive).
870 caller_pc is the pc of the caller.
872 Yes, this is hairy. */
873 static int caller_pc_valid
= 0;
874 static CORE_ADDR caller_pc
;
875 static CORE_ADDR callee_func_start
;
876 static CORE_ADDR callee_prologue_end
;
878 find_pc_partial_function (fi
->pc
, (PTR
)NULL
, &func_start
, (CORE_ADDR
*)NULL
);
879 func_start
+= FUNCTION_START_OFFSET
;
880 if (fi
->pc
== func_start
)
882 /* We just called a function. The only other case I
883 can think of where the pc would equal the pc of the
884 start of a function is a frameless function (i.e.
885 no prologue) where we branch back to the start
886 of the function. In that case, SKIP_PROLOGUE won't
887 find one, and we'll clear caller_pc_valid a few lines
890 caller_pc
= SAVED_PC_AFTER_CALL (fr
);
891 callee_func_start
= func_start
;
892 SKIP_PROLOGUE (func_start
);
893 callee_prologue_end
= func_start
;
897 if (fi
->pc
< callee_func_start
898 || fi
->pc
>= callee_prologue_end
)
902 if (contained_in (block_for_pc (caller_pc_valid
909 fr
= get_prev_frame (fr
);
911 /* If any active frame is in the exp_valid_block, then it's
912 OK. Note that this might not be the same invocation of
913 the exp_valid_block that we were watching a little while
914 ago, or the same one as when the watchpoint was set (e.g.
915 we are watching a local variable in a recursive function.
916 When we return from a recursive invocation, then we are
917 suddenly watching a different instance of the variable).
919 At least for now I am going to consider this a feature. */
920 for (; fr
!= NULL
; fr
= get_prev_frame (fr
))
922 fi
= get_frame_info (fr
);
923 if (contained_in (block_for_pc (fi
->pc
),
932 /* Possible return values for watchpoint_check (this can't be an enum
933 because of check_errors). */
934 /* The watchpoint has been disabled. */
935 #define WP_DISABLED 1
936 /* The value has changed. */
937 #define WP_VALUE_CHANGED 2
938 /* The value has not changed. */
939 #define WP_VALUE_NOT_CHANGED 3
941 /* Check watchpoint condition. */
946 bpstat bs
= (bpstat
) p
;
949 int within_current_scope
;
950 if (bs
->breakpoint_at
->exp_valid_block
== NULL
)
951 within_current_scope
= 1;
954 fr
= within_scope (bs
->breakpoint_at
->exp_valid_block
);
955 within_current_scope
= fr
!= NULL
;
956 if (within_current_scope
)
957 /* If we end up stopping, the current frame will get selected
958 in normal_stop. So this call to select_frame won't affect
960 select_frame (fr
, -1);
963 if (within_current_scope
)
965 /* We use value_{,free_to_}mark because it could be a
966 *long* time before we return to the command level and
967 call free_all_values. We can't call free_all_values because
968 we might be in the middle of evaluating a function call. */
970 value mark
= value_mark ();
971 value new_val
= evaluate_expression (bs
->breakpoint_at
->exp
);
972 if (!value_equal (bs
->breakpoint_at
->val
, new_val
))
974 release_value (new_val
);
975 value_free_to_mark (mark
);
976 bs
->old_val
= bs
->breakpoint_at
->val
;
977 bs
->breakpoint_at
->val
= new_val
;
978 /* We will stop here */
979 return WP_VALUE_CHANGED
;
983 /* Nothing changed, don't do anything. */
984 value_free_to_mark (mark
);
985 /* We won't stop here */
986 return WP_VALUE_NOT_CHANGED
;
991 /* This seems like the only logical thing to do because
992 if we temporarily ignored the watchpoint, then when
993 we reenter the block in which it is valid it contains
994 garbage (in the case of a function, it may have two
995 garbage values, one before and one after the prologue).
996 So we can't even detect the first assignment to it and
997 watch after that (since the garbage may or may not equal
998 the first value assigned). */
999 bs
->breakpoint_at
->enable
= disabled
;
1001 Watchpoint %d disabled because the program has left the block in\n\
1002 which its expression is valid.\n", bs
->breakpoint_at
->number
);
1007 /* This is used when everything which needs to be printed has
1008 already been printed. But we still want to print the frame. */
1016 /* This is used when nothing should be printed for this bpstat entry. */
1025 /* Get a bpstat associated with having just stopped at address *PC
1026 and frame address FRAME_ADDRESS. Update *PC to point at the
1027 breakpoint (if we hit a breakpoint). NOT_A_BREAKPOINT is nonzero
1028 if this is known to not be a real breakpoint (it could still be a
1029 watchpoint, though). */
1031 /* Determine whether we stopped at a breakpoint, etc, or whether we
1032 don't understand this stop. Result is a chain of bpstat's such that:
1034 if we don't understand the stop, the result is a null pointer.
1036 if we understand why we stopped, the result is not null.
1038 Each element of the chain refers to a particular breakpoint or
1039 watchpoint at which we have stopped. (We may have stopped for
1040 several reasons concurrently.)
1042 Each element of the chain has valid next, breakpoint_at,
1043 commands, FIXME??? fields.
1048 bpstat_stop_status (pc
, frame_address
, not_a_breakpoint
)
1050 FRAME_ADDR frame_address
;
1051 int not_a_breakpoint
;
1053 register struct breakpoint
*b
;
1055 #if DECR_PC_AFTER_BREAK != 0 || defined (SHIFT_INST_REGS)
1056 /* True if we've hit a breakpoint (as opposed to a watchpoint). */
1057 int real_breakpoint
= 0;
1059 /* Root of the chain of bpstat's */
1060 struct bpstat root_bs
[1];
1061 /* Pointer to the last thing in the chain currently. */
1062 bpstat bs
= root_bs
;
1064 /* Get the address where the breakpoint would have been. */
1065 bp_addr
= *pc
- DECR_PC_AFTER_BREAK
;
1069 if (b
->enable
== disabled
)
1072 if (b
->type
!= bp_watchpoint
&& b
->address
!= bp_addr
)
1075 if (b
->type
!= bp_watchpoint
&& not_a_breakpoint
)
1078 /* Come here if it's a watchpoint, or if the break address matches */
1080 bs
= bpstat_alloc (b
, bs
); /* Alloc a bpstat to explain stop */
1085 if (b
->type
== bp_watchpoint
)
1087 static char message1
[] =
1088 "Error evaluating expression for watchpoint %d\n";
1089 char message
[sizeof (message1
) + 30 /* slop */];
1090 sprintf (message
, message1
, b
->number
);
1091 switch (catch_errors (watchpoint_check
, (char *) bs
, message
,
1095 /* We've already printed what needs to be printed. */
1096 bs
->print_it
= print_it_done
;
1099 case WP_VALUE_CHANGED
:
1102 case WP_VALUE_NOT_CHANGED
:
1104 bs
->print_it
= print_it_noop
;
1111 /* Error from catch_errors. */
1112 b
->enable
= disabled
;
1113 printf_filtered ("Watchpoint %d disabled.\n", b
->number
);
1114 /* We've already printed what needs to be printed. */
1115 bs
->print_it
= print_it_done
;
1120 #if DECR_PC_AFTER_BREAK != 0 || defined (SHIFT_INST_REGS)
1122 real_breakpoint
= 1;
1125 if (b
->frame
&& b
->frame
!= frame_address
)
1129 int value_is_zero
= 0;
1133 /* Need to select the frame, with all that implies
1134 so that the conditions will have the right context. */
1135 select_frame (get_current_frame (), 0);
1137 = catch_errors (breakpoint_cond_eval
, (char *)(b
->cond
),
1138 "Error in testing breakpoint condition:\n",
1140 /* FIXME-someday, should give breakpoint # */
1143 if (b
->cond
&& value_is_zero
)
1147 else if (b
->ignore_count
> 0)
1154 /* We will stop here */
1155 if (b
->disposition
== disable
)
1156 b
->enable
= disabled
;
1157 bs
->commands
= b
->commands
;
1160 if (bs
->commands
&& STREQ ("silent", bs
->commands
->line
))
1162 bs
->commands
= bs
->commands
->next
;
1167 /* Print nothing for this entry if we dont stop or if we dont print. */
1168 if (bs
->stop
== 0 || bs
->print
== 0)
1169 bs
->print_it
= print_it_noop
;
1172 bs
->next
= NULL
; /* Terminate the chain */
1173 bs
= root_bs
->next
; /* Re-grab the head of the chain */
1174 #if DECR_PC_AFTER_BREAK != 0 || defined (SHIFT_INST_REGS)
1177 if (real_breakpoint
)
1180 #if defined (SHIFT_INST_REGS)
1182 #else /* No SHIFT_INST_REGS. */
1184 #endif /* No SHIFT_INST_REGS. */
1187 #endif /* DECR_PC_AFTER_BREAK != 0. */
1191 /* Tell what to do about this bpstat. */
1196 /* Classify each bpstat as one of the following. */
1198 /* This bpstat element has no effect on the main_action. */
1201 /* There was a watchpoint, stop but don't print. */
1204 /* There was a watchpoint, stop and print. */
1207 /* There was a breakpoint but we're not stopping. */
1210 /* There was a breakpoint, stop but don't print. */
1213 /* There was a breakpoint, stop and print. */
1216 /* We hit the longjmp breakpoint. */
1219 /* We hit the longjmp_resume breakpoint. */
1222 /* This is just used to count how many enums there are. */
1226 /* Here is the table which drives this routine. So that we can
1227 format it pretty, we define some abbreviations for the
1228 enum bpstat_what codes. */
1229 #define keep_c BPSTAT_WHAT_KEEP_CHECKING
1230 #define stop_s BPSTAT_WHAT_STOP_SILENT
1231 #define stop_n BPSTAT_WHAT_STOP_NOISY
1232 #define single BPSTAT_WHAT_SINGLE
1233 #define setlr BPSTAT_WHAT_SET_LONGJMP_RESUME
1234 #define clrlr BPSTAT_WHAT_CLEAR_LONGJMP_RESUME
1235 #define clrlrs BPSTAT_WHAT_CLEAR_LONGJMP_RESUME_SINGLE
1236 /* "Can't happen." Might want to print an error message.
1237 abort() is not out of the question, but chances are GDB is just
1238 a bit confused, not unusable. */
1239 #define err BPSTAT_WHAT_STOP_NOISY
1241 /* Given an old action and a class, come up with a new action. */
1242 /* One interesting property of this table is that wp_silent is the same
1243 as bp_silent and wp_noisy is the same as bp_noisy. That is because
1244 after stopping, the check for whether to step over a breakpoint
1245 (BPSTAT_WHAT_SINGLE type stuff) is handled in proceed() without
1246 reference to how we stopped. We retain separate wp_silent and bp_silent
1247 codes in case we want to change that someday. */
1248 static const enum bpstat_what_main_action
1249 table
[(int)class_last
][(int)BPSTAT_WHAT_LAST
] =
1252 /* keep_c stop_s stop_n single setlr clrlr clrlrs */
1254 /*no_effect*/ {keep_c
, stop_s
, stop_n
, single
, setlr
, clrlr
, clrlrs
},
1255 /*wp_silent*/ {stop_s
, stop_s
, stop_n
, stop_s
, stop_s
, stop_s
, stop_s
},
1256 /*wp_noisy*/ {stop_n
, stop_n
, stop_n
, stop_n
, stop_n
, stop_n
, stop_n
},
1257 /*bp_nostop*/ {single
, stop_s
, stop_n
, single
, setlr
, clrlrs
, clrlrs
},
1258 /*bp_silent*/ {stop_s
, stop_s
, stop_n
, stop_s
, stop_s
, stop_s
, stop_s
},
1259 /*bp_noisy*/ {stop_n
, stop_n
, stop_n
, stop_n
, stop_n
, stop_n
, stop_n
},
1260 /*long_jump*/ {setlr
, stop_s
, stop_n
, setlr
, err
, err
, err
},
1261 /*long_resume*/ {clrlr
, stop_s
, stop_n
, clrlrs
, err
, err
, err
}
1271 enum bpstat_what_main_action current_action
= BPSTAT_WHAT_KEEP_CHECKING
;
1272 struct bpstat_what retval
;
1274 retval
.call_dummy
= 0;
1275 retval
.step_resume
= 0;
1276 for (; bs
!= NULL
; bs
= bs
->next
)
1278 enum class bs_class
= no_effect
;
1279 if (bs
->breakpoint_at
== NULL
)
1280 /* I suspect this can happen if it was a momentary breakpoint
1281 which has since been deleted. */
1283 switch (bs
->breakpoint_at
->type
)
1291 bs_class
= bp_noisy
;
1293 bs_class
= bp_silent
;
1296 bs_class
= bp_nostop
;
1302 bs_class
= wp_noisy
;
1304 bs_class
= wp_silent
;
1307 /* There was a watchpoint, but we're not stopping. This requires
1308 no further action. */
1309 bs_class
= no_effect
;
1312 bs_class
= long_jump
;
1314 case bp_longjmp_resume
:
1315 bs_class
= long_resume
;
1317 case bp_step_resume
:
1319 /* Need to temporarily disable this until we can fix the bug
1320 with nexting over a breakpoint with ->stop clear causing
1321 an infinite loop. For now, treat the breakpoint as having
1322 been hit even if the frame is wrong. */
1326 retval
.step_resume
= 1;
1327 /* We don't handle this via the main_action. */
1328 bs_class
= no_effect
;
1332 /* It is for the wrong frame. */
1333 bs_class
= bp_nostop
;
1337 /* Make sure the action is stop (silent or noisy), so infrun.c
1338 pops the dummy frame. */
1339 bs_class
= bp_silent
;
1340 retval
.call_dummy
= 1;
1343 current_action
= table
[(int)bs_class
][(int)current_action
];
1345 retval
.main_action
= current_action
;
1349 /* Nonzero if we should step constantly (e.g. watchpoints on machines
1350 without hardware support). This isn't related to a specific bpstat,
1351 just to things like whether watchpoints are set. */
1354 bpstat_should_step ()
1356 struct breakpoint
*b
;
1358 if (b
->enable
== enabled
&& b
->type
== bp_watchpoint
)
1363 /* Print information on breakpoint number BNUM, or -1 if all.
1364 If WATCHPOINTS is zero, process only breakpoints; if WATCHPOINTS
1365 is nonzero, process only watchpoints. */
1368 breakpoint_1 (bnum
, allflag
)
1372 register struct breakpoint
*b
;
1373 register struct command_line
*l
;
1374 register struct symbol
*sym
;
1375 CORE_ADDR last_addr
= (CORE_ADDR
)-1;
1376 int found_a_breakpoint
= 0;
1377 static char *bptypes
[] = {"breakpoint", "until", "finish", "watchpoint",
1378 "longjmp", "longjmp resume", "step resume",
1380 static char *bpdisps
[] = {"del", "dis", "keep"};
1381 static char bpenables
[] = "ny";
1382 char wrap_indent
[80];
1386 || bnum
== b
->number
)
1388 /* We only print out user settable breakpoints unless the allflag is set. */
1390 && b
->type
!= bp_breakpoint
1391 && b
->type
!= bp_watchpoint
)
1394 if (!found_a_breakpoint
++)
1395 printf_filtered ("Num Type Disp Enb %sWhat\n",
1396 addressprint
? "Address " : "");
1398 printf_filtered ("%-3d %-14s %-4s %-3c ",
1400 bptypes
[(int)b
->type
],
1401 bpdisps
[(int)b
->disposition
],
1402 bpenables
[(int)b
->enable
]);
1403 strcpy (wrap_indent
, " ");
1405 strcat (wrap_indent
, " ");
1409 print_expression (b
->exp
, stdout
);
1416 case bp_longjmp_resume
:
1417 case bp_step_resume
:
1420 printf_filtered ("%s ", local_hex_string_custom ((unsigned long) b
->address
, "08l"));
1422 last_addr
= b
->address
;
1425 sym
= find_pc_function (b
->address
);
1428 fputs_filtered ("in ", stdout
);
1429 fputs_filtered (SYMBOL_SOURCE_NAME (sym
), stdout
);
1430 wrap_here (wrap_indent
);
1431 fputs_filtered (" at ", stdout
);
1433 fputs_filtered (b
->source_file
, stdout
);
1434 printf_filtered (":%d", b
->line_number
);
1437 print_address_symbolic (b
->address
, stdout
, demangle
, " ");
1441 printf_filtered ("\n");
1444 printf_filtered ("\tstop only in stack frame at %s\n",
1445 local_hex_string((unsigned long) b
->frame
));
1448 printf_filtered ("\tstop only if ");
1449 print_expression (b
->cond
, stdout
);
1450 printf_filtered ("\n");
1452 if (b
->ignore_count
)
1453 printf_filtered ("\tignore next %d hits\n", b
->ignore_count
);
1454 if ((l
= b
->commands
))
1457 fputs_filtered ("\t", stdout
);
1458 fputs_filtered (l
->line
, stdout
);
1459 fputs_filtered ("\n", stdout
);
1464 if (!found_a_breakpoint
)
1467 printf_filtered ("No breakpoints or watchpoints.\n");
1469 printf_filtered ("No breakpoint or watchpoint number %d.\n", bnum
);
1472 /* Compare against (CORE_ADDR)-1 in case some compiler decides
1473 that a comparison of an unsigned with -1 is always false. */
1474 if (last_addr
!= (CORE_ADDR
)-1)
1475 set_next_address (last_addr
);
1480 breakpoints_info (bnum_exp
, from_tty
)
1487 bnum
= parse_and_eval_address (bnum_exp
);
1489 breakpoint_1 (bnum
, 0);
1492 #if MAINTENANCE_CMDS
1496 maintenance_info_breakpoints (bnum_exp
, from_tty
)
1503 bnum
= parse_and_eval_address (bnum_exp
);
1505 breakpoint_1 (bnum
, 1);
1510 /* Print a message describing any breakpoints set at PC. */
1513 describe_other_breakpoints (pc
)
1514 register CORE_ADDR pc
;
1516 register int others
= 0;
1517 register struct breakpoint
*b
;
1520 if (b
->address
== pc
)
1524 printf ("Note: breakpoint%s ", (others
> 1) ? "s" : "");
1526 if (b
->address
== pc
)
1531 (b
->enable
== disabled
) ? " (disabled)" : "",
1532 (others
> 1) ? "," : ((others
== 1) ? " and" : ""));
1534 printf ("also set at pc %s.\n", local_hex_string((unsigned long) pc
));
1538 /* Set the default place to put a breakpoint
1539 for the `break' command with no arguments. */
1542 set_default_breakpoint (valid
, addr
, symtab
, line
)
1545 struct symtab
*symtab
;
1548 default_breakpoint_valid
= valid
;
1549 default_breakpoint_address
= addr
;
1550 default_breakpoint_symtab
= symtab
;
1551 default_breakpoint_line
= line
;
1554 /* Rescan breakpoints at address ADDRESS,
1555 marking the first one as "first" and any others as "duplicates".
1556 This is so that the bpt instruction is only inserted once. */
1559 check_duplicates (address
)
1562 register struct breakpoint
*b
;
1563 register int count
= 0;
1565 if (address
== 0) /* Watchpoints are uninteresting */
1569 if (b
->enable
!= disabled
&& b
->address
== address
)
1572 b
->duplicate
= count
> 1;
1576 /* Low level routine to set a breakpoint.
1577 Takes as args the three things that every breakpoint must have.
1578 Returns the breakpoint object so caller can set other things.
1579 Does not set the breakpoint number!
1580 Does not print anything.
1582 ==> This routine should not be called if there is a chance of later
1583 error(); otherwise it leaves a bogus breakpoint on the chain. Validate
1584 your arguments BEFORE calling this routine! */
1586 static struct breakpoint
*
1587 set_raw_breakpoint (sal
)
1588 struct symtab_and_line sal
;
1590 register struct breakpoint
*b
, *b1
;
1592 b
= (struct breakpoint
*) xmalloc (sizeof (struct breakpoint
));
1593 memset (b
, 0, sizeof (*b
));
1594 b
->address
= sal
.pc
;
1595 if (sal
.symtab
== NULL
)
1596 b
->source_file
= NULL
;
1598 b
->source_file
= savestring (sal
.symtab
->filename
,
1599 strlen (sal
.symtab
->filename
));
1600 b
->line_number
= sal
.line
;
1601 b
->enable
= enabled
;
1604 b
->ignore_count
= 0;
1608 /* Add this breakpoint to the end of the chain
1609 so that a list of breakpoints will come out in order
1610 of increasing numbers. */
1612 b1
= breakpoint_chain
;
1614 breakpoint_chain
= b
;
1622 check_duplicates (sal
.pc
);
1628 create_longjmp_breakpoint(func_name
)
1631 struct symtab_and_line sal
;
1632 struct breakpoint
*b
;
1633 static int internal_breakpoint_number
= -1;
1635 if (func_name
!= NULL
)
1637 struct minimal_symbol
*m
;
1639 m
= lookup_minimal_symbol(func_name
, (struct objfile
*)NULL
);
1641 sal
.pc
= SYMBOL_VALUE_ADDRESS (m
);
1651 b
= set_raw_breakpoint(sal
);
1654 b
->type
= func_name
!= NULL
? bp_longjmp
: bp_longjmp_resume
;
1655 b
->disposition
= donttouch
;
1656 b
->enable
= disabled
;
1659 b
->addr_string
= strsave(func_name
);
1660 b
->number
= internal_breakpoint_number
--;
1663 /* Call this routine when stepping and nexting to enable a breakpoint if we do
1664 a longjmp(). When we hit that breakpoint, call
1665 set_longjmp_resume_breakpoint() to figure out where we are going. */
1668 enable_longjmp_breakpoint()
1670 register struct breakpoint
*b
;
1673 if (b
->type
== bp_longjmp
)
1675 b
->enable
= enabled
;
1676 check_duplicates (b
->address
);
1681 disable_longjmp_breakpoint()
1683 register struct breakpoint
*b
;
1686 if ( b
->type
== bp_longjmp
1687 || b
->type
== bp_longjmp_resume
)
1689 b
->enable
= disabled
;
1690 check_duplicates (b
->address
);
1694 /* Call this after hitting the longjmp() breakpoint. Use this to set a new
1695 breakpoint at the target of the jmp_buf.
1697 FIXME - This ought to be done by setting a temporary breakpoint that gets
1698 deleted automatically...
1702 set_longjmp_resume_breakpoint(pc
, frame
)
1706 register struct breakpoint
*b
;
1709 if (b
->type
== bp_longjmp_resume
)
1712 b
->enable
= enabled
;
1714 b
->frame
= FRAME_FP(frame
);
1717 check_duplicates (b
->address
);
1722 /* Set a breakpoint that will evaporate an end of command
1723 at address specified by SAL.
1724 Restrict it to frame FRAME if FRAME is nonzero. */
1727 set_momentary_breakpoint (sal
, frame
, type
)
1728 struct symtab_and_line sal
;
1732 register struct breakpoint
*b
;
1733 b
= set_raw_breakpoint (sal
);
1735 b
->enable
= enabled
;
1736 b
->disposition
= donttouch
;
1737 b
->frame
= (frame
? FRAME_FP (frame
) : 0);
1743 clear_momentary_breakpoints ()
1745 register struct breakpoint
*b
;
1747 if (b
->disposition
== delete)
1749 delete_breakpoint (b
);
1755 /* Tell the user we have just set a breakpoint B. */
1758 struct breakpoint
*b
;
1763 printf_filtered ("Watchpoint %d: ", b
->number
);
1764 print_expression (b
->exp
, stdout
);
1767 printf_filtered ("Breakpoint %d at %s", b
->number
,
1768 local_hex_string((unsigned long) b
->address
));
1770 printf_filtered (": file %s, line %d.",
1771 b
->source_file
, b
->line_number
);
1776 case bp_longjmp_resume
:
1777 case bp_step_resume
:
1780 printf_filtered ("\n");
1784 /* Nobody calls this currently. */
1785 /* Set a breakpoint from a symtab and line.
1786 If TEMPFLAG is nonzero, it is a temporary breakpoint.
1787 ADDR_STRING is a malloc'd string holding the name of where we are
1788 setting the breakpoint. This is used later to re-set it after the
1789 program is relinked and symbols are reloaded.
1790 Print the same confirmation messages that the breakpoint command prints. */
1793 set_breakpoint (s
, line
, tempflag
, addr_string
)
1799 register struct breakpoint
*b
;
1800 struct symtab_and_line sal
;
1805 resolve_sal_pc (&sal
); /* Might error out */
1806 describe_other_breakpoints (sal
.pc
);
1808 b
= set_raw_breakpoint (sal
);
1809 set_breakpoint_count (breakpoint_count
+ 1);
1810 b
->number
= breakpoint_count
;
1811 b
->type
= bp_breakpoint
;
1813 b
->addr_string
= addr_string
;
1814 b
->enable
= enabled
;
1815 b
->disposition
= tempflag
? delete : donttouch
;
1821 /* Set a breakpoint according to ARG (function, linenum or *address)
1822 and make it temporary if TEMPFLAG is nonzero. */
1825 break_command_1 (arg
, tempflag
, from_tty
)
1827 int tempflag
, from_tty
;
1829 struct symtabs_and_lines sals
;
1830 struct symtab_and_line sal
;
1831 register struct expression
*cond
= 0;
1832 register struct breakpoint
*b
;
1834 /* Pointers in arg to the start, and one past the end, of the condition. */
1835 char *cond_start
= NULL
;
1836 char *cond_end
= NULL
;
1837 /* Pointers in arg to the start, and one past the end,
1838 of the address part. */
1839 char *addr_start
= NULL
;
1840 char *addr_end
= NULL
;
1841 struct cleanup
*old_chain
;
1842 struct cleanup
*canonical_strings_chain
= NULL
;
1843 char **canonical
= (char **)NULL
;
1850 sal
.line
= sal
.pc
= sal
.end
= 0;
1853 /* If no arg given, or if first arg is 'if ', use the default breakpoint. */
1855 if (!arg
|| (arg
[0] == 'i' && arg
[1] == 'f'
1856 && (arg
[2] == ' ' || arg
[2] == '\t')))
1858 if (default_breakpoint_valid
)
1860 sals
.sals
= (struct symtab_and_line
*)
1861 xmalloc (sizeof (struct symtab_and_line
));
1862 sal
.pc
= default_breakpoint_address
;
1863 sal
.line
= default_breakpoint_line
;
1864 sal
.symtab
= default_breakpoint_symtab
;
1869 error ("No default breakpoint address now.");
1875 /* Force almost all breakpoints to be in terms of the
1876 current_source_symtab (which is decode_line_1's default). This
1877 should produce the results we want almost all of the time while
1878 leaving default_breakpoint_* alone. */
1879 if (default_breakpoint_valid
1880 && (!current_source_symtab
1881 || (arg
&& (*arg
== '+' || *arg
== '-'))))
1882 sals
= decode_line_1 (&arg
, 1, default_breakpoint_symtab
,
1883 default_breakpoint_line
, &canonical
);
1885 sals
= decode_line_1 (&arg
, 1, (struct symtab
*)NULL
, 0, &canonical
);
1893 /* Make sure that all storage allocated in decode_line_1 gets freed in case
1894 the following `for' loop errors out. */
1895 old_chain
= make_cleanup (free
, sals
.sals
);
1896 if (canonical
!= (char **)NULL
)
1898 make_cleanup (free
, canonical
);
1899 canonical_strings_chain
= make_cleanup (null_cleanup
, 0);
1900 for (i
= 0; i
< sals
.nelts
; i
++)
1902 if (canonical
[i
] != NULL
)
1903 make_cleanup (free
, canonical
[i
]);
1907 /* Resolve all line numbers to PC's, and verify that conditions
1908 can be parsed, before setting any breakpoints. */
1909 for (i
= 0; i
< sals
.nelts
; i
++)
1911 resolve_sal_pc (&sals
.sals
[i
]);
1915 if (arg
[0] == 'i' && arg
[1] == 'f'
1916 && (arg
[2] == ' ' || arg
[2] == '\t'))
1920 cond
= parse_exp_1 (&arg
, block_for_pc (sals
.sals
[i
].pc
), 0);
1924 error ("Junk at end of arguments.");
1928 /* Remove the canonical strings from the cleanup, they are needed below. */
1929 if (canonical
!= (char **)NULL
)
1930 discard_cleanups (canonical_strings_chain
);
1932 /* Now set all the breakpoints. */
1933 for (i
= 0; i
< sals
.nelts
; i
++)
1938 describe_other_breakpoints (sal
.pc
);
1940 b
= set_raw_breakpoint (sal
);
1941 set_breakpoint_count (breakpoint_count
+ 1);
1942 b
->number
= breakpoint_count
;
1943 b
->type
= bp_breakpoint
;
1946 /* If a canonical line spec is needed use that instead of the
1948 if (canonical
!= (char **)NULL
&& canonical
[i
] != NULL
)
1949 b
->addr_string
= canonical
[i
];
1950 else if (addr_start
)
1951 b
->addr_string
= savestring (addr_start
, addr_end
- addr_start
);
1953 b
->cond_string
= savestring (cond_start
, cond_end
- cond_start
);
1955 b
->enable
= enabled
;
1956 b
->disposition
= tempflag
? delete : donttouch
;
1963 printf ("Multiple breakpoints were set.\n");
1964 printf ("Use the \"delete\" command to delete unwanted breakpoints.\n");
1966 do_cleanups (old_chain
);
1969 /* Helper function for break_command_1 and disassemble_command. */
1972 resolve_sal_pc (sal
)
1973 struct symtab_and_line
*sal
;
1977 if (sal
->pc
== 0 && sal
->symtab
!= 0)
1979 pc
= find_line_pc (sal
->symtab
, sal
->line
);
1981 error ("No line %d in file \"%s\".",
1982 sal
->line
, sal
->symtab
->filename
);
1988 break_command (arg
, from_tty
)
1992 break_command_1 (arg
, 0, from_tty
);
1996 tbreak_command (arg
, from_tty
)
2000 break_command_1 (arg
, 1, from_tty
);
2005 watch_command (arg
, from_tty
)
2009 struct breakpoint
*b
;
2010 struct symtab_and_line sal
;
2011 struct expression
*exp
;
2012 struct block
*exp_valid_block
;
2019 /* Parse arguments. */
2020 innermost_block
= NULL
;
2021 exp
= parse_expression (arg
);
2022 exp_valid_block
= innermost_block
;
2023 val
= evaluate_expression (exp
);
2024 release_value (val
);
2025 if (VALUE_LAZY (val
))
2026 value_fetch_lazy (val
);
2028 /* Now set up the breakpoint. */
2029 b
= set_raw_breakpoint (sal
);
2030 set_breakpoint_count (breakpoint_count
+ 1);
2031 b
->number
= breakpoint_count
;
2032 b
->type
= bp_watchpoint
;
2033 b
->disposition
= donttouch
;
2035 b
->exp_valid_block
= exp_valid_block
;
2038 b
->cond_string
= NULL
;
2039 b
->exp_string
= savestring (arg
, strlen (arg
));
2044 * Helper routine for the until_command routine in infcmd.c. Here
2045 * because it uses the mechanisms of breakpoints.
2049 until_break_command (arg
, from_tty
)
2053 struct symtabs_and_lines sals
;
2054 struct symtab_and_line sal
;
2055 FRAME prev_frame
= get_prev_frame (selected_frame
);
2056 struct breakpoint
*breakpoint
;
2057 struct cleanup
*old_chain
;
2059 clear_proceed_status ();
2061 /* Set a breakpoint where the user wants it and at return from
2064 if (default_breakpoint_valid
)
2065 sals
= decode_line_1 (&arg
, 1, default_breakpoint_symtab
,
2066 default_breakpoint_line
, (char ***)NULL
);
2068 sals
= decode_line_1 (&arg
, 1, (struct symtab
*)NULL
, 0, (char ***)NULL
);
2070 if (sals
.nelts
!= 1)
2071 error ("Couldn't get information on specified line.");
2074 free ((PTR
)sals
.sals
); /* malloc'd, so freed */
2077 error ("Junk at end of arguments.");
2079 resolve_sal_pc (&sal
);
2081 breakpoint
= set_momentary_breakpoint (sal
, selected_frame
, bp_until
);
2083 old_chain
= make_cleanup(delete_breakpoint
, breakpoint
);
2085 /* Keep within the current frame */
2089 struct frame_info
*fi
;
2091 fi
= get_frame_info (prev_frame
);
2092 sal
= find_pc_line (fi
->pc
, 0);
2094 breakpoint
= set_momentary_breakpoint (sal
, prev_frame
, bp_until
);
2095 make_cleanup(delete_breakpoint
, breakpoint
);
2098 proceed (-1, -1, 0);
2099 do_cleanups(old_chain
);
2103 /* These aren't used; I don't konw what they were for. */
2104 /* Set a breakpoint at the catch clause for NAME. */
2106 catch_breakpoint (name
)
2112 disable_catch_breakpoint ()
2117 delete_catch_breakpoint ()
2122 enable_catch_breakpoint ()
2129 struct sal_chain
*next
;
2130 struct symtab_and_line sal
;
2134 /* This isn't used; I don't know what it was for. */
2135 /* For each catch clause identified in ARGS, run FUNCTION
2136 with that clause as an argument. */
2137 static struct symtabs_and_lines
2138 map_catch_names (args
, function
)
2142 register char *p
= args
;
2144 struct symtabs_and_lines sals
;
2146 struct sal_chain
*sal_chain
= 0;
2150 error_no_arg ("one or more catch names");
2158 /* Don't swallow conditional part. */
2159 if (p1
[0] == 'i' && p1
[1] == 'f'
2160 && (p1
[2] == ' ' || p1
[2] == '\t'))
2166 while (isalnum (*p1
) || *p1
== '_' || *p1
== '$')
2170 if (*p1
&& *p1
!= ' ' && *p1
!= '\t')
2171 error ("Arguments must be catch names.");
2177 struct sal_chain
*next
2178 = (struct sal_chain
*)alloca (sizeof (struct sal_chain
));
2179 next
->next
= sal_chain
;
2180 next
->sal
= get_catch_sal (p
);
2185 printf ("No catch clause for exception %s.\n", p
);
2190 while (*p
== ' ' || *p
== '\t') p
++;
2195 /* This shares a lot of code with `print_frame_label_vars' from stack.c. */
2197 static struct symtabs_and_lines
2198 get_catch_sals (this_level_only
)
2199 int this_level_only
;
2201 register struct blockvector
*bl
;
2202 register struct block
*block
;
2203 int index
, have_default
= 0;
2204 struct frame_info
*fi
;
2206 struct symtabs_and_lines sals
;
2207 struct sal_chain
*sal_chain
= 0;
2208 char *blocks_searched
;
2210 /* Not sure whether an error message is always the correct response,
2211 but it's better than a core dump. */
2212 if (selected_frame
== NULL
)
2213 error ("No selected frame.");
2214 block
= get_frame_block (selected_frame
);
2215 fi
= get_frame_info (selected_frame
);
2222 error ("No symbol table info available.\n");
2224 bl
= blockvector_for_pc (BLOCK_END (block
) - 4, &index
);
2225 blocks_searched
= (char *) alloca (BLOCKVECTOR_NBLOCKS (bl
) * sizeof (char));
2226 memset (blocks_searched
, 0, BLOCKVECTOR_NBLOCKS (bl
) * sizeof (char));
2230 CORE_ADDR end
= BLOCK_END (block
) - 4;
2233 if (bl
!= blockvector_for_pc (end
, &index
))
2234 error ("blockvector blotch");
2235 if (BLOCKVECTOR_BLOCK (bl
, index
) != block
)
2236 error ("blockvector botch");
2237 last_index
= BLOCKVECTOR_NBLOCKS (bl
);
2240 /* Don't print out blocks that have gone by. */
2241 while (index
< last_index
2242 && BLOCK_END (BLOCKVECTOR_BLOCK (bl
, index
)) < pc
)
2245 while (index
< last_index
2246 && BLOCK_END (BLOCKVECTOR_BLOCK (bl
, index
)) < end
)
2248 if (blocks_searched
[index
] == 0)
2250 struct block
*b
= BLOCKVECTOR_BLOCK (bl
, index
);
2253 register struct symbol
*sym
;
2255 nsyms
= BLOCK_NSYMS (b
);
2257 for (i
= 0; i
< nsyms
; i
++)
2259 sym
= BLOCK_SYM (b
, i
);
2260 if (STREQ (SYMBOL_NAME (sym
), "default"))
2266 if (SYMBOL_CLASS (sym
) == LOC_LABEL
)
2268 struct sal_chain
*next
= (struct sal_chain
*)
2269 alloca (sizeof (struct sal_chain
));
2270 next
->next
= sal_chain
;
2271 next
->sal
= find_pc_line (SYMBOL_VALUE_ADDRESS (sym
), 0);
2275 blocks_searched
[index
] = 1;
2281 if (sal_chain
&& this_level_only
)
2284 /* After handling the function's top-level block, stop.
2285 Don't continue to its superblock, the block of
2286 per-file symbols. */
2287 if (BLOCK_FUNCTION (block
))
2289 block
= BLOCK_SUPERBLOCK (block
);
2294 struct sal_chain
*tmp_chain
;
2296 /* Count the number of entries. */
2297 for (index
= 0, tmp_chain
= sal_chain
; tmp_chain
;
2298 tmp_chain
= tmp_chain
->next
)
2302 sals
.sals
= (struct symtab_and_line
*)
2303 xmalloc (index
* sizeof (struct symtab_and_line
));
2304 for (index
= 0; sal_chain
; sal_chain
= sal_chain
->next
, index
++)
2305 sals
.sals
[index
] = sal_chain
->sal
;
2311 /* Commands to deal with catching exceptions. */
2314 catch_command_1 (arg
, tempflag
, from_tty
)
2319 /* First, translate ARG into something we can deal with in terms
2322 struct symtabs_and_lines sals
;
2323 struct symtab_and_line sal
;
2324 register struct expression
*cond
= 0;
2325 register struct breakpoint
*b
;
2329 sal
.line
= sal
.pc
= sal
.end
= 0;
2332 /* If no arg given, or if first arg is 'if ', all active catch clauses
2333 are breakpointed. */
2335 if (!arg
|| (arg
[0] == 'i' && arg
[1] == 'f'
2336 && (arg
[2] == ' ' || arg
[2] == '\t')))
2338 /* Grab all active catch clauses. */
2339 sals
= get_catch_sals (0);
2343 /* Grab selected catch clauses. */
2344 error ("catch NAME not implemented");
2346 /* This isn't used; I don't know what it was for. */
2347 sals
= map_catch_names (arg
, catch_breakpoint
);
2355 for (i
= 0; i
< sals
.nelts
; i
++)
2357 resolve_sal_pc (&sals
.sals
[i
]);
2361 if (arg
[0] == 'i' && arg
[1] == 'f'
2362 && (arg
[2] == ' ' || arg
[2] == '\t'))
2363 cond
= parse_exp_1 ((arg
+= 2, &arg
),
2364 block_for_pc (sals
.sals
[i
].pc
), 0);
2366 error ("Junk at end of arguments.");
2371 for (i
= 0; i
< sals
.nelts
; i
++)
2376 describe_other_breakpoints (sal
.pc
);
2378 b
= set_raw_breakpoint (sal
);
2379 set_breakpoint_count (breakpoint_count
+ 1);
2380 b
->number
= breakpoint_count
;
2381 b
->type
= bp_breakpoint
;
2383 b
->enable
= enabled
;
2384 b
->disposition
= tempflag
? delete : donttouch
;
2391 printf ("Multiple breakpoints were set.\n");
2392 printf ("Use the \"delete\" command to delete unwanted breakpoints.\n");
2394 free ((PTR
)sals
.sals
);
2398 /* These aren't used; I don't know what they were for. */
2399 /* Disable breakpoints on all catch clauses described in ARGS. */
2401 disable_catch (args
)
2404 /* Map the disable command to catch clauses described in ARGS. */
2407 /* Enable breakpoints on all catch clauses described in ARGS. */
2412 /* Map the disable command to catch clauses described in ARGS. */
2415 /* Delete breakpoints on all catch clauses in the active scope. */
2420 /* Map the delete command to catch clauses described in ARGS. */
2425 catch_command (arg
, from_tty
)
2429 catch_command_1 (arg
, 0, from_tty
);
2433 clear_command (arg
, from_tty
)
2437 register struct breakpoint
*b
, *b1
;
2438 struct symtabs_and_lines sals
;
2439 struct symtab_and_line sal
;
2440 register struct breakpoint
*found
;
2445 sals
= decode_line_spec (arg
, 1);
2449 sals
.sals
= (struct symtab_and_line
*) xmalloc (sizeof (struct symtab_and_line
));
2450 sal
.line
= default_breakpoint_line
;
2451 sal
.symtab
= default_breakpoint_symtab
;
2453 if (sal
.symtab
== 0)
2454 error ("No source file specified.");
2460 for (i
= 0; i
< sals
.nelts
; i
++)
2462 /* If exact pc given, clear bpts at that pc.
2463 But if sal.pc is zero, clear all bpts on specified line. */
2465 found
= (struct breakpoint
*) 0;
2466 while (breakpoint_chain
2468 ? breakpoint_chain
->address
== sal
.pc
2469 : (breakpoint_chain
->source_file
!= NULL
2470 && sal
.symtab
!= NULL
2471 && STREQ (breakpoint_chain
->source_file
,
2472 sal
.symtab
->filename
)
2473 && breakpoint_chain
->line_number
== sal
.line
)))
2475 b1
= breakpoint_chain
;
2476 breakpoint_chain
= b1
->next
;
2483 && b
->next
->type
!= bp_watchpoint
2485 ? b
->next
->address
== sal
.pc
2486 : (b
->next
->source_file
!= NULL
2487 && sal
.symtab
!= NULL
2488 && STREQ (b
->next
->source_file
, sal
.symtab
->filename
)
2489 && b
->next
->line_number
== sal
.line
)))
2500 error ("No breakpoint at %s.", arg
);
2502 error ("No breakpoint at this line.");
2505 if (found
->next
) from_tty
= 1; /* Always report if deleted more than one */
2506 if (from_tty
) printf ("Deleted breakpoint%s ", found
->next
? "s" : "");
2509 if (from_tty
) printf ("%d ", found
->number
);
2511 delete_breakpoint (found
);
2514 if (from_tty
) putchar ('\n');
2516 free ((PTR
)sals
.sals
);
2519 /* Delete breakpoint in BS if they are `delete' breakpoints.
2520 This is called after any breakpoint is hit, or after errors. */
2523 breakpoint_auto_delete (bs
)
2526 for (; bs
; bs
= bs
->next
)
2527 if (bs
->breakpoint_at
&& bs
->breakpoint_at
->disposition
== delete
2529 delete_breakpoint (bs
->breakpoint_at
);
2532 /* Delete a breakpoint and clean up all traces of it in the data structures. */
2535 delete_breakpoint (bpt
)
2536 struct breakpoint
*bpt
;
2538 register struct breakpoint
*b
;
2542 target_remove_breakpoint(bpt
->address
, bpt
->shadow_contents
);
2544 if (breakpoint_chain
== bpt
)
2545 breakpoint_chain
= bpt
->next
;
2550 b
->next
= bpt
->next
;
2554 check_duplicates (bpt
->address
);
2555 /* If this breakpoint was inserted, and there is another breakpoint
2556 at the same address, we need to insert the other breakpoint. */
2560 if (b
->address
== bpt
->address
2562 && b
->enable
!= disabled
)
2565 val
= target_insert_breakpoint (b
->address
, b
->shadow_contents
);
2568 fprintf (stderr
, "Cannot insert breakpoint %d:\n", b
->number
);
2569 memory_error (val
, b
->address
); /* which bombs us out */
2576 free_command_lines (&bpt
->commands
);
2579 if (bpt
->cond_string
!= NULL
)
2580 free (bpt
->cond_string
);
2581 if (bpt
->addr_string
!= NULL
)
2582 free (bpt
->addr_string
);
2583 if (bpt
->exp_string
!= NULL
)
2584 free (bpt
->exp_string
);
2585 if (bpt
->source_file
!= NULL
)
2586 free (bpt
->source_file
);
2588 if (xgdb_verbose
&& bpt
->type
== bp_breakpoint
)
2589 printf ("breakpoint #%d deleted\n", bpt
->number
);
2591 /* Be sure no bpstat's are pointing at it after it's been freed. */
2592 /* FIXME, how can we find all bpstat's? We just check stop_bpstat for now. */
2593 for (bs
= stop_bpstat
; bs
; bs
= bs
->next
)
2594 if (bs
->breakpoint_at
== bpt
)
2595 bs
->breakpoint_at
= NULL
;
2600 delete_command (arg
, from_tty
)
2607 /* Ask user only if there are some breakpoints to delete. */
2609 || (breakpoint_chain
&& query ("Delete all breakpoints? ", 0, 0)))
2611 /* No arg; clear all breakpoints. */
2612 while (breakpoint_chain
)
2613 delete_breakpoint (breakpoint_chain
);
2617 map_breakpoint_numbers (arg
, delete_breakpoint
);
2620 /* Reset a breakpoint given it's struct breakpoint * BINT.
2621 The value we return ends up being the return value from catch_errors.
2622 Unused in this case. */
2625 breakpoint_re_set_one (bint
)
2628 struct breakpoint
*b
= (struct breakpoint
*)bint
; /* get past catch_errs */
2630 struct symtabs_and_lines sals
;
2632 enum enable save_enable
;
2637 if (b
->addr_string
== NULL
)
2639 /* Anything without a string can't be re-set. */
2640 delete_breakpoint (b
);
2643 /* In case we have a problem, disable this breakpoint. We'll restore
2644 its status if we succeed. */
2645 save_enable
= b
->enable
;
2646 b
->enable
= disabled
;
2649 sals
= decode_line_1 (&s
, 1, (struct symtab
*)NULL
, 0, (char ***)NULL
);
2650 for (i
= 0; i
< sals
.nelts
; i
++)
2652 resolve_sal_pc (&sals
.sals
[i
]);
2654 /* Reparse conditions, they might contain references to the
2656 if (b
->cond_string
!= NULL
)
2660 free ((PTR
)b
->cond
);
2661 b
->cond
= parse_exp_1 (&s
, block_for_pc (sals
.sals
[i
].pc
), 0);
2664 /* We need to re-set the breakpoint if the address changes...*/
2665 if (b
->address
!= sals
.sals
[i
].pc
2666 /* ...or new and old breakpoints both have source files, and
2667 the source file name or the line number changes... */
2668 || (b
->source_file
!= NULL
2669 && sals
.sals
[i
].symtab
!= NULL
2670 && (!STREQ (b
->source_file
, sals
.sals
[i
].symtab
->filename
)
2671 || b
->line_number
!= sals
.sals
[i
].line
)
2673 /* ...or we switch between having a source file and not having
2675 || ((b
->source_file
== NULL
) != (sals
.sals
[i
].symtab
== NULL
))
2678 if (b
->source_file
!= NULL
)
2679 free (b
->source_file
);
2680 if (sals
.sals
[i
].symtab
== NULL
)
2681 b
->source_file
= NULL
;
2684 savestring (sals
.sals
[i
].symtab
->filename
,
2685 strlen (sals
.sals
[i
].symtab
->filename
));
2686 b
->line_number
= sals
.sals
[i
].line
;
2687 b
->address
= sals
.sals
[i
].pc
;
2689 check_duplicates (b
->address
);
2693 b
->enable
= save_enable
; /* Restore it, this worked. */
2695 free ((PTR
)sals
.sals
);
2699 innermost_block
= NULL
;
2700 /* The issue arises of what context to evaluate this in. The same
2701 one as when it was set, but what does that mean when symbols have
2702 been re-read? We could save the filename and functionname, but
2703 if the context is more local than that, the best we could do would
2704 be something like how many levels deep and which index at that
2705 particular level, but that's going to be less stable than filenames
2706 or functionnames. */
2707 /* So for now, just use a global context. */
2708 b
->exp
= parse_expression (b
->exp_string
);
2709 b
->exp_valid_block
= innermost_block
;
2710 b
->val
= evaluate_expression (b
->exp
);
2711 release_value (b
->val
);
2712 if (VALUE_LAZY (b
->val
))
2713 value_fetch_lazy (b
->val
);
2715 if (b
->cond_string
!= NULL
)
2718 b
->cond
= parse_exp_1 (&s
, (struct block
*)0, 0);
2720 if (b
->enable
== enabled
)
2725 printf_filtered ("Deleting unknown breakpoint type %d\n", b
->type
);
2730 case bp_longjmp_resume
:
2732 delete_breakpoint (b
);
2739 /* Re-set all breakpoints after symbols have been re-loaded. */
2741 breakpoint_re_set ()
2743 struct breakpoint
*b
, *temp
;
2744 static char message1
[] = "Error in re-setting breakpoint %d:\n";
2745 char message
[sizeof (message1
) + 30 /* slop */];
2747 ALL_BREAKPOINTS_SAFE (b
, temp
)
2749 sprintf (message
, message1
, b
->number
); /* Format possible error msg */
2750 catch_errors (breakpoint_re_set_one
, (char *) b
, message
,
2754 create_longjmp_breakpoint("longjmp");
2755 create_longjmp_breakpoint("_longjmp");
2756 create_longjmp_breakpoint("siglongjmp");
2757 create_longjmp_breakpoint(NULL
);
2760 /* Took this out (temporaliy at least), since it produces an extra
2761 blank line at startup. This messes up the gdbtests. -PB */
2762 /* Blank line to finish off all those mention() messages we just printed. */
2763 printf_filtered ("\n");
2767 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
2768 If from_tty is nonzero, it prints a message to that effect,
2769 which ends with a period (no newline). */
2772 set_ignore_count (bptnum
, count
, from_tty
)
2773 int bptnum
, count
, from_tty
;
2775 register struct breakpoint
*b
;
2781 if (b
->number
== bptnum
)
2783 b
->ignore_count
= count
;
2786 else if (count
== 0)
2787 printf_filtered ("Will stop next time breakpoint %d is reached.",
2789 else if (count
== 1)
2790 printf_filtered ("Will ignore next crossing of breakpoint %d.",
2793 printf_filtered ("Will ignore next %d crossings of breakpoint %d.",
2798 error ("No breakpoint number %d.", bptnum
);
2801 /* Clear the ignore counts of all breakpoints. */
2803 breakpoint_clear_ignore_counts ()
2805 struct breakpoint
*b
;
2808 b
->ignore_count
= 0;
2811 /* Command to set ignore-count of breakpoint N to COUNT. */
2814 ignore_command (args
, from_tty
)
2822 error_no_arg ("a breakpoint number");
2824 num
= get_number (&p
);
2827 error ("Second argument (specified ignore-count) is missing.");
2829 set_ignore_count (num
,
2830 longest_to_int (value_as_long (parse_and_eval (p
))),
2832 printf_filtered ("\n");
2835 /* Call FUNCTION on each of the breakpoints
2836 whose numbers are given in ARGS. */
2839 map_breakpoint_numbers (args
, function
)
2841 void (*function
) PARAMS ((struct breakpoint
*));
2843 register char *p
= args
;
2846 register struct breakpoint
*b
;
2849 error_no_arg ("one or more breakpoint numbers");
2855 num
= get_number (&p1
);
2858 if (b
->number
== num
)
2863 printf ("No breakpoint number %d.\n", num
);
2870 enable_breakpoint (bpt
)
2871 struct breakpoint
*bpt
;
2873 FRAME save_selected_frame
= NULL
;
2874 int save_selected_frame_level
= -1;
2876 bpt
->enable
= enabled
;
2878 if (xgdb_verbose
&& bpt
->type
== bp_breakpoint
)
2879 printf ("breakpoint #%d enabled\n", bpt
->number
);
2881 check_duplicates (bpt
->address
);
2882 if (bpt
->type
== bp_watchpoint
)
2884 if (bpt
->exp_valid_block
!= NULL
)
2886 FRAME fr
= within_scope (bpt
->exp_valid_block
);
2890 Cannot enable watchpoint %d because the block in which its expression\n\
2891 is valid is not currently in scope.\n", bpt
->number
);
2892 bpt
->enable
= disabled
;
2895 save_selected_frame
= selected_frame
;
2896 save_selected_frame_level
= selected_frame_level
;
2897 select_frame (fr
, -1);
2900 value_free (bpt
->val
);
2902 bpt
->val
= evaluate_expression (bpt
->exp
);
2903 release_value (bpt
->val
);
2904 if (VALUE_LAZY (bpt
->val
))
2905 value_fetch_lazy (bpt
->val
);
2907 if (save_selected_frame_level
>= 0)
2908 select_frame (save_selected_frame
, save_selected_frame_level
);
2914 enable_command (args
, from_tty
)
2918 struct breakpoint
*bpt
;
2920 ALL_BREAKPOINTS (bpt
)
2925 enable_breakpoint (bpt
);
2930 map_breakpoint_numbers (args
, enable_breakpoint
);
2934 disable_breakpoint (bpt
)
2935 struct breakpoint
*bpt
;
2937 bpt
->enable
= disabled
;
2939 if (xgdb_verbose
&& bpt
->type
== bp_breakpoint
)
2940 printf_filtered ("breakpoint #%d disabled\n", bpt
->number
);
2942 check_duplicates (bpt
->address
);
2947 disable_command (args
, from_tty
)
2951 register struct breakpoint
*bpt
;
2953 ALL_BREAKPOINTS (bpt
)
2958 disable_breakpoint (bpt
);
2963 map_breakpoint_numbers (args
, disable_breakpoint
);
2967 enable_once_breakpoint (bpt
)
2968 struct breakpoint
*bpt
;
2970 bpt
->enable
= enabled
;
2971 bpt
->disposition
= disable
;
2973 check_duplicates (bpt
->address
);
2978 enable_once_command (args
, from_tty
)
2982 map_breakpoint_numbers (args
, enable_once_breakpoint
);
2986 enable_delete_breakpoint (bpt
)
2987 struct breakpoint
*bpt
;
2989 bpt
->enable
= enabled
;
2990 bpt
->disposition
= delete;
2992 check_duplicates (bpt
->address
);
2997 enable_delete_command (args
, from_tty
)
3001 map_breakpoint_numbers (args
, enable_delete_breakpoint
);
3005 * Use default_breakpoint_'s, or nothing if they aren't valid.
3007 struct symtabs_and_lines
3008 decode_line_spec_1 (string
, funfirstline
)
3012 struct symtabs_and_lines sals
;
3014 error ("Empty line specification.");
3015 if (default_breakpoint_valid
)
3016 sals
= decode_line_1 (&string
, funfirstline
,
3017 default_breakpoint_symtab
, default_breakpoint_line
,
3020 sals
= decode_line_1 (&string
, funfirstline
,
3021 (struct symtab
*)NULL
, 0, (char ***)NULL
);
3023 error ("Junk at end of line specification: %s", string
);
3028 _initialize_breakpoint ()
3030 breakpoint_chain
= 0;
3031 /* Don't bother to call set_breakpoint_count. $bpnum isn't useful
3032 before a breakpoint is set. */
3033 breakpoint_count
= 0;
3035 add_com ("ignore", class_breakpoint
, ignore_command
,
3036 "Set ignore-count of breakpoint number N to COUNT.");
3038 add_com ("commands", class_breakpoint
, commands_command
,
3039 "Set commands to be executed when a breakpoint is hit.\n\
3040 Give breakpoint number as argument after \"commands\".\n\
3041 With no argument, the targeted breakpoint is the last one set.\n\
3042 The commands themselves follow starting on the next line.\n\
3043 Type a line containing \"end\" to indicate the end of them.\n\
3044 Give \"silent\" as the first line to make the breakpoint silent;\n\
3045 then no output is printed when it is hit, except what the commands print.");
3047 add_com ("condition", class_breakpoint
, condition_command
,
3048 "Specify breakpoint number N to break only if COND is true.\n\
3049 N is an integer; COND is an expression to be evaluated whenever\n\
3050 breakpoint N is reached. ");
3052 add_com ("tbreak", class_breakpoint
, tbreak_command
,
3053 "Set a temporary breakpoint. Args like \"break\" command.\n\
3054 Like \"break\" except the breakpoint is only enabled temporarily,\n\
3055 so it will be disabled when hit. Equivalent to \"break\" followed\n\
3056 by using \"enable once\" on the breakpoint number.");
3058 add_prefix_cmd ("enable", class_breakpoint
, enable_command
,
3059 "Enable some breakpoints.\n\
3060 Give breakpoint numbers (separated by spaces) as arguments.\n\
3061 With no subcommand, breakpoints are enabled until you command otherwise.\n\
3062 This is used to cancel the effect of the \"disable\" command.\n\
3063 With a subcommand you can enable temporarily.",
3064 &enablelist
, "enable ", 1, &cmdlist
);
3066 add_abbrev_prefix_cmd ("breakpoints", class_breakpoint
, enable_command
,
3067 "Enable some breakpoints.\n\
3068 Give breakpoint numbers (separated by spaces) as arguments.\n\
3069 This is used to cancel the effect of the \"disable\" command.\n\
3070 May be abbreviated to simply \"enable\".\n",
3071 &enablebreaklist
, "enable breakpoints ", 1, &enablelist
);
3073 add_cmd ("once", no_class
, enable_once_command
,
3074 "Enable breakpoints for one hit. Give breakpoint numbers.\n\
3075 If a breakpoint is hit while enabled in this fashion, it becomes disabled.\n\
3076 See the \"tbreak\" command which sets a breakpoint and enables it once.",
3079 add_cmd ("delete", no_class
, enable_delete_command
,
3080 "Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
3081 If a breakpoint is hit while enabled in this fashion, it is deleted.",
3084 add_cmd ("delete", no_class
, enable_delete_command
,
3085 "Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
3086 If a breakpoint is hit while enabled in this fashion, it is deleted.",
3089 add_cmd ("once", no_class
, enable_once_command
,
3090 "Enable breakpoints for one hit. Give breakpoint numbers.\n\
3091 If a breakpoint is hit while enabled in this fashion, it becomes disabled.\n\
3092 See the \"tbreak\" command which sets a breakpoint and enables it once.",
3095 add_prefix_cmd ("disable", class_breakpoint
, disable_command
,
3096 "Disable some breakpoints.\n\
3097 Arguments are breakpoint numbers with spaces in between.\n\
3098 To disable all breakpoints, give no argument.\n\
3099 A disabled breakpoint is not forgotten, but has no effect until reenabled.",
3100 &disablelist
, "disable ", 1, &cmdlist
);
3101 add_com_alias ("dis", "disable", class_breakpoint
, 1);
3102 add_com_alias ("disa", "disable", class_breakpoint
, 1);
3104 add_cmd ("breakpoints", class_alias
, disable_command
,
3105 "Disable some breakpoints.\n\
3106 Arguments are breakpoint numbers with spaces in between.\n\
3107 To disable all breakpoints, give no argument.\n\
3108 A disabled breakpoint is not forgotten, but has no effect until reenabled.\n\
3109 This command may be abbreviated \"disable\".",
3112 add_prefix_cmd ("delete", class_breakpoint
, delete_command
,
3113 "Delete some breakpoints or auto-display expressions.\n\
3114 Arguments are breakpoint numbers with spaces in between.\n\
3115 To delete all breakpoints, give no argument.\n\
3117 Also a prefix command for deletion of other GDB objects.\n\
3118 The \"unset\" command is also an alias for \"delete\".",
3119 &deletelist
, "delete ", 1, &cmdlist
);
3120 add_com_alias ("d", "delete", class_breakpoint
, 1);
3122 add_cmd ("breakpoints", class_alias
, delete_command
,
3123 "Delete some breakpoints or auto-display expressions.\n\
3124 Arguments are breakpoint numbers with spaces in between.\n\
3125 To delete all breakpoints, give no argument.\n\
3126 This command may be abbreviated \"delete\".",
3129 add_com ("clear", class_breakpoint
, clear_command
,
3130 "Clear breakpoint at specified line or function.\n\
3131 Argument may be line number, function name, or \"*\" and an address.\n\
3132 If line number is specified, all breakpoints in that line are cleared.\n\
3133 If function is specified, breakpoints at beginning of function are cleared.\n\
3134 If an address is specified, breakpoints at that address are cleared.\n\n\
3135 With no argument, clears all breakpoints in the line that the selected frame\n\
3138 See also the \"delete\" command which clears breakpoints by number.");
3140 add_com ("break", class_breakpoint
, break_command
,
3141 "Set breakpoint at specified line or function.\n\
3142 Argument may be line number, function name, or \"*\" and an address.\n\
3143 If line number is specified, break at start of code for that line.\n\
3144 If function is specified, break at start of code for that function.\n\
3145 If an address is specified, break at that exact address.\n\
3146 With no arg, uses current execution address of selected stack frame.\n\
3147 This is useful for breaking on return to a stack frame.\n\
3149 Multiple breakpoints at one place are permitted, and useful if conditional.\n\
3151 Do \"help breakpoints\" for info on other commands dealing with breakpoints.");
3152 add_com_alias ("b", "break", class_run
, 1);
3153 add_com_alias ("br", "break", class_run
, 1);
3154 add_com_alias ("bre", "break", class_run
, 1);
3155 add_com_alias ("brea", "break", class_run
, 1);
3157 add_info ("breakpoints", breakpoints_info
,
3158 "Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
3159 The \"Type\" column indicates one of:\n\
3160 \tbreakpoint - normal breakpoint\n\
3161 \twatchpoint - watchpoint\n\
3162 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
3163 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
3164 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
3165 address and file/line number respectively.\n\n\
3166 Convenience variable \"$_\" and default examine address for \"x\"\n\
3167 are set to the address of the last breakpoint listed.\n\n\
3168 Convenience variable \"$bpnum\" contains the number of the last\n\
3171 #if MAINTENANCE_CMDS
3173 add_cmd ("breakpoints", class_maintenance
, maintenance_info_breakpoints
,
3174 "Status of all breakpoints, or breakpoint number NUMBER.\n\
3175 The \"Type\" column indicates one of:\n\
3176 \tbreakpoint - normal breakpoint\n\
3177 \twatchpoint - watchpoint\n\
3178 \tlongjmp - internal breakpoint used to step through longjmp()\n\
3179 \tlongjmp resume - internal breakpoint at the target of longjmp()\n\
3180 \tuntil - internal breakpoint used by the \"until\" command\n\
3181 \tfinish - internal breakpoint used by the \"finish\" command\n\
3182 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
3183 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
3184 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
3185 address and file/line number respectively.\n\n\
3186 Convenience variable \"$_\" and default examine address for \"x\"\n\
3187 are set to the address of the last breakpoint listed.\n\n\
3188 Convenience variable \"$bpnum\" contains the number of the last\n\
3190 &maintenanceinfolist
);
3192 #endif /* MAINTENANCE_CMDS */
3194 add_com ("catch", class_breakpoint
, catch_command
,
3195 "Set breakpoints to catch exceptions that are raised.\n\
3196 Argument may be a single exception to catch, multiple exceptions\n\
3197 to catch, or the default exception \"default\". If no arguments\n\
3198 are given, breakpoints are set at all exception handlers catch clauses\n\
3199 within the current scope.\n\
3201 A condition specified for the catch applies to all breakpoints set\n\
3202 with this command\n\
3204 Do \"help breakpoints\" for info on other commands dealing with breakpoints.");
3206 add_com ("watch", class_breakpoint
, watch_command
,
3207 "Set a watchpoint for an expression.\n\
3208 A watchpoint stops execution of your program whenever the value of\n\
3209 an expression changes.");
3211 add_info ("watchpoints", breakpoints_info
,
3212 "Synonym for ``info breakpoints''.");
3215 /* OK, when we call objfile_relocate, we need to relocate breakpoints
3216 too. breakpoint_re_set is not a good choice--for example, if
3217 addr_string contains just a line number without a file name the
3218 breakpoint might get set in a different file. In general, there is
3219 no need to go all the way back to the user's string (though this might
3220 work if some effort were made to canonicalize it), since symtabs and
3221 everything except addresses are still valid.
3223 Probably the best way to solve this is to have each breakpoint save
3224 the objfile and the section number that was used to set it (if set
3225 by "*addr", probably it is best to use find_pc_line to get a symtab
3226 and use the objfile and block_line_section for that symtab). Then
3227 objfile_relocate can call fixup_breakpoints with the objfile and
3228 the new_offsets, and it can relocate only the appropriate breakpoints. */
3230 #ifdef IBM6000_TARGET
3231 /* But for now, just kludge it based on the concept that before an
3232 objfile is relocated the breakpoint is below 0x10000000, and afterwards
3233 it is higher, so that way we only relocate each breakpoint once. */
3236 fixup_breakpoints (low
, high
, delta
)
3241 struct breakpoint
*b
;
3245 if (b
->address
>= low
&& b
->address
<= high
)
3246 b
->address
+= delta
;