1 /* Everything about breakpoints, for GDB.
2 Copyright 1986, 1987, 1989, 1990, 1991, 1992 Free Software Foundation, Inc.
4 This file is part of GDB.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
24 #include "breakpoint.h"
26 #include "expression.h"
38 /* local function prototypes */
41 catch_command_1
PARAMS ((char *, int, int));
44 enable_delete_command
PARAMS ((char *, int));
47 enable_delete_breakpoint
PARAMS ((struct breakpoint
*));
50 enable_once_command
PARAMS ((char *, int));
53 enable_once_breakpoint
PARAMS ((struct breakpoint
*));
56 disable_command
PARAMS ((char *, int));
59 disable_breakpoint
PARAMS ((struct breakpoint
*));
62 enable_command
PARAMS ((char *, int));
65 enable_breakpoint
PARAMS ((struct breakpoint
*));
68 map_breakpoint_numbers
PARAMS ((char *, void (*)(struct breakpoint
*)));
71 ignore_command
PARAMS ((char *, int));
74 breakpoint_re_set_one
PARAMS ((char *));
77 delete_command
PARAMS ((char *, int));
80 clear_command
PARAMS ((char *, int));
83 catch_command
PARAMS ((char *, int));
85 static struct symtabs_and_lines
86 get_catch_sals
PARAMS ((int));
89 watch_command
PARAMS ((char *, int));
92 tbreak_command
PARAMS ((char *, int));
95 break_command_1
PARAMS ((char *, int, int));
98 mention
PARAMS ((struct breakpoint
*));
100 static struct breakpoint
*
101 set_raw_breakpoint
PARAMS ((struct symtab_and_line
));
104 check_duplicates
PARAMS ((CORE_ADDR
));
107 describe_other_breakpoints
PARAMS ((CORE_ADDR
));
110 breakpoints_info
PARAMS ((char *, int));
113 breakpoint_1
PARAMS ((int, int));
116 bpstat_alloc
PARAMS ((struct breakpoint
*, bpstat
));
119 breakpoint_cond_eval
PARAMS ((char *));
122 cleanup_executing_breakpoints
PARAMS ((int));
125 commands_command
PARAMS ((char *, int));
128 condition_command
PARAMS ((char *, int));
131 get_number
PARAMS ((char **));
134 set_breakpoint_count
PARAMS ((int));
137 extern int addressprint
; /* Print machine addresses? */
138 extern int demangle
; /* Print de-mangled symbol names? */
140 /* Are we executing breakpoint commands? */
141 static int executing_breakpoint_commands
;
143 /* Walk the following statement or block through all breakpoints.
144 ALL_BREAKPOINTS_SAFE does so even if the statment deletes the current
147 #define ALL_BREAKPOINTS(b) for (b = breakpoint_chain; b; b = b->next)
149 #define ALL_BREAKPOINTS_SAFE(b,tmp) \
150 for (b = breakpoint_chain; \
151 b? (tmp=b->next, 1): 0; \
154 /* Chain of all breakpoints defined. */
156 struct breakpoint
*breakpoint_chain
;
158 /* Number of last breakpoint made. */
160 static int breakpoint_count
;
162 /* Set breakpoint count to NUM. */
164 set_breakpoint_count (num
)
167 breakpoint_count
= num
;
168 set_internalvar (lookup_internalvar ("bpnum"),
169 value_from_longest (builtin_type_int
, (LONGEST
) num
));
172 /* Default address, symtab and line to put a breakpoint at
173 for "break" command with no arg.
174 if default_breakpoint_valid is zero, the other three are
175 not valid, and "break" with no arg is an error.
177 This set by print_stack_frame, which calls set_default_breakpoint. */
179 int default_breakpoint_valid
;
180 CORE_ADDR default_breakpoint_address
;
181 struct symtab
*default_breakpoint_symtab
;
182 int default_breakpoint_line
;
184 /* Flag indicating extra verbosity for xgdb. */
185 extern int xgdb_verbose
;
187 /* *PP is a string denoting a breakpoint. Get the number of the breakpoint.
188 Advance *PP after the string and any trailing whitespace.
190 Currently the string can either be a number or "$" followed by the name
191 of a convenience variable. Making it an expression wouldn't work well
192 for map_breakpoint_numbers (e.g. "4 + 5 + 6"). */
201 /* Empty line means refer to the last breakpoint. */
202 return breakpoint_count
;
205 /* Make a copy of the name, so we can null-terminate it
206 to pass to lookup_internalvar(). */
211 while (isalnum (*p
) || *p
== '_')
213 varname
= (char *) alloca (p
- start
+ 1);
214 strncpy (varname
, start
, p
- start
);
215 varname
[p
- start
] = '\0';
216 val
= value_of_internalvar (lookup_internalvar (varname
));
217 if (TYPE_CODE (VALUE_TYPE (val
)) != TYPE_CODE_INT
)
219 "Convenience variables used to specify breakpoints must have integer values."
221 retval
= (int) value_as_long (val
);
227 while (*p
>= '0' && *p
<= '9')
230 /* There is no number here. (e.g. "cond a == b"). */
231 error_no_arg ("breakpoint number");
234 if (!(isspace (*p
) || *p
== '\0'))
235 error ("breakpoint number expected");
242 /* condition N EXP -- set break condition of breakpoint N to EXP. */
245 condition_command (arg
, from_tty
)
249 register struct breakpoint
*b
;
254 error_no_arg ("breakpoint number");
257 bnum
= get_number (&p
);
260 if (b
->number
== bnum
)
267 if (b
->cond_string
!= NULL
)
268 free ((PTR
)b
->cond_string
);
273 b
->cond_string
= NULL
;
275 printf_filtered ("Breakpoint %d now unconditional.\n", bnum
);
280 /* I don't know if it matters whether this is the string the user
281 typed in or the decompiled expression. */
282 b
->cond_string
= savestring (arg
, strlen (arg
));
283 b
->cond
= parse_exp_1 (&arg
, block_for_pc (b
->address
), 0);
285 error ("Junk at end of expression");
290 error ("No breakpoint number %d.", bnum
);
295 commands_command (arg
, from_tty
)
299 register struct breakpoint
*b
;
302 struct command_line
*l
;
304 /* If we allowed this, we would have problems with when to
305 free the storage, if we change the commands currently
308 if (executing_breakpoint_commands
)
309 error ("Can't use the \"commands\" command among a breakpoint's commands.");
312 bnum
= get_number (&p
);
314 error ("Unexpected extra arguments following breakpoint number.");
317 if (b
->number
== bnum
)
319 if (from_tty
&& input_from_terminal_p ())
320 printf_filtered ("Type commands for when breakpoint %d is hit, one per line.\n\
321 End with a line saying just \"end\".\n", bnum
);
322 l
= read_command_lines ();
323 free_command_lines (&b
->commands
);
327 error ("No breakpoint number %d.", bnum
);
330 extern int memory_breakpoint_size
; /* from mem-break.c */
332 /* Like target_read_memory() but if breakpoints are inserted, return
333 the shadow contents instead of the breakpoints themselves.
335 Read "memory data" from whatever target or inferior we have.
336 Returns zero if successful, errno value if not. EIO is used
337 for address out of bounds. If breakpoints are inserted, returns
338 shadow contents, not the breakpoints themselves. From breakpoint.c. */
341 read_memory_nobpt (memaddr
, myaddr
, len
)
347 struct breakpoint
*b
;
349 if (memory_breakpoint_size
< 0)
350 /* No breakpoints on this machine. */
351 return target_read_memory (memaddr
, myaddr
, len
);
355 if (b
->type
== bp_watchpoint
|| !b
->inserted
)
357 else if (b
->address
+ memory_breakpoint_size
<= memaddr
)
358 /* The breakpoint is entirely before the chunk of memory
361 else if (b
->address
>= memaddr
+ len
)
362 /* The breakpoint is entirely after the chunk of memory we
367 /* Copy the breakpoint from the shadow contents, and recurse
368 for the things before and after. */
370 /* Addresses and length of the part of the breakpoint that
372 CORE_ADDR membpt
= b
->address
;
373 unsigned int bptlen
= memory_breakpoint_size
;
374 /* Offset within shadow_contents. */
377 if (membpt
< memaddr
)
379 /* Only copy the second part of the breakpoint. */
380 bptlen
-= memaddr
- membpt
;
381 bptoffset
= memaddr
- membpt
;
385 if (membpt
+ bptlen
> memaddr
+ len
)
387 /* Only copy the first part of the breakpoint. */
388 bptlen
-= (membpt
+ bptlen
) - (memaddr
+ len
);
391 memcpy (myaddr
+ membpt
- memaddr
,
392 b
->shadow_contents
+ bptoffset
, bptlen
);
394 if (membpt
> memaddr
)
396 /* Copy the section of memory before the breakpoint. */
397 status
= read_memory_nobpt (memaddr
, myaddr
, membpt
- memaddr
);
402 if (membpt
+ bptlen
< memaddr
+ len
)
404 /* Copy the section of memory after the breakpoint. */
405 status
= read_memory_nobpt
407 myaddr
+ membpt
+ bptlen
- memaddr
,
408 memaddr
+ len
- (membpt
+ bptlen
));
415 /* Nothing overlaps. Just call read_memory_noerr. */
416 return target_read_memory (memaddr
, myaddr
, len
);
419 /* insert_breakpoints is used when starting or continuing the program.
420 remove_breakpoints is used when the program stops.
421 Both return zero if successful,
422 or an `errno' value if could not write the inferior. */
425 insert_breakpoints ()
427 register struct breakpoint
*b
;
429 int disabled_breaks
= 0;
432 if (b
->type
!= bp_watchpoint
433 && b
->enable
!= disabled
437 val
= target_insert_breakpoint(b
->address
, b
->shadow_contents
);
440 /* Can't set the breakpoint. */
441 #if defined (DISABLE_UNSETTABLE_BREAK)
442 if (DISABLE_UNSETTABLE_BREAK (b
->address
))
445 b
->enable
= disabled
;
446 if (!disabled_breaks
)
449 "Cannot insert breakpoint %d:\n", b
->number
);
450 printf_filtered ("Disabling shared library breakpoints:\n");
453 printf_filtered ("%d ", b
->number
);
458 fprintf (stderr
, "Cannot insert breakpoint %d:\n", b
->number
);
459 #ifdef ONE_PROCESS_WRITETEXT
461 "The same program may be running in another process.\n");
463 memory_error (val
, b
->address
); /* which bombs us out */
470 printf_filtered ("\n");
475 remove_breakpoints ()
477 register struct breakpoint
*b
;
480 #ifdef BREAKPOINT_DEBUG
481 printf ("Removing breakpoints.\n");
482 #endif /* BREAKPOINT_DEBUG */
485 if (b
->type
!= bp_watchpoint
&& b
->inserted
)
487 val
= target_remove_breakpoint(b
->address
, b
->shadow_contents
);
491 #ifdef BREAKPOINT_DEBUG
492 printf ("Removed breakpoint at %s",
493 local_hex_string(b
->address
));
494 printf (", shadow %s",
495 local_hex_string(b
->shadow_contents
[0]));
497 local_hex_string(b
->shadow_contents
[1]));
498 #endif /* BREAKPOINT_DEBUG */
504 /* Clear the "inserted" flag in all breakpoints.
505 This is done when the inferior is loaded. */
508 mark_breakpoints_out ()
510 register struct breakpoint
*b
;
516 /* breakpoint_here_p (PC) returns 1 if an enabled breakpoint exists at PC.
517 When continuing from a location with a breakpoint,
518 we actually single step once before calling insert_breakpoints. */
521 breakpoint_here_p (pc
)
524 register struct breakpoint
*b
;
527 if (b
->enable
!= disabled
&& b
->address
== pc
)
533 /* bpstat stuff. External routines' interfaces are documented
536 /* Clear a bpstat so that it says we are not at any breakpoint.
537 Also free any storage that is part of a bpstat. */
552 if (p
->old_val
!= NULL
)
553 value_free (p
->old_val
);
560 /* Return a copy of a bpstat. Like "bs1 = bs2" but all storage that
561 is part of the bpstat is copied as well. */
574 for (; bs
!= NULL
; bs
= bs
->next
)
576 tmp
= (bpstat
) xmalloc (sizeof (*tmp
));
577 memcpy (tmp
, bs
, sizeof (*tmp
));
579 /* This is the first thing in the chain. */
589 /* Find the bpstat associated with this breakpoint */
592 bpstat_find_breakpoint(bsp
, breakpoint
)
594 struct breakpoint
*breakpoint
;
596 if (bsp
== NULL
) return NULL
;
598 for (;bsp
!= NULL
; bsp
= bsp
->next
) {
599 if (bsp
->breakpoint_at
== breakpoint
) return bsp
;
604 /* Return the breakpoint number of the first breakpoint we are stopped
605 at. *BSP upon return is a bpstat which points to the remaining
606 breakpoints stopped at (but which is not guaranteed to be good for
607 anything but further calls to bpstat_num).
608 Return 0 if passed a bpstat which does not indicate any breakpoints. */
614 struct breakpoint
*b
;
617 return 0; /* No more breakpoint values */
620 b
= (*bsp
)->breakpoint_at
;
623 return -1; /* breakpoint that's been deleted since */
625 return b
->number
; /* We have its number */
629 /* Modify BS so that the actions will not be performed. */
632 bpstat_clear_actions (bs
)
635 for (; bs
!= NULL
; bs
= bs
->next
)
638 if (bs
->old_val
!= NULL
)
640 value_free (bs
->old_val
);
646 /* Stub for cleaning up our state if we error-out of a breakpoint command */
649 cleanup_executing_breakpoints (ignore
)
652 executing_breakpoint_commands
= 0;
655 /* Execute all the commands associated with all the breakpoints at this
656 location. Any of these commands could cause the process to proceed
657 beyond this point, etc. We look out for such changes by checking
658 the global "breakpoint_proceeded" after each command. */
661 bpstat_do_actions (bsp
)
665 struct cleanup
*old_chain
;
667 executing_breakpoint_commands
= 1;
668 old_chain
= make_cleanup (cleanup_executing_breakpoints
, 0);
673 breakpoint_proceeded
= 0;
674 for (; bs
!= NULL
; bs
= bs
->next
)
678 char *line
= bs
->commands
->line
;
679 bs
->commands
= bs
->commands
->next
;
680 execute_command (line
, 0);
681 /* If the inferior is proceeded by the command, bomb out now.
682 The bpstat chain has been blown away by wait_for_inferior.
683 But since execution has stopped again, there is a new bpstat
684 to look at, so start over. */
685 if (breakpoint_proceeded
)
690 executing_breakpoint_commands
= 0;
691 discard_cleanups (old_chain
);
694 /* This is the normal print_it function for a bpstat. In the future,
695 much of this logic could (should?) be moved to bpstat_stop_status,
696 by having it set different print_it functions. */
702 /* bs->breakpoint_at can be NULL if it was a momentary breakpoint
703 which has since been deleted. */
704 if (bs
->breakpoint_at
== NULL
705 || (bs
->breakpoint_at
->type
!= bp_breakpoint
706 && bs
->breakpoint_at
->type
!= bp_watchpoint
))
709 if (bs
->breakpoint_at
->type
== bp_breakpoint
)
711 /* I think the user probably only wants to see one breakpoint
712 number, not all of them. */
713 printf_filtered ("\nBreakpoint %d, ", bs
->breakpoint_at
->number
);
717 if (bs
->old_val
!= NULL
)
719 printf_filtered ("\nWatchpoint %d, ", bs
->breakpoint_at
->number
);
720 print_expression (bs
->breakpoint_at
->exp
, stdout
);
721 printf_filtered ("\nOld value = ");
722 value_print (bs
->old_val
, stdout
, 0, Val_pretty_default
);
723 printf_filtered ("\nNew value = ");
724 value_print (bs
->breakpoint_at
->val
, stdout
, 0,
726 printf_filtered ("\n");
727 value_free (bs
->old_val
);
731 /* We can't deal with it. Maybe another member of the bpstat chain can. */
735 /* Print a message indicating what happened. Returns nonzero to
736 say that only the source line should be printed after this (zero
737 return means print the frame as well as the source line). */
738 /* Currently we always return zero. */
748 val
= (*bs
->print_it
) (bs
);
752 /* Maybe another breakpoint in the chain caused us to stop.
753 (Currently all watchpoints go on the bpstat whether hit or
754 not. That probably could (should) be changed, provided care is taken
755 with respect to bpstat_explains_signal). */
757 return bpstat_print (bs
->next
);
759 /* We reached the end of the chain without printing anything. */
763 /* Evaluate the expression EXP and return 1 if value is zero.
764 This is used inside a catch_errors to evaluate the breakpoint condition.
765 The argument is a "struct expression *" that has been cast to char * to
766 make it pass through catch_errors. */
769 breakpoint_cond_eval (exp
)
772 return !value_true (evaluate_expression ((struct expression
*)exp
));
775 /* Allocate a new bpstat and chain it to the current one. */
778 bpstat_alloc (b
, cbs
)
779 register struct breakpoint
*b
;
780 bpstat cbs
; /* Current "bs" value */
784 bs
= (bpstat
) xmalloc (sizeof (*bs
));
786 bs
->breakpoint_at
= b
;
787 /* If the condition is false, etc., don't do the commands. */
790 bs
->print_it
= print_it_normal
;
794 /* Possible return values for watchpoint_check (this can't be an enum
795 because of check_errors). */
796 /* The watchpoint has been disabled. */
797 #define WP_DISABLED 1
798 /* The value has changed. */
799 #define WP_VALUE_CHANGED 2
800 /* The value has not changed. */
801 #define WP_VALUE_NOT_CHANGED 3
803 /* Check watchpoint condition. */
808 bpstat bs
= (bpstat
) p
;
810 int within_current_scope
;
811 if (bs
->breakpoint_at
->exp_valid_block
!= NULL
)
812 within_current_scope
=
813 contained_in (get_selected_block (), bs
->breakpoint_at
->exp_valid_block
);
815 within_current_scope
= 1;
817 if (within_current_scope
)
819 /* We use value_{,free_to_}mark because it could be a
820 *long* time before we return to the command level and
821 call free_all_values. */
822 /* But couldn't we just call free_all_values instead? */
824 value mark
= value_mark ();
825 value new_val
= evaluate_expression (bs
->breakpoint_at
->exp
);
826 if (!value_equal (bs
->breakpoint_at
->val
, new_val
))
828 release_value (new_val
);
829 value_free_to_mark (mark
);
830 bs
->old_val
= bs
->breakpoint_at
->val
;
831 bs
->breakpoint_at
->val
= new_val
;
832 /* We will stop here */
833 return WP_VALUE_CHANGED
;
837 /* Nothing changed, don't do anything. */
838 value_free_to_mark (mark
);
839 /* We won't stop here */
840 return WP_VALUE_NOT_CHANGED
;
845 /* This seems like the only logical thing to do because
846 if we temporarily ignored the watchpoint, then when
847 we reenter the block in which it is valid it contains
848 garbage (in the case of a function, it may have two
849 garbage values, one before and one after the prologue).
850 So we can't even detect the first assignment to it and
851 watch after that (since the garbage may or may not equal
852 the first value assigned). */
853 bs
->breakpoint_at
->enable
= disabled
;
855 Watchpoint %d disabled because the program has left the block in\n\
856 which its expression is valid.\n", bs
->breakpoint_at
->number
);
861 /* This is used when everything which needs to be printed has
862 already been printed. But we still want to print the frame. */
870 /* This is used when nothing should be printed for this bpstat entry. */
879 /* Determine whether we stopped at a breakpoint, etc, or whether we
880 don't understand this stop. Result is a chain of bpstat's such that:
882 if we don't understand the stop, the result is a null pointer.
884 if we understand why we stopped, the result is not null, and
885 the first element of the chain contains summary "stop" and
886 "print" flags for the whole chain.
888 Each element of the chain refers to a particular breakpoint or
889 watchpoint at which we have stopped. (We may have stopped for
890 several reasons concurrently.)
892 Each element of the chain has valid next, breakpoint_at,
893 commands, FIXME??? fields.
899 bpstat_stop_status (pc
, frame_address
)
901 FRAME_ADDR frame_address
;
903 register struct breakpoint
*b
;
905 #if DECR_PC_AFTER_BREAK != 0 || defined (SHIFT_INST_REGS)
906 /* True if we've hit a breakpoint (as opposed to a watchpoint). */
907 int real_breakpoint
= 0;
909 /* Root of the chain of bpstat's */
910 struct bpstat root_bs
[1];
911 /* Pointer to the last thing in the chain currently. */
914 /* Get the address where the breakpoint would have been. */
915 bp_addr
= *pc
- DECR_PC_AFTER_BREAK
;
919 if (b
->enable
== disabled
)
922 if (b
->type
!= bp_watchpoint
&& b
->address
!= bp_addr
)
925 /* Come here if it's a watchpoint, or if the break address matches */
927 bs
= bpstat_alloc (b
, bs
); /* Alloc a bpstat to explain stop */
932 if (b
->type
== bp_watchpoint
)
934 static char message1
[] =
935 "Error evaluating expression for watchpoint %d\n";
936 char message
[sizeof (message1
) + 30 /* slop */];
937 sprintf (message
, message1
, b
->number
);
938 switch (catch_errors (watchpoint_check
, (char *) bs
, message
))
941 /* We've already printed what needs to be printed. */
942 bs
->print_it
= print_it_done
;
945 case WP_VALUE_CHANGED
:
948 case WP_VALUE_NOT_CHANGED
:
950 bs
->print_it
= print_it_noop
;
957 /* Error from catch_errors. */
958 b
->enable
= disabled
;
959 printf_filtered ("Watchpoint %d disabled.\n", b
->number
);
960 /* We've already printed what needs to be printed. */
961 bs
->print_it
= print_it_done
;
966 #if DECR_PC_AFTER_BREAK != 0 || defined (SHIFT_INST_REGS)
971 if (b
->frame
&& b
->frame
!= frame_address
)
979 /* Need to select the frame, with all that implies
980 so that the conditions will have the right context. */
981 select_frame (get_current_frame (), 0);
983 = catch_errors (breakpoint_cond_eval
, (char *)(b
->cond
),
984 "Error in testing breakpoint condition:\n");
985 /* FIXME-someday, should give breakpoint # */
988 if (b
->cond
&& value_is_zero
)
992 else if (b
->ignore_count
> 0)
999 /* We will stop here */
1000 if (b
->disposition
== disable
)
1001 b
->enable
= disabled
;
1002 bs
->commands
= b
->commands
;
1005 if (bs
->commands
&& STREQ ("silent", bs
->commands
->line
))
1007 bs
->commands
= bs
->commands
->next
;
1012 /* Print nothing for this entry if we dont stop or if we dont print. */
1013 if (bs
->stop
== 0 || bs
->print
== 0)
1014 bs
->print_it
= print_it_noop
;
1017 bs
->next
= NULL
; /* Terminate the chain */
1018 bs
= root_bs
->next
; /* Re-grab the head of the chain */
1019 #if DECR_PC_AFTER_BREAK != 0 || defined (SHIFT_INST_REGS)
1022 if (real_breakpoint
)
1025 #if defined (SHIFT_INST_REGS)
1027 CORE_ADDR pc
= read_register (PC_REGNUM
);
1028 CORE_ADDR npc
= read_register (NPC_REGNUM
);
1031 write_register (NNPC_REGNUM
, npc
);
1032 write_register (NPC_REGNUM
, pc
);
1035 #else /* No SHIFT_INST_REGS. */
1037 #endif /* No SHIFT_INST_REGS. */
1040 #endif /* DECR_PC_AFTER_BREAK != 0. */
1044 /* Tell what to do about this bpstat. */
1049 /* Classify each bpstat as one of the following. */
1051 /* There was a watchpoint, but we're not stopping. */
1054 /* There was a watchpoint, stop but don't print. */
1057 /* There was a watchpoint, stop and print. */
1060 /* There was a breakpoint but we're not stopping. */
1063 /* There was a breakpoint, stop but don't print. */
1066 /* There was a breakpoint, stop and print. */
1069 /* We hit the longjmp breakpoint. */
1072 /* We hit the longjmp_resume breakpoint. */
1075 /* This is just used to count how many enums there are. */
1079 /* Here is the table which drives this routine. So that we can
1080 format it pretty, we define some abbreviations for the
1081 enum bpstat_what codes. */
1082 #define keep_c BPSTAT_WHAT_KEEP_CHECKING
1083 #define stop_s BPSTAT_WHAT_STOP_SILENT
1084 #define stop_n BPSTAT_WHAT_STOP_NOISY
1085 #define single BPSTAT_WHAT_SINGLE
1086 #define setlr BPSTAT_WHAT_SET_LONGJMP_RESUME
1087 #define clrlr BPSTAT_WHAT_CLEAR_LONGJMP_RESUME
1088 #define clrlrs BPSTAT_WHAT_CLEAR_LONGJMP_RESUME_SINGLE
1089 /* "Can't happen." Might want to print an error message.
1090 abort() is not out of the question, but chances are GDB is just
1091 a bit confused, not unusable. */
1092 #define err BPSTAT_WHAT_STOP_NOISY
1094 /* Given an old action and a class, come up with a new action. */
1095 static const enum bpstat_what
1096 table
[(int)class_last
][(int)BPSTAT_WHAT_LAST
] =
1099 /* keep_c stop_s stop_n single setlr clrlr clrlrs */
1101 /*wp_nostop*/ {keep_c
, stop_s
, stop_n
, single
, setlr
, clrlr
, clrlrs
},
1102 /*wp_silent*/ {stop_s
, stop_s
, stop_n
, stop_s
, stop_s
, stop_s
, stop_s
},
1103 /*wp_noisy*/ {stop_n
, stop_n
, stop_n
, stop_n
, stop_n
, stop_n
, stop_n
},
1104 /*bp_nostop*/ {single
, stop_s
, stop_n
, single
, setlr
, clrlrs
, clrlrs
},
1105 /*bp_silent*/ {stop_s
, stop_s
, stop_n
, stop_s
, stop_s
, stop_s
, stop_s
},
1106 /*bp_noisy*/ {stop_n
, stop_n
, stop_n
, stop_n
, stop_n
, stop_n
, stop_n
},
1107 /*long_jump*/ {setlr
, stop_s
, stop_n
, setlr
, err
, err
, err
},
1108 /*long_resume*/ {clrlr
, stop_s
, stop_n
, clrlrs
, err
, err
, err
}
1118 enum bpstat_what current_action
= BPSTAT_WHAT_KEEP_CHECKING
;
1120 for (; bs
!= NULL
; bs
= bs
->next
)
1122 enum class bs_class
;
1123 if (bs
->breakpoint_at
== NULL
)
1124 /* I suspect this can happen if it was a momentary breakpoint
1125 which has since been deleted. */
1127 switch (bs
->breakpoint_at
->type
)
1135 bs_class
= bp_noisy
;
1137 bs_class
= bp_silent
;
1140 bs_class
= bp_nostop
;
1146 bs_class
= wp_noisy
;
1148 bs_class
= wp_silent
;
1151 bs_class
= wp_nostop
;
1154 bs_class
= long_jump
;
1156 case bp_longjmp_resume
:
1157 bs_class
= long_resume
;
1160 current_action
= table
[(int)bs_class
][(int)current_action
];
1162 return current_action
;
1165 /* Nonzero if we should step constantly (e.g. watchpoints on machines
1166 without hardware support). This isn't related to a specific bpstat,
1167 just to things like whether watchpoints are set. */
1170 bpstat_should_step ()
1172 struct breakpoint
*b
;
1174 if (b
->enable
== enabled
&& b
->type
== bp_watchpoint
)
1179 /* Print information on breakpoint number BNUM, or -1 if all.
1180 If WATCHPOINTS is zero, process only breakpoints; if WATCHPOINTS
1181 is nonzero, process only watchpoints. */
1184 breakpoint_1 (bnum
, allflag
)
1188 register struct breakpoint
*b
;
1189 register struct command_line
*l
;
1190 register struct symbol
*sym
;
1191 CORE_ADDR last_addr
= (CORE_ADDR
)-1;
1192 int found_a_breakpoint
= 0;
1193 static char *bptypes
[] = {"breakpoint", "until", "finish", "watchpoint",
1194 "longjmp", "longjmp resume"};
1195 static char *bpdisps
[] = {"del", "dis", "keep"};
1196 static char bpenables
[] = "ny";
1197 char wrap_indent
[80];
1199 if (!breakpoint_chain
)
1201 printf_filtered ("No breakpoints or watchpoints.\n");
1207 || bnum
== b
->number
)
1209 /* We only print out user settable breakpoints unless the allflag is set. */
1211 && b
->type
!= bp_breakpoint
1212 && b
->type
!= bp_watchpoint
)
1215 if (!found_a_breakpoint
++)
1216 printf_filtered ("Num Type Disp Enb %sWhat\n",
1217 addressprint
? "Address " : "");
1219 printf_filtered ("%-3d %-14s %-4s %-3c ",
1221 bptypes
[(int)b
->type
],
1222 bpdisps
[(int)b
->disposition
],
1223 bpenables
[(int)b
->enable
]);
1224 strcpy (wrap_indent
, " ");
1226 strcat (wrap_indent
, " ");
1230 print_expression (b
->exp
, stdout
);
1236 case bp_longjmp_resume
:
1238 printf_filtered ("%s ", local_hex_string_custom(b
->address
, "08"));
1240 last_addr
= b
->address
;
1243 sym
= find_pc_function (b
->address
);
1246 fputs_filtered ("in ", stdout
);
1247 fputs_filtered (SYMBOL_SOURCE_NAME (sym
), stdout
);
1248 wrap_here (wrap_indent
);
1249 fputs_filtered (" at ", stdout
);
1251 fputs_filtered (b
->symtab
->filename
, stdout
);
1252 printf_filtered (":%d", b
->line_number
);
1255 print_address_symbolic (b
->address
, stdout
, demangle
, " ");
1258 printf_filtered ("\n");
1261 printf_filtered ("\tstop only in stack frame at %s\n",
1262 local_hex_string(b
->frame
));
1265 printf_filtered ("\tstop only if ");
1266 print_expression (b
->cond
, stdout
);
1267 printf_filtered ("\n");
1269 if (b
->ignore_count
)
1270 printf_filtered ("\tignore next %d hits\n", b
->ignore_count
);
1271 if ((l
= b
->commands
))
1274 fputs_filtered ("\t", stdout
);
1275 fputs_filtered (l
->line
, stdout
);
1276 fputs_filtered ("\n", stdout
);
1281 if (!found_a_breakpoint
1283 printf_filtered ("No breakpoint or watchpoint number %d.\n", bnum
);
1285 /* Compare against (CORE_ADDR)-1 in case some compiler decides
1286 that a comparison of an unsigned with -1 is always false. */
1287 if (last_addr
!= (CORE_ADDR
)-1)
1288 set_next_address (last_addr
);
1293 breakpoints_info (bnum_exp
, from_tty
)
1300 bnum
= parse_and_eval_address (bnum_exp
);
1302 breakpoint_1 (bnum
, 0);
1305 #if MAINTENANCE_CMDS
1309 maintenance_info_breakpoints (bnum_exp
, from_tty
)
1316 bnum
= parse_and_eval_address (bnum_exp
);
1318 breakpoint_1 (bnum
, 1);
1323 /* Print a message describing any breakpoints set at PC. */
1326 describe_other_breakpoints (pc
)
1327 register CORE_ADDR pc
;
1329 register int others
= 0;
1330 register struct breakpoint
*b
;
1333 if (b
->address
== pc
)
1337 printf ("Note: breakpoint%s ", (others
> 1) ? "s" : "");
1339 if (b
->address
== pc
)
1344 (b
->enable
== disabled
) ? " (disabled)" : "",
1345 (others
> 1) ? "," : ((others
== 1) ? " and" : ""));
1347 printf ("also set at pc %s.\n", local_hex_string(pc
));
1351 /* Set the default place to put a breakpoint
1352 for the `break' command with no arguments. */
1355 set_default_breakpoint (valid
, addr
, symtab
, line
)
1358 struct symtab
*symtab
;
1361 default_breakpoint_valid
= valid
;
1362 default_breakpoint_address
= addr
;
1363 default_breakpoint_symtab
= symtab
;
1364 default_breakpoint_line
= line
;
1367 /* Rescan breakpoints at address ADDRESS,
1368 marking the first one as "first" and any others as "duplicates".
1369 This is so that the bpt instruction is only inserted once. */
1372 check_duplicates (address
)
1375 register struct breakpoint
*b
;
1376 register int count
= 0;
1378 if (address
== 0) /* Watchpoints are uninteresting */
1382 if (b
->enable
!= disabled
&& b
->address
== address
)
1385 b
->duplicate
= count
> 1;
1389 /* Low level routine to set a breakpoint.
1390 Takes as args the three things that every breakpoint must have.
1391 Returns the breakpoint object so caller can set other things.
1392 Does not set the breakpoint number!
1393 Does not print anything.
1395 ==> This routine should not be called if there is a chance of later
1396 error(); otherwise it leaves a bogus breakpoint on the chain. Validate
1397 your arguments BEFORE calling this routine! */
1399 static struct breakpoint
*
1400 set_raw_breakpoint (sal
)
1401 struct symtab_and_line sal
;
1403 register struct breakpoint
*b
, *b1
;
1405 b
= (struct breakpoint
*) xmalloc (sizeof (struct breakpoint
));
1406 memset (b
, 0, sizeof (*b
));
1407 b
->address
= sal
.pc
;
1408 b
->symtab
= sal
.symtab
;
1409 b
->line_number
= sal
.line
;
1410 b
->enable
= enabled
;
1413 b
->ignore_count
= 0;
1417 /* Add this breakpoint to the end of the chain
1418 so that a list of breakpoints will come out in order
1419 of increasing numbers. */
1421 b1
= breakpoint_chain
;
1423 breakpoint_chain
= b
;
1431 check_duplicates (sal
.pc
);
1437 create_longjmp_breakpoint(func_name
)
1440 struct symtab_and_line sal
;
1441 struct breakpoint
*b
;
1442 static int internal_breakpoint_number
= -1;
1444 if (func_name
!= NULL
)
1446 struct minimal_symbol
*m
;
1448 m
= lookup_minimal_symbol(func_name
, (struct objfile
*)NULL
);
1450 sal
.pc
= SYMBOL_VALUE_ADDRESS (m
);
1460 b
= set_raw_breakpoint(sal
);
1463 b
->type
= func_name
!= NULL
? bp_longjmp
: bp_longjmp_resume
;
1464 b
->disposition
= donttouch
;
1465 b
->enable
= disabled
;
1468 b
->addr_string
= strsave(func_name
);
1469 b
->number
= internal_breakpoint_number
--;
1472 /* Call this routine when stepping and nexting to enable a breakpoint if we do
1473 a longjmp(). When we hit that breakpoint, call
1474 set_longjmp_resume_breakpoint() to figure out where we are going. */
1477 enable_longjmp_breakpoint()
1479 register struct breakpoint
*b
;
1482 if (b
->type
== bp_longjmp
)
1484 b
->enable
= enabled
;
1485 check_duplicates (b
->address
);
1490 disable_longjmp_breakpoint()
1492 register struct breakpoint
*b
;
1495 if ( b
->type
== bp_longjmp
1496 || b
->type
== bp_longjmp_resume
)
1498 b
->enable
= disabled
;
1499 check_duplicates (b
->address
);
1503 /* Call this after hitting the longjmp() breakpoint. Use this to set a new
1504 breakpoint at the target of the jmp_buf.
1506 FIXME - This ought to be done by setting a temporary breakpoint that gets
1507 deleted automatically...
1511 set_longjmp_resume_breakpoint(pc
, frame
)
1515 register struct breakpoint
*b
;
1518 if (b
->type
== bp_longjmp_resume
)
1521 b
->enable
= enabled
;
1523 b
->frame
= FRAME_FP(frame
);
1526 check_duplicates (b
->address
);
1531 /* Set a breakpoint that will evaporate an end of command
1532 at address specified by SAL.
1533 Restrict it to frame FRAME if FRAME is nonzero. */
1536 set_momentary_breakpoint (sal
, frame
, type
)
1537 struct symtab_and_line sal
;
1541 register struct breakpoint
*b
;
1542 b
= set_raw_breakpoint (sal
);
1544 b
->enable
= enabled
;
1545 b
->disposition
= donttouch
;
1546 b
->frame
= (frame
? FRAME_FP (frame
) : 0);
1552 clear_momentary_breakpoints ()
1554 register struct breakpoint
*b
;
1556 if (b
->disposition
== delete)
1558 delete_breakpoint (b
);
1564 /* Tell the user we have just set a breakpoint B. */
1567 struct breakpoint
*b
;
1572 printf_filtered ("Watchpoint %d: ", b
->number
);
1573 print_expression (b
->exp
, stdout
);
1576 printf_filtered ("Breakpoint %d at %s", b
->number
,
1577 local_hex_string(b
->address
));
1579 printf_filtered (": file %s, line %d.",
1580 b
->symtab
->filename
, b
->line_number
);
1585 case bp_longjmp_resume
:
1588 printf_filtered ("\n");
1592 /* Nobody calls this currently. */
1593 /* Set a breakpoint from a symtab and line.
1594 If TEMPFLAG is nonzero, it is a temporary breakpoint.
1595 ADDR_STRING is a malloc'd string holding the name of where we are
1596 setting the breakpoint. This is used later to re-set it after the
1597 program is relinked and symbols are reloaded.
1598 Print the same confirmation messages that the breakpoint command prints. */
1601 set_breakpoint (s
, line
, tempflag
, addr_string
)
1607 register struct breakpoint
*b
;
1608 struct symtab_and_line sal
;
1613 resolve_sal_pc (&sal
); /* Might error out */
1614 describe_other_breakpoints (sal
.pc
);
1616 b
= set_raw_breakpoint (sal
);
1617 set_breakpoint_count (breakpoint_count
+ 1);
1618 b
->number
= breakpoint_count
;
1619 b
->type
= bp_breakpoint
;
1621 b
->addr_string
= addr_string
;
1622 b
->enable
= enabled
;
1623 b
->disposition
= tempflag
? delete : donttouch
;
1629 /* Set a breakpoint according to ARG (function, linenum or *address)
1630 and make it temporary if TEMPFLAG is nonzero. */
1633 break_command_1 (arg
, tempflag
, from_tty
)
1635 int tempflag
, from_tty
;
1637 struct symtabs_and_lines sals
;
1638 struct symtab_and_line sal
;
1639 register struct expression
*cond
= 0;
1640 register struct breakpoint
*b
;
1642 /* Pointers in arg to the start, and one past the end, of the condition. */
1643 char *cond_start
= NULL
;
1645 /* Pointers in arg to the start, and one past the end,
1646 of the address part. */
1647 char *addr_start
= NULL
;
1655 sal
.line
= sal
.pc
= sal
.end
= 0;
1658 /* If no arg given, or if first arg is 'if ', use the default breakpoint. */
1660 if (!arg
|| (arg
[0] == 'i' && arg
[1] == 'f'
1661 && (arg
[2] == ' ' || arg
[2] == '\t')))
1663 if (default_breakpoint_valid
)
1665 sals
.sals
= (struct symtab_and_line
*)
1666 xmalloc (sizeof (struct symtab_and_line
));
1667 sal
.pc
= default_breakpoint_address
;
1668 sal
.line
= default_breakpoint_line
;
1669 sal
.symtab
= default_breakpoint_symtab
;
1674 error ("No default breakpoint address now.");
1680 /* Force almost all breakpoints to be in terms of the
1681 current_source_symtab (which is decode_line_1's default). This
1682 should produce the results we want almost all of the time while
1683 leaving default_breakpoint_* alone. */
1684 if (default_breakpoint_valid
1685 && (!current_source_symtab
1686 || (arg
&& (*arg
== '+' || *arg
== '-'))))
1687 sals
= decode_line_1 (&arg
, 1, default_breakpoint_symtab
,
1688 default_breakpoint_line
);
1690 sals
= decode_line_1 (&arg
, 1, (struct symtab
*)NULL
, 0);
1698 /* Resolve all line numbers to PC's, and verify that conditions
1699 can be parsed, before setting any breakpoints. */
1700 for (i
= 0; i
< sals
.nelts
; i
++)
1702 resolve_sal_pc (&sals
.sals
[i
]);
1706 if (arg
[0] == 'i' && arg
[1] == 'f'
1707 && (arg
[2] == ' ' || arg
[2] == '\t'))
1711 cond
= parse_exp_1 (&arg
, block_for_pc (sals
.sals
[i
].pc
), 0);
1715 error ("Junk at end of arguments.");
1719 /* Now set all the breakpoints. */
1720 for (i
= 0; i
< sals
.nelts
; i
++)
1725 describe_other_breakpoints (sal
.pc
);
1727 b
= set_raw_breakpoint (sal
);
1728 set_breakpoint_count (breakpoint_count
+ 1);
1729 b
->number
= breakpoint_count
;
1730 b
->type
= bp_breakpoint
;
1733 /* FIXME: We should add the filename if this is a static function
1734 and probably if it is a line number (the line numbers could
1735 have changed when we re-read symbols; possibly better to disable
1736 the breakpoint in that case). */
1738 b
->addr_string
= savestring (addr_start
, addr_end
- addr_start
);
1740 b
->cond_string
= savestring (cond_start
, cond_end
- cond_start
);
1742 b
->enable
= enabled
;
1743 b
->disposition
= tempflag
? delete : donttouch
;
1750 printf ("Multiple breakpoints were set.\n");
1751 printf ("Use the \"delete\" command to delete unwanted breakpoints.\n");
1753 free ((PTR
)sals
.sals
);
1756 /* Helper function for break_command_1 and disassemble_command. */
1759 resolve_sal_pc (sal
)
1760 struct symtab_and_line
*sal
;
1764 if (sal
->pc
== 0 && sal
->symtab
!= 0)
1766 pc
= find_line_pc (sal
->symtab
, sal
->line
);
1768 error ("No line %d in file \"%s\".",
1769 sal
->line
, sal
->symtab
->filename
);
1775 break_command (arg
, from_tty
)
1779 break_command_1 (arg
, 0, from_tty
);
1783 tbreak_command (arg
, from_tty
)
1787 break_command_1 (arg
, 1, from_tty
);
1792 watch_command (arg
, from_tty
)
1796 struct breakpoint
*b
;
1797 struct symtab_and_line sal
;
1798 struct expression
*exp
;
1799 struct block
*exp_valid_block
;
1806 /* Parse arguments. */
1807 innermost_block
= NULL
;
1808 exp
= parse_expression (arg
);
1809 exp_valid_block
= innermost_block
;
1810 val
= evaluate_expression (exp
);
1811 release_value (val
);
1812 if (VALUE_LAZY (val
))
1813 value_fetch_lazy (val
);
1815 /* Now set up the breakpoint. */
1816 b
= set_raw_breakpoint (sal
);
1817 set_breakpoint_count (breakpoint_count
+ 1);
1818 b
->number
= breakpoint_count
;
1819 b
->type
= bp_watchpoint
;
1820 b
->disposition
= donttouch
;
1822 b
->exp_valid_block
= exp_valid_block
;
1825 b
->cond_string
= NULL
;
1826 b
->exp_string
= savestring (arg
, strlen (arg
));
1831 * Helper routine for the until_command routine in infcmd.c. Here
1832 * because it uses the mechanisms of breakpoints.
1836 until_break_command (arg
, from_tty
)
1840 struct symtabs_and_lines sals
;
1841 struct symtab_and_line sal
;
1842 FRAME prev_frame
= get_prev_frame (selected_frame
);
1843 struct breakpoint
*breakpoint
;
1844 struct cleanup
*old_chain
;
1846 clear_proceed_status ();
1848 /* Set a breakpoint where the user wants it and at return from
1851 if (default_breakpoint_valid
)
1852 sals
= decode_line_1 (&arg
, 1, default_breakpoint_symtab
,
1853 default_breakpoint_line
);
1855 sals
= decode_line_1 (&arg
, 1, (struct symtab
*)NULL
, 0);
1857 if (sals
.nelts
!= 1)
1858 error ("Couldn't get information on specified line.");
1861 free ((PTR
)sals
.sals
); /* malloc'd, so freed */
1864 error ("Junk at end of arguments.");
1866 resolve_sal_pc (&sal
);
1868 breakpoint
= set_momentary_breakpoint (sal
, selected_frame
, bp_until
);
1870 old_chain
= make_cleanup(delete_breakpoint
, breakpoint
);
1872 /* Keep within the current frame */
1876 struct frame_info
*fi
;
1878 fi
= get_frame_info (prev_frame
);
1879 sal
= find_pc_line (fi
->pc
, 0);
1881 breakpoint
= set_momentary_breakpoint (sal
, prev_frame
, bp_until
);
1882 make_cleanup(delete_breakpoint
, breakpoint
);
1885 proceed (-1, -1, 0);
1886 do_cleanups(old_chain
);
1890 /* These aren't used; I don't konw what they were for. */
1891 /* Set a breakpoint at the catch clause for NAME. */
1893 catch_breakpoint (name
)
1899 disable_catch_breakpoint ()
1904 delete_catch_breakpoint ()
1909 enable_catch_breakpoint ()
1916 struct sal_chain
*next
;
1917 struct symtab_and_line sal
;
1921 /* This isn't used; I don't know what it was for. */
1922 /* For each catch clause identified in ARGS, run FUNCTION
1923 with that clause as an argument. */
1924 static struct symtabs_and_lines
1925 map_catch_names (args
, function
)
1929 register char *p
= args
;
1931 struct symtabs_and_lines sals
;
1933 struct sal_chain
*sal_chain
= 0;
1937 error_no_arg ("one or more catch names");
1945 /* Don't swallow conditional part. */
1946 if (p1
[0] == 'i' && p1
[1] == 'f'
1947 && (p1
[2] == ' ' || p1
[2] == '\t'))
1953 while (isalnum (*p1
) || *p1
== '_' || *p1
== '$')
1957 if (*p1
&& *p1
!= ' ' && *p1
!= '\t')
1958 error ("Arguments must be catch names.");
1964 struct sal_chain
*next
1965 = (struct sal_chain
*)alloca (sizeof (struct sal_chain
));
1966 next
->next
= sal_chain
;
1967 next
->sal
= get_catch_sal (p
);
1972 printf ("No catch clause for exception %s.\n", p
);
1977 while (*p
== ' ' || *p
== '\t') p
++;
1982 /* This shares a lot of code with `print_frame_label_vars' from stack.c. */
1984 static struct symtabs_and_lines
1985 get_catch_sals (this_level_only
)
1986 int this_level_only
;
1988 register struct blockvector
*bl
;
1989 register struct block
*block
;
1990 int index
, have_default
= 0;
1991 struct frame_info
*fi
;
1993 struct symtabs_and_lines sals
;
1994 struct sal_chain
*sal_chain
= 0;
1995 char *blocks_searched
;
1997 /* Not sure whether an error message is always the correct response,
1998 but it's better than a core dump. */
1999 if (selected_frame
== NULL
)
2000 error ("No selected frame.");
2001 block
= get_frame_block (selected_frame
);
2002 fi
= get_frame_info (selected_frame
);
2009 error ("No symbol table info available.\n");
2011 bl
= blockvector_for_pc (BLOCK_END (block
) - 4, &index
);
2012 blocks_searched
= (char *) alloca (BLOCKVECTOR_NBLOCKS (bl
) * sizeof (char));
2013 memset (blocks_searched
, 0, BLOCKVECTOR_NBLOCKS (bl
) * sizeof (char));
2017 CORE_ADDR end
= BLOCK_END (block
) - 4;
2020 if (bl
!= blockvector_for_pc (end
, &index
))
2021 error ("blockvector blotch");
2022 if (BLOCKVECTOR_BLOCK (bl
, index
) != block
)
2023 error ("blockvector botch");
2024 last_index
= BLOCKVECTOR_NBLOCKS (bl
);
2027 /* Don't print out blocks that have gone by. */
2028 while (index
< last_index
2029 && BLOCK_END (BLOCKVECTOR_BLOCK (bl
, index
)) < pc
)
2032 while (index
< last_index
2033 && BLOCK_END (BLOCKVECTOR_BLOCK (bl
, index
)) < end
)
2035 if (blocks_searched
[index
] == 0)
2037 struct block
*b
= BLOCKVECTOR_BLOCK (bl
, index
);
2040 register struct symbol
*sym
;
2042 nsyms
= BLOCK_NSYMS (b
);
2044 for (i
= 0; i
< nsyms
; i
++)
2046 sym
= BLOCK_SYM (b
, i
);
2047 if (STREQ (SYMBOL_NAME (sym
), "default"))
2053 if (SYMBOL_CLASS (sym
) == LOC_LABEL
)
2055 struct sal_chain
*next
= (struct sal_chain
*)
2056 alloca (sizeof (struct sal_chain
));
2057 next
->next
= sal_chain
;
2058 next
->sal
= find_pc_line (SYMBOL_VALUE_ADDRESS (sym
), 0);
2062 blocks_searched
[index
] = 1;
2068 if (sal_chain
&& this_level_only
)
2071 /* After handling the function's top-level block, stop.
2072 Don't continue to its superblock, the block of
2073 per-file symbols. */
2074 if (BLOCK_FUNCTION (block
))
2076 block
= BLOCK_SUPERBLOCK (block
);
2081 struct sal_chain
*tmp_chain
;
2083 /* Count the number of entries. */
2084 for (index
= 0, tmp_chain
= sal_chain
; tmp_chain
;
2085 tmp_chain
= tmp_chain
->next
)
2089 sals
.sals
= (struct symtab_and_line
*)
2090 xmalloc (index
* sizeof (struct symtab_and_line
));
2091 for (index
= 0; sal_chain
; sal_chain
= sal_chain
->next
, index
++)
2092 sals
.sals
[index
] = sal_chain
->sal
;
2098 /* Commands to deal with catching exceptions. */
2101 catch_command_1 (arg
, tempflag
, from_tty
)
2106 /* First, translate ARG into something we can deal with in terms
2109 struct symtabs_and_lines sals
;
2110 struct symtab_and_line sal
;
2111 register struct expression
*cond
= 0;
2112 register struct breakpoint
*b
;
2116 sal
.line
= sal
.pc
= sal
.end
= 0;
2119 /* If no arg given, or if first arg is 'if ', all active catch clauses
2120 are breakpointed. */
2122 if (!arg
|| (arg
[0] == 'i' && arg
[1] == 'f'
2123 && (arg
[2] == ' ' || arg
[2] == '\t')))
2125 /* Grab all active catch clauses. */
2126 sals
= get_catch_sals (0);
2130 /* Grab selected catch clauses. */
2131 error ("catch NAME not implemeneted");
2133 /* This isn't used; I don't know what it was for. */
2134 sals
= map_catch_names (arg
, catch_breakpoint
);
2142 for (i
= 0; i
< sals
.nelts
; i
++)
2144 resolve_sal_pc (&sals
.sals
[i
]);
2148 if (arg
[0] == 'i' && arg
[1] == 'f'
2149 && (arg
[2] == ' ' || arg
[2] == '\t'))
2150 cond
= parse_exp_1 ((arg
+= 2, &arg
),
2151 block_for_pc (sals
.sals
[i
].pc
), 0);
2153 error ("Junk at end of arguments.");
2158 for (i
= 0; i
< sals
.nelts
; i
++)
2163 describe_other_breakpoints (sal
.pc
);
2165 b
= set_raw_breakpoint (sal
);
2166 set_breakpoint_count (breakpoint_count
+ 1);
2167 b
->number
= breakpoint_count
;
2168 b
->type
= bp_breakpoint
;
2170 b
->enable
= enabled
;
2171 b
->disposition
= tempflag
? delete : donttouch
;
2173 printf ("Breakpoint %d at %s", b
->number
, local_hex_string(b
->address
));
2175 printf (": file %s, line %d.", b
->symtab
->filename
, b
->line_number
);
2181 printf ("Multiple breakpoints were set.\n");
2182 printf ("Use the \"delete\" command to delete unwanted breakpoints.\n");
2184 free ((PTR
)sals
.sals
);
2188 /* These aren't used; I don't know what they were for. */
2189 /* Disable breakpoints on all catch clauses described in ARGS. */
2191 disable_catch (args
)
2194 /* Map the disable command to catch clauses described in ARGS. */
2197 /* Enable breakpoints on all catch clauses described in ARGS. */
2202 /* Map the disable command to catch clauses described in ARGS. */
2205 /* Delete breakpoints on all catch clauses in the active scope. */
2210 /* Map the delete command to catch clauses described in ARGS. */
2215 catch_command (arg
, from_tty
)
2219 catch_command_1 (arg
, 0, from_tty
);
2223 clear_command (arg
, from_tty
)
2227 register struct breakpoint
*b
, *b1
;
2228 struct symtabs_and_lines sals
;
2229 struct symtab_and_line sal
;
2230 register struct breakpoint
*found
;
2235 sals
= decode_line_spec (arg
, 1);
2239 sals
.sals
= (struct symtab_and_line
*) xmalloc (sizeof (struct symtab_and_line
));
2240 sal
.line
= default_breakpoint_line
;
2241 sal
.symtab
= default_breakpoint_symtab
;
2243 if (sal
.symtab
== 0)
2244 error ("No source file specified.");
2250 for (i
= 0; i
< sals
.nelts
; i
++)
2252 /* If exact pc given, clear bpts at that pc.
2253 But if sal.pc is zero, clear all bpts on specified line. */
2255 found
= (struct breakpoint
*) 0;
2256 while (breakpoint_chain
2257 && (sal
.pc
? breakpoint_chain
->address
== sal
.pc
2258 : (breakpoint_chain
->symtab
== sal
.symtab
2259 && breakpoint_chain
->line_number
== sal
.line
)))
2261 b1
= breakpoint_chain
;
2262 breakpoint_chain
= b1
->next
;
2269 && b
->next
->type
!= bp_watchpoint
2270 && (sal
.pc
? b
->next
->address
== sal
.pc
2271 : (b
->next
->symtab
== sal
.symtab
2272 && b
->next
->line_number
== sal
.line
)))
2283 error ("No breakpoint at %s.", arg
);
2285 error ("No breakpoint at this line.");
2288 if (found
->next
) from_tty
= 1; /* Always report if deleted more than one */
2289 if (from_tty
) printf ("Deleted breakpoint%s ", found
->next
? "s" : "");
2292 if (from_tty
) printf ("%d ", found
->number
);
2294 delete_breakpoint (found
);
2297 if (from_tty
) putchar ('\n');
2299 free ((PTR
)sals
.sals
);
2302 /* Delete breakpoint in BS if they are `delete' breakpoints.
2303 This is called after any breakpoint is hit, or after errors. */
2306 breakpoint_auto_delete (bs
)
2309 for (; bs
; bs
= bs
->next
)
2310 if (bs
->breakpoint_at
&& bs
->breakpoint_at
->disposition
== delete)
2311 delete_breakpoint (bs
->breakpoint_at
);
2314 /* Delete a breakpoint and clean up all traces of it in the data structures. */
2317 delete_breakpoint (bpt
)
2318 struct breakpoint
*bpt
;
2320 register struct breakpoint
*b
;
2324 target_remove_breakpoint(bpt
->address
, bpt
->shadow_contents
);
2326 if (breakpoint_chain
== bpt
)
2327 breakpoint_chain
= bpt
->next
;
2332 b
->next
= bpt
->next
;
2336 check_duplicates (bpt
->address
);
2338 free_command_lines (&bpt
->commands
);
2340 free ((PTR
)bpt
->cond
);
2341 if (bpt
->cond_string
!= NULL
)
2342 free ((PTR
)bpt
->cond_string
);
2343 if (bpt
->addr_string
!= NULL
)
2344 free ((PTR
)bpt
->addr_string
);
2345 if (bpt
->exp_string
!= NULL
)
2346 free ((PTR
)bpt
->exp_string
);
2348 if (xgdb_verbose
&& bpt
->type
== bp_breakpoint
)
2349 printf ("breakpoint #%d deleted\n", bpt
->number
);
2351 /* Be sure no bpstat's are pointing at it after it's been freed. */
2352 /* FIXME, how can we find all bpstat's? We just check stop_bpstat for now. */
2353 for (bs
= stop_bpstat
; bs
; bs
= bs
->next
)
2354 if (bs
->breakpoint_at
== bpt
)
2355 bs
->breakpoint_at
= NULL
;
2360 delete_command (arg
, from_tty
)
2367 /* Ask user only if there are some breakpoints to delete. */
2369 || (breakpoint_chain
&& query ("Delete all breakpoints? ", 0, 0)))
2371 /* No arg; clear all breakpoints. */
2372 while (breakpoint_chain
)
2373 delete_breakpoint (breakpoint_chain
);
2377 map_breakpoint_numbers (arg
, delete_breakpoint
);
2380 /* Reset a breakpoint given it's struct breakpoint * BINT.
2381 The value we return ends up being the return value from catch_errors.
2382 Unused in this case. */
2385 breakpoint_re_set_one (bint
)
2388 struct breakpoint
*b
= (struct breakpoint
*)bint
; /* get past catch_errs */
2390 struct symtabs_and_lines sals
;
2392 enum enable save_enable
;
2397 if (b
->addr_string
== NULL
)
2399 /* Anything without a string can't be re-set. */
2400 delete_breakpoint (b
);
2403 /* In case we have a problem, disable this breakpoint. We'll restore
2404 its status if we succeed. */
2405 save_enable
= b
->enable
;
2406 b
->enable
= disabled
;
2409 sals
= decode_line_1 (&s
, 1, (struct symtab
*)NULL
, 0);
2410 for (i
= 0; i
< sals
.nelts
; i
++)
2412 resolve_sal_pc (&sals
.sals
[i
]);
2413 if (b
->symtab
!= sals
.sals
[i
].symtab
2414 || b
->line_number
!= sals
.sals
[i
].line
2415 || b
->address
!= sals
.sals
[i
].pc
)
2417 b
->symtab
= sals
.sals
[i
].symtab
;
2418 b
->line_number
= sals
.sals
[i
].line
;
2419 b
->address
= sals
.sals
[i
].pc
;
2421 if (b
->cond_string
!= NULL
)
2425 free ((PTR
)b
->cond
);
2426 b
->cond
= parse_exp_1 (&s
, block_for_pc (sals
.sals
[i
].pc
), 0);
2429 check_duplicates (b
->address
);
2433 b
->enable
= save_enable
; /* Restore it, this worked. */
2435 free ((PTR
)sals
.sals
);
2439 innermost_block
= NULL
;
2440 /* The issue arises of what context to evaluate this in. The same
2441 one as when it was set, but what does that mean when symbols have
2442 been re-read? We could save the filename and functionname, but
2443 if the context is more local than that, the best we could do would
2444 be something like how many levels deep and which index at that
2445 particular level, but that's going to be less stable than filenames
2446 or functionnames. */
2447 /* So for now, just use a global context. */
2448 b
->exp
= parse_expression (b
->exp_string
);
2449 b
->exp_valid_block
= innermost_block
;
2450 b
->val
= evaluate_expression (b
->exp
);
2451 release_value (b
->val
);
2452 if (VALUE_LAZY (b
->val
))
2453 value_fetch_lazy (b
->val
);
2455 if (b
->cond_string
!= NULL
)
2458 b
->cond
= parse_exp_1 (&s
, (struct block
*)0, 0);
2460 if (b
->enable
== enabled
)
2465 printf_filtered ("Deleting unknown breakpoint type %d\n", b
->type
);
2470 case bp_longjmp_resume
:
2471 delete_breakpoint (b
);
2478 /* Re-set all breakpoints after symbols have been re-loaded. */
2480 breakpoint_re_set ()
2482 struct breakpoint
*b
, *temp
;
2483 static char message1
[] = "Error in re-setting breakpoint %d:\n";
2484 char message
[sizeof (message1
) + 30 /* slop */];
2486 /* If we have no current source symtab, and we have any breakpoints,
2487 go through the work of making a source context. */
2488 if (current_source_symtab
== NULL
&& breakpoint_chain
!= 0)
2490 select_source_symtab (NULL
);
2493 ALL_BREAKPOINTS_SAFE (b
, temp
)
2495 sprintf (message
, message1
, b
->number
); /* Format possible error msg */
2496 catch_errors (breakpoint_re_set_one
, (char *) b
, message
);
2499 create_longjmp_breakpoint("longjmp");
2500 create_longjmp_breakpoint("_longjmp");
2501 create_longjmp_breakpoint("siglongjmp");
2502 create_longjmp_breakpoint(NULL
);
2505 /* Took this out (temporaliy at least), since it produces an extra
2506 blank line at startup. This messes up the gdbtests. -PB */
2507 /* Blank line to finish off all those mention() messages we just printed. */
2508 printf_filtered ("\n");
2512 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
2513 If from_tty is nonzero, it prints a message to that effect,
2514 which ends with a period (no newline). */
2517 set_ignore_count (bptnum
, count
, from_tty
)
2518 int bptnum
, count
, from_tty
;
2520 register struct breakpoint
*b
;
2526 if (b
->number
== bptnum
)
2528 b
->ignore_count
= count
;
2531 else if (count
== 0)
2532 printf_filtered ("Will stop next time breakpoint %d is reached.",
2534 else if (count
== 1)
2535 printf_filtered ("Will ignore next crossing of breakpoint %d.",
2538 printf_filtered ("Will ignore next %d crossings of breakpoint %d.",
2543 error ("No breakpoint number %d.", bptnum
);
2546 /* Clear the ignore counts of all breakpoints. */
2548 breakpoint_clear_ignore_counts ()
2550 struct breakpoint
*b
;
2553 b
->ignore_count
= 0;
2556 /* Command to set ignore-count of breakpoint N to COUNT. */
2559 ignore_command (args
, from_tty
)
2567 error_no_arg ("a breakpoint number");
2569 num
= get_number (&p
);
2572 error ("Second argument (specified ignore-count) is missing.");
2574 set_ignore_count (num
,
2575 longest_to_int (value_as_long (parse_and_eval (p
))),
2577 printf_filtered ("\n");
2580 /* Call FUNCTION on each of the breakpoints
2581 whose numbers are given in ARGS. */
2584 map_breakpoint_numbers (args
, function
)
2586 void (*function
) PARAMS ((struct breakpoint
*));
2588 register char *p
= args
;
2591 register struct breakpoint
*b
;
2594 error_no_arg ("one or more breakpoint numbers");
2600 num
= get_number (&p1
);
2603 if (b
->number
== num
)
2608 printf ("No breakpoint number %d.\n", num
);
2615 enable_breakpoint (bpt
)
2616 struct breakpoint
*bpt
;
2618 bpt
->enable
= enabled
;
2620 if (xgdb_verbose
&& bpt
->type
== bp_breakpoint
)
2621 printf ("breakpoint #%d enabled\n", bpt
->number
);
2623 check_duplicates (bpt
->address
);
2624 if (bpt
->type
== bp_watchpoint
)
2626 if (bpt
->exp_valid_block
!= NULL
2627 && !contained_in (get_selected_block (), bpt
->exp_valid_block
))
2630 Cannot enable watchpoint %d because the block in which its expression\n\
2631 is valid is not currently in scope.\n", bpt
->number
);
2632 bpt
->enable
= disabled
;
2636 value_free (bpt
->val
);
2638 bpt
->val
= evaluate_expression (bpt
->exp
);
2639 release_value (bpt
->val
);
2640 if (VALUE_LAZY (bpt
->val
))
2641 value_fetch_lazy (bpt
->val
);
2647 enable_command (args
, from_tty
)
2651 struct breakpoint
*bpt
;
2653 ALL_BREAKPOINTS (bpt
)
2658 enable_breakpoint (bpt
);
2663 map_breakpoint_numbers (args
, enable_breakpoint
);
2667 disable_breakpoint (bpt
)
2668 struct breakpoint
*bpt
;
2670 bpt
->enable
= disabled
;
2672 if (xgdb_verbose
&& bpt
->type
== bp_breakpoint
)
2673 printf_filtered ("breakpoint #%d disabled\n", bpt
->number
);
2675 check_duplicates (bpt
->address
);
2680 disable_command (args
, from_tty
)
2684 register struct breakpoint
*bpt
;
2686 ALL_BREAKPOINTS (bpt
)
2691 disable_breakpoint (bpt
);
2696 map_breakpoint_numbers (args
, disable_breakpoint
);
2700 enable_once_breakpoint (bpt
)
2701 struct breakpoint
*bpt
;
2703 bpt
->enable
= enabled
;
2704 bpt
->disposition
= disable
;
2706 check_duplicates (bpt
->address
);
2711 enable_once_command (args
, from_tty
)
2715 map_breakpoint_numbers (args
, enable_once_breakpoint
);
2719 enable_delete_breakpoint (bpt
)
2720 struct breakpoint
*bpt
;
2722 bpt
->enable
= enabled
;
2723 bpt
->disposition
= delete;
2725 check_duplicates (bpt
->address
);
2730 enable_delete_command (args
, from_tty
)
2734 map_breakpoint_numbers (args
, enable_delete_breakpoint
);
2738 * Use default_breakpoint_'s, or nothing if they aren't valid.
2740 struct symtabs_and_lines
2741 decode_line_spec_1 (string
, funfirstline
)
2745 struct symtabs_and_lines sals
;
2747 error ("Empty line specification.");
2748 if (default_breakpoint_valid
)
2749 sals
= decode_line_1 (&string
, funfirstline
,
2750 default_breakpoint_symtab
, default_breakpoint_line
);
2752 sals
= decode_line_1 (&string
, funfirstline
, (struct symtab
*)NULL
, 0);
2754 error ("Junk at end of line specification: %s", string
);
2759 _initialize_breakpoint ()
2761 breakpoint_chain
= 0;
2762 /* Don't bother to call set_breakpoint_count. $bpnum isn't useful
2763 before a breakpoint is set. */
2764 breakpoint_count
= 0;
2766 add_com ("ignore", class_breakpoint
, ignore_command
,
2767 "Set ignore-count of breakpoint number N to COUNT.");
2769 add_com ("commands", class_breakpoint
, commands_command
,
2770 "Set commands to be executed when a breakpoint is hit.\n\
2771 Give breakpoint number as argument after \"commands\".\n\
2772 With no argument, the targeted breakpoint is the last one set.\n\
2773 The commands themselves follow starting on the next line.\n\
2774 Type a line containing \"end\" to indicate the end of them.\n\
2775 Give \"silent\" as the first line to make the breakpoint silent;\n\
2776 then no output is printed when it is hit, except what the commands print.");
2778 add_com ("condition", class_breakpoint
, condition_command
,
2779 "Specify breakpoint number N to break only if COND is true.\n\
2780 N is an integer; COND is an expression to be evaluated whenever\n\
2781 breakpoint N is reached. ");
2783 add_com ("tbreak", class_breakpoint
, tbreak_command
,
2784 "Set a temporary breakpoint. Args like \"break\" command.\n\
2785 Like \"break\" except the breakpoint is only enabled temporarily,\n\
2786 so it will be disabled when hit. Equivalent to \"break\" followed\n\
2787 by using \"enable once\" on the breakpoint number.");
2789 add_prefix_cmd ("enable", class_breakpoint
, enable_command
,
2790 "Enable some breakpoints.\n\
2791 Give breakpoint numbers (separated by spaces) as arguments.\n\
2792 With no subcommand, breakpoints are enabled until you command otherwise.\n\
2793 This is used to cancel the effect of the \"disable\" command.\n\
2794 With a subcommand you can enable temporarily.",
2795 &enablelist
, "enable ", 1, &cmdlist
);
2797 add_abbrev_prefix_cmd ("breakpoints", class_breakpoint
, enable_command
,
2798 "Enable some breakpoints.\n\
2799 Give breakpoint numbers (separated by spaces) as arguments.\n\
2800 This is used to cancel the effect of the \"disable\" command.\n\
2801 May be abbreviated to simply \"enable\".\n",
2802 &enablebreaklist
, "enable breakpoints ", 1, &enablelist
);
2804 add_cmd ("once", no_class
, enable_once_command
,
2805 "Enable breakpoints for one hit. Give breakpoint numbers.\n\
2806 If a breakpoint is hit while enabled in this fashion, it becomes disabled.\n\
2807 See the \"tbreak\" command which sets a breakpoint and enables it once.",
2810 add_cmd ("delete", no_class
, enable_delete_command
,
2811 "Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
2812 If a breakpoint is hit while enabled in this fashion, it is deleted.",
2815 add_cmd ("delete", no_class
, enable_delete_command
,
2816 "Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
2817 If a breakpoint is hit while enabled in this fashion, it is deleted.",
2820 add_cmd ("once", no_class
, enable_once_command
,
2821 "Enable breakpoints for one hit. Give breakpoint numbers.\n\
2822 If a breakpoint is hit while enabled in this fashion, it becomes disabled.\n\
2823 See the \"tbreak\" command which sets a breakpoint and enables it once.",
2826 add_prefix_cmd ("disable", class_breakpoint
, disable_command
,
2827 "Disable some breakpoints.\n\
2828 Arguments are breakpoint numbers with spaces in between.\n\
2829 To disable all breakpoints, give no argument.\n\
2830 A disabled breakpoint is not forgotten, but has no effect until reenabled.",
2831 &disablelist
, "disable ", 1, &cmdlist
);
2832 add_com_alias ("dis", "disable", class_breakpoint
, 1);
2833 add_com_alias ("disa", "disable", class_breakpoint
, 1);
2835 add_cmd ("breakpoints", class_alias
, disable_command
,
2836 "Disable some breakpoints.\n\
2837 Arguments are breakpoint numbers with spaces in between.\n\
2838 To disable all breakpoints, give no argument.\n\
2839 A disabled breakpoint is not forgotten, but has no effect until reenabled.\n\
2840 This command may be abbreviated \"disable\".",
2843 add_prefix_cmd ("delete", class_breakpoint
, delete_command
,
2844 "Delete some breakpoints or auto-display expressions.\n\
2845 Arguments are breakpoint numbers with spaces in between.\n\
2846 To delete all breakpoints, give no argument.\n\
2848 Also a prefix command for deletion of other GDB objects.\n\
2849 The \"unset\" command is also an alias for \"delete\".",
2850 &deletelist
, "delete ", 1, &cmdlist
);
2851 add_com_alias ("d", "delete", class_breakpoint
, 1);
2853 add_cmd ("breakpoints", class_alias
, delete_command
,
2854 "Delete some breakpoints or auto-display expressions.\n\
2855 Arguments are breakpoint numbers with spaces in between.\n\
2856 To delete all breakpoints, give no argument.\n\
2857 This command may be abbreviated \"delete\".",
2860 add_com ("clear", class_breakpoint
, clear_command
,
2861 "Clear breakpoint at specified line or function.\n\
2862 Argument may be line number, function name, or \"*\" and an address.\n\
2863 If line number is specified, all breakpoints in that line are cleared.\n\
2864 If function is specified, breakpoints at beginning of function are cleared.\n\
2865 If an address is specified, breakpoints at that address are cleared.\n\n\
2866 With no argument, clears all breakpoints in the line that the selected frame\n\
2869 See also the \"delete\" command which clears breakpoints by number.");
2871 add_com ("break", class_breakpoint
, break_command
,
2872 "Set breakpoint at specified line or function.\n\
2873 Argument may be line number, function name, or \"*\" and an address.\n\
2874 If line number is specified, break at start of code for that line.\n\
2875 If function is specified, break at start of code for that function.\n\
2876 If an address is specified, break at that exact address.\n\
2877 With no arg, uses current execution address of selected stack frame.\n\
2878 This is useful for breaking on return to a stack frame.\n\
2880 Multiple breakpoints at one place are permitted, and useful if conditional.\n\
2882 Do \"help breakpoints\" for info on other commands dealing with breakpoints.");
2883 add_com_alias ("b", "break", class_run
, 1);
2884 add_com_alias ("br", "break", class_run
, 1);
2885 add_com_alias ("bre", "break", class_run
, 1);
2886 add_com_alias ("brea", "break", class_run
, 1);
2888 add_info ("breakpoints", breakpoints_info
,
2889 "Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
2890 The \"Type\" column indicates one of:\n\
2891 \tbreakpoint - normal breakpoint\n\
2892 \twatchpoint - watchpoint\n\
2893 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
2894 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
2895 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
2896 address and file/line number respectively.\n\n\
2897 Convenience variable \"$_\" and default examine address for \"x\"\n\
2898 are set to the address of the last breakpoint listed.\n\n\
2899 Convenience variable \"$bpnum\" contains the number of the last\n\
2902 #if MAINTENANCE_CMDS
2904 add_cmd ("breakpoints", class_maintenance
, maintenance_info_breakpoints
,
2905 "Status of all breakpoints, or breakpoint number NUMBER.\n\
2906 The \"Type\" column indicates one of:\n\
2907 \tbreakpoint - normal breakpoint\n\
2908 \twatchpoint - watchpoint\n\
2909 \tlongjmp - internal breakpoint used to step through longjmp()\n\
2910 \tlongjmp resume - internal breakpoint at the target of longjmp()\n\
2911 \tuntil - internal breakpoint used by the \"until\" command\n\
2912 \tfinish - internal breakpoint used by the \"finish\" command\n\
2913 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
2914 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
2915 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
2916 address and file/line number respectively.\n\n\
2917 Convenience variable \"$_\" and default examine address for \"x\"\n\
2918 are set to the address of the last breakpoint listed.\n\n\
2919 Convenience variable \"$bpnum\" contains the number of the last\n\
2921 &maintenanceinfolist
);
2923 #endif /* MAINTENANCE_CMDS */
2925 add_com ("catch", class_breakpoint
, catch_command
,
2926 "Set breakpoints to catch exceptions that are raised.\n\
2927 Argument may be a single exception to catch, multiple exceptions\n\
2928 to catch, or the default exception \"default\". If no arguments\n\
2929 are given, breakpoints are set at all exception handlers catch clauses\n\
2930 within the current scope.\n\
2932 A condition specified for the catch applies to all breakpoints set\n\
2933 with this command\n\
2935 Do \"help breakpoints\" for info on other commands dealing with breakpoints.");
2937 add_com ("watch", class_breakpoint
, watch_command
,
2938 "Set a watchpoint for an expression.\n\
2939 A watchpoint stops execution of your program whenever the value of\n\
2940 an expression changes.");
2942 add_info ("watchpoints", breakpoints_info
,
2943 "Synonym for ``info breakpoints''.");
2946 /* OK, when we call objfile_relocate, we need to relocate breakpoints
2947 too. breakpoint_re_set is not a good choice--for example, if
2948 addr_string contains just a line number without a file name the
2949 breakpoint might get set in a different file. In general, there is
2950 no need to go all the way back to the user's string (though this might
2951 work if some effort were made to canonicalize it), since symtabs and
2952 everything except addresses are still valid.
2954 Probably the best way to solve this is to have each breakpoint save
2955 the objfile and the section number that was used to set it (if set
2956 by "*addr", probably it is best to use find_pc_line to get a symtab
2957 and use the objfile and block_line_section for that symtab). Then
2958 objfile_relocate can call fixup_breakpoints with the objfile and
2959 the new_offsets, and it can relocate only the appropriate breakpoints. */
2961 #ifdef IBM6000_TARGET
2962 /* But for now, just kludge it based on the concept that before an
2963 objfile is relocated the breakpoint is below 0x10000000, and afterwards
2964 it is higher, so that way we only relocate each breakpoint once. */
2967 fixup_breakpoints (low
, high
, delta
)
2972 struct breakpoint
*b
;
2976 if (b
->address
>= low
&& b
->address
<= high
)
2977 b
->address
+= delta
;