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 /* step_resume entries: a step resume breakpoint overrides another
2424 breakpoint of signal handling (see comment in wait_for_inferior
2425 at first IN_SIGTRAMP where we set the step_resume breakpoint). */
2426 /* We handle the through_sigtramp_breakpoint the same way; having both
2427 one of those and a step_resume_breakpoint is probably very rare (?). */
2429 static const enum bpstat_what_main_action
2430 table
[(int)class_last
][(int)BPSTAT_WHAT_LAST
] =
2433 /* kc ss sn sgl slr clr clrs sr ts shl shlr
2435 /*no_effect*/ {kc
, ss
, sn
, sgl
, slr
, clr
, clrs
, sr
, ts
, shl
, shlr
},
2436 /*wp_silent*/ {ss
, ss
, sn
, ss
, ss
, ss
, ss
, sr
, ts
, shl
, shlr
},
2437 /*wp_noisy*/ {sn
, sn
, sn
, sn
, sn
, sn
, sn
, sr
, ts
, shl
, shlr
},
2438 /*bp_nostop*/ {sgl
, ss
, sn
, sgl
, slr
, clrs
, clrs
, sr
, ts
, shl
, shlr
},
2439 /*bp_silent*/ {ss
, ss
, sn
, ss
, ss
, ss
, ss
, sr
, ts
, shl
, shlr
},
2440 /*bp_noisy*/ {sn
, sn
, sn
, sn
, sn
, sn
, sn
, sr
, ts
, shl
, shlr
},
2441 /*long_jump*/ {slr
, ss
, sn
, slr
, err
, err
, err
, sr
, ts
, shl
, shlr
},
2442 /*long_resume*/ {clr
, ss
, sn
, clrs
, err
, err
, err
, sr
, ts
, shl
, shlr
},
2443 /*step_resume*/ {sr
, sr
, sr
, sr
, sr
, sr
, sr
, sr
, ts
, shl
, shlr
},
2444 /*through_sig*/ {ts
, ts
, ts
, ts
, ts
, ts
, ts
, ts
, ts
, shl
, shlr
},
2445 /*shlib*/ {shl
, shl
, shl
, shl
, shl
, shl
, shl
, shl
, ts
, shl
, shlr
},
2446 /*catch_shlib*/ {shlr
, shlr
, shlr
, shlr
, shlr
, shlr
, shlr
, shlr
, ts
, shlr
, shlr
}
2461 enum bpstat_what_main_action current_action
= BPSTAT_WHAT_KEEP_CHECKING
;
2462 struct bpstat_what retval
;
2464 retval
.call_dummy
= 0;
2465 for (; bs
!= NULL
; bs
= bs
->next
)
2467 enum class bs_class
= no_effect
;
2468 if (bs
->breakpoint_at
== NULL
)
2469 /* I suspect this can happen if it was a momentary breakpoint
2470 which has since been deleted. */
2472 switch (bs
->breakpoint_at
->type
)
2478 case bp_hardware_breakpoint
:
2484 bs_class
= bp_noisy
;
2486 bs_class
= bp_silent
;
2489 bs_class
= bp_nostop
;
2492 case bp_hardware_watchpoint
:
2493 case bp_read_watchpoint
:
2494 case bp_access_watchpoint
:
2498 bs_class
= wp_noisy
;
2500 bs_class
= wp_silent
;
2503 /* There was a watchpoint, but we're not stopping. This requires
2504 no further action. */
2505 bs_class
= no_effect
;
2508 bs_class
= long_jump
;
2510 case bp_longjmp_resume
:
2511 bs_class
= long_resume
;
2513 case bp_step_resume
:
2516 bs_class
= step_resume
;
2519 /* It is for the wrong frame. */
2520 bs_class
= bp_nostop
;
2522 case bp_through_sigtramp
:
2523 bs_class
= through_sig
;
2525 case bp_watchpoint_scope
:
2526 bs_class
= bp_nostop
;
2528 case bp_shlib_event
:
2529 bs_class
= shlib_event
;
2532 case bp_catch_unload
:
2533 /* Only if this catchpoint triggered should we cause the
2534 step-out-of-dld behaviour. Otherwise, we ignore this
2537 bs_class
= catch_shlib_event
;
2539 bs_class
= no_effect
;
2542 case bp_catch_vfork
:
2547 bs_class
= bp_noisy
;
2549 bs_class
= bp_silent
;
2552 /* There was a catchpoint, but we're not stopping. This requires
2553 no further action. */
2554 bs_class
= no_effect
;
2556 case bp_catch_catch
:
2557 if (!bs
->stop
|| CURRENT_EXCEPTION_KIND
!= EX_EVENT_CATCH
)
2558 bs_class
= bp_nostop
;
2560 bs_class
= bs
->print
? bp_noisy
: bp_silent
;
2562 case bp_catch_throw
:
2563 if (!bs
->stop
|| CURRENT_EXCEPTION_KIND
!= EX_EVENT_THROW
)
2564 bs_class
= bp_nostop
;
2566 bs_class
= bs
->print
? bp_noisy
: bp_silent
;
2569 /* Make sure the action is stop (silent or noisy), so infrun.c
2570 pops the dummy frame. */
2571 bs_class
= bp_silent
;
2572 retval
.call_dummy
= 1;
2575 current_action
= table
[(int)bs_class
][(int)current_action
];
2577 retval
.main_action
= current_action
;
2581 /* Nonzero if we should step constantly (e.g. watchpoints on machines
2582 without hardware support). This isn't related to a specific bpstat,
2583 just to things like whether watchpoints are set. */
2586 bpstat_should_step ()
2588 struct breakpoint
*b
;
2590 if (b
->enable
== enabled
&& b
->type
== bp_watchpoint
)
2595 /* Nonzero if there are enabled hardware watchpoints. */
2597 bpstat_have_active_hw_watchpoints ()
2599 struct breakpoint
*b
;
2601 if ((b
->enable
== enabled
) &&
2603 ((b
->type
== bp_hardware_watchpoint
) ||
2604 (b
->type
== bp_read_watchpoint
) ||
2605 (b
->type
== bp_access_watchpoint
)))
2611 /* Given a bpstat that records zero or more triggered eventpoints, this
2612 function returns another bpstat which contains only the catchpoints
2613 on that first list, if any. */
2615 bpstat_get_triggered_catchpoints (ep_list
, cp_list
)
2619 struct bpstats root_bs
[1];
2620 bpstat bs
= root_bs
;
2621 struct breakpoint
* ep
;
2622 char * dll_pathname
;
2624 bpstat_clear (cp_list
);
2625 root_bs
->next
= NULL
;
2627 for (; ep_list
!= NULL
; ep_list
= ep_list
->next
)
2629 /* Is this eventpoint a catchpoint? If not, ignore it. */
2630 ep
= ep_list
->breakpoint_at
;
2633 if ((ep
->type
!= bp_catch_load
) &&
2634 (ep
->type
!= bp_catch_unload
) &&
2635 (ep
->type
!= bp_catch_catch
) &&
2636 (ep
->type
!= bp_catch_throw
)) /* pai: (temp) ADD fork/vfork here!! */
2639 /* Yes; add it to the list. */
2640 bs
= bpstat_alloc (ep
, bs
);
2645 #if defined(SOLIB_ADD)
2646 /* Also, for each triggered catchpoint, tag it with the name of
2647 the library that caused this trigger. (We copy the name now,
2648 because it's only guaranteed to be available NOW, when the
2649 catchpoint triggers. Clients who may wish to know the name
2650 later must get it from the catchpoint itself.) */
2651 if (ep
->triggered_dll_pathname
!= NULL
)
2652 free (ep
->triggered_dll_pathname
);
2653 if (ep
->type
== bp_catch_load
)
2654 dll_pathname
= SOLIB_LOADED_LIBRARY_PATHNAME (inferior_pid
);
2656 dll_pathname
= SOLIB_UNLOADED_LIBRARY_PATHNAME (inferior_pid
);
2658 dll_pathname
= NULL
;
2662 ep
->triggered_dll_pathname
= (char *) xmalloc (strlen (dll_pathname
) + 1);
2663 strcpy (ep
->triggered_dll_pathname
, dll_pathname
);
2666 ep
->triggered_dll_pathname
= NULL
;
2672 /* Print information on breakpoint number BNUM, or -1 if all.
2673 If WATCHPOINTS is zero, process only breakpoints; if WATCHPOINTS
2674 is nonzero, process only watchpoints. */
2679 } ep_type_description_t
;
2682 breakpoint_1 (bnum
, allflag
)
2686 register struct breakpoint
*b
;
2687 register struct command_line
*l
;
2688 register struct symbol
*sym
;
2689 CORE_ADDR last_addr
= (CORE_ADDR
)-1;
2690 int found_a_breakpoint
= 0;
2691 static ep_type_description_t bptypes
[] =
2693 {bp_none
, "?deleted?"},
2694 {bp_breakpoint
, "breakpoint"},
2695 {bp_hardware_breakpoint
, "hw breakpoint"},
2696 {bp_until
, "until"},
2697 {bp_finish
, "finish"},
2698 {bp_watchpoint
, "watchpoint"},
2699 {bp_hardware_watchpoint
, "hw watchpoint"},
2700 {bp_read_watchpoint
, "read watchpoint"},
2701 {bp_access_watchpoint
, "acc watchpoint"},
2702 {bp_longjmp
, "longjmp"},
2703 {bp_longjmp_resume
, "longjmp resume"},
2704 {bp_step_resume
, "step resume"},
2705 {bp_through_sigtramp
, "sigtramp"},
2706 {bp_watchpoint_scope
, "watchpoint scope"},
2707 {bp_call_dummy
, "call dummy"},
2708 {bp_shlib_event
, "shlib events"},
2709 {bp_catch_load
, "catch load"},
2710 {bp_catch_unload
, "catch unload"},
2711 {bp_catch_fork
, "catch fork"},
2712 {bp_catch_vfork
, "catch vfork"},
2713 {bp_catch_exec
, "catch exec"},
2714 {bp_catch_catch
, "catch catch"},
2715 {bp_catch_throw
, "catch throw"}
2718 static char *bpdisps
[] = {"del", "dstp", "dis", "keep"};
2719 static char bpenables
[] = "nyn";
2720 char wrap_indent
[80];
2725 || bnum
== b
->number
)
2727 /* We only print out user settable breakpoints unless the allflag is set. */
2729 && b
->type
!= bp_breakpoint
2730 && b
->type
!= bp_catch_load
2731 && b
->type
!= bp_catch_unload
2732 && b
->type
!= bp_catch_fork
2733 && b
->type
!= bp_catch_vfork
2734 && b
->type
!= bp_catch_exec
2735 && b
->type
!= bp_catch_catch
2736 && b
->type
!= bp_catch_throw
2737 && b
->type
!= bp_hardware_breakpoint
2738 && b
->type
!= bp_watchpoint
2739 && b
->type
!= bp_read_watchpoint
2740 && b
->type
!= bp_access_watchpoint
2741 && b
->type
!= bp_hardware_watchpoint
)
2744 if (!found_a_breakpoint
++)
2746 annotate_breakpoints_headers ();
2749 printf_filtered ("Num ");
2751 printf_filtered ("Type ");
2753 printf_filtered ("Disp ");
2755 printf_filtered ("Enb ");
2759 printf_filtered ("Address ");
2762 printf_filtered ("What\n");
2764 annotate_breakpoints_table ();
2769 printf_filtered ("%-3d ", b
->number
);
2771 if ((int)b
->type
> (sizeof(bptypes
)/sizeof(bptypes
[0])))
2772 error ("bptypes table does not describe type #%d.", (int)b
->type
);
2773 if ((int)b
->type
!= bptypes
[(int)b
->type
].type
)
2774 error ("bptypes table does not describe type #%d?", (int)b
->type
);
2775 printf_filtered ("%-14s ", bptypes
[(int)b
->type
].description
);
2777 printf_filtered ("%-4s ", bpdisps
[(int)b
->disposition
]);
2779 printf_filtered ("%-3c ", bpenables
[(int)b
->enable
]);
2781 strcpy (wrap_indent
, " ");
2783 strcat (wrap_indent
, " ");
2787 case bp_hardware_watchpoint
:
2788 case bp_read_watchpoint
:
2789 case bp_access_watchpoint
:
2790 /* Field 4, the address, is omitted (which makes the columns
2791 not line up too nicely with the headers, but the effect
2792 is relatively readable). */
2794 print_expression (b
->exp
, gdb_stdout
);
2798 case bp_catch_unload
:
2799 /* Field 4, the address, is omitted (which makes the columns
2800 not line up too nicely with the headers, but the effect
2801 is relatively readable). */
2803 if (b
->dll_pathname
== NULL
)
2804 printf_filtered ("<any library> ");
2806 printf_filtered ("library \"%s\" ", b
->dll_pathname
);
2810 case bp_catch_vfork
:
2811 /* Field 4, the address, is omitted (which makes the columns
2812 not line up too nicely with the headers, but the effect
2813 is relatively readable). */
2815 if (b
->forked_inferior_pid
!= 0)
2816 printf_filtered ("process %d ", b
->forked_inferior_pid
);
2820 /* Field 4, the address, is omitted (which makes the columns
2821 not line up too nicely with the headers, but the effect
2822 is relatively readable). */
2824 if (b
->exec_pathname
!= NULL
)
2825 printf_filtered ("program \"%s\" ", b
->exec_pathname
);
2827 case bp_catch_catch
:
2828 /* Field 4, the address, is omitted (which makes the columns
2829 not line up too nicely with the headers, but the effect
2830 is relatively readable). */
2832 printf_filtered ("exception catch ");
2834 case bp_catch_throw
:
2835 /* Field 4, the address, is omitted (which makes the columns
2836 not line up too nicely with the headers, but the effect
2837 is relatively readable). */
2839 printf_filtered ("exception throw ");
2843 case bp_hardware_breakpoint
:
2847 case bp_longjmp_resume
:
2848 case bp_step_resume
:
2849 case bp_through_sigtramp
:
2850 case bp_watchpoint_scope
:
2852 case bp_shlib_event
:
2856 /* FIXME-32x64: need a print_address_numeric with
2860 local_hex_string_custom
2861 ((unsigned long) b
->address
, "08l"));
2866 last_addr
= b
->address
;
2869 sym
= find_pc_sect_function (b
->address
, b
->section
);
2872 fputs_filtered ("in ", gdb_stdout
);
2873 fputs_filtered (SYMBOL_SOURCE_NAME (sym
), gdb_stdout
);
2874 wrap_here (wrap_indent
);
2875 fputs_filtered (" at ", gdb_stdout
);
2877 fputs_filtered (b
->source_file
, gdb_stdout
);
2878 printf_filtered (":%d", b
->line_number
);
2881 print_address_symbolic (b
->address
, gdb_stdout
, demangle
, " ");
2885 if (b
->thread
!= -1)
2886 printf_filtered (" thread %d", b
->thread
);
2888 printf_filtered ("\n");
2894 printf_filtered ("\tstop only in stack frame at ");
2895 print_address_numeric (b
->frame
, 1, gdb_stdout
);
2896 printf_filtered ("\n");
2903 printf_filtered ("\tstop only if ");
2904 print_expression (b
->cond
, gdb_stdout
);
2905 printf_filtered ("\n");
2908 if (b
->thread
!= -1)
2910 /* FIXME should make an annotation for this */
2911 printf_filtered ("\tstop only in thread %d\n", b
->thread
);
2914 if (show_breakpoint_hit_counts
&& b
->hit_count
)
2916 /* FIXME should make an annotation for this */
2917 if (ep_is_catchpoint (b
))
2918 printf_filtered ("\tcatchpoint");
2920 printf_filtered ("\tbreakpoint");
2921 printf_filtered (" already hit %d time%s\n",
2922 b
->hit_count
, (b
->hit_count
== 1 ? "" : "s"));
2925 if (b
->ignore_count
)
2929 printf_filtered ("\tignore next %d hits\n", b
->ignore_count
);
2932 if ((l
= b
->commands
))
2938 print_command_line (l
, 4, gdb_stdout
);
2944 if (!found_a_breakpoint
)
2947 printf_filtered ("No breakpoints or watchpoints.\n");
2949 printf_filtered ("No breakpoint or watchpoint number %d.\n", bnum
);
2952 /* Compare against (CORE_ADDR)-1 in case some compiler decides
2953 that a comparison of an unsigned with -1 is always false. */
2954 if (last_addr
!= (CORE_ADDR
)-1)
2955 set_next_address (last_addr
);
2957 annotate_breakpoints_table_end ();
2962 breakpoints_info (bnum_exp
, from_tty
)
2969 bnum
= parse_and_eval_address (bnum_exp
);
2971 breakpoint_1 (bnum
, 0);
2976 maintenance_info_breakpoints (bnum_exp
, from_tty
)
2983 bnum
= parse_and_eval_address (bnum_exp
);
2985 breakpoint_1 (bnum
, 1);
2988 /* Print a message describing any breakpoints set at PC. */
2991 describe_other_breakpoints (pc
, section
)
2995 register int others
= 0;
2996 register struct breakpoint
*b
;
2999 if (b
->address
== pc
)
3000 if (overlay_debugging
== 0 ||
3001 b
->section
== section
)
3005 printf_filtered ("Note: breakpoint%s ", (others
> 1) ? "s" : "");
3007 if (b
->address
== pc
)
3008 if (overlay_debugging
== 0 ||
3009 b
->section
== section
)
3015 ((b
->enable
== disabled
|| b
->enable
== shlib_disabled
|| b
->enable
== call_disabled
)
3016 ? " (disabled)" : ""),
3017 (others
> 1) ? "," : ((others
== 1) ? " and" : ""));
3019 printf_filtered ("also set at pc ");
3020 print_address_numeric (pc
, 1, gdb_stdout
);
3021 printf_filtered (".\n");
3025 /* Set the default place to put a breakpoint
3026 for the `break' command with no arguments. */
3029 set_default_breakpoint (valid
, addr
, symtab
, line
)
3032 struct symtab
*symtab
;
3035 default_breakpoint_valid
= valid
;
3036 default_breakpoint_address
= addr
;
3037 default_breakpoint_symtab
= symtab
;
3038 default_breakpoint_line
= line
;
3041 /* Rescan breakpoints at address ADDRESS,
3042 marking the first one as "first" and any others as "duplicates".
3043 This is so that the bpt instruction is only inserted once. */
3046 check_duplicates (address
, section
)
3050 register struct breakpoint
*b
;
3051 register int count
= 0;
3053 if (address
== 0) /* Watchpoints are uninteresting */
3057 if (b
->enable
!= disabled
3058 && b
->enable
!= shlib_disabled
3059 && b
->enable
!= call_disabled
3060 && b
->address
== address
3061 && (overlay_debugging
== 0 || b
->section
== section
))
3064 b
->duplicate
= count
> 1;
3068 /* Low level routine to set a breakpoint.
3069 Takes as args the three things that every breakpoint must have.
3070 Returns the breakpoint object so caller can set other things.
3071 Does not set the breakpoint number!
3072 Does not print anything.
3074 ==> This routine should not be called if there is a chance of later
3075 error(); otherwise it leaves a bogus breakpoint on the chain. Validate
3076 your arguments BEFORE calling this routine! */
3079 set_raw_breakpoint (sal
)
3080 struct symtab_and_line sal
;
3082 register struct breakpoint
*b
, *b1
;
3084 b
= (struct breakpoint
*) xmalloc (sizeof (struct breakpoint
));
3085 memset (b
, 0, sizeof (*b
));
3086 b
->address
= sal
.pc
;
3087 if (sal
.symtab
== NULL
)
3088 b
->source_file
= NULL
;
3090 b
->source_file
= savestring (sal
.symtab
->filename
,
3091 strlen (sal
.symtab
->filename
));
3092 b
->section
= sal
.section
;
3093 b
->language
= current_language
->la_language
;
3094 b
->input_radix
= input_radix
;
3096 b
->line_number
= sal
.line
;
3097 b
->enable
= enabled
;
3100 b
->ignore_count
= 0;
3103 b
->dll_pathname
= NULL
;
3104 b
->triggered_dll_pathname
= NULL
;
3105 b
->forked_inferior_pid
= 0;
3106 b
->exec_pathname
= NULL
;
3108 /* Add this breakpoint to the end of the chain
3109 so that a list of breakpoints will come out in order
3110 of increasing numbers. */
3112 b1
= breakpoint_chain
;
3114 breakpoint_chain
= b
;
3122 check_duplicates (sal
.pc
, sal
.section
);
3123 breakpoints_changed ();
3128 #ifdef GET_LONGJMP_TARGET
3131 create_longjmp_breakpoint (func_name
)
3134 struct symtab_and_line sal
;
3135 struct breakpoint
*b
;
3137 INIT_SAL (&sal
); /* initialize to zeroes */
3138 if (func_name
!= NULL
)
3140 struct minimal_symbol
*m
;
3142 m
= lookup_minimal_symbol_text (func_name
, NULL
, (struct objfile
*)NULL
);
3144 sal
.pc
= SYMBOL_VALUE_ADDRESS (m
);
3148 sal
.section
= find_pc_overlay (sal
.pc
);
3149 b
= set_raw_breakpoint (sal
);
3152 b
->type
= func_name
!= NULL
? bp_longjmp
: bp_longjmp_resume
;
3153 b
->disposition
= donttouch
;
3154 b
->enable
= disabled
;
3157 b
->addr_string
= strsave(func_name
);
3158 b
->number
= internal_breakpoint_number
--;
3161 #endif /* #ifdef GET_LONGJMP_TARGET */
3163 /* Call this routine when stepping and nexting to enable a breakpoint if we do
3164 a longjmp(). When we hit that breakpoint, call
3165 set_longjmp_resume_breakpoint() to figure out where we are going. */
3168 enable_longjmp_breakpoint()
3170 register struct breakpoint
*b
;
3173 if (b
->type
== bp_longjmp
)
3175 b
->enable
= enabled
;
3176 check_duplicates (b
->address
, b
->section
);
3181 disable_longjmp_breakpoint()
3183 register struct breakpoint
*b
;
3186 if ( b
->type
== bp_longjmp
3187 || b
->type
== bp_longjmp_resume
)
3189 b
->enable
= disabled
;
3190 check_duplicates (b
->address
, b
->section
);
3196 remove_solib_event_breakpoints ()
3198 register struct breakpoint
*b
, *temp
;
3200 ALL_BREAKPOINTS_SAFE (b
, temp
)
3201 if (b
->type
== bp_shlib_event
)
3202 delete_breakpoint (b
);
3206 create_solib_event_breakpoint (address
)
3209 struct breakpoint
*b
;
3210 struct symtab_and_line sal
;
3212 INIT_SAL (&sal
); /* initialize to zeroes */
3214 sal
.section
= find_pc_overlay (sal
.pc
);
3215 b
= set_raw_breakpoint (sal
);
3216 b
->number
= internal_breakpoint_number
--;
3217 b
->disposition
= donttouch
;
3218 b
->type
= bp_shlib_event
;
3222 disable_breakpoints_in_shlibs (silent
)
3225 struct breakpoint
* b
;
3226 int disabled_shlib_breaks
= 0;
3228 /* See also: insert_breakpoints, under DISABLE_UNSETTABLE_BREAK. */
3231 #if defined (PC_SOLIB)
3232 if (((b
->type
== bp_breakpoint
) ||
3233 (b
->type
== bp_hardware_breakpoint
)) &&
3234 (b
->enable
!= shlib_disabled
) &&
3235 (b
->enable
!= call_disabled
) &&
3237 PC_SOLIB (b
->address
))
3239 b
->enable
= shlib_disabled
;
3242 if (!disabled_shlib_breaks
)
3244 target_terminal_ours_for_output ();
3245 printf_filtered ("Temporarily disabling shared library breakpoints:\n");
3247 disabled_shlib_breaks
= 1;
3248 printf_filtered ("%d ", b
->number
);
3253 if (disabled_shlib_breaks
&& !silent
)
3254 printf_filtered ("\n");
3257 /* Try to reenable any breakpoints in shared libraries. */
3259 re_enable_breakpoints_in_shlibs ()
3261 struct breakpoint
*b
;
3264 if (b
->enable
== shlib_disabled
)
3268 /* Do not reenable the breakpoint if the shared library
3269 is still not mapped in. */
3270 if (target_read_memory (b
->address
, buf
, 1) == 0)
3271 b
->enable
= enabled
;
3278 create_solib_load_unload_event_breakpoint (hookname
, tempflag
, dll_pathname
, cond_string
, bp_kind
)
3283 enum bptype bp_kind
;
3285 struct breakpoint
* b
;
3286 struct symtabs_and_lines sals
;
3287 struct symtab_and_line sal
;
3288 struct cleanup
* old_chain
;
3289 struct cleanup
* canonical_strings_chain
= NULL
;
3291 char * addr_start
= hookname
;
3292 char * addr_end
= NULL
;
3293 char ** canonical
= (char **) NULL
;
3294 int thread
= -1; /* All threads. */
3296 /* Set a breakpoint on the specified hook. */
3297 sals
= decode_line_1 (&hookname
, 1, (struct symtab
*) NULL
, 0, &canonical
);
3298 addr_end
= hookname
;
3300 if (sals
.nelts
== 0)
3302 warning ("Unable to set a breakpoint on dynamic linker callback.");
3303 warning ("Suggest linking with /opt/langtools/lib/end.o.");
3304 warning ("GDB will be unable to track shl_load/shl_unload calls");
3307 if (sals
.nelts
!= 1)
3309 warning ("Unable to set a unique breakpoint on dynamic linker callback.");
3310 warning ("GDB will be unable to track shl_load/shl_unload calls");
3314 /* Make sure that all storage allocated in decode_line_1 gets freed in case
3315 the following errors out. */
3316 old_chain
= make_cleanup (free
, sals
.sals
);
3317 if (canonical
!= (char **)NULL
)
3319 make_cleanup (free
, canonical
);
3320 canonical_strings_chain
= make_cleanup (null_cleanup
, 0);
3321 if (canonical
[0] != NULL
)
3322 make_cleanup (free
, canonical
[0]);
3325 resolve_sal_pc (&sals
.sals
[0]);
3327 /* Remove the canonical strings from the cleanup, they are needed below. */
3328 if (canonical
!= (char **)NULL
)
3329 discard_cleanups (canonical_strings_chain
);
3331 b
= set_raw_breakpoint (sals
.sals
[0]);
3332 set_breakpoint_count (breakpoint_count
+ 1);
3333 b
->number
= breakpoint_count
;
3335 b
->cond_string
= (cond_string
== NULL
) ? NULL
: savestring (cond_string
, strlen (cond_string
));
3338 if (canonical
!= (char **)NULL
&& canonical
[0] != NULL
)
3339 b
->addr_string
= canonical
[0];
3340 else if (addr_start
)
3341 b
->addr_string
= savestring (addr_start
, addr_end
- addr_start
);
3343 b
->enable
= enabled
;
3344 b
->disposition
= tempflag
? del
: donttouch
;
3346 if (dll_pathname
== NULL
)
3347 b
->dll_pathname
= NULL
;
3350 b
->dll_pathname
= (char *) xmalloc (strlen (dll_pathname
) + 1);
3351 strcpy (b
->dll_pathname
, dll_pathname
);
3356 do_cleanups (old_chain
);
3360 create_solib_load_event_breakpoint (hookname
, tempflag
, dll_pathname
, cond_string
)
3363 char * dll_pathname
;
3366 create_solib_load_unload_event_breakpoint (hookname
,
3374 create_solib_unload_event_breakpoint (hookname
, tempflag
, dll_pathname
, cond_string
)
3377 char * dll_pathname
;
3380 create_solib_load_unload_event_breakpoint (hookname
,
3388 create_fork_vfork_event_catchpoint (tempflag
, cond_string
, bp_kind
)
3391 enum bptype bp_kind
;
3393 struct symtab_and_line sal
;
3394 struct breakpoint
* b
;
3395 int thread
= -1; /* All threads. */
3402 b
= set_raw_breakpoint (sal
);
3403 set_breakpoint_count (breakpoint_count
+ 1);
3404 b
->number
= breakpoint_count
;
3406 b
->cond_string
= (cond_string
== NULL
) ? NULL
: savestring (cond_string
, strlen (cond_string
));
3408 b
->addr_string
= NULL
;
3409 b
->enable
= enabled
;
3410 b
->disposition
= tempflag
? del
: donttouch
;
3411 b
->forked_inferior_pid
= 0;
3419 create_fork_event_catchpoint (tempflag
, cond_string
)
3423 create_fork_vfork_event_catchpoint (tempflag
, cond_string
, bp_catch_fork
);
3427 create_vfork_event_catchpoint (tempflag
, cond_string
)
3431 create_fork_vfork_event_catchpoint (tempflag
, cond_string
, bp_catch_vfork
);
3435 create_exec_event_catchpoint (tempflag
, cond_string
)
3439 struct symtab_and_line sal
;
3440 struct breakpoint
* b
;
3441 int thread
= -1; /* All threads. */
3448 b
= set_raw_breakpoint (sal
);
3449 set_breakpoint_count (breakpoint_count
+ 1);
3450 b
->number
= breakpoint_count
;
3452 b
->cond_string
= (cond_string
== NULL
) ? NULL
: savestring (cond_string
, strlen (cond_string
));
3454 b
->addr_string
= NULL
;
3455 b
->enable
= enabled
;
3456 b
->disposition
= tempflag
? del
: donttouch
;
3458 b
->type
= bp_catch_exec
;
3464 hw_breakpoint_used_count()
3466 register struct breakpoint
*b
;
3471 if (b
->type
== bp_hardware_breakpoint
&& b
->enable
== enabled
)
3479 hw_watchpoint_used_count(type
, other_type_used
)
3481 int *other_type_used
;
3483 register struct breakpoint
*b
;
3486 *other_type_used
= 0;
3489 if (b
->enable
== enabled
)
3491 if (b
->type
== type
) i
++;
3492 else if ((b
->type
== bp_hardware_watchpoint
||
3493 b
->type
== bp_read_watchpoint
||
3494 b
->type
== bp_access_watchpoint
)
3495 && b
->enable
== enabled
)
3496 *other_type_used
= 1;
3502 /* Call this after hitting the longjmp() breakpoint. Use this to set a new
3503 breakpoint at the target of the jmp_buf.
3505 FIXME - This ought to be done by setting a temporary breakpoint that gets
3506 deleted automatically... */
3509 set_longjmp_resume_breakpoint(pc
, frame
)
3511 struct frame_info
*frame
;
3513 register struct breakpoint
*b
;
3516 if (b
->type
== bp_longjmp_resume
)
3519 b
->enable
= enabled
;
3521 b
->frame
= frame
->frame
;
3524 check_duplicates (b
->address
, b
->section
);
3530 disable_watchpoints_before_interactive_call_start ()
3532 struct breakpoint
* b
;
3536 if (((b
->type
== bp_watchpoint
)
3537 || (b
->type
== bp_hardware_watchpoint
)
3538 || (b
->type
== bp_read_watchpoint
)
3539 || (b
->type
== bp_access_watchpoint
)
3540 || ep_is_exception_catchpoint (b
))
3541 && (b
->enable
== enabled
))
3543 b
->enable
= call_disabled
;
3544 check_duplicates (b
->address
, b
->section
);
3550 enable_watchpoints_after_interactive_call_stop ()
3552 struct breakpoint
* b
;
3556 if (((b
->type
== bp_watchpoint
)
3557 || (b
->type
== bp_hardware_watchpoint
)
3558 || (b
->type
== bp_read_watchpoint
)
3559 || (b
->type
== bp_access_watchpoint
)
3560 || ep_is_exception_catchpoint (b
))
3561 && (b
->enable
== call_disabled
))
3563 b
->enable
= enabled
;
3564 check_duplicates (b
->address
, b
->section
);
3570 /* Set a breakpoint that will evaporate an end of command
3571 at address specified by SAL.
3572 Restrict it to frame FRAME if FRAME is nonzero. */
3575 set_momentary_breakpoint (sal
, frame
, type
)
3576 struct symtab_and_line sal
;
3577 struct frame_info
*frame
;
3580 register struct breakpoint
*b
;
3581 b
= set_raw_breakpoint (sal
);
3583 b
->enable
= enabled
;
3584 b
->disposition
= donttouch
;
3585 b
->frame
= (frame
? frame
->frame
: 0);
3587 /* If we're debugging a multi-threaded program, then we
3588 want momentary breakpoints to be active in only a
3589 single thread of control. */
3590 if (in_thread_list (inferior_pid
))
3591 b
->thread
= pid_to_thread_id (inferior_pid
);
3597 /* Tell the user we have just set a breakpoint B. */
3601 struct breakpoint
*b
;
3605 /* FIXME: This is misplaced; mention() is called by things (like hitting a
3606 watchpoint) other than breakpoint creation. It should be possible to
3607 clean this up and at the same time replace the random calls to
3608 breakpoint_changed with this hook, as has already been done for
3609 delete_breakpoint_hook and so on. */
3610 if (create_breakpoint_hook
)
3611 create_breakpoint_hook (b
);
3616 printf_filtered ("(apparently deleted?) Eventpoint %d: ", b
->number
);
3619 printf_filtered ("Watchpoint %d: ", b
->number
);
3620 print_expression (b
->exp
, gdb_stdout
);
3622 case bp_hardware_watchpoint
:
3623 printf_filtered ("Hardware watchpoint %d: ", b
->number
);
3624 print_expression (b
->exp
, gdb_stdout
);
3626 case bp_read_watchpoint
:
3627 printf_filtered ("Hardware read watchpoint %d: ", b
->number
);
3628 print_expression (b
->exp
, gdb_stdout
);
3630 case bp_access_watchpoint
:
3631 printf_filtered ("Hardware access (read/write) watchpoint %d: ",b
->number
);
3632 print_expression (b
->exp
, gdb_stdout
);
3635 printf_filtered ("Breakpoint %d", b
->number
);
3638 case bp_hardware_breakpoint
:
3639 printf_filtered ("Hardware assisted breakpoint %d", b
->number
);
3643 case bp_catch_unload
:
3644 printf_filtered ("Catchpoint %d (%s %s)",
3646 (b
->type
== bp_catch_load
) ? "load" : "unload",
3647 (b
->dll_pathname
!= NULL
) ? b
->dll_pathname
: "<any library>");
3650 case bp_catch_vfork
:
3651 printf_filtered ("Catchpoint %d (%s)",
3653 (b
->type
== bp_catch_fork
) ? "fork" : "vfork");
3656 printf_filtered ("Catchpoint %d (exec)",
3659 case bp_catch_catch
:
3660 case bp_catch_throw
:
3661 printf_filtered ("Catchpoint %d (%s)",
3663 (b
->type
== bp_catch_catch
) ? "catch" : "throw");
3669 case bp_longjmp_resume
:
3670 case bp_step_resume
:
3671 case bp_through_sigtramp
:
3673 case bp_watchpoint_scope
:
3674 case bp_shlib_event
:
3679 if (addressprint
|| b
->source_file
== NULL
)
3681 printf_filtered (" at ");
3682 print_address_numeric (b
->address
, 1, gdb_stdout
);
3685 printf_filtered (": file %s, line %d.",
3686 b
->source_file
, b
->line_number
);
3687 TUIDO(((TuiOpaqueFuncPtr
)tui_vAllSetHasBreakAt
, b
, 1));
3688 TUIDO(((TuiOpaqueFuncPtr
)tuiUpdateAllExecInfos
));
3690 printf_filtered ("\n");
3694 /* Set a breakpoint according to ARG (function, linenum or *address)
3695 flag: first bit : 0 non-temporary, 1 temporary.
3696 second bit : 0 normal breakpoint, 1 hardware breakpoint. */
3699 break_command_1 (arg
, flag
, from_tty
)
3703 int tempflag
, hardwareflag
;
3704 struct symtabs_and_lines sals
;
3705 struct symtab_and_line sal
;
3706 register struct expression
*cond
= 0;
3707 register struct breakpoint
*b
;
3709 /* Pointers in arg to the start, and one past the end, of the condition. */
3710 char *cond_start
= NULL
;
3711 char *cond_end
= NULL
;
3712 /* Pointers in arg to the start, and one past the end,
3713 of the address part. */
3714 char *addr_start
= NULL
;
3715 char *addr_end
= NULL
;
3716 struct cleanup
*old_chain
;
3717 struct cleanup
*canonical_strings_chain
= NULL
;
3718 char **canonical
= (char **)NULL
;
3722 hardwareflag
= flag
& BP_HARDWAREFLAG
;
3723 tempflag
= flag
& BP_TEMPFLAG
;
3728 INIT_SAL (&sal
); /* initialize to zeroes */
3730 /* If no arg given, or if first arg is 'if ', use the default breakpoint. */
3732 if (!arg
|| (arg
[0] == 'i' && arg
[1] == 'f'
3733 && (arg
[2] == ' ' || arg
[2] == '\t')))
3735 if (default_breakpoint_valid
)
3737 sals
.sals
= (struct symtab_and_line
*)
3738 xmalloc (sizeof (struct symtab_and_line
));
3739 sal
.pc
= default_breakpoint_address
;
3740 sal
.line
= default_breakpoint_line
;
3741 sal
.symtab
= default_breakpoint_symtab
;
3742 sal
.section
= find_pc_overlay (sal
.pc
);
3747 error ("No default breakpoint address now.");
3753 /* Force almost all breakpoints to be in terms of the
3754 current_source_symtab (which is decode_line_1's default). This
3755 should produce the results we want almost all of the time while
3756 leaving default_breakpoint_* alone. */
3757 if (default_breakpoint_valid
3758 && (!current_source_symtab
3759 || (arg
&& (*arg
== '+' || *arg
== '-'))))
3760 sals
= decode_line_1 (&arg
, 1, default_breakpoint_symtab
,
3761 default_breakpoint_line
, &canonical
);
3763 sals
= decode_line_1 (&arg
, 1, (struct symtab
*)NULL
, 0, &canonical
);
3771 /* Make sure that all storage allocated in decode_line_1 gets freed in case
3772 the following `for' loop errors out. */
3773 old_chain
= make_cleanup (free
, sals
.sals
);
3774 if (canonical
!= (char **)NULL
)
3776 make_cleanup (free
, canonical
);
3777 canonical_strings_chain
= make_cleanup (null_cleanup
, 0);
3778 for (i
= 0; i
< sals
.nelts
; i
++)
3780 if (canonical
[i
] != NULL
)
3781 make_cleanup (free
, canonical
[i
]);
3785 thread
= -1; /* No specific thread yet */
3787 /* Resolve all line numbers to PC's, and verify that conditions
3788 can be parsed, before setting any breakpoints. */
3789 for (i
= 0; i
< sals
.nelts
; i
++)
3791 char *tok
, *end_tok
;
3794 resolve_sal_pc (&sals
.sals
[i
]);
3796 /* It's possible for the PC to be nonzero, but still an illegal
3797 value on some targets.
3799 For example, on HP-UX if you start gdb, and before running the
3800 inferior you try to set a breakpoint on a shared library function
3801 "foo" where the inferior doesn't call "foo" directly but does
3802 pass its address to another function call, then we do find a
3803 minimal symbol for the "foo", but it's address is invalid.
3804 (Appears to be an index into a table that the loader sets up
3805 when the inferior is run.)
3807 Give the target a chance to bless sals.sals[i].pc before we
3808 try to make a breakpoint for it. */
3809 if (PC_REQUIRES_RUN_BEFORE_USE(sals
.sals
[i
].pc
))
3811 error ("Cannot break on %s without a running program.", addr_start
);
3818 while (*tok
== ' ' || *tok
== '\t')
3823 while (*end_tok
!= ' ' && *end_tok
!= '\t' && *end_tok
!= '\000')
3826 toklen
= end_tok
- tok
;
3828 if (toklen
>= 1 && strncmp (tok
, "if", toklen
) == 0)
3830 tok
= cond_start
= end_tok
+ 1;
3831 cond
= parse_exp_1 (&tok
, block_for_pc (sals
.sals
[i
].pc
), 0);
3834 else if (toklen
>= 1 && strncmp (tok
, "thread", toklen
) == 0)
3840 thread
= strtol (tok
, &tok
, 0);
3842 error ("Junk after thread keyword.");
3843 if (!valid_thread_id (thread
))
3844 error ("Unknown thread %d\n", thread
);
3847 error ("Junk at end of arguments.");
3852 int i
, target_resources_ok
;
3854 i
= hw_breakpoint_used_count ();
3855 target_resources_ok
= TARGET_CAN_USE_HARDWARE_WATCHPOINT (
3856 bp_hardware_breakpoint
, i
+ sals
.nelts
, 0);
3857 if (target_resources_ok
== 0)
3858 error ("No hardware breakpoint support in the target.");
3859 else if (target_resources_ok
< 0)
3860 error ("Hardware breakpoints used exceeds limit.");
3863 /* Remove the canonical strings from the cleanup, they are needed below. */
3864 if (canonical
!= (char **)NULL
)
3865 discard_cleanups (canonical_strings_chain
);
3867 /* Now set all the breakpoints. */
3868 for (i
= 0; i
< sals
.nelts
; i
++)
3873 describe_other_breakpoints (sal
.pc
, sal
.section
);
3875 b
= set_raw_breakpoint (sal
);
3876 set_breakpoint_count (breakpoint_count
+ 1);
3877 b
->number
= breakpoint_count
;
3878 b
->type
= hardwareflag
? bp_hardware_breakpoint
: bp_breakpoint
;
3882 /* If a canonical line spec is needed use that instead of the
3884 if (canonical
!= (char **)NULL
&& canonical
[i
] != NULL
)
3885 b
->addr_string
= canonical
[i
];
3886 else if (addr_start
)
3887 b
->addr_string
= savestring (addr_start
, addr_end
- addr_start
);
3889 b
->cond_string
= savestring (cond_start
, cond_end
- cond_start
);
3891 b
->enable
= enabled
;
3892 b
->disposition
= tempflag
? del
: donttouch
;
3898 printf_filtered ("Multiple breakpoints were set.\n");
3899 printf_filtered ("Use the \"delete\" command to delete unwanted breakpoints.\n");
3901 do_cleanups (old_chain
);
3905 break_at_finish_at_depth_command_1 (arg
, flag
, from_tty
)
3910 struct frame_info
*frame
;
3911 CORE_ADDR low
, high
, selected_pc
= 0;
3912 char *extra_args
, *level_arg
, *addr_string
;
3913 int extra_args_len
= 0, if_arg
= 0;
3916 (arg
[0] == 'i' && arg
[1] == 'f' && (arg
[2] == ' ' || arg
[2] == '\t')))
3919 if (default_breakpoint_valid
)
3923 selected_pc
= selected_frame
->pc
;
3928 error ("No selected frame.");
3931 error ("No default breakpoint address now.");
3935 extra_args
= strchr (arg
, ' ');
3939 extra_args_len
= strlen (extra_args
);
3940 level_arg
= (char *) xmalloc (extra_args
- arg
);
3941 strncpy (level_arg
, arg
, extra_args
- arg
- 1);
3942 level_arg
[extra_args
- arg
- 1] = '\0';
3946 level_arg
= (char *) xmalloc (strlen (arg
) + 1);
3947 strcpy (level_arg
, arg
);
3950 frame
= parse_frame_specification (level_arg
);
3952 selected_pc
= frame
->pc
;
3959 extra_args_len
= strlen (arg
);
3964 if (find_pc_partial_function(selected_pc
, (char **)NULL
, &low
, &high
))
3966 addr_string
= (char *) xmalloc (26 + extra_args_len
);
3968 sprintf (addr_string
, "*0x%x %s", high
, extra_args
);
3970 sprintf (addr_string
, "*0x%x", high
);
3971 break_command_1 (addr_string
, flag
, from_tty
);
3975 error ("No function contains the specified address");
3978 error ("Unable to set breakpoint at procedure exit");
3983 break_at_finish_command_1 (arg
, flag
, from_tty
)
3988 char *addr_string
, *break_string
, *beg_addr_string
;
3989 CORE_ADDR low
, high
;
3990 struct symtabs_and_lines sals
;
3991 struct symtab_and_line sal
;
3992 struct cleanup
*old_chain
;
3994 int extra_args_len
= 0;
3998 (arg
[0] == 'i' && arg
[1] == 'f' && (arg
[2] == ' ' || arg
[2] == '\t')))
4000 if (default_breakpoint_valid
)
4004 addr_string
= (char *) xmalloc (15);
4005 sprintf (addr_string
, "*0x%x", selected_frame
->pc
);
4010 error ("No selected frame.");
4013 error ("No default breakpoint address now.");
4017 addr_string
= (char *) xmalloc (strlen (arg
) + 1);
4018 strcpy (addr_string
, arg
);
4024 extra_args_len
= strlen (arg
);
4029 /* get the stuff after the function name or address */
4030 extra_args
= strchr (arg
, ' ');
4034 extra_args_len
= strlen (extra_args
);
4041 beg_addr_string
= addr_string
;
4042 sals
= decode_line_1 (&addr_string
, 1, (struct symtab
*)NULL
, 0,
4045 free (beg_addr_string
);
4046 old_chain
= make_cleanup (free
, sals
.sals
);
4047 for (i
= 0; (i
< sals
.nelts
); i
++)
4050 if (find_pc_partial_function (sal
.pc
, (char **)NULL
, &low
, &high
))
4052 break_string
= (char *) xmalloc (extra_args_len
+ 26);
4054 sprintf (break_string
, "*0x%x %s", high
, extra_args
);
4056 sprintf (break_string
, "*0x%x", high
);
4057 break_command_1 (break_string
, flag
, from_tty
);
4061 error ("No function contains the specified address");
4065 printf_filtered ("Multiple breakpoints were set.\n");
4066 printf_filtered ("Use the \"delete\" command to delete unwanted breakpoints.\n");
4068 do_cleanups(old_chain
);
4072 /* Helper function for break_command_1 and disassemble_command. */
4075 resolve_sal_pc (sal
)
4076 struct symtab_and_line
*sal
;
4080 if (sal
->pc
== 0 && sal
->symtab
!= NULL
)
4082 if (!find_line_pc (sal
->symtab
, sal
->line
, &pc
))
4083 error ("No line %d in file \"%s\".",
4084 sal
->line
, sal
->symtab
->filename
);
4088 if (sal
->section
== 0 && sal
->symtab
!= NULL
)
4090 struct blockvector
*bv
;
4095 bv
= blockvector_for_pc_sect (sal
->pc
, 0, &index
, sal
->symtab
);
4098 b
= BLOCKVECTOR_BLOCK (bv
, index
);
4099 sym
= block_function (b
);
4102 fixup_symbol_section (sym
, sal
->symtab
->objfile
);
4103 sal
->section
= SYMBOL_BFD_SECTION (sym
);
4107 /* It really is worthwhile to have the section, so we'll just
4108 have to look harder. This case can be executed if we have
4109 line numbers but no functions (as can happen in assembly
4112 struct minimal_symbol
*msym
;
4114 msym
= lookup_minimal_symbol_by_pc (sal
->pc
);
4116 sal
->section
= SYMBOL_BFD_SECTION (msym
);
4123 break_command (arg
, from_tty
)
4127 break_command_1 (arg
, 0, from_tty
);
4131 break_at_finish_command (arg
, from_tty
)
4135 break_at_finish_command_1 (arg
, 0, from_tty
);
4139 break_at_finish_at_depth_command (arg
, from_tty
)
4143 break_at_finish_at_depth_command_1 (arg
, 0, from_tty
);
4147 tbreak_command (arg
, from_tty
)
4151 break_command_1 (arg
, BP_TEMPFLAG
, from_tty
);
4155 tbreak_at_finish_command (arg
, from_tty
)
4159 break_at_finish_command_1 (arg
, BP_TEMPFLAG
, from_tty
);
4163 hbreak_command (arg
, from_tty
)
4167 break_command_1 (arg
, BP_HARDWAREFLAG
, from_tty
);
4171 thbreak_command (arg
, from_tty
)
4175 break_command_1 (arg
, (BP_TEMPFLAG
| BP_HARDWAREFLAG
), from_tty
);
4179 stop_command (arg
, from_tty
)
4183 printf_filtered ("Specify the type of breakpoint to set.\n\
4184 Usage: stop in <function | address>\n\
4189 stopin_command (arg
, from_tty
)
4195 if (arg
== (char *)NULL
)
4197 else if (*arg
!= '*')
4202 /* look for a ':'. If this is a line number specification, then say
4203 it is bad, otherwise, it should be an address or function/method
4205 while (*argptr
&& !hasColon
)
4207 hasColon
= (*argptr
== ':');
4212 badInput
= (*argptr
!= ':'); /* Not a class::method */
4214 badInput
= isdigit(*arg
); /* a simple line number */
4218 printf_filtered("Usage: stop in <function | address>\n");
4220 break_command_1 (arg
, 0, from_tty
);
4224 stopat_command (arg
, from_tty
)
4230 if (arg
== (char *)NULL
|| *arg
== '*') /* no line number */
4237 /* look for a ':'. If there is a '::' then get out, otherwise
4238 it is probably a line number. */
4239 while (*argptr
&& !hasColon
)
4241 hasColon
= (*argptr
== ':');
4246 badInput
= (*argptr
== ':'); /* we have class::method */
4248 badInput
= !isdigit(*arg
); /* not a line number */
4252 printf_filtered("Usage: stop at <line>\n");
4254 break_command_1 (arg
, 0, from_tty
);
4258 /* accessflag: 0: watch write, 1: watch read, 2: watch access(read or write) */
4260 watch_command_1 (arg
, accessflag
, from_tty
)
4265 struct breakpoint
*b
;
4266 struct symtab_and_line sal
;
4267 struct expression
*exp
;
4268 struct block
*exp_valid_block
;
4269 struct value
*val
, *mark
;
4270 struct frame_info
*frame
;
4271 struct frame_info
*prev_frame
= NULL
;
4272 char *exp_start
= NULL
;
4273 char *exp_end
= NULL
;
4274 char *tok
, *end_tok
;
4276 char *cond_start
= NULL
;
4277 char *cond_end
= NULL
;
4278 struct expression
*cond
= NULL
;
4279 int i
, other_type_used
, target_resources_ok
= 0;
4280 enum bptype bp_type
;
4283 INIT_SAL (&sal
); /* initialize to zeroes */
4285 /* Parse arguments. */
4286 innermost_block
= NULL
;
4288 exp
= parse_exp_1 (&arg
, 0, 0);
4290 exp_valid_block
= innermost_block
;
4291 mark
= value_mark ();
4292 val
= evaluate_expression (exp
);
4293 release_value (val
);
4294 if (VALUE_LAZY (val
))
4295 value_fetch_lazy (val
);
4298 while (*tok
== ' ' || *tok
== '\t')
4302 while (*end_tok
!= ' ' && *end_tok
!= '\t' && *end_tok
!= '\000')
4305 toklen
= end_tok
- tok
;
4306 if (toklen
>= 1 && strncmp (tok
, "if", toklen
) == 0)
4308 tok
= cond_start
= end_tok
+ 1;
4309 cond
= parse_exp_1 (&tok
, 0, 0);
4313 error("Junk at end of command.");
4315 if (accessflag
== 1) bp_type
= bp_read_watchpoint
;
4316 else if (accessflag
== 2) bp_type
= bp_access_watchpoint
;
4317 else bp_type
= bp_hardware_watchpoint
;
4319 mem_cnt
= can_use_hardware_watchpoint (val
);
4320 if (mem_cnt
== 0 && bp_type
!= bp_hardware_watchpoint
)
4321 error ("Expression cannot be implemented with read/access watchpoint.");
4323 i
= hw_watchpoint_used_count (bp_type
, &other_type_used
);
4324 target_resources_ok
= TARGET_CAN_USE_HARDWARE_WATCHPOINT(
4325 bp_type
, i
+ mem_cnt
, other_type_used
);
4326 if (target_resources_ok
== 0 && bp_type
!= bp_hardware_watchpoint
)
4327 error ("Target does not have this type of hardware watchpoint support.");
4328 if (target_resources_ok
< 0 && bp_type
!= bp_hardware_watchpoint
)
4329 error ("Target resources have been allocated for other types of watchpoints.");
4332 #if defined(HPUXHPPA)
4333 /* On HP-UX if you set a h/w
4334 watchpoint before the "run" command, the inferior dies with a e.g.,
4335 SIGILL once you start it. I initially believed this was due to a
4336 bad interaction between page protection traps and the initial
4337 startup sequence by the dynamic linker.
4339 However, I tried avoiding that by having HP-UX's implementation of
4340 TARGET_CAN_USE_HW_WATCHPOINT return FALSE if there was no inferior_pid
4341 yet, which forced slow watches before a "run" or "attach", and it
4342 still fails somewhere in the startup code.
4344 Until I figure out what's happening, I'm disallowing watches altogether
4345 before the "run" or "attach" command. We'll tell the user they must
4346 set watches after getting the program started. */
4347 if (! target_has_execution
)
4349 warning ("can't do that without a running program; try \"break main\", \"run\" first");
4352 #endif /* HPUXHPPA */
4354 /* Now set up the breakpoint. */
4355 b
= set_raw_breakpoint (sal
);
4356 set_breakpoint_count (breakpoint_count
+ 1);
4357 b
->number
= breakpoint_count
;
4358 b
->disposition
= donttouch
;
4360 b
->exp_valid_block
= exp_valid_block
;
4361 b
->exp_string
= savestring (exp_start
, exp_end
- exp_start
);
4365 b
->cond_string
= savestring (cond_start
, cond_end
- cond_start
);
4369 frame
= block_innermost_frame (exp_valid_block
);
4372 prev_frame
= get_prev_frame (frame
);
4373 b
->watchpoint_frame
= frame
->frame
;
4376 b
->watchpoint_frame
= (CORE_ADDR
)0;
4378 if (mem_cnt
&& target_resources_ok
> 0)
4381 b
->type
= bp_watchpoint
;
4383 /* If the expression is "local", then set up a "watchpoint scope"
4384 breakpoint at the point where we've left the scope of the watchpoint
4386 if (innermost_block
)
4390 struct breakpoint
*scope_breakpoint
;
4391 struct symtab_and_line scope_sal
;
4393 INIT_SAL (&scope_sal
); /* initialize to zeroes */
4394 scope_sal
.pc
= get_frame_pc (prev_frame
);
4395 scope_sal
.section
= find_pc_overlay (scope_sal
.pc
);
4397 scope_breakpoint
= set_raw_breakpoint (scope_sal
);
4398 set_breakpoint_count (breakpoint_count
+ 1);
4399 scope_breakpoint
->number
= breakpoint_count
;
4401 scope_breakpoint
->type
= bp_watchpoint_scope
;
4402 scope_breakpoint
->enable
= enabled
;
4404 /* Automatically delete the breakpoint when it hits. */
4405 scope_breakpoint
->disposition
= del
;
4407 /* Only break in the proper frame (help with recursion). */
4408 scope_breakpoint
->frame
= prev_frame
->frame
;
4410 /* Set the address at which we will stop. */
4411 scope_breakpoint
->address
= get_frame_pc (prev_frame
);
4413 /* The scope breakpoint is related to the watchpoint. We
4414 will need to act on them together. */
4415 b
->related_breakpoint
= scope_breakpoint
;
4418 value_free_to_mark (mark
);
4422 /* Return count of locations need to be watched and can be handled
4423 in hardware. If the watchpoint can not be handled
4424 in hardware return zero. */
4426 #if !defined(TARGET_REGION_SIZE_OK_FOR_HW_WATCHPOINT)
4427 #define TARGET_REGION_SIZE_OK_FOR_HW_WATCHPOINT(byte_size) \
4428 ((byte_size) <= (REGISTER_SIZE))
4432 can_use_hardware_watchpoint (v
)
4435 int found_memory_cnt
= 0;
4437 /* Did the user specifically forbid us to use hardware watchpoints? */
4438 if (! can_use_hw_watchpoints
)
4441 /* Make sure all the intermediate values are in memory. Also make sure
4442 we found at least one memory expression. Guards against watch 0x12345,
4443 which is meaningless, but could cause errors if one tries to insert a
4444 hardware watchpoint for the constant expression. */
4445 for ( ; v
; v
= v
->next
)
4447 if (v
->lval
== lval_memory
)
4449 if (TARGET_REGION_SIZE_OK_FOR_HW_WATCHPOINT (TYPE_LENGTH (VALUE_TYPE (v
))))
4452 else if (v
->lval
!= not_lval
&& v
->modifiable
== 0)
4456 /* The expression itself looks suitable for using a hardware
4457 watchpoint, but give the target machine a chance to reject it. */
4458 return found_memory_cnt
;
4461 static void watch_command (arg
, from_tty
)
4465 watch_command_1 (arg
, 0, from_tty
);
4468 static void rwatch_command (arg
, from_tty
)
4472 watch_command_1 (arg
, 1, from_tty
);
4475 static void awatch_command (arg
, from_tty
)
4479 watch_command_1 (arg
, 2, from_tty
);
4483 /* Helper routine for the until_command routine in infcmd.c. Here
4484 because it uses the mechanisms of breakpoints. */
4488 until_break_command (arg
, from_tty
)
4492 struct symtabs_and_lines sals
;
4493 struct symtab_and_line sal
;
4494 struct frame_info
*prev_frame
= get_prev_frame (selected_frame
);
4495 struct breakpoint
*breakpoint
;
4496 struct cleanup
*old_chain
;
4498 clear_proceed_status ();
4500 /* Set a breakpoint where the user wants it and at return from
4503 if (default_breakpoint_valid
)
4504 sals
= decode_line_1 (&arg
, 1, default_breakpoint_symtab
,
4505 default_breakpoint_line
, (char ***)NULL
);
4507 sals
= decode_line_1 (&arg
, 1, (struct symtab
*)NULL
, 0, (char ***)NULL
);
4509 if (sals
.nelts
!= 1)
4510 error ("Couldn't get information on specified line.");
4513 free ((PTR
)sals
.sals
); /* malloc'd, so freed */
4516 error ("Junk at end of arguments.");
4518 resolve_sal_pc (&sal
);
4520 breakpoint
= set_momentary_breakpoint (sal
, selected_frame
, bp_until
);
4522 old_chain
= make_cleanup ((make_cleanup_func
) delete_breakpoint
, breakpoint
);
4524 /* Keep within the current frame */
4528 sal
= find_pc_line (prev_frame
->pc
, 0);
4529 sal
.pc
= prev_frame
->pc
;
4530 breakpoint
= set_momentary_breakpoint (sal
, prev_frame
, bp_until
);
4531 make_cleanup ((make_cleanup_func
) delete_breakpoint
, breakpoint
);
4534 proceed (-1, TARGET_SIGNAL_DEFAULT
, 0);
4535 do_cleanups(old_chain
);
4539 /* These aren't used; I don't konw what they were for. */
4540 /* Set a breakpoint at the catch clause for NAME. */
4542 catch_breakpoint (name
)
4548 disable_catch_breakpoint ()
4553 delete_catch_breakpoint ()
4558 enable_catch_breakpoint ()
4565 struct sal_chain
*next
;
4566 struct symtab_and_line sal
;
4570 /* Not really used -- invocation in handle_gnu_4_16_catch_command
4571 had been commented out in the v.4.16 sources, and stays
4572 disabled there now because "catch NAME" syntax isn't allowed.
4574 /* This isn't used; I don't know what it was for. */
4575 /* For each catch clause identified in ARGS, run FUNCTION
4576 with that clause as an argument. */
4577 static struct symtabs_and_lines
4578 map_catch_names (args
, function
)
4582 register char *p
= args
;
4584 struct symtabs_and_lines sals
;
4586 struct sal_chain
*sal_chain
= 0;
4590 error_no_arg ("one or more catch names");
4598 /* Don't swallow conditional part. */
4599 if (p1
[0] == 'i' && p1
[1] == 'f'
4600 && (p1
[2] == ' ' || p1
[2] == '\t'))
4606 while (isalnum (*p1
) || *p1
== '_' || *p1
== '$')
4610 if (*p1
&& *p1
!= ' ' && *p1
!= '\t')
4611 error ("Arguments must be catch names.");
4617 struct sal_chain
*next
= (struct sal_chain
*)
4618 alloca (sizeof (struct sal_chain
));
4619 next
->next
= sal_chain
;
4620 next
->sal
= get_catch_sal (p
);
4625 printf_unfiltered ("No catch clause for exception %s.\n", p
);
4630 while (*p
== ' ' || *p
== '\t') p
++;
4635 /* This shares a lot of code with `print_frame_label_vars' from stack.c. */
4637 static struct symtabs_and_lines
4638 get_catch_sals (this_level_only
)
4639 int this_level_only
;
4641 register struct blockvector
*bl
;
4642 register struct block
*block
;
4643 int index
, have_default
= 0;
4645 struct symtabs_and_lines sals
;
4646 struct sal_chain
*sal_chain
= 0;
4647 char *blocks_searched
;
4649 /* Not sure whether an error message is always the correct response,
4650 but it's better than a core dump. */
4651 if (selected_frame
== NULL
)
4652 error ("No selected frame.");
4653 block
= get_frame_block (selected_frame
);
4654 pc
= selected_frame
->pc
;
4660 error ("No symbol table info available.\n");
4662 bl
= blockvector_for_pc (BLOCK_END (block
) - 4, &index
);
4663 blocks_searched
= (char *) alloca (BLOCKVECTOR_NBLOCKS (bl
) * sizeof (char));
4664 memset (blocks_searched
, 0, BLOCKVECTOR_NBLOCKS (bl
) * sizeof (char));
4668 CORE_ADDR end
= BLOCK_END (block
) - 4;
4671 if (bl
!= blockvector_for_pc (end
, &index
))
4672 error ("blockvector blotch");
4673 if (BLOCKVECTOR_BLOCK (bl
, index
) != block
)
4674 error ("blockvector botch");
4675 last_index
= BLOCKVECTOR_NBLOCKS (bl
);
4678 /* Don't print out blocks that have gone by. */
4679 while (index
< last_index
4680 && BLOCK_END (BLOCKVECTOR_BLOCK (bl
, index
)) < pc
)
4683 while (index
< last_index
4684 && BLOCK_END (BLOCKVECTOR_BLOCK (bl
, index
)) < end
)
4686 if (blocks_searched
[index
] == 0)
4688 struct block
*b
= BLOCKVECTOR_BLOCK (bl
, index
);
4691 register struct symbol
*sym
;
4693 nsyms
= BLOCK_NSYMS (b
);
4695 for (i
= 0; i
< nsyms
; i
++)
4697 sym
= BLOCK_SYM (b
, i
);
4698 if (STREQ (SYMBOL_NAME (sym
), "default"))
4704 if (SYMBOL_CLASS (sym
) == LOC_LABEL
)
4706 struct sal_chain
*next
= (struct sal_chain
*)
4707 alloca (sizeof (struct sal_chain
));
4708 next
->next
= sal_chain
;
4709 next
->sal
= find_pc_line (SYMBOL_VALUE_ADDRESS (sym
), 0);
4713 blocks_searched
[index
] = 1;
4719 if (sal_chain
&& this_level_only
)
4722 /* After handling the function's top-level block, stop.
4723 Don't continue to its superblock, the block of
4724 per-file symbols. */
4725 if (BLOCK_FUNCTION (block
))
4727 block
= BLOCK_SUPERBLOCK (block
);
4732 struct sal_chain
*tmp_chain
;
4734 /* Count the number of entries. */
4735 for (index
= 0, tmp_chain
= sal_chain
; tmp_chain
;
4736 tmp_chain
= tmp_chain
->next
)
4740 sals
.sals
= (struct symtab_and_line
*)
4741 xmalloc (index
* sizeof (struct symtab_and_line
));
4742 for (index
= 0; sal_chain
; sal_chain
= sal_chain
->next
, index
++)
4743 sals
.sals
[index
] = sal_chain
->sal
;
4750 ep_skip_leading_whitespace (s
)
4753 if ((s
== NULL
) || (*s
== NULL
))
4755 while (isspace(**s
))
4759 /* This function examines a string, and attempts to find a token
4760 that might be an event name in the leading characters. If a
4761 possible match is found, a pointer to the last character of
4762 the token is returned. Else, NULL is returned. */
4764 ep_find_event_name_end (arg
)
4768 char * event_name_end
= NULL
;
4770 /* If we could depend upon the presense of strrpbrk, we'd use that... */
4774 /* We break out of the loop when we find a token delimiter.
4775 Basically, we're looking for alphanumerics and underscores;
4776 anything else delimites the token. */
4779 if (! isalnum(*s
) && (*s
!= '_'))
4785 return event_name_end
;
4789 /* This function attempts to parse an optional "if <cond>" clause
4790 from the arg string. If one is not found, it returns NULL.
4792 Else, it returns a pointer to the condition string. (It does not
4793 attempt to evaluate the string against a particular block.) And,
4794 it updates arg to point to the first character following the parsed
4795 if clause in the arg string. */
4797 ep_parse_optional_if_clause (arg
)
4802 if (((*arg
)[0] != 'i') || ((*arg
)[1] != 'f') || !isspace((*arg
)[2]))
4805 /* Skip the "if" keyword. */
4808 /* Skip any extra leading whitespace, and record the start of the
4809 condition string. */
4810 ep_skip_leading_whitespace (arg
);
4813 /* Assume that the condition occupies the remainder of the arg string. */
4814 (*arg
) += strlen (cond_string
);
4819 /* This function attempts to parse an optional filename from the arg
4820 string. If one is not found, it returns NULL.
4822 Else, it returns a pointer to the parsed filename. (This function
4823 makes no attempt to verify that a file of that name exists, or is
4824 accessible.) And, it updates arg to point to the first character
4825 following the parsed filename in the arg string.
4827 Note that clients needing to preserve the returned filename for
4828 future access should copy it to their own buffers. */
4830 ep_parse_optional_filename (arg
)
4833 static char filename
[1024];
4834 char * arg_p
= *arg
;
4838 if ((*arg_p
== '\0') || isspace (*arg_p
))
4856 /* Commands to deal with catching events, such as signals, exceptions,
4857 process start/exit, etc. */
4859 typedef enum {catch_fork
, catch_vfork
} catch_fork_kind
;
4861 static void catch_fork_command_1
PARAMS ((catch_fork_kind fork_kind
, char *arg
, int tempflag
, int from_tty
));
4864 catch_fork_command_1 (fork_kind
, arg
, tempflag
, from_tty
)
4865 catch_fork_kind fork_kind
;
4870 char * cond_string
= NULL
;
4872 ep_skip_leading_whitespace (&arg
);
4874 /* The allowed syntax is:
4876 catch [v]fork if <cond>
4878 First, check if there's an if clause. */
4879 cond_string
= ep_parse_optional_if_clause (&arg
);
4881 if ((*arg
!= '\0') && !isspace (*arg
))
4882 error ("Junk at end of arguments.");
4884 /* If this target supports it, create a fork or vfork catchpoint
4885 and enable reporting of such events. */
4886 switch (fork_kind
) {
4888 create_fork_event_catchpoint (tempflag
, cond_string
);
4891 create_vfork_event_catchpoint (tempflag
, cond_string
);
4894 error ("unsupported or unknown fork kind; cannot catch it");
4900 catch_exec_command_1 (arg
, tempflag
, from_tty
)
4905 char * cond_string
= NULL
;
4907 ep_skip_leading_whitespace (&arg
);
4909 /* The allowed syntax is:
4911 catch exec if <cond>
4913 First, check if there's an if clause. */
4914 cond_string
= ep_parse_optional_if_clause (&arg
);
4916 if ((*arg
!= '\0') && !isspace (*arg
))
4917 error ("Junk at end of arguments.");
4919 /* If this target supports it, create an exec catchpoint
4920 and enable reporting of such events. */
4921 create_exec_event_catchpoint (tempflag
, cond_string
);
4924 #if defined(SOLIB_ADD)
4926 catch_load_command_1 (arg
, tempflag
, from_tty
)
4931 char * dll_pathname
= NULL
;
4932 char * cond_string
= NULL
;
4934 ep_skip_leading_whitespace (&arg
);
4936 /* The allowed syntax is:
4938 catch load if <cond>
4939 catch load <filename>
4940 catch load <filename> if <cond>
4942 The user is not allowed to specify the <filename> after an
4945 We'll ignore the pathological case of a file named "if".
4947 First, check if there's an if clause. If so, then there
4948 cannot be a filename. */
4949 cond_string
= ep_parse_optional_if_clause (&arg
);
4951 /* If there was an if clause, then there cannot be a filename.
4952 Else, there might be a filename and an if clause. */
4953 if (cond_string
== NULL
)
4955 dll_pathname
= ep_parse_optional_filename (&arg
);
4956 ep_skip_leading_whitespace (&arg
);
4957 cond_string
= ep_parse_optional_if_clause (&arg
);
4960 if ((*arg
!= '\0') && !isspace (*arg
))
4961 error ("Junk at end of arguments.");
4963 /* Create a load breakpoint that only triggers when a load of
4964 the specified dll (or any dll, if no pathname was specified)
4966 SOLIB_CREATE_CATCH_LOAD_HOOK (inferior_pid
, tempflag
, dll_pathname
, cond_string
);
4970 catch_unload_command_1 (arg
, tempflag
, from_tty
)
4975 char * dll_pathname
= NULL
;
4976 char * cond_string
= NULL
;
4978 ep_skip_leading_whitespace (&arg
);
4980 /* The allowed syntax is:
4982 catch unload if <cond>
4983 catch unload <filename>
4984 catch unload <filename> if <cond>
4986 The user is not allowed to specify the <filename> after an
4989 We'll ignore the pathological case of a file named "if".
4991 First, check if there's an if clause. If so, then there
4992 cannot be a filename. */
4993 cond_string
= ep_parse_optional_if_clause (&arg
);
4995 /* If there was an if clause, then there cannot be a filename.
4996 Else, there might be a filename and an if clause. */
4997 if (cond_string
== NULL
)
4999 dll_pathname
= ep_parse_optional_filename (&arg
);
5000 ep_skip_leading_whitespace (&arg
);
5001 cond_string
= ep_parse_optional_if_clause (&arg
);
5004 if ((*arg
!= '\0') && !isspace (*arg
))
5005 error ("Junk at end of arguments.");
5007 /* Create an unload breakpoint that only triggers when an unload of
5008 the specified dll (or any dll, if no pathname was specified)
5010 SOLIB_CREATE_CATCH_UNLOAD_HOOK (inferior_pid
, tempflag
, dll_pathname
, cond_string
);
5012 #endif /* SOLIB_ADD */
5014 /* Commands to deal with catching exceptions. */
5016 /* Set a breakpoint at the specified callback routine for an
5017 exception event callback */
5020 create_exception_catchpoint (tempflag
, cond_string
, ex_event
, sal
)
5023 enum exception_event_kind ex_event
;
5024 struct symtab_and_line
*sal
;
5026 struct breakpoint
* b
;
5028 int thread
= -1; /* All threads. */
5030 if (!sal
) /* no exception support? */
5033 b
= set_raw_breakpoint (*sal
);
5034 set_breakpoint_count (breakpoint_count
+ 1);
5035 b
->number
= breakpoint_count
;
5037 b
->cond_string
= (cond_string
== NULL
) ? NULL
: savestring (cond_string
, strlen (cond_string
));
5039 b
->addr_string
= NULL
;
5040 b
->enable
= enabled
;
5041 b
->disposition
= tempflag
? del
: donttouch
;
5044 case EX_EVENT_THROW
:
5045 b
->type
= bp_catch_throw
;
5047 case EX_EVENT_CATCH
:
5048 b
->type
= bp_catch_catch
;
5050 default: /* error condition */
5052 b
->enable
= disabled
;
5053 error ("Internal error -- invalid catchpoint kind");
5058 /* Deal with "catch catch" and "catch throw" commands */
5061 catch_exception_command_1 (ex_event
, arg
, tempflag
, from_tty
)
5062 enum exception_event_kind ex_event
;
5067 char * cond_string
= NULL
;
5068 struct symtab_and_line
* sal
= NULL
;
5070 ep_skip_leading_whitespace (&arg
);
5072 cond_string
= ep_parse_optional_if_clause (&arg
);
5074 if ((*arg
!= '\0') && !isspace (*arg
))
5075 error ("Junk at end of arguments.");
5077 if ((ex_event
!= EX_EVENT_THROW
) &&
5078 (ex_event
!= EX_EVENT_CATCH
))
5079 error ("Unsupported or unknown exception event; cannot catch it");
5081 /* See if we can find a callback routine */
5082 sal
= target_enable_exception_callback (ex_event
, 1);
5086 /* We have callbacks from the runtime system for exceptions.
5087 Set a breakpoint on the sal found, if no errors */
5088 if (sal
!= (struct symtab_and_line
*) -1)
5089 create_exception_catchpoint (tempflag
, cond_string
, ex_event
, sal
);
5091 return; /* something went wrong with setting up callbacks */
5095 /* No callbacks from runtime system for exceptions.
5096 Try GNU C++ exception breakpoints using labels in debug info. */
5097 if (ex_event
== EX_EVENT_CATCH
)
5099 handle_gnu_4_16_catch_command (arg
, tempflag
, from_tty
);
5101 else if (ex_event
== EX_EVENT_THROW
)
5103 /* Set a breakpoint on __raise_exception () */
5105 fprintf_filtered (gdb_stderr
, "Unsupported with this platform/compiler combination.\n");
5106 fprintf_filtered (gdb_stderr
, "Perhaps you can achieve the effect you want by setting\n");
5107 fprintf_filtered (gdb_stderr
, "a breakpoint on __raise_exception().\n");
5112 /* Cover routine to allow wrapping target_enable_exception_catchpoints
5113 inside a catch_errors */
5116 cover_target_enable_exception_callback (arg
)
5119 args_for_catchpoint_enable
*args
= arg
;
5120 struct symtab_and_line
*sal
;
5121 sal
= target_enable_exception_callback (args
->kind
, args
->enable
);
5124 else if (sal
== (struct symtab_and_line
*) -1)
5127 return 1; /*is valid*/
5132 /* This is the original v.4.16 and earlier version of the
5133 catch_command_1() function. Now that other flavours of "catch"
5134 have been introduced, and since exception handling can be handled
5135 in other ways (through target ops) also, this is used only for the
5136 GNU C++ exception handling system.
5137 Note: Only the "catch" flavour of GDB 4.16 is handled here. The
5138 "catch NAME" is now no longer allowed in catch_command_1(). Also,
5139 there was no code in GDB 4.16 for "catch throw".
5141 Called from catch_exception_command_1 () */
5145 handle_gnu_4_16_catch_command (arg
, tempflag
, from_tty
)
5150 /* First, translate ARG into something we can deal with in terms
5153 struct symtabs_and_lines sals
;
5154 struct symtab_and_line sal
;
5155 register struct expression
*cond
= 0;
5156 register struct breakpoint
*b
;
5160 INIT_SAL (&sal
); /* initialize to zeroes */
5162 /* If no arg given, or if first arg is 'if ', all active catch clauses
5163 are breakpointed. */
5165 if (!arg
|| (arg
[0] == 'i' && arg
[1] == 'f'
5166 && (arg
[2] == ' ' || arg
[2] == '\t')))
5168 /* Grab all active catch clauses. */
5169 sals
= get_catch_sals (0);
5173 /* Grab selected catch clauses. */
5174 error ("catch NAME not implemented");
5177 /* Not sure why this code has been disabled. I'm leaving
5178 it disabled. We can never come here now anyway
5179 since we don't allow the "catch NAME" syntax.
5182 /* This isn't used; I don't know what it was for. */
5183 sals
= map_catch_names (arg
, catch_breakpoint
);
5191 for (i
= 0; i
< sals
.nelts
; i
++)
5193 resolve_sal_pc (&sals
.sals
[i
]);
5197 if (arg
[0] == 'i' && arg
[1] == 'f'
5198 && (arg
[2] == ' ' || arg
[2] == '\t'))
5199 cond
= parse_exp_1 ((arg
+= 2, &arg
),
5200 block_for_pc (sals
.sals
[i
].pc
), 0);
5202 error ("Junk at end of arguments.");
5207 for (i
= 0; i
< sals
.nelts
; i
++)
5212 describe_other_breakpoints (sal
.pc
, sal
.section
);
5214 b
= set_raw_breakpoint (sal
);
5215 set_breakpoint_count (breakpoint_count
+ 1);
5216 b
->number
= breakpoint_count
;
5217 b
->type
= bp_breakpoint
; /* Important -- this is an ordinary breakpoint.
5218 For platforms with callback support for exceptions,
5219 create_exception_catchpoint() will create special
5220 bp types (bp_catch_catch and bp_catch_throw), and
5221 there is code in insert_breakpoints() and elsewhere
5222 that depends on that. */
5225 b
->enable
= enabled
;
5226 b
->disposition
= tempflag
? del
: donttouch
;
5233 printf_unfiltered ("Multiple breakpoints were set.\n");
5234 printf_unfiltered ("Use the \"delete\" command to delete unwanted breakpoints.\n");
5236 free ((PTR
)sals
.sals
);
5240 /* This creates a temporary internal breakpoint
5241 just to placate infrun */
5242 static struct breakpoint
*
5243 create_temp_exception_breakpoint (pc
)
5246 struct symtab_and_line sal
;
5247 struct breakpoint
*b
;
5254 b
= set_raw_breakpoint (sal
);
5256 error ("Internal error -- couldn't set temp exception breakpoint");
5258 b
->type
= bp_breakpoint
;
5259 b
->disposition
= del
;
5260 b
->enable
= enabled
;
5262 b
->number
= internal_breakpoint_number
--;
5268 catch_command_1 (arg
, tempflag
, from_tty
)
5274 /* The first argument may be an event name, such as "start" or "load".
5275 If so, then handle it as such. If it doesn't match an event name,
5276 then attempt to interpret it as an exception name. (This latter is
5277 the v4.16-and-earlier GDB meaning of the "catch" command.)
5279 First, try to find the bounds of what might be an event name. */
5280 char * arg1_start
= arg
;
5284 if (arg1_start
== NULL
)
5286 /* Old behaviour was to use pre-v-4.16 syntax */
5287 /* catch_throw_command_1 (arg1_start, tempflag, from_tty); */
5289 /* Now, this is not allowed */
5290 error ("Catch requires an event name.");
5293 arg1_end
= ep_find_event_name_end (arg1_start
);
5294 if (arg1_end
== NULL
)
5295 error ("catch requires an event");
5296 arg1_length
= arg1_end
+ 1 - arg1_start
;
5298 /* Try to match what we found against known event names. */
5299 if (strncmp (arg1_start
, "signal", arg1_length
) == 0)
5301 error ("Catch of signal not yet implemented");
5303 else if (strncmp (arg1_start
, "catch", arg1_length
) == 0)
5305 catch_exception_command_1 (EX_EVENT_CATCH
, arg1_end
+1, tempflag
, from_tty
);
5307 else if (strncmp (arg1_start
, "throw", arg1_length
) == 0)
5309 catch_exception_command_1 (EX_EVENT_THROW
, arg1_end
+1, tempflag
, from_tty
);
5311 else if (strncmp (arg1_start
, "thread_start", arg1_length
) == 0)
5313 error ("Catch of thread_start not yet implemented");
5315 else if (strncmp (arg1_start
, "thread_exit", arg1_length
) == 0)
5317 error ("Catch of thread_exit not yet implemented");
5319 else if (strncmp (arg1_start
, "thread_join", arg1_length
) == 0)
5321 error ("Catch of thread_join not yet implemented");
5323 else if (strncmp (arg1_start
, "start", arg1_length
) == 0)
5325 error ("Catch of start not yet implemented");
5327 else if (strncmp (arg1_start
, "exit", arg1_length
) == 0)
5329 error ("Catch of exit not yet implemented");
5331 else if (strncmp (arg1_start
, "fork", arg1_length
) == 0)
5333 #if defined(CHILD_INSERT_FORK_CATCHPOINT)
5334 catch_fork_command_1 (catch_fork
, arg1_end
+1, tempflag
, from_tty
);
5336 error ("Catch of fork not yet implemented");
5339 else if (strncmp (arg1_start
, "vfork", arg1_length
) == 0)
5341 #if defined(CHILD_INSERT_VFORK_CATCHPOINT)
5342 catch_fork_command_1 (catch_vfork
, arg1_end
+1, tempflag
, from_tty
);
5344 error ("Catch of vfork not yet implemented");
5347 else if (strncmp (arg1_start
, "exec", arg1_length
) == 0)
5349 #if defined(CHILD_INSERT_EXEC_CATCHPOINT)
5350 catch_exec_command_1 (arg1_end
+1, tempflag
, from_tty
);
5352 error ("Catch of exec not yet implemented");
5355 else if (strncmp (arg1_start
, "load", arg1_length
) == 0)
5357 #if defined(SOLIB_ADD)
5358 catch_load_command_1 (arg1_end
+1, tempflag
, from_tty
);
5360 error ("Catch of load not implemented");
5363 else if (strncmp (arg1_start
, "unload", arg1_length
) == 0)
5365 #if defined(SOLIB_ADD)
5366 catch_unload_command_1 (arg1_end
+1, tempflag
, from_tty
);
5368 error ("Catch of load not implemented");
5371 else if (strncmp (arg1_start
, "stop", arg1_length
) == 0)
5373 error ("Catch of stop not yet implemented");
5376 /* This doesn't appear to be an event name */
5380 /* Pre-v.4.16 behaviour was to treat the argument
5381 as the name of an exception */
5382 /* catch_throw_command_1 (arg1_start, tempflag, from_tty); */
5383 /* Now this is not allowed */
5384 error ("Unknown event kind specified for catch");
5389 /* Used by the gui, could be made a worker for other things. */
5392 set_breakpoint_sal (sal
)
5393 struct symtab_and_line sal
;
5395 struct breakpoint
*b
;
5396 b
= set_raw_breakpoint (sal
);
5397 set_breakpoint_count (breakpoint_count
+ 1);
5398 b
->number
= breakpoint_count
;
5399 b
->type
= bp_breakpoint
;
5406 /* These aren't used; I don't know what they were for. */
5407 /* Disable breakpoints on all catch clauses described in ARGS. */
5409 disable_catch (args
)
5412 /* Map the disable command to catch clauses described in ARGS. */
5415 /* Enable breakpoints on all catch clauses described in ARGS. */
5420 /* Map the disable command to catch clauses described in ARGS. */
5423 /* Delete breakpoints on all catch clauses in the active scope. */
5428 /* Map the delete command to catch clauses described in ARGS. */
5433 catch_command (arg
, from_tty
)
5437 catch_command_1 (arg
, 0, from_tty
);
5442 tcatch_command (arg
, from_tty
)
5446 catch_command_1 (arg
, 1, from_tty
);
5451 clear_command (arg
, from_tty
)
5455 register struct breakpoint
*b
, *b1
;
5457 struct symtabs_and_lines sals
;
5458 struct symtab_and_line sal
;
5459 register struct breakpoint
*found
;
5464 sals
= decode_line_spec (arg
, 1);
5469 sals
.sals
= (struct symtab_and_line
*)
5470 xmalloc (sizeof (struct symtab_and_line
));
5471 INIT_SAL (&sal
); /* initialize to zeroes */
5472 sal
.line
= default_breakpoint_line
;
5473 sal
.symtab
= default_breakpoint_symtab
;
5474 sal
.pc
= default_breakpoint_address
;
5475 if (sal
.symtab
== 0)
5476 error ("No source file specified.");
5484 /* For each line spec given, delete bps which correspond
5485 to it. We do this in two loops: the first loop looks at
5486 the initial bp(s) in the chain which should be deleted,
5487 the second goes down the rest of the chain looking ahead
5488 one so it can take those bps off the chain without messing
5492 for (i
= 0; i
< sals
.nelts
; i
++)
5494 /* If exact pc given, clear bpts at that pc.
5495 If line given (pc == 0), clear all bpts on specified line.
5496 If defaulting, clear all bpts on default line
5499 defaulting sal.pc != 0 tests to do
5504 1 0 <can't happen> */
5507 found
= (struct breakpoint
*) 0;
5510 while (breakpoint_chain
5511 /* Why don't we check here that this is not
5512 a watchpoint, etc., as we do below?
5513 I can't make it fail, but don't know
5514 what's stopping the failure: a watchpoint
5515 of the same address as "sal.pc" should
5516 wind up being deleted. */
5518 && ( ((sal
.pc
&& (breakpoint_chain
->address
== sal
.pc
)) &&
5519 (overlay_debugging
== 0 ||
5520 breakpoint_chain
->section
== sal
.section
))
5521 || ((default_match
|| (0 == sal
.pc
))
5522 && breakpoint_chain
->source_file
!= NULL
5523 && sal
.symtab
!= NULL
5524 && STREQ (breakpoint_chain
->source_file
, sal
.symtab
->filename
)
5525 && breakpoint_chain
->line_number
== sal
.line
)))
5528 b1
= breakpoint_chain
;
5529 breakpoint_chain
= b1
->next
;
5537 && b
->next
->type
!= bp_none
5538 && b
->next
->type
!= bp_watchpoint
5539 && b
->next
->type
!= bp_hardware_watchpoint
5540 && b
->next
->type
!= bp_read_watchpoint
5541 && b
->next
->type
!= bp_access_watchpoint
5542 && ( ((sal
.pc
&& (b
->next
->address
== sal
.pc
)) &&
5543 (overlay_debugging
== 0 ||
5544 b
->next
->section
== sal
.section
))
5545 || ((default_match
|| (0 == sal
.pc
))
5546 && b
->next
->source_file
!= NULL
5547 && sal
.symtab
!= NULL
5548 && STREQ (b
->next
->source_file
, sal
.symtab
->filename
)
5549 && b
->next
->line_number
== sal
.line
)))
5562 error ("No breakpoint at %s.", arg
);
5564 error ("No breakpoint at this line.");
5567 if (found
->next
) from_tty
= 1; /* Always report if deleted more than one */
5568 if (from_tty
) printf_unfiltered ("Deleted breakpoint%s ", found
->next
? "s" : "");
5569 breakpoints_changed ();
5572 if (from_tty
) printf_unfiltered ("%d ", found
->number
);
5574 delete_breakpoint (found
);
5577 if (from_tty
) putchar_unfiltered ('\n');
5579 free ((PTR
)sals
.sals
);
5582 /* Delete breakpoint in BS if they are `delete' breakpoints and
5583 all breakpoints that are marked for deletion, whether hit or not.
5584 This is called after any breakpoint is hit, or after errors. */
5587 breakpoint_auto_delete (bs
)
5590 struct breakpoint
*b
, *temp
;
5592 for (; bs
; bs
= bs
->next
)
5593 if (bs
->breakpoint_at
&& bs
->breakpoint_at
->disposition
== del
5595 delete_breakpoint (bs
->breakpoint_at
);
5597 ALL_BREAKPOINTS_SAFE (b
, temp
)
5599 if (b
->disposition
== del_at_next_stop
)
5600 delete_breakpoint (b
);
5604 /* Delete a breakpoint and clean up all traces of it in the data structures. */
5607 delete_breakpoint (bpt
)
5608 struct breakpoint
*bpt
;
5610 register struct breakpoint
*b
;
5614 error ("Internal error (attempted to delete a NULL breakpoint)");
5617 /* Has this bp already been deleted? This can happen because multiple
5618 lists can hold pointers to bp's. bpstat lists are especial culprits.
5620 One example of this happening is a watchpoint's scope bp. When the
5621 scope bp triggers, we notice that the watchpoint is out of scope, and
5622 delete it. We also delete its scope bp. But the scope bp is marked
5623 "auto-deleting", and is already on a bpstat. That bpstat is then
5624 checked for auto-deleting bp's, which are deleted.
5626 A real solution to this problem might involve reference counts in bp's,
5627 and/or giving them pointers back to their referencing bpstat's, and
5628 teaching delete_breakpoint to only free a bp's storage when no more
5629 references were extent. A cheaper bandaid was chosen. */
5630 if (bpt
->type
== bp_none
)
5633 if (delete_breakpoint_hook
)
5634 delete_breakpoint_hook (bpt
);
5637 remove_breakpoint (bpt
, mark_uninserted
);
5639 if (breakpoint_chain
== bpt
)
5640 breakpoint_chain
= bpt
->next
;
5642 /* If we have callback-style exception catchpoints, don't go through
5643 the adjustments to the C++ runtime library etc. if the inferior
5644 isn't actually running. target_enable_exception_callback for a
5645 null target ops vector gives an undesirable error message, so we
5646 check here and avoid it. Since currently (1997-09-17) only HP-UX aCC's
5647 exceptions are supported in this way, it's OK for now. FIXME */
5648 if (ep_is_exception_catchpoint (bpt
) && target_has_execution
)
5650 static char message1
[] = "Error in deleting catchpoint %d:\n";
5651 static char message
[sizeof (message1
) + 30];
5652 args_for_catchpoint_enable args
;
5654 sprintf (message
, message1
, bpt
->number
); /* Format possible error msg */
5655 args
.kind
= bpt
->type
== bp_catch_catch
? EX_EVENT_CATCH
: EX_EVENT_THROW
;
5657 catch_errors (cover_target_enable_exception_callback
, &args
,
5658 message
, RETURN_MASK_ALL
);
5665 b
->next
= bpt
->next
;
5669 /* Before turning off the visuals for the bp, check to see that
5670 there are no other bps at the same address. */
5677 clearIt
= (b
->address
!= bpt
->address
);
5684 TUIDO(((TuiOpaqueFuncPtr
)tui_vAllSetHasBreakAt
, bpt
, 0));
5685 TUIDO(((TuiOpaqueFuncPtr
)tuiUpdateAllExecInfos
));
5689 check_duplicates (bpt
->address
, bpt
->section
);
5690 /* If this breakpoint was inserted, and there is another breakpoint
5691 at the same address, we need to insert the other breakpoint. */
5693 && bpt
->type
!= bp_hardware_watchpoint
5694 && bpt
->type
!= bp_read_watchpoint
5695 && bpt
->type
!= bp_access_watchpoint
5696 && bpt
->type
!= bp_catch_fork
5697 && bpt
->type
!= bp_catch_vfork
5698 && bpt
->type
!= bp_catch_exec
)
5701 if (b
->address
== bpt
->address
5702 && b
->section
== bpt
->section
5704 && b
->enable
!= disabled
5705 && b
->enable
!= shlib_disabled
5706 && b
->enable
!= call_disabled
)
5709 val
= target_insert_breakpoint (b
->address
, b
->shadow_contents
);
5712 target_terminal_ours_for_output ();
5713 fprintf_unfiltered (gdb_stderr
, "Cannot insert breakpoint %d:\n", b
->number
);
5714 memory_error (val
, b
->address
); /* which bombs us out */
5721 free_command_lines (&bpt
->commands
);
5724 if (bpt
->cond_string
!= NULL
)
5725 free (bpt
->cond_string
);
5726 if (bpt
->addr_string
!= NULL
)
5727 free (bpt
->addr_string
);
5728 if (bpt
->exp
!= NULL
)
5730 if (bpt
->exp_string
!= NULL
)
5731 free (bpt
->exp_string
);
5732 if (bpt
->val
!= NULL
)
5733 value_free (bpt
->val
);
5734 if (bpt
->source_file
!= NULL
)
5735 free (bpt
->source_file
);
5736 if (bpt
->dll_pathname
!= NULL
)
5737 free (bpt
->dll_pathname
);
5738 if (bpt
->triggered_dll_pathname
!= NULL
)
5739 free (bpt
->triggered_dll_pathname
);
5740 if (bpt
->exec_pathname
!= NULL
)
5741 free (bpt
->exec_pathname
);
5743 /* Be sure no bpstat's are pointing at it after it's been freed. */
5744 /* FIXME, how can we find all bpstat's?
5745 We just check stop_bpstat for now. */
5746 for (bs
= stop_bpstat
; bs
; bs
= bs
->next
)
5747 if (bs
->breakpoint_at
== bpt
)
5749 bs
->breakpoint_at
= NULL
;
5751 /* we'd call bpstat_clear_actions, but that free's stuff and due
5752 to the multiple pointers pointing to one item with no
5753 reference counts found anywhere through out the bpstat's (how
5754 do you spell fragile?), we don't want to free things twice --
5755 better a memory leak than a corrupt malloc pool! */
5756 bs
->commands
= NULL
;
5759 /* On the chance that someone will soon try again to delete this same
5760 bp, we mark it as deleted before freeing its storage. */
5761 bpt
->type
= bp_none
;
5767 delete_command (arg
, from_tty
)
5771 struct breakpoint
*b
, *temp
;
5775 int breaks_to_delete
= 0;
5777 /* Delete all breakpoints if no argument.
5778 Do not delete internal or call-dummy breakpoints, these
5779 have to be deleted with an explicit breakpoint number argument. */
5782 if (b
->type
!= bp_call_dummy
&&
5783 b
->type
!= bp_shlib_event
&&
5785 breaks_to_delete
= 1;
5788 /* Ask user only if there are some breakpoints to delete. */
5790 || (breaks_to_delete
&& query ("Delete all breakpoints? ")))
5792 ALL_BREAKPOINTS_SAFE (b
, temp
)
5794 if (b
->type
!= bp_call_dummy
&&
5795 b
->type
!= bp_shlib_event
&&
5797 delete_breakpoint (b
);
5802 map_breakpoint_numbers (arg
, delete_breakpoint
);
5805 /* Reset a breakpoint given it's struct breakpoint * BINT.
5806 The value we return ends up being the return value from catch_errors.
5807 Unused in this case. */
5810 breakpoint_re_set_one (bint
)
5813 struct breakpoint
*b
= (struct breakpoint
*)bint
; /* get past catch_errs */
5816 struct symtabs_and_lines sals
;
5818 enum enable save_enable
;
5823 warning ("attempted to reset apparently deleted breakpoint #%d?\n", b
->number
);
5826 case bp_hardware_breakpoint
:
5828 case bp_catch_unload
:
5829 if (b
->addr_string
== NULL
)
5831 /* Anything without a string can't be re-set. */
5832 delete_breakpoint (b
);
5835 /* In case we have a problem, disable this breakpoint. We'll restore
5836 its status if we succeed. */
5837 save_enable
= b
->enable
;
5838 b
->enable
= disabled
;
5840 set_language (b
->language
);
5841 input_radix
= b
->input_radix
;
5843 sals
= decode_line_1 (&s
, 1, (struct symtab
*)NULL
, 0, (char ***)NULL
);
5844 for (i
= 0; i
< sals
.nelts
; i
++)
5846 resolve_sal_pc (&sals
.sals
[i
]);
5848 /* Reparse conditions, they might contain references to the
5850 if (b
->cond_string
!= NULL
)
5854 free ((PTR
)b
->cond
);
5855 b
->cond
= parse_exp_1 (&s
, block_for_pc (sals
.sals
[i
].pc
), 0);
5858 /* We need to re-set the breakpoint if the address changes...*/
5859 if (b
->address
!= sals
.sals
[i
].pc
5860 /* ...or new and old breakpoints both have source files, and
5861 the source file name or the line number changes... */
5862 || (b
->source_file
!= NULL
5863 && sals
.sals
[i
].symtab
!= NULL
5864 && (!STREQ (b
->source_file
, sals
.sals
[i
].symtab
->filename
)
5865 || b
->line_number
!= sals
.sals
[i
].line
)
5867 /* ...or we switch between having a source file and not having
5869 || ((b
->source_file
== NULL
) != (sals
.sals
[i
].symtab
== NULL
))
5872 if (b
->source_file
!= NULL
)
5873 free (b
->source_file
);
5874 if (sals
.sals
[i
].symtab
== NULL
)
5875 b
->source_file
= NULL
;
5878 savestring (sals
.sals
[i
].symtab
->filename
,
5879 strlen (sals
.sals
[i
].symtab
->filename
));
5880 b
->line_number
= sals
.sals
[i
].line
;
5881 b
->address
= sals
.sals
[i
].pc
;
5883 /* Used to check for duplicates here, but that can
5884 cause trouble, as it doesn't check for disable
5889 /* Might be better to do this just once per breakpoint_re_set,
5890 rather than once for every breakpoint. */
5891 breakpoints_changed ();
5893 b
->section
= sals
.sals
[i
].section
;
5894 b
->enable
= save_enable
; /* Restore it, this worked. */
5897 /* Now that this is re-enabled, check_duplicates
5899 check_duplicates (b
->address
, b
->section
);
5902 free ((PTR
)sals
.sals
);
5906 case bp_hardware_watchpoint
:
5907 case bp_read_watchpoint
:
5908 case bp_access_watchpoint
:
5909 innermost_block
= NULL
;
5910 /* The issue arises of what context to evaluate this in. The same
5911 one as when it was set, but what does that mean when symbols have
5912 been re-read? We could save the filename and functionname, but
5913 if the context is more local than that, the best we could do would
5914 be something like how many levels deep and which index at that
5915 particular level, but that's going to be less stable than filenames
5916 or functionnames. */
5917 /* So for now, just use a global context. */
5920 b
->exp
= parse_expression (b
->exp_string
);
5921 b
->exp_valid_block
= innermost_block
;
5922 mark
= value_mark ();
5924 value_free (b
->val
);
5925 b
->val
= evaluate_expression (b
->exp
);
5926 release_value (b
->val
);
5927 if (VALUE_LAZY (b
->val
))
5928 value_fetch_lazy (b
->val
);
5930 if (b
->cond_string
!= NULL
)
5934 free ((PTR
)b
->cond
);
5935 b
->cond
= parse_exp_1 (&s
, (struct block
*)0, 0);
5937 if (b
->enable
== enabled
)
5939 value_free_to_mark (mark
);
5941 case bp_catch_catch
:
5942 case bp_catch_throw
:
5944 /* We needn't really do anything to reset these, since the mask
5945 that requests them is unaffected by e.g., new libraries being
5948 case bp_catch_vfork
:
5953 printf_filtered ("Deleting unknown breakpoint type %d\n", b
->type
);
5955 /* Delete longjmp breakpoints, they will be reset later by
5956 breakpoint_re_set. */
5958 case bp_longjmp_resume
:
5959 delete_breakpoint (b
);
5962 /* This breakpoint is special, it's set up when the inferior
5963 starts and we really don't want to touch it. */
5964 case bp_shlib_event
:
5966 /* Keep temporary breakpoints, which can be encountered when we step
5967 over a dlopen call and SOLIB_ADD is resetting the breakpoints.
5968 Otherwise these should have been blown away via the cleanup chain
5969 or by breakpoint_init_inferior when we rerun the executable. */
5972 case bp_watchpoint_scope
:
5974 case bp_step_resume
:
5981 /* Re-set all breakpoints after symbols have been re-loaded. */
5983 breakpoint_re_set ()
5985 struct breakpoint
*b
, *temp
;
5986 enum language save_language
;
5987 int save_input_radix
;
5988 static char message1
[] = "Error in re-setting breakpoint %d:\n";
5989 char message
[sizeof (message1
) + 30 /* slop */];
5991 save_language
= current_language
->la_language
;
5992 save_input_radix
= input_radix
;
5993 ALL_BREAKPOINTS_SAFE (b
, temp
)
5995 sprintf (message
, message1
, b
->number
); /* Format possible error msg */
5996 catch_errors (breakpoint_re_set_one
, b
, message
, RETURN_MASK_ALL
);
5998 set_language (save_language
);
5999 input_radix
= save_input_radix
;
6001 #ifdef GET_LONGJMP_TARGET
6002 create_longjmp_breakpoint ("longjmp");
6003 create_longjmp_breakpoint ("_longjmp");
6004 create_longjmp_breakpoint ("siglongjmp");
6005 create_longjmp_breakpoint ("_siglongjmp");
6006 create_longjmp_breakpoint (NULL
);
6010 /* Took this out (temporarily at least), since it produces an extra
6011 blank line at startup. This messes up the gdbtests. -PB */
6012 /* Blank line to finish off all those mention() messages we just printed. */
6013 printf_filtered ("\n");
6017 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
6018 If from_tty is nonzero, it prints a message to that effect,
6019 which ends with a period (no newline). */
6021 /* Reset the thread number of this breakpoint:
6023 - If the breakpoint is for all threads, leave it as-is.
6024 - Else, reset it to the current thread for inferior_pid. */
6026 breakpoint_re_set_thread (b
)
6027 struct breakpoint
* b
;
6029 if (b
->thread
!= -1)
6031 if (in_thread_list (inferior_pid
))
6032 b
->thread
= pid_to_thread_id (inferior_pid
);
6037 set_ignore_count (bptnum
, count
, from_tty
)
6038 int bptnum
, count
, from_tty
;
6040 register struct breakpoint
*b
;
6046 if (b
->number
== bptnum
)
6048 b
->ignore_count
= count
;
6051 else if (count
== 0)
6052 printf_filtered ("Will stop next time breakpoint %d is reached.",
6054 else if (count
== 1)
6055 printf_filtered ("Will ignore next crossing of breakpoint %d.",
6058 printf_filtered ("Will ignore next %d crossings of breakpoint %d.",
6060 breakpoints_changed ();
6064 error ("No breakpoint number %d.", bptnum
);
6067 /* Clear the ignore counts of all breakpoints. */
6069 breakpoint_clear_ignore_counts ()
6071 struct breakpoint
*b
;
6074 b
->ignore_count
= 0;
6077 /* Command to set ignore-count of breakpoint N to COUNT. */
6080 ignore_command (args
, from_tty
)
6088 error_no_arg ("a breakpoint number");
6090 num
= get_number (&p
);
6093 error ("Second argument (specified ignore-count) is missing.");
6095 set_ignore_count (num
,
6096 longest_to_int (value_as_long (parse_and_eval (p
))),
6098 printf_filtered ("\n");
6099 breakpoints_changed ();
6102 /* Call FUNCTION on each of the breakpoints
6103 whose numbers are given in ARGS. */
6106 map_breakpoint_numbers (args
, function
)
6108 void (*function
) PARAMS ((struct breakpoint
*));
6110 register char *p
= args
;
6113 register struct breakpoint
*b
;
6116 error_no_arg ("one or more breakpoint numbers");
6122 num
= get_number (&p1
);
6125 if (b
->number
== num
)
6127 struct breakpoint
*related_breakpoint
= b
->related_breakpoint
;
6129 if (related_breakpoint
)
6130 function (related_breakpoint
);
6133 printf_unfiltered ("No breakpoint number %d.\n", num
);
6140 disable_breakpoint (bpt
)
6141 struct breakpoint
*bpt
;
6143 /* Never disable a watchpoint scope breakpoint; we want to
6144 hit them when we leave scope so we can delete both the
6145 watchpoint and its scope breakpoint at that time. */
6146 if (bpt
->type
== bp_watchpoint_scope
)
6149 bpt
->enable
= disabled
;
6151 check_duplicates (bpt
->address
, bpt
->section
);
6153 if (modify_breakpoint_hook
)
6154 modify_breakpoint_hook (bpt
);
6159 disable_command (args
, from_tty
)
6163 register struct breakpoint
*bpt
;
6165 ALL_BREAKPOINTS (bpt
)
6169 warning ("attempted to disable apparently deleted breakpoint #%d?\n", bpt
->number
);
6173 case bp_catch_unload
:
6175 case bp_catch_vfork
:
6177 case bp_catch_catch
:
6178 case bp_catch_throw
:
6179 case bp_hardware_breakpoint
:
6181 case bp_hardware_watchpoint
:
6182 case bp_read_watchpoint
:
6183 case bp_access_watchpoint
:
6184 disable_breakpoint (bpt
);
6189 map_breakpoint_numbers (args
, disable_breakpoint
);
6193 do_enable_breakpoint (bpt
, disposition
)
6194 struct breakpoint
*bpt
;
6195 enum bpdisp disposition
;
6197 struct frame_info
*save_selected_frame
= NULL
;
6198 int save_selected_frame_level
= -1;
6199 int target_resources_ok
, other_type_used
;
6202 if (bpt
->type
== bp_hardware_breakpoint
)
6205 i
= hw_breakpoint_used_count();
6206 target_resources_ok
= TARGET_CAN_USE_HARDWARE_WATCHPOINT(
6207 bp_hardware_breakpoint
, i
+1, 0);
6208 if (target_resources_ok
== 0)
6209 error ("No hardware breakpoint support in the target.");
6210 else if (target_resources_ok
< 0)
6211 error ("Hardware breakpoints used exceeds limit.");
6214 bpt
->enable
= enabled
;
6215 bpt
->disposition
= disposition
;
6216 check_duplicates (bpt
->address
, bpt
->section
);
6217 breakpoints_changed ();
6219 if (bpt
->type
== bp_watchpoint
|| bpt
->type
== bp_hardware_watchpoint
||
6220 bpt
->type
== bp_read_watchpoint
|| bpt
->type
== bp_access_watchpoint
)
6222 if (bpt
->exp_valid_block
!= NULL
)
6224 struct frame_info
*fr
=
6226 /* Ensure that we have the current frame. Else, this
6227 next query may pessimistically be answered as, "No,
6228 not within current scope". */
6229 get_current_frame ();
6230 fr
= find_frame_addr_in_frame_chain (bpt
->watchpoint_frame
);
6234 Cannot enable watchpoint %d because the block in which its expression\n\
6235 is valid is not currently in scope.\n", bpt
->number
);
6236 bpt
->enable
= disabled
;
6240 save_selected_frame
= selected_frame
;
6241 save_selected_frame_level
= selected_frame_level
;
6242 select_frame (fr
, -1);
6245 value_free (bpt
->val
);
6246 mark
= value_mark ();
6247 bpt
->val
= evaluate_expression (bpt
->exp
);
6248 release_value (bpt
->val
);
6249 if (VALUE_LAZY (bpt
->val
))
6250 value_fetch_lazy (bpt
->val
);
6252 if (bpt
->type
== bp_hardware_watchpoint
||
6253 bpt
->type
== bp_read_watchpoint
||
6254 bpt
->type
== bp_access_watchpoint
)
6256 int i
= hw_watchpoint_used_count (bpt
->type
, &other_type_used
);
6257 int mem_cnt
= can_use_hardware_watchpoint (bpt
->val
);
6259 /* Hack around 'unused var' error for some targets here */
6261 target_resources_ok
= TARGET_CAN_USE_HARDWARE_WATCHPOINT(
6262 bpt
->type
, i
+ mem_cnt
, other_type_used
);
6263 /* we can consider of type is bp_hardware_watchpoint, convert to
6264 bp_watchpoint in the following condition */
6265 if (target_resources_ok
< 0)
6268 Cannot enable watchpoint %d because target watch resources\n\
6269 have been allocated for other watchpoints.\n", bpt
->number
);
6270 bpt
->enable
= disabled
;
6271 value_free_to_mark (mark
);
6276 if (save_selected_frame_level
>= 0)
6277 select_and_print_frame (save_selected_frame
, save_selected_frame_level
);
6278 value_free_to_mark (mark
);
6280 if (modify_breakpoint_hook
)
6281 modify_breakpoint_hook (bpt
);
6285 enable_breakpoint (bpt
)
6286 struct breakpoint
*bpt
;
6288 do_enable_breakpoint (bpt
, bpt
->disposition
);
6291 /* The enable command enables the specified breakpoints (or all defined
6292 breakpoints) so they once again become (or continue to be) effective
6293 in stopping the inferior. */
6297 enable_command (args
, from_tty
)
6301 register struct breakpoint
*bpt
;
6303 ALL_BREAKPOINTS (bpt
)
6307 warning ("attempted to enable apparently deleted breakpoint #%d?\n", bpt
->number
);
6311 case bp_catch_unload
:
6313 case bp_catch_vfork
:
6315 case bp_catch_catch
:
6316 case bp_catch_throw
:
6317 case bp_hardware_breakpoint
:
6319 case bp_hardware_watchpoint
:
6320 case bp_read_watchpoint
:
6321 case bp_access_watchpoint
:
6322 enable_breakpoint (bpt
);
6327 map_breakpoint_numbers (args
, enable_breakpoint
);
6331 enable_once_breakpoint (bpt
)
6332 struct breakpoint
*bpt
;
6334 do_enable_breakpoint (bpt
, disable
);
6339 enable_once_command (args
, from_tty
)
6343 map_breakpoint_numbers (args
, enable_once_breakpoint
);
6347 enable_delete_breakpoint (bpt
)
6348 struct breakpoint
*bpt
;
6350 do_enable_breakpoint (bpt
, del
);
6355 enable_delete_command (args
, from_tty
)
6359 map_breakpoint_numbers (args
, enable_delete_breakpoint
);
6362 /* Use default_breakpoint_'s, or nothing if they aren't valid. */
6364 struct symtabs_and_lines
6365 decode_line_spec_1 (string
, funfirstline
)
6369 struct symtabs_and_lines sals
;
6371 error ("Empty line specification.");
6372 if (default_breakpoint_valid
)
6373 sals
= decode_line_1 (&string
, funfirstline
,
6374 default_breakpoint_symtab
, default_breakpoint_line
,
6377 sals
= decode_line_1 (&string
, funfirstline
,
6378 (struct symtab
*)NULL
, 0, (char ***)NULL
);
6380 error ("Junk at end of line specification: %s", string
);
6385 _initialize_breakpoint ()
6387 struct cmd_list_element
*c
;
6389 breakpoint_chain
= 0;
6390 /* Don't bother to call set_breakpoint_count. $bpnum isn't useful
6391 before a breakpoint is set. */
6392 breakpoint_count
= 0;
6394 add_com ("ignore", class_breakpoint
, ignore_command
,
6395 "Set ignore-count of breakpoint number N to COUNT.\n\
6396 Usage is `ignore N COUNT'.");
6398 add_com_alias("bc", "ignore", class_breakpoint
, 1);
6400 add_com ("commands", class_breakpoint
, commands_command
,
6401 "Set commands to be executed when a breakpoint is hit.\n\
6402 Give breakpoint number as argument after \"commands\".\n\
6403 With no argument, the targeted breakpoint is the last one set.\n\
6404 The commands themselves follow starting on the next line.\n\
6405 Type a line containing \"end\" to indicate the end of them.\n\
6406 Give \"silent\" as the first line to make the breakpoint silent;\n\
6407 then no output is printed when it is hit, except what the commands print.");
6409 add_com ("condition", class_breakpoint
, condition_command
,
6410 "Specify breakpoint number N to break only if COND is true.\n\
6411 Usage is `condition N COND', where N is an integer and COND is an\n\
6412 expression to be evaluated whenever breakpoint N is reached. ");
6414 add_com ("tbreak", class_breakpoint
, tbreak_command
,
6415 "Set a temporary breakpoint. Args like \"break\" command.\n\
6416 Like \"break\" except the breakpoint is only temporary,\n\
6417 so it will be deleted when hit. Equivalent to \"break\" followed\n\
6418 by using \"enable delete\" on the breakpoint number.");
6419 add_com("txbreak", class_breakpoint
, tbreak_at_finish_command
,
6420 "Set temporary breakpoint at procedure exit. Either there should\n\
6421 be no argument or the argument must be a depth.\n");
6423 add_com ("hbreak", class_breakpoint
, hbreak_command
,
6424 "Set a hardware assisted breakpoint. Args like \"break\" command.\n\
6425 Like \"break\" except the breakpoint requires hardware support,\n\
6426 some target hardware may not have this support.");
6428 add_com ("thbreak", class_breakpoint
, thbreak_command
,
6429 "Set a temporary hardware assisted breakpoint. Args like \"break\" command.\n\
6430 Like \"hbreak\" except the breakpoint is only temporary,\n\
6431 so it will be deleted when hit.");
6433 add_prefix_cmd ("enable", class_breakpoint
, enable_command
,
6434 "Enable some breakpoints.\n\
6435 Give breakpoint numbers (separated by spaces) as arguments.\n\
6436 With no subcommand, breakpoints are enabled until you command otherwise.\n\
6437 This is used to cancel the effect of the \"disable\" command.\n\
6438 With a subcommand you can enable temporarily.",
6439 &enablelist
, "enable ", 1, &cmdlist
);
6441 add_com("ab", class_breakpoint
, enable_command
,
6442 "Enable some breakpoints.\n\
6443 Give breakpoint numbers (separated by spaces) as arguments.\n\
6444 With no subcommand, breakpoints are enabled until you command otherwise.\n\
6445 This is used to cancel the effect of the \"disable\" command.\n\
6446 With a subcommand you can enable temporarily.");
6448 add_com_alias ("en", "enable", class_breakpoint
, 1);
6450 add_abbrev_prefix_cmd ("breakpoints", class_breakpoint
, enable_command
,
6451 "Enable some breakpoints.\n\
6452 Give breakpoint numbers (separated by spaces) as arguments.\n\
6453 This is used to cancel the effect of the \"disable\" command.\n\
6454 May be abbreviated to simply \"enable\".\n",
6455 &enablebreaklist
, "enable breakpoints ", 1, &enablelist
);
6457 add_cmd ("once", no_class
, enable_once_command
,
6458 "Enable breakpoints for one hit. Give breakpoint numbers.\n\
6459 If a breakpoint is hit while enabled in this fashion, it becomes disabled.",
6462 add_cmd ("delete", no_class
, enable_delete_command
,
6463 "Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
6464 If a breakpoint is hit while enabled in this fashion, it is deleted.",
6467 add_cmd ("delete", no_class
, enable_delete_command
,
6468 "Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
6469 If a breakpoint is hit while enabled in this fashion, it is deleted.",
6472 add_cmd ("once", no_class
, enable_once_command
,
6473 "Enable breakpoints for one hit. Give breakpoint numbers.\n\
6474 If a breakpoint is hit while enabled in this fashion, it becomes disabled.",
6477 add_prefix_cmd ("disable", class_breakpoint
, disable_command
,
6478 "Disable some breakpoints.\n\
6479 Arguments are breakpoint numbers with spaces in between.\n\
6480 To disable all breakpoints, give no argument.\n\
6481 A disabled breakpoint is not forgotten, but has no effect until reenabled.",
6482 &disablelist
, "disable ", 1, &cmdlist
);
6483 add_com_alias ("dis", "disable", class_breakpoint
, 1);
6484 add_com_alias ("disa", "disable", class_breakpoint
, 1);
6486 add_com("sb", class_breakpoint
, disable_command
,
6487 "Disable some breakpoints.\n\
6488 Arguments are breakpoint numbers with spaces in between.\n\
6489 To disable all breakpoints, give no argument.\n\
6490 A disabled breakpoint is not forgotten, but has no effect until reenabled.");
6492 add_cmd ("breakpoints", class_alias
, disable_command
,
6493 "Disable some breakpoints.\n\
6494 Arguments are breakpoint numbers with spaces in between.\n\
6495 To disable all breakpoints, give no argument.\n\
6496 A disabled breakpoint is not forgotten, but has no effect until reenabled.\n\
6497 This command may be abbreviated \"disable\".",
6500 add_prefix_cmd ("delete", class_breakpoint
, delete_command
,
6501 "Delete some breakpoints or auto-display expressions.\n\
6502 Arguments are breakpoint numbers with spaces in between.\n\
6503 To delete all breakpoints, give no argument.\n\
6505 Also a prefix command for deletion of other GDB objects.\n\
6506 The \"unset\" command is also an alias for \"delete\".",
6507 &deletelist
, "delete ", 1, &cmdlist
);
6508 add_com_alias ("d", "delete", class_breakpoint
, 1);
6510 add_com ("db", class_breakpoint
, delete_command
,
6511 "Delete some breakpoints.\n\
6512 Arguments are breakpoint numbers with spaces in between.\n\
6513 To delete all breakpoints, give no argument.\n");
6515 add_cmd ("breakpoints", class_alias
, delete_command
,
6516 "Delete some breakpoints or auto-display expressions.\n\
6517 Arguments are breakpoint numbers with spaces in between.\n\
6518 To delete all breakpoints, give no argument.\n\
6519 This command may be abbreviated \"delete\".",
6522 add_com ("clear", class_breakpoint
, clear_command
,
6523 concat ("Clear breakpoint at specified line or function.\n\
6524 Argument may be line number, function name, or \"*\" and an address.\n\
6525 If line number is specified, all breakpoints in that line are cleared.\n\
6526 If function is specified, breakpoints at beginning of function are cleared.\n\
6527 If an address is specified, breakpoints at that address are cleared.\n\n",
6528 "With no argument, clears all breakpoints in the line that the selected frame\n\
6531 See also the \"delete\" command which clears breakpoints by number.", NULL
));
6533 add_com ("break", class_breakpoint
, break_command
,
6534 concat ("Set breakpoint at specified line or function.\n\
6535 Argument may be line number, function name, or \"*\" and an address.\n\
6536 If line number is specified, break at start of code for that line.\n\
6537 If function is specified, break at start of code for that function.\n\
6538 If an address is specified, break at that exact address.\n",
6539 "With no arg, uses current execution address of selected stack frame.\n\
6540 This is useful for breaking on return to a stack frame.\n\
6542 Multiple breakpoints at one place are permitted, and useful if conditional.\n\
6544 Do \"help breakpoints\" for info on other commands dealing with breakpoints.", NULL
));
6545 add_com_alias ("b", "break", class_run
, 1);
6546 add_com_alias ("br", "break", class_run
, 1);
6547 add_com_alias ("bre", "break", class_run
, 1);
6548 add_com_alias ("brea", "break", class_run
, 1);
6550 add_com("xbreak", class_breakpoint
, break_at_finish_command
,
6551 concat("Set breakpoint at procedure exit. \n\
6552 Argument may be function name, or \"*\" and an address.\n\
6553 If function is specified, break at end of code for that function.\n\
6554 If an address is specified, break at the end of the function that contains \n\
6555 that exact address.\n",
6556 "With no arg, uses current execution address of selected stack frame.\n\
6557 This is useful for breaking on return to a stack frame.\n\
6559 Multiple breakpoints at one place are permitted, and useful if conditional.\n\
6561 Do \"help breakpoints\" for info on other commands dealing with breakpoints.", NULL
));
6562 add_com_alias ("xb", "xbreak", class_breakpoint
, 1);
6563 add_com_alias ("xbr", "xbreak", class_breakpoint
, 1);
6564 add_com_alias ("xbre", "xbreak", class_breakpoint
, 1);
6565 add_com_alias ("xbrea", "xbreak", class_breakpoint
, 1);
6569 add_com_alias ("ba", "break", class_breakpoint
, 1);
6570 add_com_alias ("bu", "ubreak", class_breakpoint
, 1);
6571 add_com ("bx", class_breakpoint
, break_at_finish_at_depth_command
,
6572 "Set breakpoint at procedure exit. Either there should\n\
6573 be no argument or the argument must be a depth.\n");
6578 add_abbrev_prefix_cmd("stop", class_breakpoint
, stop_command
,
6579 "Break in function/address or break at a line in the current file.",
6580 &stoplist
, "stop ", 1, &cmdlist
);
6581 add_cmd("in", class_breakpoint
, stopin_command
,
6582 "Break in function or address.\n", &stoplist
);
6583 add_cmd("at", class_breakpoint
, stopat_command
,
6584 "Break at a line in the current file.\n", &stoplist
);
6585 add_com("status", class_info
, breakpoints_info
,
6586 concat ("Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
6587 The \"Type\" column indicates one of:\n\
6588 \tbreakpoint - normal breakpoint\n\
6589 \twatchpoint - watchpoint\n\
6590 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
6591 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
6592 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
6593 address and file/line number respectively.\n\n",
6594 "Convenience variable \"$_\" and default examine address for \"x\"\n\
6595 are set to the address of the last breakpoint listed.\n\n\
6596 Convenience variable \"$bpnum\" contains the number of the last\n\
6597 breakpoint set.", NULL
));
6600 add_info ("breakpoints", breakpoints_info
,
6601 concat ("Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
6602 The \"Type\" column indicates one of:\n\
6603 \tbreakpoint - normal breakpoint\n\
6604 \twatchpoint - watchpoint\n\
6605 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
6606 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
6607 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
6608 address and file/line number respectively.\n\n",
6609 "Convenience variable \"$_\" and default examine address for \"x\"\n\
6610 are set to the address of the last breakpoint listed.\n\n\
6611 Convenience variable \"$bpnum\" contains the number of the last\n\
6612 breakpoint set.", NULL
));
6615 add_com("lb", class_breakpoint
, breakpoints_info
,
6616 concat ("Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
6617 The \"Type\" column indicates one of:\n\
6618 \tbreakpoint - normal breakpoint\n\
6619 \twatchpoint - watchpoint\n\
6620 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
6621 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
6622 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
6623 address and file/line number respectively.\n\n",
6624 "Convenience variable \"$_\" and default examine address for \"x\"\n\
6625 are set to the address of the last breakpoint listed.\n\n\
6626 Convenience variable \"$bpnum\" contains the number of the last\n\
6627 breakpoint set.", NULL
));
6629 add_cmd ("breakpoints", class_maintenance
, maintenance_info_breakpoints
,
6630 concat ("Status of all breakpoints, or breakpoint number NUMBER.\n\
6631 The \"Type\" column indicates one of:\n\
6632 \tbreakpoint - normal breakpoint\n\
6633 \twatchpoint - watchpoint\n\
6634 \tlongjmp - internal breakpoint used to step through longjmp()\n\
6635 \tlongjmp resume - internal breakpoint at the target of longjmp()\n\
6636 \tuntil - internal breakpoint used by the \"until\" command\n\
6637 \tfinish - internal breakpoint used by the \"finish\" command\n",
6638 "The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
6639 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
6640 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
6641 address and file/line number respectively.\n\n",
6642 "Convenience variable \"$_\" and default examine address for \"x\"\n\
6643 are set to the address of the last breakpoint listed.\n\n\
6644 Convenience variable \"$bpnum\" contains the number of the last\n\
6645 breakpoint set.", NULL
),
6646 &maintenanceinfolist
);
6648 add_com ("catch", class_breakpoint
, catch_command
,
6649 "Set catchpoints to catch events.\n\
6650 Raised signals may be caught:\n\
6651 \tcatch signal - all signals\n\
6652 \tcatch signal <signame> - a particular signal\n\
6653 Raised exceptions may be caught:\n\
6654 \tcatch throw - all exceptions, when thrown\n\
6655 \tcatch throw <exceptname> - a particular exception, when thrown\n\
6656 \tcatch catch - all exceptions, when caught\n\
6657 \tcatch catch <exceptname> - a particular exception, when caught\n\
6658 Thread or process events may be caught:\n\
6659 \tcatch thread_start - any threads, just after creation\n\
6660 \tcatch thread_exit - any threads, just before expiration\n\
6661 \tcatch thread_join - any threads, just after joins\n\
6662 Process events may be caught:\n\
6663 \tcatch start - any processes, just after creation\n\
6664 \tcatch exit - any processes, just before expiration\n\
6665 \tcatch fork - calls to fork()\n\
6666 \tcatch vfork - calls to vfork()\n\
6667 \tcatch exec - calls to exec()\n\
6668 Dynamically-linked library events may be caught:\n\
6669 \tcatch load - loads of any library\n\
6670 \tcatch load <libname> - loads of a particular library\n\
6671 \tcatch unload - unloads of any library\n\
6672 \tcatch unload <libname> - unloads of a particular library\n\
6673 The act of your program's execution stopping may also be caught:\n\
6675 C++ exceptions may be caught:\n\
6676 \tcatch throw - all exceptions, when thrown\n\
6677 \tcatch catch - all exceptions, when caught\n\
6679 Do \"help set follow-fork-mode\" for info on debugging your program\n\
6680 after a fork or vfork is caught.\n\n\
6681 Do \"help breakpoints\" for info on other commands dealing with breakpoints.");
6683 add_com ("tcatch", class_breakpoint
, tcatch_command
,
6684 "Set temporary catchpoints to catch events.\n\
6685 Args like \"catch\" command.\n\
6686 Like \"catch\" except the catchpoint is only temporary,\n\
6687 so it will be deleted when hit. Equivalent to \"catch\" followed\n\
6688 by using \"enable delete\" on the catchpoint number.");
6690 add_com ("watch", class_breakpoint
, watch_command
,
6692 "Set a watchpoint for an expression.\n\
6693 A watchpoint stops execution of your program whenever the value of\n\
6694 an expression changes.");
6696 add_com ("rwatch", class_breakpoint
, rwatch_command
,
6697 "Set a read watchpoint for an expression.\n\
6698 A watchpoint stops execution of your program whenever the value of\n\
6699 an expression is read.");
6701 add_com ("awatch", class_breakpoint
, awatch_command
,
6702 "Set a watchpoint for an expression.\n\
6703 A watchpoint stops execution of your program whenever the value of\n\
6704 an expression is either read or written.");
6706 add_info ("watchpoints", breakpoints_info
,
6707 "Synonym for ``info breakpoints''.");
6710 c
= add_set_cmd ("can-use-hw-watchpoints", class_support
, var_zinteger
,
6711 (char *) &can_use_hw_watchpoints
,
6712 "Set debugger's willingness to use watchpoint hardware.\n\
6713 If zero, gdb will not use hardware for new watchpoints, even if\n\
6714 such is available. (However, any hardware watchpoints that were\n\
6715 created before setting this to nonzero, will continue to use watchpoint\n\
6718 add_show_from_set (c
, &showlist
);
6720 can_use_hw_watchpoints
= 1;