1 /* Everything about breakpoints, for GDB.
2 Copyright 1986, 87, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 1999
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));
71 static int breakpoint_re_set_one
PARAMS ((PTR
));
74 clear_command
PARAMS ((char *, int));
77 catch_command
PARAMS ((char *, int));
80 handle_gnu_4_16_catch_command
PARAMS ((char *, int, int));
82 static struct symtabs_and_lines
83 get_catch_sals
PARAMS ((int));
86 watch_command
PARAMS ((char *, int));
89 can_use_hardware_watchpoint
PARAMS ((struct value
*));
91 static void break_at_finish_command
PARAMS ((char *, int));
92 static void break_at_finish_at_depth_command
PARAMS ((char *, int));
95 tbreak_command
PARAMS ((char *, int));
97 static void tbreak_at_finish_command
PARAMS ((char *, int));
100 break_command_1
PARAMS ((char *, int, int));
103 mention
PARAMS ((struct breakpoint
*));
106 set_raw_breakpoint
PARAMS ((struct symtab_and_line
));
109 check_duplicates
PARAMS ((CORE_ADDR
, asection
*));
112 describe_other_breakpoints
PARAMS ((CORE_ADDR
, asection
*));
115 breakpoints_info
PARAMS ((char *, int));
118 breakpoint_1
PARAMS ((int, int));
121 bpstat_alloc
PARAMS ((struct breakpoint
*, bpstat
));
123 static int breakpoint_cond_eval
PARAMS ((PTR
));
126 cleanup_executing_breakpoints
PARAMS ((PTR
));
129 commands_command
PARAMS ((char *, int));
132 condition_command
PARAMS ((char *, int));
135 get_number
PARAMS ((char **));
138 set_breakpoint_count
PARAMS ((int));
141 static struct breakpoint
*
142 create_temp_exception_breakpoint
PARAMS ((CORE_ADDR
));
151 remove_breakpoint
PARAMS ((struct breakpoint
*, insertion_state_t
));
153 static int print_it_normal
PARAMS ((bpstat
));
156 enum exception_event_kind kind
;
158 } args_for_catchpoint_enable
;
160 static int watchpoint_check
PARAMS ((PTR
));
162 static int cover_target_enable_exception_callback
PARAMS ((PTR
));
164 static int print_it_done
PARAMS ((bpstat
));
166 static int print_it_noop
PARAMS ((bpstat
));
168 static void maintenance_info_breakpoints
PARAMS ((char *, int));
170 #ifdef GET_LONGJMP_TARGET
171 static void create_longjmp_breakpoint
PARAMS ((char *));
174 static int hw_breakpoint_used_count
PARAMS ((void));
176 static int hw_watchpoint_used_count
PARAMS ((enum bptype
, int *));
178 static void hbreak_command
PARAMS ((char *, int));
180 static void thbreak_command
PARAMS ((char *, int));
182 static void watch_command_1
PARAMS ((char *, int, int));
184 static void rwatch_command
PARAMS ((char *, int));
186 static void awatch_command
PARAMS ((char *, int));
188 static void do_enable_breakpoint
PARAMS ((struct breakpoint
*, enum bpdisp
));
190 static void create_solib_load_unload_event_breakpoint
PARAMS ((char *hookname
, int tempflag
, char *dll_pathname
, char *cond_string
, enum bptype bp_kind
));
192 static void create_fork_vfork_event_catchpoint
PARAMS ((int tempflag
, char * cond_string
, enum bptype bp_kind
));
194 static void break_at_finish_at_depth_command_1
PARAMS ((char *arg
, int flag
, int from_tty
));
196 static void break_at_finish_command_1
PARAMS ((char *arg
, int flag
, int from_tty
));
198 static void stop_command
PARAMS ((char *arg
, int from_tty
));
200 static void stopin_command
PARAMS ((char *arg
, int from_tty
));
202 static void stopat_command
PARAMS ((char *arg
, int from_tty
));
204 static char *ep_find_event_name_end
PARAMS ((char *arg
));
206 static char *ep_parse_optional_if_clause
PARAMS ((char **arg
));
208 static char *ep_parse_optional_filename
PARAMS ((char **arg
));
210 static void catch_exec_command_1
PARAMS ((char *arg
, int tempflag
, int from_tty
));
212 static void create_exception_catchpoint
PARAMS ((int tempflag
, char *cond_string
, enum exception_event_kind ex_event
, struct symtab_and_line
*sal
));
214 static void catch_exception_command_1
PARAMS ((enum exception_event_kind ex_event
, char *arg
, int tempflag
, int from_tty
));
216 static void tcatch_command
PARAMS ((char *arg
, int from_tty
));
218 static void ep_skip_leading_whitespace
PARAMS ((char **s
));
220 /* Prototypes for exported functions. */
223 awatch_command
PARAMS ((char *, int));
226 do_enable_breakpoint
PARAMS ((struct breakpoint
*, enum bpdisp
));
228 /* If FALSE, gdb will not use hardware support for watchpoints, even
229 if such is available. */
230 static int can_use_hw_watchpoints
;
232 void delete_command
PARAMS ((char *, int));
234 void _initialize_breakpoint
PARAMS ((void));
236 void set_breakpoint_count
PARAMS ((int));
238 extern int addressprint
; /* Print machine addresses? */
240 #if defined (GET_LONGJMP_TARGET) || defined (SOLIB_ADD)
241 static int internal_breakpoint_number
= -1;
244 /* Are we executing breakpoint commands? */
245 static int executing_breakpoint_commands
;
247 /* Walk the following statement or block through all breakpoints.
248 ALL_BREAKPOINTS_SAFE does so even if the statment deletes the current
251 #define ALL_BREAKPOINTS(b) for (b = breakpoint_chain; b; b = b->next)
253 #define ALL_BREAKPOINTS_SAFE(b,tmp) \
254 for (b = breakpoint_chain; \
255 b? (tmp=b->next, 1): 0; \
258 /* True if SHIFT_INST_REGS defined, false otherwise. */
260 int must_shift_inst_regs
=
261 #if defined(SHIFT_INST_REGS)
268 /* True if breakpoint hit counts should be displayed in breakpoint info. */
270 int show_breakpoint_hit_counts
= 1;
272 /* Chain of all breakpoints defined. */
274 struct breakpoint
*breakpoint_chain
;
276 /* Number of last breakpoint made. */
278 int breakpoint_count
;
280 /* Pointer to current exception event record */
281 static struct exception_event_record
* current_exception_event
;
283 /* Indicator of whether exception catchpoints should be nuked
284 between runs of a program */
285 int exception_catchpoints_are_fragile
= 0;
287 /* Indicator of when exception catchpoints set-up should be
288 reinitialized -- e.g. when program is re-run */
289 int exception_support_initialized
= 0;
291 /* This function returns a pointer to the string representation of the
292 pathname of the dynamically-linked library that has just been
295 This function must be used only when SOLIB_HAVE_LOAD_EVENT is TRUE,
296 or undefined results are guaranteed.
298 This string's contents are only valid immediately after the
299 inferior has stopped in the dynamic linker hook, and becomes
300 invalid as soon as the inferior is continued. Clients should make
301 a copy of this string if they wish to continue the inferior and
302 then access the string. */
304 #ifndef SOLIB_LOADED_LIBRARY_PATHNAME
305 #define SOLIB_LOADED_LIBRARY_PATHNAME(pid) ""
308 /* This function returns a pointer to the string representation of the
309 pathname of the dynamically-linked library that has just been
312 This function must be used only when SOLIB_HAVE_UNLOAD_EVENT is
313 TRUE, or undefined results are guaranteed.
315 This string's contents are only valid immediately after the
316 inferior has stopped in the dynamic linker hook, and becomes
317 invalid as soon as the inferior is continued. Clients should make
318 a copy of this string if they wish to continue the inferior and
319 then access the string. */
321 #ifndef SOLIB_UNLOADED_LIBRARY_PATHNAME
322 #define SOLIB_UNLOADED_LIBRARY_PATHNAME(pid) ""
325 /* This function is called by the "catch load" command. It allows the
326 debugger to be notified by the dynamic linker when a specified
327 library file (or any library file, if filename is NULL) is loaded. */
329 #ifndef SOLIB_CREATE_CATCH_LOAD_HOOK
330 #define SOLIB_CREATE_CATCH_LOAD_HOOK(pid,tempflag,filename,cond_string) \
331 error ("catch of library loads not yet implemented on this platform")
334 /* This function is called by the "catch unload" command. It allows
335 the debugger to be notified by the dynamic linker when a specified
336 library file (or any library file, if filename is NULL) is
339 #ifndef SOLIB_CREATE_CATCH_UNLOAD_HOOK
340 #define SOLIB_CREATE_CATCH_UNLOAD_HOOK(pid,tempflag,filename,cond_string) \
341 error ("catch of library unloads not yet implemented on this platform")
344 /* Set breakpoint count to NUM. */
347 set_breakpoint_count (num
)
350 breakpoint_count
= num
;
351 set_internalvar (lookup_internalvar ("bpnum"),
352 value_from_longest (builtin_type_int
, (LONGEST
) num
));
355 /* Used in run_command to zero the hit count when a new run starts. */
358 clear_breakpoint_hit_counts ()
360 struct breakpoint
*b
;
366 /* Default address, symtab and line to put a breakpoint at
367 for "break" command with no arg.
368 if default_breakpoint_valid is zero, the other three are
369 not valid, and "break" with no arg is an error.
371 This set by print_stack_frame, which calls set_default_breakpoint. */
373 int default_breakpoint_valid
;
374 CORE_ADDR default_breakpoint_address
;
375 struct symtab
*default_breakpoint_symtab
;
376 int default_breakpoint_line
;
378 /* *PP is a string denoting a breakpoint. Get the number of the breakpoint.
379 Advance *PP after the string and any trailing whitespace.
381 Currently the string can either be a number or "$" followed by the name
382 of a convenience variable. Making it an expression wouldn't work well
383 for map_breakpoint_numbers (e.g. "4 + 5 + 6"). */
392 /* Empty line means refer to the last breakpoint. */
393 return breakpoint_count
;
396 /* Make a copy of the name, so we can null-terminate it
397 to pass to lookup_internalvar(). */
402 while (isalnum (*p
) || *p
== '_')
404 varname
= (char *) alloca (p
- start
+ 1);
405 strncpy (varname
, start
, p
- start
);
406 varname
[p
- start
] = '\0';
407 val
= value_of_internalvar (lookup_internalvar (varname
));
408 if (TYPE_CODE (VALUE_TYPE (val
)) != TYPE_CODE_INT
)
410 "Convenience variables used to specify breakpoints must have integer values."
412 retval
= (int) value_as_long (val
);
418 while (*p
>= '0' && *p
<= '9')
421 /* There is no number here. (e.g. "cond a == b"). */
422 error_no_arg ("breakpoint number");
425 if (!(isspace (*p
) || *p
== '\0'))
426 error ("breakpoint number expected");
433 /* condition N EXP -- set break condition of breakpoint N to EXP. */
436 condition_command (arg
, from_tty
)
440 register struct breakpoint
*b
;
445 error_no_arg ("breakpoint number");
448 bnum
= get_number (&p
);
451 if (b
->number
== bnum
)
458 if (b
->cond_string
!= NULL
)
459 free ((PTR
)b
->cond_string
);
464 b
->cond_string
= NULL
;
466 printf_filtered ("Breakpoint %d now unconditional.\n", bnum
);
471 /* I don't know if it matters whether this is the string the user
472 typed in or the decompiled expression. */
473 b
->cond_string
= savestring (arg
, strlen (arg
));
474 b
->cond
= parse_exp_1 (&arg
, block_for_pc (b
->address
), 0);
476 error ("Junk at end of expression");
478 breakpoints_changed ();
482 error ("No breakpoint number %d.", bnum
);
487 commands_command (arg
, from_tty
)
491 register struct breakpoint
*b
;
494 struct command_line
*l
;
496 /* If we allowed this, we would have problems with when to
497 free the storage, if we change the commands currently
500 if (executing_breakpoint_commands
)
501 error ("Can't use the \"commands\" command among a breakpoint's commands.");
504 bnum
= get_number (&p
);
506 error ("Unexpected extra arguments following breakpoint number.");
509 if (b
->number
== bnum
)
512 sprintf (tmpbuf
, "Type commands for when breakpoint %d is hit, one per line.", bnum
);
513 l
= read_command_lines (tmpbuf
, from_tty
);
514 free_command_lines (&b
->commands
);
516 breakpoints_changed ();
519 error ("No breakpoint number %d.", bnum
);
522 /* Like target_read_memory() but if breakpoints are inserted, return
523 the shadow contents instead of the breakpoints themselves.
525 Read "memory data" from whatever target or inferior we have.
526 Returns zero if successful, errno value if not. EIO is used
527 for address out of bounds. If breakpoints are inserted, returns
528 shadow contents, not the breakpoints themselves. From breakpoint.c. */
531 read_memory_nobpt (memaddr
, myaddr
, len
)
537 struct breakpoint
*b
;
538 CORE_ADDR bp_addr
= 0;
541 if (BREAKPOINT_FROM_PC (&bp_addr
, &bp_size
) == NULL
)
542 /* No breakpoints on this machine. */
543 return target_read_memory (memaddr
, myaddr
, len
);
547 if (b
->type
== bp_none
)
548 warning ("attempted to read through apparently deleted breakpoint #%d?\n", b
->number
);
550 /* memory breakpoint? */
551 if (b
->type
== bp_watchpoint
552 || b
->type
== bp_hardware_watchpoint
553 || b
->type
== bp_read_watchpoint
554 || b
->type
== bp_access_watchpoint
)
559 /* Addresses and length of the part of the breakpoint that
561 /* XXXX The m68k, sh and h8300 have different local and remote
562 breakpoint values. BREAKPOINT_FROM_PC still manages to
563 correctly determine the breakpoints memory address and size
564 for these targets. */
565 bp_addr
= b
->address
;
567 if (BREAKPOINT_FROM_PC (&bp_addr
, &bp_size
) == NULL
)
572 if (bp_addr
+ bp_size
<= memaddr
)
573 /* The breakpoint is entirely before the chunk of memory we
576 if (bp_addr
>= memaddr
+ len
)
577 /* The breakpoint is entirely after the chunk of memory we are
580 /* Copy the breakpoint from the shadow contents, and recurse for
581 the things before and after. */
583 /* Offset within shadow_contents. */
586 if (bp_addr
< memaddr
)
588 /* Only copy the second part of the breakpoint. */
589 bp_size
-= memaddr
- bp_addr
;
590 bptoffset
= memaddr
- bp_addr
;
594 if (bp_addr
+ bp_size
> memaddr
+ len
)
596 /* Only copy the first part of the breakpoint. */
597 bp_size
-= (bp_addr
+ bp_size
) - (memaddr
+ len
);
600 memcpy (myaddr
+ bp_addr
- memaddr
,
601 b
->shadow_contents
+ bptoffset
, bp_size
);
603 if (bp_addr
> memaddr
)
605 /* Copy the section of memory before the breakpoint. */
606 status
= read_memory_nobpt (memaddr
, myaddr
, bp_addr
- memaddr
);
611 if (bp_addr
+ bp_size
< memaddr
+ len
)
613 /* Copy the section of memory after the breakpoint. */
614 status
= read_memory_nobpt
616 myaddr
+ bp_addr
+ bp_size
- memaddr
,
617 memaddr
+ len
- (bp_addr
+ bp_size
));
624 /* Nothing overlaps. Just call read_memory_noerr. */
625 return target_read_memory (memaddr
, myaddr
, len
);
629 /* insert_breakpoints is used when starting or continuing the program.
630 remove_breakpoints is used when the program stops.
631 Both return zero if successful,
632 or an `errno' value if could not write the inferior. */
635 insert_breakpoints ()
637 register struct breakpoint
*b
, *temp
;
639 int disabled_breaks
= 0;
641 static char message1
[] = "Error inserting catchpoint %d:\n";
642 static char message
[sizeof (message1
) + 30];
645 ALL_BREAKPOINTS_SAFE (b
, temp
)
647 if (b
->type
!= bp_watchpoint
648 && b
->type
!= bp_hardware_watchpoint
649 && b
->type
!= bp_read_watchpoint
650 && b
->type
!= bp_access_watchpoint
651 && b
->type
!= bp_catch_fork
652 && b
->type
!= bp_catch_vfork
653 && b
->type
!= bp_catch_exec
654 && b
->type
!= bp_catch_throw
655 && b
->type
!= bp_catch_catch
656 && b
->enable
!= disabled
657 && b
->enable
!= shlib_disabled
658 && b
->enable
!= call_disabled
662 if (b
->type
== bp_hardware_breakpoint
)
663 val
= target_insert_hw_breakpoint(b
->address
, b
->shadow_contents
);
666 /* Check to see if breakpoint is in an overlay section;
667 if so, we should set the breakpoint at the LMA address.
668 Only if the section is currently mapped should we ALSO
669 set a break at the VMA address. */
670 if (overlay_debugging
&& b
->section
&&
671 section_is_overlay (b
->section
))
675 addr
= overlay_unmapped_address (b
->address
, b
->section
);
676 val
= target_insert_breakpoint (addr
, b
->shadow_contents
);
677 /* This would be the time to check val, to see if the
678 breakpoint write to the load address succeeded.
679 However, this might be an ordinary occurrance, eg. if
680 the unmapped overlay is in ROM. */
681 val
= 0; /* in case unmapped address failed */
682 if (section_is_mapped (b
->section
))
683 val
= target_insert_breakpoint (b
->address
,
686 else /* ordinary (non-overlay) address */
687 val
= target_insert_breakpoint(b
->address
, b
->shadow_contents
);
691 /* Can't set the breakpoint. */
692 #if defined (DISABLE_UNSETTABLE_BREAK)
693 if (DISABLE_UNSETTABLE_BREAK (b
->address
))
695 /* See also: disable_breakpoints_in_shlibs. */
697 b
->enable
= shlib_disabled
;
698 if (!disabled_breaks
)
700 target_terminal_ours_for_output ();
701 fprintf_unfiltered (gdb_stderr
,
702 "Cannot insert breakpoint %d:\n", b
->number
);
703 printf_filtered ("Temporarily disabling shared library breakpoints:\n");
706 printf_filtered ("%d ", b
->number
);
711 target_terminal_ours_for_output ();
712 fprintf_unfiltered (gdb_stderr
, "Cannot insert breakpoint %d:\n", b
->number
);
713 #ifdef ONE_PROCESS_WRITETEXT
714 fprintf_unfiltered (gdb_stderr
,
715 "The same program may be running in another process.\n");
717 memory_error (val
, b
->address
); /* which bombs us out */
723 else if (ep_is_exception_catchpoint (b
)
724 && b
->enable
!= disabled
725 && b
->enable
!= shlib_disabled
726 && b
->enable
!= call_disabled
731 /* If we get here, we must have a callback mechanism for exception
732 events -- with g++ style embedded label support, we insert
733 ordinary breakpoints and not catchpoints. */
734 sprintf (message
, message1
, b
->number
); /* Format possible error message */
736 val
= target_insert_breakpoint(b
->address
, b
->shadow_contents
);
739 /* Couldn't set breakpoint for some reason */
740 target_terminal_ours_for_output ();
741 fprintf_unfiltered (gdb_stderr
,
742 "Cannot insert catchpoint %d; disabling it\n", b
->number
);
743 b
->enable
= disabled
;
747 /* Bp set, now make sure callbacks are enabled */
749 args_for_catchpoint_enable args
;
750 args
.kind
= b
->type
== bp_catch_catch
? EX_EVENT_CATCH
: EX_EVENT_THROW
;
752 val
= catch_errors (cover_target_enable_exception_callback
,
754 message
, RETURN_MASK_ALL
);
755 if (val
!= 0 && val
!= -1)
759 /* Check if something went wrong; val == 0 can be ignored */
762 /* something went wrong */
763 target_terminal_ours_for_output ();
764 fprintf_unfiltered (gdb_stderr
, "Cannot insert catchpoint %d; disabling it\n", b
->number
);
765 b
->enable
= disabled
;
770 else if ((b
->type
== bp_hardware_watchpoint
||
771 b
->type
== bp_read_watchpoint
||
772 b
->type
== bp_access_watchpoint
)
773 && b
->enable
== enabled
777 struct frame_info
*saved_frame
;
778 int saved_level
, within_current_scope
;
779 value_ptr mark
= value_mark ();
782 /* Save the current frame and level so we can restore it after
783 evaluating the watchpoint expression on its own frame. */
784 saved_frame
= selected_frame
;
785 saved_level
= selected_frame_level
;
787 /* Determine if the watchpoint is within scope. */
788 if (b
->exp_valid_block
== NULL
)
789 within_current_scope
= 1;
792 struct frame_info
*fi
;
794 /* There might be no current frame at this moment if we are
795 resuming from a step over a breakpoint.
796 Set up current frame before trying to find the watchpoint
798 get_current_frame ();
799 fi
= find_frame_addr_in_frame_chain (b
->watchpoint_frame
);
800 within_current_scope
= (fi
!= NULL
);
801 if (within_current_scope
)
802 select_frame (fi
, -1);
805 if (within_current_scope
)
807 /* Evaluate the expression and cut the chain of values
808 produced off from the value chain. */
809 v
= evaluate_expression (b
->exp
);
810 value_release_to_mark (mark
);
815 /* Look at each value on the value chain. */
816 for ( ; v
; v
=v
->next
)
818 /* If it's a memory location, then we must watch it. */
819 if (v
->lval
== lval_memory
)
823 addr
= VALUE_ADDRESS (v
) + VALUE_OFFSET (v
);
824 len
= TYPE_LENGTH (VALUE_TYPE (v
));
826 if (b
->type
== bp_read_watchpoint
)
828 else if (b
->type
== bp_access_watchpoint
)
831 val
= target_insert_watchpoint (addr
, len
, type
);
840 /* Failure to insert a watchpoint on any memory value in the
841 value chain brings us here. */
843 warning ("Hardware watchpoint %d: Could not insert watchpoint\n",
849 Hardware watchpoint %d deleted because the program has left the block in\n\
850 which its expression is valid.\n", b
->number
);
851 if (b
->related_breakpoint
)
852 b
->related_breakpoint
->disposition
= del_at_next_stop
;
853 b
->disposition
= del_at_next_stop
;
856 /* Restore the frame and level. */
857 if ((saved_frame
!= selected_frame
) ||
858 (saved_level
!= selected_frame_level
))
859 select_and_print_frame (saved_frame
, saved_level
);
861 else if ((b
->type
== bp_catch_fork
862 || b
->type
== bp_catch_vfork
863 || b
->type
== bp_catch_exec
)
864 && b
->enable
== enabled
872 val
= target_insert_fork_catchpoint (inferior_pid
);
874 case bp_catch_vfork
:
875 val
= target_insert_vfork_catchpoint (inferior_pid
);
878 val
= target_insert_exec_catchpoint (inferior_pid
);
881 warning ("GDB bug: breakpoint.c (insert_breakpoints): enclosing `if' does not protect `switch'");
886 target_terminal_ours_for_output ();
887 fprintf_unfiltered (gdb_stderr
, "Cannot insert catchpoint %d:\n", b
->number
);
894 printf_filtered ("\n");
901 remove_breakpoints ()
903 register struct breakpoint
*b
;
910 val
= remove_breakpoint (b
, mark_uninserted
);
919 reattach_breakpoints (pid
)
922 register struct breakpoint
*b
;
924 int saved_inferior_pid
= inferior_pid
;
926 inferior_pid
= pid
; /* Because remove_breakpoint will use this global. */
931 remove_breakpoint (b
, mark_inserted
);
932 if (b
->type
== bp_hardware_breakpoint
)
933 val
= target_insert_hw_breakpoint(b
->address
, b
->shadow_contents
);
935 val
= target_insert_breakpoint(b
->address
, b
->shadow_contents
);
938 inferior_pid
= saved_inferior_pid
;
943 inferior_pid
= saved_inferior_pid
;
948 update_breakpoints_after_exec ()
950 struct breakpoint
* b
;
951 struct breakpoint
* temp
;
953 /* Doing this first prevents the badness of having delete_breakpoint()
954 write a breakpoint's current "shadow contents" to lift the bp. That
955 shadow is NOT valid after an exec()! */
956 mark_breakpoints_out ();
958 ALL_BREAKPOINTS_SAFE (b
, temp
)
960 /* Solib breakpoints must be explicitly reset after an exec(). */
961 if (b
->type
== bp_shlib_event
)
963 delete_breakpoint (b
);
967 /* Step-resume breakpoints are meaningless after an exec(). */
968 if (b
->type
== bp_step_resume
)
970 delete_breakpoint (b
);
974 /* Ditto the sigtramp handler breakpoints. */
975 if (b
->type
== bp_through_sigtramp
)
977 delete_breakpoint (b
);
981 /* Ditto the exception-handling catchpoints. */
982 if ((b
->type
== bp_catch_catch
) || (b
->type
== bp_catch_throw
))
984 delete_breakpoint (b
);
988 /* Don't delete an exec catchpoint, because else the inferior
989 won't stop when it ought!
991 Similarly, we probably ought to keep vfork catchpoints, 'cause
992 on this target, we may not be able to stop when the vfork is seen,
993 but only when the subsequent exec is seen. (And because deleting
994 fork catchpoints here but not vfork catchpoints will seem mysterious
995 to users, keep those too.)
997 ??rehrauer: Let's hope that merely clearing out this catchpoint's
998 target address field, if any, is sufficient to have it be reset
999 automagically. Certainly on HP-UX that's true. */
1000 if ((b
->type
== bp_catch_exec
) ||
1001 (b
->type
== bp_catch_vfork
) ||
1002 (b
->type
== bp_catch_fork
))
1004 b
->address
= (CORE_ADDR
) NULL
;
1008 /* bp_finish is a special case. The only way we ought to be able
1009 to see one of these when an exec() has happened, is if the user
1010 caught a vfork, and then said "finish". Ordinarily a finish just
1011 carries them to the call-site of the current callee, by setting
1012 a temporary bp there and resuming. But in this case, the finish
1013 will carry them entirely through the vfork & exec.
1015 We don't want to allow a bp_finish to remain inserted now. But
1016 we can't safely delete it, 'cause finish_command has a handle to
1017 the bp on a bpstat, and will later want to delete it. There's a
1018 chance (and I've seen it happen) that if we delete the bp_finish
1019 here, that its storage will get reused by the time finish_command
1020 gets 'round to deleting the "use to be a bp_finish" breakpoint.
1021 We really must allow finish_command to delete a bp_finish.
1023 In the absense of a general solution for the "how do we know it's
1024 safe to delete something others may have handles to?" problem, what
1025 we'll do here is just uninsert the bp_finish, and let finish_command
1028 (We know the bp_finish is "doomed" in the sense that it's momentary,
1029 and will be deleted as soon as finish_command sees the inferior stopped.
1030 So it doesn't matter that the bp's address is probably bogus in the
1031 new a.out, unlike e.g., the solib breakpoints.) */
1032 if (b
->type
== bp_finish
)
1037 /* Without a symbolic address, we have little hope of the
1038 pre-exec() address meaning the same thing in the post-exec()
1040 if (b
->addr_string
== NULL
)
1042 delete_breakpoint (b
);
1046 /* If this breakpoint has survived the above battery of checks, then
1047 it must have a symbolic address. Be sure that it gets reevaluated
1048 to a target address, rather than reusing the old evaluation. */
1049 b
->address
= (CORE_ADDR
) NULL
;
1054 detach_breakpoints (pid
)
1057 register struct breakpoint
*b
;
1059 int saved_inferior_pid
= inferior_pid
;
1061 if (pid
== inferior_pid
)
1062 error ("Cannot detach breakpoints of inferior_pid");
1064 inferior_pid
= pid
; /* Because remove_breakpoint will use this global. */
1069 val
= remove_breakpoint (b
, mark_inserted
);
1072 inferior_pid
= saved_inferior_pid
;
1077 inferior_pid
= saved_inferior_pid
;
1082 remove_breakpoint (b
, is
)
1083 struct breakpoint
*b
;
1084 insertion_state_t is
;
1088 if (b
->type
== bp_none
)
1089 warning ("attempted to remove apparently deleted breakpoint #%d?\n", b
->number
);
1091 if (b
->type
!= bp_watchpoint
1092 && b
->type
!= bp_hardware_watchpoint
1093 && b
->type
!= bp_read_watchpoint
1094 && b
->type
!= bp_access_watchpoint
1095 && b
->type
!= bp_catch_fork
1096 && b
->type
!= bp_catch_vfork
1097 && b
->type
!= bp_catch_exec
1098 && b
->type
!= bp_catch_catch
1099 && b
->type
!= bp_catch_throw
)
1102 if (b
->type
== bp_hardware_breakpoint
)
1103 val
= target_remove_hw_breakpoint(b
->address
, b
->shadow_contents
);
1106 /* Check to see if breakpoint is in an overlay section;
1107 if so, we should remove the breakpoint at the LMA address.
1108 If that is not equal to the raw address, then we should
1109 presumable remove the breakpoint there as well. */
1110 if (overlay_debugging
&& b
->section
&&
1111 section_is_overlay (b
->section
))
1115 addr
= overlay_unmapped_address (b
->address
, b
->section
);
1116 val
= target_remove_breakpoint (addr
, b
->shadow_contents
);
1117 /* This would be the time to check val, to see if the
1118 shadow breakpoint write to the load address succeeded.
1119 However, this might be an ordinary occurrance, eg. if
1120 the unmapped overlay is in ROM. */
1121 val
= 0; /* in case unmapped address failed */
1122 if (section_is_mapped (b
->section
))
1123 val
= target_remove_breakpoint (b
->address
,
1124 b
->shadow_contents
);
1126 else /* ordinary (non-overlay) address */
1127 val
= target_remove_breakpoint(b
->address
, b
->shadow_contents
);
1131 b
->inserted
= (is
== mark_inserted
);
1133 else if ((b
->type
== bp_hardware_watchpoint
||
1134 b
->type
== bp_read_watchpoint
||
1135 b
->type
== bp_access_watchpoint
)
1136 && b
->enable
== enabled
1141 b
->inserted
= (is
== mark_inserted
);
1142 /* Walk down the saved value chain. */
1143 for (v
= b
->val_chain
; v
; v
= v
->next
)
1145 /* For each memory reference remove the watchpoint
1147 if (v
->lval
== lval_memory
)
1149 int addr
, len
, type
;
1151 addr
= VALUE_ADDRESS (v
) + VALUE_OFFSET (v
);
1152 len
= TYPE_LENGTH (VALUE_TYPE (v
));
1154 if (b
->type
== bp_read_watchpoint
)
1156 else if (b
->type
== bp_access_watchpoint
)
1159 val
= target_remove_watchpoint (addr
, len
, type
);
1165 /* Failure to remove any of the hardware watchpoints comes here. */
1166 if ((is
== mark_uninserted
) && (b
->inserted
))
1167 warning ("Hardware watchpoint %d: Could not remove watchpoint\n",
1170 /* Free the saved value chain. We will construct a new one
1171 the next time the watchpoint is inserted. */
1172 for (v
= b
->val_chain
; v
; v
= n
)
1177 b
->val_chain
= NULL
;
1179 else if ((b
->type
== bp_catch_fork
||
1180 b
->type
== bp_catch_vfork
||
1181 b
->type
== bp_catch_exec
)
1182 && b
->enable
== enabled
1189 val
= target_remove_fork_catchpoint (inferior_pid
);
1191 case bp_catch_vfork
:
1192 val
= target_remove_vfork_catchpoint (inferior_pid
);
1194 case bp_catch_exec
:
1195 val
= target_remove_exec_catchpoint (inferior_pid
);
1198 warning ("GDB bug: breakpoint.c (remove_breakpoint): enclosing `if' does not protect `switch'");
1203 b
->inserted
= (is
== mark_inserted
);
1205 else if ((b
->type
== bp_catch_catch
||
1206 b
->type
== bp_catch_throw
)
1207 && b
->enable
== enabled
1211 val
= target_remove_breakpoint(b
->address
, b
->shadow_contents
);
1214 b
->inserted
= (is
== mark_inserted
);
1216 else if (ep_is_exception_catchpoint (b
)
1217 && b
->inserted
/* sometimes previous insert doesn't happen */
1218 && b
->enable
== enabled
1222 val
= target_remove_breakpoint(b
->address
, b
->shadow_contents
);
1226 b
->inserted
= (is
== mark_inserted
);
1232 /* Clear the "inserted" flag in all breakpoints. */
1235 mark_breakpoints_out ()
1237 register struct breakpoint
*b
;
1243 /* Clear the "inserted" flag in all breakpoints and delete any breakpoints
1244 which should go away between runs of the program.
1246 Plus other such housekeeping that has to be done for breakpoints
1249 Note: this function gets called at the end of a run (by generic_mourn_inferior)
1250 and when a run begins (by init_wait_for_inferior). */
1255 breakpoint_init_inferior (context
)
1256 enum inf_context context
;
1258 register struct breakpoint
*b
, *temp
;
1259 static int warning_needed
= 0;
1261 ALL_BREAKPOINTS_SAFE (b
, temp
)
1268 case bp_watchpoint_scope
:
1270 /* If the call dummy breakpoint is at the entry point it will
1271 cause problems when the inferior is rerun, so we better
1274 Also get rid of scope breakpoints. */
1275 delete_breakpoint (b
);
1279 case bp_hardware_watchpoint
:
1280 case bp_read_watchpoint
:
1281 case bp_access_watchpoint
:
1283 /* Likewise for watchpoints on local expressions. */
1284 if (b
->exp_valid_block
!= NULL
)
1285 delete_breakpoint (b
);
1288 /* Likewise for exception catchpoints in dynamic-linked
1289 executables where required */
1290 if (ep_is_exception_catchpoint (b
) &&
1291 exception_catchpoints_are_fragile
)
1294 delete_breakpoint (b
);
1300 if (exception_catchpoints_are_fragile
)
1301 exception_support_initialized
= 0;
1303 /* Don't issue the warning unless it's really needed... */
1304 if (warning_needed
&& (context
!= inf_exited
))
1306 warning ("Exception catchpoints from last run were deleted, you must reinsert them explicitly");
1311 /* breakpoint_here_p (PC) returns 1 if an enabled breakpoint exists at PC.
1312 When continuing from a location with a breakpoint,
1313 we actually single step once before calling insert_breakpoints. */
1316 breakpoint_here_p (pc
)
1319 register struct breakpoint
*b
;
1322 if (b
->enable
== enabled
1323 && b
->enable
!= shlib_disabled
1324 && b
->enable
!= call_disabled
1325 && b
->address
== pc
) /* bp is enabled and matches pc */
1327 if (overlay_debugging
&&
1328 section_is_overlay (b
->section
) &&
1329 !section_is_mapped (b
->section
))
1330 continue; /* unmapped overlay -- can't be a match */
1338 /* breakpoint_inserted_here_p (PC) is just like breakpoint_here_p(), but it
1339 only returns true if there is actually a breakpoint inserted at PC. */
1342 breakpoint_inserted_here_p (pc
)
1345 register struct breakpoint
*b
;
1349 && b
->address
== pc
) /* bp is inserted and matches pc */
1351 if (overlay_debugging
&&
1352 section_is_overlay (b
->section
) &&
1353 !section_is_mapped (b
->section
))
1354 continue; /* unmapped overlay -- can't be a match */
1362 /* Return nonzero if FRAME is a dummy frame. We can't use PC_IN_CALL_DUMMY
1363 because figuring out the saved SP would take too much time, at least using
1364 get_saved_register on the 68k. This means that for this function to
1365 work right a port must use the bp_call_dummy breakpoint. */
1368 frame_in_dummy (frame
)
1369 struct frame_info
*frame
;
1371 struct breakpoint
*b
;
1376 if (USE_GENERIC_DUMMY_FRAMES
)
1377 return generic_pc_in_call_dummy (frame
->pc
, frame
->frame
, frame
->frame
);
1381 if (b
->type
== bp_call_dummy
1382 && b
->frame
== frame
->frame
1383 /* We need to check the PC as well as the frame on the sparc,
1384 for signals.exp in the testsuite. */
1387 - SIZEOF_CALL_DUMMY_WORDS
/ sizeof (LONGEST
) * REGISTER_SIZE
))
1388 && frame
->pc
<= b
->address
)
1394 /* breakpoint_match_thread (PC, PID) returns true if the breakpoint at PC
1395 is valid for process/thread PID. */
1398 breakpoint_thread_match (pc
, pid
)
1402 struct breakpoint
*b
;
1405 thread
= pid_to_thread_id (pid
);
1408 if (b
->enable
!= disabled
1409 && b
->enable
!= shlib_disabled
1410 && b
->enable
!= call_disabled
1412 && (b
->thread
== -1 || b
->thread
== thread
))
1414 if (overlay_debugging
&&
1415 section_is_overlay (b
->section
) &&
1416 !section_is_mapped (b
->section
))
1417 continue; /* unmapped overlay -- can't be a match */
1426 /* bpstat stuff. External routines' interfaces are documented
1430 ep_is_catchpoint (ep
)
1431 struct breakpoint
* ep
;
1434 (ep
->type
== bp_catch_load
)
1435 || (ep
->type
== bp_catch_unload
)
1436 || (ep
->type
== bp_catch_fork
)
1437 || (ep
->type
== bp_catch_vfork
)
1438 || (ep
->type
== bp_catch_exec
)
1439 || (ep
->type
== bp_catch_catch
)
1440 || (ep
->type
== bp_catch_throw
)
1443 /* ??rehrauer: Add more kinds here, as are implemented... */
1448 ep_is_shlib_catchpoint (ep
)
1449 struct breakpoint
* ep
;
1452 (ep
->type
== bp_catch_load
)
1453 || (ep
->type
== bp_catch_unload
)
1458 ep_is_exception_catchpoint (ep
)
1459 struct breakpoint
* ep
;
1462 (ep
->type
== bp_catch_catch
)
1463 || (ep
->type
== bp_catch_throw
)
1467 /* Clear a bpstat so that it says we are not at any breakpoint.
1468 Also free any storage that is part of a bpstat. */
1483 if (p
->old_val
!= NULL
)
1484 value_free (p
->old_val
);
1491 /* Return a copy of a bpstat. Like "bs1 = bs2" but all storage that
1492 is part of the bpstat is copied as well. */
1500 bpstat retval
= NULL
;
1505 for (; bs
!= NULL
; bs
= bs
->next
)
1507 tmp
= (bpstat
) xmalloc (sizeof (*tmp
));
1508 memcpy (tmp
, bs
, sizeof (*tmp
));
1510 /* This is the first thing in the chain. */
1520 /* Find the bpstat associated with this breakpoint */
1523 bpstat_find_breakpoint(bsp
, breakpoint
)
1525 struct breakpoint
*breakpoint
;
1527 if (bsp
== NULL
) return NULL
;
1529 for (;bsp
!= NULL
; bsp
= bsp
->next
) {
1530 if (bsp
->breakpoint_at
== breakpoint
) return bsp
;
1535 /* Find a step_resume breakpoint associated with this bpstat.
1536 (If there are multiple step_resume bp's on the list, this function
1537 will arbitrarily pick one.)
1539 It is an error to use this function if BPSTAT doesn't contain a
1540 step_resume breakpoint.
1542 See wait_for_inferior's use of this function. */
1544 bpstat_find_step_resume_breakpoint (bsp
)
1548 error ("Internal error (bpstat_find_step_resume_breakpoint)");
1550 for (; bsp
!= NULL
; bsp
= bsp
->next
)
1552 if ((bsp
->breakpoint_at
!= NULL
) &&
1553 (bsp
->breakpoint_at
->type
== bp_step_resume
))
1554 return bsp
->breakpoint_at
;
1557 error ("Internal error (no step_resume breakpoint found)");
1561 /* Return the breakpoint number of the first breakpoint we are stopped
1562 at. *BSP upon return is a bpstat which points to the remaining
1563 breakpoints stopped at (but which is not guaranteed to be good for
1564 anything but further calls to bpstat_num).
1565 Return 0 if passed a bpstat which does not indicate any breakpoints. */
1571 struct breakpoint
*b
;
1574 return 0; /* No more breakpoint values */
1577 b
= (*bsp
)->breakpoint_at
;
1578 *bsp
= (*bsp
)->next
;
1580 return -1; /* breakpoint that's been deleted since */
1582 return b
->number
; /* We have its number */
1586 /* Modify BS so that the actions will not be performed. */
1589 bpstat_clear_actions (bs
)
1592 for (; bs
!= NULL
; bs
= bs
->next
)
1594 bs
->commands
= NULL
;
1595 if (bs
->old_val
!= NULL
)
1597 value_free (bs
->old_val
);
1603 /* Stub for cleaning up our state if we error-out of a breakpoint command */
1606 cleanup_executing_breakpoints (ignore
)
1609 executing_breakpoint_commands
= 0;
1612 /* Execute all the commands associated with all the breakpoints at this
1613 location. Any of these commands could cause the process to proceed
1614 beyond this point, etc. We look out for such changes by checking
1615 the global "breakpoint_proceeded" after each command. */
1618 bpstat_do_actions (bsp
)
1622 struct cleanup
*old_chain
;
1623 struct command_line
*cmd
;
1625 /* Avoid endless recursion if a `source' command is contained
1627 if (executing_breakpoint_commands
)
1630 executing_breakpoint_commands
= 1;
1631 old_chain
= make_cleanup (cleanup_executing_breakpoints
, 0);
1634 /* Note that (as of this writing), our callers all appear to
1635 be passing us the address of global stop_bpstat. And, if
1636 our calls to execute_control_command cause the inferior to
1637 proceed, that global (and hence, *bsp) will change.
1639 We must be careful to not touch *bsp unless the inferior
1640 has not proceeded. */
1642 /* This pointer will iterate over the list of bpstat's. */
1645 breakpoint_proceeded
= 0;
1646 for (; bs
!= NULL
; bs
= bs
->next
)
1651 execute_control_command (cmd
);
1653 if (breakpoint_proceeded
)
1658 if (breakpoint_proceeded
)
1659 /* The inferior is proceeded by the command; bomb out now.
1660 The bpstat chain has been blown away by wait_for_inferior.
1661 But since execution has stopped again, there is a new bpstat
1662 to look at, so start over. */
1665 bs
->commands
= NULL
;
1668 executing_breakpoint_commands
= 0;
1669 discard_cleanups (old_chain
);
1672 /* This is the normal print_it function for a bpstat. In the future,
1673 much of this logic could (should?) be moved to bpstat_stop_status,
1674 by having it set different print_it functions.
1676 Current scheme: When we stop, bpstat_print() is called.
1677 It loops through the bpstat list of things causing this stop,
1678 calling the print_it function for each one. The default
1679 print_it function, used for breakpoints, is print_it_normal().
1680 (Also see print_it_noop() and print_it_done()).
1682 Return values from this routine (used by bpstat_print() to
1684 1: Means we printed something, and we do *not* desire that
1685 something to be followed by a location.
1686 0: Means we printed something, and we *do* desire that
1687 something to be followed by a location.
1688 -1: Means we printed nothing. */
1691 print_it_normal (bs
)
1694 /* bs->breakpoint_at can be NULL if it was a momentary breakpoint
1695 which has since been deleted. */
1696 if (bs
->breakpoint_at
== NULL
1697 || (bs
->breakpoint_at
->type
!= bp_breakpoint
1698 && bs
->breakpoint_at
->type
!= bp_catch_load
1699 && bs
->breakpoint_at
->type
!= bp_catch_unload
1700 && bs
->breakpoint_at
->type
!= bp_catch_fork
1701 && bs
->breakpoint_at
->type
!= bp_catch_vfork
1702 && bs
->breakpoint_at
->type
!= bp_catch_exec
1703 && bs
->breakpoint_at
->type
!= bp_catch_catch
1704 && bs
->breakpoint_at
->type
!= bp_catch_throw
1705 && bs
->breakpoint_at
->type
!= bp_hardware_breakpoint
1706 && bs
->breakpoint_at
->type
!= bp_watchpoint
1707 && bs
->breakpoint_at
->type
!= bp_read_watchpoint
1708 && bs
->breakpoint_at
->type
!= bp_access_watchpoint
1709 && bs
->breakpoint_at
->type
!= bp_hardware_watchpoint
))
1712 if (ep_is_shlib_catchpoint (bs
->breakpoint_at
))
1714 annotate_catchpoint (bs
->breakpoint_at
->number
);
1715 printf_filtered ("\nCatchpoint %d (", bs
->breakpoint_at
->number
);
1716 if (bs
->breakpoint_at
->type
== bp_catch_load
)
1717 printf_filtered ("loaded");
1718 else if (bs
->breakpoint_at
->type
== bp_catch_unload
)
1719 printf_filtered ("unloaded");
1720 printf_filtered (" %s), ", bs
->breakpoint_at
->triggered_dll_pathname
);
1723 else if (bs
->breakpoint_at
->type
== bp_catch_fork
||
1724 bs
->breakpoint_at
->type
== bp_catch_vfork
)
1726 annotate_catchpoint (bs
->breakpoint_at
->number
);
1727 printf_filtered ("\nCatchpoint %d (", bs
->breakpoint_at
->number
);
1728 if (bs
->breakpoint_at
->type
== bp_catch_fork
)
1729 printf_filtered ("forked");
1730 else if (bs
->breakpoint_at
->type
== bp_catch_vfork
)
1731 printf_filtered ("vforked");
1732 printf_filtered (" process %d), ", bs
->breakpoint_at
->forked_inferior_pid
);
1735 else if (bs
->breakpoint_at
->type
== bp_catch_exec
)
1737 annotate_catchpoint (bs
->breakpoint_at
->number
);
1738 printf_filtered ("\nCatchpoint %d (exec'd %s), ",
1739 bs
->breakpoint_at
->number
,
1740 bs
->breakpoint_at
->exec_pathname
);
1743 else if (bs
->breakpoint_at
->type
== bp_catch_catch
)
1745 if (current_exception_event
&& (CURRENT_EXCEPTION_KIND
== EX_EVENT_CATCH
))
1747 annotate_catchpoint (bs
->breakpoint_at
->number
);
1748 printf_filtered ("\nCatchpoint %d (exception caught), ", bs
->breakpoint_at
->number
);
1749 printf_filtered ("throw location ");
1750 if (CURRENT_EXCEPTION_THROW_PC
&& CURRENT_EXCEPTION_THROW_LINE
)
1751 printf_filtered ("%s:%d",
1752 CURRENT_EXCEPTION_THROW_FILE
,
1753 CURRENT_EXCEPTION_THROW_LINE
);
1755 printf_filtered ("unknown");
1757 printf_filtered (", catch location ");
1758 if (CURRENT_EXCEPTION_CATCH_PC
&& CURRENT_EXCEPTION_CATCH_LINE
)
1759 printf_filtered ("%s:%d",
1760 CURRENT_EXCEPTION_CATCH_FILE
,
1761 CURRENT_EXCEPTION_CATCH_LINE
);
1763 printf_filtered ("unknown");
1765 printf_filtered ("\n");
1766 return 1; /* don't bother to print location frame info */
1770 return -1; /* really throw, some other bpstat will handle it */
1773 else if (bs
->breakpoint_at
->type
== bp_catch_throw
)
1775 if (current_exception_event
&& (CURRENT_EXCEPTION_KIND
== EX_EVENT_THROW
))
1777 annotate_catchpoint (bs
->breakpoint_at
->number
);
1778 printf_filtered ("\nCatchpoint %d (exception thrown), ", bs
->breakpoint_at
->number
);
1779 printf_filtered ("throw location ");
1780 if (CURRENT_EXCEPTION_THROW_PC
&& CURRENT_EXCEPTION_THROW_LINE
)
1781 printf_filtered ("%s:%d",
1782 CURRENT_EXCEPTION_THROW_FILE
,
1783 CURRENT_EXCEPTION_THROW_LINE
);
1785 printf_filtered ("unknown");
1787 printf_filtered (", catch location ");
1788 if (CURRENT_EXCEPTION_CATCH_PC
&& CURRENT_EXCEPTION_CATCH_LINE
)
1789 printf_filtered ("%s:%d",
1790 CURRENT_EXCEPTION_CATCH_FILE
,
1791 CURRENT_EXCEPTION_CATCH_LINE
);
1793 printf_filtered ("unknown");
1795 printf_filtered ("\n");
1796 return 1; /* don't bother to print location frame info */
1800 return -1; /* really catch, some other bpstat willhandle it */
1804 else if (bs
->breakpoint_at
->type
== bp_breakpoint
||
1805 bs
->breakpoint_at
->type
== bp_hardware_breakpoint
)
1807 /* I think the user probably only wants to see one breakpoint
1808 number, not all of them. */
1809 annotate_breakpoint (bs
->breakpoint_at
->number
);
1810 printf_filtered ("\nBreakpoint %d, ", bs
->breakpoint_at
->number
);
1813 else if ((bs
->old_val
!= NULL
) &&
1814 (bs
->breakpoint_at
->type
== bp_watchpoint
||
1815 bs
->breakpoint_at
->type
== bp_access_watchpoint
||
1816 bs
->breakpoint_at
->type
== bp_hardware_watchpoint
))
1818 annotate_watchpoint (bs
->breakpoint_at
->number
);
1819 mention (bs
->breakpoint_at
);
1820 printf_filtered ("\nOld value = ");
1821 value_print (bs
->old_val
, gdb_stdout
, 0, Val_pretty_default
);
1822 printf_filtered ("\nNew value = ");
1823 value_print (bs
->breakpoint_at
->val
, gdb_stdout
, 0,
1824 Val_pretty_default
);
1825 printf_filtered ("\n");
1826 value_free (bs
->old_val
);
1828 /* More than one watchpoint may have been triggered. */
1831 else if (bs
->breakpoint_at
->type
== bp_access_watchpoint
||
1832 bs
->breakpoint_at
->type
== bp_read_watchpoint
)
1834 mention (bs
->breakpoint_at
);
1835 printf_filtered ("\nValue = ");
1836 value_print (bs
->breakpoint_at
->val
, gdb_stdout
, 0,
1837 Val_pretty_default
);
1838 printf_filtered ("\n");
1841 /* We can't deal with it. Maybe another member of the bpstat chain can. */
1845 /* Print a message indicating what happened.
1846 This is called from normal_stop().
1847 The input to this routine is the head of the bpstat list - a list
1848 of the eventpoints that caused this stop.
1849 This routine calls the "print_it" routine(s) associated
1850 with these eventpoints. This will print (for example)
1851 the "Breakpoint n," part of the output.
1852 The return value of this routine is one of:
1854 -1: Means we printed nothing
1855 0: Means we printed something, and expect subsequent
1856 code to print the location. An example is
1857 "Breakpoint 1, " which should be followed by
1859 1 : Means we printed something, but there is no need
1860 to also print the location part of the message.
1861 An example is the catch/throw messages, which
1862 don't require a location appended to the end. */
1873 val
= (*bs
->print_it
) (bs
);
1877 /* Maybe another breakpoint in the chain caused us to stop.
1878 (Currently all watchpoints go on the bpstat whether hit or
1879 not. That probably could (should) be changed, provided care is taken
1880 with respect to bpstat_explains_signal). */
1882 return bpstat_print (bs
->next
);
1884 /* We reached the end of the chain without printing anything. */
1888 /* Evaluate the expression EXP and return 1 if value is zero.
1889 This is used inside a catch_errors to evaluate the breakpoint condition.
1890 The argument is a "struct expression *" that has been cast to char * to
1891 make it pass through catch_errors. */
1894 breakpoint_cond_eval (exp
)
1897 value_ptr mark
= value_mark ();
1898 int i
= !value_true (evaluate_expression ((struct expression
*)exp
));
1899 value_free_to_mark (mark
);
1903 /* Allocate a new bpstat and chain it to the current one. */
1906 bpstat_alloc (b
, cbs
)
1907 register struct breakpoint
*b
;
1908 bpstat cbs
; /* Current "bs" value */
1912 bs
= (bpstat
) xmalloc (sizeof (*bs
));
1914 bs
->breakpoint_at
= b
;
1915 /* If the condition is false, etc., don't do the commands. */
1916 bs
->commands
= NULL
;
1918 bs
->print_it
= print_it_normal
;
1922 /* Possible return values for watchpoint_check (this can't be an enum
1923 because of check_errors). */
1924 /* The watchpoint has been deleted. */
1925 #define WP_DELETED 1
1926 /* The value has changed. */
1927 #define WP_VALUE_CHANGED 2
1928 /* The value has not changed. */
1929 #define WP_VALUE_NOT_CHANGED 3
1931 #define BP_TEMPFLAG 1
1932 #define BP_HARDWAREFLAG 2
1934 /* Check watchpoint condition. */
1937 watchpoint_check (p
)
1940 bpstat bs
= (bpstat
) p
;
1941 struct breakpoint
*b
;
1942 struct frame_info
*fr
;
1943 int within_current_scope
;
1945 b
= bs
->breakpoint_at
;
1947 if (b
->exp_valid_block
== NULL
)
1948 within_current_scope
= 1;
1951 /* There is no current frame at this moment. If we're going to have
1952 any chance of handling watchpoints on local variables, we'll need
1953 the frame chain (so we can determine if we're in scope). */
1954 reinit_frame_cache();
1955 fr
= find_frame_addr_in_frame_chain (b
->watchpoint_frame
);
1956 within_current_scope
= (fr
!= NULL
);
1957 if (within_current_scope
)
1958 /* If we end up stopping, the current frame will get selected
1959 in normal_stop. So this call to select_frame won't affect
1961 select_frame (fr
, -1);
1964 if (within_current_scope
)
1966 /* We use value_{,free_to_}mark because it could be a
1967 *long* time before we return to the command level and
1968 call free_all_values. We can't call free_all_values because
1969 we might be in the middle of evaluating a function call. */
1971 value_ptr mark
= value_mark ();
1972 value_ptr new_val
= evaluate_expression (bs
->breakpoint_at
->exp
);
1973 if (!value_equal (b
->val
, new_val
))
1975 release_value (new_val
);
1976 value_free_to_mark (mark
);
1977 bs
->old_val
= b
->val
;
1979 /* We will stop here */
1980 return WP_VALUE_CHANGED
;
1984 /* Nothing changed, don't do anything. */
1985 value_free_to_mark (mark
);
1986 /* We won't stop here */
1987 return WP_VALUE_NOT_CHANGED
;
1992 /* This seems like the only logical thing to do because
1993 if we temporarily ignored the watchpoint, then when
1994 we reenter the block in which it is valid it contains
1995 garbage (in the case of a function, it may have two
1996 garbage values, one before and one after the prologue).
1997 So we can't even detect the first assignment to it and
1998 watch after that (since the garbage may or may not equal
1999 the first value assigned). */
2001 Watchpoint %d deleted because the program has left the block in\n\
2002 which its expression is valid.\n", bs
->breakpoint_at
->number
);
2003 if (b
->related_breakpoint
)
2004 b
->related_breakpoint
->disposition
= del_at_next_stop
;
2005 b
->disposition
= del_at_next_stop
;
2011 /* This is used when everything which needs to be printed has
2012 already been printed. But we still want to print the frame. */
2014 /* Background: When we stop, bpstat_print() is called.
2015 It loops through the bpstat list of things causing this stop,
2016 calling the print_it function for each one. The default
2017 print_it function, used for breakpoints, is print_it_normal().
2018 Also see print_it_noop() and print_it_done() are the other
2019 two possibilities. See comments in bpstat_print() and
2020 in header of print_it_normal() for more detail. */
2029 /* This is used when nothing should be printed for this bpstat entry. */
2030 /* Background: When we stop, bpstat_print() is called.
2031 It loops through the bpstat list of things causing this stop,
2032 calling the print_it function for each one. The default
2033 print_it function, used for breakpoints, is print_it_normal().
2034 Also see print_it_noop() and print_it_done() are the other
2035 two possibilities. See comments in bpstat_print() and
2036 in header of print_it_normal() for more detail. */
2045 /* Get a bpstat associated with having just stopped at address *PC
2046 and frame address CORE_ADDRESS. Update *PC to point at the
2047 breakpoint (if we hit a breakpoint). NOT_A_BREAKPOINT is nonzero
2048 if this is known to not be a real breakpoint (it could still be a
2049 watchpoint, though). */
2051 /* Determine whether we stopped at a breakpoint, etc, or whether we
2052 don't understand this stop. Result is a chain of bpstat's such that:
2054 if we don't understand the stop, the result is a null pointer.
2056 if we understand why we stopped, the result is not null.
2058 Each element of the chain refers to a particular breakpoint or
2059 watchpoint at which we have stopped. (We may have stopped for
2060 several reasons concurrently.)
2062 Each element of the chain has valid next, breakpoint_at,
2063 commands, FIXME??? fields. */
2066 bpstat_stop_status (pc
, not_a_breakpoint
)
2068 int not_a_breakpoint
;
2070 register struct breakpoint
*b
, *temp
;
2072 /* True if we've hit a breakpoint (as opposed to a watchpoint). */
2073 int real_breakpoint
= 0;
2074 /* Root of the chain of bpstat's */
2075 struct bpstats root_bs
[1];
2076 /* Pointer to the last thing in the chain currently. */
2077 bpstat bs
= root_bs
;
2078 static char message1
[] =
2079 "Error evaluating expression for watchpoint %d\n";
2080 char message
[sizeof (message1
) + 30 /* slop */];
2082 /* Get the address where the breakpoint would have been. */
2083 bp_addr
= *pc
- DECR_PC_AFTER_BREAK
;
2085 ALL_BREAKPOINTS_SAFE (b
, temp
)
2087 if (b
->enable
== disabled
2088 || b
->enable
== shlib_disabled
2089 || b
->enable
== call_disabled
)
2092 if (b
->type
!= bp_watchpoint
2093 && b
->type
!= bp_hardware_watchpoint
2094 && b
->type
!= bp_read_watchpoint
2095 && b
->type
!= bp_access_watchpoint
2096 && b
->type
!= bp_hardware_breakpoint
2097 && b
->type
!= bp_catch_fork
2098 && b
->type
!= bp_catch_vfork
2099 && b
->type
!= bp_catch_exec
2100 && b
->type
!= bp_catch_catch
2101 && b
->type
!= bp_catch_throw
) /* a non-watchpoint bp */
2102 if (b
->address
!= bp_addr
|| /* address doesn't match or */
2103 (overlay_debugging
&& /* overlay doesn't match */
2104 section_is_overlay (b
->section
) &&
2105 !section_is_mapped (b
->section
)))
2108 if (b
->type
== bp_hardware_breakpoint
2109 && b
->address
!= (*pc
- DECR_PC_AFTER_HW_BREAK
))
2112 if (b
->type
!= bp_watchpoint
2113 && b
->type
!= bp_hardware_watchpoint
2114 && b
->type
!= bp_read_watchpoint
2115 && b
->type
!= bp_access_watchpoint
2116 && not_a_breakpoint
)
2119 /* Is this a catchpoint of a load or unload? If so, did we
2120 get a load or unload of the specified library? If not,
2122 if ((b
->type
== bp_catch_load
)
2123 #if defined(SOLIB_HAVE_LOAD_EVENT)
2124 && (!SOLIB_HAVE_LOAD_EVENT(inferior_pid
)
2125 || ((b
->dll_pathname
!= NULL
)
2126 && (strcmp (b
->dll_pathname
, SOLIB_LOADED_LIBRARY_PATHNAME(inferior_pid
)) != 0)))
2131 if ((b
->type
== bp_catch_unload
)
2132 #if defined(SOLIB_HAVE_UNLOAD_EVENT)
2133 && (!SOLIB_HAVE_UNLOAD_EVENT(inferior_pid
)
2134 || ((b
->dll_pathname
!= NULL
)
2135 && (strcmp (b
->dll_pathname
, SOLIB_UNLOADED_LIBRARY_PATHNAME(inferior_pid
)) != 0)))
2140 if ((b
->type
== bp_catch_fork
)
2141 && ! target_has_forked (inferior_pid
, &b
->forked_inferior_pid
))
2144 if ((b
->type
== bp_catch_vfork
)
2145 && ! target_has_vforked (inferior_pid
, &b
->forked_inferior_pid
))
2148 if ((b
->type
== bp_catch_exec
)
2149 && ! target_has_execd (inferior_pid
, &b
->exec_pathname
))
2152 if (ep_is_exception_catchpoint (b
) &&
2153 !(current_exception_event
= target_get_current_exception_event ()))
2156 /* Come here if it's a watchpoint, or if the break address matches */
2158 bs
= bpstat_alloc (b
, bs
); /* Alloc a bpstat to explain stop */
2160 /* Watchpoints may change this, if not found to have triggered. */
2164 sprintf (message
, message1
, b
->number
);
2165 if (b
->type
== bp_watchpoint
|| b
->type
== bp_hardware_watchpoint
)
2167 switch (catch_errors (watchpoint_check
, bs
, message
, RETURN_MASK_ALL
))
2170 /* We've already printed what needs to be printed. */
2171 bs
->print_it
= print_it_done
;
2174 case WP_VALUE_CHANGED
:
2178 case WP_VALUE_NOT_CHANGED
:
2180 bs
->print_it
= print_it_noop
;
2182 /* Don't consider this a hit. */
2189 /* Error from catch_errors. */
2190 printf_filtered ("Watchpoint %d deleted.\n", b
->number
);
2191 if (b
->related_breakpoint
)
2192 b
->related_breakpoint
->disposition
= del_at_next_stop
;
2193 b
->disposition
= del_at_next_stop
;
2194 /* We've already printed what needs to be printed. */
2195 bs
->print_it
= print_it_done
;
2201 else if (b
->type
== bp_read_watchpoint
|| b
->type
== bp_access_watchpoint
)
2207 addr
= target_stopped_data_address();
2208 if (addr
== 0) continue;
2209 for (v
= b
->val_chain
; v
; v
= v
->next
)
2211 if (v
->lval
== lval_memory
)
2215 vaddr
= VALUE_ADDRESS (v
) + VALUE_OFFSET (v
);
2221 switch (catch_errors (watchpoint_check
, bs
, message
, RETURN_MASK_ALL
))
2224 /* We've already printed what needs to be printed. */
2225 bs
->print_it
= print_it_done
;
2228 case WP_VALUE_CHANGED
:
2229 case WP_VALUE_NOT_CHANGED
:
2236 /* Error from catch_errors. */
2237 printf_filtered ("Watchpoint %d deleted.\n", b
->number
);
2238 if (b
->related_breakpoint
)
2239 b
->related_breakpoint
->disposition
= del_at_next_stop
;
2240 b
->disposition
= del_at_next_stop
;
2241 /* We've already printed what needs to be printed. */
2242 bs
->print_it
= print_it_done
;
2248 /* By definition, an encountered breakpoint is a triggered
2252 real_breakpoint
= 1;
2255 if (b
->frame
&& b
->frame
!= (get_current_frame ())->frame
&&
2256 (b
->type
== bp_step_resume
&&
2257 (INNER_THAN (get_current_frame ()->frame
, b
->frame
))))
2261 int value_is_zero
= 0;
2265 /* Need to select the frame, with all that implies
2266 so that the conditions will have the right context. */
2267 select_frame (get_current_frame (), 0);
2269 = catch_errors (breakpoint_cond_eval
, (b
->cond
),
2270 "Error in testing breakpoint condition:\n",
2272 /* FIXME-someday, should give breakpoint # */
2275 if (b
->cond
&& value_is_zero
)
2278 /* Don't consider this a hit. */
2281 else if (b
->ignore_count
> 0)
2288 /* We will stop here */
2289 if (b
->disposition
== disable
)
2290 b
->enable
= disabled
;
2291 bs
->commands
= b
->commands
;
2295 (STREQ ("silent", bs
->commands
->line
) ||
2296 (xdb_commands
&& STREQ ("Q", bs
->commands
->line
))))
2298 bs
->commands
= bs
->commands
->next
;
2303 /* Print nothing for this entry if we dont stop or if we dont print. */
2304 if (bs
->stop
== 0 || bs
->print
== 0)
2305 bs
->print_it
= print_it_noop
;
2308 bs
->next
= NULL
; /* Terminate the chain */
2309 bs
= root_bs
->next
; /* Re-grab the head of the chain */
2311 if (real_breakpoint
&& bs
)
2313 if (bs
->breakpoint_at
->type
== bp_hardware_breakpoint
)
2315 if (DECR_PC_AFTER_HW_BREAK
!= 0)
2317 *pc
= *pc
- DECR_PC_AFTER_HW_BREAK
;
2323 if (DECR_PC_AFTER_BREAK
!= 0 || must_shift_inst_regs
)
2326 #if defined (SHIFT_INST_REGS)
2328 #else /* No SHIFT_INST_REGS. */
2330 #endif /* No SHIFT_INST_REGS. */
2335 /* The value of a hardware watchpoint hasn't changed, but the
2336 intermediate memory locations we are watching may have. */
2337 if (bs
&& ! bs
->stop
&&
2338 (bs
->breakpoint_at
->type
== bp_hardware_watchpoint
||
2339 bs
->breakpoint_at
->type
== bp_read_watchpoint
||
2340 bs
->breakpoint_at
->type
== bp_access_watchpoint
))
2342 remove_breakpoints ();
2343 insert_breakpoints ();
2348 /* Tell what to do about this bpstat. */
2353 /* Classify each bpstat as one of the following. */
2355 /* This bpstat element has no effect on the main_action. */
2358 /* There was a watchpoint, stop but don't print. */
2361 /* There was a watchpoint, stop and print. */
2364 /* There was a breakpoint but we're not stopping. */
2367 /* There was a breakpoint, stop but don't print. */
2370 /* There was a breakpoint, stop and print. */
2373 /* We hit the longjmp breakpoint. */
2376 /* We hit the longjmp_resume breakpoint. */
2379 /* We hit the step_resume breakpoint. */
2382 /* We hit the through_sigtramp breakpoint. */
2385 /* We hit the shared library event breakpoint. */
2388 /* We caught a shared library event. */
2391 /* This is just used to count how many enums there are. */
2395 /* Here is the table which drives this routine. So that we can
2396 format it pretty, we define some abbreviations for the
2397 enum bpstat_what codes. */
2398 #define kc BPSTAT_WHAT_KEEP_CHECKING
2399 #define ss BPSTAT_WHAT_STOP_SILENT
2400 #define sn BPSTAT_WHAT_STOP_NOISY
2401 #define sgl BPSTAT_WHAT_SINGLE
2402 #define slr BPSTAT_WHAT_SET_LONGJMP_RESUME
2403 #define clr BPSTAT_WHAT_CLEAR_LONGJMP_RESUME
2404 #define clrs BPSTAT_WHAT_CLEAR_LONGJMP_RESUME_SINGLE
2405 #define sr BPSTAT_WHAT_STEP_RESUME
2406 #define ts BPSTAT_WHAT_THROUGH_SIGTRAMP
2407 #define shl BPSTAT_WHAT_CHECK_SHLIBS
2408 #define shlr BPSTAT_WHAT_CHECK_SHLIBS_RESUME_FROM_HOOK
2410 /* "Can't happen." Might want to print an error message.
2411 abort() is not out of the question, but chances are GDB is just
2412 a bit confused, not unusable. */
2413 #define err BPSTAT_WHAT_STOP_NOISY
2415 /* Given an old action and a class, come up with a new action. */
2416 /* One interesting property of this table is that wp_silent is the same
2417 as bp_silent and wp_noisy is the same as bp_noisy. That is because
2418 after stopping, the check for whether to step over a breakpoint
2419 (BPSTAT_WHAT_SINGLE type stuff) is handled in proceed() without
2420 reference to how we stopped. We retain separate wp_silent and bp_silent
2421 codes in case we want to change that someday.
2423 Another possibly interesting property of this table is that
2424 there's a partial ordering, priority-like, of the actions. Once
2425 you've decided that some action is appropriate, you'll never go
2426 back and decide something of a lower priority is better. The
2429 kc < clr sgl shl slr sn sr ss ts
2430 sgl < clrs shl shlr slr sn sr ss ts
2431 slr < err shl shlr sn sr ss ts
2432 clr < clrs err shl shlr sn sr ss ts
2433 clrs < err shl shlr sn sr ss ts
2434 ss < shl shlr sn sr ts
2441 What I think this means is that we don't need a damned table
2442 here. If you just put the rows and columns in the right order,
2443 it'd look awfully regular. We could simply walk the bpstat list
2444 and choose the highest priority action we find, with a little
2445 logic to handle the 'err' cases, and the CLEAR_LONGJMP_RESUME/
2446 CLEAR_LONGJMP_RESUME_SINGLE distinction (which breakpoint.h says
2447 is messy anyway). */
2449 /* step_resume entries: a step resume breakpoint overrides another
2450 breakpoint of signal handling (see comment in wait_for_inferior
2451 at first IN_SIGTRAMP where we set the step_resume breakpoint). */
2452 /* We handle the through_sigtramp_breakpoint the same way; having both
2453 one of those and a step_resume_breakpoint is probably very rare (?). */
2455 static const enum bpstat_what_main_action
2456 table
[(int)class_last
][(int)BPSTAT_WHAT_LAST
] =
2459 /* kc ss sn sgl slr clr clrs sr ts shl shlr
2461 /*no_effect*/ {kc
, ss
, sn
, sgl
, slr
, clr
, clrs
, sr
, ts
, shl
, shlr
},
2462 /*wp_silent*/ {ss
, ss
, sn
, ss
, ss
, ss
, ss
, sr
, ts
, shl
, shlr
},
2463 /*wp_noisy*/ {sn
, sn
, sn
, sn
, sn
, sn
, sn
, sr
, ts
, shl
, shlr
},
2464 /*bp_nostop*/ {sgl
, ss
, sn
, sgl
, slr
, clrs
, clrs
, sr
, ts
, shl
, shlr
},
2465 /*bp_silent*/ {ss
, ss
, sn
, ss
, ss
, ss
, ss
, sr
, ts
, shl
, shlr
},
2466 /*bp_noisy*/ {sn
, sn
, sn
, sn
, sn
, sn
, sn
, sr
, ts
, shl
, shlr
},
2467 /*long_jump*/ {slr
, ss
, sn
, slr
, err
, err
, err
, sr
, ts
, shl
, shlr
},
2468 /*long_resume*/ {clr
, ss
, sn
, clrs
, err
, err
, err
, sr
, ts
, shl
, shlr
},
2469 /*step_resume*/ {sr
, sr
, sr
, sr
, sr
, sr
, sr
, sr
, ts
, shl
, shlr
},
2470 /*through_sig*/ {ts
, ts
, ts
, ts
, ts
, ts
, ts
, ts
, ts
, shl
, shlr
},
2471 /*shlib*/ {shl
, shl
, shl
, shl
, shl
, shl
, shl
, shl
, ts
, shl
, shlr
},
2472 /*catch_shlib*/ {shlr
, shlr
, shlr
, shlr
, shlr
, shlr
, shlr
, shlr
, ts
, shlr
, shlr
}
2487 enum bpstat_what_main_action current_action
= BPSTAT_WHAT_KEEP_CHECKING
;
2488 struct bpstat_what retval
;
2490 retval
.call_dummy
= 0;
2491 for (; bs
!= NULL
; bs
= bs
->next
)
2493 enum class bs_class
= no_effect
;
2494 if (bs
->breakpoint_at
== NULL
)
2495 /* I suspect this can happen if it was a momentary breakpoint
2496 which has since been deleted. */
2498 switch (bs
->breakpoint_at
->type
)
2504 case bp_hardware_breakpoint
:
2510 bs_class
= bp_noisy
;
2512 bs_class
= bp_silent
;
2515 bs_class
= bp_nostop
;
2518 case bp_hardware_watchpoint
:
2519 case bp_read_watchpoint
:
2520 case bp_access_watchpoint
:
2524 bs_class
= wp_noisy
;
2526 bs_class
= wp_silent
;
2529 /* There was a watchpoint, but we're not stopping. This requires
2530 no further action. */
2531 bs_class
= no_effect
;
2534 bs_class
= long_jump
;
2536 case bp_longjmp_resume
:
2537 bs_class
= long_resume
;
2539 case bp_step_resume
:
2542 bs_class
= step_resume
;
2545 /* It is for the wrong frame. */
2546 bs_class
= bp_nostop
;
2548 case bp_through_sigtramp
:
2549 bs_class
= through_sig
;
2551 case bp_watchpoint_scope
:
2552 bs_class
= bp_nostop
;
2554 case bp_shlib_event
:
2555 bs_class
= shlib_event
;
2558 case bp_catch_unload
:
2559 /* Only if this catchpoint triggered should we cause the
2560 step-out-of-dld behaviour. Otherwise, we ignore this
2563 bs_class
= catch_shlib_event
;
2565 bs_class
= no_effect
;
2568 case bp_catch_vfork
:
2573 bs_class
= bp_noisy
;
2575 bs_class
= bp_silent
;
2578 /* There was a catchpoint, but we're not stopping. This requires
2579 no further action. */
2580 bs_class
= no_effect
;
2582 case bp_catch_catch
:
2583 if (!bs
->stop
|| CURRENT_EXCEPTION_KIND
!= EX_EVENT_CATCH
)
2584 bs_class
= bp_nostop
;
2586 bs_class
= bs
->print
? bp_noisy
: bp_silent
;
2588 case bp_catch_throw
:
2589 if (!bs
->stop
|| CURRENT_EXCEPTION_KIND
!= EX_EVENT_THROW
)
2590 bs_class
= bp_nostop
;
2592 bs_class
= bs
->print
? bp_noisy
: bp_silent
;
2595 /* Make sure the action is stop (silent or noisy), so infrun.c
2596 pops the dummy frame. */
2597 bs_class
= bp_silent
;
2598 retval
.call_dummy
= 1;
2601 current_action
= table
[(int)bs_class
][(int)current_action
];
2603 retval
.main_action
= current_action
;
2607 /* Nonzero if we should step constantly (e.g. watchpoints on machines
2608 without hardware support). This isn't related to a specific bpstat,
2609 just to things like whether watchpoints are set. */
2612 bpstat_should_step ()
2614 struct breakpoint
*b
;
2616 if (b
->enable
== enabled
&& b
->type
== bp_watchpoint
)
2621 /* Nonzero if there are enabled hardware watchpoints. */
2623 bpstat_have_active_hw_watchpoints ()
2625 struct breakpoint
*b
;
2627 if ((b
->enable
== enabled
) &&
2629 ((b
->type
== bp_hardware_watchpoint
) ||
2630 (b
->type
== bp_read_watchpoint
) ||
2631 (b
->type
== bp_access_watchpoint
)))
2637 /* Given a bpstat that records zero or more triggered eventpoints, this
2638 function returns another bpstat which contains only the catchpoints
2639 on that first list, if any. */
2641 bpstat_get_triggered_catchpoints (ep_list
, cp_list
)
2645 struct bpstats root_bs
[1];
2646 bpstat bs
= root_bs
;
2647 struct breakpoint
* ep
;
2648 char * dll_pathname
;
2650 bpstat_clear (cp_list
);
2651 root_bs
->next
= NULL
;
2653 for (; ep_list
!= NULL
; ep_list
= ep_list
->next
)
2655 /* Is this eventpoint a catchpoint? If not, ignore it. */
2656 ep
= ep_list
->breakpoint_at
;
2659 if ((ep
->type
!= bp_catch_load
) &&
2660 (ep
->type
!= bp_catch_unload
) &&
2661 (ep
->type
!= bp_catch_catch
) &&
2662 (ep
->type
!= bp_catch_throw
)) /* pai: (temp) ADD fork/vfork here!! */
2665 /* Yes; add it to the list. */
2666 bs
= bpstat_alloc (ep
, bs
);
2671 #if defined(SOLIB_ADD)
2672 /* Also, for each triggered catchpoint, tag it with the name of
2673 the library that caused this trigger. (We copy the name now,
2674 because it's only guaranteed to be available NOW, when the
2675 catchpoint triggers. Clients who may wish to know the name
2676 later must get it from the catchpoint itself.) */
2677 if (ep
->triggered_dll_pathname
!= NULL
)
2678 free (ep
->triggered_dll_pathname
);
2679 if (ep
->type
== bp_catch_load
)
2680 dll_pathname
= SOLIB_LOADED_LIBRARY_PATHNAME (inferior_pid
);
2682 dll_pathname
= SOLIB_UNLOADED_LIBRARY_PATHNAME (inferior_pid
);
2684 dll_pathname
= NULL
;
2688 ep
->triggered_dll_pathname
= (char *) xmalloc (strlen (dll_pathname
) + 1);
2689 strcpy (ep
->triggered_dll_pathname
, dll_pathname
);
2692 ep
->triggered_dll_pathname
= NULL
;
2698 /* Print information on breakpoint number BNUM, or -1 if all.
2699 If WATCHPOINTS is zero, process only breakpoints; if WATCHPOINTS
2700 is nonzero, process only watchpoints. */
2705 } ep_type_description_t
;
2708 breakpoint_1 (bnum
, allflag
)
2712 register struct breakpoint
*b
;
2713 register struct command_line
*l
;
2714 register struct symbol
*sym
;
2715 CORE_ADDR last_addr
= (CORE_ADDR
)-1;
2716 int found_a_breakpoint
= 0;
2717 static ep_type_description_t bptypes
[] =
2719 {bp_none
, "?deleted?"},
2720 {bp_breakpoint
, "breakpoint"},
2721 {bp_hardware_breakpoint
, "hw breakpoint"},
2722 {bp_until
, "until"},
2723 {bp_finish
, "finish"},
2724 {bp_watchpoint
, "watchpoint"},
2725 {bp_hardware_watchpoint
, "hw watchpoint"},
2726 {bp_read_watchpoint
, "read watchpoint"},
2727 {bp_access_watchpoint
, "acc watchpoint"},
2728 {bp_longjmp
, "longjmp"},
2729 {bp_longjmp_resume
, "longjmp resume"},
2730 {bp_step_resume
, "step resume"},
2731 {bp_through_sigtramp
, "sigtramp"},
2732 {bp_watchpoint_scope
, "watchpoint scope"},
2733 {bp_call_dummy
, "call dummy"},
2734 {bp_shlib_event
, "shlib events"},
2735 {bp_catch_load
, "catch load"},
2736 {bp_catch_unload
, "catch unload"},
2737 {bp_catch_fork
, "catch fork"},
2738 {bp_catch_vfork
, "catch vfork"},
2739 {bp_catch_exec
, "catch exec"},
2740 {bp_catch_catch
, "catch catch"},
2741 {bp_catch_throw
, "catch throw"}
2744 static char *bpdisps
[] = {"del", "dstp", "dis", "keep"};
2745 static char bpenables
[] = "nyn";
2746 char wrap_indent
[80];
2751 || bnum
== b
->number
)
2753 /* We only print out user settable breakpoints unless the allflag is set. */
2755 && b
->type
!= bp_breakpoint
2756 && b
->type
!= bp_catch_load
2757 && b
->type
!= bp_catch_unload
2758 && b
->type
!= bp_catch_fork
2759 && b
->type
!= bp_catch_vfork
2760 && b
->type
!= bp_catch_exec
2761 && b
->type
!= bp_catch_catch
2762 && b
->type
!= bp_catch_throw
2763 && b
->type
!= bp_hardware_breakpoint
2764 && b
->type
!= bp_watchpoint
2765 && b
->type
!= bp_read_watchpoint
2766 && b
->type
!= bp_access_watchpoint
2767 && b
->type
!= bp_hardware_watchpoint
)
2770 if (!found_a_breakpoint
++)
2772 annotate_breakpoints_headers ();
2775 printf_filtered ("Num ");
2777 printf_filtered ("Type ");
2779 printf_filtered ("Disp ");
2781 printf_filtered ("Enb ");
2785 printf_filtered ("Address ");
2788 printf_filtered ("What\n");
2790 annotate_breakpoints_table ();
2795 printf_filtered ("%-3d ", b
->number
);
2797 if ((int)b
->type
> (sizeof(bptypes
)/sizeof(bptypes
[0])))
2798 error ("bptypes table does not describe type #%d.", (int)b
->type
);
2799 if ((int)b
->type
!= bptypes
[(int)b
->type
].type
)
2800 error ("bptypes table does not describe type #%d?", (int)b
->type
);
2801 printf_filtered ("%-14s ", bptypes
[(int)b
->type
].description
);
2803 printf_filtered ("%-4s ", bpdisps
[(int)b
->disposition
]);
2805 printf_filtered ("%-3c ", bpenables
[(int)b
->enable
]);
2807 strcpy (wrap_indent
, " ");
2809 strcat (wrap_indent
, " ");
2813 case bp_hardware_watchpoint
:
2814 case bp_read_watchpoint
:
2815 case bp_access_watchpoint
:
2816 /* Field 4, the address, is omitted (which makes the columns
2817 not line up too nicely with the headers, but the effect
2818 is relatively readable). */
2820 print_expression (b
->exp
, gdb_stdout
);
2824 case bp_catch_unload
:
2825 /* Field 4, the address, is omitted (which makes the columns
2826 not line up too nicely with the headers, but the effect
2827 is relatively readable). */
2829 if (b
->dll_pathname
== NULL
)
2830 printf_filtered ("<any library> ");
2832 printf_filtered ("library \"%s\" ", b
->dll_pathname
);
2836 case bp_catch_vfork
:
2837 /* Field 4, the address, is omitted (which makes the columns
2838 not line up too nicely with the headers, but the effect
2839 is relatively readable). */
2841 if (b
->forked_inferior_pid
!= 0)
2842 printf_filtered ("process %d ", b
->forked_inferior_pid
);
2846 /* Field 4, the address, is omitted (which makes the columns
2847 not line up too nicely with the headers, but the effect
2848 is relatively readable). */
2850 if (b
->exec_pathname
!= NULL
)
2851 printf_filtered ("program \"%s\" ", b
->exec_pathname
);
2853 case bp_catch_catch
:
2854 /* Field 4, the address, is omitted (which makes the columns
2855 not line up too nicely with the headers, but the effect
2856 is relatively readable). */
2858 printf_filtered ("exception catch ");
2860 case bp_catch_throw
:
2861 /* Field 4, the address, is omitted (which makes the columns
2862 not line up too nicely with the headers, but the effect
2863 is relatively readable). */
2865 printf_filtered ("exception throw ");
2869 case bp_hardware_breakpoint
:
2873 case bp_longjmp_resume
:
2874 case bp_step_resume
:
2875 case bp_through_sigtramp
:
2876 case bp_watchpoint_scope
:
2878 case bp_shlib_event
:
2882 /* FIXME-32x64: need a print_address_numeric with
2886 local_hex_string_custom
2887 ((unsigned long) b
->address
, "08l"));
2892 last_addr
= b
->address
;
2895 sym
= find_pc_sect_function (b
->address
, b
->section
);
2898 fputs_filtered ("in ", gdb_stdout
);
2899 fputs_filtered (SYMBOL_SOURCE_NAME (sym
), gdb_stdout
);
2900 wrap_here (wrap_indent
);
2901 fputs_filtered (" at ", gdb_stdout
);
2903 fputs_filtered (b
->source_file
, gdb_stdout
);
2904 printf_filtered (":%d", b
->line_number
);
2907 print_address_symbolic (b
->address
, gdb_stdout
, demangle
, " ");
2911 if (b
->thread
!= -1)
2912 printf_filtered (" thread %d", b
->thread
);
2914 printf_filtered ("\n");
2920 printf_filtered ("\tstop only in stack frame at ");
2921 print_address_numeric (b
->frame
, 1, gdb_stdout
);
2922 printf_filtered ("\n");
2929 printf_filtered ("\tstop only if ");
2930 print_expression (b
->cond
, gdb_stdout
);
2931 printf_filtered ("\n");
2934 if (b
->thread
!= -1)
2936 /* FIXME should make an annotation for this */
2937 printf_filtered ("\tstop only in thread %d\n", b
->thread
);
2940 if (show_breakpoint_hit_counts
&& b
->hit_count
)
2942 /* FIXME should make an annotation for this */
2943 if (ep_is_catchpoint (b
))
2944 printf_filtered ("\tcatchpoint");
2946 printf_filtered ("\tbreakpoint");
2947 printf_filtered (" already hit %d time%s\n",
2948 b
->hit_count
, (b
->hit_count
== 1 ? "" : "s"));
2951 if (b
->ignore_count
)
2955 printf_filtered ("\tignore next %d hits\n", b
->ignore_count
);
2958 if ((l
= b
->commands
))
2964 print_command_line (l
, 4, gdb_stdout
);
2970 if (!found_a_breakpoint
)
2973 printf_filtered ("No breakpoints or watchpoints.\n");
2975 printf_filtered ("No breakpoint or watchpoint number %d.\n", bnum
);
2978 /* Compare against (CORE_ADDR)-1 in case some compiler decides
2979 that a comparison of an unsigned with -1 is always false. */
2980 if (last_addr
!= (CORE_ADDR
)-1)
2981 set_next_address (last_addr
);
2983 annotate_breakpoints_table_end ();
2988 breakpoints_info (bnum_exp
, from_tty
)
2995 bnum
= parse_and_eval_address (bnum_exp
);
2997 breakpoint_1 (bnum
, 0);
3002 maintenance_info_breakpoints (bnum_exp
, from_tty
)
3009 bnum
= parse_and_eval_address (bnum_exp
);
3011 breakpoint_1 (bnum
, 1);
3014 /* Print a message describing any breakpoints set at PC. */
3017 describe_other_breakpoints (pc
, section
)
3021 register int others
= 0;
3022 register struct breakpoint
*b
;
3025 if (b
->address
== pc
)
3026 if (overlay_debugging
== 0 ||
3027 b
->section
== section
)
3031 printf_filtered ("Note: breakpoint%s ", (others
> 1) ? "s" : "");
3033 if (b
->address
== pc
)
3034 if (overlay_debugging
== 0 ||
3035 b
->section
== section
)
3041 ((b
->enable
== disabled
|| b
->enable
== shlib_disabled
|| b
->enable
== call_disabled
)
3042 ? " (disabled)" : ""),
3043 (others
> 1) ? "," : ((others
== 1) ? " and" : ""));
3045 printf_filtered ("also set at pc ");
3046 print_address_numeric (pc
, 1, gdb_stdout
);
3047 printf_filtered (".\n");
3051 /* Set the default place to put a breakpoint
3052 for the `break' command with no arguments. */
3055 set_default_breakpoint (valid
, addr
, symtab
, line
)
3058 struct symtab
*symtab
;
3061 default_breakpoint_valid
= valid
;
3062 default_breakpoint_address
= addr
;
3063 default_breakpoint_symtab
= symtab
;
3064 default_breakpoint_line
= line
;
3067 /* Rescan breakpoints at address ADDRESS,
3068 marking the first one as "first" and any others as "duplicates".
3069 This is so that the bpt instruction is only inserted once. */
3072 check_duplicates (address
, section
)
3076 register struct breakpoint
*b
;
3077 register int count
= 0;
3079 if (address
== 0) /* Watchpoints are uninteresting */
3083 if (b
->enable
!= disabled
3084 && b
->enable
!= shlib_disabled
3085 && b
->enable
!= call_disabled
3086 && b
->address
== address
3087 && (overlay_debugging
== 0 || b
->section
== section
))
3090 b
->duplicate
= count
> 1;
3094 /* Low level routine to set a breakpoint.
3095 Takes as args the three things that every breakpoint must have.
3096 Returns the breakpoint object so caller can set other things.
3097 Does not set the breakpoint number!
3098 Does not print anything.
3100 ==> This routine should not be called if there is a chance of later
3101 error(); otherwise it leaves a bogus breakpoint on the chain. Validate
3102 your arguments BEFORE calling this routine! */
3105 set_raw_breakpoint (sal
)
3106 struct symtab_and_line sal
;
3108 register struct breakpoint
*b
, *b1
;
3110 b
= (struct breakpoint
*) xmalloc (sizeof (struct breakpoint
));
3111 memset (b
, 0, sizeof (*b
));
3112 b
->address
= sal
.pc
;
3113 if (sal
.symtab
== NULL
)
3114 b
->source_file
= NULL
;
3116 b
->source_file
= savestring (sal
.symtab
->filename
,
3117 strlen (sal
.symtab
->filename
));
3118 b
->section
= sal
.section
;
3119 b
->language
= current_language
->la_language
;
3120 b
->input_radix
= input_radix
;
3122 b
->line_number
= sal
.line
;
3123 b
->enable
= enabled
;
3126 b
->ignore_count
= 0;
3129 b
->dll_pathname
= NULL
;
3130 b
->triggered_dll_pathname
= NULL
;
3131 b
->forked_inferior_pid
= 0;
3132 b
->exec_pathname
= NULL
;
3134 /* Add this breakpoint to the end of the chain
3135 so that a list of breakpoints will come out in order
3136 of increasing numbers. */
3138 b1
= breakpoint_chain
;
3140 breakpoint_chain
= b
;
3148 check_duplicates (sal
.pc
, sal
.section
);
3149 breakpoints_changed ();
3154 #ifdef GET_LONGJMP_TARGET
3157 create_longjmp_breakpoint (func_name
)
3160 struct symtab_and_line sal
;
3161 struct breakpoint
*b
;
3163 INIT_SAL (&sal
); /* initialize to zeroes */
3164 if (func_name
!= NULL
)
3166 struct minimal_symbol
*m
;
3168 m
= lookup_minimal_symbol_text (func_name
, NULL
, (struct objfile
*)NULL
);
3170 sal
.pc
= SYMBOL_VALUE_ADDRESS (m
);
3174 sal
.section
= find_pc_overlay (sal
.pc
);
3175 b
= set_raw_breakpoint (sal
);
3178 b
->type
= func_name
!= NULL
? bp_longjmp
: bp_longjmp_resume
;
3179 b
->disposition
= donttouch
;
3180 b
->enable
= disabled
;
3183 b
->addr_string
= strsave(func_name
);
3184 b
->number
= internal_breakpoint_number
--;
3187 #endif /* #ifdef GET_LONGJMP_TARGET */
3189 /* Call this routine when stepping and nexting to enable a breakpoint if we do
3190 a longjmp(). When we hit that breakpoint, call
3191 set_longjmp_resume_breakpoint() to figure out where we are going. */
3194 enable_longjmp_breakpoint()
3196 register struct breakpoint
*b
;
3199 if (b
->type
== bp_longjmp
)
3201 b
->enable
= enabled
;
3202 check_duplicates (b
->address
, b
->section
);
3207 disable_longjmp_breakpoint()
3209 register struct breakpoint
*b
;
3212 if ( b
->type
== bp_longjmp
3213 || b
->type
== bp_longjmp_resume
)
3215 b
->enable
= disabled
;
3216 check_duplicates (b
->address
, b
->section
);
3222 remove_solib_event_breakpoints ()
3224 register struct breakpoint
*b
, *temp
;
3226 ALL_BREAKPOINTS_SAFE (b
, temp
)
3227 if (b
->type
== bp_shlib_event
)
3228 delete_breakpoint (b
);
3232 create_solib_event_breakpoint (address
)
3235 struct breakpoint
*b
;
3236 struct symtab_and_line sal
;
3238 INIT_SAL (&sal
); /* initialize to zeroes */
3240 sal
.section
= find_pc_overlay (sal
.pc
);
3241 b
= set_raw_breakpoint (sal
);
3242 b
->number
= internal_breakpoint_number
--;
3243 b
->disposition
= donttouch
;
3244 b
->type
= bp_shlib_event
;
3248 disable_breakpoints_in_shlibs (silent
)
3251 struct breakpoint
* b
;
3252 int disabled_shlib_breaks
= 0;
3254 /* See also: insert_breakpoints, under DISABLE_UNSETTABLE_BREAK. */
3257 #if defined (PC_SOLIB)
3258 if (((b
->type
== bp_breakpoint
) ||
3259 (b
->type
== bp_hardware_breakpoint
)) &&
3260 (b
->enable
!= shlib_disabled
) &&
3261 (b
->enable
!= call_disabled
) &&
3263 PC_SOLIB (b
->address
))
3265 b
->enable
= shlib_disabled
;
3268 if (!disabled_shlib_breaks
)
3270 target_terminal_ours_for_output ();
3271 printf_filtered ("Temporarily disabling shared library breakpoints:\n");
3273 disabled_shlib_breaks
= 1;
3274 printf_filtered ("%d ", b
->number
);
3279 if (disabled_shlib_breaks
&& !silent
)
3280 printf_filtered ("\n");
3283 /* Try to reenable any breakpoints in shared libraries. */
3285 re_enable_breakpoints_in_shlibs ()
3287 struct breakpoint
*b
;
3290 if (b
->enable
== shlib_disabled
)
3294 /* Do not reenable the breakpoint if the shared library
3295 is still not mapped in. */
3296 if (target_read_memory (b
->address
, buf
, 1) == 0)
3297 b
->enable
= enabled
;
3304 create_solib_load_unload_event_breakpoint (hookname
, tempflag
, dll_pathname
, cond_string
, bp_kind
)
3309 enum bptype bp_kind
;
3311 struct breakpoint
* b
;
3312 struct symtabs_and_lines sals
;
3313 struct symtab_and_line sal
;
3314 struct cleanup
* old_chain
;
3315 struct cleanup
* canonical_strings_chain
= NULL
;
3317 char * addr_start
= hookname
;
3318 char * addr_end
= NULL
;
3319 char ** canonical
= (char **) NULL
;
3320 int thread
= -1; /* All threads. */
3322 /* Set a breakpoint on the specified hook. */
3323 sals
= decode_line_1 (&hookname
, 1, (struct symtab
*) NULL
, 0, &canonical
);
3324 addr_end
= hookname
;
3326 if (sals
.nelts
== 0)
3328 warning ("Unable to set a breakpoint on dynamic linker callback.");
3329 warning ("Suggest linking with /opt/langtools/lib/end.o.");
3330 warning ("GDB will be unable to track shl_load/shl_unload calls");
3333 if (sals
.nelts
!= 1)
3335 warning ("Unable to set a unique breakpoint on dynamic linker callback.");
3336 warning ("GDB will be unable to track shl_load/shl_unload calls");
3340 /* Make sure that all storage allocated in decode_line_1 gets freed in case
3341 the following errors out. */
3342 old_chain
= make_cleanup (free
, sals
.sals
);
3343 if (canonical
!= (char **)NULL
)
3345 make_cleanup (free
, canonical
);
3346 canonical_strings_chain
= make_cleanup (null_cleanup
, 0);
3347 if (canonical
[0] != NULL
)
3348 make_cleanup (free
, canonical
[0]);
3351 resolve_sal_pc (&sals
.sals
[0]);
3353 /* Remove the canonical strings from the cleanup, they are needed below. */
3354 if (canonical
!= (char **)NULL
)
3355 discard_cleanups (canonical_strings_chain
);
3357 b
= set_raw_breakpoint (sals
.sals
[0]);
3358 set_breakpoint_count (breakpoint_count
+ 1);
3359 b
->number
= breakpoint_count
;
3361 b
->cond_string
= (cond_string
== NULL
) ? NULL
: savestring (cond_string
, strlen (cond_string
));
3364 if (canonical
!= (char **)NULL
&& canonical
[0] != NULL
)
3365 b
->addr_string
= canonical
[0];
3366 else if (addr_start
)
3367 b
->addr_string
= savestring (addr_start
, addr_end
- addr_start
);
3369 b
->enable
= enabled
;
3370 b
->disposition
= tempflag
? del
: donttouch
;
3372 if (dll_pathname
== NULL
)
3373 b
->dll_pathname
= NULL
;
3376 b
->dll_pathname
= (char *) xmalloc (strlen (dll_pathname
) + 1);
3377 strcpy (b
->dll_pathname
, dll_pathname
);
3382 do_cleanups (old_chain
);
3386 create_solib_load_event_breakpoint (hookname
, tempflag
, dll_pathname
, cond_string
)
3389 char * dll_pathname
;
3392 create_solib_load_unload_event_breakpoint (hookname
,
3400 create_solib_unload_event_breakpoint (hookname
, tempflag
, dll_pathname
, cond_string
)
3403 char * dll_pathname
;
3406 create_solib_load_unload_event_breakpoint (hookname
,
3414 create_fork_vfork_event_catchpoint (tempflag
, cond_string
, bp_kind
)
3417 enum bptype bp_kind
;
3419 struct symtab_and_line sal
;
3420 struct breakpoint
* b
;
3421 int thread
= -1; /* All threads. */
3428 b
= set_raw_breakpoint (sal
);
3429 set_breakpoint_count (breakpoint_count
+ 1);
3430 b
->number
= breakpoint_count
;
3432 b
->cond_string
= (cond_string
== NULL
) ? NULL
: savestring (cond_string
, strlen (cond_string
));
3434 b
->addr_string
= NULL
;
3435 b
->enable
= enabled
;
3436 b
->disposition
= tempflag
? del
: donttouch
;
3437 b
->forked_inferior_pid
= 0;
3445 create_fork_event_catchpoint (tempflag
, cond_string
)
3449 create_fork_vfork_event_catchpoint (tempflag
, cond_string
, bp_catch_fork
);
3453 create_vfork_event_catchpoint (tempflag
, cond_string
)
3457 create_fork_vfork_event_catchpoint (tempflag
, cond_string
, bp_catch_vfork
);
3461 create_exec_event_catchpoint (tempflag
, cond_string
)
3465 struct symtab_and_line sal
;
3466 struct breakpoint
* b
;
3467 int thread
= -1; /* All threads. */
3474 b
= set_raw_breakpoint (sal
);
3475 set_breakpoint_count (breakpoint_count
+ 1);
3476 b
->number
= breakpoint_count
;
3478 b
->cond_string
= (cond_string
== NULL
) ? NULL
: savestring (cond_string
, strlen (cond_string
));
3480 b
->addr_string
= NULL
;
3481 b
->enable
= enabled
;
3482 b
->disposition
= tempflag
? del
: donttouch
;
3484 b
->type
= bp_catch_exec
;
3490 hw_breakpoint_used_count()
3492 register struct breakpoint
*b
;
3497 if (b
->type
== bp_hardware_breakpoint
&& b
->enable
== enabled
)
3505 hw_watchpoint_used_count(type
, other_type_used
)
3507 int *other_type_used
;
3509 register struct breakpoint
*b
;
3512 *other_type_used
= 0;
3515 if (b
->enable
== enabled
)
3517 if (b
->type
== type
) i
++;
3518 else if ((b
->type
== bp_hardware_watchpoint
||
3519 b
->type
== bp_read_watchpoint
||
3520 b
->type
== bp_access_watchpoint
)
3521 && b
->enable
== enabled
)
3522 *other_type_used
= 1;
3528 /* Call this after hitting the longjmp() breakpoint. Use this to set a new
3529 breakpoint at the target of the jmp_buf.
3531 FIXME - This ought to be done by setting a temporary breakpoint that gets
3532 deleted automatically... */
3535 set_longjmp_resume_breakpoint(pc
, frame
)
3537 struct frame_info
*frame
;
3539 register struct breakpoint
*b
;
3542 if (b
->type
== bp_longjmp_resume
)
3545 b
->enable
= enabled
;
3547 b
->frame
= frame
->frame
;
3550 check_duplicates (b
->address
, b
->section
);
3556 disable_watchpoints_before_interactive_call_start ()
3558 struct breakpoint
* b
;
3562 if (((b
->type
== bp_watchpoint
)
3563 || (b
->type
== bp_hardware_watchpoint
)
3564 || (b
->type
== bp_read_watchpoint
)
3565 || (b
->type
== bp_access_watchpoint
)
3566 || ep_is_exception_catchpoint (b
))
3567 && (b
->enable
== enabled
))
3569 b
->enable
= call_disabled
;
3570 check_duplicates (b
->address
, b
->section
);
3576 enable_watchpoints_after_interactive_call_stop ()
3578 struct breakpoint
* b
;
3582 if (((b
->type
== bp_watchpoint
)
3583 || (b
->type
== bp_hardware_watchpoint
)
3584 || (b
->type
== bp_read_watchpoint
)
3585 || (b
->type
== bp_access_watchpoint
)
3586 || ep_is_exception_catchpoint (b
))
3587 && (b
->enable
== call_disabled
))
3589 b
->enable
= enabled
;
3590 check_duplicates (b
->address
, b
->section
);
3596 /* Set a breakpoint that will evaporate an end of command
3597 at address specified by SAL.
3598 Restrict it to frame FRAME if FRAME is nonzero. */
3601 set_momentary_breakpoint (sal
, frame
, type
)
3602 struct symtab_and_line sal
;
3603 struct frame_info
*frame
;
3606 register struct breakpoint
*b
;
3607 b
= set_raw_breakpoint (sal
);
3609 b
->enable
= enabled
;
3610 b
->disposition
= donttouch
;
3611 b
->frame
= (frame
? frame
->frame
: 0);
3613 /* If we're debugging a multi-threaded program, then we
3614 want momentary breakpoints to be active in only a
3615 single thread of control. */
3616 if (in_thread_list (inferior_pid
))
3617 b
->thread
= pid_to_thread_id (inferior_pid
);
3623 /* Tell the user we have just set a breakpoint B. */
3627 struct breakpoint
*b
;
3631 /* FIXME: This is misplaced; mention() is called by things (like hitting a
3632 watchpoint) other than breakpoint creation. It should be possible to
3633 clean this up and at the same time replace the random calls to
3634 breakpoint_changed with this hook, as has already been done for
3635 delete_breakpoint_hook and so on. */
3636 if (create_breakpoint_hook
)
3637 create_breakpoint_hook (b
);
3642 printf_filtered ("(apparently deleted?) Eventpoint %d: ", b
->number
);
3645 printf_filtered ("Watchpoint %d: ", b
->number
);
3646 print_expression (b
->exp
, gdb_stdout
);
3648 case bp_hardware_watchpoint
:
3649 printf_filtered ("Hardware watchpoint %d: ", b
->number
);
3650 print_expression (b
->exp
, gdb_stdout
);
3652 case bp_read_watchpoint
:
3653 printf_filtered ("Hardware read watchpoint %d: ", b
->number
);
3654 print_expression (b
->exp
, gdb_stdout
);
3656 case bp_access_watchpoint
:
3657 printf_filtered ("Hardware access (read/write) watchpoint %d: ",b
->number
);
3658 print_expression (b
->exp
, gdb_stdout
);
3661 printf_filtered ("Breakpoint %d", b
->number
);
3664 case bp_hardware_breakpoint
:
3665 printf_filtered ("Hardware assisted breakpoint %d", b
->number
);
3669 case bp_catch_unload
:
3670 printf_filtered ("Catchpoint %d (%s %s)",
3672 (b
->type
== bp_catch_load
) ? "load" : "unload",
3673 (b
->dll_pathname
!= NULL
) ? b
->dll_pathname
: "<any library>");
3676 case bp_catch_vfork
:
3677 printf_filtered ("Catchpoint %d (%s)",
3679 (b
->type
== bp_catch_fork
) ? "fork" : "vfork");
3682 printf_filtered ("Catchpoint %d (exec)",
3685 case bp_catch_catch
:
3686 case bp_catch_throw
:
3687 printf_filtered ("Catchpoint %d (%s)",
3689 (b
->type
== bp_catch_catch
) ? "catch" : "throw");
3695 case bp_longjmp_resume
:
3696 case bp_step_resume
:
3697 case bp_through_sigtramp
:
3699 case bp_watchpoint_scope
:
3700 case bp_shlib_event
:
3705 if (addressprint
|| b
->source_file
== NULL
)
3707 printf_filtered (" at ");
3708 print_address_numeric (b
->address
, 1, gdb_stdout
);
3711 printf_filtered (": file %s, line %d.",
3712 b
->source_file
, b
->line_number
);
3713 TUIDO(((TuiOpaqueFuncPtr
)tui_vAllSetHasBreakAt
, b
, 1));
3714 TUIDO(((TuiOpaqueFuncPtr
)tuiUpdateAllExecInfos
));
3716 printf_filtered ("\n");
3720 /* Set a breakpoint according to ARG (function, linenum or *address)
3721 flag: first bit : 0 non-temporary, 1 temporary.
3722 second bit : 0 normal breakpoint, 1 hardware breakpoint. */
3725 break_command_1 (arg
, flag
, from_tty
)
3729 int tempflag
, hardwareflag
;
3730 struct symtabs_and_lines sals
;
3731 struct symtab_and_line sal
;
3732 register struct expression
*cond
= 0;
3733 register struct breakpoint
*b
;
3735 /* Pointers in arg to the start, and one past the end, of the condition. */
3736 char *cond_start
= NULL
;
3737 char *cond_end
= NULL
;
3738 /* Pointers in arg to the start, and one past the end,
3739 of the address part. */
3740 char *addr_start
= NULL
;
3741 char *addr_end
= NULL
;
3742 struct cleanup
*old_chain
;
3743 struct cleanup
*canonical_strings_chain
= NULL
;
3744 char **canonical
= (char **)NULL
;
3748 hardwareflag
= flag
& BP_HARDWAREFLAG
;
3749 tempflag
= flag
& BP_TEMPFLAG
;
3754 INIT_SAL (&sal
); /* initialize to zeroes */
3756 /* If no arg given, or if first arg is 'if ', use the default breakpoint. */
3758 if (!arg
|| (arg
[0] == 'i' && arg
[1] == 'f'
3759 && (arg
[2] == ' ' || arg
[2] == '\t')))
3761 if (default_breakpoint_valid
)
3763 sals
.sals
= (struct symtab_and_line
*)
3764 xmalloc (sizeof (struct symtab_and_line
));
3765 sal
.pc
= default_breakpoint_address
;
3766 sal
.line
= default_breakpoint_line
;
3767 sal
.symtab
= default_breakpoint_symtab
;
3768 sal
.section
= find_pc_overlay (sal
.pc
);
3773 error ("No default breakpoint address now.");
3779 /* Force almost all breakpoints to be in terms of the
3780 current_source_symtab (which is decode_line_1's default). This
3781 should produce the results we want almost all of the time while
3782 leaving default_breakpoint_* alone. */
3783 if (default_breakpoint_valid
3784 && (!current_source_symtab
3785 || (arg
&& (*arg
== '+' || *arg
== '-'))))
3786 sals
= decode_line_1 (&arg
, 1, default_breakpoint_symtab
,
3787 default_breakpoint_line
, &canonical
);
3789 sals
= decode_line_1 (&arg
, 1, (struct symtab
*)NULL
, 0, &canonical
);
3797 /* Make sure that all storage allocated in decode_line_1 gets freed in case
3798 the following `for' loop errors out. */
3799 old_chain
= make_cleanup (free
, sals
.sals
);
3800 if (canonical
!= (char **)NULL
)
3802 make_cleanup (free
, canonical
);
3803 canonical_strings_chain
= make_cleanup (null_cleanup
, 0);
3804 for (i
= 0; i
< sals
.nelts
; i
++)
3806 if (canonical
[i
] != NULL
)
3807 make_cleanup (free
, canonical
[i
]);
3811 thread
= -1; /* No specific thread yet */
3813 /* Resolve all line numbers to PC's, and verify that conditions
3814 can be parsed, before setting any breakpoints. */
3815 for (i
= 0; i
< sals
.nelts
; i
++)
3817 char *tok
, *end_tok
;
3820 resolve_sal_pc (&sals
.sals
[i
]);
3822 /* It's possible for the PC to be nonzero, but still an illegal
3823 value on some targets.
3825 For example, on HP-UX if you start gdb, and before running the
3826 inferior you try to set a breakpoint on a shared library function
3827 "foo" where the inferior doesn't call "foo" directly but does
3828 pass its address to another function call, then we do find a
3829 minimal symbol for the "foo", but it's address is invalid.
3830 (Appears to be an index into a table that the loader sets up
3831 when the inferior is run.)
3833 Give the target a chance to bless sals.sals[i].pc before we
3834 try to make a breakpoint for it. */
3835 if (PC_REQUIRES_RUN_BEFORE_USE(sals
.sals
[i
].pc
))
3837 error ("Cannot break on %s without a running program.", addr_start
);
3844 while (*tok
== ' ' || *tok
== '\t')
3849 while (*end_tok
!= ' ' && *end_tok
!= '\t' && *end_tok
!= '\000')
3852 toklen
= end_tok
- tok
;
3854 if (toklen
>= 1 && strncmp (tok
, "if", toklen
) == 0)
3856 tok
= cond_start
= end_tok
+ 1;
3857 cond
= parse_exp_1 (&tok
, block_for_pc (sals
.sals
[i
].pc
), 0);
3860 else if (toklen
>= 1 && strncmp (tok
, "thread", toklen
) == 0)
3866 thread
= strtol (tok
, &tok
, 0);
3868 error ("Junk after thread keyword.");
3869 if (!valid_thread_id (thread
))
3870 error ("Unknown thread %d\n", thread
);
3873 error ("Junk at end of arguments.");
3878 int i
, target_resources_ok
;
3880 i
= hw_breakpoint_used_count ();
3881 target_resources_ok
= TARGET_CAN_USE_HARDWARE_WATCHPOINT (
3882 bp_hardware_breakpoint
, i
+ sals
.nelts
, 0);
3883 if (target_resources_ok
== 0)
3884 error ("No hardware breakpoint support in the target.");
3885 else if (target_resources_ok
< 0)
3886 error ("Hardware breakpoints used exceeds limit.");
3889 /* Remove the canonical strings from the cleanup, they are needed below. */
3890 if (canonical
!= (char **)NULL
)
3891 discard_cleanups (canonical_strings_chain
);
3893 /* Now set all the breakpoints. */
3894 for (i
= 0; i
< sals
.nelts
; i
++)
3899 describe_other_breakpoints (sal
.pc
, sal
.section
);
3901 b
= set_raw_breakpoint (sal
);
3902 set_breakpoint_count (breakpoint_count
+ 1);
3903 b
->number
= breakpoint_count
;
3904 b
->type
= hardwareflag
? bp_hardware_breakpoint
: bp_breakpoint
;
3908 /* If a canonical line spec is needed use that instead of the
3910 if (canonical
!= (char **)NULL
&& canonical
[i
] != NULL
)
3911 b
->addr_string
= canonical
[i
];
3912 else if (addr_start
)
3913 b
->addr_string
= savestring (addr_start
, addr_end
- addr_start
);
3915 b
->cond_string
= savestring (cond_start
, cond_end
- cond_start
);
3917 b
->enable
= enabled
;
3918 b
->disposition
= tempflag
? del
: donttouch
;
3924 printf_filtered ("Multiple breakpoints were set.\n");
3925 printf_filtered ("Use the \"delete\" command to delete unwanted breakpoints.\n");
3927 do_cleanups (old_chain
);
3931 break_at_finish_at_depth_command_1 (arg
, flag
, from_tty
)
3936 struct frame_info
*frame
;
3937 CORE_ADDR low
, high
, selected_pc
= 0;
3938 char *extra_args
, *level_arg
, *addr_string
;
3939 int extra_args_len
= 0, if_arg
= 0;
3942 (arg
[0] == 'i' && arg
[1] == 'f' && (arg
[2] == ' ' || arg
[2] == '\t')))
3945 if (default_breakpoint_valid
)
3949 selected_pc
= selected_frame
->pc
;
3954 error ("No selected frame.");
3957 error ("No default breakpoint address now.");
3961 extra_args
= strchr (arg
, ' ');
3965 extra_args_len
= strlen (extra_args
);
3966 level_arg
= (char *) xmalloc (extra_args
- arg
);
3967 strncpy (level_arg
, arg
, extra_args
- arg
- 1);
3968 level_arg
[extra_args
- arg
- 1] = '\0';
3972 level_arg
= (char *) xmalloc (strlen (arg
) + 1);
3973 strcpy (level_arg
, arg
);
3976 frame
= parse_frame_specification (level_arg
);
3978 selected_pc
= frame
->pc
;
3985 extra_args_len
= strlen (arg
);
3990 if (find_pc_partial_function(selected_pc
, (char **)NULL
, &low
, &high
))
3992 addr_string
= (char *) xmalloc (26 + extra_args_len
);
3994 sprintf (addr_string
, "*0x%x %s", high
, extra_args
);
3996 sprintf (addr_string
, "*0x%x", high
);
3997 break_command_1 (addr_string
, flag
, from_tty
);
4001 error ("No function contains the specified address");
4004 error ("Unable to set breakpoint at procedure exit");
4009 break_at_finish_command_1 (arg
, flag
, from_tty
)
4014 char *addr_string
, *break_string
, *beg_addr_string
;
4015 CORE_ADDR low
, high
;
4016 struct symtabs_and_lines sals
;
4017 struct symtab_and_line sal
;
4018 struct cleanup
*old_chain
;
4020 int extra_args_len
= 0;
4024 (arg
[0] == 'i' && arg
[1] == 'f' && (arg
[2] == ' ' || arg
[2] == '\t')))
4026 if (default_breakpoint_valid
)
4030 addr_string
= (char *) xmalloc (15);
4031 sprintf (addr_string
, "*0x%x", selected_frame
->pc
);
4036 error ("No selected frame.");
4039 error ("No default breakpoint address now.");
4043 addr_string
= (char *) xmalloc (strlen (arg
) + 1);
4044 strcpy (addr_string
, arg
);
4050 extra_args_len
= strlen (arg
);
4055 /* get the stuff after the function name or address */
4056 extra_args
= strchr (arg
, ' ');
4060 extra_args_len
= strlen (extra_args
);
4067 beg_addr_string
= addr_string
;
4068 sals
= decode_line_1 (&addr_string
, 1, (struct symtab
*)NULL
, 0,
4071 free (beg_addr_string
);
4072 old_chain
= make_cleanup (free
, sals
.sals
);
4073 for (i
= 0; (i
< sals
.nelts
); i
++)
4076 if (find_pc_partial_function (sal
.pc
, (char **)NULL
, &low
, &high
))
4078 break_string
= (char *) xmalloc (extra_args_len
+ 26);
4080 sprintf (break_string
, "*0x%x %s", high
, extra_args
);
4082 sprintf (break_string
, "*0x%x", high
);
4083 break_command_1 (break_string
, flag
, from_tty
);
4087 error ("No function contains the specified address");
4091 printf_filtered ("Multiple breakpoints were set.\n");
4092 printf_filtered ("Use the \"delete\" command to delete unwanted breakpoints.\n");
4094 do_cleanups(old_chain
);
4098 /* Helper function for break_command_1 and disassemble_command. */
4101 resolve_sal_pc (sal
)
4102 struct symtab_and_line
*sal
;
4106 if (sal
->pc
== 0 && sal
->symtab
!= NULL
)
4108 if (!find_line_pc (sal
->symtab
, sal
->line
, &pc
))
4109 error ("No line %d in file \"%s\".",
4110 sal
->line
, sal
->symtab
->filename
);
4114 if (sal
->section
== 0 && sal
->symtab
!= NULL
)
4116 struct blockvector
*bv
;
4121 bv
= blockvector_for_pc_sect (sal
->pc
, 0, &index
, sal
->symtab
);
4124 b
= BLOCKVECTOR_BLOCK (bv
, index
);
4125 sym
= block_function (b
);
4128 fixup_symbol_section (sym
, sal
->symtab
->objfile
);
4129 sal
->section
= SYMBOL_BFD_SECTION (sym
);
4133 /* It really is worthwhile to have the section, so we'll just
4134 have to look harder. This case can be executed if we have
4135 line numbers but no functions (as can happen in assembly
4138 struct minimal_symbol
*msym
;
4140 msym
= lookup_minimal_symbol_by_pc (sal
->pc
);
4142 sal
->section
= SYMBOL_BFD_SECTION (msym
);
4149 break_command (arg
, from_tty
)
4153 break_command_1 (arg
, 0, from_tty
);
4157 break_at_finish_command (arg
, from_tty
)
4161 break_at_finish_command_1 (arg
, 0, from_tty
);
4165 break_at_finish_at_depth_command (arg
, from_tty
)
4169 break_at_finish_at_depth_command_1 (arg
, 0, from_tty
);
4173 tbreak_command (arg
, from_tty
)
4177 break_command_1 (arg
, BP_TEMPFLAG
, from_tty
);
4181 tbreak_at_finish_command (arg
, from_tty
)
4185 break_at_finish_command_1 (arg
, BP_TEMPFLAG
, from_tty
);
4189 hbreak_command (arg
, from_tty
)
4193 break_command_1 (arg
, BP_HARDWAREFLAG
, from_tty
);
4197 thbreak_command (arg
, from_tty
)
4201 break_command_1 (arg
, (BP_TEMPFLAG
| BP_HARDWAREFLAG
), from_tty
);
4205 stop_command (arg
, from_tty
)
4209 printf_filtered ("Specify the type of breakpoint to set.\n\
4210 Usage: stop in <function | address>\n\
4215 stopin_command (arg
, from_tty
)
4221 if (arg
== (char *)NULL
)
4223 else if (*arg
!= '*')
4228 /* look for a ':'. If this is a line number specification, then say
4229 it is bad, otherwise, it should be an address or function/method
4231 while (*argptr
&& !hasColon
)
4233 hasColon
= (*argptr
== ':');
4238 badInput
= (*argptr
!= ':'); /* Not a class::method */
4240 badInput
= isdigit(*arg
); /* a simple line number */
4244 printf_filtered("Usage: stop in <function | address>\n");
4246 break_command_1 (arg
, 0, from_tty
);
4250 stopat_command (arg
, from_tty
)
4256 if (arg
== (char *)NULL
|| *arg
== '*') /* no line number */
4263 /* look for a ':'. If there is a '::' then get out, otherwise
4264 it is probably a line number. */
4265 while (*argptr
&& !hasColon
)
4267 hasColon
= (*argptr
== ':');
4272 badInput
= (*argptr
== ':'); /* we have class::method */
4274 badInput
= !isdigit(*arg
); /* not a line number */
4278 printf_filtered("Usage: stop at <line>\n");
4280 break_command_1 (arg
, 0, from_tty
);
4284 /* accessflag: 0: watch write, 1: watch read, 2: watch access(read or write) */
4286 watch_command_1 (arg
, accessflag
, from_tty
)
4291 struct breakpoint
*b
;
4292 struct symtab_and_line sal
;
4293 struct expression
*exp
;
4294 struct block
*exp_valid_block
;
4295 struct value
*val
, *mark
;
4296 struct frame_info
*frame
;
4297 struct frame_info
*prev_frame
= NULL
;
4298 char *exp_start
= NULL
;
4299 char *exp_end
= NULL
;
4300 char *tok
, *end_tok
;
4302 char *cond_start
= NULL
;
4303 char *cond_end
= NULL
;
4304 struct expression
*cond
= NULL
;
4305 int i
, other_type_used
, target_resources_ok
= 0;
4306 enum bptype bp_type
;
4309 INIT_SAL (&sal
); /* initialize to zeroes */
4311 /* Parse arguments. */
4312 innermost_block
= NULL
;
4314 exp
= parse_exp_1 (&arg
, 0, 0);
4316 exp_valid_block
= innermost_block
;
4317 mark
= value_mark ();
4318 val
= evaluate_expression (exp
);
4319 release_value (val
);
4320 if (VALUE_LAZY (val
))
4321 value_fetch_lazy (val
);
4324 while (*tok
== ' ' || *tok
== '\t')
4328 while (*end_tok
!= ' ' && *end_tok
!= '\t' && *end_tok
!= '\000')
4331 toklen
= end_tok
- tok
;
4332 if (toklen
>= 1 && strncmp (tok
, "if", toklen
) == 0)
4334 tok
= cond_start
= end_tok
+ 1;
4335 cond
= parse_exp_1 (&tok
, 0, 0);
4339 error("Junk at end of command.");
4341 if (accessflag
== 1) bp_type
= bp_read_watchpoint
;
4342 else if (accessflag
== 2) bp_type
= bp_access_watchpoint
;
4343 else bp_type
= bp_hardware_watchpoint
;
4345 mem_cnt
= can_use_hardware_watchpoint (val
);
4346 if (mem_cnt
== 0 && bp_type
!= bp_hardware_watchpoint
)
4347 error ("Expression cannot be implemented with read/access watchpoint.");
4349 i
= hw_watchpoint_used_count (bp_type
, &other_type_used
);
4350 target_resources_ok
= TARGET_CAN_USE_HARDWARE_WATCHPOINT(
4351 bp_type
, i
+ mem_cnt
, other_type_used
);
4352 if (target_resources_ok
== 0 && bp_type
!= bp_hardware_watchpoint
)
4353 error ("Target does not have this type of hardware watchpoint support.");
4354 if (target_resources_ok
< 0 && bp_type
!= bp_hardware_watchpoint
)
4355 error ("Target resources have been allocated for other types of watchpoints.");
4358 #if defined(HPUXHPPA)
4359 /* On HP-UX if you set a h/w
4360 watchpoint before the "run" command, the inferior dies with a e.g.,
4361 SIGILL once you start it. I initially believed this was due to a
4362 bad interaction between page protection traps and the initial
4363 startup sequence by the dynamic linker.
4365 However, I tried avoiding that by having HP-UX's implementation of
4366 TARGET_CAN_USE_HW_WATCHPOINT return FALSE if there was no inferior_pid
4367 yet, which forced slow watches before a "run" or "attach", and it
4368 still fails somewhere in the startup code.
4370 Until I figure out what's happening, I'm disallowing watches altogether
4371 before the "run" or "attach" command. We'll tell the user they must
4372 set watches after getting the program started. */
4373 if (! target_has_execution
)
4375 warning ("can't do that without a running program; try \"break main\", \"run\" first");
4378 #endif /* HPUXHPPA */
4380 /* Now set up the breakpoint. */
4381 b
= set_raw_breakpoint (sal
);
4382 set_breakpoint_count (breakpoint_count
+ 1);
4383 b
->number
= breakpoint_count
;
4384 b
->disposition
= donttouch
;
4386 b
->exp_valid_block
= exp_valid_block
;
4387 b
->exp_string
= savestring (exp_start
, exp_end
- exp_start
);
4391 b
->cond_string
= savestring (cond_start
, cond_end
- cond_start
);
4395 frame
= block_innermost_frame (exp_valid_block
);
4398 prev_frame
= get_prev_frame (frame
);
4399 b
->watchpoint_frame
= frame
->frame
;
4402 b
->watchpoint_frame
= (CORE_ADDR
)0;
4404 if (mem_cnt
&& target_resources_ok
> 0)
4407 b
->type
= bp_watchpoint
;
4409 /* If the expression is "local", then set up a "watchpoint scope"
4410 breakpoint at the point where we've left the scope of the watchpoint
4412 if (innermost_block
)
4416 struct breakpoint
*scope_breakpoint
;
4417 struct symtab_and_line scope_sal
;
4419 INIT_SAL (&scope_sal
); /* initialize to zeroes */
4420 scope_sal
.pc
= get_frame_pc (prev_frame
);
4421 scope_sal
.section
= find_pc_overlay (scope_sal
.pc
);
4423 scope_breakpoint
= set_raw_breakpoint (scope_sal
);
4424 set_breakpoint_count (breakpoint_count
+ 1);
4425 scope_breakpoint
->number
= breakpoint_count
;
4427 scope_breakpoint
->type
= bp_watchpoint_scope
;
4428 scope_breakpoint
->enable
= enabled
;
4430 /* Automatically delete the breakpoint when it hits. */
4431 scope_breakpoint
->disposition
= del
;
4433 /* Only break in the proper frame (help with recursion). */
4434 scope_breakpoint
->frame
= prev_frame
->frame
;
4436 /* Set the address at which we will stop. */
4437 scope_breakpoint
->address
= get_frame_pc (prev_frame
);
4439 /* The scope breakpoint is related to the watchpoint. We
4440 will need to act on them together. */
4441 b
->related_breakpoint
= scope_breakpoint
;
4444 value_free_to_mark (mark
);
4448 /* Return count of locations need to be watched and can be handled
4449 in hardware. If the watchpoint can not be handled
4450 in hardware return zero. */
4452 #if !defined(TARGET_REGION_SIZE_OK_FOR_HW_WATCHPOINT)
4453 #define TARGET_REGION_SIZE_OK_FOR_HW_WATCHPOINT(byte_size) \
4454 ((byte_size) <= (REGISTER_SIZE))
4458 can_use_hardware_watchpoint (v
)
4461 int found_memory_cnt
= 0;
4463 /* Did the user specifically forbid us to use hardware watchpoints? */
4464 if (! can_use_hw_watchpoints
)
4467 /* Make sure all the intermediate values are in memory. Also make sure
4468 we found at least one memory expression. Guards against watch 0x12345,
4469 which is meaningless, but could cause errors if one tries to insert a
4470 hardware watchpoint for the constant expression. */
4471 for ( ; v
; v
= v
->next
)
4473 if (v
->lval
== lval_memory
)
4475 if (TARGET_REGION_SIZE_OK_FOR_HW_WATCHPOINT (TYPE_LENGTH (VALUE_TYPE (v
))))
4478 else if (v
->lval
!= not_lval
&& v
->modifiable
== 0)
4482 /* The expression itself looks suitable for using a hardware
4483 watchpoint, but give the target machine a chance to reject it. */
4484 return found_memory_cnt
;
4487 static void watch_command (arg
, from_tty
)
4491 watch_command_1 (arg
, 0, from_tty
);
4494 static void rwatch_command (arg
, from_tty
)
4498 watch_command_1 (arg
, 1, from_tty
);
4501 static void awatch_command (arg
, from_tty
)
4505 watch_command_1 (arg
, 2, from_tty
);
4509 /* Helper routines for the until_command routine in infcmd.c. Here
4510 because it uses the mechanisms of breakpoints. */
4512 /* This function is called by fetch_inferior_event via the
4513 cmd_continuation pointer, to complete the until command. It takes
4514 care of cleaning up the temporary breakpoints set up by the until
4517 until_break_command_continuation (arg
)
4518 struct continuation_arg
*arg
;
4520 /* Do all the exec cleanups, which at this point should only be the
4521 one set up in the first part of the until_break_command
4523 do_exec_cleanups (ALL_CLEANUPS
);
4528 until_break_command (arg
, from_tty
)
4532 struct symtabs_and_lines sals
;
4533 struct symtab_and_line sal
;
4534 struct frame_info
*prev_frame
= get_prev_frame (selected_frame
);
4535 struct breakpoint
*breakpoint
;
4536 struct cleanup
*old_chain
;
4537 struct continuation_arg
*arg1
, *arg2
;
4539 clear_proceed_status ();
4541 /* Set a breakpoint where the user wants it and at return from
4544 if (default_breakpoint_valid
)
4545 sals
= decode_line_1 (&arg
, 1, default_breakpoint_symtab
,
4546 default_breakpoint_line
, (char ***)NULL
);
4548 sals
= decode_line_1 (&arg
, 1, (struct symtab
*)NULL
, 0, (char ***)NULL
);
4550 if (sals
.nelts
!= 1)
4551 error ("Couldn't get information on specified line.");
4554 free ((PTR
)sals
.sals
); /* malloc'd, so freed */
4557 error ("Junk at end of arguments.");
4559 resolve_sal_pc (&sal
);
4561 breakpoint
= set_momentary_breakpoint (sal
, selected_frame
, bp_until
);
4563 if (!async_p
|| !target_has_async
)
4564 old_chain
= make_cleanup ((make_cleanup_func
) delete_breakpoint
, breakpoint
);
4566 make_exec_cleanup ((make_cleanup_func
) delete_breakpoint
, breakpoint
);
4568 /* If we are running asynchronously, and the target supports async
4569 execution, we are not waiting for the target to stop, in the call
4570 tp proceed, below. This means that we cannot delete the
4571 brekpoints until the target has actually stopped. The only place
4572 where we get a chance to do that is in fetch_inferior_event, so
4573 we must set things up for that. */
4575 if (async_p
&& target_has_async
)
4577 /* In this case we don't need args for the continuation, because
4578 all it needs to do is do the cleanups in the
4579 exec_cleanup_chain, which will be only those inserted by this
4580 function. We can get away by using ALL_CLEANUPS. */
4581 add_continuation (until_break_command_continuation
, NULL
);
4584 /* Keep within the current frame */
4588 sal
= find_pc_line (prev_frame
->pc
, 0);
4589 sal
.pc
= prev_frame
->pc
;
4590 breakpoint
= set_momentary_breakpoint (sal
, prev_frame
, bp_until
);
4591 if (!async_p
|| !target_has_async
)
4592 make_cleanup ((make_cleanup_func
) delete_breakpoint
, breakpoint
);
4594 make_exec_cleanup ((make_cleanup_func
) delete_breakpoint
, breakpoint
);
4597 proceed (-1, TARGET_SIGNAL_DEFAULT
, 0);
4598 /* Do the cleanups now, anly if we are not running asynchronously,
4599 of if we are, but the target is still synchronous. */
4600 if (!async_p
|| !target_has_async
)
4601 do_cleanups(old_chain
);
4605 /* These aren't used; I don't konw what they were for. */
4606 /* Set a breakpoint at the catch clause for NAME. */
4608 catch_breakpoint (name
)
4614 disable_catch_breakpoint ()
4619 delete_catch_breakpoint ()
4624 enable_catch_breakpoint ()
4631 struct sal_chain
*next
;
4632 struct symtab_and_line sal
;
4636 /* Not really used -- invocation in handle_gnu_4_16_catch_command
4637 had been commented out in the v.4.16 sources, and stays
4638 disabled there now because "catch NAME" syntax isn't allowed.
4640 /* This isn't used; I don't know what it was for. */
4641 /* For each catch clause identified in ARGS, run FUNCTION
4642 with that clause as an argument. */
4643 static struct symtabs_and_lines
4644 map_catch_names (args
, function
)
4648 register char *p
= args
;
4650 struct symtabs_and_lines sals
;
4652 struct sal_chain
*sal_chain
= 0;
4656 error_no_arg ("one or more catch names");
4664 /* Don't swallow conditional part. */
4665 if (p1
[0] == 'i' && p1
[1] == 'f'
4666 && (p1
[2] == ' ' || p1
[2] == '\t'))
4672 while (isalnum (*p1
) || *p1
== '_' || *p1
== '$')
4676 if (*p1
&& *p1
!= ' ' && *p1
!= '\t')
4677 error ("Arguments must be catch names.");
4683 struct sal_chain
*next
= (struct sal_chain
*)
4684 alloca (sizeof (struct sal_chain
));
4685 next
->next
= sal_chain
;
4686 next
->sal
= get_catch_sal (p
);
4691 printf_unfiltered ("No catch clause for exception %s.\n", p
);
4696 while (*p
== ' ' || *p
== '\t') p
++;
4701 /* This shares a lot of code with `print_frame_label_vars' from stack.c. */
4703 static struct symtabs_and_lines
4704 get_catch_sals (this_level_only
)
4705 int this_level_only
;
4707 register struct blockvector
*bl
;
4708 register struct block
*block
;
4709 int index
, have_default
= 0;
4711 struct symtabs_and_lines sals
;
4712 struct sal_chain
*sal_chain
= 0;
4713 char *blocks_searched
;
4715 /* Not sure whether an error message is always the correct response,
4716 but it's better than a core dump. */
4717 if (selected_frame
== NULL
)
4718 error ("No selected frame.");
4719 block
= get_frame_block (selected_frame
);
4720 pc
= selected_frame
->pc
;
4726 error ("No symbol table info available.\n");
4728 bl
= blockvector_for_pc (BLOCK_END (block
) - 4, &index
);
4729 blocks_searched
= (char *) alloca (BLOCKVECTOR_NBLOCKS (bl
) * sizeof (char));
4730 memset (blocks_searched
, 0, BLOCKVECTOR_NBLOCKS (bl
) * sizeof (char));
4734 CORE_ADDR end
= BLOCK_END (block
) - 4;
4737 if (bl
!= blockvector_for_pc (end
, &index
))
4738 error ("blockvector blotch");
4739 if (BLOCKVECTOR_BLOCK (bl
, index
) != block
)
4740 error ("blockvector botch");
4741 last_index
= BLOCKVECTOR_NBLOCKS (bl
);
4744 /* Don't print out blocks that have gone by. */
4745 while (index
< last_index
4746 && BLOCK_END (BLOCKVECTOR_BLOCK (bl
, index
)) < pc
)
4749 while (index
< last_index
4750 && BLOCK_END (BLOCKVECTOR_BLOCK (bl
, index
)) < end
)
4752 if (blocks_searched
[index
] == 0)
4754 struct block
*b
= BLOCKVECTOR_BLOCK (bl
, index
);
4757 register struct symbol
*sym
;
4759 nsyms
= BLOCK_NSYMS (b
);
4761 for (i
= 0; i
< nsyms
; i
++)
4763 sym
= BLOCK_SYM (b
, i
);
4764 if (STREQ (SYMBOL_NAME (sym
), "default"))
4770 if (SYMBOL_CLASS (sym
) == LOC_LABEL
)
4772 struct sal_chain
*next
= (struct sal_chain
*)
4773 alloca (sizeof (struct sal_chain
));
4774 next
->next
= sal_chain
;
4775 next
->sal
= find_pc_line (SYMBOL_VALUE_ADDRESS (sym
), 0);
4779 blocks_searched
[index
] = 1;
4785 if (sal_chain
&& this_level_only
)
4788 /* After handling the function's top-level block, stop.
4789 Don't continue to its superblock, the block of
4790 per-file symbols. */
4791 if (BLOCK_FUNCTION (block
))
4793 block
= BLOCK_SUPERBLOCK (block
);
4798 struct sal_chain
*tmp_chain
;
4800 /* Count the number of entries. */
4801 for (index
= 0, tmp_chain
= sal_chain
; tmp_chain
;
4802 tmp_chain
= tmp_chain
->next
)
4806 sals
.sals
= (struct symtab_and_line
*)
4807 xmalloc (index
* sizeof (struct symtab_and_line
));
4808 for (index
= 0; sal_chain
; sal_chain
= sal_chain
->next
, index
++)
4809 sals
.sals
[index
] = sal_chain
->sal
;
4816 ep_skip_leading_whitespace (s
)
4819 if ((s
== NULL
) || (*s
== NULL
))
4821 while (isspace(**s
))
4825 /* This function examines a string, and attempts to find a token
4826 that might be an event name in the leading characters. If a
4827 possible match is found, a pointer to the last character of
4828 the token is returned. Else, NULL is returned. */
4830 ep_find_event_name_end (arg
)
4834 char * event_name_end
= NULL
;
4836 /* If we could depend upon the presense of strrpbrk, we'd use that... */
4840 /* We break out of the loop when we find a token delimiter.
4841 Basically, we're looking for alphanumerics and underscores;
4842 anything else delimites the token. */
4845 if (! isalnum(*s
) && (*s
!= '_'))
4851 return event_name_end
;
4855 /* This function attempts to parse an optional "if <cond>" clause
4856 from the arg string. If one is not found, it returns NULL.
4858 Else, it returns a pointer to the condition string. (It does not
4859 attempt to evaluate the string against a particular block.) And,
4860 it updates arg to point to the first character following the parsed
4861 if clause in the arg string. */
4863 ep_parse_optional_if_clause (arg
)
4868 if (((*arg
)[0] != 'i') || ((*arg
)[1] != 'f') || !isspace((*arg
)[2]))
4871 /* Skip the "if" keyword. */
4874 /* Skip any extra leading whitespace, and record the start of the
4875 condition string. */
4876 ep_skip_leading_whitespace (arg
);
4879 /* Assume that the condition occupies the remainder of the arg string. */
4880 (*arg
) += strlen (cond_string
);
4885 /* This function attempts to parse an optional filename from the arg
4886 string. If one is not found, it returns NULL.
4888 Else, it returns a pointer to the parsed filename. (This function
4889 makes no attempt to verify that a file of that name exists, or is
4890 accessible.) And, it updates arg to point to the first character
4891 following the parsed filename in the arg string.
4893 Note that clients needing to preserve the returned filename for
4894 future access should copy it to their own buffers. */
4896 ep_parse_optional_filename (arg
)
4899 static char filename
[1024];
4900 char * arg_p
= *arg
;
4904 if ((*arg_p
== '\0') || isspace (*arg_p
))
4922 /* Commands to deal with catching events, such as signals, exceptions,
4923 process start/exit, etc. */
4925 typedef enum {catch_fork
, catch_vfork
} catch_fork_kind
;
4927 static void catch_fork_command_1
PARAMS ((catch_fork_kind fork_kind
, char *arg
, int tempflag
, int from_tty
));
4930 catch_fork_command_1 (fork_kind
, arg
, tempflag
, from_tty
)
4931 catch_fork_kind fork_kind
;
4936 char * cond_string
= NULL
;
4938 ep_skip_leading_whitespace (&arg
);
4940 /* The allowed syntax is:
4942 catch [v]fork if <cond>
4944 First, check if there's an if clause. */
4945 cond_string
= ep_parse_optional_if_clause (&arg
);
4947 if ((*arg
!= '\0') && !isspace (*arg
))
4948 error ("Junk at end of arguments.");
4950 /* If this target supports it, create a fork or vfork catchpoint
4951 and enable reporting of such events. */
4952 switch (fork_kind
) {
4954 create_fork_event_catchpoint (tempflag
, cond_string
);
4957 create_vfork_event_catchpoint (tempflag
, cond_string
);
4960 error ("unsupported or unknown fork kind; cannot catch it");
4966 catch_exec_command_1 (arg
, tempflag
, from_tty
)
4971 char * cond_string
= NULL
;
4973 ep_skip_leading_whitespace (&arg
);
4975 /* The allowed syntax is:
4977 catch exec if <cond>
4979 First, check if there's an if clause. */
4980 cond_string
= ep_parse_optional_if_clause (&arg
);
4982 if ((*arg
!= '\0') && !isspace (*arg
))
4983 error ("Junk at end of arguments.");
4985 /* If this target supports it, create an exec catchpoint
4986 and enable reporting of such events. */
4987 create_exec_event_catchpoint (tempflag
, cond_string
);
4990 #if defined(SOLIB_ADD)
4992 catch_load_command_1 (arg
, tempflag
, from_tty
)
4997 char * dll_pathname
= NULL
;
4998 char * cond_string
= NULL
;
5000 ep_skip_leading_whitespace (&arg
);
5002 /* The allowed syntax is:
5004 catch load if <cond>
5005 catch load <filename>
5006 catch load <filename> if <cond>
5008 The user is not allowed to specify the <filename> after an
5011 We'll ignore the pathological case of a file named "if".
5013 First, check if there's an if clause. If so, then there
5014 cannot be a filename. */
5015 cond_string
= ep_parse_optional_if_clause (&arg
);
5017 /* If there was an if clause, then there cannot be a filename.
5018 Else, there might be a filename and an if clause. */
5019 if (cond_string
== NULL
)
5021 dll_pathname
= ep_parse_optional_filename (&arg
);
5022 ep_skip_leading_whitespace (&arg
);
5023 cond_string
= ep_parse_optional_if_clause (&arg
);
5026 if ((*arg
!= '\0') && !isspace (*arg
))
5027 error ("Junk at end of arguments.");
5029 /* Create a load breakpoint that only triggers when a load of
5030 the specified dll (or any dll, if no pathname was specified)
5032 SOLIB_CREATE_CATCH_LOAD_HOOK (inferior_pid
, tempflag
, dll_pathname
, cond_string
);
5036 catch_unload_command_1 (arg
, tempflag
, from_tty
)
5041 char * dll_pathname
= NULL
;
5042 char * cond_string
= NULL
;
5044 ep_skip_leading_whitespace (&arg
);
5046 /* The allowed syntax is:
5048 catch unload if <cond>
5049 catch unload <filename>
5050 catch unload <filename> if <cond>
5052 The user is not allowed to specify the <filename> after an
5055 We'll ignore the pathological case of a file named "if".
5057 First, check if there's an if clause. If so, then there
5058 cannot be a filename. */
5059 cond_string
= ep_parse_optional_if_clause (&arg
);
5061 /* If there was an if clause, then there cannot be a filename.
5062 Else, there might be a filename and an if clause. */
5063 if (cond_string
== NULL
)
5065 dll_pathname
= ep_parse_optional_filename (&arg
);
5066 ep_skip_leading_whitespace (&arg
);
5067 cond_string
= ep_parse_optional_if_clause (&arg
);
5070 if ((*arg
!= '\0') && !isspace (*arg
))
5071 error ("Junk at end of arguments.");
5073 /* Create an unload breakpoint that only triggers when an unload of
5074 the specified dll (or any dll, if no pathname was specified)
5076 SOLIB_CREATE_CATCH_UNLOAD_HOOK (inferior_pid
, tempflag
, dll_pathname
, cond_string
);
5078 #endif /* SOLIB_ADD */
5080 /* Commands to deal with catching exceptions. */
5082 /* Set a breakpoint at the specified callback routine for an
5083 exception event callback */
5086 create_exception_catchpoint (tempflag
, cond_string
, ex_event
, sal
)
5089 enum exception_event_kind ex_event
;
5090 struct symtab_and_line
*sal
;
5092 struct breakpoint
* b
;
5094 int thread
= -1; /* All threads. */
5096 if (!sal
) /* no exception support? */
5099 b
= set_raw_breakpoint (*sal
);
5100 set_breakpoint_count (breakpoint_count
+ 1);
5101 b
->number
= breakpoint_count
;
5103 b
->cond_string
= (cond_string
== NULL
) ? NULL
: savestring (cond_string
, strlen (cond_string
));
5105 b
->addr_string
= NULL
;
5106 b
->enable
= enabled
;
5107 b
->disposition
= tempflag
? del
: donttouch
;
5110 case EX_EVENT_THROW
:
5111 b
->type
= bp_catch_throw
;
5113 case EX_EVENT_CATCH
:
5114 b
->type
= bp_catch_catch
;
5116 default: /* error condition */
5118 b
->enable
= disabled
;
5119 error ("Internal error -- invalid catchpoint kind");
5124 /* Deal with "catch catch" and "catch throw" commands */
5127 catch_exception_command_1 (ex_event
, arg
, tempflag
, from_tty
)
5128 enum exception_event_kind ex_event
;
5133 char * cond_string
= NULL
;
5134 struct symtab_and_line
* sal
= NULL
;
5136 ep_skip_leading_whitespace (&arg
);
5138 cond_string
= ep_parse_optional_if_clause (&arg
);
5140 if ((*arg
!= '\0') && !isspace (*arg
))
5141 error ("Junk at end of arguments.");
5143 if ((ex_event
!= EX_EVENT_THROW
) &&
5144 (ex_event
!= EX_EVENT_CATCH
))
5145 error ("Unsupported or unknown exception event; cannot catch it");
5147 /* See if we can find a callback routine */
5148 sal
= target_enable_exception_callback (ex_event
, 1);
5152 /* We have callbacks from the runtime system for exceptions.
5153 Set a breakpoint on the sal found, if no errors */
5154 if (sal
!= (struct symtab_and_line
*) -1)
5155 create_exception_catchpoint (tempflag
, cond_string
, ex_event
, sal
);
5157 return; /* something went wrong with setting up callbacks */
5161 /* No callbacks from runtime system for exceptions.
5162 Try GNU C++ exception breakpoints using labels in debug info. */
5163 if (ex_event
== EX_EVENT_CATCH
)
5165 handle_gnu_4_16_catch_command (arg
, tempflag
, from_tty
);
5167 else if (ex_event
== EX_EVENT_THROW
)
5169 /* Set a breakpoint on __raise_exception () */
5171 fprintf_filtered (gdb_stderr
, "Unsupported with this platform/compiler combination.\n");
5172 fprintf_filtered (gdb_stderr
, "Perhaps you can achieve the effect you want by setting\n");
5173 fprintf_filtered (gdb_stderr
, "a breakpoint on __raise_exception().\n");
5178 /* Cover routine to allow wrapping target_enable_exception_catchpoints
5179 inside a catch_errors */
5182 cover_target_enable_exception_callback (arg
)
5185 args_for_catchpoint_enable
*args
= arg
;
5186 struct symtab_and_line
*sal
;
5187 sal
= target_enable_exception_callback (args
->kind
, args
->enable
);
5190 else if (sal
== (struct symtab_and_line
*) -1)
5193 return 1; /*is valid*/
5198 /* This is the original v.4.16 and earlier version of the
5199 catch_command_1() function. Now that other flavours of "catch"
5200 have been introduced, and since exception handling can be handled
5201 in other ways (through target ops) also, this is used only for the
5202 GNU C++ exception handling system.
5203 Note: Only the "catch" flavour of GDB 4.16 is handled here. The
5204 "catch NAME" is now no longer allowed in catch_command_1(). Also,
5205 there was no code in GDB 4.16 for "catch throw".
5207 Called from catch_exception_command_1 () */
5211 handle_gnu_4_16_catch_command (arg
, tempflag
, from_tty
)
5216 /* First, translate ARG into something we can deal with in terms
5219 struct symtabs_and_lines sals
;
5220 struct symtab_and_line sal
;
5221 register struct expression
*cond
= 0;
5222 register struct breakpoint
*b
;
5226 INIT_SAL (&sal
); /* initialize to zeroes */
5228 /* If no arg given, or if first arg is 'if ', all active catch clauses
5229 are breakpointed. */
5231 if (!arg
|| (arg
[0] == 'i' && arg
[1] == 'f'
5232 && (arg
[2] == ' ' || arg
[2] == '\t')))
5234 /* Grab all active catch clauses. */
5235 sals
= get_catch_sals (0);
5239 /* Grab selected catch clauses. */
5240 error ("catch NAME not implemented");
5243 /* Not sure why this code has been disabled. I'm leaving
5244 it disabled. We can never come here now anyway
5245 since we don't allow the "catch NAME" syntax.
5248 /* This isn't used; I don't know what it was for. */
5249 sals
= map_catch_names (arg
, catch_breakpoint
);
5257 for (i
= 0; i
< sals
.nelts
; i
++)
5259 resolve_sal_pc (&sals
.sals
[i
]);
5263 if (arg
[0] == 'i' && arg
[1] == 'f'
5264 && (arg
[2] == ' ' || arg
[2] == '\t'))
5265 cond
= parse_exp_1 ((arg
+= 2, &arg
),
5266 block_for_pc (sals
.sals
[i
].pc
), 0);
5268 error ("Junk at end of arguments.");
5273 for (i
= 0; i
< sals
.nelts
; i
++)
5278 describe_other_breakpoints (sal
.pc
, sal
.section
);
5280 b
= set_raw_breakpoint (sal
);
5281 set_breakpoint_count (breakpoint_count
+ 1);
5282 b
->number
= breakpoint_count
;
5283 b
->type
= bp_breakpoint
; /* Important -- this is an ordinary breakpoint.
5284 For platforms with callback support for exceptions,
5285 create_exception_catchpoint() will create special
5286 bp types (bp_catch_catch and bp_catch_throw), and
5287 there is code in insert_breakpoints() and elsewhere
5288 that depends on that. */
5291 b
->enable
= enabled
;
5292 b
->disposition
= tempflag
? del
: donttouch
;
5299 printf_unfiltered ("Multiple breakpoints were set.\n");
5300 printf_unfiltered ("Use the \"delete\" command to delete unwanted breakpoints.\n");
5302 free ((PTR
)sals
.sals
);
5306 /* This creates a temporary internal breakpoint
5307 just to placate infrun */
5308 static struct breakpoint
*
5309 create_temp_exception_breakpoint (pc
)
5312 struct symtab_and_line sal
;
5313 struct breakpoint
*b
;
5320 b
= set_raw_breakpoint (sal
);
5322 error ("Internal error -- couldn't set temp exception breakpoint");
5324 b
->type
= bp_breakpoint
;
5325 b
->disposition
= del
;
5326 b
->enable
= enabled
;
5328 b
->number
= internal_breakpoint_number
--;
5334 catch_command_1 (arg
, tempflag
, from_tty
)
5340 /* The first argument may be an event name, such as "start" or "load".
5341 If so, then handle it as such. If it doesn't match an event name,
5342 then attempt to interpret it as an exception name. (This latter is
5343 the v4.16-and-earlier GDB meaning of the "catch" command.)
5345 First, try to find the bounds of what might be an event name. */
5346 char * arg1_start
= arg
;
5350 if (arg1_start
== NULL
)
5352 /* Old behaviour was to use pre-v-4.16 syntax */
5353 /* catch_throw_command_1 (arg1_start, tempflag, from_tty); */
5355 /* Now, this is not allowed */
5356 error ("Catch requires an event name.");
5359 arg1_end
= ep_find_event_name_end (arg1_start
);
5360 if (arg1_end
== NULL
)
5361 error ("catch requires an event");
5362 arg1_length
= arg1_end
+ 1 - arg1_start
;
5364 /* Try to match what we found against known event names. */
5365 if (strncmp (arg1_start
, "signal", arg1_length
) == 0)
5367 error ("Catch of signal not yet implemented");
5369 else if (strncmp (arg1_start
, "catch", arg1_length
) == 0)
5371 catch_exception_command_1 (EX_EVENT_CATCH
, arg1_end
+1, tempflag
, from_tty
);
5373 else if (strncmp (arg1_start
, "throw", arg1_length
) == 0)
5375 catch_exception_command_1 (EX_EVENT_THROW
, arg1_end
+1, tempflag
, from_tty
);
5377 else if (strncmp (arg1_start
, "thread_start", arg1_length
) == 0)
5379 error ("Catch of thread_start not yet implemented");
5381 else if (strncmp (arg1_start
, "thread_exit", arg1_length
) == 0)
5383 error ("Catch of thread_exit not yet implemented");
5385 else if (strncmp (arg1_start
, "thread_join", arg1_length
) == 0)
5387 error ("Catch of thread_join not yet implemented");
5389 else if (strncmp (arg1_start
, "start", arg1_length
) == 0)
5391 error ("Catch of start not yet implemented");
5393 else if (strncmp (arg1_start
, "exit", arg1_length
) == 0)
5395 error ("Catch of exit not yet implemented");
5397 else if (strncmp (arg1_start
, "fork", arg1_length
) == 0)
5399 #if defined(CHILD_INSERT_FORK_CATCHPOINT)
5400 catch_fork_command_1 (catch_fork
, arg1_end
+1, tempflag
, from_tty
);
5402 error ("Catch of fork not yet implemented");
5405 else if (strncmp (arg1_start
, "vfork", arg1_length
) == 0)
5407 #if defined(CHILD_INSERT_VFORK_CATCHPOINT)
5408 catch_fork_command_1 (catch_vfork
, arg1_end
+1, tempflag
, from_tty
);
5410 error ("Catch of vfork not yet implemented");
5413 else if (strncmp (arg1_start
, "exec", arg1_length
) == 0)
5415 #if defined(CHILD_INSERT_EXEC_CATCHPOINT)
5416 catch_exec_command_1 (arg1_end
+1, tempflag
, from_tty
);
5418 error ("Catch of exec not yet implemented");
5421 else if (strncmp (arg1_start
, "load", arg1_length
) == 0)
5423 #if defined(SOLIB_ADD)
5424 catch_load_command_1 (arg1_end
+1, tempflag
, from_tty
);
5426 error ("Catch of load not implemented");
5429 else if (strncmp (arg1_start
, "unload", arg1_length
) == 0)
5431 #if defined(SOLIB_ADD)
5432 catch_unload_command_1 (arg1_end
+1, tempflag
, from_tty
);
5434 error ("Catch of load not implemented");
5437 else if (strncmp (arg1_start
, "stop", arg1_length
) == 0)
5439 error ("Catch of stop not yet implemented");
5442 /* This doesn't appear to be an event name */
5446 /* Pre-v.4.16 behaviour was to treat the argument
5447 as the name of an exception */
5448 /* catch_throw_command_1 (arg1_start, tempflag, from_tty); */
5449 /* Now this is not allowed */
5450 error ("Unknown event kind specified for catch");
5455 /* Used by the gui, could be made a worker for other things. */
5458 set_breakpoint_sal (sal
)
5459 struct symtab_and_line sal
;
5461 struct breakpoint
*b
;
5462 b
= set_raw_breakpoint (sal
);
5463 set_breakpoint_count (breakpoint_count
+ 1);
5464 b
->number
= breakpoint_count
;
5465 b
->type
= bp_breakpoint
;
5472 /* These aren't used; I don't know what they were for. */
5473 /* Disable breakpoints on all catch clauses described in ARGS. */
5475 disable_catch (args
)
5478 /* Map the disable command to catch clauses described in ARGS. */
5481 /* Enable breakpoints on all catch clauses described in ARGS. */
5486 /* Map the disable command to catch clauses described in ARGS. */
5489 /* Delete breakpoints on all catch clauses in the active scope. */
5494 /* Map the delete command to catch clauses described in ARGS. */
5499 catch_command (arg
, from_tty
)
5503 catch_command_1 (arg
, 0, from_tty
);
5508 tcatch_command (arg
, from_tty
)
5512 catch_command_1 (arg
, 1, from_tty
);
5517 clear_command (arg
, from_tty
)
5521 register struct breakpoint
*b
, *b1
;
5523 struct symtabs_and_lines sals
;
5524 struct symtab_and_line sal
;
5525 register struct breakpoint
*found
;
5530 sals
= decode_line_spec (arg
, 1);
5535 sals
.sals
= (struct symtab_and_line
*)
5536 xmalloc (sizeof (struct symtab_and_line
));
5537 INIT_SAL (&sal
); /* initialize to zeroes */
5538 sal
.line
= default_breakpoint_line
;
5539 sal
.symtab
= default_breakpoint_symtab
;
5540 sal
.pc
= default_breakpoint_address
;
5541 if (sal
.symtab
== 0)
5542 error ("No source file specified.");
5550 /* For each line spec given, delete bps which correspond
5551 to it. We do this in two loops: the first loop looks at
5552 the initial bp(s) in the chain which should be deleted,
5553 the second goes down the rest of the chain looking ahead
5554 one so it can take those bps off the chain without messing
5558 for (i
= 0; i
< sals
.nelts
; i
++)
5560 /* If exact pc given, clear bpts at that pc.
5561 If line given (pc == 0), clear all bpts on specified line.
5562 If defaulting, clear all bpts on default line
5565 defaulting sal.pc != 0 tests to do
5570 1 0 <can't happen> */
5573 found
= (struct breakpoint
*) 0;
5576 while (breakpoint_chain
5577 /* Why don't we check here that this is not
5578 a watchpoint, etc., as we do below?
5579 I can't make it fail, but don't know
5580 what's stopping the failure: a watchpoint
5581 of the same address as "sal.pc" should
5582 wind up being deleted. */
5584 && ( ((sal
.pc
&& (breakpoint_chain
->address
== sal
.pc
)) &&
5585 (overlay_debugging
== 0 ||
5586 breakpoint_chain
->section
== sal
.section
))
5587 || ((default_match
|| (0 == sal
.pc
))
5588 && breakpoint_chain
->source_file
!= NULL
5589 && sal
.symtab
!= NULL
5590 && STREQ (breakpoint_chain
->source_file
, sal
.symtab
->filename
)
5591 && breakpoint_chain
->line_number
== sal
.line
)))
5594 b1
= breakpoint_chain
;
5595 breakpoint_chain
= b1
->next
;
5603 && b
->next
->type
!= bp_none
5604 && b
->next
->type
!= bp_watchpoint
5605 && b
->next
->type
!= bp_hardware_watchpoint
5606 && b
->next
->type
!= bp_read_watchpoint
5607 && b
->next
->type
!= bp_access_watchpoint
5608 && ( ((sal
.pc
&& (b
->next
->address
== sal
.pc
)) &&
5609 (overlay_debugging
== 0 ||
5610 b
->next
->section
== sal
.section
))
5611 || ((default_match
|| (0 == sal
.pc
))
5612 && b
->next
->source_file
!= NULL
5613 && sal
.symtab
!= NULL
5614 && STREQ (b
->next
->source_file
, sal
.symtab
->filename
)
5615 && b
->next
->line_number
== sal
.line
)))
5628 error ("No breakpoint at %s.", arg
);
5630 error ("No breakpoint at this line.");
5633 if (found
->next
) from_tty
= 1; /* Always report if deleted more than one */
5634 if (from_tty
) printf_unfiltered ("Deleted breakpoint%s ", found
->next
? "s" : "");
5635 breakpoints_changed ();
5638 if (from_tty
) printf_unfiltered ("%d ", found
->number
);
5640 delete_breakpoint (found
);
5643 if (from_tty
) putchar_unfiltered ('\n');
5645 free ((PTR
)sals
.sals
);
5648 /* Delete breakpoint in BS if they are `delete' breakpoints and
5649 all breakpoints that are marked for deletion, whether hit or not.
5650 This is called after any breakpoint is hit, or after errors. */
5653 breakpoint_auto_delete (bs
)
5656 struct breakpoint
*b
, *temp
;
5658 for (; bs
; bs
= bs
->next
)
5659 if (bs
->breakpoint_at
&& bs
->breakpoint_at
->disposition
== del
5661 delete_breakpoint (bs
->breakpoint_at
);
5663 ALL_BREAKPOINTS_SAFE (b
, temp
)
5665 if (b
->disposition
== del_at_next_stop
)
5666 delete_breakpoint (b
);
5670 /* Delete a breakpoint and clean up all traces of it in the data structures. */
5673 delete_breakpoint (bpt
)
5674 struct breakpoint
*bpt
;
5676 register struct breakpoint
*b
;
5680 error ("Internal error (attempted to delete a NULL breakpoint)");
5683 /* Has this bp already been deleted? This can happen because multiple
5684 lists can hold pointers to bp's. bpstat lists are especial culprits.
5686 One example of this happening is a watchpoint's scope bp. When the
5687 scope bp triggers, we notice that the watchpoint is out of scope, and
5688 delete it. We also delete its scope bp. But the scope bp is marked
5689 "auto-deleting", and is already on a bpstat. That bpstat is then
5690 checked for auto-deleting bp's, which are deleted.
5692 A real solution to this problem might involve reference counts in bp's,
5693 and/or giving them pointers back to their referencing bpstat's, and
5694 teaching delete_breakpoint to only free a bp's storage when no more
5695 references were extent. A cheaper bandaid was chosen. */
5696 if (bpt
->type
== bp_none
)
5699 if (delete_breakpoint_hook
)
5700 delete_breakpoint_hook (bpt
);
5703 remove_breakpoint (bpt
, mark_uninserted
);
5705 if (breakpoint_chain
== bpt
)
5706 breakpoint_chain
= bpt
->next
;
5708 /* If we have callback-style exception catchpoints, don't go through
5709 the adjustments to the C++ runtime library etc. if the inferior
5710 isn't actually running. target_enable_exception_callback for a
5711 null target ops vector gives an undesirable error message, so we
5712 check here and avoid it. Since currently (1997-09-17) only HP-UX aCC's
5713 exceptions are supported in this way, it's OK for now. FIXME */
5714 if (ep_is_exception_catchpoint (bpt
) && target_has_execution
)
5716 static char message1
[] = "Error in deleting catchpoint %d:\n";
5717 static char message
[sizeof (message1
) + 30];
5718 args_for_catchpoint_enable args
;
5720 sprintf (message
, message1
, bpt
->number
); /* Format possible error msg */
5721 args
.kind
= bpt
->type
== bp_catch_catch
? EX_EVENT_CATCH
: EX_EVENT_THROW
;
5723 catch_errors (cover_target_enable_exception_callback
, &args
,
5724 message
, RETURN_MASK_ALL
);
5731 b
->next
= bpt
->next
;
5735 /* Before turning off the visuals for the bp, check to see that
5736 there are no other bps at the same address. */
5743 clearIt
= (b
->address
!= bpt
->address
);
5750 TUIDO(((TuiOpaqueFuncPtr
)tui_vAllSetHasBreakAt
, bpt
, 0));
5751 TUIDO(((TuiOpaqueFuncPtr
)tuiUpdateAllExecInfos
));
5755 check_duplicates (bpt
->address
, bpt
->section
);
5756 /* If this breakpoint was inserted, and there is another breakpoint
5757 at the same address, we need to insert the other breakpoint. */
5759 && bpt
->type
!= bp_hardware_watchpoint
5760 && bpt
->type
!= bp_read_watchpoint
5761 && bpt
->type
!= bp_access_watchpoint
5762 && bpt
->type
!= bp_catch_fork
5763 && bpt
->type
!= bp_catch_vfork
5764 && bpt
->type
!= bp_catch_exec
)
5767 if (b
->address
== bpt
->address
5768 && b
->section
== bpt
->section
5770 && b
->enable
!= disabled
5771 && b
->enable
!= shlib_disabled
5772 && b
->enable
!= call_disabled
)
5775 val
= target_insert_breakpoint (b
->address
, b
->shadow_contents
);
5778 target_terminal_ours_for_output ();
5779 fprintf_unfiltered (gdb_stderr
, "Cannot insert breakpoint %d:\n", b
->number
);
5780 memory_error (val
, b
->address
); /* which bombs us out */
5787 free_command_lines (&bpt
->commands
);
5790 if (bpt
->cond_string
!= NULL
)
5791 free (bpt
->cond_string
);
5792 if (bpt
->addr_string
!= NULL
)
5793 free (bpt
->addr_string
);
5794 if (bpt
->exp
!= NULL
)
5796 if (bpt
->exp_string
!= NULL
)
5797 free (bpt
->exp_string
);
5798 if (bpt
->val
!= NULL
)
5799 value_free (bpt
->val
);
5800 if (bpt
->source_file
!= NULL
)
5801 free (bpt
->source_file
);
5802 if (bpt
->dll_pathname
!= NULL
)
5803 free (bpt
->dll_pathname
);
5804 if (bpt
->triggered_dll_pathname
!= NULL
)
5805 free (bpt
->triggered_dll_pathname
);
5806 if (bpt
->exec_pathname
!= NULL
)
5807 free (bpt
->exec_pathname
);
5809 /* Be sure no bpstat's are pointing at it after it's been freed. */
5810 /* FIXME, how can we find all bpstat's?
5811 We just check stop_bpstat for now. */
5812 for (bs
= stop_bpstat
; bs
; bs
= bs
->next
)
5813 if (bs
->breakpoint_at
== bpt
)
5815 bs
->breakpoint_at
= NULL
;
5817 /* we'd call bpstat_clear_actions, but that free's stuff and due
5818 to the multiple pointers pointing to one item with no
5819 reference counts found anywhere through out the bpstat's (how
5820 do you spell fragile?), we don't want to free things twice --
5821 better a memory leak than a corrupt malloc pool! */
5822 bs
->commands
= NULL
;
5825 /* On the chance that someone will soon try again to delete this same
5826 bp, we mark it as deleted before freeing its storage. */
5827 bpt
->type
= bp_none
;
5833 delete_command (arg
, from_tty
)
5837 struct breakpoint
*b
, *temp
;
5841 int breaks_to_delete
= 0;
5843 /* Delete all breakpoints if no argument.
5844 Do not delete internal or call-dummy breakpoints, these
5845 have to be deleted with an explicit breakpoint number argument. */
5848 if (b
->type
!= bp_call_dummy
&&
5849 b
->type
!= bp_shlib_event
&&
5851 breaks_to_delete
= 1;
5854 /* Ask user only if there are some breakpoints to delete. */
5856 || (breaks_to_delete
&& query ("Delete all breakpoints? ")))
5858 ALL_BREAKPOINTS_SAFE (b
, temp
)
5860 if (b
->type
!= bp_call_dummy
&&
5861 b
->type
!= bp_shlib_event
&&
5863 delete_breakpoint (b
);
5868 map_breakpoint_numbers (arg
, delete_breakpoint
);
5871 /* Reset a breakpoint given it's struct breakpoint * BINT.
5872 The value we return ends up being the return value from catch_errors.
5873 Unused in this case. */
5876 breakpoint_re_set_one (bint
)
5879 struct breakpoint
*b
= (struct breakpoint
*)bint
; /* get past catch_errs */
5882 struct symtabs_and_lines sals
;
5884 enum enable save_enable
;
5889 warning ("attempted to reset apparently deleted breakpoint #%d?\n", b
->number
);
5892 case bp_hardware_breakpoint
:
5894 case bp_catch_unload
:
5895 if (b
->addr_string
== NULL
)
5897 /* Anything without a string can't be re-set. */
5898 delete_breakpoint (b
);
5901 /* In case we have a problem, disable this breakpoint. We'll restore
5902 its status if we succeed. */
5903 save_enable
= b
->enable
;
5904 b
->enable
= disabled
;
5906 set_language (b
->language
);
5907 input_radix
= b
->input_radix
;
5909 sals
= decode_line_1 (&s
, 1, (struct symtab
*)NULL
, 0, (char ***)NULL
);
5910 for (i
= 0; i
< sals
.nelts
; i
++)
5912 resolve_sal_pc (&sals
.sals
[i
]);
5914 /* Reparse conditions, they might contain references to the
5916 if (b
->cond_string
!= NULL
)
5920 free ((PTR
)b
->cond
);
5921 b
->cond
= parse_exp_1 (&s
, block_for_pc (sals
.sals
[i
].pc
), 0);
5924 /* We need to re-set the breakpoint if the address changes...*/
5925 if (b
->address
!= sals
.sals
[i
].pc
5926 /* ...or new and old breakpoints both have source files, and
5927 the source file name or the line number changes... */
5928 || (b
->source_file
!= NULL
5929 && sals
.sals
[i
].symtab
!= NULL
5930 && (!STREQ (b
->source_file
, sals
.sals
[i
].symtab
->filename
)
5931 || b
->line_number
!= sals
.sals
[i
].line
)
5933 /* ...or we switch between having a source file and not having
5935 || ((b
->source_file
== NULL
) != (sals
.sals
[i
].symtab
== NULL
))
5938 if (b
->source_file
!= NULL
)
5939 free (b
->source_file
);
5940 if (sals
.sals
[i
].symtab
== NULL
)
5941 b
->source_file
= NULL
;
5944 savestring (sals
.sals
[i
].symtab
->filename
,
5945 strlen (sals
.sals
[i
].symtab
->filename
));
5946 b
->line_number
= sals
.sals
[i
].line
;
5947 b
->address
= sals
.sals
[i
].pc
;
5949 /* Used to check for duplicates here, but that can
5950 cause trouble, as it doesn't check for disable
5955 /* Might be better to do this just once per breakpoint_re_set,
5956 rather than once for every breakpoint. */
5957 breakpoints_changed ();
5959 b
->section
= sals
.sals
[i
].section
;
5960 b
->enable
= save_enable
; /* Restore it, this worked. */
5963 /* Now that this is re-enabled, check_duplicates
5965 check_duplicates (b
->address
, b
->section
);
5968 free ((PTR
)sals
.sals
);
5972 case bp_hardware_watchpoint
:
5973 case bp_read_watchpoint
:
5974 case bp_access_watchpoint
:
5975 innermost_block
= NULL
;
5976 /* The issue arises of what context to evaluate this in. The same
5977 one as when it was set, but what does that mean when symbols have
5978 been re-read? We could save the filename and functionname, but
5979 if the context is more local than that, the best we could do would
5980 be something like how many levels deep and which index at that
5981 particular level, but that's going to be less stable than filenames
5982 or functionnames. */
5983 /* So for now, just use a global context. */
5986 b
->exp
= parse_expression (b
->exp_string
);
5987 b
->exp_valid_block
= innermost_block
;
5988 mark
= value_mark ();
5990 value_free (b
->val
);
5991 b
->val
= evaluate_expression (b
->exp
);
5992 release_value (b
->val
);
5993 if (VALUE_LAZY (b
->val
))
5994 value_fetch_lazy (b
->val
);
5996 if (b
->cond_string
!= NULL
)
6000 free ((PTR
)b
->cond
);
6001 b
->cond
= parse_exp_1 (&s
, (struct block
*)0, 0);
6003 if (b
->enable
== enabled
)
6005 value_free_to_mark (mark
);
6007 case bp_catch_catch
:
6008 case bp_catch_throw
:
6010 /* We needn't really do anything to reset these, since the mask
6011 that requests them is unaffected by e.g., new libraries being
6014 case bp_catch_vfork
:
6019 printf_filtered ("Deleting unknown breakpoint type %d\n", b
->type
);
6021 /* Delete longjmp breakpoints, they will be reset later by
6022 breakpoint_re_set. */
6024 case bp_longjmp_resume
:
6025 delete_breakpoint (b
);
6028 /* This breakpoint is special, it's set up when the inferior
6029 starts and we really don't want to touch it. */
6030 case bp_shlib_event
:
6032 /* Keep temporary breakpoints, which can be encountered when we step
6033 over a dlopen call and SOLIB_ADD is resetting the breakpoints.
6034 Otherwise these should have been blown away via the cleanup chain
6035 or by breakpoint_init_inferior when we rerun the executable. */
6038 case bp_watchpoint_scope
:
6040 case bp_step_resume
:
6047 /* Re-set all breakpoints after symbols have been re-loaded. */
6049 breakpoint_re_set ()
6051 struct breakpoint
*b
, *temp
;
6052 enum language save_language
;
6053 int save_input_radix
;
6054 static char message1
[] = "Error in re-setting breakpoint %d:\n";
6055 char message
[sizeof (message1
) + 30 /* slop */];
6057 save_language
= current_language
->la_language
;
6058 save_input_radix
= input_radix
;
6059 ALL_BREAKPOINTS_SAFE (b
, temp
)
6061 sprintf (message
, message1
, b
->number
); /* Format possible error msg */
6062 catch_errors (breakpoint_re_set_one
, b
, message
, RETURN_MASK_ALL
);
6064 set_language (save_language
);
6065 input_radix
= save_input_radix
;
6067 #ifdef GET_LONGJMP_TARGET
6068 create_longjmp_breakpoint ("longjmp");
6069 create_longjmp_breakpoint ("_longjmp");
6070 create_longjmp_breakpoint ("siglongjmp");
6071 create_longjmp_breakpoint ("_siglongjmp");
6072 create_longjmp_breakpoint (NULL
);
6076 /* Took this out (temporarily at least), since it produces an extra
6077 blank line at startup. This messes up the gdbtests. -PB */
6078 /* Blank line to finish off all those mention() messages we just printed. */
6079 printf_filtered ("\n");
6083 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
6084 If from_tty is nonzero, it prints a message to that effect,
6085 which ends with a period (no newline). */
6087 /* Reset the thread number of this breakpoint:
6089 - If the breakpoint is for all threads, leave it as-is.
6090 - Else, reset it to the current thread for inferior_pid. */
6092 breakpoint_re_set_thread (b
)
6093 struct breakpoint
* b
;
6095 if (b
->thread
!= -1)
6097 if (in_thread_list (inferior_pid
))
6098 b
->thread
= pid_to_thread_id (inferior_pid
);
6103 set_ignore_count (bptnum
, count
, from_tty
)
6104 int bptnum
, count
, from_tty
;
6106 register struct breakpoint
*b
;
6112 if (b
->number
== bptnum
)
6114 b
->ignore_count
= count
;
6117 else if (count
== 0)
6118 printf_filtered ("Will stop next time breakpoint %d is reached.",
6120 else if (count
== 1)
6121 printf_filtered ("Will ignore next crossing of breakpoint %d.",
6124 printf_filtered ("Will ignore next %d crossings of breakpoint %d.",
6126 breakpoints_changed ();
6130 error ("No breakpoint number %d.", bptnum
);
6133 /* Clear the ignore counts of all breakpoints. */
6135 breakpoint_clear_ignore_counts ()
6137 struct breakpoint
*b
;
6140 b
->ignore_count
= 0;
6143 /* Command to set ignore-count of breakpoint N to COUNT. */
6146 ignore_command (args
, from_tty
)
6154 error_no_arg ("a breakpoint number");
6156 num
= get_number (&p
);
6159 error ("Second argument (specified ignore-count) is missing.");
6161 set_ignore_count (num
,
6162 longest_to_int (value_as_long (parse_and_eval (p
))),
6164 printf_filtered ("\n");
6165 breakpoints_changed ();
6168 /* Call FUNCTION on each of the breakpoints
6169 whose numbers are given in ARGS. */
6172 map_breakpoint_numbers (args
, function
)
6174 void (*function
) PARAMS ((struct breakpoint
*));
6176 register char *p
= args
;
6179 register struct breakpoint
*b
;
6182 error_no_arg ("one or more breakpoint numbers");
6188 num
= get_number (&p1
);
6191 if (b
->number
== num
)
6193 struct breakpoint
*related_breakpoint
= b
->related_breakpoint
;
6195 if (related_breakpoint
)
6196 function (related_breakpoint
);
6199 printf_unfiltered ("No breakpoint number %d.\n", num
);
6206 disable_breakpoint (bpt
)
6207 struct breakpoint
*bpt
;
6209 /* Never disable a watchpoint scope breakpoint; we want to
6210 hit them when we leave scope so we can delete both the
6211 watchpoint and its scope breakpoint at that time. */
6212 if (bpt
->type
== bp_watchpoint_scope
)
6215 bpt
->enable
= disabled
;
6217 check_duplicates (bpt
->address
, bpt
->section
);
6219 if (modify_breakpoint_hook
)
6220 modify_breakpoint_hook (bpt
);
6225 disable_command (args
, from_tty
)
6229 register struct breakpoint
*bpt
;
6231 ALL_BREAKPOINTS (bpt
)
6235 warning ("attempted to disable apparently deleted breakpoint #%d?\n", bpt
->number
);
6239 case bp_catch_unload
:
6241 case bp_catch_vfork
:
6243 case bp_catch_catch
:
6244 case bp_catch_throw
:
6245 case bp_hardware_breakpoint
:
6247 case bp_hardware_watchpoint
:
6248 case bp_read_watchpoint
:
6249 case bp_access_watchpoint
:
6250 disable_breakpoint (bpt
);
6255 map_breakpoint_numbers (args
, disable_breakpoint
);
6259 do_enable_breakpoint (bpt
, disposition
)
6260 struct breakpoint
*bpt
;
6261 enum bpdisp disposition
;
6263 struct frame_info
*save_selected_frame
= NULL
;
6264 int save_selected_frame_level
= -1;
6265 int target_resources_ok
, other_type_used
;
6268 if (bpt
->type
== bp_hardware_breakpoint
)
6271 i
= hw_breakpoint_used_count();
6272 target_resources_ok
= TARGET_CAN_USE_HARDWARE_WATCHPOINT(
6273 bp_hardware_breakpoint
, i
+1, 0);
6274 if (target_resources_ok
== 0)
6275 error ("No hardware breakpoint support in the target.");
6276 else if (target_resources_ok
< 0)
6277 error ("Hardware breakpoints used exceeds limit.");
6280 bpt
->enable
= enabled
;
6281 bpt
->disposition
= disposition
;
6282 check_duplicates (bpt
->address
, bpt
->section
);
6283 breakpoints_changed ();
6285 if (bpt
->type
== bp_watchpoint
|| bpt
->type
== bp_hardware_watchpoint
||
6286 bpt
->type
== bp_read_watchpoint
|| bpt
->type
== bp_access_watchpoint
)
6288 if (bpt
->exp_valid_block
!= NULL
)
6290 struct frame_info
*fr
=
6292 /* Ensure that we have the current frame. Else, this
6293 next query may pessimistically be answered as, "No,
6294 not within current scope". */
6295 get_current_frame ();
6296 fr
= find_frame_addr_in_frame_chain (bpt
->watchpoint_frame
);
6300 Cannot enable watchpoint %d because the block in which its expression\n\
6301 is valid is not currently in scope.\n", bpt
->number
);
6302 bpt
->enable
= disabled
;
6306 save_selected_frame
= selected_frame
;
6307 save_selected_frame_level
= selected_frame_level
;
6308 select_frame (fr
, -1);
6311 value_free (bpt
->val
);
6312 mark
= value_mark ();
6313 bpt
->val
= evaluate_expression (bpt
->exp
);
6314 release_value (bpt
->val
);
6315 if (VALUE_LAZY (bpt
->val
))
6316 value_fetch_lazy (bpt
->val
);
6318 if (bpt
->type
== bp_hardware_watchpoint
||
6319 bpt
->type
== bp_read_watchpoint
||
6320 bpt
->type
== bp_access_watchpoint
)
6322 int i
= hw_watchpoint_used_count (bpt
->type
, &other_type_used
);
6323 int mem_cnt
= can_use_hardware_watchpoint (bpt
->val
);
6325 /* Hack around 'unused var' error for some targets here */
6327 target_resources_ok
= TARGET_CAN_USE_HARDWARE_WATCHPOINT(
6328 bpt
->type
, i
+ mem_cnt
, other_type_used
);
6329 /* we can consider of type is bp_hardware_watchpoint, convert to
6330 bp_watchpoint in the following condition */
6331 if (target_resources_ok
< 0)
6334 Cannot enable watchpoint %d because target watch resources\n\
6335 have been allocated for other watchpoints.\n", bpt
->number
);
6336 bpt
->enable
= disabled
;
6337 value_free_to_mark (mark
);
6342 if (save_selected_frame_level
>= 0)
6343 select_and_print_frame (save_selected_frame
, save_selected_frame_level
);
6344 value_free_to_mark (mark
);
6346 if (modify_breakpoint_hook
)
6347 modify_breakpoint_hook (bpt
);
6351 enable_breakpoint (bpt
)
6352 struct breakpoint
*bpt
;
6354 do_enable_breakpoint (bpt
, bpt
->disposition
);
6357 /* The enable command enables the specified breakpoints (or all defined
6358 breakpoints) so they once again become (or continue to be) effective
6359 in stopping the inferior. */
6363 enable_command (args
, from_tty
)
6367 register struct breakpoint
*bpt
;
6369 ALL_BREAKPOINTS (bpt
)
6373 warning ("attempted to enable apparently deleted breakpoint #%d?\n", bpt
->number
);
6377 case bp_catch_unload
:
6379 case bp_catch_vfork
:
6381 case bp_catch_catch
:
6382 case bp_catch_throw
:
6383 case bp_hardware_breakpoint
:
6385 case bp_hardware_watchpoint
:
6386 case bp_read_watchpoint
:
6387 case bp_access_watchpoint
:
6388 enable_breakpoint (bpt
);
6393 map_breakpoint_numbers (args
, enable_breakpoint
);
6397 enable_once_breakpoint (bpt
)
6398 struct breakpoint
*bpt
;
6400 do_enable_breakpoint (bpt
, disable
);
6405 enable_once_command (args
, from_tty
)
6409 map_breakpoint_numbers (args
, enable_once_breakpoint
);
6413 enable_delete_breakpoint (bpt
)
6414 struct breakpoint
*bpt
;
6416 do_enable_breakpoint (bpt
, del
);
6421 enable_delete_command (args
, from_tty
)
6425 map_breakpoint_numbers (args
, enable_delete_breakpoint
);
6428 /* Use default_breakpoint_'s, or nothing if they aren't valid. */
6430 struct symtabs_and_lines
6431 decode_line_spec_1 (string
, funfirstline
)
6435 struct symtabs_and_lines sals
;
6437 error ("Empty line specification.");
6438 if (default_breakpoint_valid
)
6439 sals
= decode_line_1 (&string
, funfirstline
,
6440 default_breakpoint_symtab
, default_breakpoint_line
,
6443 sals
= decode_line_1 (&string
, funfirstline
,
6444 (struct symtab
*)NULL
, 0, (char ***)NULL
);
6446 error ("Junk at end of line specification: %s", string
);
6451 _initialize_breakpoint ()
6453 struct cmd_list_element
*c
;
6455 breakpoint_chain
= 0;
6456 /* Don't bother to call set_breakpoint_count. $bpnum isn't useful
6457 before a breakpoint is set. */
6458 breakpoint_count
= 0;
6460 add_com ("ignore", class_breakpoint
, ignore_command
,
6461 "Set ignore-count of breakpoint number N to COUNT.\n\
6462 Usage is `ignore N COUNT'.");
6464 add_com_alias("bc", "ignore", class_breakpoint
, 1);
6466 add_com ("commands", class_breakpoint
, commands_command
,
6467 "Set commands to be executed when a breakpoint is hit.\n\
6468 Give breakpoint number as argument after \"commands\".\n\
6469 With no argument, the targeted breakpoint is the last one set.\n\
6470 The commands themselves follow starting on the next line.\n\
6471 Type a line containing \"end\" to indicate the end of them.\n\
6472 Give \"silent\" as the first line to make the breakpoint silent;\n\
6473 then no output is printed when it is hit, except what the commands print.");
6475 add_com ("condition", class_breakpoint
, condition_command
,
6476 "Specify breakpoint number N to break only if COND is true.\n\
6477 Usage is `condition N COND', where N is an integer and COND is an\n\
6478 expression to be evaluated whenever breakpoint N is reached. ");
6480 add_com ("tbreak", class_breakpoint
, tbreak_command
,
6481 "Set a temporary breakpoint. Args like \"break\" command.\n\
6482 Like \"break\" except the breakpoint is only temporary,\n\
6483 so it will be deleted when hit. Equivalent to \"break\" followed\n\
6484 by using \"enable delete\" on the breakpoint number.");
6485 add_com("txbreak", class_breakpoint
, tbreak_at_finish_command
,
6486 "Set temporary breakpoint at procedure exit. Either there should\n\
6487 be no argument or the argument must be a depth.\n");
6489 add_com ("hbreak", class_breakpoint
, hbreak_command
,
6490 "Set a hardware assisted breakpoint. Args like \"break\" command.\n\
6491 Like \"break\" except the breakpoint requires hardware support,\n\
6492 some target hardware may not have this support.");
6494 add_com ("thbreak", class_breakpoint
, thbreak_command
,
6495 "Set a temporary hardware assisted breakpoint. Args like \"break\" command.\n\
6496 Like \"hbreak\" except the breakpoint is only temporary,\n\
6497 so it will be deleted when hit.");
6499 add_prefix_cmd ("enable", class_breakpoint
, enable_command
,
6500 "Enable some breakpoints.\n\
6501 Give breakpoint numbers (separated by spaces) as arguments.\n\
6502 With no subcommand, breakpoints are enabled until you command otherwise.\n\
6503 This is used to cancel the effect of the \"disable\" command.\n\
6504 With a subcommand you can enable temporarily.",
6505 &enablelist
, "enable ", 1, &cmdlist
);
6507 add_com("ab", class_breakpoint
, enable_command
,
6508 "Enable some breakpoints.\n\
6509 Give breakpoint numbers (separated by spaces) as arguments.\n\
6510 With no subcommand, breakpoints are enabled until you command otherwise.\n\
6511 This is used to cancel the effect of the \"disable\" command.\n\
6512 With a subcommand you can enable temporarily.");
6514 add_com_alias ("en", "enable", class_breakpoint
, 1);
6516 add_abbrev_prefix_cmd ("breakpoints", class_breakpoint
, enable_command
,
6517 "Enable some breakpoints.\n\
6518 Give breakpoint numbers (separated by spaces) as arguments.\n\
6519 This is used to cancel the effect of the \"disable\" command.\n\
6520 May be abbreviated to simply \"enable\".\n",
6521 &enablebreaklist
, "enable breakpoints ", 1, &enablelist
);
6523 add_cmd ("once", no_class
, enable_once_command
,
6524 "Enable breakpoints for one hit. Give breakpoint numbers.\n\
6525 If a breakpoint is hit while enabled in this fashion, it becomes disabled.",
6528 add_cmd ("delete", no_class
, enable_delete_command
,
6529 "Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
6530 If a breakpoint is hit while enabled in this fashion, it is deleted.",
6533 add_cmd ("delete", no_class
, enable_delete_command
,
6534 "Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
6535 If a breakpoint is hit while enabled in this fashion, it is deleted.",
6538 add_cmd ("once", no_class
, enable_once_command
,
6539 "Enable breakpoints for one hit. Give breakpoint numbers.\n\
6540 If a breakpoint is hit while enabled in this fashion, it becomes disabled.",
6543 add_prefix_cmd ("disable", class_breakpoint
, disable_command
,
6544 "Disable some breakpoints.\n\
6545 Arguments are breakpoint numbers with spaces in between.\n\
6546 To disable all breakpoints, give no argument.\n\
6547 A disabled breakpoint is not forgotten, but has no effect until reenabled.",
6548 &disablelist
, "disable ", 1, &cmdlist
);
6549 add_com_alias ("dis", "disable", class_breakpoint
, 1);
6550 add_com_alias ("disa", "disable", class_breakpoint
, 1);
6552 add_com("sb", class_breakpoint
, disable_command
,
6553 "Disable some breakpoints.\n\
6554 Arguments are breakpoint numbers with spaces in between.\n\
6555 To disable all breakpoints, give no argument.\n\
6556 A disabled breakpoint is not forgotten, but has no effect until reenabled.");
6558 add_cmd ("breakpoints", class_alias
, disable_command
,
6559 "Disable some breakpoints.\n\
6560 Arguments are breakpoint numbers with spaces in between.\n\
6561 To disable all breakpoints, give no argument.\n\
6562 A disabled breakpoint is not forgotten, but has no effect until reenabled.\n\
6563 This command may be abbreviated \"disable\".",
6566 add_prefix_cmd ("delete", class_breakpoint
, delete_command
,
6567 "Delete some breakpoints or auto-display expressions.\n\
6568 Arguments are breakpoint numbers with spaces in between.\n\
6569 To delete all breakpoints, give no argument.\n\
6571 Also a prefix command for deletion of other GDB objects.\n\
6572 The \"unset\" command is also an alias for \"delete\".",
6573 &deletelist
, "delete ", 1, &cmdlist
);
6574 add_com_alias ("d", "delete", class_breakpoint
, 1);
6576 add_com ("db", class_breakpoint
, delete_command
,
6577 "Delete some breakpoints.\n\
6578 Arguments are breakpoint numbers with spaces in between.\n\
6579 To delete all breakpoints, give no argument.\n");
6581 add_cmd ("breakpoints", class_alias
, delete_command
,
6582 "Delete some breakpoints or auto-display expressions.\n\
6583 Arguments are breakpoint numbers with spaces in between.\n\
6584 To delete all breakpoints, give no argument.\n\
6585 This command may be abbreviated \"delete\".",
6588 add_com ("clear", class_breakpoint
, clear_command
,
6589 concat ("Clear breakpoint at specified line or function.\n\
6590 Argument may be line number, function name, or \"*\" and an address.\n\
6591 If line number is specified, all breakpoints in that line are cleared.\n\
6592 If function is specified, breakpoints at beginning of function are cleared.\n\
6593 If an address is specified, breakpoints at that address are cleared.\n\n",
6594 "With no argument, clears all breakpoints in the line that the selected frame\n\
6597 See also the \"delete\" command which clears breakpoints by number.", NULL
));
6599 add_com ("break", class_breakpoint
, break_command
,
6600 concat ("Set breakpoint at specified line or function.\n\
6601 Argument may be line number, function name, or \"*\" and an address.\n\
6602 If line number is specified, break at start of code for that line.\n\
6603 If function is specified, break at start of code for that function.\n\
6604 If an address is specified, break at that exact address.\n",
6605 "With no arg, uses current execution address of selected stack frame.\n\
6606 This is useful for breaking on return to a stack frame.\n\
6608 Multiple breakpoints at one place are permitted, and useful if conditional.\n\
6610 Do \"help breakpoints\" for info on other commands dealing with breakpoints.", NULL
));
6611 add_com_alias ("b", "break", class_run
, 1);
6612 add_com_alias ("br", "break", class_run
, 1);
6613 add_com_alias ("bre", "break", class_run
, 1);
6614 add_com_alias ("brea", "break", class_run
, 1);
6616 add_com("xbreak", class_breakpoint
, break_at_finish_command
,
6617 concat("Set breakpoint at procedure exit. \n\
6618 Argument may be function name, or \"*\" and an address.\n\
6619 If function is specified, break at end of code for that function.\n\
6620 If an address is specified, break at the end of the function that contains \n\
6621 that exact address.\n",
6622 "With no arg, uses current execution address of selected stack frame.\n\
6623 This is useful for breaking on return to a stack frame.\n\
6625 Multiple breakpoints at one place are permitted, and useful if conditional.\n\
6627 Do \"help breakpoints\" for info on other commands dealing with breakpoints.", NULL
));
6628 add_com_alias ("xb", "xbreak", class_breakpoint
, 1);
6629 add_com_alias ("xbr", "xbreak", class_breakpoint
, 1);
6630 add_com_alias ("xbre", "xbreak", class_breakpoint
, 1);
6631 add_com_alias ("xbrea", "xbreak", class_breakpoint
, 1);
6635 add_com_alias ("ba", "break", class_breakpoint
, 1);
6636 add_com_alias ("bu", "ubreak", class_breakpoint
, 1);
6637 add_com ("bx", class_breakpoint
, break_at_finish_at_depth_command
,
6638 "Set breakpoint at procedure exit. Either there should\n\
6639 be no argument or the argument must be a depth.\n");
6644 add_abbrev_prefix_cmd("stop", class_breakpoint
, stop_command
,
6645 "Break in function/address or break at a line in the current file.",
6646 &stoplist
, "stop ", 1, &cmdlist
);
6647 add_cmd("in", class_breakpoint
, stopin_command
,
6648 "Break in function or address.\n", &stoplist
);
6649 add_cmd("at", class_breakpoint
, stopat_command
,
6650 "Break at a line in the current file.\n", &stoplist
);
6651 add_com("status", class_info
, breakpoints_info
,
6652 concat ("Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
6653 The \"Type\" column indicates one of:\n\
6654 \tbreakpoint - normal breakpoint\n\
6655 \twatchpoint - watchpoint\n\
6656 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
6657 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
6658 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
6659 address and file/line number respectively.\n\n",
6660 "Convenience variable \"$_\" and default examine address for \"x\"\n\
6661 are set to the address of the last breakpoint listed.\n\n\
6662 Convenience variable \"$bpnum\" contains the number of the last\n\
6663 breakpoint set.", NULL
));
6666 add_info ("breakpoints", breakpoints_info
,
6667 concat ("Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
6668 The \"Type\" column indicates one of:\n\
6669 \tbreakpoint - normal breakpoint\n\
6670 \twatchpoint - watchpoint\n\
6671 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
6672 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
6673 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
6674 address and file/line number respectively.\n\n",
6675 "Convenience variable \"$_\" and default examine address for \"x\"\n\
6676 are set to the address of the last breakpoint listed.\n\n\
6677 Convenience variable \"$bpnum\" contains the number of the last\n\
6678 breakpoint set.", NULL
));
6681 add_com("lb", class_breakpoint
, breakpoints_info
,
6682 concat ("Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
6683 The \"Type\" column indicates one of:\n\
6684 \tbreakpoint - normal breakpoint\n\
6685 \twatchpoint - watchpoint\n\
6686 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
6687 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
6688 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
6689 address and file/line number respectively.\n\n",
6690 "Convenience variable \"$_\" and default examine address for \"x\"\n\
6691 are set to the address of the last breakpoint listed.\n\n\
6692 Convenience variable \"$bpnum\" contains the number of the last\n\
6693 breakpoint set.", NULL
));
6695 add_cmd ("breakpoints", class_maintenance
, maintenance_info_breakpoints
,
6696 concat ("Status of all breakpoints, or breakpoint number NUMBER.\n\
6697 The \"Type\" column indicates one of:\n\
6698 \tbreakpoint - normal breakpoint\n\
6699 \twatchpoint - watchpoint\n\
6700 \tlongjmp - internal breakpoint used to step through longjmp()\n\
6701 \tlongjmp resume - internal breakpoint at the target of longjmp()\n\
6702 \tuntil - internal breakpoint used by the \"until\" command\n\
6703 \tfinish - internal breakpoint used by the \"finish\" command\n",
6704 "The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
6705 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
6706 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
6707 address and file/line number respectively.\n\n",
6708 "Convenience variable \"$_\" and default examine address for \"x\"\n\
6709 are set to the address of the last breakpoint listed.\n\n\
6710 Convenience variable \"$bpnum\" contains the number of the last\n\
6711 breakpoint set.", NULL
),
6712 &maintenanceinfolist
);
6714 add_com ("catch", class_breakpoint
, catch_command
,
6715 "Set catchpoints to catch events.\n\
6716 Raised signals may be caught:\n\
6717 \tcatch signal - all signals\n\
6718 \tcatch signal <signame> - a particular signal\n\
6719 Raised exceptions may be caught:\n\
6720 \tcatch throw - all exceptions, when thrown\n\
6721 \tcatch throw <exceptname> - a particular exception, when thrown\n\
6722 \tcatch catch - all exceptions, when caught\n\
6723 \tcatch catch <exceptname> - a particular exception, when caught\n\
6724 Thread or process events may be caught:\n\
6725 \tcatch thread_start - any threads, just after creation\n\
6726 \tcatch thread_exit - any threads, just before expiration\n\
6727 \tcatch thread_join - any threads, just after joins\n\
6728 Process events may be caught:\n\
6729 \tcatch start - any processes, just after creation\n\
6730 \tcatch exit - any processes, just before expiration\n\
6731 \tcatch fork - calls to fork()\n\
6732 \tcatch vfork - calls to vfork()\n\
6733 \tcatch exec - calls to exec()\n\
6734 Dynamically-linked library events may be caught:\n\
6735 \tcatch load - loads of any library\n\
6736 \tcatch load <libname> - loads of a particular library\n\
6737 \tcatch unload - unloads of any library\n\
6738 \tcatch unload <libname> - unloads of a particular library\n\
6739 The act of your program's execution stopping may also be caught:\n\
6741 C++ exceptions may be caught:\n\
6742 \tcatch throw - all exceptions, when thrown\n\
6743 \tcatch catch - all exceptions, when caught\n\
6745 Do \"help set follow-fork-mode\" for info on debugging your program\n\
6746 after a fork or vfork is caught.\n\n\
6747 Do \"help breakpoints\" for info on other commands dealing with breakpoints.");
6749 add_com ("tcatch", class_breakpoint
, tcatch_command
,
6750 "Set temporary catchpoints to catch events.\n\
6751 Args like \"catch\" command.\n\
6752 Like \"catch\" except the catchpoint is only temporary,\n\
6753 so it will be deleted when hit. Equivalent to \"catch\" followed\n\
6754 by using \"enable delete\" on the catchpoint number.");
6756 add_com ("watch", class_breakpoint
, watch_command
,
6758 "Set a watchpoint for an expression.\n\
6759 A watchpoint stops execution of your program whenever the value of\n\
6760 an expression changes.");
6762 add_com ("rwatch", class_breakpoint
, rwatch_command
,
6763 "Set a read watchpoint for an expression.\n\
6764 A watchpoint stops execution of your program whenever the value of\n\
6765 an expression is read.");
6767 add_com ("awatch", class_breakpoint
, awatch_command
,
6768 "Set a watchpoint for an expression.\n\
6769 A watchpoint stops execution of your program whenever the value of\n\
6770 an expression is either read or written.");
6772 add_info ("watchpoints", breakpoints_info
,
6773 "Synonym for ``info breakpoints''.");
6776 c
= add_set_cmd ("can-use-hw-watchpoints", class_support
, var_zinteger
,
6777 (char *) &can_use_hw_watchpoints
,
6778 "Set debugger's willingness to use watchpoint hardware.\n\
6779 If zero, gdb will not use hardware for new watchpoints, even if\n\
6780 such is available. (However, any hardware watchpoints that were\n\
6781 created before setting this to nonzero, will continue to use watchpoint\n\
6784 add_show_from_set (c
, &showlist
);
6786 can_use_hw_watchpoints
= 1;