1 /* Everything about breakpoints, for GDB.
2 Copyright 1986, 87, 89, 90, 91, 92, 93, 94, 95, 96, 97, 1998
3 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
25 #include "breakpoint.h"
27 #include "expression.h"
33 #include "gdbthread.h"
36 #include "gdb_string.h"
42 /* Prototypes for local functions. */
45 catch_command_1
PARAMS ((char *, int, int));
48 enable_delete_command
PARAMS ((char *, int));
51 enable_delete_breakpoint
PARAMS ((struct breakpoint
*));
54 enable_once_command
PARAMS ((char *, int));
57 enable_once_breakpoint
PARAMS ((struct breakpoint
*));
60 disable_command
PARAMS ((char *, int));
63 enable_command
PARAMS ((char *, int));
66 map_breakpoint_numbers
PARAMS ((char *, void (*)(struct breakpoint
*)));
69 ignore_command
PARAMS ((char *, int));
72 breakpoint_re_set_one
PARAMS ((char *));
75 clear_command
PARAMS ((char *, int));
78 catch_command
PARAMS ((char *, int));
81 handle_gnu_4_16_catch_command
PARAMS ((char *, int, int));
83 static struct symtabs_and_lines
84 get_catch_sals
PARAMS ((int));
87 watch_command
PARAMS ((char *, int));
90 can_use_hardware_watchpoint
PARAMS ((struct value
*));
93 tbreak_command
PARAMS ((char *, int));
96 break_command_1
PARAMS ((char *, int, int));
99 mention
PARAMS ((struct breakpoint
*));
102 set_raw_breakpoint
PARAMS ((struct symtab_and_line
));
105 check_duplicates
PARAMS ((CORE_ADDR
, asection
*));
108 describe_other_breakpoints
PARAMS ((CORE_ADDR
, asection
*));
111 breakpoints_info
PARAMS ((char *, int));
114 breakpoint_1
PARAMS ((int, int));
117 bpstat_alloc
PARAMS ((struct breakpoint
*, bpstat
));
120 breakpoint_cond_eval
PARAMS ((char *));
123 cleanup_executing_breakpoints
PARAMS ((PTR
));
126 commands_command
PARAMS ((char *, int));
129 condition_command
PARAMS ((char *, int));
132 get_number
PARAMS ((char **));
135 set_breakpoint_count
PARAMS ((int));
138 static struct breakpoint
*
139 create_temp_exception_breakpoint
PARAMS ((CORE_ADDR
));
148 remove_breakpoint
PARAMS ((struct breakpoint
*, insertion_state_t
));
150 static int print_it_normal
PARAMS ((bpstat
));
153 enum exception_event_kind kind
;
155 } args_for_catchpoint_enable
;
157 static int watchpoint_check
PARAMS ((char *));
159 static struct symtab_and_line
*
160 cover_target_enable_exception_callback
PARAMS ((args_for_catchpoint_enable
*));
162 static int print_it_done
PARAMS ((bpstat
));
164 static int print_it_noop
PARAMS ((bpstat
));
166 static void maintenance_info_breakpoints
PARAMS ((char *, int));
168 #ifdef GET_LONGJMP_TARGET
169 static void create_longjmp_breakpoint
PARAMS ((char *));
172 static int hw_breakpoint_used_count
PARAMS ((void));
174 static int hw_watchpoint_used_count
PARAMS ((enum bptype
, int *));
176 static void hbreak_command
PARAMS ((char *, int));
178 static void thbreak_command
PARAMS ((char *, int));
180 static void watch_command_1
PARAMS ((char *, int, int));
182 static void rwatch_command
PARAMS ((char *, int));
184 static void awatch_command
PARAMS ((char *, int));
186 static void do_enable_breakpoint
PARAMS ((struct breakpoint
*, enum bpdisp
));
188 /* Prototypes for exported functions. */
191 awatch_command
PARAMS ((char *, int));
194 do_enable_breakpoint
PARAMS ((struct breakpoint
*, enum bpdisp
));
196 /* If FALSE, gdb will not use hardware support for watchpoints, even
197 if such is available. */
198 static int can_use_hw_watchpoints
;
200 void delete_command
PARAMS ((char *, int));
202 void _initialize_breakpoint
PARAMS ((void));
204 void set_breakpoint_count
PARAMS ((int));
206 extern int addressprint
; /* Print machine addresses? */
208 #if defined (GET_LONGJMP_TARGET) || defined (SOLIB_ADD)
209 static int internal_breakpoint_number
= -1;
212 /* Are we executing breakpoint commands? */
213 static int executing_breakpoint_commands
;
215 /* Walk the following statement or block through all breakpoints.
216 ALL_BREAKPOINTS_SAFE does so even if the statment deletes the current
219 #define ALL_BREAKPOINTS(b) for (b = breakpoint_chain; b; b = b->next)
221 #define ALL_BREAKPOINTS_SAFE(b,tmp) \
222 for (b = breakpoint_chain; \
223 b? (tmp=b->next, 1): 0; \
226 /* True if SHIFT_INST_REGS defined, false otherwise. */
228 int must_shift_inst_regs
=
229 #if defined(SHIFT_INST_REGS)
236 /* True if breakpoint hit counts should be displayed in breakpoint info. */
238 int show_breakpoint_hit_counts
= 1;
240 /* Chain of all breakpoints defined. */
242 struct breakpoint
*breakpoint_chain
;
244 /* Number of last breakpoint made. */
246 int breakpoint_count
;
248 /* Pointer to current exception event record */
249 static struct exception_event_record
* current_exception_event
;
251 /* Indicator of whether exception catchpoints should be nuked
252 between runs of a program */
253 int exception_catchpoints_are_fragile
= 0;
255 /* Indicator of when exception catchpoints set-up should be
256 reinitialized -- e.g. when program is re-run */
257 int exception_support_initialized
= 0;
260 /* Set breakpoint count to NUM. */
263 set_breakpoint_count (num
)
266 breakpoint_count
= num
;
267 set_internalvar (lookup_internalvar ("bpnum"),
268 value_from_longest (builtin_type_int
, (LONGEST
) num
));
271 /* Used in run_command to zero the hit count when a new run starts. */
274 clear_breakpoint_hit_counts ()
276 struct breakpoint
*b
;
282 /* Default address, symtab and line to put a breakpoint at
283 for "break" command with no arg.
284 if default_breakpoint_valid is zero, the other three are
285 not valid, and "break" with no arg is an error.
287 This set by print_stack_frame, which calls set_default_breakpoint. */
289 int default_breakpoint_valid
;
290 CORE_ADDR default_breakpoint_address
;
291 struct symtab
*default_breakpoint_symtab
;
292 int default_breakpoint_line
;
294 /* *PP is a string denoting a breakpoint. Get the number of the breakpoint.
295 Advance *PP after the string and any trailing whitespace.
297 Currently the string can either be a number or "$" followed by the name
298 of a convenience variable. Making it an expression wouldn't work well
299 for map_breakpoint_numbers (e.g. "4 + 5 + 6"). */
308 /* Empty line means refer to the last breakpoint. */
309 return breakpoint_count
;
312 /* Make a copy of the name, so we can null-terminate it
313 to pass to lookup_internalvar(). */
318 while (isalnum (*p
) || *p
== '_')
320 varname
= (char *) alloca (p
- start
+ 1);
321 strncpy (varname
, start
, p
- start
);
322 varname
[p
- start
] = '\0';
323 val
= value_of_internalvar (lookup_internalvar (varname
));
324 if (TYPE_CODE (VALUE_TYPE (val
)) != TYPE_CODE_INT
)
326 "Convenience variables used to specify breakpoints must have integer values."
328 retval
= (int) value_as_long (val
);
334 while (*p
>= '0' && *p
<= '9')
337 /* There is no number here. (e.g. "cond a == b"). */
338 error_no_arg ("breakpoint number");
341 if (!(isspace (*p
) || *p
== '\0'))
342 error ("breakpoint number expected");
349 /* condition N EXP -- set break condition of breakpoint N to EXP. */
352 condition_command (arg
, from_tty
)
356 register struct breakpoint
*b
;
361 error_no_arg ("breakpoint number");
364 bnum
= get_number (&p
);
367 if (b
->number
== bnum
)
374 if (b
->cond_string
!= NULL
)
375 free ((PTR
)b
->cond_string
);
380 b
->cond_string
= NULL
;
382 printf_filtered ("Breakpoint %d now unconditional.\n", bnum
);
387 /* I don't know if it matters whether this is the string the user
388 typed in or the decompiled expression. */
389 b
->cond_string
= savestring (arg
, strlen (arg
));
390 b
->cond
= parse_exp_1 (&arg
, block_for_pc (b
->address
), 0);
392 error ("Junk at end of expression");
394 breakpoints_changed ();
398 error ("No breakpoint number %d.", bnum
);
403 commands_command (arg
, from_tty
)
407 register struct breakpoint
*b
;
410 struct command_line
*l
;
412 /* If we allowed this, we would have problems with when to
413 free the storage, if we change the commands currently
416 if (executing_breakpoint_commands
)
417 error ("Can't use the \"commands\" command among a breakpoint's commands.");
420 bnum
= get_number (&p
);
422 error ("Unexpected extra arguments following breakpoint number.");
425 if (b
->number
== bnum
)
428 sprintf (tmpbuf
, "Type commands for when breakpoint %d is hit, one per line.", bnum
);
429 l
= read_command_lines (tmpbuf
, from_tty
);
430 free_command_lines (&b
->commands
);
432 breakpoints_changed ();
435 error ("No breakpoint number %d.", bnum
);
438 /* Like target_read_memory() but if breakpoints are inserted, return
439 the shadow contents instead of the breakpoints themselves.
441 Read "memory data" from whatever target or inferior we have.
442 Returns zero if successful, errno value if not. EIO is used
443 for address out of bounds. If breakpoints are inserted, returns
444 shadow contents, not the breakpoints themselves. From breakpoint.c. */
447 read_memory_nobpt (memaddr
, myaddr
, len
)
453 struct breakpoint
*b
;
454 CORE_ADDR bp_addr
= 0;
457 if (BREAKPOINT_FROM_PC (&bp_addr
, &bp_size
) == NULL
)
458 /* No breakpoints on this machine. */
459 return target_read_memory (memaddr
, myaddr
, len
);
463 if (b
->type
== bp_none
)
464 warning ("attempted to read through apparently deleted breakpoint #%d?\n", b
->number
);
466 /* memory breakpoint? */
467 if (b
->type
== bp_watchpoint
468 || b
->type
== bp_hardware_watchpoint
469 || b
->type
== bp_read_watchpoint
470 || b
->type
== bp_access_watchpoint
)
475 /* Addresses and length of the part of the breakpoint that
477 /* XXXX The m68k, sh and h8300 have different local and remote
478 breakpoint values. BREAKPOINT_FROM_PC still manages to
479 correctly determine the breakpoints memory address and size
480 for these targets. */
481 bp_addr
= b
->address
;
483 if (BREAKPOINT_FROM_PC (&bp_addr
, &bp_size
) == NULL
)
488 if (bp_addr
+ bp_size
<= memaddr
)
489 /* The breakpoint is entirely before the chunk of memory we
492 if (bp_addr
>= memaddr
+ len
)
493 /* The breakpoint is entirely after the chunk of memory we are
496 /* Copy the breakpoint from the shadow contents, and recurse for
497 the things before and after. */
499 /* Offset within shadow_contents. */
502 if (bp_addr
< memaddr
)
504 /* Only copy the second part of the breakpoint. */
505 bp_size
-= memaddr
- bp_addr
;
506 bptoffset
= memaddr
- bp_addr
;
510 if (bp_addr
+ bp_size
> memaddr
+ len
)
512 /* Only copy the first part of the breakpoint. */
513 bp_size
-= (bp_addr
+ bp_size
) - (memaddr
+ len
);
516 memcpy (myaddr
+ bp_addr
- memaddr
,
517 b
->shadow_contents
+ bptoffset
, bp_size
);
519 if (bp_addr
> memaddr
)
521 /* Copy the section of memory before the breakpoint. */
522 status
= read_memory_nobpt (memaddr
, myaddr
, bp_addr
- memaddr
);
527 if (bp_addr
+ bp_size
< memaddr
+ len
)
529 /* Copy the section of memory after the breakpoint. */
530 status
= read_memory_nobpt
532 myaddr
+ bp_addr
+ bp_size
- memaddr
,
533 memaddr
+ len
- (bp_addr
+ bp_size
));
540 /* Nothing overlaps. Just call read_memory_noerr. */
541 return target_read_memory (memaddr
, myaddr
, len
);
545 /* insert_breakpoints is used when starting or continuing the program.
546 remove_breakpoints is used when the program stops.
547 Both return zero if successful,
548 or an `errno' value if could not write the inferior. */
551 insert_breakpoints ()
553 register struct breakpoint
*b
, *temp
;
555 int disabled_breaks
= 0;
557 static char message1
[] = "Error inserting catchpoint %d:\n";
558 static char message
[sizeof (message1
) + 30];
561 ALL_BREAKPOINTS_SAFE (b
, temp
)
563 if (b
->type
!= bp_watchpoint
564 && b
->type
!= bp_hardware_watchpoint
565 && b
->type
!= bp_read_watchpoint
566 && b
->type
!= bp_access_watchpoint
567 && b
->type
!= bp_catch_fork
568 && b
->type
!= bp_catch_vfork
569 && b
->type
!= bp_catch_exec
570 && b
->type
!= bp_catch_throw
571 && b
->type
!= bp_catch_catch
572 && b
->enable
!= disabled
573 && b
->enable
!= shlib_disabled
574 && b
->enable
!= call_disabled
578 if (b
->type
== bp_hardware_breakpoint
)
579 val
= target_insert_hw_breakpoint(b
->address
, b
->shadow_contents
);
582 /* Check to see if breakpoint is in an overlay section;
583 if so, we should set the breakpoint at the LMA address.
584 Only if the section is currently mapped should we ALSO
585 set a break at the VMA address. */
586 if (overlay_debugging
&& b
->section
&&
587 section_is_overlay (b
->section
))
591 addr
= overlay_unmapped_address (b
->address
, b
->section
);
592 val
= target_insert_breakpoint (addr
, b
->shadow_contents
);
593 /* This would be the time to check val, to see if the
594 breakpoint write to the load address succeeded.
595 However, this might be an ordinary occurrance, eg. if
596 the unmapped overlay is in ROM. */
597 val
= 0; /* in case unmapped address failed */
598 if (section_is_mapped (b
->section
))
599 val
= target_insert_breakpoint (b
->address
,
602 else /* ordinary (non-overlay) address */
603 val
= target_insert_breakpoint(b
->address
, b
->shadow_contents
);
607 /* Can't set the breakpoint. */
608 #if defined (DISABLE_UNSETTABLE_BREAK)
609 if (DISABLE_UNSETTABLE_BREAK (b
->address
))
611 /* See also: disable_breakpoints_in_shlibs. */
613 b
->enable
= shlib_disabled
;
614 if (!disabled_breaks
)
616 target_terminal_ours_for_output ();
617 fprintf_unfiltered (gdb_stderr
,
618 "Cannot insert breakpoint %d:\n", b
->number
);
619 printf_filtered ("Temporarily disabling shared library breakpoints:\n");
622 printf_filtered ("%d ", b
->number
);
627 target_terminal_ours_for_output ();
628 fprintf_unfiltered (gdb_stderr
, "Cannot insert breakpoint %d:\n", b
->number
);
629 #ifdef ONE_PROCESS_WRITETEXT
630 fprintf_unfiltered (gdb_stderr
,
631 "The same program may be running in another process.\n");
633 memory_error (val
, b
->address
); /* which bombs us out */
639 else if (ep_is_exception_catchpoint (b
)
640 && b
->enable
!= disabled
641 && b
->enable
!= shlib_disabled
642 && b
->enable
!= call_disabled
647 /* If we get here, we must have a callback mechanism for exception
648 events -- with g++ style embedded label support, we insert
649 ordinary breakpoints and not catchpoints. */
650 struct symtab_and_line
* sal
;
651 args_for_catchpoint_enable args
;
652 sprintf (message
, message1
, b
->number
); /* Format possible error message */
654 val
= target_insert_breakpoint(b
->address
, b
->shadow_contents
);
657 /* Couldn't set breakpoint for some reason */
658 target_terminal_ours_for_output ();
659 fprintf_unfiltered (gdb_stderr
,
660 "Cannot insert catchpoint %d; disabling it\n", b
->number
);
661 b
->enable
= disabled
;
665 /* Bp set, now make sure callbacks are enabled */
666 args
.kind
= b
->type
== bp_catch_catch
? EX_EVENT_CATCH
: EX_EVENT_THROW
;
668 sal
= (struct symtab_and_line
*)
669 catch_errors ((int (*) PARAMS ((char *)))
670 cover_target_enable_exception_callback
,
672 message
, RETURN_MASK_ALL
);
673 if (sal
&& (sal
!= (struct symtab_and_line
*) -1))
677 /* Check if something went wrong; sal == 0 can be ignored */
678 if (sal
== (struct symtab_and_line
*) -1)
680 /* something went wrong */
681 target_terminal_ours_for_output ();
682 fprintf_unfiltered (gdb_stderr
, "Cannot insert catchpoint %d; disabling it\n", b
->number
);
683 b
->enable
= disabled
;
688 else if ((b
->type
== bp_hardware_watchpoint
||
689 b
->type
== bp_read_watchpoint
||
690 b
->type
== bp_access_watchpoint
)
691 && b
->enable
== enabled
695 struct frame_info
*saved_frame
;
696 int saved_level
, within_current_scope
;
697 value_ptr mark
= value_mark ();
700 /* Save the current frame and level so we can restore it after
701 evaluating the watchpoint expression on its own frame. */
702 saved_frame
= selected_frame
;
703 saved_level
= selected_frame_level
;
705 /* Determine if the watchpoint is within scope. */
706 if (b
->exp_valid_block
== NULL
)
707 within_current_scope
= 1;
710 struct frame_info
*fi
;
712 /* There might be no current frame at this moment if we are
713 resuming from a step over a breakpoint.
714 Set up current frame before trying to find the watchpoint
716 get_current_frame ();
717 fi
= find_frame_addr_in_frame_chain (b
->watchpoint_frame
);
718 within_current_scope
= (fi
!= NULL
);
719 if (within_current_scope
)
720 select_frame (fi
, -1);
723 if (within_current_scope
)
725 /* Evaluate the expression and cut the chain of values
726 produced off from the value chain. */
727 v
= evaluate_expression (b
->exp
);
728 value_release_to_mark (mark
);
733 /* Look at each value on the value chain. */
734 for ( ; v
; v
=v
->next
)
736 /* If it's a memory location, then we must watch it. */
737 if (v
->lval
== lval_memory
)
741 addr
= VALUE_ADDRESS (v
) + VALUE_OFFSET (v
);
742 len
= TYPE_LENGTH (VALUE_TYPE (v
));
744 if (b
->type
== bp_read_watchpoint
)
746 else if (b
->type
== bp_access_watchpoint
)
749 val
= target_insert_watchpoint (addr
, len
, type
);
758 /* Failure to insert a watchpoint on any memory value in the
759 value chain brings us here. */
761 warning ("Hardware watchpoint %d: Could not insert watchpoint\n",
767 Hardware watchpoint %d deleted because the program has left the block in\n\
768 which its expression is valid.\n", b
->number
);
769 if (b
->related_breakpoint
)
770 b
->related_breakpoint
->disposition
= del_at_next_stop
;
771 b
->disposition
= del_at_next_stop
;
774 /* Restore the frame and level. */
775 if ((saved_frame
!= selected_frame
) ||
776 (saved_level
!= selected_frame_level
))
777 select_and_print_frame (saved_frame
, saved_level
);
779 else if ((b
->type
== bp_catch_fork
780 || b
->type
== bp_catch_vfork
781 || b
->type
== bp_catch_exec
)
782 && b
->enable
== enabled
790 val
= target_insert_fork_catchpoint (inferior_pid
);
792 case bp_catch_vfork
:
793 val
= target_insert_vfork_catchpoint (inferior_pid
);
796 val
= target_insert_exec_catchpoint (inferior_pid
);
801 target_terminal_ours_for_output ();
802 fprintf_unfiltered (gdb_stderr
, "Cannot insert catchpoint %d:\n", b
->number
);
809 printf_filtered ("\n");
816 remove_breakpoints ()
818 register struct breakpoint
*b
;
825 val
= remove_breakpoint (b
, mark_uninserted
);
834 reattach_breakpoints (pid
)
837 register struct breakpoint
*b
;
839 int saved_inferior_pid
= inferior_pid
;
841 inferior_pid
= pid
; /* Because remove_breakpoint will use this global. */
846 remove_breakpoint (b
, mark_inserted
);
847 if (b
->type
== bp_hardware_breakpoint
)
848 val
= target_insert_hw_breakpoint(b
->address
, b
->shadow_contents
);
850 val
= target_insert_breakpoint(b
->address
, b
->shadow_contents
);
853 inferior_pid
= saved_inferior_pid
;
858 inferior_pid
= saved_inferior_pid
;
863 update_breakpoints_after_exec ()
865 struct breakpoint
* b
;
866 struct breakpoint
* temp
;
868 /* Doing this first prevents the badness of having delete_breakpoint()
869 write a breakpoint's current "shadow contents" to lift the bp. That
870 shadow is NOT valid after an exec()! */
871 mark_breakpoints_out ();
873 ALL_BREAKPOINTS_SAFE (b
, temp
)
875 /* Solib breakpoints must be explicitly reset after an exec(). */
876 if (b
->type
== bp_shlib_event
)
878 delete_breakpoint (b
);
882 /* Step-resume breakpoints are meaningless after an exec(). */
883 if (b
->type
== bp_step_resume
)
885 delete_breakpoint (b
);
889 /* Ditto the sigtramp handler breakpoints. */
890 if (b
->type
== bp_through_sigtramp
)
892 delete_breakpoint (b
);
896 /* Ditto the exception-handling catchpoints. */
897 if ((b
->type
== bp_catch_catch
) || (b
->type
== bp_catch_throw
))
899 delete_breakpoint (b
);
903 /* Don't delete an exec catchpoint, because else the inferior
904 won't stop when it ought!
906 Similarly, we probably ought to keep vfork catchpoints, 'cause
907 on this target, we may not be able to stop when the vfork is seen,
908 but only when the subsequent exec is seen. (And because deleting
909 fork catchpoints here but not vfork catchpoints will seem mysterious
910 to users, keep those too.)
912 ??rehrauer: Let's hope that merely clearing out this catchpoint's
913 target address field, if any, is sufficient to have it be reset
914 automagically. Certainly on HP-UX that's true. */
915 if ((b
->type
== bp_catch_exec
) ||
916 (b
->type
== bp_catch_vfork
) ||
917 (b
->type
== bp_catch_fork
))
919 b
->address
= (CORE_ADDR
) NULL
;
923 /* bp_finish is a special case. The only way we ought to be able
924 to see one of these when an exec() has happened, is if the user
925 caught a vfork, and then said "finish". Ordinarily a finish just
926 carries them to the call-site of the current callee, by setting
927 a temporary bp there and resuming. But in this case, the finish
928 will carry them entirely through the vfork & exec.
930 We don't want to allow a bp_finish to remain inserted now. But
931 we can't safely delete it, 'cause finish_command has a handle to
932 the bp on a bpstat, and will later want to delete it. There's a
933 chance (and I've seen it happen) that if we delete the bp_finish
934 here, that its storage will get reused by the time finish_command
935 gets 'round to deleting the "use to be a bp_finish" breakpoint.
936 We really must allow finish_command to delete a bp_finish.
938 In the absense of a general solution for the "how do we know it's
939 safe to delete something others may have handles to?" problem, what
940 we'll do here is just uninsert the bp_finish, and let finish_command
943 (We know the bp_finish is "doomed" in the sense that it's momentary,
944 and will be deleted as soon as finish_command sees the inferior stopped.
945 So it doesn't matter that the bp's address is probably bogus in the
946 new a.out, unlike e.g., the solib breakpoints.) */
947 if (b
->type
== bp_finish
)
952 /* Without a symbolic address, we have little hope of the
953 pre-exec() address meaning the same thing in the post-exec()
955 if (b
->addr_string
== NULL
)
957 delete_breakpoint (b
);
961 /* If this breakpoint has survived the above battery of checks, then
962 it must have a symbolic address. Be sure that it gets reevaluated
963 to a target address, rather than reusing the old evaluation. */
964 b
->address
= (CORE_ADDR
) NULL
;
969 detach_breakpoints (pid
)
972 register struct breakpoint
*b
;
974 int saved_inferior_pid
= inferior_pid
;
976 if (pid
== inferior_pid
)
977 error ("Cannot detach breakpoints of inferior_pid");
979 inferior_pid
= pid
; /* Because remove_breakpoint will use this global. */
984 val
= remove_breakpoint (b
, mark_inserted
);
987 inferior_pid
= saved_inferior_pid
;
992 inferior_pid
= saved_inferior_pid
;
997 remove_breakpoint (b
, is
)
998 struct breakpoint
*b
;
999 insertion_state_t is
;
1003 if (b
->type
== bp_none
)
1004 warning ("attempted to remove apparently deleted breakpoint #%d?\n", b
->number
);
1006 if (b
->type
!= bp_watchpoint
1007 && b
->type
!= bp_hardware_watchpoint
1008 && b
->type
!= bp_read_watchpoint
1009 && b
->type
!= bp_access_watchpoint
1010 && b
->type
!= bp_catch_fork
1011 && b
->type
!= bp_catch_vfork
1012 && b
->type
!= bp_catch_exec
1013 && b
->type
!= bp_catch_catch
1014 && b
->type
!= bp_catch_throw
)
1017 if (b
->type
== bp_hardware_breakpoint
)
1018 val
= target_remove_hw_breakpoint(b
->address
, b
->shadow_contents
);
1021 /* Check to see if breakpoint is in an overlay section;
1022 if so, we should remove the breakpoint at the LMA address.
1023 If that is not equal to the raw address, then we should
1024 presumable remove the breakpoint there as well. */
1025 if (overlay_debugging
&& b
->section
&&
1026 section_is_overlay (b
->section
))
1030 addr
= overlay_unmapped_address (b
->address
, b
->section
);
1031 val
= target_remove_breakpoint (addr
, b
->shadow_contents
);
1032 /* This would be the time to check val, to see if the
1033 shadow breakpoint write to the load address succeeded.
1034 However, this might be an ordinary occurrance, eg. if
1035 the unmapped overlay is in ROM. */
1036 val
= 0; /* in case unmapped address failed */
1037 if (section_is_mapped (b
->section
))
1038 val
= target_remove_breakpoint (b
->address
,
1039 b
->shadow_contents
);
1041 else /* ordinary (non-overlay) address */
1042 val
= target_remove_breakpoint(b
->address
, b
->shadow_contents
);
1046 b
->inserted
= (is
== mark_inserted
);
1048 else if ((b
->type
== bp_hardware_watchpoint
||
1049 b
->type
== bp_read_watchpoint
||
1050 b
->type
== bp_access_watchpoint
)
1051 && b
->enable
== enabled
1056 b
->inserted
= (is
== mark_inserted
);
1057 /* Walk down the saved value chain. */
1058 for (v
= b
->val_chain
; v
; v
= v
->next
)
1060 /* For each memory reference remove the watchpoint
1062 if (v
->lval
== lval_memory
)
1064 int addr
, len
, type
;
1066 addr
= VALUE_ADDRESS (v
) + VALUE_OFFSET (v
);
1067 len
= TYPE_LENGTH (VALUE_TYPE (v
));
1069 if (b
->type
== bp_read_watchpoint
)
1071 else if (b
->type
== bp_access_watchpoint
)
1074 val
= target_remove_watchpoint (addr
, len
, type
);
1080 /* Failure to remove any of the hardware watchpoints comes here. */
1081 if ((is
== mark_uninserted
) && (b
->inserted
))
1082 warning ("Hardware watchpoint %d: Could not remove watchpoint\n",
1085 /* Free the saved value chain. We will construct a new one
1086 the next time the watchpoint is inserted. */
1087 for (v
= b
->val_chain
; v
; v
= n
)
1092 b
->val_chain
= NULL
;
1094 else if ((b
->type
== bp_catch_fork
||
1095 b
->type
== bp_catch_vfork
||
1096 b
->type
== bp_catch_exec
)
1097 && b
->enable
== enabled
1104 val
= target_remove_fork_catchpoint (inferior_pid
);
1106 case bp_catch_vfork
:
1107 val
= target_remove_vfork_catchpoint (inferior_pid
);
1109 case bp_catch_exec
:
1110 val
= target_remove_exec_catchpoint (inferior_pid
);
1115 b
->inserted
= (is
== mark_inserted
);
1117 else if ((b
->type
== bp_catch_catch
||
1118 b
->type
== bp_catch_throw
)
1119 && b
->enable
== enabled
1123 val
= target_remove_breakpoint(b
->address
, b
->shadow_contents
);
1126 b
->inserted
= (is
== mark_inserted
);
1128 else if (ep_is_exception_catchpoint (b
)
1129 && b
->inserted
/* sometimes previous insert doesn't happen */
1130 && b
->enable
== enabled
1134 val
= target_remove_breakpoint(b
->address
, b
->shadow_contents
);
1138 b
->inserted
= (is
== mark_inserted
);
1144 /* Clear the "inserted" flag in all breakpoints. */
1147 mark_breakpoints_out ()
1149 register struct breakpoint
*b
;
1155 /* Clear the "inserted" flag in all breakpoints and delete any breakpoints
1156 which should go away between runs of the program.
1158 Plus other such housekeeping that has to be done for breakpoints
1161 Note: this function gets called at the end of a run (by generic_mourn_inferior)
1162 and when a run begins (by init_wait_for_inferior). */
1167 breakpoint_init_inferior (context
)
1168 enum inf_context context
;
1170 register struct breakpoint
*b
, *temp
;
1171 static int warning_needed
= 0;
1173 ALL_BREAKPOINTS_SAFE (b
, temp
)
1180 case bp_watchpoint_scope
:
1182 /* If the call dummy breakpoint is at the entry point it will
1183 cause problems when the inferior is rerun, so we better
1186 Also get rid of scope breakpoints. */
1187 delete_breakpoint (b
);
1191 case bp_hardware_watchpoint
:
1192 case bp_read_watchpoint
:
1193 case bp_access_watchpoint
:
1195 /* Likewise for watchpoints on local expressions. */
1196 if (b
->exp_valid_block
!= NULL
)
1197 delete_breakpoint (b
);
1200 /* Likewise for exception catchpoints in dynamic-linked
1201 executables where required */
1202 if (ep_is_exception_catchpoint (b
) &&
1203 exception_catchpoints_are_fragile
)
1206 delete_breakpoint (b
);
1212 if (exception_catchpoints_are_fragile
)
1213 exception_support_initialized
= 0;
1215 /* Don't issue the warning unless it's really needed... */
1216 if (warning_needed
&& (context
!= inf_exited
))
1218 warning ("Exception catchpoints from last run were deleted, you must reinsert them explicitly");
1223 /* breakpoint_here_p (PC) returns 1 if an enabled breakpoint exists at PC.
1224 When continuing from a location with a breakpoint,
1225 we actually single step once before calling insert_breakpoints. */
1228 breakpoint_here_p (pc
)
1231 register struct breakpoint
*b
;
1234 if (b
->enable
== enabled
1235 && b
->enable
!= shlib_disabled
1236 && b
->enable
!= call_disabled
1237 && b
->address
== pc
) /* bp is enabled and matches pc */
1239 if (overlay_debugging
&&
1240 section_is_overlay (b
->section
) &&
1241 !section_is_mapped (b
->section
))
1242 continue; /* unmapped overlay -- can't be a match */
1250 /* breakpoint_inserted_here_p (PC) is just like breakpoint_here_p(), but it
1251 only returns true if there is actually a breakpoint inserted at PC. */
1254 breakpoint_inserted_here_p (pc
)
1257 register struct breakpoint
*b
;
1261 && b
->address
== pc
) /* bp is inserted and matches pc */
1263 if (overlay_debugging
&&
1264 section_is_overlay (b
->section
) &&
1265 !section_is_mapped (b
->section
))
1266 continue; /* unmapped overlay -- can't be a match */
1274 /* Return nonzero if FRAME is a dummy frame. We can't use PC_IN_CALL_DUMMY
1275 because figuring out the saved SP would take too much time, at least using
1276 get_saved_register on the 68k. This means that for this function to
1277 work right a port must use the bp_call_dummy breakpoint. */
1280 frame_in_dummy (frame
)
1281 struct frame_info
*frame
;
1284 #ifdef USE_GENERIC_DUMMY_FRAMES
1285 return generic_pc_in_call_dummy (frame
->pc
, frame
->frame
);
1287 struct breakpoint
*b
;
1291 static ULONGEST dummy
[] = CALL_DUMMY
;
1293 if (b
->type
== bp_call_dummy
1294 && b
->frame
== frame
->frame
1296 /* We need to check the PC as well as the frame on the sparc,
1297 for signals.exp in the testsuite. */
1300 - sizeof (dummy
) / sizeof (LONGEST
) * REGISTER_SIZE
))
1301 && frame
->pc
<= b
->address
)
1304 #endif /* GENERIC_DUMMY_FRAMES */
1305 #endif /* CALL_DUMMY */
1309 /* breakpoint_match_thread (PC, PID) returns true if the breakpoint at PC
1310 is valid for process/thread PID. */
1313 breakpoint_thread_match (pc
, pid
)
1317 struct breakpoint
*b
;
1320 thread
= pid_to_thread_id (pid
);
1323 if (b
->enable
!= disabled
1324 && b
->enable
!= shlib_disabled
1325 && b
->enable
!= call_disabled
1327 && (b
->thread
== -1 || b
->thread
== thread
))
1329 if (overlay_debugging
&&
1330 section_is_overlay (b
->section
) &&
1331 !section_is_mapped (b
->section
))
1332 continue; /* unmapped overlay -- can't be a match */
1341 /* bpstat stuff. External routines' interfaces are documented
1345 ep_is_catchpoint (ep
)
1346 struct breakpoint
* ep
;
1349 (ep
->type
== bp_catch_load
)
1350 || (ep
->type
== bp_catch_unload
)
1351 || (ep
->type
== bp_catch_fork
)
1352 || (ep
->type
== bp_catch_vfork
)
1353 || (ep
->type
== bp_catch_exec
)
1354 || (ep
->type
== bp_catch_catch
)
1355 || (ep
->type
== bp_catch_throw
)
1358 /* ??rehrauer: Add more kinds here, as are implemented... */
1363 ep_is_shlib_catchpoint (ep
)
1364 struct breakpoint
* ep
;
1367 (ep
->type
== bp_catch_load
)
1368 || (ep
->type
== bp_catch_unload
)
1373 ep_is_exception_catchpoint (ep
)
1374 struct breakpoint
* ep
;
1377 (ep
->type
== bp_catch_catch
)
1378 || (ep
->type
== bp_catch_throw
)
1382 /* Clear a bpstat so that it says we are not at any breakpoint.
1383 Also free any storage that is part of a bpstat. */
1398 if (p
->old_val
!= NULL
)
1399 value_free (p
->old_val
);
1406 /* Return a copy of a bpstat. Like "bs1 = bs2" but all storage that
1407 is part of the bpstat is copied as well. */
1415 bpstat retval
= NULL
;
1420 for (; bs
!= NULL
; bs
= bs
->next
)
1422 tmp
= (bpstat
) xmalloc (sizeof (*tmp
));
1423 memcpy (tmp
, bs
, sizeof (*tmp
));
1425 /* This is the first thing in the chain. */
1435 /* Find the bpstat associated with this breakpoint */
1438 bpstat_find_breakpoint(bsp
, breakpoint
)
1440 struct breakpoint
*breakpoint
;
1442 if (bsp
== NULL
) return NULL
;
1444 for (;bsp
!= NULL
; bsp
= bsp
->next
) {
1445 if (bsp
->breakpoint_at
== breakpoint
) return bsp
;
1450 /* Find a step_resume breakpoint associated with this bpstat.
1451 (If there are multiple step_resume bp's on the list, this function
1452 will arbitrarily pick one.)
1454 It is an error to use this function if BPSTAT doesn't contain a
1455 step_resume breakpoint.
1457 See wait_for_inferior's use of this function. */
1459 bpstat_find_step_resume_breakpoint (bsp
)
1463 error ("Internal error (bpstat_find_step_resume_breakpoint)");
1465 for (; bsp
!= NULL
; bsp
= bsp
->next
)
1467 if ((bsp
->breakpoint_at
!= NULL
) &&
1468 (bsp
->breakpoint_at
->type
== bp_step_resume
))
1469 return bsp
->breakpoint_at
;
1472 error ("Internal error (no step_resume breakpoint found)");
1476 /* Return the breakpoint number of the first breakpoint we are stopped
1477 at. *BSP upon return is a bpstat which points to the remaining
1478 breakpoints stopped at (but which is not guaranteed to be good for
1479 anything but further calls to bpstat_num).
1480 Return 0 if passed a bpstat which does not indicate any breakpoints. */
1486 struct breakpoint
*b
;
1489 return 0; /* No more breakpoint values */
1492 b
= (*bsp
)->breakpoint_at
;
1493 *bsp
= (*bsp
)->next
;
1495 return -1; /* breakpoint that's been deleted since */
1497 return b
->number
; /* We have its number */
1501 /* Modify BS so that the actions will not be performed. */
1504 bpstat_clear_actions (bs
)
1507 for (; bs
!= NULL
; bs
= bs
->next
)
1509 bs
->commands
= NULL
;
1510 if (bs
->old_val
!= NULL
)
1512 value_free (bs
->old_val
);
1518 /* Stub for cleaning up our state if we error-out of a breakpoint command */
1521 cleanup_executing_breakpoints (ignore
)
1524 executing_breakpoint_commands
= 0;
1527 /* Execute all the commands associated with all the breakpoints at this
1528 location. Any of these commands could cause the process to proceed
1529 beyond this point, etc. We look out for such changes by checking
1530 the global "breakpoint_proceeded" after each command. */
1533 bpstat_do_actions (bsp
)
1537 struct cleanup
*old_chain
;
1538 struct command_line
*cmd
;
1540 /* Avoid endless recursion if a `source' command is contained
1542 if (executing_breakpoint_commands
)
1545 executing_breakpoint_commands
= 1;
1546 old_chain
= make_cleanup (cleanup_executing_breakpoints
, 0);
1549 /* Note that (as of this writing), our callers all appear to
1550 be passing us the address of global stop_bpstat. And, if
1551 our calls to execute_control_command cause the inferior to
1552 proceed, that global (and hence, *bsp) will change.
1554 We must be careful to not touch *bsp unless the inferior
1555 has not proceeded. */
1557 /* This pointer will iterate over the list of bpstat's. */
1560 breakpoint_proceeded
= 0;
1561 for (; bs
!= NULL
; bs
= bs
->next
)
1566 execute_control_command (cmd
);
1568 if (breakpoint_proceeded
)
1573 if (breakpoint_proceeded
)
1574 /* The inferior is proceeded by the command; bomb out now.
1575 The bpstat chain has been blown away by wait_for_inferior.
1576 But since execution has stopped again, there is a new bpstat
1577 to look at, so start over. */
1580 bs
->commands
= NULL
;
1583 executing_breakpoint_commands
= 0;
1584 discard_cleanups (old_chain
);
1587 /* This is the normal print_it function for a bpstat. In the future,
1588 much of this logic could (should?) be moved to bpstat_stop_status,
1589 by having it set different print_it functions.
1591 Current scheme: When we stop, bpstat_print() is called.
1592 It loops through the bpstat list of things causing this stop,
1593 calling the print_it function for each one. The default
1594 print_it function, used for breakpoints, is print_it_normal().
1595 (Also see print_it_noop() and print_it_done()).
1597 Return values from this routine (used by bpstat_print() to
1599 1: Means we printed something, and we do *not* desire that
1600 something to be followed by a location.
1601 0: Means we printed something, and we *do* desire that
1602 something to be followed by a location.
1603 -1: Means we printed nothing. */
1606 print_it_normal (bs
)
1609 /* bs->breakpoint_at can be NULL if it was a momentary breakpoint
1610 which has since been deleted. */
1611 if (bs
->breakpoint_at
== NULL
1612 || (bs
->breakpoint_at
->type
!= bp_breakpoint
1613 && bs
->breakpoint_at
->type
!= bp_catch_load
1614 && bs
->breakpoint_at
->type
!= bp_catch_unload
1615 && bs
->breakpoint_at
->type
!= bp_catch_fork
1616 && bs
->breakpoint_at
->type
!= bp_catch_vfork
1617 && bs
->breakpoint_at
->type
!= bp_catch_exec
1618 && bs
->breakpoint_at
->type
!= bp_catch_catch
1619 && bs
->breakpoint_at
->type
!= bp_catch_throw
1620 && bs
->breakpoint_at
->type
!= bp_hardware_breakpoint
1621 && bs
->breakpoint_at
->type
!= bp_watchpoint
1622 && bs
->breakpoint_at
->type
!= bp_read_watchpoint
1623 && bs
->breakpoint_at
->type
!= bp_access_watchpoint
1624 && bs
->breakpoint_at
->type
!= bp_hardware_watchpoint
))
1627 if (ep_is_shlib_catchpoint (bs
->breakpoint_at
))
1629 annotate_catchpoint (bs
->breakpoint_at
->number
);
1630 printf_filtered ("\nCatchpoint %d (", bs
->breakpoint_at
->number
);
1631 if (bs
->breakpoint_at
->type
== bp_catch_load
)
1632 printf_filtered ("loaded");
1633 else if (bs
->breakpoint_at
->type
== bp_catch_unload
)
1634 printf_filtered ("unloaded");
1635 printf_filtered (" %s), ", bs
->breakpoint_at
->triggered_dll_pathname
);
1638 else if (bs
->breakpoint_at
->type
== bp_catch_fork
||
1639 bs
->breakpoint_at
->type
== bp_catch_vfork
)
1641 annotate_catchpoint (bs
->breakpoint_at
->number
);
1642 printf_filtered ("\nCatchpoint %d (", bs
->breakpoint_at
->number
);
1643 if (bs
->breakpoint_at
->type
== bp_catch_fork
)
1644 printf_filtered ("forked");
1645 else if (bs
->breakpoint_at
->type
== bp_catch_vfork
)
1646 printf_filtered ("vforked");
1647 printf_filtered (" process %d), ", bs
->breakpoint_at
->forked_inferior_pid
);
1650 else if (bs
->breakpoint_at
->type
== bp_catch_exec
)
1652 annotate_catchpoint (bs
->breakpoint_at
->number
);
1653 printf_filtered ("\nCatchpoint %d (exec'd %s), ",
1654 bs
->breakpoint_at
->number
,
1655 bs
->breakpoint_at
->exec_pathname
);
1658 else if (bs
->breakpoint_at
->type
== bp_catch_catch
)
1660 if (current_exception_event
&& (CURRENT_EXCEPTION_KIND
== EX_EVENT_CATCH
))
1662 annotate_catchpoint (bs
->breakpoint_at
->number
);
1663 printf_filtered ("\nCatchpoint %d (exception caught), ", bs
->breakpoint_at
->number
);
1664 printf_filtered ("throw location ");
1665 if (CURRENT_EXCEPTION_THROW_PC
&& CURRENT_EXCEPTION_THROW_LINE
)
1666 printf_filtered ("%s:%d",
1667 CURRENT_EXCEPTION_THROW_FILE
,
1668 CURRENT_EXCEPTION_THROW_LINE
);
1670 printf_filtered ("unknown");
1672 printf_filtered (", catch location ");
1673 if (CURRENT_EXCEPTION_CATCH_PC
&& CURRENT_EXCEPTION_CATCH_LINE
)
1674 printf_filtered ("%s:%d",
1675 CURRENT_EXCEPTION_CATCH_FILE
,
1676 CURRENT_EXCEPTION_CATCH_LINE
);
1678 printf_filtered ("unknown");
1680 printf_filtered ("\n");
1681 return 1; /* don't bother to print location frame info */
1685 return -1; /* really throw, some other bpstat will handle it */
1688 else if (bs
->breakpoint_at
->type
== bp_catch_throw
)
1690 if (current_exception_event
&& (CURRENT_EXCEPTION_KIND
== EX_EVENT_THROW
))
1692 annotate_catchpoint (bs
->breakpoint_at
->number
);
1693 printf_filtered ("\nCatchpoint %d (exception thrown), ", bs
->breakpoint_at
->number
);
1694 printf_filtered ("throw location ");
1695 if (CURRENT_EXCEPTION_THROW_PC
&& CURRENT_EXCEPTION_THROW_LINE
)
1696 printf_filtered ("%s:%d",
1697 CURRENT_EXCEPTION_THROW_FILE
,
1698 CURRENT_EXCEPTION_THROW_LINE
);
1700 printf_filtered ("unknown");
1702 printf_filtered (", catch location ");
1703 if (CURRENT_EXCEPTION_CATCH_PC
&& CURRENT_EXCEPTION_CATCH_LINE
)
1704 printf_filtered ("%s:%d",
1705 CURRENT_EXCEPTION_CATCH_FILE
,
1706 CURRENT_EXCEPTION_CATCH_LINE
);
1708 printf_filtered ("unknown");
1710 printf_filtered ("\n");
1711 return 1; /* don't bother to print location frame info */
1715 return -1; /* really catch, some other bpstat willhandle it */
1719 else if (bs
->breakpoint_at
->type
== bp_breakpoint
||
1720 bs
->breakpoint_at
->type
== bp_hardware_breakpoint
)
1722 /* I think the user probably only wants to see one breakpoint
1723 number, not all of them. */
1724 annotate_breakpoint (bs
->breakpoint_at
->number
);
1725 printf_filtered ("\nBreakpoint %d, ", bs
->breakpoint_at
->number
);
1728 else if ((bs
->old_val
!= NULL
) &&
1729 (bs
->breakpoint_at
->type
== bp_watchpoint
||
1730 bs
->breakpoint_at
->type
== bp_access_watchpoint
||
1731 bs
->breakpoint_at
->type
== bp_hardware_watchpoint
))
1733 annotate_watchpoint (bs
->breakpoint_at
->number
);
1734 mention (bs
->breakpoint_at
);
1735 printf_filtered ("\nOld value = ");
1736 value_print (bs
->old_val
, gdb_stdout
, 0, Val_pretty_default
);
1737 printf_filtered ("\nNew value = ");
1738 value_print (bs
->breakpoint_at
->val
, gdb_stdout
, 0,
1739 Val_pretty_default
);
1740 printf_filtered ("\n");
1741 value_free (bs
->old_val
);
1743 /* More than one watchpoint may have been triggered. */
1746 else if (bs
->breakpoint_at
->type
== bp_access_watchpoint
||
1747 bs
->breakpoint_at
->type
== bp_read_watchpoint
)
1749 mention (bs
->breakpoint_at
);
1750 printf_filtered ("\nValue = ");
1751 value_print (bs
->breakpoint_at
->val
, gdb_stdout
, 0,
1752 Val_pretty_default
);
1753 printf_filtered ("\n");
1756 /* We can't deal with it. Maybe another member of the bpstat chain can. */
1760 /* Print a message indicating what happened.
1761 This is called from normal_stop().
1762 The input to this routine is the head of the bpstat list - a list
1763 of the eventpoints that caused this stop.
1764 This routine calls the "print_it" routine(s) associated
1765 with these eventpoints. This will print (for example)
1766 the "Breakpoint n," part of the output.
1767 The return value of this routine is one of:
1769 -1: Means we printed nothing
1770 0: Means we printed something, and expect subsequent
1771 code to print the location. An example is
1772 "Breakpoint 1, " which should be followed by
1774 1 : Means we printed something, but there is no need
1775 to also print the location part of the message.
1776 An example is the catch/throw messages, which
1777 don't require a location appended to the end. */
1788 val
= (*bs
->print_it
) (bs
);
1792 /* Maybe another breakpoint in the chain caused us to stop.
1793 (Currently all watchpoints go on the bpstat whether hit or
1794 not. That probably could (should) be changed, provided care is taken
1795 with respect to bpstat_explains_signal). */
1797 return bpstat_print (bs
->next
);
1799 /* We reached the end of the chain without printing anything. */
1803 /* Evaluate the expression EXP and return 1 if value is zero.
1804 This is used inside a catch_errors to evaluate the breakpoint condition.
1805 The argument is a "struct expression *" that has been cast to char * to
1806 make it pass through catch_errors. */
1809 breakpoint_cond_eval (exp
)
1812 value_ptr mark
= value_mark ();
1813 int i
= !value_true (evaluate_expression ((struct expression
*)exp
));
1814 value_free_to_mark (mark
);
1818 /* Allocate a new bpstat and chain it to the current one. */
1821 bpstat_alloc (b
, cbs
)
1822 register struct breakpoint
*b
;
1823 bpstat cbs
; /* Current "bs" value */
1827 bs
= (bpstat
) xmalloc (sizeof (*bs
));
1829 bs
->breakpoint_at
= b
;
1830 /* If the condition is false, etc., don't do the commands. */
1831 bs
->commands
= NULL
;
1833 bs
->print_it
= print_it_normal
;
1837 /* Possible return values for watchpoint_check (this can't be an enum
1838 because of check_errors). */
1839 /* The watchpoint has been deleted. */
1840 #define WP_DELETED 1
1841 /* The value has changed. */
1842 #define WP_VALUE_CHANGED 2
1843 /* The value has not changed. */
1844 #define WP_VALUE_NOT_CHANGED 3
1846 #define BP_TEMPFLAG 1
1847 #define BP_HARDWAREFLAG 2
1849 /* Check watchpoint condition. */
1852 watchpoint_check (p
)
1855 bpstat bs
= (bpstat
) p
;
1856 struct breakpoint
*b
;
1857 struct frame_info
*fr
;
1858 int within_current_scope
;
1860 b
= bs
->breakpoint_at
;
1862 if (b
->exp_valid_block
== NULL
)
1863 within_current_scope
= 1;
1866 /* There is no current frame at this moment. If we're going to have
1867 any chance of handling watchpoints on local variables, we'll need
1868 the frame chain (so we can determine if we're in scope). */
1869 reinit_frame_cache();
1870 fr
= find_frame_addr_in_frame_chain (b
->watchpoint_frame
);
1871 within_current_scope
= (fr
!= NULL
);
1872 if (within_current_scope
)
1873 /* If we end up stopping, the current frame will get selected
1874 in normal_stop. So this call to select_frame won't affect
1876 select_frame (fr
, -1);
1879 if (within_current_scope
)
1881 /* We use value_{,free_to_}mark because it could be a
1882 *long* time before we return to the command level and
1883 call free_all_values. We can't call free_all_values because
1884 we might be in the middle of evaluating a function call. */
1886 value_ptr mark
= value_mark ();
1887 value_ptr new_val
= evaluate_expression (bs
->breakpoint_at
->exp
);
1888 if (!value_equal (b
->val
, new_val
))
1890 release_value (new_val
);
1891 value_free_to_mark (mark
);
1892 bs
->old_val
= b
->val
;
1894 /* We will stop here */
1895 return WP_VALUE_CHANGED
;
1899 /* Nothing changed, don't do anything. */
1900 value_free_to_mark (mark
);
1901 /* We won't stop here */
1902 return WP_VALUE_NOT_CHANGED
;
1907 /* This seems like the only logical thing to do because
1908 if we temporarily ignored the watchpoint, then when
1909 we reenter the block in which it is valid it contains
1910 garbage (in the case of a function, it may have two
1911 garbage values, one before and one after the prologue).
1912 So we can't even detect the first assignment to it and
1913 watch after that (since the garbage may or may not equal
1914 the first value assigned). */
1916 Watchpoint %d deleted because the program has left the block in\n\
1917 which its expression is valid.\n", bs
->breakpoint_at
->number
);
1918 if (b
->related_breakpoint
)
1919 b
->related_breakpoint
->disposition
= del_at_next_stop
;
1920 b
->disposition
= del_at_next_stop
;
1926 /* This is used when everything which needs to be printed has
1927 already been printed. But we still want to print the frame. */
1929 /* Background: When we stop, bpstat_print() is called.
1930 It loops through the bpstat list of things causing this stop,
1931 calling the print_it function for each one. The default
1932 print_it function, used for breakpoints, is print_it_normal().
1933 Also see print_it_noop() and print_it_done() are the other
1934 two possibilities. See comments in bpstat_print() and
1935 in header of print_it_normal() for more detail. */
1944 /* This is used when nothing should be printed for this bpstat entry. */
1945 /* Background: When we stop, bpstat_print() is called.
1946 It loops through the bpstat list of things causing this stop,
1947 calling the print_it function for each one. The default
1948 print_it function, used for breakpoints, is print_it_normal().
1949 Also see print_it_noop() and print_it_done() are the other
1950 two possibilities. See comments in bpstat_print() and
1951 in header of print_it_normal() for more detail. */
1960 /* Get a bpstat associated with having just stopped at address *PC
1961 and frame address CORE_ADDRESS. Update *PC to point at the
1962 breakpoint (if we hit a breakpoint). NOT_A_BREAKPOINT is nonzero
1963 if this is known to not be a real breakpoint (it could still be a
1964 watchpoint, though). */
1966 /* Determine whether we stopped at a breakpoint, etc, or whether we
1967 don't understand this stop. Result is a chain of bpstat's such that:
1969 if we don't understand the stop, the result is a null pointer.
1971 if we understand why we stopped, the result is not null.
1973 Each element of the chain refers to a particular breakpoint or
1974 watchpoint at which we have stopped. (We may have stopped for
1975 several reasons concurrently.)
1977 Each element of the chain has valid next, breakpoint_at,
1978 commands, FIXME??? fields. */
1981 bpstat_stop_status (pc
, not_a_breakpoint
)
1983 int not_a_breakpoint
;
1985 register struct breakpoint
*b
, *temp
;
1987 /* True if we've hit a breakpoint (as opposed to a watchpoint). */
1988 int real_breakpoint
= 0;
1989 /* Root of the chain of bpstat's */
1990 struct bpstats root_bs
[1];
1991 /* Pointer to the last thing in the chain currently. */
1992 bpstat bs
= root_bs
;
1993 static char message1
[] =
1994 "Error evaluating expression for watchpoint %d\n";
1995 char message
[sizeof (message1
) + 30 /* slop */];
1997 /* Get the address where the breakpoint would have been. */
1998 bp_addr
= *pc
- DECR_PC_AFTER_BREAK
;
2000 ALL_BREAKPOINTS_SAFE (b
, temp
)
2002 if (b
->enable
== disabled
2003 || b
->enable
== shlib_disabled
2004 || b
->enable
== call_disabled
)
2007 if (b
->type
!= bp_watchpoint
2008 && b
->type
!= bp_hardware_watchpoint
2009 && b
->type
!= bp_read_watchpoint
2010 && b
->type
!= bp_access_watchpoint
2011 && b
->type
!= bp_hardware_breakpoint
2012 && b
->type
!= bp_catch_fork
2013 && b
->type
!= bp_catch_vfork
2014 && b
->type
!= bp_catch_exec
2015 && b
->type
!= bp_catch_catch
2016 && b
->type
!= bp_catch_throw
) /* a non-watchpoint bp */
2017 if (b
->address
!= bp_addr
|| /* address doesn't match or */
2018 (overlay_debugging
&& /* overlay doesn't match */
2019 section_is_overlay (b
->section
) &&
2020 !section_is_mapped (b
->section
)))
2023 if (b
->type
== bp_hardware_breakpoint
2024 && b
->address
!= (bp_addr
- DECR_PC_AFTER_HW_BREAK
))
2027 if (b
->type
!= bp_watchpoint
2028 && b
->type
!= bp_hardware_watchpoint
2029 && b
->type
!= bp_read_watchpoint
2030 && b
->type
!= bp_access_watchpoint
2031 && not_a_breakpoint
)
2034 /* Is this a catchpoint of a load or unload? If so, did we
2035 get a load or unload of the specified library? If not,
2037 if ((b
->type
== bp_catch_load
)
2038 #if defined(SOLIB_HAVE_LOAD_EVENT)
2039 && (!SOLIB_HAVE_LOAD_EVENT(inferior_pid
)
2040 || ((b
->dll_pathname
!= NULL
)
2041 && (strcmp (b
->dll_pathname
, SOLIB_LOADED_LIBRARY_PATHNAME(inferior_pid
)) != 0)))
2046 if ((b
->type
== bp_catch_unload
)
2047 #if defined(SOLIB_HAVE_UNLOAD_EVENT)
2048 && (!SOLIB_HAVE_UNLOAD_EVENT(inferior_pid
)
2049 || ((b
->dll_pathname
!= NULL
)
2050 && (strcmp (b
->dll_pathname
, SOLIB_UNLOADED_LIBRARY_PATHNAME(inferior_pid
)) != 0)))
2055 if ((b
->type
== bp_catch_fork
)
2056 && ! target_has_forked (inferior_pid
, &b
->forked_inferior_pid
))
2059 if ((b
->type
== bp_catch_vfork
)
2060 && ! target_has_vforked (inferior_pid
, &b
->forked_inferior_pid
))
2063 if ((b
->type
== bp_catch_exec
)
2064 && ! target_has_execd (inferior_pid
, &b
->exec_pathname
))
2067 if (ep_is_exception_catchpoint (b
) &&
2068 !(current_exception_event
= target_get_current_exception_event ()))
2071 /* Come here if it's a watchpoint, or if the break address matches */
2073 bs
= bpstat_alloc (b
, bs
); /* Alloc a bpstat to explain stop */
2075 /* Watchpoints may change this, if not found to have triggered. */
2079 sprintf (message
, message1
, b
->number
);
2080 if (b
->type
== bp_watchpoint
|| b
->type
== bp_hardware_watchpoint
)
2082 switch (catch_errors ((int (*) PARAMS ((char *))) watchpoint_check
, (char *) bs
, message
,
2086 /* We've already printed what needs to be printed. */
2087 bs
->print_it
= print_it_done
;
2090 case WP_VALUE_CHANGED
:
2094 case WP_VALUE_NOT_CHANGED
:
2096 bs
->print_it
= print_it_noop
;
2098 /* Don't consider this a hit. */
2105 /* Error from catch_errors. */
2106 printf_filtered ("Watchpoint %d deleted.\n", b
->number
);
2107 if (b
->related_breakpoint
)
2108 b
->related_breakpoint
->disposition
= del_at_next_stop
;
2109 b
->disposition
= del_at_next_stop
;
2110 /* We've already printed what needs to be printed. */
2111 bs
->print_it
= print_it_done
;
2117 else if (b
->type
== bp_read_watchpoint
|| b
->type
== bp_access_watchpoint
)
2123 addr
= target_stopped_data_address();
2124 if (addr
== 0) continue;
2125 for (v
= b
->val_chain
; v
; v
= v
->next
)
2127 if (v
->lval
== lval_memory
)
2131 vaddr
= VALUE_ADDRESS (v
) + VALUE_OFFSET (v
);
2137 switch (catch_errors ((int (*) PARAMS ((char *))) watchpoint_check
, (char *) bs
, message
,
2141 /* We've already printed what needs to be printed. */
2142 bs
->print_it
= print_it_done
;
2145 case WP_VALUE_CHANGED
:
2146 case WP_VALUE_NOT_CHANGED
:
2153 /* Error from catch_errors. */
2154 printf_filtered ("Watchpoint %d deleted.\n", b
->number
);
2155 if (b
->related_breakpoint
)
2156 b
->related_breakpoint
->disposition
= del_at_next_stop
;
2157 b
->disposition
= del_at_next_stop
;
2158 /* We've already printed what needs to be printed. */
2159 bs
->print_it
= print_it_done
;
2165 /* By definition, an encountered breakpoint is a triggered
2169 if (DECR_PC_AFTER_BREAK
!= 0 || must_shift_inst_regs
)
2170 real_breakpoint
= 1;
2173 if (b
->frame
&& b
->frame
!= (get_current_frame ())->frame
&&
2174 (b
->type
== bp_step_resume
&&
2175 (INNER_THAN (get_current_frame ()->frame
, b
->frame
))))
2179 int value_is_zero
= 0;
2183 /* Need to select the frame, with all that implies
2184 so that the conditions will have the right context. */
2185 select_frame (get_current_frame (), 0);
2187 = catch_errors ((int (*) PARAMS ((char *))) breakpoint_cond_eval
, (char *)(b
->cond
),
2188 "Error in testing breakpoint condition:\n",
2190 /* FIXME-someday, should give breakpoint # */
2193 if (b
->cond
&& value_is_zero
)
2196 /* Don't consider this a hit. */
2199 else if (b
->ignore_count
> 0)
2206 /* We will stop here */
2207 if (b
->disposition
== disable
)
2208 b
->enable
= disabled
;
2209 bs
->commands
= b
->commands
;
2213 (STREQ ("silent", bs
->commands
->line
) ||
2214 (xdb_commands
&& STREQ ("Q", bs
->commands
->line
))))
2216 bs
->commands
= bs
->commands
->next
;
2221 /* Print nothing for this entry if we dont stop or if we dont print. */
2222 if (bs
->stop
== 0 || bs
->print
== 0)
2223 bs
->print_it
= print_it_noop
;
2226 bs
->next
= NULL
; /* Terminate the chain */
2227 bs
= root_bs
->next
; /* Re-grab the head of the chain */
2229 if ((DECR_PC_AFTER_BREAK
!= 0 || must_shift_inst_regs
) && bs
)
2231 if (real_breakpoint
)
2234 #if defined (SHIFT_INST_REGS)
2236 #else /* No SHIFT_INST_REGS. */
2238 #endif /* No SHIFT_INST_REGS. */
2242 /* The value of a hardware watchpoint hasn't changed, but the
2243 intermediate memory locations we are watching may have. */
2244 if (bs
&& ! bs
->stop
&&
2245 (bs
->breakpoint_at
->type
== bp_hardware_watchpoint
||
2246 bs
->breakpoint_at
->type
== bp_read_watchpoint
||
2247 bs
->breakpoint_at
->type
== bp_access_watchpoint
))
2249 remove_breakpoints ();
2250 insert_breakpoints ();
2255 /* Tell what to do about this bpstat. */
2260 /* Classify each bpstat as one of the following. */
2262 /* This bpstat element has no effect on the main_action. */
2265 /* There was a watchpoint, stop but don't print. */
2268 /* There was a watchpoint, stop and print. */
2271 /* There was a breakpoint but we're not stopping. */
2274 /* There was a breakpoint, stop but don't print. */
2277 /* There was a breakpoint, stop and print. */
2280 /* We hit the longjmp breakpoint. */
2283 /* We hit the longjmp_resume breakpoint. */
2286 /* We hit the step_resume breakpoint. */
2289 /* We hit the through_sigtramp breakpoint. */
2292 /* We hit the shared library event breakpoint. */
2295 /* We caught a shared library event. */
2298 /* This is just used to count how many enums there are. */
2302 /* Here is the table which drives this routine. So that we can
2303 format it pretty, we define some abbreviations for the
2304 enum bpstat_what codes. */
2305 #define kc BPSTAT_WHAT_KEEP_CHECKING
2306 #define ss BPSTAT_WHAT_STOP_SILENT
2307 #define sn BPSTAT_WHAT_STOP_NOISY
2308 #define sgl BPSTAT_WHAT_SINGLE
2309 #define slr BPSTAT_WHAT_SET_LONGJMP_RESUME
2310 #define clr BPSTAT_WHAT_CLEAR_LONGJMP_RESUME
2311 #define clrs BPSTAT_WHAT_CLEAR_LONGJMP_RESUME_SINGLE
2312 #define sr BPSTAT_WHAT_STEP_RESUME
2313 #define ts BPSTAT_WHAT_THROUGH_SIGTRAMP
2314 #define shl BPSTAT_WHAT_CHECK_SHLIBS
2315 #define shlr BPSTAT_WHAT_CHECK_SHLIBS_RESUME_FROM_HOOK
2317 /* "Can't happen." Might want to print an error message.
2318 abort() is not out of the question, but chances are GDB is just
2319 a bit confused, not unusable. */
2320 #define err BPSTAT_WHAT_STOP_NOISY
2322 /* Given an old action and a class, come up with a new action. */
2323 /* One interesting property of this table is that wp_silent is the same
2324 as bp_silent and wp_noisy is the same as bp_noisy. That is because
2325 after stopping, the check for whether to step over a breakpoint
2326 (BPSTAT_WHAT_SINGLE type stuff) is handled in proceed() without
2327 reference to how we stopped. We retain separate wp_silent and bp_silent
2328 codes in case we want to change that someday. */
2330 /* step_resume entries: a step resume breakpoint overrides another
2331 breakpoint of signal handling (see comment in wait_for_inferior
2332 at first IN_SIGTRAMP where we set the step_resume breakpoint). */
2333 /* We handle the through_sigtramp_breakpoint the same way; having both
2334 one of those and a step_resume_breakpoint is probably very rare (?). */
2336 static const enum bpstat_what_main_action
2337 table
[(int)class_last
][(int)BPSTAT_WHAT_LAST
] =
2340 /* kc ss sn sgl slr clr clrs sr ts shl shlr
2342 /*no_effect*/ {kc
, ss
, sn
, sgl
, slr
, clr
, clrs
, sr
, ts
, shl
, shlr
},
2343 /*wp_silent*/ {ss
, ss
, sn
, ss
, ss
, ss
, ss
, sr
, ts
, shl
, shlr
},
2344 /*wp_noisy*/ {sn
, sn
, sn
, sn
, sn
, sn
, sn
, sr
, ts
, shl
, shlr
},
2345 /*bp_nostop*/ {sgl
, ss
, sn
, sgl
, slr
, clrs
, clrs
, sr
, ts
, shl
, shlr
},
2346 /*bp_silent*/ {ss
, ss
, sn
, ss
, ss
, ss
, ss
, sr
, ts
, shl
, shlr
},
2347 /*bp_noisy*/ {sn
, sn
, sn
, sn
, sn
, sn
, sn
, sr
, ts
, shl
, shlr
},
2348 /*long_jump*/ {slr
, ss
, sn
, slr
, err
, err
, err
, sr
, ts
, shl
, shlr
},
2349 /*long_resume*/ {clr
, ss
, sn
, clrs
, err
, err
, err
, sr
, ts
, shl
, shlr
},
2350 /*step_resume*/ {sr
, sr
, sr
, sr
, sr
, sr
, sr
, sr
, ts
, shl
, shlr
},
2351 /*through_sig*/ {ts
, ts
, ts
, ts
, ts
, ts
, ts
, ts
, ts
, shl
, shlr
},
2352 /*shlib*/ {shl
, shl
, shl
, shl
, shl
, shl
, shl
, shl
, ts
, shl
, shlr
},
2353 /*catch_shlib*/ {shlr
, shlr
, shlr
, shlr
, shlr
, shlr
, shlr
, shlr
, ts
, shlr
, shlr
}
2368 enum bpstat_what_main_action current_action
= BPSTAT_WHAT_KEEP_CHECKING
;
2369 struct bpstat_what retval
;
2371 retval
.call_dummy
= 0;
2372 for (; bs
!= NULL
; bs
= bs
->next
)
2374 enum class bs_class
= no_effect
;
2375 if (bs
->breakpoint_at
== NULL
)
2376 /* I suspect this can happen if it was a momentary breakpoint
2377 which has since been deleted. */
2379 switch (bs
->breakpoint_at
->type
)
2385 case bp_hardware_breakpoint
:
2391 bs_class
= bp_noisy
;
2393 bs_class
= bp_silent
;
2396 bs_class
= bp_nostop
;
2399 case bp_hardware_watchpoint
:
2400 case bp_read_watchpoint
:
2401 case bp_access_watchpoint
:
2405 bs_class
= wp_noisy
;
2407 bs_class
= wp_silent
;
2410 /* There was a watchpoint, but we're not stopping. This requires
2411 no further action. */
2412 bs_class
= no_effect
;
2415 bs_class
= long_jump
;
2417 case bp_longjmp_resume
:
2418 bs_class
= long_resume
;
2420 case bp_step_resume
:
2423 bs_class
= step_resume
;
2426 /* It is for the wrong frame. */
2427 bs_class
= bp_nostop
;
2429 case bp_through_sigtramp
:
2430 bs_class
= through_sig
;
2432 case bp_watchpoint_scope
:
2433 bs_class
= bp_nostop
;
2435 case bp_shlib_event
:
2436 bs_class
= shlib_event
;
2439 case bp_catch_unload
:
2440 /* Only if this catchpoint triggered should we cause the
2441 step-out-of-dld behaviour. Otherwise, we ignore this
2444 bs_class
= catch_shlib_event
;
2446 bs_class
= no_effect
;
2449 case bp_catch_vfork
:
2454 bs_class
= bp_noisy
;
2456 bs_class
= bp_silent
;
2459 /* There was a catchpoint, but we're not stopping. This requires
2460 no further action. */
2461 bs_class
= no_effect
;
2463 case bp_catch_catch
:
2464 if (!bs
->stop
|| CURRENT_EXCEPTION_KIND
!= EX_EVENT_CATCH
)
2465 bs_class
= bp_nostop
;
2467 bs_class
= bs
->print
? bp_noisy
: bp_silent
;
2469 case bp_catch_throw
:
2470 if (!bs
->stop
|| CURRENT_EXCEPTION_KIND
!= EX_EVENT_THROW
)
2471 bs_class
= bp_nostop
;
2473 bs_class
= bs
->print
? bp_noisy
: bp_silent
;
2476 /* Make sure the action is stop (silent or noisy), so infrun.c
2477 pops the dummy frame. */
2478 bs_class
= bp_silent
;
2479 retval
.call_dummy
= 1;
2482 current_action
= table
[(int)bs_class
][(int)current_action
];
2484 retval
.main_action
= current_action
;
2488 /* Nonzero if we should step constantly (e.g. watchpoints on machines
2489 without hardware support). This isn't related to a specific bpstat,
2490 just to things like whether watchpoints are set. */
2493 bpstat_should_step ()
2495 struct breakpoint
*b
;
2497 if (b
->enable
== enabled
&& b
->type
== bp_watchpoint
)
2502 /* Nonzero if there are enabled hardware watchpoints. */
2504 bpstat_have_active_hw_watchpoints ()
2506 struct breakpoint
*b
;
2508 if ((b
->enable
== enabled
) &&
2510 ((b
->type
== bp_hardware_watchpoint
) ||
2511 (b
->type
== bp_read_watchpoint
) ||
2512 (b
->type
== bp_access_watchpoint
)))
2518 /* Given a bpstat that records zero or more triggered eventpoints, this
2519 function returns another bpstat which contains only the catchpoints
2520 on that first list, if any. */
2522 bpstat_get_triggered_catchpoints (ep_list
, cp_list
)
2526 struct bpstats root_bs
[1];
2527 bpstat bs
= root_bs
;
2528 struct breakpoint
* ep
;
2529 char * dll_pathname
;
2531 bpstat_clear (cp_list
);
2532 root_bs
->next
= NULL
;
2534 for (; ep_list
!= NULL
; ep_list
= ep_list
->next
)
2536 /* Is this eventpoint a catchpoint? If not, ignore it. */
2537 ep
= ep_list
->breakpoint_at
;
2540 if ((ep
->type
!= bp_catch_load
) &&
2541 (ep
->type
!= bp_catch_unload
) &&
2542 (ep
->type
!= bp_catch_catch
) &&
2543 (ep
->type
!= bp_catch_throw
)) /* pai: (temp) ADD fork/vfork here!! */
2546 /* Yes; add it to the list. */
2547 bs
= bpstat_alloc (ep
, bs
);
2552 #if defined(SOLIB_ADD)
2553 /* Also, for each triggered catchpoint, tag it with the name of
2554 the library that caused this trigger. (We copy the name now,
2555 because it's only guaranteed to be available NOW, when the
2556 catchpoint triggers. Clients who may wish to know the name
2557 later must get it from the catchpoint itself.) */
2558 if (ep
->triggered_dll_pathname
!= NULL
)
2559 free (ep
->triggered_dll_pathname
);
2560 if (ep
->type
== bp_catch_load
)
2561 dll_pathname
= SOLIB_LOADED_LIBRARY_PATHNAME (inferior_pid
);
2563 dll_pathname
= SOLIB_UNLOADED_LIBRARY_PATHNAME (inferior_pid
);
2565 dll_pathname
= NULL
;
2569 ep
->triggered_dll_pathname
= (char *) xmalloc (strlen (dll_pathname
) + 1);
2570 strcpy (ep
->triggered_dll_pathname
, dll_pathname
);
2573 ep
->triggered_dll_pathname
= NULL
;
2579 /* Print information on breakpoint number BNUM, or -1 if all.
2580 If WATCHPOINTS is zero, process only breakpoints; if WATCHPOINTS
2581 is nonzero, process only watchpoints. */
2586 } ep_type_description_t
;
2589 breakpoint_1 (bnum
, allflag
)
2593 register struct breakpoint
*b
;
2594 register struct command_line
*l
;
2595 register struct symbol
*sym
;
2596 CORE_ADDR last_addr
= (CORE_ADDR
)-1;
2597 int found_a_breakpoint
= 0;
2598 static ep_type_description_t bptypes
[] =
2600 {bp_none
, "?deleted?"},
2601 {bp_breakpoint
, "breakpoint"},
2602 {bp_hardware_breakpoint
, "hw breakpoint"},
2603 {bp_until
, "until"},
2604 {bp_finish
, "finish"},
2605 {bp_watchpoint
, "watchpoint"},
2606 {bp_hardware_watchpoint
, "hw watchpoint"},
2607 {bp_read_watchpoint
, "read watchpoint"},
2608 {bp_access_watchpoint
, "acc watchpoint"},
2609 {bp_longjmp
, "longjmp"},
2610 {bp_longjmp_resume
, "longjmp resume"},
2611 {bp_step_resume
, "step resume"},
2612 {bp_through_sigtramp
, "sigtramp"},
2613 {bp_watchpoint_scope
, "watchpoint scope"},
2614 {bp_call_dummy
, "call dummy"},
2615 {bp_shlib_event
, "shlib events"},
2616 {bp_catch_load
, "catch load"},
2617 {bp_catch_unload
, "catch unload"},
2618 {bp_catch_fork
, "catch fork"},
2619 {bp_catch_vfork
, "catch vfork"},
2620 {bp_catch_exec
, "catch exec"},
2621 {bp_catch_catch
, "catch catch"},
2622 {bp_catch_throw
, "catch throw"}
2625 static char *bpdisps
[] = {"del", "dstp", "dis", "keep"};
2626 static char bpenables
[] = "nyn";
2627 char wrap_indent
[80];
2631 || bnum
== b
->number
)
2633 /* We only print out user settable breakpoints unless the allflag is set. */
2635 && b
->type
!= bp_breakpoint
2636 && b
->type
!= bp_catch_load
2637 && b
->type
!= bp_catch_unload
2638 && b
->type
!= bp_catch_fork
2639 && b
->type
!= bp_catch_vfork
2640 && b
->type
!= bp_catch_exec
2641 && b
->type
!= bp_catch_catch
2642 && b
->type
!= bp_catch_throw
2643 && b
->type
!= bp_hardware_breakpoint
2644 && b
->type
!= bp_watchpoint
2645 && b
->type
!= bp_read_watchpoint
2646 && b
->type
!= bp_access_watchpoint
2647 && b
->type
!= bp_hardware_watchpoint
)
2650 if (!found_a_breakpoint
++)
2652 annotate_breakpoints_headers ();
2655 printf_filtered ("Num ");
2657 printf_filtered ("Type ");
2659 printf_filtered ("Disp ");
2661 printf_filtered ("Enb ");
2665 printf_filtered ("Address ");
2668 printf_filtered ("What\n");
2670 annotate_breakpoints_table ();
2675 printf_filtered ("%-3d ", b
->number
);
2677 if ((int)b
->type
> (sizeof(bptypes
)/sizeof(bptypes
[0])))
2678 error ("bptypes table does not describe type #%d.", (int)b
->type
);
2679 if ((int)b
->type
!= bptypes
[(int)b
->type
].type
)
2680 error ("bptypes table does not describe type #%d?", (int)b
->type
);
2681 printf_filtered ("%-14s ", bptypes
[(int)b
->type
].description
);
2683 printf_filtered ("%-4s ", bpdisps
[(int)b
->disposition
]);
2685 printf_filtered ("%-3c ", bpenables
[(int)b
->enable
]);
2687 strcpy (wrap_indent
, " ");
2689 strcat (wrap_indent
, " ");
2693 case bp_hardware_watchpoint
:
2694 case bp_read_watchpoint
:
2695 case bp_access_watchpoint
:
2696 /* Field 4, the address, is omitted (which makes the columns
2697 not line up too nicely with the headers, but the effect
2698 is relatively readable). */
2700 print_expression (b
->exp
, gdb_stdout
);
2704 case bp_catch_unload
:
2705 /* Field 4, the address, is omitted (which makes the columns
2706 not line up too nicely with the headers, but the effect
2707 is relatively readable). */
2709 if (b
->dll_pathname
== NULL
)
2710 printf_filtered ("<any library> ");
2712 printf_filtered ("library \"%s\" ", b
->dll_pathname
);
2716 case bp_catch_vfork
:
2717 /* Field 4, the address, is omitted (which makes the columns
2718 not line up too nicely with the headers, but the effect
2719 is relatively readable). */
2721 if (b
->forked_inferior_pid
!= 0)
2722 printf_filtered ("process %d ", b
->forked_inferior_pid
);
2726 /* Field 4, the address, is omitted (which makes the columns
2727 not line up too nicely with the headers, but the effect
2728 is relatively readable). */
2730 if (b
->exec_pathname
!= NULL
)
2731 printf_filtered ("program \"%s\" ", b
->exec_pathname
);
2733 case bp_catch_catch
:
2734 /* Field 4, the address, is omitted (which makes the columns
2735 not line up too nicely with the headers, but the effect
2736 is relatively readable). */
2738 printf_filtered ("exception catch ");
2740 case bp_catch_throw
:
2741 /* Field 4, the address, is omitted (which makes the columns
2742 not line up too nicely with the headers, but the effect
2743 is relatively readable). */
2745 printf_filtered ("exception throw ");
2749 case bp_hardware_breakpoint
:
2753 case bp_longjmp_resume
:
2754 case bp_step_resume
:
2755 case bp_through_sigtramp
:
2756 case bp_watchpoint_scope
:
2758 case bp_shlib_event
:
2762 /* FIXME-32x64: need a print_address_numeric with
2766 local_hex_string_custom
2767 ((unsigned long) b
->address
, "08l"));
2772 last_addr
= b
->address
;
2775 sym
= find_pc_sect_function (b
->address
, b
->section
);
2778 fputs_filtered ("in ", gdb_stdout
);
2779 fputs_filtered (SYMBOL_SOURCE_NAME (sym
), gdb_stdout
);
2780 wrap_here (wrap_indent
);
2781 fputs_filtered (" at ", gdb_stdout
);
2783 fputs_filtered (b
->source_file
, gdb_stdout
);
2784 printf_filtered (":%d", b
->line_number
);
2787 print_address_symbolic (b
->address
, gdb_stdout
, demangle
, " ");
2791 if (b
->thread
!= -1)
2792 printf_filtered (" thread %d", b
->thread
);
2794 printf_filtered ("\n");
2800 printf_filtered ("\tstop only in stack frame at ");
2801 print_address_numeric (b
->frame
, 1, gdb_stdout
);
2802 printf_filtered ("\n");
2809 printf_filtered ("\tstop only if ");
2810 print_expression (b
->cond
, gdb_stdout
);
2811 printf_filtered ("\n");
2814 if (b
->thread
!= -1)
2816 /* FIXME should make an annotation for this */
2817 printf_filtered ("\tstop only in thread %d\n", b
->thread
);
2820 if (show_breakpoint_hit_counts
&& b
->hit_count
)
2822 /* FIXME should make an annotation for this */
2823 if (ep_is_catchpoint (b
))
2824 printf_filtered ("\tcatchpoint");
2826 printf_filtered ("\tbreakpoint");
2827 printf_filtered (" already hit %d time%s\n",
2828 b
->hit_count
, (b
->hit_count
== 1 ? "" : "s"));
2831 if (b
->ignore_count
)
2835 printf_filtered ("\tignore next %d hits\n", b
->ignore_count
);
2838 if ((l
= b
->commands
))
2844 print_command_line (l
, 4);
2850 if (!found_a_breakpoint
)
2853 printf_filtered ("No breakpoints or watchpoints.\n");
2855 printf_filtered ("No breakpoint or watchpoint number %d.\n", bnum
);
2858 /* Compare against (CORE_ADDR)-1 in case some compiler decides
2859 that a comparison of an unsigned with -1 is always false. */
2860 if (last_addr
!= (CORE_ADDR
)-1)
2861 set_next_address (last_addr
);
2863 annotate_breakpoints_table_end ();
2868 breakpoints_info (bnum_exp
, from_tty
)
2875 bnum
= parse_and_eval_address (bnum_exp
);
2877 breakpoint_1 (bnum
, 0);
2880 #if MAINTENANCE_CMDS
2884 maintenance_info_breakpoints (bnum_exp
, from_tty
)
2891 bnum
= parse_and_eval_address (bnum_exp
);
2893 breakpoint_1 (bnum
, 1);
2898 /* Print a message describing any breakpoints set at PC. */
2901 describe_other_breakpoints (pc
, section
)
2905 register int others
= 0;
2906 register struct breakpoint
*b
;
2909 if (b
->address
== pc
)
2910 if (overlay_debugging
== 0 ||
2911 b
->section
== section
)
2915 printf_filtered ("Note: breakpoint%s ", (others
> 1) ? "s" : "");
2917 if (b
->address
== pc
)
2918 if (overlay_debugging
== 0 ||
2919 b
->section
== section
)
2925 ((b
->enable
== disabled
|| b
->enable
== shlib_disabled
|| b
->enable
== call_disabled
)
2926 ? " (disabled)" : ""),
2927 (others
> 1) ? "," : ((others
== 1) ? " and" : ""));
2929 printf_filtered ("also set at pc ");
2930 print_address_numeric (pc
, 1, gdb_stdout
);
2931 printf_filtered (".\n");
2935 /* Set the default place to put a breakpoint
2936 for the `break' command with no arguments. */
2939 set_default_breakpoint (valid
, addr
, symtab
, line
)
2942 struct symtab
*symtab
;
2945 default_breakpoint_valid
= valid
;
2946 default_breakpoint_address
= addr
;
2947 default_breakpoint_symtab
= symtab
;
2948 default_breakpoint_line
= line
;
2951 /* Rescan breakpoints at address ADDRESS,
2952 marking the first one as "first" and any others as "duplicates".
2953 This is so that the bpt instruction is only inserted once. */
2956 check_duplicates (address
, section
)
2960 register struct breakpoint
*b
;
2961 register int count
= 0;
2963 if (address
== 0) /* Watchpoints are uninteresting */
2967 if (b
->enable
!= disabled
2968 && b
->enable
!= shlib_disabled
2969 && b
->enable
!= call_disabled
2970 && b
->address
== address
2971 && (overlay_debugging
== 0 || b
->section
== section
))
2974 b
->duplicate
= count
> 1;
2978 /* Low level routine to set a breakpoint.
2979 Takes as args the three things that every breakpoint must have.
2980 Returns the breakpoint object so caller can set other things.
2981 Does not set the breakpoint number!
2982 Does not print anything.
2984 ==> This routine should not be called if there is a chance of later
2985 error(); otherwise it leaves a bogus breakpoint on the chain. Validate
2986 your arguments BEFORE calling this routine! */
2989 set_raw_breakpoint (sal
)
2990 struct symtab_and_line sal
;
2992 register struct breakpoint
*b
, *b1
;
2994 b
= (struct breakpoint
*) xmalloc (sizeof (struct breakpoint
));
2995 memset (b
, 0, sizeof (*b
));
2996 b
->address
= sal
.pc
;
2997 if (sal
.symtab
== NULL
)
2998 b
->source_file
= NULL
;
3000 b
->source_file
= savestring (sal
.symtab
->filename
,
3001 strlen (sal
.symtab
->filename
));
3002 b
->section
= sal
.section
;
3003 b
->language
= current_language
->la_language
;
3004 b
->input_radix
= input_radix
;
3006 b
->line_number
= sal
.line
;
3007 b
->enable
= enabled
;
3010 b
->ignore_count
= 0;
3013 b
->dll_pathname
= NULL
;
3014 b
->triggered_dll_pathname
= NULL
;
3015 b
->forked_inferior_pid
= 0;
3016 b
->exec_pathname
= NULL
;
3018 /* Add this breakpoint to the end of the chain
3019 so that a list of breakpoints will come out in order
3020 of increasing numbers. */
3022 b1
= breakpoint_chain
;
3024 breakpoint_chain
= b
;
3032 check_duplicates (sal
.pc
, sal
.section
);
3033 breakpoints_changed ();
3038 #ifdef GET_LONGJMP_TARGET
3041 create_longjmp_breakpoint (func_name
)
3044 struct symtab_and_line sal
;
3045 struct breakpoint
*b
;
3047 INIT_SAL (&sal
); /* initialize to zeroes */
3048 if (func_name
!= NULL
)
3050 struct minimal_symbol
*m
;
3052 m
= lookup_minimal_symbol_text (func_name
, NULL
, (struct objfile
*)NULL
);
3054 sal
.pc
= SYMBOL_VALUE_ADDRESS (m
);
3058 sal
.section
= find_pc_overlay (sal
.pc
);
3059 b
= set_raw_breakpoint (sal
);
3062 b
->type
= func_name
!= NULL
? bp_longjmp
: bp_longjmp_resume
;
3063 b
->disposition
= donttouch
;
3064 b
->enable
= disabled
;
3067 b
->addr_string
= strsave(func_name
);
3068 b
->number
= internal_breakpoint_number
--;
3071 #endif /* #ifdef GET_LONGJMP_TARGET */
3073 /* Call this routine when stepping and nexting to enable a breakpoint if we do
3074 a longjmp(). When we hit that breakpoint, call
3075 set_longjmp_resume_breakpoint() to figure out where we are going. */
3078 enable_longjmp_breakpoint()
3080 register struct breakpoint
*b
;
3083 if (b
->type
== bp_longjmp
)
3085 b
->enable
= enabled
;
3086 check_duplicates (b
->address
, b
->section
);
3091 disable_longjmp_breakpoint()
3093 register struct breakpoint
*b
;
3096 if ( b
->type
== bp_longjmp
3097 || b
->type
== bp_longjmp_resume
)
3099 b
->enable
= disabled
;
3100 check_duplicates (b
->address
, b
->section
);
3106 remove_solib_event_breakpoints ()
3108 register struct breakpoint
*b
, *temp
;
3110 ALL_BREAKPOINTS_SAFE (b
, temp
)
3111 if (b
->type
== bp_shlib_event
)
3112 delete_breakpoint (b
);
3116 create_solib_event_breakpoint (address
)
3119 struct breakpoint
*b
;
3120 struct symtab_and_line sal
;
3122 INIT_SAL (&sal
); /* initialize to zeroes */
3124 sal
.section
= find_pc_overlay (sal
.pc
);
3125 b
= set_raw_breakpoint (sal
);
3126 b
->number
= internal_breakpoint_number
--;
3127 b
->disposition
= donttouch
;
3128 b
->type
= bp_shlib_event
;
3132 disable_breakpoints_in_shlibs ()
3134 struct breakpoint
* b
;
3135 int disabled_shlib_breaks
= 0;
3137 /* See also: insert_breakpoints, under DISABLE_UNSETTABLE_BREAK. */
3140 #if defined (PC_SOLIB)
3141 if (((b
->type
== bp_breakpoint
) ||
3142 (b
->type
== bp_hardware_breakpoint
)) &&
3143 (b
->enable
!= shlib_disabled
) &&
3144 (b
->enable
!= call_disabled
) &&
3146 PC_SOLIB (b
->address
))
3148 b
->enable
= shlib_disabled
;
3149 if (!disabled_shlib_breaks
)
3151 target_terminal_ours_for_output ();
3152 printf_filtered ("Temporarily disabling shared library breakpoints:\n");
3154 disabled_shlib_breaks
= 1;
3155 printf_filtered ("%d ", b
->number
);
3159 if (disabled_shlib_breaks
)
3160 printf_filtered ("\n");
3163 /* Try to reenable any breakpoints in shared libraries. */
3165 re_enable_breakpoints_in_shlibs ()
3167 struct breakpoint
*b
;
3170 if (b
->enable
== shlib_disabled
)
3174 /* Do not reenable the breakpoint if the shared library
3175 is still not mapped in. */
3176 if (target_read_memory (b
->address
, buf
, 1) == 0)
3177 b
->enable
= enabled
;
3184 create_solib_load_unload_event_breakpoint (hookname
, tempflag
, dll_pathname
, cond_string
, bp_kind
)
3187 char * dll_pathname
;
3189 enum bptype bp_kind
;
3191 struct breakpoint
* b
;
3192 struct symtabs_and_lines sals
;
3193 struct symtab_and_line sal
;
3194 struct cleanup
* old_chain
;
3195 struct cleanup
* canonical_strings_chain
= NULL
;
3197 char * addr_start
= hookname
;
3198 char * addr_end
= NULL
;
3199 char ** canonical
= (char **) NULL
;
3200 int thread
= -1; /* All threads. */
3202 /* Set a breakpoint on the specified hook. */
3203 sals
= decode_line_1 (&hookname
, 1, (struct symtab
*) NULL
, 0, &canonical
);
3204 addr_end
= hookname
;
3206 if (sals
.nelts
== 0)
3208 warning ("Unable to set a breakpoint on dynamic linker callback.");
3209 warning ("Suggest linking with /opt/langtools/lib/end.o.");
3210 warning ("GDB will be unable to track shl_load/shl_unload calls");
3213 if (sals
.nelts
!= 1)
3215 warning ("Unable to set a unique breakpoint on dynamic linker callback.");
3216 warning ("GDB will be unable to track shl_load/shl_unload calls");
3220 /* Make sure that all storage allocated in decode_line_1 gets freed in case
3221 the following errors out. */
3222 old_chain
= make_cleanup (free
, sals
.sals
);
3223 if (canonical
!= (char **)NULL
)
3225 make_cleanup (free
, canonical
);
3226 canonical_strings_chain
= make_cleanup (null_cleanup
, 0);
3227 if (canonical
[0] != NULL
)
3228 make_cleanup (free
, canonical
[0]);
3231 resolve_sal_pc (&sals
.sals
[0]);
3233 /* Remove the canonical strings from the cleanup, they are needed below. */
3234 if (canonical
!= (char **)NULL
)
3235 discard_cleanups (canonical_strings_chain
);
3237 b
= set_raw_breakpoint (sals
.sals
[0]);
3238 set_breakpoint_count (breakpoint_count
+ 1);
3239 b
->number
= breakpoint_count
;
3241 b
->cond_string
= (cond_string
== NULL
) ? NULL
: savestring (cond_string
, strlen (cond_string
));
3244 if (canonical
!= (char **)NULL
&& canonical
[0] != NULL
)
3245 b
->addr_string
= canonical
[0];
3246 else if (addr_start
)
3247 b
->addr_string
= savestring (addr_start
, addr_end
- addr_start
);
3249 b
->enable
= enabled
;
3250 b
->disposition
= tempflag
? del
: donttouch
;
3252 if (dll_pathname
== NULL
)
3253 b
->dll_pathname
= NULL
;
3256 b
->dll_pathname
= (char *) xmalloc (strlen (dll_pathname
) + 1);
3257 strcpy (b
->dll_pathname
, dll_pathname
);
3262 do_cleanups (old_chain
);
3266 create_solib_load_event_breakpoint (hookname
, tempflag
, dll_pathname
, cond_string
)
3269 char * dll_pathname
;
3272 create_solib_load_unload_event_breakpoint (hookname
,
3280 create_solib_unload_event_breakpoint (hookname
, tempflag
, dll_pathname
, cond_string
)
3283 char * dll_pathname
;
3286 create_solib_load_unload_event_breakpoint (hookname
,
3294 create_fork_vfork_event_catchpoint (tempflag
, cond_string
, bp_kind
)
3297 enum bptype bp_kind
;
3299 struct symtab_and_line sal
;
3300 struct breakpoint
* b
;
3301 int thread
= -1; /* All threads. */
3308 b
= set_raw_breakpoint (sal
);
3309 set_breakpoint_count (breakpoint_count
+ 1);
3310 b
->number
= breakpoint_count
;
3312 b
->cond_string
= (cond_string
== NULL
) ? NULL
: savestring (cond_string
, strlen (cond_string
));
3314 b
->addr_string
= NULL
;
3315 b
->enable
= enabled
;
3316 b
->disposition
= tempflag
? del
: donttouch
;
3317 b
->forked_inferior_pid
= 0;
3325 create_fork_event_catchpoint (tempflag
, cond_string
)
3329 create_fork_vfork_event_catchpoint (tempflag
, cond_string
, bp_catch_fork
);
3333 create_vfork_event_catchpoint (tempflag
, cond_string
)
3337 create_fork_vfork_event_catchpoint (tempflag
, cond_string
, bp_catch_vfork
);
3341 create_exec_event_catchpoint (tempflag
, cond_string
)
3345 struct symtab_and_line sal
;
3346 struct breakpoint
* b
;
3347 int thread
= -1; /* All threads. */
3354 b
= set_raw_breakpoint (sal
);
3355 set_breakpoint_count (breakpoint_count
+ 1);
3356 b
->number
= breakpoint_count
;
3358 b
->cond_string
= (cond_string
== NULL
) ? NULL
: savestring (cond_string
, strlen (cond_string
));
3360 b
->addr_string
= NULL
;
3361 b
->enable
= enabled
;
3362 b
->disposition
= tempflag
? del
: donttouch
;
3364 b
->type
= bp_catch_exec
;
3370 hw_breakpoint_used_count()
3372 register struct breakpoint
*b
;
3377 if (b
->type
== bp_hardware_breakpoint
&& b
->enable
== enabled
)
3385 hw_watchpoint_used_count(type
, other_type_used
)
3387 int *other_type_used
;
3389 register struct breakpoint
*b
;
3392 *other_type_used
= 0;
3395 if (b
->enable
== enabled
)
3397 if (b
->type
== type
) i
++;
3398 else if ((b
->type
== bp_hardware_watchpoint
||
3399 b
->type
== bp_read_watchpoint
||
3400 b
->type
== bp_access_watchpoint
)
3401 && b
->enable
== enabled
)
3402 *other_type_used
= 1;
3408 /* Call this after hitting the longjmp() breakpoint. Use this to set a new
3409 breakpoint at the target of the jmp_buf.
3411 FIXME - This ought to be done by setting a temporary breakpoint that gets
3412 deleted automatically... */
3415 set_longjmp_resume_breakpoint(pc
, frame
)
3417 struct frame_info
*frame
;
3419 register struct breakpoint
*b
;
3422 if (b
->type
== bp_longjmp_resume
)
3425 b
->enable
= enabled
;
3427 b
->frame
= frame
->frame
;
3430 check_duplicates (b
->address
, b
->section
);
3436 disable_watchpoints_before_interactive_call_start ()
3438 struct breakpoint
* b
;
3442 if (((b
->type
== bp_watchpoint
)
3443 || (b
->type
== bp_hardware_watchpoint
)
3444 || (b
->type
== bp_read_watchpoint
)
3445 || (b
->type
== bp_access_watchpoint
)
3446 || ep_is_exception_catchpoint (b
))
3447 && (b
->enable
== enabled
))
3449 b
->enable
= call_disabled
;
3450 check_duplicates (b
->address
, b
->section
);
3456 enable_watchpoints_after_interactive_call_stop ()
3458 struct breakpoint
* b
;
3462 if (((b
->type
== bp_watchpoint
)
3463 || (b
->type
== bp_hardware_watchpoint
)
3464 || (b
->type
== bp_read_watchpoint
)
3465 || (b
->type
== bp_access_watchpoint
)
3466 || ep_is_exception_catchpoint (b
))
3467 && (b
->enable
== call_disabled
))
3469 b
->enable
= enabled
;
3470 check_duplicates (b
->address
, b
->section
);
3476 /* Set a breakpoint that will evaporate an end of command
3477 at address specified by SAL.
3478 Restrict it to frame FRAME if FRAME is nonzero. */
3481 set_momentary_breakpoint (sal
, frame
, type
)
3482 struct symtab_and_line sal
;
3483 struct frame_info
*frame
;
3486 register struct breakpoint
*b
;
3487 b
= set_raw_breakpoint (sal
);
3489 b
->enable
= enabled
;
3490 b
->disposition
= donttouch
;
3491 b
->frame
= (frame
? frame
->frame
: 0);
3493 /* If we're debugging a multi-threaded program, then we
3494 want momentary breakpoints to be active in only a
3495 single thread of control. */
3496 if (in_thread_list (inferior_pid
))
3497 b
->thread
= pid_to_thread_id (inferior_pid
);
3503 /* Tell the user we have just set a breakpoint B. */
3507 struct breakpoint
*b
;
3511 /* FIXME: This is misplaced; mention() is called by things (like hitting a
3512 watchpoint) other than breakpoint creation. It should be possible to
3513 clean this up and at the same time replace the random calls to
3514 breakpoint_changed with this hook, as has already been done for
3515 delete_breakpoint_hook and so on. */
3516 if (create_breakpoint_hook
)
3517 create_breakpoint_hook (b
);
3522 printf_filtered ("(apparently deleted?) Eventpoint %d: ", b
->number
);
3525 printf_filtered ("Watchpoint %d: ", b
->number
);
3526 print_expression (b
->exp
, gdb_stdout
);
3528 case bp_hardware_watchpoint
:
3529 printf_filtered ("Hardware watchpoint %d: ", b
->number
);
3530 print_expression (b
->exp
, gdb_stdout
);
3532 case bp_read_watchpoint
:
3533 printf_filtered ("Hardware read watchpoint %d: ", b
->number
);
3534 print_expression (b
->exp
, gdb_stdout
);
3536 case bp_access_watchpoint
:
3537 printf_filtered ("Hardware access (read/write) watchpoint %d: ",b
->number
);
3538 print_expression (b
->exp
, gdb_stdout
);
3541 printf_filtered ("Breakpoint %d", b
->number
);
3544 case bp_hardware_breakpoint
:
3545 printf_filtered ("Hardware assisted breakpoint %d", b
->number
);
3549 case bp_catch_unload
:
3550 printf_filtered ("Catchpoint %d (%s %s)",
3552 (b
->type
== bp_catch_load
) ? "load" : "unload",
3553 (b
->dll_pathname
!= NULL
) ? b
->dll_pathname
: "<any library>");
3556 case bp_catch_vfork
:
3557 printf_filtered ("Catchpoint %d (%s)",
3559 (b
->type
== bp_catch_fork
) ? "fork" : "vfork");
3562 printf_filtered ("Catchpoint %d (exec)",
3565 case bp_catch_catch
:
3566 case bp_catch_throw
:
3567 printf_filtered ("Catchpoint %d (%s)",
3569 (b
->type
== bp_catch_catch
) ? "catch" : "throw");
3575 case bp_longjmp_resume
:
3576 case bp_step_resume
:
3577 case bp_through_sigtramp
:
3579 case bp_watchpoint_scope
:
3580 case bp_shlib_event
:
3585 if (addressprint
|| b
->source_file
== NULL
)
3587 printf_filtered (" at ");
3588 print_address_numeric (b
->address
, 1, gdb_stdout
);
3591 printf_filtered (": file %s, line %d.",
3592 b
->source_file
, b
->line_number
);
3593 TUIDO(((TuiOpaqueFuncPtr
)tui_vAllSetHasBreakAt
, b
, 1));
3594 TUIDO(((TuiOpaqueFuncPtr
)tuiUpdateAllExecInfos
));
3596 printf_filtered ("\n");
3600 /* Set a breakpoint according to ARG (function, linenum or *address)
3601 flag: first bit : 0 non-temporary, 1 temporary.
3602 second bit : 0 normal breakpoint, 1 hardware breakpoint. */
3605 break_command_1 (arg
, flag
, from_tty
)
3609 int tempflag
, hardwareflag
;
3610 struct symtabs_and_lines sals
;
3611 struct symtab_and_line sal
;
3612 register struct expression
*cond
= 0;
3613 register struct breakpoint
*b
;
3615 /* Pointers in arg to the start, and one past the end, of the condition. */
3616 char *cond_start
= NULL
;
3617 char *cond_end
= NULL
;
3618 /* Pointers in arg to the start, and one past the end,
3619 of the address part. */
3620 char *addr_start
= NULL
;
3621 char *addr_end
= NULL
;
3622 struct cleanup
*old_chain
;
3623 struct cleanup
*canonical_strings_chain
= NULL
;
3624 char **canonical
= (char **)NULL
;
3628 hardwareflag
= flag
& BP_HARDWAREFLAG
;
3629 tempflag
= flag
& BP_TEMPFLAG
;
3634 INIT_SAL (&sal
); /* initialize to zeroes */
3636 /* If no arg given, or if first arg is 'if ', use the default breakpoint. */
3638 if (!arg
|| (arg
[0] == 'i' && arg
[1] == 'f'
3639 && (arg
[2] == ' ' || arg
[2] == '\t')))
3641 if (default_breakpoint_valid
)
3643 sals
.sals
= (struct symtab_and_line
*)
3644 xmalloc (sizeof (struct symtab_and_line
));
3645 sal
.pc
= default_breakpoint_address
;
3646 sal
.line
= default_breakpoint_line
;
3647 sal
.symtab
= default_breakpoint_symtab
;
3648 sal
.section
= find_pc_overlay (sal
.pc
);
3653 error ("No default breakpoint address now.");
3659 /* Force almost all breakpoints to be in terms of the
3660 current_source_symtab (which is decode_line_1's default). This
3661 should produce the results we want almost all of the time while
3662 leaving default_breakpoint_* alone. */
3663 if (default_breakpoint_valid
3664 && (!current_source_symtab
3665 || (arg
&& (*arg
== '+' || *arg
== '-'))))
3666 sals
= decode_line_1 (&arg
, 1, default_breakpoint_symtab
,
3667 default_breakpoint_line
, &canonical
);
3669 sals
= decode_line_1 (&arg
, 1, (struct symtab
*)NULL
, 0, &canonical
);
3677 /* Make sure that all storage allocated in decode_line_1 gets freed in case
3678 the following `for' loop errors out. */
3679 old_chain
= make_cleanup (free
, sals
.sals
);
3680 if (canonical
!= (char **)NULL
)
3682 make_cleanup (free
, canonical
);
3683 canonical_strings_chain
= make_cleanup (null_cleanup
, 0);
3684 for (i
= 0; i
< sals
.nelts
; i
++)
3686 if (canonical
[i
] != NULL
)
3687 make_cleanup (free
, canonical
[i
]);
3691 thread
= -1; /* No specific thread yet */
3693 /* Resolve all line numbers to PC's, and verify that conditions
3694 can be parsed, before setting any breakpoints. */
3695 for (i
= 0; i
< sals
.nelts
; i
++)
3697 char *tok
, *end_tok
;
3700 resolve_sal_pc (&sals
.sals
[i
]);
3702 /* It's possible for the PC to be nonzero, but still an illegal
3703 value on some targets.
3705 For example, on HP-UX if you start gdb, and before running the
3706 inferior you try to set a breakpoint on a shared library function
3707 "foo" where the inferior doesn't call "foo" directly but does
3708 pass its address to another function call, then we do find a
3709 minimal symbol for the "foo", but it's address is invalid.
3710 (Appears to be an index into a table that the loader sets up
3711 when the inferior is run.)
3713 Give the target a chance to bless sals.sals[i].pc before we
3714 try to make a breakpoint for it. */
3715 if (PC_REQUIRES_RUN_BEFORE_USE(sals
.sals
[i
].pc
))
3717 error ("Cannot break on %s without a running program.", addr_start
);
3724 while (*tok
== ' ' || *tok
== '\t')
3729 while (*end_tok
!= ' ' && *end_tok
!= '\t' && *end_tok
!= '\000')
3732 toklen
= end_tok
- tok
;
3734 if (toklen
>= 1 && strncmp (tok
, "if", toklen
) == 0)
3736 tok
= cond_start
= end_tok
+ 1;
3737 cond
= parse_exp_1 (&tok
, block_for_pc (sals
.sals
[i
].pc
), 0);
3740 else if (toklen
>= 1 && strncmp (tok
, "thread", toklen
) == 0)
3746 thread
= strtol (tok
, &tok
, 0);
3748 error ("Junk after thread keyword.");
3749 if (!valid_thread_id (thread
))
3750 error ("Unknown thread %d\n", thread
);
3753 error ("Junk at end of arguments.");
3758 int i
, target_resources_ok
;
3760 i
= hw_breakpoint_used_count ();
3761 target_resources_ok
= TARGET_CAN_USE_HARDWARE_WATCHPOINT (
3762 bp_hardware_breakpoint
, i
+ sals
.nelts
, 0);
3763 if (target_resources_ok
== 0)
3764 error ("No hardware breakpoint support in the target.");
3765 else if (target_resources_ok
< 0)
3766 error ("Hardware breakpoints used exceeds limit.");
3769 /* Remove the canonical strings from the cleanup, they are needed below. */
3770 if (canonical
!= (char **)NULL
)
3771 discard_cleanups (canonical_strings_chain
);
3773 /* Now set all the breakpoints. */
3774 for (i
= 0; i
< sals
.nelts
; i
++)
3779 describe_other_breakpoints (sal
.pc
, sal
.section
);
3781 b
= set_raw_breakpoint (sal
);
3782 set_breakpoint_count (breakpoint_count
+ 1);
3783 b
->number
= breakpoint_count
;
3784 b
->type
= hardwareflag
? bp_hardware_breakpoint
: bp_breakpoint
;
3788 /* If a canonical line spec is needed use that instead of the
3790 if (canonical
!= (char **)NULL
&& canonical
[i
] != NULL
)
3791 b
->addr_string
= canonical
[i
];
3792 else if (addr_start
)
3793 b
->addr_string
= savestring (addr_start
, addr_end
- addr_start
);
3795 b
->cond_string
= savestring (cond_start
, cond_end
- cond_start
);
3797 b
->enable
= enabled
;
3798 b
->disposition
= tempflag
? del
: donttouch
;
3804 printf_filtered ("Multiple breakpoints were set.\n");
3805 printf_filtered ("Use the \"delete\" command to delete unwanted breakpoints.\n");
3807 do_cleanups (old_chain
);
3811 break_at_finish_at_depth_command_1 (arg
, flag
, from_tty
)
3816 struct frame_info
*frame
;
3817 CORE_ADDR low
, high
, selected_pc
= 0;
3818 char *extra_args
, *level_arg
, *addr_string
;
3819 int extra_args_len
= 0, if_arg
= 0;
3822 (arg
[0] == 'i' && arg
[1] == 'f' && (arg
[2] == ' ' || arg
[2] == '\t')))
3825 if (default_breakpoint_valid
)
3829 selected_pc
= selected_frame
->pc
;
3834 error ("No selected frame.");
3837 error ("No default breakpoint address now.");
3841 extra_args
= strchr (arg
, ' ');
3845 extra_args_len
= strlen (extra_args
);
3846 level_arg
= (char *) xmalloc (extra_args
- arg
);
3847 strncpy (level_arg
, arg
, extra_args
- arg
- 1);
3848 level_arg
[extra_args
- arg
- 1] = '\0';
3852 level_arg
= (char *) xmalloc (strlen (arg
) + 1);
3853 strcpy (level_arg
, arg
);
3856 frame
= parse_frame_specification (level_arg
);
3858 selected_pc
= frame
->pc
;
3865 extra_args_len
= strlen (arg
);
3870 if (find_pc_partial_function(selected_pc
, (char **)NULL
, &low
, &high
))
3872 addr_string
= (char *) xmalloc (26 + extra_args_len
);
3874 sprintf (addr_string
, "*0x%x %s", high
, extra_args
);
3876 sprintf (addr_string
, "*0x%x", high
);
3877 break_command_1 (addr_string
, flag
, from_tty
);
3881 error ("No function contains the specified address");
3884 error ("Unable to set breakpoint at procedure exit");
3889 break_at_finish_command_1 (arg
, flag
, from_tty
)
3894 char *addr_string
, *break_string
, *beg_addr_string
;
3895 CORE_ADDR low
, high
;
3896 struct symtabs_and_lines sals
;
3897 struct symtab_and_line sal
;
3898 struct cleanup
*old_chain
;
3900 int extra_args_len
= 0;
3904 (arg
[0] == 'i' && arg
[1] == 'f' && (arg
[2] == ' ' || arg
[2] == '\t')))
3906 if (default_breakpoint_valid
)
3910 addr_string
= (char *) xmalloc (15);
3911 sprintf (addr_string
, "*0x%x", selected_frame
->pc
);
3916 error ("No selected frame.");
3919 error ("No default breakpoint address now.");
3923 addr_string
= (char *) xmalloc (strlen (arg
) + 1);
3924 strcpy (addr_string
, arg
);
3930 extra_args_len
= strlen (arg
);
3935 /* get the stuff after the function name or address */
3936 extra_args
= strchr (arg
, ' ');
3940 extra_args_len
= strlen (extra_args
);
3947 beg_addr_string
= addr_string
;
3948 sals
= decode_line_1 (&addr_string
, 1, (struct symtab
*)NULL
, 0,
3951 free (beg_addr_string
);
3952 old_chain
= make_cleanup (free
, sals
.sals
);
3953 for (i
= 0; (i
< sals
.nelts
); i
++)
3956 if (find_pc_partial_function (sal
.pc
, (char **)NULL
, &low
, &high
))
3958 break_string
= (char *) xmalloc (extra_args_len
+ 26);
3960 sprintf (break_string
, "*0x%x %s", high
, extra_args
);
3962 sprintf (break_string
, "*0x%x", high
);
3963 break_command_1 (break_string
, flag
, from_tty
);
3967 error ("No function contains the specified address");
3971 printf_filtered ("Multiple breakpoints were set.\n");
3972 printf_filtered ("Use the \"delete\" command to delete unwanted breakpoints.\n");
3974 do_cleanups(old_chain
);
3978 /* Helper function for break_command_1 and disassemble_command. */
3981 resolve_sal_pc (sal
)
3982 struct symtab_and_line
*sal
;
3986 if (sal
->pc
== 0 && sal
->symtab
!= NULL
)
3988 if (!find_line_pc (sal
->symtab
, sal
->line
, &pc
))
3989 error ("No line %d in file \"%s\".",
3990 sal
->line
, sal
->symtab
->filename
);
3994 if (sal
->section
== 0 && sal
->symtab
!= NULL
)
3996 struct blockvector
*bv
;
4001 bv
= blockvector_for_pc_sect (sal
->pc
, 0, &index
, sal
->symtab
);
4004 b
= BLOCKVECTOR_BLOCK (bv
, index
);
4005 sym
= block_function (b
);
4008 fixup_symbol_section (sym
, sal
->symtab
->objfile
);
4009 sal
->section
= SYMBOL_BFD_SECTION (sym
);
4013 /* It really is worthwhile to have the section, so we'll just
4014 have to look harder. This case can be executed if we have
4015 line numbers but no functions (as can happen in assembly
4018 struct minimal_symbol
*msym
;
4020 msym
= lookup_minimal_symbol_by_pc (sal
->pc
);
4022 sal
->section
= SYMBOL_BFD_SECTION (msym
);
4029 break_command (arg
, from_tty
)
4033 break_command_1 (arg
, 0, from_tty
);
4037 break_at_finish_command (arg
, from_tty
)
4041 break_at_finish_command_1 (arg
, 0, from_tty
);
4045 break_at_finish_at_depth_command (arg
, from_tty
)
4049 break_at_finish_at_depth_command_1 (arg
, 0, from_tty
);
4053 tbreak_command (arg
, from_tty
)
4057 break_command_1 (arg
, BP_TEMPFLAG
, from_tty
);
4061 tbreak_at_finish_command (arg
, from_tty
)
4065 break_at_finish_command_1 (arg
, BP_TEMPFLAG
, from_tty
);
4069 hbreak_command (arg
, from_tty
)
4073 break_command_1 (arg
, BP_HARDWAREFLAG
, from_tty
);
4077 thbreak_command (arg
, from_tty
)
4081 break_command_1 (arg
, (BP_TEMPFLAG
| BP_HARDWAREFLAG
), from_tty
);
4085 stop_command (arg
, from_tty
)
4089 printf_filtered ("Specify the type of breakpoint to set.\n\
4090 Usage: stop in <function | address>\n\
4095 stopin_command (arg
, from_tty
)
4101 if (arg
== (char *)NULL
)
4103 else if (*arg
!= '*')
4108 /* look for a ':'. If this is a line number specification, then say
4109 it is bad, otherwise, it should be an address or function/method
4111 while (*argptr
&& !hasColon
)
4113 hasColon
= (*argptr
== ':');
4118 badInput
= (*argptr
!= ':'); /* Not a class::method */
4120 badInput
= isdigit(*arg
); /* a simple line number */
4124 printf_filtered("Usage: stop in <function | address>\n");
4126 break_command_1 (arg
, 0, from_tty
);
4130 stopat_command (arg
, from_tty
)
4136 if (arg
== (char *)NULL
|| *arg
== '*') /* no line number */
4143 /* look for a ':'. If there is a '::' then get out, otherwise
4144 it is probably a line number. */
4145 while (*argptr
&& !hasColon
)
4147 hasColon
= (*argptr
== ':');
4152 badInput
= (*argptr
== ':'); /* we have class::method */
4154 badInput
= !isdigit(*arg
); /* not a line number */
4158 printf_filtered("Usage: stop at <line>\n");
4160 break_command_1 (arg
, 0, from_tty
);
4164 /* accessflag: 0: watch write, 1: watch read, 2: watch access(read or write) */
4166 watch_command_1 (arg
, accessflag
, from_tty
)
4171 struct breakpoint
*b
;
4172 struct symtab_and_line sal
;
4173 struct expression
*exp
;
4174 struct block
*exp_valid_block
;
4175 struct value
*val
, *mark
;
4176 struct frame_info
*frame
;
4177 struct frame_info
*prev_frame
= NULL
;
4178 char *exp_start
= NULL
;
4179 char *exp_end
= NULL
;
4180 char *tok
, *end_tok
;
4182 char *cond_start
= NULL
;
4183 char *cond_end
= NULL
;
4184 struct expression
*cond
= NULL
;
4185 int i
, other_type_used
, target_resources_ok
= 0;
4186 enum bptype bp_type
;
4189 INIT_SAL (&sal
); /* initialize to zeroes */
4191 /* Parse arguments. */
4192 innermost_block
= NULL
;
4194 exp
= parse_exp_1 (&arg
, 0, 0);
4196 exp_valid_block
= innermost_block
;
4197 mark
= value_mark ();
4198 val
= evaluate_expression (exp
);
4199 release_value (val
);
4200 if (VALUE_LAZY (val
))
4201 value_fetch_lazy (val
);
4204 while (*tok
== ' ' || *tok
== '\t')
4208 while (*end_tok
!= ' ' && *end_tok
!= '\t' && *end_tok
!= '\000')
4211 toklen
= end_tok
- tok
;
4212 if (toklen
>= 1 && strncmp (tok
, "if", toklen
) == 0)
4214 tok
= cond_start
= end_tok
+ 1;
4215 cond
= parse_exp_1 (&tok
, 0, 0);
4219 error("Junk at end of command.");
4221 if (accessflag
== 1) bp_type
= bp_read_watchpoint
;
4222 else if (accessflag
== 2) bp_type
= bp_access_watchpoint
;
4223 else bp_type
= bp_hardware_watchpoint
;
4225 mem_cnt
= can_use_hardware_watchpoint (val
);
4226 if (mem_cnt
== 0 && bp_type
!= bp_hardware_watchpoint
)
4227 error ("Expression cannot be implemented with read/access watchpoint.");
4229 i
= hw_watchpoint_used_count (bp_type
, &other_type_used
);
4230 target_resources_ok
= TARGET_CAN_USE_HARDWARE_WATCHPOINT(
4231 bp_type
, i
+ mem_cnt
, other_type_used
);
4232 if (target_resources_ok
== 0 && bp_type
!= bp_hardware_watchpoint
)
4233 error ("Target does not have this type of hardware watchpoint support.");
4234 if (target_resources_ok
< 0 && bp_type
!= bp_hardware_watchpoint
)
4235 error ("Target resources have been allocated for other types of watchpoints.");
4238 #if defined(HPUXHPPA)
4239 /* ??rehrauer: DTS #CHFts23014 notes that on HP-UX if you set a h/w
4240 watchpoint before the "run" command, the inferior dies with a e.g.,
4241 SIGILL once you start it. I initially believed this was due to a
4242 bad interaction between page protection traps and the initial
4243 startup sequence by the dynamic linker.
4245 However, I tried avoiding that by having HP-UX's implementation of
4246 TARGET_CAN_USE_HW_WATCHPOINT return FALSE if there was no inferior_pid
4247 yet, which forced slow watches before a "run" or "attach", and it
4248 still fails somewhere in the startup code.
4250 Until I figure out what's happening, I'm disallowing watches altogether
4251 before the "run" or "attach" command. We'll tell the user they must
4252 set watches after getting the program started. */
4253 if (! target_has_execution
)
4255 warning ("can't do that without a running program; try \"break main\", \"run\" first");
4258 #endif /* HPUXHPPA */
4260 /* Now set up the breakpoint. */
4261 b
= set_raw_breakpoint (sal
);
4262 set_breakpoint_count (breakpoint_count
+ 1);
4263 b
->number
= breakpoint_count
;
4264 b
->disposition
= donttouch
;
4266 b
->exp_valid_block
= exp_valid_block
;
4267 b
->exp_string
= savestring (exp_start
, exp_end
- exp_start
);
4271 b
->cond_string
= savestring (cond_start
, cond_end
- cond_start
);
4275 frame
= block_innermost_frame (exp_valid_block
);
4278 prev_frame
= get_prev_frame (frame
);
4279 b
->watchpoint_frame
= frame
->frame
;
4282 b
->watchpoint_frame
= (CORE_ADDR
)0;
4284 if (mem_cnt
&& target_resources_ok
> 0)
4287 b
->type
= bp_watchpoint
;
4289 /* If the expression is "local", then set up a "watchpoint scope"
4290 breakpoint at the point where we've left the scope of the watchpoint
4292 if (innermost_block
)
4296 struct breakpoint
*scope_breakpoint
;
4297 struct symtab_and_line scope_sal
;
4299 INIT_SAL (&scope_sal
); /* initialize to zeroes */
4300 scope_sal
.pc
= get_frame_pc (prev_frame
);
4301 scope_sal
.section
= find_pc_overlay (scope_sal
.pc
);
4303 scope_breakpoint
= set_raw_breakpoint (scope_sal
);
4304 set_breakpoint_count (breakpoint_count
+ 1);
4305 scope_breakpoint
->number
= breakpoint_count
;
4307 scope_breakpoint
->type
= bp_watchpoint_scope
;
4308 scope_breakpoint
->enable
= enabled
;
4310 /* Automatically delete the breakpoint when it hits. */
4311 scope_breakpoint
->disposition
= del
;
4313 /* Only break in the proper frame (help with recursion). */
4314 scope_breakpoint
->frame
= prev_frame
->frame
;
4316 /* Set the address at which we will stop. */
4317 scope_breakpoint
->address
= get_frame_pc (prev_frame
);
4319 /* The scope breakpoint is related to the watchpoint. We
4320 will need to act on them together. */
4321 b
->related_breakpoint
= scope_breakpoint
;
4324 value_free_to_mark (mark
);
4328 /* Return count of locations need to be watched and can be handled
4329 in hardware. If the watchpoint can not be handled
4330 in hardware return zero. */
4332 #if !defined(TARGET_REGION_SIZE_OK_FOR_HW_WATCHPOINT)
4333 #define TARGET_REGION_SIZE_OK_FOR_HW_WATCHPOINT(byte_size) \
4334 ((byte_size) <= (REGISTER_SIZE))
4338 can_use_hardware_watchpoint (v
)
4341 int found_memory_cnt
= 0;
4343 /* Did the user specifically forbid us to use hardware watchpoints? */
4344 if (! can_use_hw_watchpoints
)
4347 /* Make sure all the intermediate values are in memory. Also make sure
4348 we found at least one memory expression. Guards against watch 0x12345,
4349 which is meaningless, but could cause errors if one tries to insert a
4350 hardware watchpoint for the constant expression. */
4351 for ( ; v
; v
= v
->next
)
4353 if (v
->lval
== lval_memory
)
4355 if (TARGET_REGION_SIZE_OK_FOR_HW_WATCHPOINT (TYPE_LENGTH (VALUE_TYPE (v
))))
4358 else if (v
->lval
!= not_lval
&& v
->modifiable
== 0)
4362 /* The expression itself looks suitable for using a hardware
4363 watchpoint, but give the target machine a chance to reject it. */
4364 return found_memory_cnt
;
4367 static void watch_command (arg
, from_tty
)
4371 watch_command_1 (arg
, 0, from_tty
);
4374 static void rwatch_command (arg
, from_tty
)
4378 watch_command_1 (arg
, 1, from_tty
);
4381 static void awatch_command (arg
, from_tty
)
4385 watch_command_1 (arg
, 2, from_tty
);
4389 /* Helper routine for the until_command routine in infcmd.c. Here
4390 because it uses the mechanisms of breakpoints. */
4394 until_break_command (arg
, from_tty
)
4398 struct symtabs_and_lines sals
;
4399 struct symtab_and_line sal
;
4400 struct frame_info
*prev_frame
= get_prev_frame (selected_frame
);
4401 struct breakpoint
*breakpoint
;
4402 struct cleanup
*old_chain
;
4404 clear_proceed_status ();
4406 /* Set a breakpoint where the user wants it and at return from
4409 if (default_breakpoint_valid
)
4410 sals
= decode_line_1 (&arg
, 1, default_breakpoint_symtab
,
4411 default_breakpoint_line
, (char ***)NULL
);
4413 sals
= decode_line_1 (&arg
, 1, (struct symtab
*)NULL
, 0, (char ***)NULL
);
4415 if (sals
.nelts
!= 1)
4416 error ("Couldn't get information on specified line.");
4419 free ((PTR
)sals
.sals
); /* malloc'd, so freed */
4422 error ("Junk at end of arguments.");
4424 resolve_sal_pc (&sal
);
4426 breakpoint
= set_momentary_breakpoint (sal
, selected_frame
, bp_until
);
4428 old_chain
= make_cleanup ((make_cleanup_func
) delete_breakpoint
, breakpoint
);
4430 /* Keep within the current frame */
4434 sal
= find_pc_line (prev_frame
->pc
, 0);
4435 sal
.pc
= prev_frame
->pc
;
4436 breakpoint
= set_momentary_breakpoint (sal
, prev_frame
, bp_until
);
4437 make_cleanup ((make_cleanup_func
) delete_breakpoint
, breakpoint
);
4440 proceed (-1, TARGET_SIGNAL_DEFAULT
, 0);
4441 do_cleanups(old_chain
);
4445 /* These aren't used; I don't konw what they were for. */
4446 /* Set a breakpoint at the catch clause for NAME. */
4448 catch_breakpoint (name
)
4454 disable_catch_breakpoint ()
4459 delete_catch_breakpoint ()
4464 enable_catch_breakpoint ()
4471 struct sal_chain
*next
;
4472 struct symtab_and_line sal
;
4475 /* Not really used -- invocation in handle_gnu_4_16_catch_command
4476 had been commented out in the v.4.16 sources, and stays
4477 disabled there now because "catch NAME" syntax isn't allowed.
4479 /* This isn't used; I don't know what it was for. */
4480 /* For each catch clause identified in ARGS, run FUNCTION
4481 with that clause as an argument. */
4482 static struct symtabs_and_lines
4483 map_catch_names (args
, function
)
4487 register char *p
= args
;
4489 struct symtabs_and_lines sals
;
4491 struct sal_chain
*sal_chain
= 0;
4495 error_no_arg ("one or more catch names");
4503 /* Don't swallow conditional part. */
4504 if (p1
[0] == 'i' && p1
[1] == 'f'
4505 && (p1
[2] == ' ' || p1
[2] == '\t'))
4511 while (isalnum (*p1
) || *p1
== '_' || *p1
== '$')
4515 if (*p1
&& *p1
!= ' ' && *p1
!= '\t')
4516 error ("Arguments must be catch names.");
4522 struct sal_chain
*next
= (struct sal_chain
*)
4523 alloca (sizeof (struct sal_chain
));
4524 next
->next
= sal_chain
;
4525 next
->sal
= get_catch_sal (p
);
4530 printf_unfiltered ("No catch clause for exception %s.\n", p
);
4535 while (*p
== ' ' || *p
== '\t') p
++;
4539 /* This shares a lot of code with `print_frame_label_vars' from stack.c. */
4541 static struct symtabs_and_lines
4542 get_catch_sals (this_level_only
)
4543 int this_level_only
;
4545 register struct blockvector
*bl
;
4546 register struct block
*block
;
4547 int index
, have_default
= 0;
4549 struct symtabs_and_lines sals
;
4550 struct sal_chain
*sal_chain
= 0;
4551 char *blocks_searched
;
4553 /* Not sure whether an error message is always the correct response,
4554 but it's better than a core dump. */
4555 if (selected_frame
== NULL
)
4556 error ("No selected frame.");
4557 block
= get_frame_block (selected_frame
);
4558 pc
= selected_frame
->pc
;
4564 error ("No symbol table info available.\n");
4566 bl
= blockvector_for_pc (BLOCK_END (block
) - 4, &index
);
4567 blocks_searched
= (char *) alloca (BLOCKVECTOR_NBLOCKS (bl
) * sizeof (char));
4568 memset (blocks_searched
, 0, BLOCKVECTOR_NBLOCKS (bl
) * sizeof (char));
4572 CORE_ADDR end
= BLOCK_END (block
) - 4;
4575 if (bl
!= blockvector_for_pc (end
, &index
))
4576 error ("blockvector blotch");
4577 if (BLOCKVECTOR_BLOCK (bl
, index
) != block
)
4578 error ("blockvector botch");
4579 last_index
= BLOCKVECTOR_NBLOCKS (bl
);
4582 /* Don't print out blocks that have gone by. */
4583 while (index
< last_index
4584 && BLOCK_END (BLOCKVECTOR_BLOCK (bl
, index
)) < pc
)
4587 while (index
< last_index
4588 && BLOCK_END (BLOCKVECTOR_BLOCK (bl
, index
)) < end
)
4590 if (blocks_searched
[index
] == 0)
4592 struct block
*b
= BLOCKVECTOR_BLOCK (bl
, index
);
4595 register struct symbol
*sym
;
4597 nsyms
= BLOCK_NSYMS (b
);
4599 for (i
= 0; i
< nsyms
; i
++)
4601 sym
= BLOCK_SYM (b
, i
);
4602 if (STREQ (SYMBOL_NAME (sym
), "default"))
4608 if (SYMBOL_CLASS (sym
) == LOC_LABEL
)
4610 struct sal_chain
*next
= (struct sal_chain
*)
4611 alloca (sizeof (struct sal_chain
));
4612 next
->next
= sal_chain
;
4613 next
->sal
= find_pc_line (SYMBOL_VALUE_ADDRESS (sym
), 0);
4617 blocks_searched
[index
] = 1;
4623 if (sal_chain
&& this_level_only
)
4626 /* After handling the function's top-level block, stop.
4627 Don't continue to its superblock, the block of
4628 per-file symbols. */
4629 if (BLOCK_FUNCTION (block
))
4631 block
= BLOCK_SUPERBLOCK (block
);
4636 struct sal_chain
*tmp_chain
;
4638 /* Count the number of entries. */
4639 for (index
= 0, tmp_chain
= sal_chain
; tmp_chain
;
4640 tmp_chain
= tmp_chain
->next
)
4644 sals
.sals
= (struct symtab_and_line
*)
4645 xmalloc (index
* sizeof (struct symtab_and_line
));
4646 for (index
= 0; sal_chain
; sal_chain
= sal_chain
->next
, index
++)
4647 sals
.sals
[index
] = sal_chain
->sal
;
4654 ep_skip_leading_whitespace (s
)
4657 if ((s
== NULL
) || (*s
== NULL
))
4659 while (isspace(**s
))
4663 /* This function examines a string, and attempts to find a token
4664 that might be an event name in the leading characters. If a
4665 possible match is found, a pointer to the last character of
4666 the token is returned. Else, NULL is returned. */
4668 ep_find_event_name_end (arg
)
4672 char * event_name_end
= NULL
;
4674 /* If we could depend upon the presense of strrpbrk, we'd use that... */
4678 /* We break out of the loop when we find a token delimiter.
4679 Basically, we're looking for alphanumerics and underscores;
4680 anything else delimites the token. */
4683 if (! isalnum(*s
) && (*s
!= '_'))
4689 return event_name_end
;
4693 /* This function attempts to parse an optional "if <cond>" clause
4694 from the arg string. If one is not found, it returns NULL.
4696 Else, it returns a pointer to the condition string. (It does not
4697 attempt to evaluate the string against a particular block.) And,
4698 it updates arg to point to the first character following the parsed
4699 if clause in the arg string. */
4701 ep_parse_optional_if_clause (arg
)
4706 if (((*arg
)[0] != 'i') || ((*arg
)[1] != 'f') || !isspace((*arg
)[2]))
4709 /* Skip the "if" keyword. */
4712 /* Skip any extra leading whitespace, and record the start of the
4713 condition string. */
4714 ep_skip_leading_whitespace (arg
);
4717 /* Assume that the condition occupies the remainder of the arg string. */
4718 (*arg
) += strlen (cond_string
);
4723 /* This function attempts to parse an optional filename from the arg
4724 string. If one is not found, it returns NULL.
4726 Else, it returns a pointer to the parsed filename. (This function
4727 makes no attempt to verify that a file of that name exists, or is
4728 accessible.) And, it updates arg to point to the first character
4729 following the parsed filename in the arg string.
4731 Note that clients needing to preserve the returned filename for
4732 future access should copy it to their own buffers. */
4734 ep_parse_optional_filename (arg
)
4737 static char filename
[1024];
4738 char * arg_p
= *arg
;
4742 if ((*arg_p
== '\0') || isspace (*arg_p
))
4760 /* Commands to deal with catching events, such as signals, exceptions,
4761 process start/exit, etc. */
4763 typedef enum {catch_fork
, catch_vfork
} catch_fork_kind
;
4766 catch_fork_command_1 (fork_kind
, arg
, tempflag
, from_tty
)
4767 catch_fork_kind fork_kind
;
4772 char * cond_string
= NULL
;
4774 ep_skip_leading_whitespace (&arg
);
4776 /* The allowed syntax is:
4778 catch [v]fork if <cond>
4780 First, check if there's an if clause. */
4781 cond_string
= ep_parse_optional_if_clause (&arg
);
4783 if ((*arg
!= '\0') && !isspace (*arg
))
4784 error ("Junk at end of arguments.");
4786 /* If this target supports it, create a fork or vfork catchpoint
4787 and enable reporting of such events. */
4788 switch (fork_kind
) {
4790 create_fork_event_catchpoint (tempflag
, cond_string
);
4793 create_vfork_event_catchpoint (tempflag
, cond_string
);
4796 error ("unsupported or unknown fork kind; cannot catch it");
4802 catch_exec_command_1 (arg
, tempflag
, from_tty
)
4807 char * cond_string
= NULL
;
4809 ep_skip_leading_whitespace (&arg
);
4811 /* The allowed syntax is:
4813 catch exec if <cond>
4815 First, check if there's an if clause. */
4816 cond_string
= ep_parse_optional_if_clause (&arg
);
4818 if ((*arg
!= '\0') && !isspace (*arg
))
4819 error ("Junk at end of arguments.");
4821 /* If this target supports it, create an exec catchpoint
4822 and enable reporting of such events. */
4823 create_exec_event_catchpoint (tempflag
, cond_string
);
4826 #if defined(SOLIB_ADD)
4828 catch_load_command_1 (arg
, tempflag
, from_tty
)
4833 char * dll_pathname
= NULL
;
4834 char * cond_string
= NULL
;
4836 ep_skip_leading_whitespace (&arg
);
4838 /* The allowed syntax is:
4840 catch load if <cond>
4841 catch load <filename>
4842 catch load <filename> if <cond>
4844 The user is not allowed to specify the <filename> after an
4847 We'll ignore the pathological case of a file named "if".
4849 First, check if there's an if clause. If so, then there
4850 cannot be a filename. */
4851 cond_string
= ep_parse_optional_if_clause (&arg
);
4853 /* If there was an if clause, then there cannot be a filename.
4854 Else, there might be a filename and an if clause. */
4855 if (cond_string
== NULL
)
4857 dll_pathname
= ep_parse_optional_filename (&arg
);
4858 ep_skip_leading_whitespace (&arg
);
4859 cond_string
= ep_parse_optional_if_clause (&arg
);
4862 if ((*arg
!= '\0') && !isspace (*arg
))
4863 error ("Junk at end of arguments.");
4865 /* Create a load breakpoint that only triggers when a load of
4866 the specified dll (or any dll, if no pathname was specified)
4868 SOLIB_CREATE_CATCH_LOAD_HOOK (inferior_pid
, tempflag
, dll_pathname
, cond_string
);
4872 catch_unload_command_1 (arg
, tempflag
, from_tty
)
4877 char * dll_pathname
= NULL
;
4878 char * cond_string
= NULL
;
4880 ep_skip_leading_whitespace (&arg
);
4882 /* The allowed syntax is:
4884 catch unload if <cond>
4885 catch unload <filename>
4886 catch unload <filename> if <cond>
4888 The user is not allowed to specify the <filename> after an
4891 We'll ignore the pathological case of a file named "if".
4893 First, check if there's an if clause. If so, then there
4894 cannot be a filename. */
4895 cond_string
= ep_parse_optional_if_clause (&arg
);
4897 /* If there was an if clause, then there cannot be a filename.
4898 Else, there might be a filename and an if clause. */
4899 if (cond_string
== NULL
)
4901 dll_pathname
= ep_parse_optional_filename (&arg
);
4902 ep_skip_leading_whitespace (&arg
);
4903 cond_string
= ep_parse_optional_if_clause (&arg
);
4906 if ((*arg
!= '\0') && !isspace (*arg
))
4907 error ("Junk at end of arguments.");
4909 /* Create an unload breakpoint that only triggers when an unload of
4910 the specified dll (or any dll, if no pathname was specified)
4912 SOLIB_CREATE_CATCH_UNLOAD_HOOK (inferior_pid
, tempflag
, dll_pathname
, cond_string
);
4914 #endif /* SOLIB_ADD */
4916 /* Commands to deal with catching exceptions. */
4918 /* Set a breakpoint at the specified callback routine for an
4919 exception event callback */
4922 create_exception_catchpoint (tempflag
, cond_string
, ex_event
, sal
)
4925 enum exception_event_kind ex_event
;
4926 struct symtab_and_line
* sal
;
4928 struct breakpoint
* b
;
4930 int thread
= -1; /* All threads. */
4932 if (!sal
) /* no exception support? */
4935 b
= set_raw_breakpoint (*sal
);
4936 set_breakpoint_count (breakpoint_count
+ 1);
4937 b
->number
= breakpoint_count
;
4939 b
->cond_string
= (cond_string
== NULL
) ? NULL
: savestring (cond_string
, strlen (cond_string
));
4941 b
->addr_string
= NULL
;
4942 b
->enable
= enabled
;
4943 b
->disposition
= tempflag
? del
: donttouch
;
4946 case EX_EVENT_THROW
:
4947 b
->type
= bp_catch_throw
;
4949 case EX_EVENT_CATCH
:
4950 b
->type
= bp_catch_catch
;
4952 default: /* error condition */
4954 b
->enable
= disabled
;
4955 error ("Internal error -- invalid catchpoint kind");
4960 /* Deal with "catch catch" and "catch throw" commands */
4963 catch_exception_command_1 (ex_event
, arg
, tempflag
, from_tty
)
4964 enum exception_event_kind ex_event
;
4969 char * cond_string
= NULL
;
4970 struct symtab_and_line
* sal
= NULL
;
4972 ep_skip_leading_whitespace (&arg
);
4974 cond_string
= ep_parse_optional_if_clause (&arg
);
4976 if ((*arg
!= '\0') && !isspace (*arg
))
4977 error ("Junk at end of arguments.");
4979 if ((ex_event
!= EX_EVENT_THROW
) &&
4980 (ex_event
!= EX_EVENT_CATCH
))
4981 error ("Unsupported or unknown exception event; cannot catch it");
4983 /* See if we can find a callback routine */
4984 sal
= target_enable_exception_callback (ex_event
, 1);
4988 /* We have callbacks from the runtime system for exceptions.
4989 Set a breakpoint on the sal found, if no errors */
4990 if (sal
!= (struct symtab_and_line
*) -1)
4991 create_exception_catchpoint (tempflag
, cond_string
, ex_event
, sal
);
4993 return; /* something went wrong with setting up callbacks */
4997 /* No callbacks from runtime system for exceptions.
4998 Try GNU C++ exception breakpoints using labels in debug info. */
4999 if (ex_event
== EX_EVENT_CATCH
)
5001 handle_gnu_4_16_catch_command (arg
, tempflag
, from_tty
);
5003 else if (ex_event
== EX_EVENT_THROW
)
5005 /* Set a breakpoint on __raise_exception () */
5007 fprintf_filtered (gdb_stderr
, "Unsupported with this platform/compiler combination.\n");
5008 fprintf_filtered (gdb_stderr
, "Perhaps you can achieve the effect you want by setting\n");
5009 fprintf_filtered (gdb_stderr
, "a breakpoint on __raise_exception().\n");
5014 /* Cover routine to allow wrapping target_enable_exception_catchpoints
5015 inside a catch_errors */
5017 static struct symtab_and_line
*
5018 cover_target_enable_exception_callback (args
)
5019 args_for_catchpoint_enable
* args
;
5021 target_enable_exception_callback (args
->kind
, args
->enable
);
5026 /* This is the original v.4.16 and earlier version of the
5027 catch_command_1() function. Now that other flavours of "catch"
5028 have been introduced, and since exception handling can be handled
5029 in other ways (through target ops) also, this is used only for the
5030 GNU C++ exception handling system.
5031 Note: Only the "catch" flavour of GDB 4.16 is handled here. The
5032 "catch NAME" is now no longer allowed in catch_command_1(). Also,
5033 there was no code in GDB 4.16 for "catch throw".
5035 Called from catch_exception_command_1 () */
5039 handle_gnu_4_16_catch_command (arg
, tempflag
, from_tty
)
5044 /* First, translate ARG into something we can deal with in terms
5047 struct symtabs_and_lines sals
;
5048 struct symtab_and_line sal
;
5049 register struct expression
*cond
= 0;
5050 register struct breakpoint
*b
;
5054 INIT_SAL (&sal
); /* initialize to zeroes */
5056 /* If no arg given, or if first arg is 'if ', all active catch clauses
5057 are breakpointed. */
5059 if (!arg
|| (arg
[0] == 'i' && arg
[1] == 'f'
5060 && (arg
[2] == ' ' || arg
[2] == '\t')))
5062 /* Grab all active catch clauses. */
5063 sals
= get_catch_sals (0);
5067 /* Grab selected catch clauses. */
5068 error ("catch NAME not implemented");
5071 /* Not sure why this code has been disabled. I'm leaving
5072 it disabled. We can never come here now anyway
5073 since we don't allow the "catch NAME" syntax.
5076 /* This isn't used; I don't know what it was for. */
5077 sals
= map_catch_names (arg
, catch_breakpoint
);
5085 for (i
= 0; i
< sals
.nelts
; i
++)
5087 resolve_sal_pc (&sals
.sals
[i
]);
5091 if (arg
[0] == 'i' && arg
[1] == 'f'
5092 && (arg
[2] == ' ' || arg
[2] == '\t'))
5093 cond
= parse_exp_1 ((arg
+= 2, &arg
),
5094 block_for_pc (sals
.sals
[i
].pc
), 0);
5096 error ("Junk at end of arguments.");
5101 for (i
= 0; i
< sals
.nelts
; i
++)
5106 describe_other_breakpoints (sal
.pc
, sal
.section
);
5108 b
= set_raw_breakpoint (sal
);
5109 set_breakpoint_count (breakpoint_count
+ 1);
5110 b
->number
= breakpoint_count
;
5111 b
->type
= bp_breakpoint
; /* Important -- this is an ordinary breakpoint.
5112 For platforms with callback support for exceptions,
5113 create_exception_catchpoint() will create special
5114 bp types (bp_catch_catch and bp_catch_throw), and
5115 there is code in insert_breakpoints() and elsewhere
5116 that depends on that. */
5119 b
->enable
= enabled
;
5120 b
->disposition
= tempflag
? del
: donttouch
;
5127 printf_unfiltered ("Multiple breakpoints were set.\n");
5128 printf_unfiltered ("Use the \"delete\" command to delete unwanted breakpoints.\n");
5130 free ((PTR
)sals
.sals
);
5134 /* This creates a temporary internal breakpoint
5135 just to placate infrun */
5136 static struct breakpoint
*
5137 create_temp_exception_breakpoint (pc
)
5140 struct symtab_and_line sal
;
5141 struct breakpoint
*b
;
5148 b
= set_raw_breakpoint (sal
);
5150 error ("Internal error -- couldn't set temp exception breakpoint");
5152 b
->type
= bp_breakpoint
;
5153 b
->disposition
= del
;
5154 b
->enable
= enabled
;
5156 b
->number
= internal_breakpoint_number
--;
5162 catch_command_1 (arg
, tempflag
, from_tty
)
5168 /* The first argument may be an event name, such as "start" or "load".
5169 If so, then handle it as such. If it doesn't match an event name,
5170 then attempt to interpret it as an exception name. (This latter is
5171 the v4.16-and-earlier GDB meaning of the "catch" command.)
5173 First, try to find the bounds of what might be an event name. */
5174 char * arg1_start
= arg
;
5178 if (arg1_start
== NULL
)
5180 /* Old behaviour was to use pre-v-4.16 syntax */
5181 /* catch_throw_command_1 (arg1_start, tempflag, from_tty); */
5183 /* Now, this is not allowed */
5184 error ("Catch requires an event name.");
5187 arg1_end
= ep_find_event_name_end (arg1_start
);
5188 if (arg1_end
== NULL
)
5189 error ("catch requires an event");
5190 arg1_length
= arg1_end
+ 1 - arg1_start
;
5192 /* Try to match what we found against known event names. */
5193 if (strncmp (arg1_start
, "signal", arg1_length
) == 0)
5195 error ("Catch of signal not yet implemented");
5197 else if (strncmp (arg1_start
, "catch", arg1_length
) == 0)
5199 catch_exception_command_1 (EX_EVENT_CATCH
, arg1_end
+1, tempflag
, from_tty
);
5201 else if (strncmp (arg1_start
, "throw", arg1_length
) == 0)
5203 catch_exception_command_1 (EX_EVENT_THROW
, arg1_end
+1, tempflag
, from_tty
);
5205 else if (strncmp (arg1_start
, "thread_start", arg1_length
) == 0)
5207 error ("Catch of thread_start not yet implemented");
5209 else if (strncmp (arg1_start
, "thread_exit", arg1_length
) == 0)
5211 error ("Catch of thread_exit not yet implemented");
5213 else if (strncmp (arg1_start
, "thread_join", arg1_length
) == 0)
5215 error ("Catch of thread_join not yet implemented");
5217 else if (strncmp (arg1_start
, "start", arg1_length
) == 0)
5219 error ("Catch of start not yet implemented");
5221 else if (strncmp (arg1_start
, "exit", arg1_length
) == 0)
5223 error ("Catch of exit not yet implemented");
5225 else if (strncmp (arg1_start
, "fork", arg1_length
) == 0)
5227 #if defined(CHILD_INSERT_FORK_CATCHPOINT)
5228 catch_fork_command_1 (catch_fork
, arg1_end
+1, tempflag
, from_tty
);
5230 error ("Catch of fork not yet implemented");
5233 else if (strncmp (arg1_start
, "vfork", arg1_length
) == 0)
5235 #if defined(CHILD_INSERT_VFORK_CATCHPOINT)
5236 catch_fork_command_1 (catch_vfork
, arg1_end
+1, tempflag
, from_tty
);
5238 error ("Catch of vfork not yet implemented");
5241 else if (strncmp (arg1_start
, "exec", arg1_length
) == 0)
5243 #if defined(CHILD_INSERT_EXEC_CATCHPOINT)
5244 catch_exec_command_1 (arg1_end
+1, tempflag
, from_tty
);
5246 error ("Catch of exec not yet implemented");
5249 else if (strncmp (arg1_start
, "load", arg1_length
) == 0)
5251 #if defined(SOLIB_ADD)
5252 catch_load_command_1 (arg1_end
+1, tempflag
, from_tty
);
5254 error ("Catch of load not implemented");
5257 else if (strncmp (arg1_start
, "unload", arg1_length
) == 0)
5259 #if defined(SOLIB_ADD)
5260 catch_unload_command_1 (arg1_end
+1, tempflag
, from_tty
);
5262 error ("Catch of load not implemented");
5265 else if (strncmp (arg1_start
, "stop", arg1_length
) == 0)
5267 error ("Catch of stop not yet implemented");
5270 /* This doesn't appear to be an event name */
5274 /* Pre-v.4.16 behaviour was to treat the argument
5275 as the name of an exception */
5276 /* catch_throw_command_1 (arg1_start, tempflag, from_tty); */
5277 /* Now this is not allowed */
5278 error ("Unknown event kind specified for catch");
5283 /* Used by the gui, could be made a worker for other things. */
5286 set_breakpoint_sal (sal
)
5287 struct symtab_and_line sal
;
5289 struct breakpoint
*b
;
5290 b
= set_raw_breakpoint (sal
);
5291 set_breakpoint_count (breakpoint_count
+ 1);
5292 b
->number
= breakpoint_count
;
5293 b
->type
= bp_breakpoint
;
5300 /* These aren't used; I don't know what they were for. */
5301 /* Disable breakpoints on all catch clauses described in ARGS. */
5303 disable_catch (args
)
5306 /* Map the disable command to catch clauses described in ARGS. */
5309 /* Enable breakpoints on all catch clauses described in ARGS. */
5314 /* Map the disable command to catch clauses described in ARGS. */
5317 /* Delete breakpoints on all catch clauses in the active scope. */
5322 /* Map the delete command to catch clauses described in ARGS. */
5327 catch_command (arg
, from_tty
)
5331 catch_command_1 (arg
, 0, from_tty
);
5336 tcatch_command (arg
, from_tty
)
5340 catch_command_1 (arg
, 1, from_tty
);
5345 clear_command (arg
, from_tty
)
5349 register struct breakpoint
*b
, *b1
;
5351 struct symtabs_and_lines sals
;
5352 struct symtab_and_line sal
;
5353 register struct breakpoint
*found
;
5358 sals
= decode_line_spec (arg
, 1);
5363 sals
.sals
= (struct symtab_and_line
*)
5364 xmalloc (sizeof (struct symtab_and_line
));
5365 INIT_SAL (&sal
); /* initialize to zeroes */
5366 sal
.line
= default_breakpoint_line
;
5367 sal
.symtab
= default_breakpoint_symtab
;
5368 sal
.pc
= default_breakpoint_address
;
5369 if (sal
.symtab
== 0)
5370 error ("No source file specified.");
5378 /* For each line spec given, delete bps which correspond
5379 to it. We do this in two loops: the first loop looks at
5380 the initial bp(s) in the chain which should be deleted,
5381 the second goes down the rest of the chain looking ahead
5382 one so it can take those bps off the chain without messing
5386 for (i
= 0; i
< sals
.nelts
; i
++)
5388 /* If exact pc given, clear bpts at that pc.
5389 If line given (pc == 0), clear all bpts on specified line.
5390 If defaulting, clear all bpts on default line
5393 defaulting sal.pc != 0 tests to do
5398 1 0 <can't happen> */
5401 found
= (struct breakpoint
*) 0;
5404 while (breakpoint_chain
5405 /* Why don't we check here that this is not
5406 a watchpoint, etc., as we do below?
5407 I can't make it fail, but don't know
5408 what's stopping the failure: a watchpoint
5409 of the same address as "sal.pc" should
5410 wind up being deleted. */
5412 && ( ((sal
.pc
&& (breakpoint_chain
->address
== sal
.pc
)) &&
5413 (overlay_debugging
== 0 ||
5414 breakpoint_chain
->section
== sal
.section
))
5415 || ((default_match
|| (0 == sal
.pc
))
5416 && breakpoint_chain
->source_file
!= NULL
5417 && sal
.symtab
!= NULL
5418 && STREQ (breakpoint_chain
->source_file
, sal
.symtab
->filename
)
5419 && breakpoint_chain
->line_number
== sal
.line
)))
5422 b1
= breakpoint_chain
;
5423 breakpoint_chain
= b1
->next
;
5431 && b
->next
->type
!= bp_none
5432 && b
->next
->type
!= bp_watchpoint
5433 && b
->next
->type
!= bp_hardware_watchpoint
5434 && b
->next
->type
!= bp_read_watchpoint
5435 && b
->next
->type
!= bp_access_watchpoint
5436 && ( ((sal
.pc
&& (b
->next
->address
== sal
.pc
)) &&
5437 (overlay_debugging
== 0 ||
5438 b
->next
->section
== sal
.section
))
5439 || ((default_match
|| (0 == sal
.pc
))
5440 && b
->next
->source_file
!= NULL
5441 && sal
.symtab
!= NULL
5442 && STREQ (b
->next
->source_file
, sal
.symtab
->filename
)
5443 && b
->next
->line_number
== sal
.line
)))
5456 error ("No breakpoint at %s.", arg
);
5458 error ("No breakpoint at this line.");
5461 if (found
->next
) from_tty
= 1; /* Always report if deleted more than one */
5462 if (from_tty
) printf_unfiltered ("Deleted breakpoint%s ", found
->next
? "s" : "");
5463 breakpoints_changed ();
5466 if (from_tty
) printf_unfiltered ("%d ", found
->number
);
5468 delete_breakpoint (found
);
5471 if (from_tty
) putchar_unfiltered ('\n');
5473 free ((PTR
)sals
.sals
);
5476 /* Delete breakpoint in BS if they are `delete' breakpoints and
5477 all breakpoints that are marked for deletion, whether hit or not.
5478 This is called after any breakpoint is hit, or after errors. */
5481 breakpoint_auto_delete (bs
)
5484 struct breakpoint
*b
, *temp
;
5486 for (; bs
; bs
= bs
->next
)
5487 if (bs
->breakpoint_at
&& bs
->breakpoint_at
->disposition
== del
5489 delete_breakpoint (bs
->breakpoint_at
);
5491 ALL_BREAKPOINTS_SAFE (b
, temp
)
5493 if (b
->disposition
== del_at_next_stop
)
5494 delete_breakpoint (b
);
5498 /* Delete a breakpoint and clean up all traces of it in the data structures. */
5501 delete_breakpoint (bpt
)
5502 struct breakpoint
*bpt
;
5504 register struct breakpoint
*b
;
5508 error ("Internal error (attempted to delete a NULL breakpoint)");
5511 /* Has this bp already been deleted? This can happen because multiple
5512 lists can hold pointers to bp's. bpstat lists are especial culprits.
5514 One example of this happening is a watchpoint's scope bp. When the
5515 scope bp triggers, we notice that the watchpoint is out of scope, and
5516 delete it. We also delete its scope bp. But the scope bp is marked
5517 "auto-deleting", and is already on a bpstat. That bpstat is then
5518 checked for auto-deleting bp's, which are deleted.
5520 A real solution to this problem might involve reference counts in bp's,
5521 and/or giving them pointers back to their referencing bpstat's, and
5522 teaching delete_breakpoint to only free a bp's storage when no more
5523 references were extent. A cheaper bandaid was chosen. */
5524 if (bpt
->type
== bp_none
)
5527 if (delete_breakpoint_hook
)
5528 delete_breakpoint_hook (bpt
);
5531 remove_breakpoint (bpt
, mark_uninserted
);
5533 if (breakpoint_chain
== bpt
)
5534 breakpoint_chain
= bpt
->next
;
5536 /* If we have callback-style exception catchpoints, don't go through
5537 the adjustments to the C++ runtime library etc. if the inferior
5538 isn't actually running. target_enable_exception_callback for a
5539 null target ops vector gives an undesirable error message, so we
5540 check here and avoid it. Since currently (1997-09-17) only HP-UX aCC's
5541 exceptions are supported in this way, it's OK for now. FIXME */
5542 if (ep_is_exception_catchpoint (bpt
) && target_has_execution
)
5544 static char message1
[] = "Error in deleting catchpoint %d:\n";
5545 static char message
[sizeof (message1
) + 30];
5546 args_for_catchpoint_enable args
;
5548 sprintf (message
, message1
, bpt
->number
); /* Format possible error msg */
5549 args
.kind
= bpt
->type
== bp_catch_catch
? EX_EVENT_CATCH
: EX_EVENT_THROW
;
5551 (void) catch_errors ((int (*) PARAMS ((char *))) cover_target_enable_exception_callback
,
5553 message
, RETURN_MASK_ALL
);
5560 b
->next
= bpt
->next
;
5564 /* Before turning off the visuals for the bp, check to see that
5565 there are no other bps at the same address. */
5572 clearIt
= (b
->address
!= bpt
->address
);
5579 TUIDO(((TuiOpaqueFuncPtr
)tui_vAllSetHasBreakAt
, bpt
, 0));
5580 TUIDO(((TuiOpaqueFuncPtr
)tuiUpdateAllExecInfos
));
5584 check_duplicates (bpt
->address
, bpt
->section
);
5585 /* If this breakpoint was inserted, and there is another breakpoint
5586 at the same address, we need to insert the other breakpoint. */
5588 && bpt
->type
!= bp_hardware_watchpoint
5589 && bpt
->type
!= bp_read_watchpoint
5590 && bpt
->type
!= bp_access_watchpoint
5591 && bpt
->type
!= bp_catch_fork
5592 && bpt
->type
!= bp_catch_vfork
5593 && bpt
->type
!= bp_catch_exec
)
5596 if (b
->address
== bpt
->address
5597 && b
->section
== bpt
->section
5599 && b
->enable
!= disabled
5600 && b
->enable
!= shlib_disabled
5601 && b
->enable
!= call_disabled
)
5604 val
= target_insert_breakpoint (b
->address
, b
->shadow_contents
);
5607 target_terminal_ours_for_output ();
5608 fprintf_unfiltered (gdb_stderr
, "Cannot insert breakpoint %d:\n", b
->number
);
5609 memory_error (val
, b
->address
); /* which bombs us out */
5616 free_command_lines (&bpt
->commands
);
5619 if (bpt
->cond_string
!= NULL
)
5620 free (bpt
->cond_string
);
5621 if (bpt
->addr_string
!= NULL
)
5622 free (bpt
->addr_string
);
5623 if (bpt
->exp
!= NULL
)
5625 if (bpt
->exp_string
!= NULL
)
5626 free (bpt
->exp_string
);
5627 if (bpt
->val
!= NULL
)
5628 value_free (bpt
->val
);
5629 if (bpt
->source_file
!= NULL
)
5630 free (bpt
->source_file
);
5631 if (bpt
->dll_pathname
!= NULL
)
5632 free (bpt
->dll_pathname
);
5633 if (bpt
->triggered_dll_pathname
!= NULL
)
5634 free (bpt
->triggered_dll_pathname
);
5635 if (bpt
->exec_pathname
!= NULL
)
5636 free (bpt
->exec_pathname
);
5638 /* Be sure no bpstat's are pointing at it after it's been freed. */
5639 /* FIXME, how can we find all bpstat's?
5640 We just check stop_bpstat for now. */
5641 for (bs
= stop_bpstat
; bs
; bs
= bs
->next
)
5642 if (bs
->breakpoint_at
== bpt
)
5644 bs
->breakpoint_at
= NULL
;
5646 /* we'd call bpstat_clear_actions, but that free's stuff and due
5647 to the multiple pointers pointing to one item with no
5648 reference counts found anywhere through out the bpstat's (how
5649 do you spell fragile?), we don't want to free things twice --
5650 better a memory leak than a corrupt malloc pool! */
5651 bs
->commands
= NULL
;
5654 /* On the chance that someone will soon try again to delete this same
5655 bp, we mark it as deleted before freeing its storage. */
5656 bpt
->type
= bp_none
;
5662 delete_command (arg
, from_tty
)
5666 struct breakpoint
*b
, *temp
;
5670 int breaks_to_delete
= 0;
5672 /* Delete all breakpoints if no argument.
5673 Do not delete internal or call-dummy breakpoints, these
5674 have to be deleted with an explicit breakpoint number argument. */
5677 if (b
->type
!= bp_call_dummy
&&
5678 b
->type
!= bp_shlib_event
&&
5680 breaks_to_delete
= 1;
5683 /* Ask user only if there are some breakpoints to delete. */
5685 || (breaks_to_delete
&& query ("Delete all breakpoints? ")))
5687 ALL_BREAKPOINTS_SAFE (b
, temp
)
5689 if (b
->type
!= bp_call_dummy
&&
5690 b
->type
!= bp_shlib_event
&&
5692 delete_breakpoint (b
);
5697 map_breakpoint_numbers (arg
, delete_breakpoint
);
5700 /* Reset a breakpoint given it's struct breakpoint * BINT.
5701 The value we return ends up being the return value from catch_errors.
5702 Unused in this case. */
5705 breakpoint_re_set_one (bint
)
5708 struct breakpoint
*b
= (struct breakpoint
*)bint
; /* get past catch_errs */
5711 struct symtabs_and_lines sals
;
5713 enum enable save_enable
;
5718 warning ("attempted to reset apparently deleted breakpoint #%d?\n", b
->number
);
5721 case bp_hardware_breakpoint
:
5723 case bp_catch_unload
:
5724 if (b
->addr_string
== NULL
)
5726 /* Anything without a string can't be re-set. */
5727 delete_breakpoint (b
);
5730 /* In case we have a problem, disable this breakpoint. We'll restore
5731 its status if we succeed. */
5732 save_enable
= b
->enable
;
5733 b
->enable
= disabled
;
5735 set_language (b
->language
);
5736 input_radix
= b
->input_radix
;
5738 sals
= decode_line_1 (&s
, 1, (struct symtab
*)NULL
, 0, (char ***)NULL
);
5739 for (i
= 0; i
< sals
.nelts
; i
++)
5741 resolve_sal_pc (&sals
.sals
[i
]);
5743 /* Reparse conditions, they might contain references to the
5745 if (b
->cond_string
!= NULL
)
5749 free ((PTR
)b
->cond
);
5750 b
->cond
= parse_exp_1 (&s
, block_for_pc (sals
.sals
[i
].pc
), 0);
5753 /* We need to re-set the breakpoint if the address changes...*/
5754 if (b
->address
!= sals
.sals
[i
].pc
5755 /* ...or new and old breakpoints both have source files, and
5756 the source file name or the line number changes... */
5757 || (b
->source_file
!= NULL
5758 && sals
.sals
[i
].symtab
!= NULL
5759 && (!STREQ (b
->source_file
, sals
.sals
[i
].symtab
->filename
)
5760 || b
->line_number
!= sals
.sals
[i
].line
)
5762 /* ...or we switch between having a source file and not having
5764 || ((b
->source_file
== NULL
) != (sals
.sals
[i
].symtab
== NULL
))
5767 if (b
->source_file
!= NULL
)
5768 free (b
->source_file
);
5769 if (sals
.sals
[i
].symtab
== NULL
)
5770 b
->source_file
= NULL
;
5773 savestring (sals
.sals
[i
].symtab
->filename
,
5774 strlen (sals
.sals
[i
].symtab
->filename
));
5775 b
->line_number
= sals
.sals
[i
].line
;
5776 b
->address
= sals
.sals
[i
].pc
;
5778 /* Used to check for duplicates here, but that can
5779 cause trouble, as it doesn't check for disable
5784 /* Might be better to do this just once per breakpoint_re_set,
5785 rather than once for every breakpoint. */
5786 breakpoints_changed ();
5788 b
->section
= sals
.sals
[i
].section
;
5789 b
->enable
= save_enable
; /* Restore it, this worked. */
5792 /* Now that this is re-enabled, check_duplicates
5794 check_duplicates (b
->address
, b
->section
);
5797 free ((PTR
)sals
.sals
);
5801 case bp_hardware_watchpoint
:
5802 case bp_read_watchpoint
:
5803 case bp_access_watchpoint
:
5804 innermost_block
= NULL
;
5805 /* The issue arises of what context to evaluate this in. The same
5806 one as when it was set, but what does that mean when symbols have
5807 been re-read? We could save the filename and functionname, but
5808 if the context is more local than that, the best we could do would
5809 be something like how many levels deep and which index at that
5810 particular level, but that's going to be less stable than filenames
5811 or functionnames. */
5812 /* So for now, just use a global context. */
5815 b
->exp
= parse_expression (b
->exp_string
);
5816 b
->exp_valid_block
= innermost_block
;
5817 mark
= value_mark ();
5819 value_free (b
->val
);
5820 b
->val
= evaluate_expression (b
->exp
);
5821 release_value (b
->val
);
5822 if (VALUE_LAZY (b
->val
))
5823 value_fetch_lazy (b
->val
);
5825 if (b
->cond_string
!= NULL
)
5829 free ((PTR
)b
->cond
);
5830 b
->cond
= parse_exp_1 (&s
, (struct block
*)0, 0);
5832 if (b
->enable
== enabled
)
5834 value_free_to_mark (mark
);
5836 case bp_catch_catch
:
5837 case bp_catch_throw
:
5839 /* We needn't really do anything to reset these, since the mask
5840 that requests them is unaffected by e.g., new libraries being
5843 case bp_catch_vfork
:
5848 printf_filtered ("Deleting unknown breakpoint type %d\n", b
->type
);
5850 /* Delete longjmp breakpoints, they will be reset later by
5851 breakpoint_re_set. */
5853 case bp_longjmp_resume
:
5854 delete_breakpoint (b
);
5857 /* This breakpoint is special, it's set up when the inferior
5858 starts and we really don't want to touch it. */
5859 case bp_shlib_event
:
5861 /* Keep temporary breakpoints, which can be encountered when we step
5862 over a dlopen call and SOLIB_ADD is resetting the breakpoints.
5863 Otherwise these should have been blown away via the cleanup chain
5864 or by breakpoint_init_inferior when we rerun the executable. */
5867 case bp_watchpoint_scope
:
5869 case bp_step_resume
:
5876 /* Re-set all breakpoints after symbols have been re-loaded. */
5878 breakpoint_re_set ()
5880 struct breakpoint
*b
, *temp
;
5881 enum language save_language
;
5882 int save_input_radix
;
5883 static char message1
[] = "Error in re-setting breakpoint %d:\n";
5884 char message
[sizeof (message1
) + 30 /* slop */];
5886 save_language
= current_language
->la_language
;
5887 save_input_radix
= input_radix
;
5888 ALL_BREAKPOINTS_SAFE (b
, temp
)
5890 sprintf (message
, message1
, b
->number
); /* Format possible error msg */
5891 catch_errors ((int (*) PARAMS ((char *))) breakpoint_re_set_one
, (char *) b
, message
,
5894 set_language (save_language
);
5895 input_radix
= save_input_radix
;
5897 #ifdef GET_LONGJMP_TARGET
5898 create_longjmp_breakpoint ("longjmp");
5899 create_longjmp_breakpoint ("_longjmp");
5900 create_longjmp_breakpoint ("siglongjmp");
5901 create_longjmp_breakpoint ("_siglongjmp");
5902 create_longjmp_breakpoint (NULL
);
5906 /* Took this out (temporarily at least), since it produces an extra
5907 blank line at startup. This messes up the gdbtests. -PB */
5908 /* Blank line to finish off all those mention() messages we just printed. */
5909 printf_filtered ("\n");
5913 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
5914 If from_tty is nonzero, it prints a message to that effect,
5915 which ends with a period (no newline). */
5917 /* Reset the thread number of this breakpoint:
5919 - If the breakpoint is for all threads, leave it as-is.
5920 - Else, reset it to the current thread for inferior_pid. */
5922 breakpoint_re_set_thread (b
)
5923 struct breakpoint
* b
;
5925 if (b
->thread
!= -1)
5927 if (in_thread_list (inferior_pid
))
5928 b
->thread
= pid_to_thread_id (inferior_pid
);
5933 set_ignore_count (bptnum
, count
, from_tty
)
5934 int bptnum
, count
, from_tty
;
5936 register struct breakpoint
*b
;
5942 if (b
->number
== bptnum
)
5944 b
->ignore_count
= count
;
5947 else if (count
== 0)
5948 printf_filtered ("Will stop next time breakpoint %d is reached.",
5950 else if (count
== 1)
5951 printf_filtered ("Will ignore next crossing of breakpoint %d.",
5954 printf_filtered ("Will ignore next %d crossings of breakpoint %d.",
5956 breakpoints_changed ();
5960 error ("No breakpoint number %d.", bptnum
);
5963 /* Clear the ignore counts of all breakpoints. */
5965 breakpoint_clear_ignore_counts ()
5967 struct breakpoint
*b
;
5970 b
->ignore_count
= 0;
5973 /* Command to set ignore-count of breakpoint N to COUNT. */
5976 ignore_command (args
, from_tty
)
5984 error_no_arg ("a breakpoint number");
5986 num
= get_number (&p
);
5989 error ("Second argument (specified ignore-count) is missing.");
5991 set_ignore_count (num
,
5992 longest_to_int (value_as_long (parse_and_eval (p
))),
5994 printf_filtered ("\n");
5995 breakpoints_changed ();
5998 /* Call FUNCTION on each of the breakpoints
5999 whose numbers are given in ARGS. */
6002 map_breakpoint_numbers (args
, function
)
6004 void (*function
) PARAMS ((struct breakpoint
*));
6006 register char *p
= args
;
6009 register struct breakpoint
*b
;
6012 error_no_arg ("one or more breakpoint numbers");
6018 num
= get_number (&p1
);
6021 if (b
->number
== num
)
6023 struct breakpoint
*related_breakpoint
= b
->related_breakpoint
;
6025 if (related_breakpoint
)
6026 function (related_breakpoint
);
6029 printf_unfiltered ("No breakpoint number %d.\n", num
);
6036 disable_breakpoint (bpt
)
6037 struct breakpoint
*bpt
;
6039 /* Never disable a watchpoint scope breakpoint; we want to
6040 hit them when we leave scope so we can delete both the
6041 watchpoint and its scope breakpoint at that time. */
6042 if (bpt
->type
== bp_watchpoint_scope
)
6045 bpt
->enable
= disabled
;
6047 check_duplicates (bpt
->address
, bpt
->section
);
6049 if (modify_breakpoint_hook
)
6050 modify_breakpoint_hook (bpt
);
6055 disable_command (args
, from_tty
)
6059 register struct breakpoint
*bpt
;
6061 ALL_BREAKPOINTS (bpt
)
6065 warning ("attempted to disable apparently deleted breakpoint #%d?\n", bpt
->number
);
6069 case bp_catch_unload
:
6071 case bp_catch_vfork
:
6073 case bp_catch_catch
:
6074 case bp_catch_throw
:
6075 case bp_hardware_breakpoint
:
6077 case bp_hardware_watchpoint
:
6078 case bp_read_watchpoint
:
6079 case bp_access_watchpoint
:
6080 disable_breakpoint (bpt
);
6085 map_breakpoint_numbers (args
, disable_breakpoint
);
6089 do_enable_breakpoint (bpt
, disposition
)
6090 struct breakpoint
*bpt
;
6091 enum bpdisp disposition
;
6093 struct frame_info
*save_selected_frame
= NULL
;
6094 int save_selected_frame_level
= -1;
6095 int target_resources_ok
, other_type_used
;
6098 if (bpt
->type
== bp_hardware_breakpoint
)
6101 i
= hw_breakpoint_used_count();
6102 target_resources_ok
= TARGET_CAN_USE_HARDWARE_WATCHPOINT(
6103 bp_hardware_breakpoint
, i
+1, 0);
6104 if (target_resources_ok
== 0)
6105 error ("No hardware breakpoint support in the target.");
6106 else if (target_resources_ok
< 0)
6107 error ("Hardware breakpoints used exceeds limit.");
6110 bpt
->enable
= enabled
;
6111 bpt
->disposition
= disposition
;
6112 check_duplicates (bpt
->address
, bpt
->section
);
6113 breakpoints_changed ();
6115 if (bpt
->type
== bp_watchpoint
|| bpt
->type
== bp_hardware_watchpoint
||
6116 bpt
->type
== bp_read_watchpoint
|| bpt
->type
== bp_access_watchpoint
)
6118 if (bpt
->exp_valid_block
!= NULL
)
6120 struct frame_info
*fr
=
6122 /* Ensure that we have the current frame. Else, this
6123 next query may pessimistically be answered as, "No,
6124 not within current scope". */
6125 get_current_frame ();
6126 fr
= find_frame_addr_in_frame_chain (bpt
->watchpoint_frame
);
6130 Cannot enable watchpoint %d because the block in which its expression\n\
6131 is valid is not currently in scope.\n", bpt
->number
);
6132 bpt
->enable
= disabled
;
6136 save_selected_frame
= selected_frame
;
6137 save_selected_frame_level
= selected_frame_level
;
6138 select_frame (fr
, -1);
6141 value_free (bpt
->val
);
6142 mark
= value_mark ();
6143 bpt
->val
= evaluate_expression (bpt
->exp
);
6144 release_value (bpt
->val
);
6145 if (VALUE_LAZY (bpt
->val
))
6146 value_fetch_lazy (bpt
->val
);
6148 if (bpt
->type
== bp_hardware_watchpoint
||
6149 bpt
->type
== bp_read_watchpoint
||
6150 bpt
->type
== bp_access_watchpoint
)
6152 int i
= hw_watchpoint_used_count (bpt
->type
, &other_type_used
);
6153 int mem_cnt
= can_use_hardware_watchpoint (bpt
->val
);
6155 /* Hack around 'unused var' error for some targets here */
6157 target_resources_ok
= TARGET_CAN_USE_HARDWARE_WATCHPOINT(
6158 bpt
->type
, i
+ mem_cnt
, other_type_used
);
6159 /* we can consider of type is bp_hardware_watchpoint, convert to
6160 bp_watchpoint in the following condition */
6161 if (target_resources_ok
< 0)
6164 Cannot enable watchpoint %d because target watch resources\n\
6165 have been allocated for other watchpoints.\n", bpt
->number
);
6166 bpt
->enable
= disabled
;
6167 value_free_to_mark (mark
);
6172 if (save_selected_frame_level
>= 0)
6173 select_and_print_frame (save_selected_frame
, save_selected_frame_level
);
6174 value_free_to_mark (mark
);
6176 if (modify_breakpoint_hook
)
6177 modify_breakpoint_hook (bpt
);
6181 enable_breakpoint (bpt
)
6182 struct breakpoint
*bpt
;
6184 do_enable_breakpoint (bpt
, bpt
->disposition
);
6187 /* The enable command enables the specified breakpoints (or all defined
6188 breakpoints) so they once again become (or continue to be) effective
6189 in stopping the inferior. */
6193 enable_command (args
, from_tty
)
6197 register struct breakpoint
*bpt
;
6199 ALL_BREAKPOINTS (bpt
)
6203 warning ("attempted to enable apparently deleted breakpoint #%d?\n", bpt
->number
);
6207 case bp_catch_unload
:
6209 case bp_catch_vfork
:
6211 case bp_catch_catch
:
6212 case bp_catch_throw
:
6213 case bp_hardware_breakpoint
:
6215 case bp_hardware_watchpoint
:
6216 case bp_read_watchpoint
:
6217 case bp_access_watchpoint
:
6218 enable_breakpoint (bpt
);
6223 map_breakpoint_numbers (args
, enable_breakpoint
);
6227 enable_once_breakpoint (bpt
)
6228 struct breakpoint
*bpt
;
6230 do_enable_breakpoint (bpt
, disable
);
6235 enable_once_command (args
, from_tty
)
6239 map_breakpoint_numbers (args
, enable_once_breakpoint
);
6243 enable_delete_breakpoint (bpt
)
6244 struct breakpoint
*bpt
;
6246 do_enable_breakpoint (bpt
, del
);
6251 enable_delete_command (args
, from_tty
)
6255 map_breakpoint_numbers (args
, enable_delete_breakpoint
);
6258 /* Use default_breakpoint_'s, or nothing if they aren't valid. */
6260 struct symtabs_and_lines
6261 decode_line_spec_1 (string
, funfirstline
)
6265 struct symtabs_and_lines sals
;
6267 error ("Empty line specification.");
6268 if (default_breakpoint_valid
)
6269 sals
= decode_line_1 (&string
, funfirstline
,
6270 default_breakpoint_symtab
, default_breakpoint_line
,
6273 sals
= decode_line_1 (&string
, funfirstline
,
6274 (struct symtab
*)NULL
, 0, (char ***)NULL
);
6276 error ("Junk at end of line specification: %s", string
);
6281 _initialize_breakpoint ()
6283 struct cmd_list_element
*c
;
6285 breakpoint_chain
= 0;
6286 /* Don't bother to call set_breakpoint_count. $bpnum isn't useful
6287 before a breakpoint is set. */
6288 breakpoint_count
= 0;
6290 add_com ("ignore", class_breakpoint
, ignore_command
,
6291 "Set ignore-count of breakpoint number N to COUNT.\n\
6292 Usage is `ignore N COUNT'.");
6294 add_com_alias("bc", "ignore", class_breakpoint
, 1);
6296 add_com ("commands", class_breakpoint
, commands_command
,
6297 "Set commands to be executed when a breakpoint is hit.\n\
6298 Give breakpoint number as argument after \"commands\".\n\
6299 With no argument, the targeted breakpoint is the last one set.\n\
6300 The commands themselves follow starting on the next line.\n\
6301 Type a line containing \"end\" to indicate the end of them.\n\
6302 Give \"silent\" as the first line to make the breakpoint silent;\n\
6303 then no output is printed when it is hit, except what the commands print.");
6305 add_com ("condition", class_breakpoint
, condition_command
,
6306 "Specify breakpoint number N to break only if COND is true.\n\
6307 Usage is `condition N COND', where N is an integer and COND is an\n\
6308 expression to be evaluated whenever breakpoint N is reached. ");
6310 add_com ("tbreak", class_breakpoint
, tbreak_command
,
6311 "Set a temporary breakpoint. Args like \"break\" command.\n\
6312 Like \"break\" except the breakpoint is only temporary,\n\
6313 so it will be deleted when hit. Equivalent to \"break\" followed\n\
6314 by using \"enable delete\" on the breakpoint number.");
6315 add_com("txbreak", class_breakpoint
, tbreak_at_finish_command
,
6316 "Set temporary breakpoint at procedure exit. Either there should\n\
6317 be no argument or the argument must be a depth.\n");
6319 add_com ("hbreak", class_breakpoint
, hbreak_command
,
6320 "Set a hardware assisted breakpoint. Args like \"break\" command.\n\
6321 Like \"break\" except the breakpoint requires hardware support,\n\
6322 some target hardware may not have this support.");
6324 add_com ("thbreak", class_breakpoint
, thbreak_command
,
6325 "Set a temporary hardware assisted breakpoint. Args like \"break\" command.\n\
6326 Like \"hbreak\" except the breakpoint is only temporary,\n\
6327 so it will be deleted when hit.");
6329 add_prefix_cmd ("enable", class_breakpoint
, enable_command
,
6330 "Enable some breakpoints.\n\
6331 Give breakpoint numbers (separated by spaces) as arguments.\n\
6332 With no subcommand, breakpoints are enabled until you command otherwise.\n\
6333 This is used to cancel the effect of the \"disable\" command.\n\
6334 With a subcommand you can enable temporarily.",
6335 &enablelist
, "enable ", 1, &cmdlist
);
6337 add_com("ab", class_breakpoint
, enable_command
,
6338 "Enable some breakpoints.\n\
6339 Give breakpoint numbers (separated by spaces) as arguments.\n\
6340 With no subcommand, breakpoints are enabled until you command otherwise.\n\
6341 This is used to cancel the effect of the \"disable\" command.\n\
6342 With a subcommand you can enable temporarily.");
6344 add_com_alias ("en", "enable", class_breakpoint
, 1);
6346 add_abbrev_prefix_cmd ("breakpoints", class_breakpoint
, enable_command
,
6347 "Enable some breakpoints.\n\
6348 Give breakpoint numbers (separated by spaces) as arguments.\n\
6349 This is used to cancel the effect of the \"disable\" command.\n\
6350 May be abbreviated to simply \"enable\".\n",
6351 &enablebreaklist
, "enable breakpoints ", 1, &enablelist
);
6353 add_cmd ("once", no_class
, enable_once_command
,
6354 "Enable breakpoints for one hit. Give breakpoint numbers.\n\
6355 If a breakpoint is hit while enabled in this fashion, it becomes disabled.",
6358 add_cmd ("delete", no_class
, enable_delete_command
,
6359 "Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
6360 If a breakpoint is hit while enabled in this fashion, it is deleted.",
6363 add_cmd ("delete", no_class
, enable_delete_command
,
6364 "Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
6365 If a breakpoint is hit while enabled in this fashion, it is deleted.",
6368 add_cmd ("once", no_class
, enable_once_command
,
6369 "Enable breakpoints for one hit. Give breakpoint numbers.\n\
6370 If a breakpoint is hit while enabled in this fashion, it becomes disabled.",
6373 add_prefix_cmd ("disable", class_breakpoint
, disable_command
,
6374 "Disable some breakpoints.\n\
6375 Arguments are breakpoint numbers with spaces in between.\n\
6376 To disable all breakpoints, give no argument.\n\
6377 A disabled breakpoint is not forgotten, but has no effect until reenabled.",
6378 &disablelist
, "disable ", 1, &cmdlist
);
6379 add_com_alias ("dis", "disable", class_breakpoint
, 1);
6380 add_com_alias ("disa", "disable", class_breakpoint
, 1);
6382 add_com("sb", class_breakpoint
, disable_command
,
6383 "Disable some breakpoints.\n\
6384 Arguments are breakpoint numbers with spaces in between.\n\
6385 To disable all breakpoints, give no argument.\n\
6386 A disabled breakpoint is not forgotten, but has no effect until reenabled.");
6388 add_cmd ("breakpoints", class_alias
, disable_command
,
6389 "Disable some breakpoints.\n\
6390 Arguments are breakpoint numbers with spaces in between.\n\
6391 To disable all breakpoints, give no argument.\n\
6392 A disabled breakpoint is not forgotten, but has no effect until reenabled.\n\
6393 This command may be abbreviated \"disable\".",
6396 add_prefix_cmd ("delete", class_breakpoint
, delete_command
,
6397 "Delete some breakpoints or auto-display expressions.\n\
6398 Arguments are breakpoint numbers with spaces in between.\n\
6399 To delete all breakpoints, give no argument.\n\
6401 Also a prefix command for deletion of other GDB objects.\n\
6402 The \"unset\" command is also an alias for \"delete\".",
6403 &deletelist
, "delete ", 1, &cmdlist
);
6404 add_com_alias ("d", "delete", class_breakpoint
, 1);
6406 add_com ("db", class_breakpoint
, delete_command
,
6407 "Delete some breakpoints.\n\
6408 Arguments are breakpoint numbers with spaces in between.\n\
6409 To delete all breakpoints, give no argument.\n");
6411 add_cmd ("breakpoints", class_alias
, delete_command
,
6412 "Delete some breakpoints or auto-display expressions.\n\
6413 Arguments are breakpoint numbers with spaces in between.\n\
6414 To delete all breakpoints, give no argument.\n\
6415 This command may be abbreviated \"delete\".",
6418 add_com ("clear", class_breakpoint
, clear_command
,
6419 concat ("Clear breakpoint at specified line or function.\n\
6420 Argument may be line number, function name, or \"*\" and an address.\n\
6421 If line number is specified, all breakpoints in that line are cleared.\n\
6422 If function is specified, breakpoints at beginning of function are cleared.\n\
6423 If an address is specified, breakpoints at that address are cleared.\n\n",
6424 "With no argument, clears all breakpoints in the line that the selected frame\n\
6427 See also the \"delete\" command which clears breakpoints by number.", NULL
));
6429 add_com ("break", class_breakpoint
, break_command
,
6430 concat ("Set breakpoint at specified line or function.\n\
6431 Argument may be line number, function name, or \"*\" and an address.\n\
6432 If line number is specified, break at start of code for that line.\n\
6433 If function is specified, break at start of code for that function.\n\
6434 If an address is specified, break at that exact address.\n",
6435 "With no arg, uses current execution address of selected stack frame.\n\
6436 This is useful for breaking on return to a stack frame.\n\
6438 Multiple breakpoints at one place are permitted, and useful if conditional.\n\
6440 Do \"help breakpoints\" for info on other commands dealing with breakpoints.", NULL
));
6441 add_com_alias ("b", "break", class_run
, 1);
6442 add_com_alias ("br", "break", class_run
, 1);
6443 add_com_alias ("bre", "break", class_run
, 1);
6444 add_com_alias ("brea", "break", class_run
, 1);
6446 add_com("xbreak", class_breakpoint
, break_at_finish_command
,
6447 concat("Set breakpoint at procedure exit. \n\
6448 Argument may be function name, or \"*\" and an address.\n\
6449 If function is specified, break at end of code for that function.\n\
6450 If an address is specified, break at the end of the function that contains \n\
6451 that exact address.\n",
6452 "With no arg, uses current execution address of selected stack frame.\n\
6453 This is useful for breaking on return to a stack frame.\n\
6455 Multiple breakpoints at one place are permitted, and useful if conditional.\n\
6457 Do \"help breakpoints\" for info on other commands dealing with breakpoints.", NULL
));
6458 add_com_alias ("xb", "xbreak", class_breakpoint
, 1);
6459 add_com_alias ("xbr", "xbreak", class_breakpoint
, 1);
6460 add_com_alias ("xbre", "xbreak", class_breakpoint
, 1);
6461 add_com_alias ("xbrea", "xbreak", class_breakpoint
, 1);
6465 add_com_alias ("ba", "break", class_breakpoint
, 1);
6466 add_com_alias ("bu", "ubreak", class_breakpoint
, 1);
6467 add_com ("bx", class_breakpoint
, break_at_finish_at_depth_command
,
6468 "Set breakpoint at procedure exit. Either there should\n\
6469 be no argument or the argument must be a depth.\n");
6474 add_abbrev_prefix_cmd("stop", class_breakpoint
, stop_command
,
6475 "Break in function/address or break at a line in the current file.",
6476 &stoplist
, "stop ", 1, &cmdlist
);
6477 add_cmd("in", class_breakpoint
, stopin_command
,
6478 "Break in function or address.\n", &stoplist
);
6479 add_cmd("at", class_breakpoint
, stopat_command
,
6480 "Break at a line in the current file.\n", &stoplist
);
6481 add_com("status", class_info
, breakpoints_info
,
6482 concat ("Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
6483 The \"Type\" column indicates one of:\n\
6484 \tbreakpoint - normal breakpoint\n\
6485 \twatchpoint - watchpoint\n\
6486 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
6487 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
6488 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
6489 address and file/line number respectively.\n\n",
6490 "Convenience variable \"$_\" and default examine address for \"x\"\n\
6491 are set to the address of the last breakpoint listed.\n\n\
6492 Convenience variable \"$bpnum\" contains the number of the last\n\
6493 breakpoint set.", NULL
));
6496 add_info ("breakpoints", breakpoints_info
,
6497 concat ("Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
6498 The \"Type\" column indicates one of:\n\
6499 \tbreakpoint - normal breakpoint\n\
6500 \twatchpoint - watchpoint\n\
6501 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
6502 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
6503 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
6504 address and file/line number respectively.\n\n",
6505 "Convenience variable \"$_\" and default examine address for \"x\"\n\
6506 are set to the address of the last breakpoint listed.\n\n\
6507 Convenience variable \"$bpnum\" contains the number of the last\n\
6508 breakpoint set.", NULL
));
6511 add_com("lb", class_breakpoint
, breakpoints_info
,
6512 concat ("Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
6513 The \"Type\" column indicates one of:\n\
6514 \tbreakpoint - normal breakpoint\n\
6515 \twatchpoint - watchpoint\n\
6516 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
6517 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
6518 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
6519 address and file/line number respectively.\n\n",
6520 "Convenience variable \"$_\" and default examine address for \"x\"\n\
6521 are set to the address of the last breakpoint listed.\n\n\
6522 Convenience variable \"$bpnum\" contains the number of the last\n\
6523 breakpoint set.", NULL
));
6525 #if MAINTENANCE_CMDS
6527 add_cmd ("breakpoints", class_maintenance
, maintenance_info_breakpoints
,
6528 concat ("Status of all breakpoints, or breakpoint number NUMBER.\n\
6529 The \"Type\" column indicates one of:\n\
6530 \tbreakpoint - normal breakpoint\n\
6531 \twatchpoint - watchpoint\n\
6532 \tlongjmp - internal breakpoint used to step through longjmp()\n\
6533 \tlongjmp resume - internal breakpoint at the target of longjmp()\n\
6534 \tuntil - internal breakpoint used by the \"until\" command\n\
6535 \tfinish - internal breakpoint used by the \"finish\" command\n",
6536 "The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
6537 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
6538 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
6539 address and file/line number respectively.\n\n",
6540 "Convenience variable \"$_\" and default examine address for \"x\"\n\
6541 are set to the address of the last breakpoint listed.\n\n\
6542 Convenience variable \"$bpnum\" contains the number of the last\n\
6543 breakpoint set.", NULL
),
6544 &maintenanceinfolist
);
6546 #endif /* MAINTENANCE_CMDS */
6548 add_com ("catch", class_breakpoint
, catch_command
,
6549 "Set catchpoints to catch events.\n\
6550 Raised signals may be caught:\n\
6551 \tcatch signal - all signals\n\
6552 \tcatch signal <signame> - a particular signal\n\
6553 Raised exceptions may be caught:\n\
6554 \tcatch throw - all exceptions, when thrown\n\
6555 \tcatch throw <exceptname> - a particular exception, when thrown\n\
6556 \tcatch catch - all exceptions, when caught\n\
6557 \tcatch catch <exceptname> - a particular exception, when caught\n\
6558 Thread or process events may be caught:\n\
6559 \tcatch thread_start - any threads, just after creation\n\
6560 \tcatch thread_exit - any threads, just before expiration\n\
6561 \tcatch thread_join - any threads, just after joins\n\
6562 Process events may be caught:\n\
6563 \tcatch start - any processes, just after creation\n\
6564 \tcatch exit - any processes, just before expiration\n\
6565 \tcatch fork - calls to fork()\n\
6566 \tcatch vfork - calls to vfork()\n\
6567 \tcatch exec - calls to exec()\n\
6568 Dynamically-linked library events may be caught:\n\
6569 \tcatch load - loads of any library\n\
6570 \tcatch load <libname> - loads of a particular library\n\
6571 \tcatch unload - unloads of any library\n\
6572 \tcatch unload <libname> - unloads of a particular library\n\
6573 The act of your program's execution stopping may also be caught:\n\
6575 C++ exceptions may be caught:\n\
6576 \tcatch throw - all exceptions, when thrown\n\
6577 \tcatch catch - all exceptions, when caught\n\
6579 Do \"help set follow-fork-mode\" for info on debugging your program\n\
6580 after a fork or vfork is caught.\n\n\
6581 Do \"help breakpoints\" for info on other commands dealing with breakpoints.");
6583 add_com ("tcatch", class_breakpoint
, tcatch_command
,
6584 "Set temporary catchpoints to catch events.\n\
6585 Args like \"catch\" command.\n\
6586 Like \"catch\" except the catchpoint is only temporary,\n\
6587 so it will be deleted when hit. Equivalent to \"catch\" followed\n\
6588 by using \"enable delete\" on the catchpoint number.");
6590 add_com ("watch", class_breakpoint
, watch_command
,
6592 "Set a watchpoint for an expression.\n\
6593 A watchpoint stops execution of your program whenever the value of\n\
6594 an expression changes.");
6596 add_com ("rwatch", class_breakpoint
, rwatch_command
,
6597 "Set a read watchpoint for an expression.\n\
6598 A watchpoint stops execution of your program whenever the value of\n\
6599 an expression is read.");
6601 add_com ("awatch", class_breakpoint
, awatch_command
,
6602 "Set a watchpoint for an expression.\n\
6603 A watchpoint stops execution of your program whenever the value of\n\
6604 an expression is either read or written.");
6606 add_info ("watchpoints", breakpoints_info
,
6607 "Synonym for ``info breakpoints''.");
6610 c
= add_set_cmd ("can-use-hw-watchpoints", class_support
, var_zinteger
,
6611 (char *) &can_use_hw_watchpoints
,
6612 "Set debugger's willingness to use watchpoint hardware.\n\
6613 If zero, gdb will not use hardware for new watchpoints, even if\n\
6614 such is available. (However, any hardware watchpoints that were\n\
6615 created before setting this to nonzero, will continue to use watchpoint\n\
6618 add_show_from_set (c
, &showlist
);
6620 can_use_hw_watchpoints
= 1;