1 /* Everything about breakpoints, for GDB.
2 Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
3 1996, 1997, 1998, 1999, 2000, 2001 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,
20 Boston, MA 02111-1307, USA. */
26 #include "breakpoint.h"
28 #include "expression.h"
34 #include "gdbthread.h"
37 #include "gdb_string.h"
43 #include "completer.h"
49 #include "gdb-events.h"
51 /* Prototypes for local functions. */
53 static void until_break_command_continuation (struct continuation_arg
*arg
);
55 static void catch_command_1 (char *, int, int);
57 static void enable_delete_command (char *, int);
59 static void enable_delete_breakpoint (struct breakpoint
*);
61 static void enable_once_command (char *, int);
63 static void enable_once_breakpoint (struct breakpoint
*);
65 static void disable_command (char *, int);
67 static void enable_command (char *, int);
69 static void map_breakpoint_numbers (char *, void (*)(struct breakpoint
*));
71 static void ignore_command (char *, int);
73 static int breakpoint_re_set_one (PTR
);
75 static void clear_command (char *, int);
77 static void catch_command (char *, int);
79 static void handle_gnu_4_16_catch_command (char *, int, int);
81 static struct symtabs_and_lines
get_catch_sals (int);
83 static void watch_command (char *, int);
85 static int can_use_hardware_watchpoint (struct value
*);
87 static void break_at_finish_command (char *, int);
88 static void break_at_finish_at_depth_command (char *, int);
90 static void tbreak_at_finish_command (char *, int);
92 static void break_command_1 (char *, int, int);
94 static void mention (struct breakpoint
*);
96 struct breakpoint
*set_raw_breakpoint (struct symtab_and_line
, enum bptype
);
98 static void check_duplicates (struct breakpoint
*);
100 static void describe_other_breakpoints (CORE_ADDR
, asection
*);
102 static void breakpoints_info (char *, int);
104 static void breakpoint_1 (int, int);
106 static bpstat
bpstat_alloc (struct breakpoint
*, bpstat
);
108 static int breakpoint_cond_eval (PTR
);
110 static void cleanup_executing_breakpoints (PTR
);
112 static void commands_command (char *, int);
114 static void condition_command (char *, int);
116 static int get_number_trailer (char **, int);
118 void set_breakpoint_count (int);
121 static struct breakpoint
*create_temp_exception_breakpoint (CORE_ADDR
);
131 static int remove_breakpoint (struct breakpoint
*, insertion_state_t
);
133 static enum print_stop_action
print_it_typical (bpstat
);
135 static enum print_stop_action
print_bp_stop_message (bpstat bs
);
139 enum exception_event_kind kind
;
142 args_for_catchpoint_enable
;
144 static int watchpoint_check (PTR
);
146 static int cover_target_enable_exception_callback (PTR
);
148 static void maintenance_info_breakpoints (char *, int);
150 #ifdef GET_LONGJMP_TARGET
151 static void create_longjmp_breakpoint (char *);
154 static int hw_breakpoint_used_count (void);
156 static int hw_watchpoint_used_count (enum bptype
, int *);
158 static void hbreak_command (char *, int);
160 static void thbreak_command (char *, int);
162 static void watch_command_1 (char *, int, int);
164 static void rwatch_command (char *, int);
166 static void awatch_command (char *, int);
168 static void do_enable_breakpoint (struct breakpoint
*, enum bpdisp
);
170 static void solib_load_unload_1 (char *hookname
,
173 char *cond_string
, enum bptype bp_kind
);
175 static void create_fork_vfork_event_catchpoint (int tempflag
,
177 enum bptype bp_kind
);
179 static void break_at_finish_at_depth_command_1 (char *arg
,
180 int flag
, int from_tty
);
182 static void break_at_finish_command_1 (char *arg
, int flag
, int from_tty
);
184 static void stop_command (char *arg
, int from_tty
);
186 static void stopin_command (char *arg
, int from_tty
);
188 static void stopat_command (char *arg
, int from_tty
);
190 static char *ep_find_event_name_end (char *arg
);
192 static char *ep_parse_optional_if_clause (char **arg
);
194 static char *ep_parse_optional_filename (char **arg
);
196 #if defined(CHILD_INSERT_EXEC_CATCHPOINT)
197 static void catch_exec_command_1 (char *arg
, int tempflag
, int from_tty
);
200 static void create_exception_catchpoint (int tempflag
, char *cond_string
,
201 enum exception_event_kind ex_event
,
202 struct symtab_and_line
*sal
);
204 static void catch_exception_command_1 (enum exception_event_kind ex_event
,
205 char *arg
, int tempflag
, int from_tty
);
207 static void tcatch_command (char *arg
, int from_tty
);
209 static void ep_skip_leading_whitespace (char **s
);
211 /* Prototypes for exported functions. */
213 /* If FALSE, gdb will not use hardware support for watchpoints, even
214 if such is available. */
215 static int can_use_hw_watchpoints
;
217 void _initialize_breakpoint (void);
219 extern int addressprint
; /* Print machine addresses? */
221 static int internal_breakpoint_number
= -1;
223 /* Are we executing breakpoint commands? */
224 static int executing_breakpoint_commands
;
226 /* Walk the following statement or block through all breakpoints.
227 ALL_BREAKPOINTS_SAFE does so even if the statment deletes the current
230 #define ALL_BREAKPOINTS(B) for (B = breakpoint_chain; B; B = B->next)
232 #define ALL_BREAKPOINTS_SAFE(B,TMP) \
233 for (B = breakpoint_chain; \
234 B ? (TMP=B->next, 1): 0; \
237 /* True if SHIFT_INST_REGS defined, false otherwise. */
239 int must_shift_inst_regs
=
240 #if defined(SHIFT_INST_REGS)
247 /* True if breakpoint hit counts should be displayed in breakpoint info. */
249 int show_breakpoint_hit_counts
= 1;
251 /* Chain of all breakpoints defined. */
253 struct breakpoint
*breakpoint_chain
;
255 /* Number of last breakpoint made. */
257 int breakpoint_count
;
259 /* Pointer to current exception event record */
260 static struct exception_event_record
*current_exception_event
;
262 /* Indicator of whether exception catchpoints should be nuked
263 between runs of a program */
264 int exception_catchpoints_are_fragile
= 0;
266 /* Indicator of when exception catchpoints set-up should be
267 reinitialized -- e.g. when program is re-run */
268 int exception_support_initialized
= 0;
270 /* This function returns a pointer to the string representation of the
271 pathname of the dynamically-linked library that has just been
274 This function must be used only when SOLIB_HAVE_LOAD_EVENT is TRUE,
275 or undefined results are guaranteed.
277 This string's contents are only valid immediately after the
278 inferior has stopped in the dynamic linker hook, and becomes
279 invalid as soon as the inferior is continued. Clients should make
280 a copy of this string if they wish to continue the inferior and
281 then access the string. */
283 #ifndef SOLIB_LOADED_LIBRARY_PATHNAME
284 #define SOLIB_LOADED_LIBRARY_PATHNAME(pid) ""
287 /* This function returns a pointer to the string representation of the
288 pathname of the dynamically-linked library that has just been
291 This function must be used only when SOLIB_HAVE_UNLOAD_EVENT is
292 TRUE, or undefined results are guaranteed.
294 This string's contents are only valid immediately after the
295 inferior has stopped in the dynamic linker hook, and becomes
296 invalid as soon as the inferior is continued. Clients should make
297 a copy of this string if they wish to continue the inferior and
298 then access the string. */
300 #ifndef SOLIB_UNLOADED_LIBRARY_PATHNAME
301 #define SOLIB_UNLOADED_LIBRARY_PATHNAME(pid) ""
304 /* This function is called by the "catch load" command. It allows the
305 debugger to be notified by the dynamic linker when a specified
306 library file (or any library file, if filename is NULL) is loaded. */
308 #ifndef SOLIB_CREATE_CATCH_LOAD_HOOK
309 #define SOLIB_CREATE_CATCH_LOAD_HOOK(pid,tempflag,filename,cond_string) \
310 error ("catch of library loads not yet implemented on this platform")
313 /* This function is called by the "catch unload" command. It allows
314 the debugger to be notified by the dynamic linker when a specified
315 library file (or any library file, if filename is NULL) is
318 #ifndef SOLIB_CREATE_CATCH_UNLOAD_HOOK
319 #define SOLIB_CREATE_CATCH_UNLOAD_HOOK(pid,tempflag,filename,cond_string) \
320 error ("catch of library unloads not yet implemented on this platform")
323 /* Set breakpoint count to NUM. */
326 set_breakpoint_count (int num
)
328 breakpoint_count
= num
;
329 set_internalvar (lookup_internalvar ("bpnum"),
330 value_from_longest (builtin_type_int
, (LONGEST
) num
));
333 /* Used in run_command to zero the hit count when a new run starts. */
336 clear_breakpoint_hit_counts (void)
338 struct breakpoint
*b
;
344 /* Default address, symtab and line to put a breakpoint at
345 for "break" command with no arg.
346 if default_breakpoint_valid is zero, the other three are
347 not valid, and "break" with no arg is an error.
349 This set by print_stack_frame, which calls set_default_breakpoint. */
351 int default_breakpoint_valid
;
352 CORE_ADDR default_breakpoint_address
;
353 struct symtab
*default_breakpoint_symtab
;
354 int default_breakpoint_line
;
356 /* *PP is a string denoting a breakpoint. Get the number of the breakpoint.
357 Advance *PP after the string and any trailing whitespace.
359 Currently the string can either be a number or "$" followed by the name
360 of a convenience variable. Making it an expression wouldn't work well
361 for map_breakpoint_numbers (e.g. "4 + 5 + 6").
363 TRAILER is a character which can be found after the number; most
364 commonly this is `-'. If you don't want a trailer, use \0. */
366 get_number_trailer (char **pp
, int trailer
)
368 int retval
= 0; /* default */
372 /* Empty line means refer to the last breakpoint. */
373 return breakpoint_count
;
376 /* Make a copy of the name, so we can null-terminate it
377 to pass to lookup_internalvar(). */
382 while (isalnum (*p
) || *p
== '_')
384 varname
= (char *) alloca (p
- start
+ 1);
385 strncpy (varname
, start
, p
- start
);
386 varname
[p
- start
] = '\0';
387 val
= value_of_internalvar (lookup_internalvar (varname
));
388 if (TYPE_CODE (VALUE_TYPE (val
)) == TYPE_CODE_INT
)
389 retval
= (int) value_as_long (val
);
392 printf_filtered ("Convenience variable must have integer value.\n");
400 while (*p
>= '0' && *p
<= '9')
403 /* There is no number here. (e.g. "cond a == b"). */
405 /* Skip non-numeric token */
406 while (*p
&& !isspace((int) *p
))
408 /* Return zero, which caller must interpret as error. */
414 if (!(isspace (*p
) || *p
== '\0' || *p
== trailer
))
416 /* Trailing junk: return 0 and let caller print error msg. */
417 while (!(isspace (*p
) || *p
== '\0' || *p
== trailer
))
428 /* Like get_number_trailer, but don't allow a trailer. */
430 get_number (char **pp
)
432 return get_number_trailer (pp
, '\0');
435 /* Parse a number or a range.
436 * A number will be of the form handled by get_number.
437 * A range will be of the form <number1> - <number2>, and
438 * will represent all the integers between number1 and number2,
441 * While processing a range, this fuction is called iteratively;
442 * At each call it will return the next value in the range.
444 * At the beginning of parsing a range, the char pointer PP will
445 * be advanced past <number1> and left pointing at the '-' token.
446 * Subsequent calls will not advance the pointer until the range
447 * is completed. The call that completes the range will advance
448 * pointer PP past <number2>.
452 get_number_or_range (char **pp
)
454 static int last_retval
, end_value
;
455 static char *end_ptr
;
456 static int in_range
= 0;
460 /* Default case: pp is pointing either to a solo number,
461 or to the first number of a range. */
462 last_retval
= get_number_trailer (pp
, '-');
467 /* This is the start of a range (<number1> - <number2>).
468 Skip the '-', parse and remember the second number,
469 and also remember the end of the final token. */
473 while (isspace ((int) *end_ptr
))
474 end_ptr
++; /* skip white space */
475 end_value
= get_number (temp
);
476 if (end_value
< last_retval
)
478 error ("inverted range");
480 else if (end_value
== last_retval
)
482 /* degenerate range (number1 == number2). Advance the
483 token pointer so that the range will be treated as a
492 error ("negative value");
495 /* pp points to the '-' that betokens a range. All
496 number-parsing has already been done. Return the next
497 integer value (one greater than the saved previous value).
498 Do not advance the token pointer 'pp' until the end of range
501 if (++last_retval
== end_value
)
503 /* End of range reached; advance token pointer. */
513 /* condition N EXP -- set break condition of breakpoint N to EXP. */
516 condition_command (char *arg
, int from_tty
)
518 register struct breakpoint
*b
;
523 error_no_arg ("breakpoint number");
526 bnum
= get_number (&p
);
528 error ("Bad breakpoint argument: '%s'", arg
);
531 if (b
->number
== bnum
)
538 if (b
->cond_string
!= NULL
)
539 xfree (b
->cond_string
);
544 b
->cond_string
= NULL
;
546 printf_filtered ("Breakpoint %d now unconditional.\n", bnum
);
551 /* I don't know if it matters whether this is the string the user
552 typed in or the decompiled expression. */
553 b
->cond_string
= savestring (arg
, strlen (arg
));
554 b
->cond
= parse_exp_1 (&arg
, block_for_pc (b
->address
), 0);
556 error ("Junk at end of expression");
558 breakpoints_changed ();
562 error ("No breakpoint number %d.", bnum
);
567 commands_command (char *arg
, int from_tty
)
569 register struct breakpoint
*b
;
572 struct command_line
*l
;
574 /* If we allowed this, we would have problems with when to
575 free the storage, if we change the commands currently
578 if (executing_breakpoint_commands
)
579 error ("Can't use the \"commands\" command among a breakpoint's commands.");
582 bnum
= get_number (&p
);
585 error ("Unexpected extra arguments following breakpoint number.");
588 if (b
->number
== bnum
)
592 "Type commands for when breakpoint %d is hit, one per line.",
594 l
= read_command_lines (tmpbuf
, from_tty
);
595 free_command_lines (&b
->commands
);
597 breakpoints_changed ();
600 error ("No breakpoint number %d.", bnum
);
603 /* Like target_read_memory() but if breakpoints are inserted, return
604 the shadow contents instead of the breakpoints themselves.
606 Read "memory data" from whatever target or inferior we have.
607 Returns zero if successful, errno value if not. EIO is used
608 for address out of bounds. If breakpoints are inserted, returns
609 shadow contents, not the breakpoints themselves. From breakpoint.c. */
612 read_memory_nobpt (CORE_ADDR memaddr
, char *myaddr
, unsigned len
)
615 struct breakpoint
*b
;
616 CORE_ADDR bp_addr
= 0;
619 if (BREAKPOINT_FROM_PC (&bp_addr
, &bp_size
) == NULL
)
620 /* No breakpoints on this machine. */
621 return target_read_memory (memaddr
, myaddr
, len
);
625 if (b
->type
== bp_none
)
626 warning ("reading through apparently deleted breakpoint #%d?",
629 /* memory breakpoint? */
630 if (b
->type
== bp_watchpoint
631 || b
->type
== bp_hardware_watchpoint
632 || b
->type
== bp_read_watchpoint
633 || b
->type
== bp_access_watchpoint
)
638 /* Addresses and length of the part of the breakpoint that
640 /* XXXX The m68k, sh and h8300 have different local and remote
641 breakpoint values. BREAKPOINT_FROM_PC still manages to
642 correctly determine the breakpoints memory address and size
643 for these targets. */
644 bp_addr
= b
->address
;
646 if (BREAKPOINT_FROM_PC (&bp_addr
, &bp_size
) == NULL
)
651 if (bp_addr
+ bp_size
<= memaddr
)
652 /* The breakpoint is entirely before the chunk of memory we
655 if (bp_addr
>= memaddr
+ len
)
656 /* The breakpoint is entirely after the chunk of memory we are
659 /* Copy the breakpoint from the shadow contents, and recurse for
660 the things before and after. */
662 /* Offset within shadow_contents. */
665 if (bp_addr
< memaddr
)
667 /* Only copy the second part of the breakpoint. */
668 bp_size
-= memaddr
- bp_addr
;
669 bptoffset
= memaddr
- bp_addr
;
673 if (bp_addr
+ bp_size
> memaddr
+ len
)
675 /* Only copy the first part of the breakpoint. */
676 bp_size
-= (bp_addr
+ bp_size
) - (memaddr
+ len
);
679 memcpy (myaddr
+ bp_addr
- memaddr
,
680 b
->shadow_contents
+ bptoffset
, bp_size
);
682 if (bp_addr
> memaddr
)
684 /* Copy the section of memory before the breakpoint. */
685 status
= read_memory_nobpt (memaddr
, myaddr
, bp_addr
- memaddr
);
690 if (bp_addr
+ bp_size
< memaddr
+ len
)
692 /* Copy the section of memory after the breakpoint. */
693 status
= read_memory_nobpt (bp_addr
+ bp_size
,
694 myaddr
+ bp_addr
+ bp_size
- memaddr
,
695 memaddr
+ len
- (bp_addr
+ bp_size
));
702 /* Nothing overlaps. Just call read_memory_noerr. */
703 return target_read_memory (memaddr
, myaddr
, len
);
707 /* insert_breakpoints is used when starting or continuing the program.
708 remove_breakpoints is used when the program stops.
709 Both return zero if successful,
710 or an `errno' value if could not write the inferior. */
713 insert_breakpoints (void)
715 register struct breakpoint
*b
, *temp
;
716 int return_val
= 0; /* return success code. */
718 int disabled_breaks
= 0;
720 static char message1
[] = "Error inserting catchpoint %d:\n";
721 static char message
[sizeof (message1
) + 30];
724 ALL_BREAKPOINTS_SAFE (b
, temp
)
726 if (b
->enable_state
== bp_permanent
)
727 /* Permanent breakpoints cannot be inserted or removed. */
729 else if (b
->type
!= bp_watchpoint
730 && b
->type
!= bp_hardware_watchpoint
731 && b
->type
!= bp_read_watchpoint
732 && b
->type
!= bp_access_watchpoint
733 && b
->type
!= bp_catch_fork
734 && b
->type
!= bp_catch_vfork
735 && b
->type
!= bp_catch_exec
736 && b
->type
!= bp_catch_throw
737 && b
->type
!= bp_catch_catch
738 && b
->enable_state
!= bp_disabled
739 && b
->enable_state
!= bp_shlib_disabled
740 && b
->enable_state
!= bp_call_disabled
744 if (b
->type
== bp_hardware_breakpoint
)
745 val
= target_insert_hw_breakpoint (b
->address
, b
->shadow_contents
);
748 /* Check to see if breakpoint is in an overlay section;
749 if so, we should set the breakpoint at the LMA address.
750 Only if the section is currently mapped should we ALSO
751 set a break at the VMA address. */
752 if (overlay_debugging
&& b
->section
&&
753 section_is_overlay (b
->section
))
757 addr
= overlay_unmapped_address (b
->address
, b
->section
);
758 val
= target_insert_breakpoint (addr
, b
->shadow_contents
);
759 /* This would be the time to check val, to see if the
760 breakpoint write to the load address succeeded.
761 However, this might be an ordinary occurrance, eg. if
762 the unmapped overlay is in ROM. */
763 val
= 0; /* in case unmapped address failed */
764 if (section_is_mapped (b
->section
))
765 val
= target_insert_breakpoint (b
->address
,
768 else /* ordinary (non-overlay) address */
769 val
= target_insert_breakpoint (b
->address
, b
->shadow_contents
);
773 /* Can't set the breakpoint. */
774 #if defined (DISABLE_UNSETTABLE_BREAK)
775 if (DISABLE_UNSETTABLE_BREAK (b
->address
))
777 /* See also: disable_breakpoints_in_shlibs. */
779 b
->enable_state
= bp_shlib_disabled
;
780 if (!disabled_breaks
)
782 target_terminal_ours_for_output ();
783 warning ("Cannot insert breakpoint %d:", b
->number
);
784 warning ("Temporarily disabling shared library breakpoints:");
787 warning ("breakpoint #%d ", b
->number
);
792 target_terminal_ours_for_output ();
793 warning ("Cannot insert breakpoint %d:", b
->number
);
794 #ifdef ONE_PROCESS_WRITETEXT
795 warning ("The same program may be running in another process.");
797 memory_error (val
, b
->address
); /* which bombs us out */
804 return_val
= val
; /* remember failure */
806 else if (ep_is_exception_catchpoint (b
)
807 && b
->enable_state
!= bp_disabled
808 && b
->enable_state
!= bp_shlib_disabled
809 && b
->enable_state
!= bp_call_disabled
814 /* If we get here, we must have a callback mechanism for exception
815 events -- with g++ style embedded label support, we insert
816 ordinary breakpoints and not catchpoints. */
817 /* Format possible error message */
818 sprintf (message
, message1
, b
->number
);
820 val
= target_insert_breakpoint (b
->address
, b
->shadow_contents
);
823 /* Couldn't set breakpoint for some reason */
824 target_terminal_ours_for_output ();
825 warning ("Cannot insert catchpoint %d; disabling it.",
827 b
->enable_state
= bp_disabled
;
831 /* Bp set, now make sure callbacks are enabled */
833 args_for_catchpoint_enable args
;
834 args
.kind
= b
->type
== bp_catch_catch
?
835 EX_EVENT_CATCH
: EX_EVENT_THROW
;
837 val
= catch_errors (cover_target_enable_exception_callback
,
839 message
, RETURN_MASK_ALL
);
840 if (val
!= 0 && val
!= -1)
844 /* Check if something went wrong; val == 0 can be ignored */
847 /* something went wrong */
848 target_terminal_ours_for_output ();
849 warning ("Cannot insert catchpoint %d; disabling it.",
851 b
->enable_state
= bp_disabled
;
856 return_val
= val
; /* remember failure */
859 else if ((b
->type
== bp_hardware_watchpoint
||
860 b
->type
== bp_read_watchpoint
||
861 b
->type
== bp_access_watchpoint
)
862 && b
->enable_state
== bp_enabled
863 && b
->disposition
!= disp_del_at_next_stop
867 struct frame_info
*saved_frame
;
868 int saved_level
, within_current_scope
;
869 struct value
*mark
= value_mark ();
872 /* Save the current frame and level so we can restore it after
873 evaluating the watchpoint expression on its own frame. */
874 saved_frame
= selected_frame
;
875 saved_level
= selected_frame_level
;
877 /* Determine if the watchpoint is within scope. */
878 if (b
->exp_valid_block
== NULL
)
879 within_current_scope
= 1;
882 struct frame_info
*fi
;
884 /* There might be no current frame at this moment if we are
885 resuming from a step over a breakpoint.
886 Set up current frame before trying to find the watchpoint
888 get_current_frame ();
889 fi
= find_frame_addr_in_frame_chain (b
->watchpoint_frame
);
890 within_current_scope
= (fi
!= NULL
);
891 if (within_current_scope
)
892 select_frame (fi
, -1);
895 if (within_current_scope
)
897 /* Evaluate the expression and cut the chain of values
898 produced off from the value chain.
900 Make sure the value returned isn't lazy; we use
901 laziness to determine what memory GDB actually needed
902 in order to compute the value of the expression. */
903 v
= evaluate_expression (b
->exp
);
905 value_release_to_mark (mark
);
910 /* Look at each value on the value chain. */
911 for (; v
; v
= v
->next
)
913 /* If it's a memory location, and GDB actually needed
914 its contents to evaluate the expression, then we
916 if (VALUE_LVAL (v
) == lval_memory
919 struct type
*vtype
= check_typedef (VALUE_TYPE (v
));
921 /* We only watch structs and arrays if user asked
922 for it explicitly, never if they just happen to
923 appear in the middle of some value chain. */
924 if (v
== b
->val_chain
925 || (TYPE_CODE (vtype
) != TYPE_CODE_STRUCT
926 && TYPE_CODE (vtype
) != TYPE_CODE_ARRAY
))
931 addr
= VALUE_ADDRESS (v
) + VALUE_OFFSET (v
);
932 len
= TYPE_LENGTH (VALUE_TYPE (v
));
934 if (b
->type
== bp_read_watchpoint
)
936 else if (b
->type
== bp_access_watchpoint
)
939 val
= target_insert_watchpoint (addr
, len
, type
);
942 /* Don't exit the loop, try to insert
943 every value on the value chain. That's
944 because we will be removing all the
945 watches below, and removing a
946 watchpoint we didn't insert could have
954 /* Failure to insert a watchpoint on any memory value in the
955 value chain brings us here. */
958 remove_breakpoint (b
, mark_uninserted
);
959 warning ("Could not insert hardware watchpoint %d.",
966 printf_filtered ("Hardware watchpoint %d deleted ", b
->number
);
967 printf_filtered ("because the program has left the block \n");
968 printf_filtered ("in which its expression is valid.\n");
969 if (b
->related_breakpoint
)
970 b
->related_breakpoint
->disposition
= disp_del_at_next_stop
;
971 b
->disposition
= disp_del_at_next_stop
;
974 /* Restore the frame and level. */
975 if ((saved_frame
!= selected_frame
) ||
976 (saved_level
!= selected_frame_level
))
977 select_frame (saved_frame
, saved_level
);
980 return_val
= val
; /* remember failure */
982 else if ((b
->type
== bp_catch_fork
983 || b
->type
== bp_catch_vfork
984 || b
->type
== bp_catch_exec
)
985 && b
->enable_state
== bp_enabled
993 val
= target_insert_fork_catchpoint (PIDGET (inferior_ptid
));
996 val
= target_insert_vfork_catchpoint (PIDGET (inferior_ptid
));
999 val
= target_insert_exec_catchpoint (PIDGET (inferior_ptid
));
1002 warning ("Internal error, %s line %d.", __FILE__
, __LINE__
);
1007 target_terminal_ours_for_output ();
1008 warning ("Cannot insert catchpoint %d.", b
->number
);
1014 return_val
= val
; /* remember failure */
1023 remove_breakpoints (void)
1025 register struct breakpoint
*b
;
1032 val
= remove_breakpoint (b
, mark_uninserted
);
1041 remove_hw_watchpoints (void)
1043 register struct breakpoint
*b
;
1049 && (b
->type
== bp_hardware_watchpoint
1050 || b
->type
== bp_read_watchpoint
1051 || b
->type
== bp_access_watchpoint
))
1053 val
= remove_breakpoint (b
, mark_uninserted
);
1062 reattach_breakpoints (int pid
)
1064 register struct breakpoint
*b
;
1066 struct cleanup
*old_chain
= save_inferior_ptid ();
1068 /* Set inferior_ptid; remove_breakpoint uses this global. */
1069 inferior_ptid
= pid_to_ptid (pid
);
1074 remove_breakpoint (b
, mark_inserted
);
1075 if (b
->type
== bp_hardware_breakpoint
)
1076 val
= target_insert_hw_breakpoint (b
->address
, b
->shadow_contents
);
1078 val
= target_insert_breakpoint (b
->address
, b
->shadow_contents
);
1081 do_cleanups (old_chain
);
1086 do_cleanups (old_chain
);
1091 update_breakpoints_after_exec (void)
1093 struct breakpoint
*b
;
1094 struct breakpoint
*temp
;
1096 /* Doing this first prevents the badness of having delete_breakpoint()
1097 write a breakpoint's current "shadow contents" to lift the bp. That
1098 shadow is NOT valid after an exec()! */
1099 mark_breakpoints_out ();
1101 ALL_BREAKPOINTS_SAFE (b
, temp
)
1103 /* Solib breakpoints must be explicitly reset after an exec(). */
1104 if (b
->type
== bp_shlib_event
)
1106 delete_breakpoint (b
);
1110 /* Thread event breakpoints must be set anew after an exec(). */
1111 if (b
->type
== bp_thread_event
)
1113 delete_breakpoint (b
);
1117 /* Step-resume breakpoints are meaningless after an exec(). */
1118 if (b
->type
== bp_step_resume
)
1120 delete_breakpoint (b
);
1124 /* Ditto the sigtramp handler breakpoints. */
1125 if (b
->type
== bp_through_sigtramp
)
1127 delete_breakpoint (b
);
1131 /* Ditto the exception-handling catchpoints. */
1132 if ((b
->type
== bp_catch_catch
) || (b
->type
== bp_catch_throw
))
1134 delete_breakpoint (b
);
1138 /* Don't delete an exec catchpoint, because else the inferior
1139 won't stop when it ought!
1141 Similarly, we probably ought to keep vfork catchpoints, 'cause
1142 on this target, we may not be able to stop when the vfork is
1143 seen, but only when the subsequent exec is seen. (And because
1144 deleting fork catchpoints here but not vfork catchpoints will
1145 seem mysterious to users, keep those too.)
1147 ??rehrauer: Let's hope that merely clearing out this catchpoint's
1148 target address field, if any, is sufficient to have it be reset
1149 automagically. Certainly on HP-UX that's true.
1151 Jim Blandy <jimb@redhat.com>: Actually, zero is a perfectly
1152 valid code address on some platforms (like the mn10200 and
1153 mn10300 simulators). We shouldn't assign any special
1154 interpretation to a breakpoint with a zero address. And in
1155 fact, GDB doesn't --- I can't see what that comment above is
1156 talking about. As far as I can tell, setting the address of a
1157 bp_catch_exec/bp_catch_vfork/bp_catch_fork breakpoint to zero
1158 is meaningless, since those are implemented with HP-UX kernel
1159 hackery, not by storing breakpoint instructions somewhere. */
1160 if ((b
->type
== bp_catch_exec
) ||
1161 (b
->type
== bp_catch_vfork
) ||
1162 (b
->type
== bp_catch_fork
))
1164 b
->address
= (CORE_ADDR
) NULL
;
1168 /* bp_finish is a special case. The only way we ought to be able
1169 to see one of these when an exec() has happened, is if the user
1170 caught a vfork, and then said "finish". Ordinarily a finish just
1171 carries them to the call-site of the current callee, by setting
1172 a temporary bp there and resuming. But in this case, the finish
1173 will carry them entirely through the vfork & exec.
1175 We don't want to allow a bp_finish to remain inserted now. But
1176 we can't safely delete it, 'cause finish_command has a handle to
1177 the bp on a bpstat, and will later want to delete it. There's a
1178 chance (and I've seen it happen) that if we delete the bp_finish
1179 here, that its storage will get reused by the time finish_command
1180 gets 'round to deleting the "use to be a bp_finish" breakpoint.
1181 We really must allow finish_command to delete a bp_finish.
1183 In the absense of a general solution for the "how do we know
1184 it's safe to delete something others may have handles to?"
1185 problem, what we'll do here is just uninsert the bp_finish, and
1186 let finish_command delete it.
1188 (We know the bp_finish is "doomed" in the sense that it's
1189 momentary, and will be deleted as soon as finish_command sees
1190 the inferior stopped. So it doesn't matter that the bp's
1191 address is probably bogus in the new a.out, unlike e.g., the
1192 solib breakpoints.) */
1194 if (b
->type
== bp_finish
)
1199 /* Without a symbolic address, we have little hope of the
1200 pre-exec() address meaning the same thing in the post-exec()
1202 if (b
->addr_string
== NULL
)
1204 delete_breakpoint (b
);
1208 /* If this breakpoint has survived the above battery of checks, then
1209 it must have a symbolic address. Be sure that it gets reevaluated
1210 to a target address, rather than reusing the old evaluation.
1212 Jim Blandy <jimb@redhat.com>: As explained above in the comment
1213 for bp_catch_exec and friends, I'm pretty sure this is entirely
1214 unnecessary. A call to breakpoint_re_set_one always recomputes
1215 the breakpoint's address from scratch, or deletes it if it can't.
1216 So I think this assignment could be deleted without effect. */
1217 b
->address
= (CORE_ADDR
) NULL
;
1222 detach_breakpoints (int pid
)
1224 register struct breakpoint
*b
;
1226 struct cleanup
*old_chain
= save_inferior_ptid ();
1228 if (pid
== PIDGET (inferior_ptid
))
1229 error ("Cannot detach breakpoints of inferior_ptid");
1231 /* Set inferior_ptid; remove_breakpoint uses this global. */
1232 inferior_ptid
= pid_to_ptid (pid
);
1237 val
= remove_breakpoint (b
, mark_inserted
);
1240 do_cleanups (old_chain
);
1245 do_cleanups (old_chain
);
1250 remove_breakpoint (struct breakpoint
*b
, insertion_state_t is
)
1254 if (b
->enable_state
== bp_permanent
)
1255 /* Permanent breakpoints cannot be inserted or removed. */
1258 if (b
->type
== bp_none
)
1259 warning ("attempted to remove apparently deleted breakpoint #%d?",
1262 if (b
->type
!= bp_watchpoint
1263 && b
->type
!= bp_hardware_watchpoint
1264 && b
->type
!= bp_read_watchpoint
1265 && b
->type
!= bp_access_watchpoint
1266 && b
->type
!= bp_catch_fork
1267 && b
->type
!= bp_catch_vfork
1268 && b
->type
!= bp_catch_exec
1269 && b
->type
!= bp_catch_catch
1270 && b
->type
!= bp_catch_throw
)
1272 if (b
->type
== bp_hardware_breakpoint
)
1273 val
= target_remove_hw_breakpoint (b
->address
, b
->shadow_contents
);
1276 /* Check to see if breakpoint is in an overlay section;
1277 if so, we should remove the breakpoint at the LMA address.
1278 If that is not equal to the raw address, then we should
1279 presumably remove the breakpoint there as well. */
1280 if (overlay_debugging
&& b
->section
&&
1281 section_is_overlay (b
->section
))
1285 addr
= overlay_unmapped_address (b
->address
, b
->section
);
1286 val
= target_remove_breakpoint (addr
, b
->shadow_contents
);
1287 /* This would be the time to check val, to see if the
1288 shadow breakpoint write to the load address succeeded.
1289 However, this might be an ordinary occurrance, eg. if
1290 the unmapped overlay is in ROM. */
1291 val
= 0; /* in case unmapped address failed */
1292 if (section_is_mapped (b
->section
))
1293 val
= target_remove_breakpoint (b
->address
,
1294 b
->shadow_contents
);
1296 else /* ordinary (non-overlay) address */
1297 val
= target_remove_breakpoint (b
->address
, b
->shadow_contents
);
1301 b
->inserted
= (is
== mark_inserted
);
1303 else if ((b
->type
== bp_hardware_watchpoint
||
1304 b
->type
== bp_read_watchpoint
||
1305 b
->type
== bp_access_watchpoint
)
1306 && b
->enable_state
== bp_enabled
1312 b
->inserted
= (is
== mark_inserted
);
1313 /* Walk down the saved value chain. */
1314 for (v
= b
->val_chain
; v
; v
= v
->next
)
1316 /* For each memory reference remove the watchpoint
1318 if (VALUE_LVAL (v
) == lval_memory
1319 && ! VALUE_LAZY (v
))
1321 struct type
*vtype
= check_typedef (VALUE_TYPE (v
));
1323 if (v
== b
->val_chain
1324 || (TYPE_CODE (vtype
) != TYPE_CODE_STRUCT
1325 && TYPE_CODE (vtype
) != TYPE_CODE_ARRAY
))
1330 addr
= VALUE_ADDRESS (v
) + VALUE_OFFSET (v
);
1331 len
= TYPE_LENGTH (VALUE_TYPE (v
));
1333 if (b
->type
== bp_read_watchpoint
)
1335 else if (b
->type
== bp_access_watchpoint
)
1338 val
= target_remove_watchpoint (addr
, len
, type
);
1345 /* Failure to remove any of the hardware watchpoints comes here. */
1346 if ((is
== mark_uninserted
) && (b
->inserted
))
1347 warning ("Could not remove hardware watchpoint %d.",
1350 /* Free the saved value chain. We will construct a new one
1351 the next time the watchpoint is inserted. */
1352 for (v
= b
->val_chain
; v
; v
= n
)
1357 b
->val_chain
= NULL
;
1359 else if ((b
->type
== bp_catch_fork
||
1360 b
->type
== bp_catch_vfork
||
1361 b
->type
== bp_catch_exec
)
1362 && b
->enable_state
== bp_enabled
1369 val
= target_remove_fork_catchpoint (PIDGET (inferior_ptid
));
1371 case bp_catch_vfork
:
1372 val
= target_remove_vfork_catchpoint (PIDGET (inferior_ptid
));
1375 val
= target_remove_exec_catchpoint (PIDGET (inferior_ptid
));
1378 warning ("Internal error, %s line %d.", __FILE__
, __LINE__
);
1383 b
->inserted
= (is
== mark_inserted
);
1385 else if ((b
->type
== bp_catch_catch
||
1386 b
->type
== bp_catch_throw
)
1387 && b
->enable_state
== bp_enabled
1391 val
= target_remove_breakpoint (b
->address
, b
->shadow_contents
);
1394 b
->inserted
= (is
== mark_inserted
);
1396 else if (ep_is_exception_catchpoint (b
)
1397 && b
->inserted
/* sometimes previous insert doesn't happen */
1398 && b
->enable_state
== bp_enabled
1402 val
= target_remove_breakpoint (b
->address
, b
->shadow_contents
);
1406 b
->inserted
= (is
== mark_inserted
);
1412 /* Clear the "inserted" flag in all breakpoints. */
1415 mark_breakpoints_out (void)
1417 register struct breakpoint
*b
;
1423 /* Clear the "inserted" flag in all breakpoints and delete any
1424 breakpoints which should go away between runs of the program.
1426 Plus other such housekeeping that has to be done for breakpoints
1429 Note: this function gets called at the end of a run (by
1430 generic_mourn_inferior) and when a run begins (by
1431 init_wait_for_inferior). */
1436 breakpoint_init_inferior (enum inf_context context
)
1438 register struct breakpoint
*b
, *temp
;
1439 static int warning_needed
= 0;
1441 ALL_BREAKPOINTS_SAFE (b
, temp
)
1448 case bp_watchpoint_scope
:
1450 /* If the call dummy breakpoint is at the entry point it will
1451 cause problems when the inferior is rerun, so we better
1454 Also get rid of scope breakpoints. */
1455 delete_breakpoint (b
);
1459 case bp_hardware_watchpoint
:
1460 case bp_read_watchpoint
:
1461 case bp_access_watchpoint
:
1463 /* Likewise for watchpoints on local expressions. */
1464 if (b
->exp_valid_block
!= NULL
)
1465 delete_breakpoint (b
);
1468 /* Likewise for exception catchpoints in dynamic-linked
1469 executables where required */
1470 if (ep_is_exception_catchpoint (b
) &&
1471 exception_catchpoints_are_fragile
)
1474 delete_breakpoint (b
);
1480 if (exception_catchpoints_are_fragile
)
1481 exception_support_initialized
= 0;
1483 /* Don't issue the warning unless it's really needed... */
1484 if (warning_needed
&& (context
!= inf_exited
))
1486 warning ("Exception catchpoints from last run were deleted.");
1487 warning ("You must reinsert them explicitly.");
1492 /* breakpoint_here_p (PC) returns non-zero if an enabled breakpoint
1493 exists at PC. It returns ordinary_breakpoint_here if it's an
1494 ordinary breakpoint, or permanent_breakpoint_here if it's a
1495 permanent breakpoint.
1496 - When continuing from a location with an ordinary breakpoint, we
1497 actually single step once before calling insert_breakpoints.
1498 - When continuing from a localion with a permanent breakpoint, we
1499 need to use the `SKIP_PERMANENT_BREAKPOINT' macro, provided by
1500 the target, to advance the PC past the breakpoint. */
1502 enum breakpoint_here
1503 breakpoint_here_p (CORE_ADDR pc
)
1505 register struct breakpoint
*b
;
1506 int any_breakpoint_here
= 0;
1509 if ((b
->enable_state
== bp_enabled
1510 || b
->enable_state
== bp_permanent
)
1511 && b
->address
== pc
) /* bp is enabled and matches pc */
1513 if (overlay_debugging
&&
1514 section_is_overlay (b
->section
) &&
1515 !section_is_mapped (b
->section
))
1516 continue; /* unmapped overlay -- can't be a match */
1517 else if (b
->enable_state
== bp_permanent
)
1518 return permanent_breakpoint_here
;
1520 any_breakpoint_here
= 1;
1523 return any_breakpoint_here
? ordinary_breakpoint_here
: 0;
1527 /* breakpoint_inserted_here_p (PC) is just like breakpoint_here_p(),
1528 but it only returns true if there is actually a breakpoint inserted
1532 breakpoint_inserted_here_p (CORE_ADDR pc
)
1534 register struct breakpoint
*b
;
1538 && b
->address
== pc
) /* bp is inserted and matches pc */
1540 if (overlay_debugging
&&
1541 section_is_overlay (b
->section
) &&
1542 !section_is_mapped (b
->section
))
1543 continue; /* unmapped overlay -- can't be a match */
1551 /* Return nonzero if FRAME is a dummy frame. We can't use
1552 PC_IN_CALL_DUMMY because figuring out the saved SP would take too
1553 much time, at least using get_saved_register on the 68k. This
1554 means that for this function to work right a port must use the
1555 bp_call_dummy breakpoint. */
1558 frame_in_dummy (struct frame_info
*frame
)
1560 struct breakpoint
*b
;
1565 if (USE_GENERIC_DUMMY_FRAMES
)
1566 return generic_pc_in_call_dummy (frame
->pc
, frame
->frame
, frame
->frame
);
1570 if (b
->type
== bp_call_dummy
1571 && b
->frame
== frame
->frame
1572 /* We need to check the PC as well as the frame on the sparc,
1573 for signals.exp in the testsuite. */
1576 - SIZEOF_CALL_DUMMY_WORDS
/ sizeof (LONGEST
) * REGISTER_SIZE
))
1577 && frame
->pc
<= b
->address
)
1583 /* breakpoint_thread_match (PC, PID) returns true if the breakpoint at
1584 PC is valid for process/thread PID. */
1587 breakpoint_thread_match (CORE_ADDR pc
, ptid_t ptid
)
1589 struct breakpoint
*b
;
1592 thread
= pid_to_thread_id (ptid
);
1595 if (b
->enable_state
!= bp_disabled
1596 && b
->enable_state
!= bp_shlib_disabled
1597 && b
->enable_state
!= bp_call_disabled
1599 && (b
->thread
== -1 || b
->thread
== thread
))
1601 if (overlay_debugging
&&
1602 section_is_overlay (b
->section
) &&
1603 !section_is_mapped (b
->section
))
1604 continue; /* unmapped overlay -- can't be a match */
1613 /* bpstat stuff. External routines' interfaces are documented
1617 ep_is_catchpoint (struct breakpoint
*ep
)
1620 (ep
->type
== bp_catch_load
)
1621 || (ep
->type
== bp_catch_unload
)
1622 || (ep
->type
== bp_catch_fork
)
1623 || (ep
->type
== bp_catch_vfork
)
1624 || (ep
->type
== bp_catch_exec
)
1625 || (ep
->type
== bp_catch_catch
)
1626 || (ep
->type
== bp_catch_throw
);
1628 /* ??rehrauer: Add more kinds here, as are implemented... */
1632 ep_is_shlib_catchpoint (struct breakpoint
*ep
)
1635 (ep
->type
== bp_catch_load
)
1636 || (ep
->type
== bp_catch_unload
);
1640 ep_is_exception_catchpoint (struct breakpoint
*ep
)
1643 (ep
->type
== bp_catch_catch
)
1644 || (ep
->type
== bp_catch_throw
);
1647 /* Clear a bpstat so that it says we are not at any breakpoint.
1648 Also free any storage that is part of a bpstat. */
1651 bpstat_clear (bpstat
*bsp
)
1662 if (p
->old_val
!= NULL
)
1663 value_free (p
->old_val
);
1670 /* Return a copy of a bpstat. Like "bs1 = bs2" but all storage that
1671 is part of the bpstat is copied as well. */
1674 bpstat_copy (bpstat bs
)
1678 bpstat retval
= NULL
;
1683 for (; bs
!= NULL
; bs
= bs
->next
)
1685 tmp
= (bpstat
) xmalloc (sizeof (*tmp
));
1686 memcpy (tmp
, bs
, sizeof (*tmp
));
1688 /* This is the first thing in the chain. */
1698 /* Find the bpstat associated with this breakpoint */
1701 bpstat_find_breakpoint (bpstat bsp
, struct breakpoint
*breakpoint
)
1706 for (; bsp
!= NULL
; bsp
= bsp
->next
)
1708 if (bsp
->breakpoint_at
== breakpoint
)
1714 /* Find a step_resume breakpoint associated with this bpstat.
1715 (If there are multiple step_resume bp's on the list, this function
1716 will arbitrarily pick one.)
1718 It is an error to use this function if BPSTAT doesn't contain a
1719 step_resume breakpoint.
1721 See wait_for_inferior's use of this function. */
1723 bpstat_find_step_resume_breakpoint (bpstat bsp
)
1728 error ("Internal error (bpstat_find_step_resume_breakpoint)");
1730 current_thread
= pid_to_thread_id (inferior_ptid
);
1732 for (; bsp
!= NULL
; bsp
= bsp
->next
)
1734 if ((bsp
->breakpoint_at
!= NULL
) &&
1735 (bsp
->breakpoint_at
->type
== bp_step_resume
) &&
1736 (bsp
->breakpoint_at
->thread
== current_thread
||
1737 bsp
->breakpoint_at
->thread
== -1))
1738 return bsp
->breakpoint_at
;
1741 error ("Internal error (no step_resume breakpoint found)");
1745 /* Return the breakpoint number of the first breakpoint we are stopped
1746 at. *BSP upon return is a bpstat which points to the remaining
1747 breakpoints stopped at (but which is not guaranteed to be good for
1748 anything but further calls to bpstat_num).
1749 Return 0 if passed a bpstat which does not indicate any breakpoints. */
1752 bpstat_num (bpstat
*bsp
)
1754 struct breakpoint
*b
;
1757 return 0; /* No more breakpoint values */
1760 b
= (*bsp
)->breakpoint_at
;
1761 *bsp
= (*bsp
)->next
;
1763 return -1; /* breakpoint that's been deleted since */
1765 return b
->number
; /* We have its number */
1769 /* Modify BS so that the actions will not be performed. */
1772 bpstat_clear_actions (bpstat bs
)
1774 for (; bs
!= NULL
; bs
= bs
->next
)
1776 bs
->commands
= NULL
;
1777 if (bs
->old_val
!= NULL
)
1779 value_free (bs
->old_val
);
1785 /* Stub for cleaning up our state if we error-out of a breakpoint command */
1788 cleanup_executing_breakpoints (PTR ignore
)
1790 executing_breakpoint_commands
= 0;
1793 /* Execute all the commands associated with all the breakpoints at this
1794 location. Any of these commands could cause the process to proceed
1795 beyond this point, etc. We look out for such changes by checking
1796 the global "breakpoint_proceeded" after each command. */
1799 bpstat_do_actions (bpstat
*bsp
)
1802 struct cleanup
*old_chain
;
1803 struct command_line
*cmd
;
1805 /* Avoid endless recursion if a `source' command is contained
1807 if (executing_breakpoint_commands
)
1810 executing_breakpoint_commands
= 1;
1811 old_chain
= make_cleanup (cleanup_executing_breakpoints
, 0);
1814 /* Note that (as of this writing), our callers all appear to
1815 be passing us the address of global stop_bpstat. And, if
1816 our calls to execute_control_command cause the inferior to
1817 proceed, that global (and hence, *bsp) will change.
1819 We must be careful to not touch *bsp unless the inferior
1820 has not proceeded. */
1822 /* This pointer will iterate over the list of bpstat's. */
1825 breakpoint_proceeded
= 0;
1826 for (; bs
!= NULL
; bs
= bs
->next
)
1831 execute_control_command (cmd
);
1833 if (breakpoint_proceeded
)
1838 if (breakpoint_proceeded
)
1839 /* The inferior is proceeded by the command; bomb out now.
1840 The bpstat chain has been blown away by wait_for_inferior.
1841 But since execution has stopped again, there is a new bpstat
1842 to look at, so start over. */
1845 bs
->commands
= NULL
;
1848 executing_breakpoint_commands
= 0;
1849 discard_cleanups (old_chain
);
1852 /* This is the normal print function for a bpstat. In the future,
1853 much of this logic could (should?) be moved to bpstat_stop_status,
1854 by having it set different print_it values.
1856 Current scheme: When we stop, bpstat_print() is called. It loops
1857 through the bpstat list of things causing this stop, calling the
1858 print_bp_stop_message function on each one. The behavior of the
1859 print_bp_stop_message function depends on the print_it field of
1860 bpstat. If such field so indicates, call this function here.
1862 Return values from this routine (ultimately used by bpstat_print()
1863 and normal_stop() to decide what to do):
1864 PRINT_NOTHING: Means we already printed all we needed to print,
1865 don't print anything else.
1866 PRINT_SRC_ONLY: Means we printed something, and we do *not* desire
1867 that something to be followed by a location.
1868 PRINT_SCR_AND_LOC: Means we printed something, and we *do* desire
1869 that something to be followed by a location.
1870 PRINT_UNKNOWN: Means we printed nothing or we need to do some more
1873 static enum print_stop_action
1874 print_it_typical (bpstat bs
)
1877 struct cleanup
*old_chain
;
1878 struct ui_stream
*stb
;
1879 stb
= ui_out_stream_new (uiout
);
1880 old_chain
= make_cleanup_ui_out_stream_delete (stb
);
1882 /* bs->breakpoint_at can be NULL if it was a momentary breakpoint
1883 which has since been deleted. */
1884 if (bs
->breakpoint_at
== NULL
)
1885 return PRINT_UNKNOWN
;
1887 switch (bs
->breakpoint_at
->type
)
1890 case bp_hardware_breakpoint
:
1892 annotate_breakpoint (bs
->breakpoint_at
->number
);
1893 ui_out_text (uiout
, "\nBreakpoint ");
1894 if (ui_out_is_mi_like_p (uiout
))
1895 ui_out_field_string (uiout
, "reason", "breakpoint-hit");
1896 ui_out_field_int (uiout
, "bkptno", bs
->breakpoint_at
->number
);
1897 ui_out_text (uiout
, ", ");
1898 return PRINT_SRC_AND_LOC
;
1900 /* I think the user probably only wants to see one breakpoint
1901 number, not all of them. */
1902 annotate_breakpoint (bs
->breakpoint_at
->number
);
1903 printf_filtered ("\nBreakpoint %d, ", bs
->breakpoint_at
->number
);
1904 return PRINT_SRC_AND_LOC
;
1908 case bp_shlib_event
:
1909 /* Did we stop because the user set the stop_on_solib_events
1910 variable? (If so, we report this as a generic, "Stopped due
1911 to shlib event" message.) */
1912 printf_filtered ("Stopped due to shared library event\n");
1913 return PRINT_NOTHING
;
1916 case bp_thread_event
:
1917 /* Not sure how we will get here.
1918 GDB should not stop for these breakpoints. */
1919 printf_filtered ("Thread Event Breakpoint: gdb should not stop!\n");
1920 return PRINT_NOTHING
;
1924 annotate_catchpoint (bs
->breakpoint_at
->number
);
1925 printf_filtered ("\nCatchpoint %d (", bs
->breakpoint_at
->number
);
1926 printf_filtered ("loaded");
1927 printf_filtered (" %s), ", bs
->breakpoint_at
->triggered_dll_pathname
);
1928 return PRINT_SRC_AND_LOC
;
1931 case bp_catch_unload
:
1932 annotate_catchpoint (bs
->breakpoint_at
->number
);
1933 printf_filtered ("\nCatchpoint %d (", bs
->breakpoint_at
->number
);
1934 printf_filtered ("unloaded");
1935 printf_filtered (" %s), ", bs
->breakpoint_at
->triggered_dll_pathname
);
1936 return PRINT_SRC_AND_LOC
;
1940 annotate_catchpoint (bs
->breakpoint_at
->number
);
1941 printf_filtered ("\nCatchpoint %d (", bs
->breakpoint_at
->number
);
1942 printf_filtered ("forked");
1943 printf_filtered (" process %d), ",
1944 bs
->breakpoint_at
->forked_inferior_pid
);
1945 return PRINT_SRC_AND_LOC
;
1948 case bp_catch_vfork
:
1949 annotate_catchpoint (bs
->breakpoint_at
->number
);
1950 printf_filtered ("\nCatchpoint %d (", bs
->breakpoint_at
->number
);
1951 printf_filtered ("vforked");
1952 printf_filtered (" process %d), ",
1953 bs
->breakpoint_at
->forked_inferior_pid
);
1954 return PRINT_SRC_AND_LOC
;
1958 annotate_catchpoint (bs
->breakpoint_at
->number
);
1959 printf_filtered ("\nCatchpoint %d (exec'd %s), ",
1960 bs
->breakpoint_at
->number
,
1961 bs
->breakpoint_at
->exec_pathname
);
1962 return PRINT_SRC_AND_LOC
;
1965 case bp_catch_catch
:
1966 if (current_exception_event
&&
1967 (CURRENT_EXCEPTION_KIND
== EX_EVENT_CATCH
))
1969 annotate_catchpoint (bs
->breakpoint_at
->number
);
1970 printf_filtered ("\nCatchpoint %d (exception caught), ",
1971 bs
->breakpoint_at
->number
);
1972 printf_filtered ("throw location ");
1973 if (CURRENT_EXCEPTION_THROW_PC
&& CURRENT_EXCEPTION_THROW_LINE
)
1974 printf_filtered ("%s:%d",
1975 CURRENT_EXCEPTION_THROW_FILE
,
1976 CURRENT_EXCEPTION_THROW_LINE
);
1978 printf_filtered ("unknown");
1980 printf_filtered (", catch location ");
1981 if (CURRENT_EXCEPTION_CATCH_PC
&& CURRENT_EXCEPTION_CATCH_LINE
)
1982 printf_filtered ("%s:%d",
1983 CURRENT_EXCEPTION_CATCH_FILE
,
1984 CURRENT_EXCEPTION_CATCH_LINE
);
1986 printf_filtered ("unknown");
1988 printf_filtered ("\n");
1989 /* don't bother to print location frame info */
1990 return PRINT_SRC_ONLY
;
1994 /* really throw, some other bpstat will handle it */
1995 return PRINT_UNKNOWN
;
1999 case bp_catch_throw
:
2000 if (current_exception_event
&&
2001 (CURRENT_EXCEPTION_KIND
== EX_EVENT_THROW
))
2003 annotate_catchpoint (bs
->breakpoint_at
->number
);
2004 printf_filtered ("\nCatchpoint %d (exception thrown), ",
2005 bs
->breakpoint_at
->number
);
2006 printf_filtered ("throw location ");
2007 if (CURRENT_EXCEPTION_THROW_PC
&& CURRENT_EXCEPTION_THROW_LINE
)
2008 printf_filtered ("%s:%d",
2009 CURRENT_EXCEPTION_THROW_FILE
,
2010 CURRENT_EXCEPTION_THROW_LINE
);
2012 printf_filtered ("unknown");
2014 printf_filtered (", catch location ");
2015 if (CURRENT_EXCEPTION_CATCH_PC
&& CURRENT_EXCEPTION_CATCH_LINE
)
2016 printf_filtered ("%s:%d",
2017 CURRENT_EXCEPTION_CATCH_FILE
,
2018 CURRENT_EXCEPTION_CATCH_LINE
);
2020 printf_filtered ("unknown");
2022 printf_filtered ("\n");
2023 /* don't bother to print location frame info */
2024 return PRINT_SRC_ONLY
;
2028 /* really catch, some other bpstat will handle it */
2029 return PRINT_UNKNOWN
;
2034 case bp_hardware_watchpoint
:
2035 if (bs
->old_val
!= NULL
)
2037 annotate_watchpoint (bs
->breakpoint_at
->number
);
2039 if (ui_out_is_mi_like_p (uiout
))
2040 ui_out_field_string (uiout
, "reason", "watchpoint-trigger");
2041 mention (bs
->breakpoint_at
);
2042 ui_out_tuple_begin (uiout
, "value");
2043 ui_out_text (uiout
, "\nOld value = ");
2044 value_print (bs
->old_val
, stb
->stream
, 0, Val_pretty_default
);
2045 ui_out_field_stream (uiout
, "old", stb
);
2046 ui_out_text (uiout
, "\nNew value = ");
2047 value_print (bs
->breakpoint_at
->val
, stb
->stream
, 0, Val_pretty_default
);
2048 ui_out_field_stream (uiout
, "new", stb
);
2049 ui_out_tuple_end (uiout
);
2050 ui_out_text (uiout
, "\n");
2052 mention (bs
->breakpoint_at
);
2053 printf_filtered ("\nOld value = ");
2054 value_print (bs
->old_val
, gdb_stdout
, 0, Val_pretty_default
);
2055 printf_filtered ("\nNew value = ");
2056 value_print (bs
->breakpoint_at
->val
, gdb_stdout
, 0,
2057 Val_pretty_default
);
2058 printf_filtered ("\n");
2060 value_free (bs
->old_val
);
2063 /* More than one watchpoint may have been triggered. */
2064 return PRINT_UNKNOWN
;
2067 case bp_read_watchpoint
:
2069 if (ui_out_is_mi_like_p (uiout
))
2070 ui_out_field_string (uiout
, "reason", "read-watchpoint-trigger");
2071 mention (bs
->breakpoint_at
);
2072 ui_out_tuple_begin (uiout
, "value");
2073 ui_out_text (uiout
, "\nValue = ");
2074 value_print (bs
->breakpoint_at
->val
, stb
->stream
, 0, Val_pretty_default
);
2075 ui_out_field_stream (uiout
, "value", stb
);
2076 ui_out_tuple_end (uiout
);
2077 ui_out_text (uiout
, "\n");
2079 mention (bs
->breakpoint_at
);
2080 printf_filtered ("\nValue = ");
2081 value_print (bs
->breakpoint_at
->val
, gdb_stdout
, 0,
2082 Val_pretty_default
);
2083 printf_filtered ("\n");
2085 return PRINT_UNKNOWN
;
2088 case bp_access_watchpoint
:
2090 if (bs
->old_val
!= NULL
)
2092 annotate_watchpoint (bs
->breakpoint_at
->number
);
2093 if (ui_out_is_mi_like_p (uiout
))
2094 ui_out_field_string (uiout
, "reason", "access-watchpoint-trigger");
2095 mention (bs
->breakpoint_at
);
2096 ui_out_tuple_begin (uiout
, "value");
2097 ui_out_text (uiout
, "\nOld value = ");
2098 value_print (bs
->old_val
, stb
->stream
, 0, Val_pretty_default
);
2099 ui_out_field_stream (uiout
, "old", stb
);
2100 value_free (bs
->old_val
);
2102 ui_out_text (uiout
, "\nNew value = ");
2106 mention (bs
->breakpoint_at
);
2107 if (ui_out_is_mi_like_p (uiout
))
2108 ui_out_field_string (uiout
, "reason", "access-watchpoint-trigger");
2109 ui_out_tuple_begin (uiout
, "value");
2110 ui_out_text (uiout
, "\nValue = ");
2112 value_print (bs
->breakpoint_at
->val
, stb
->stream
, 0,Val_pretty_default
);
2113 ui_out_field_stream (uiout
, "new", stb
);
2114 ui_out_tuple_end (uiout
);
2115 ui_out_text (uiout
, "\n");
2117 if (bs
->old_val
!= NULL
)
2119 annotate_watchpoint (bs
->breakpoint_at
->number
);
2120 mention (bs
->breakpoint_at
);
2121 printf_filtered ("\nOld value = ");
2122 value_print (bs
->old_val
, gdb_stdout
, 0, Val_pretty_default
);
2123 value_free (bs
->old_val
);
2125 printf_filtered ("\nNew value = ");
2129 mention (bs
->breakpoint_at
);
2130 printf_filtered ("\nValue = ");
2132 value_print (bs
->breakpoint_at
->val
, gdb_stdout
, 0,
2133 Val_pretty_default
);
2134 printf_filtered ("\n");
2136 return PRINT_UNKNOWN
;
2139 /* Fall through, we don't deal with these types of breakpoints
2144 if (ui_out_is_mi_like_p (uiout
))
2145 ui_out_field_string (uiout
, "reason", "function-finished");
2147 return PRINT_UNKNOWN
;
2152 if (ui_out_is_mi_like_p (uiout
))
2153 ui_out_field_string (uiout
, "reason", "location-reached");
2155 return PRINT_UNKNOWN
;
2160 case bp_longjmp_resume
:
2161 case bp_step_resume
:
2162 case bp_through_sigtramp
:
2163 case bp_watchpoint_scope
:
2166 return PRINT_UNKNOWN
;
2170 /* Generic routine for printing messages indicating why we
2171 stopped. The behavior of this function depends on the value
2172 'print_it' in the bpstat structure. Under some circumstances we
2173 may decide not to print anything here and delegate the task to
2176 static enum print_stop_action
2177 print_bp_stop_message (bpstat bs
)
2179 switch (bs
->print_it
)
2182 /* Nothing should be printed for this bpstat entry. */
2183 return PRINT_UNKNOWN
;
2187 /* We still want to print the frame, but we already printed the
2188 relevant messages. */
2189 return PRINT_SRC_AND_LOC
;
2192 case print_it_normal
:
2193 /* Normal case, we handle everything in print_it_typical. */
2194 return print_it_typical (bs
);
2197 internal_error (__FILE__
, __LINE__
,
2198 "print_bp_stop_message: unrecognized enum value");
2203 /* Print a message indicating what happened. This is called from
2204 normal_stop(). The input to this routine is the head of the bpstat
2205 list - a list of the eventpoints that caused this stop. This
2206 routine calls the generic print routine for printing a message
2207 about reasons for stopping. This will print (for example) the
2208 "Breakpoint n," part of the output. The return value of this
2211 PRINT_UNKNOWN: Means we printed nothing
2212 PRINT_SRC_AND_LOC: Means we printed something, and expect subsequent
2213 code to print the location. An example is
2214 "Breakpoint 1, " which should be followed by
2216 PRINT_SRC_ONLY: Means we printed something, but there is no need
2217 to also print the location part of the message.
2218 An example is the catch/throw messages, which
2219 don't require a location appended to the end.
2220 PRINT_NOTHING: We have done some printing and we don't need any
2221 further info to be printed.*/
2223 enum print_stop_action
2224 bpstat_print (bpstat bs
)
2228 /* Maybe another breakpoint in the chain caused us to stop.
2229 (Currently all watchpoints go on the bpstat whether hit or not.
2230 That probably could (should) be changed, provided care is taken
2231 with respect to bpstat_explains_signal). */
2232 for (; bs
; bs
= bs
->next
)
2234 val
= print_bp_stop_message (bs
);
2235 if (val
== PRINT_SRC_ONLY
2236 || val
== PRINT_SRC_AND_LOC
2237 || val
== PRINT_NOTHING
)
2241 /* We reached the end of the chain, or we got a null BS to start
2242 with and nothing was printed. */
2243 return PRINT_UNKNOWN
;
2246 /* Evaluate the expression EXP and return 1 if value is zero.
2247 This is used inside a catch_errors to evaluate the breakpoint condition.
2248 The argument is a "struct expression *" that has been cast to char * to
2249 make it pass through catch_errors. */
2252 breakpoint_cond_eval (PTR exp
)
2254 struct value
*mark
= value_mark ();
2255 int i
= !value_true (evaluate_expression ((struct expression
*) exp
));
2256 value_free_to_mark (mark
);
2260 /* Allocate a new bpstat and chain it to the current one. */
2263 bpstat_alloc (struct breakpoint
*b
, bpstat cbs
/* Current "bs" value */ )
2267 bs
= (bpstat
) xmalloc (sizeof (*bs
));
2269 bs
->breakpoint_at
= b
;
2270 /* If the condition is false, etc., don't do the commands. */
2271 bs
->commands
= NULL
;
2273 bs
->print_it
= print_it_normal
;
2277 /* Possible return values for watchpoint_check (this can't be an enum
2278 because of check_errors). */
2279 /* The watchpoint has been deleted. */
2280 #define WP_DELETED 1
2281 /* The value has changed. */
2282 #define WP_VALUE_CHANGED 2
2283 /* The value has not changed. */
2284 #define WP_VALUE_NOT_CHANGED 3
2286 #define BP_TEMPFLAG 1
2287 #define BP_HARDWAREFLAG 2
2289 /* Check watchpoint condition. */
2292 watchpoint_check (PTR p
)
2294 bpstat bs
= (bpstat
) p
;
2295 struct breakpoint
*b
;
2296 struct frame_info
*fr
;
2297 int within_current_scope
;
2299 b
= bs
->breakpoint_at
;
2301 if (b
->exp_valid_block
== NULL
)
2302 within_current_scope
= 1;
2305 /* There is no current frame at this moment. If we're going to have
2306 any chance of handling watchpoints on local variables, we'll need
2307 the frame chain (so we can determine if we're in scope). */
2308 reinit_frame_cache ();
2309 fr
= find_frame_addr_in_frame_chain (b
->watchpoint_frame
);
2310 within_current_scope
= (fr
!= NULL
);
2311 if (within_current_scope
)
2312 /* If we end up stopping, the current frame will get selected
2313 in normal_stop. So this call to select_frame won't affect
2315 select_frame (fr
, -1);
2318 if (within_current_scope
)
2320 /* We use value_{,free_to_}mark because it could be a
2321 *long* time before we return to the command level and
2322 call free_all_values. We can't call free_all_values because
2323 we might be in the middle of evaluating a function call. */
2325 struct value
*mark
= value_mark ();
2326 struct value
*new_val
= evaluate_expression (bs
->breakpoint_at
->exp
);
2327 if (!value_equal (b
->val
, new_val
))
2329 release_value (new_val
);
2330 value_free_to_mark (mark
);
2331 bs
->old_val
= b
->val
;
2333 /* We will stop here */
2334 return WP_VALUE_CHANGED
;
2338 /* Nothing changed, don't do anything. */
2339 value_free_to_mark (mark
);
2340 /* We won't stop here */
2341 return WP_VALUE_NOT_CHANGED
;
2346 /* This seems like the only logical thing to do because
2347 if we temporarily ignored the watchpoint, then when
2348 we reenter the block in which it is valid it contains
2349 garbage (in the case of a function, it may have two
2350 garbage values, one before and one after the prologue).
2351 So we can't even detect the first assignment to it and
2352 watch after that (since the garbage may or may not equal
2353 the first value assigned). */
2354 /* We print all the stop information in print_it_typical(), but
2355 in this case, by the time we call print_it_typical() this bp
2356 will be deleted already. So we have no choice but print the
2357 information here. */
2359 if (ui_out_is_mi_like_p (uiout
))
2360 ui_out_field_string (uiout
, "reason", "watchpoint-scope");
2361 ui_out_text (uiout
, "\nWatchpoint ");
2362 ui_out_field_int (uiout
, "wpnum", bs
->breakpoint_at
->number
);
2363 ui_out_text (uiout
, " deleted because the program has left the block in\n\
2364 which its expression is valid.\n");
2367 Watchpoint %d deleted because the program has left the block in\n\
2368 which its expression is valid.\n", bs
->breakpoint_at
->number
);
2371 if (b
->related_breakpoint
)
2372 b
->related_breakpoint
->disposition
= disp_del_at_next_stop
;
2373 b
->disposition
= disp_del_at_next_stop
;
2379 /* Get a bpstat associated with having just stopped at address *PC
2380 and frame address CORE_ADDRESS. Update *PC to point at the
2381 breakpoint (if we hit a breakpoint). NOT_A_BREAKPOINT is nonzero
2382 if this is known to not be a real breakpoint (it could still be a
2383 watchpoint, though). */
2385 /* Determine whether we stopped at a breakpoint, etc, or whether we
2386 don't understand this stop. Result is a chain of bpstat's such that:
2388 if we don't understand the stop, the result is a null pointer.
2390 if we understand why we stopped, the result is not null.
2392 Each element of the chain refers to a particular breakpoint or
2393 watchpoint at which we have stopped. (We may have stopped for
2394 several reasons concurrently.)
2396 Each element of the chain has valid next, breakpoint_at,
2397 commands, FIXME??? fields. */
2400 bpstat_stop_status (CORE_ADDR
*pc
, int not_a_breakpoint
)
2402 register struct breakpoint
*b
, *temp
;
2404 /* True if we've hit a breakpoint (as opposed to a watchpoint). */
2405 int real_breakpoint
= 0;
2406 /* Root of the chain of bpstat's */
2407 struct bpstats root_bs
[1];
2408 /* Pointer to the last thing in the chain currently. */
2409 bpstat bs
= root_bs
;
2410 static char message1
[] =
2411 "Error evaluating expression for watchpoint %d\n";
2412 char message
[sizeof (message1
) + 30 /* slop */ ];
2414 /* Get the address where the breakpoint would have been.
2415 The "not_a_breakpoint" argument is meant to distinguish
2416 between a breakpoint trap event and a trace/singlestep
2417 trap event. For a trace/singlestep trap event, we would
2418 not want to subtract DECR_PC_AFTER_BREAK from the PC. */
2420 bp_addr
= *pc
- (not_a_breakpoint
&& !SOFTWARE_SINGLE_STEP_P () ?
2421 0 : DECR_PC_AFTER_BREAK
);
2423 ALL_BREAKPOINTS_SAFE (b
, temp
)
2425 if (b
->enable_state
== bp_disabled
2426 || b
->enable_state
== bp_shlib_disabled
2427 || b
->enable_state
== bp_call_disabled
)
2430 if (b
->type
!= bp_watchpoint
2431 && b
->type
!= bp_hardware_watchpoint
2432 && b
->type
!= bp_read_watchpoint
2433 && b
->type
!= bp_access_watchpoint
2434 && b
->type
!= bp_hardware_breakpoint
2435 && b
->type
!= bp_catch_fork
2436 && b
->type
!= bp_catch_vfork
2437 && b
->type
!= bp_catch_exec
2438 && b
->type
!= bp_catch_catch
2439 && b
->type
!= bp_catch_throw
) /* a non-watchpoint bp */
2440 if (b
->address
!= bp_addr
|| /* address doesn't match or */
2441 (overlay_debugging
&& /* overlay doesn't match */
2442 section_is_overlay (b
->section
) &&
2443 !section_is_mapped (b
->section
)))
2446 if (b
->type
== bp_hardware_breakpoint
2447 && b
->address
!= (*pc
- DECR_PC_AFTER_HW_BREAK
))
2450 /* Is this a catchpoint of a load or unload? If so, did we
2451 get a load or unload of the specified library? If not,
2453 if ((b
->type
== bp_catch_load
)
2454 #if defined(SOLIB_HAVE_LOAD_EVENT)
2455 && (!SOLIB_HAVE_LOAD_EVENT (PIDGET (inferior_ptid
))
2456 || ((b
->dll_pathname
!= NULL
)
2457 && (strcmp (b
->dll_pathname
,
2458 SOLIB_LOADED_LIBRARY_PATHNAME (
2459 PIDGET (inferior_ptid
)))
2465 if ((b
->type
== bp_catch_unload
)
2466 #if defined(SOLIB_HAVE_UNLOAD_EVENT)
2467 && (!SOLIB_HAVE_UNLOAD_EVENT (PIDGET (inferior_ptid
))
2468 || ((b
->dll_pathname
!= NULL
)
2469 && (strcmp (b
->dll_pathname
,
2470 SOLIB_UNLOADED_LIBRARY_PATHNAME (
2471 PIDGET (inferior_ptid
)))
2477 if ((b
->type
== bp_catch_fork
)
2478 && !target_has_forked (PIDGET (inferior_ptid
),
2479 &b
->forked_inferior_pid
))
2482 if ((b
->type
== bp_catch_vfork
)
2483 && !target_has_vforked (PIDGET (inferior_ptid
),
2484 &b
->forked_inferior_pid
))
2487 if ((b
->type
== bp_catch_exec
)
2488 && !target_has_execd (PIDGET (inferior_ptid
), &b
->exec_pathname
))
2491 if (ep_is_exception_catchpoint (b
) &&
2492 !(current_exception_event
= target_get_current_exception_event ()))
2495 /* Come here if it's a watchpoint, or if the break address matches */
2497 bs
= bpstat_alloc (b
, bs
); /* Alloc a bpstat to explain stop */
2499 /* Watchpoints may change this, if not found to have triggered. */
2503 sprintf (message
, message1
, b
->number
);
2504 if (b
->type
== bp_watchpoint
||
2505 b
->type
== bp_hardware_watchpoint
)
2507 switch (catch_errors (watchpoint_check
, bs
, message
,
2511 /* We've already printed what needs to be printed. */
2512 /* Actually this is superfluous, because by the time we
2513 call print_it_typical() the wp will be already deleted,
2514 and the function will return immediately. */
2515 bs
->print_it
= print_it_done
;
2518 case WP_VALUE_CHANGED
:
2522 case WP_VALUE_NOT_CHANGED
:
2524 bs
->print_it
= print_it_noop
;
2531 /* Error from catch_errors. */
2532 printf_filtered ("Watchpoint %d deleted.\n", b
->number
);
2533 if (b
->related_breakpoint
)
2534 b
->related_breakpoint
->disposition
= disp_del_at_next_stop
;
2535 b
->disposition
= disp_del_at_next_stop
;
2536 /* We've already printed what needs to be printed. */
2537 bs
->print_it
= print_it_done
;
2543 else if (b
->type
== bp_read_watchpoint
||
2544 b
->type
== bp_access_watchpoint
)
2550 addr
= target_stopped_data_address ();
2553 for (v
= b
->val_chain
; v
; v
= v
->next
)
2555 if (VALUE_LVAL (v
) == lval_memory
2556 && ! VALUE_LAZY (v
))
2558 struct type
*vtype
= check_typedef (VALUE_TYPE (v
));
2560 if (v
== b
->val_chain
2561 || (TYPE_CODE (vtype
) != TYPE_CODE_STRUCT
2562 && TYPE_CODE (vtype
) != TYPE_CODE_ARRAY
))
2566 vaddr
= VALUE_ADDRESS (v
) + VALUE_OFFSET (v
);
2567 /* Exact match not required. Within range is
2569 if (addr
>= vaddr
&&
2570 addr
< vaddr
+ TYPE_LENGTH (VALUE_TYPE (v
)))
2576 switch (catch_errors (watchpoint_check
, bs
, message
,
2580 /* We've already printed what needs to be printed. */
2581 bs
->print_it
= print_it_done
;
2584 case WP_VALUE_CHANGED
:
2585 if (b
->type
== bp_read_watchpoint
)
2587 /* Don't stop: read watchpoints shouldn't fire if
2588 the value has changed. This is for targets which
2589 cannot set read-only watchpoints. */
2590 bs
->print_it
= print_it_noop
;
2596 case WP_VALUE_NOT_CHANGED
:
2603 /* Error from catch_errors. */
2604 printf_filtered ("Watchpoint %d deleted.\n", b
->number
);
2605 if (b
->related_breakpoint
)
2606 b
->related_breakpoint
->disposition
= disp_del_at_next_stop
;
2607 b
->disposition
= disp_del_at_next_stop
;
2608 /* We've already printed what needs to be printed. */
2609 bs
->print_it
= print_it_done
;
2612 else /* found == 0 */
2614 /* This is a case where some watchpoint(s) triggered,
2615 but not at the address of this watchpoint (FOUND
2616 was left zero). So don't print anything for this
2618 bs
->print_it
= print_it_noop
;
2625 /* By definition, an encountered breakpoint is a triggered
2629 real_breakpoint
= 1;
2633 b
->frame
!= (get_current_frame ())->frame
)
2637 int value_is_zero
= 0;
2641 /* Need to select the frame, with all that implies
2642 so that the conditions will have the right context. */
2643 select_frame (get_current_frame (), 0);
2645 = catch_errors (breakpoint_cond_eval
, (b
->cond
),
2646 "Error in testing breakpoint condition:\n",
2648 /* FIXME-someday, should give breakpoint # */
2651 if (b
->cond
&& value_is_zero
)
2654 /* Don't consider this a hit. */
2657 else if (b
->ignore_count
> 0)
2660 annotate_ignore_count_change ();
2665 /* We will stop here */
2666 if (b
->disposition
== disp_disable
)
2667 b
->enable_state
= bp_disabled
;
2668 bs
->commands
= b
->commands
;
2672 (STREQ ("silent", bs
->commands
->line
) ||
2673 (xdb_commands
&& STREQ ("Q", bs
->commands
->line
))))
2675 bs
->commands
= bs
->commands
->next
;
2680 /* Print nothing for this entry if we dont stop or if we dont print. */
2681 if (bs
->stop
== 0 || bs
->print
== 0)
2682 bs
->print_it
= print_it_noop
;
2685 bs
->next
= NULL
; /* Terminate the chain */
2686 bs
= root_bs
->next
; /* Re-grab the head of the chain */
2688 if (real_breakpoint
&& bs
)
2690 if (bs
->breakpoint_at
->type
== bp_hardware_breakpoint
)
2692 if (DECR_PC_AFTER_HW_BREAK
!= 0)
2694 *pc
= *pc
- DECR_PC_AFTER_HW_BREAK
;
2700 if (DECR_PC_AFTER_BREAK
!= 0 || must_shift_inst_regs
)
2703 #if defined (SHIFT_INST_REGS)
2705 #else /* No SHIFT_INST_REGS. */
2707 #endif /* No SHIFT_INST_REGS. */
2712 /* The value of a hardware watchpoint hasn't changed, but the
2713 intermediate memory locations we are watching may have. */
2714 if (bs
&& !bs
->stop
&&
2715 (bs
->breakpoint_at
->type
== bp_hardware_watchpoint
||
2716 bs
->breakpoint_at
->type
== bp_read_watchpoint
||
2717 bs
->breakpoint_at
->type
== bp_access_watchpoint
))
2719 remove_breakpoints ();
2720 insert_breakpoints ();
2725 /* Tell what to do about this bpstat. */
2727 bpstat_what (bpstat bs
)
2729 /* Classify each bpstat as one of the following. */
2732 /* This bpstat element has no effect on the main_action. */
2735 /* There was a watchpoint, stop but don't print. */
2738 /* There was a watchpoint, stop and print. */
2741 /* There was a breakpoint but we're not stopping. */
2744 /* There was a breakpoint, stop but don't print. */
2747 /* There was a breakpoint, stop and print. */
2750 /* We hit the longjmp breakpoint. */
2753 /* We hit the longjmp_resume breakpoint. */
2756 /* We hit the step_resume breakpoint. */
2759 /* We hit the through_sigtramp breakpoint. */
2762 /* We hit the shared library event breakpoint. */
2765 /* We caught a shared library event. */
2768 /* This is just used to count how many enums there are. */
2772 /* Here is the table which drives this routine. So that we can
2773 format it pretty, we define some abbreviations for the
2774 enum bpstat_what codes. */
2775 #define kc BPSTAT_WHAT_KEEP_CHECKING
2776 #define ss BPSTAT_WHAT_STOP_SILENT
2777 #define sn BPSTAT_WHAT_STOP_NOISY
2778 #define sgl BPSTAT_WHAT_SINGLE
2779 #define slr BPSTAT_WHAT_SET_LONGJMP_RESUME
2780 #define clr BPSTAT_WHAT_CLEAR_LONGJMP_RESUME
2781 #define clrs BPSTAT_WHAT_CLEAR_LONGJMP_RESUME_SINGLE
2782 #define sr BPSTAT_WHAT_STEP_RESUME
2783 #define ts BPSTAT_WHAT_THROUGH_SIGTRAMP
2784 #define shl BPSTAT_WHAT_CHECK_SHLIBS
2785 #define shlr BPSTAT_WHAT_CHECK_SHLIBS_RESUME_FROM_HOOK
2787 /* "Can't happen." Might want to print an error message.
2788 abort() is not out of the question, but chances are GDB is just
2789 a bit confused, not unusable. */
2790 #define err BPSTAT_WHAT_STOP_NOISY
2792 /* Given an old action and a class, come up with a new action. */
2793 /* One interesting property of this table is that wp_silent is the same
2794 as bp_silent and wp_noisy is the same as bp_noisy. That is because
2795 after stopping, the check for whether to step over a breakpoint
2796 (BPSTAT_WHAT_SINGLE type stuff) is handled in proceed() without
2797 reference to how we stopped. We retain separate wp_silent and
2798 bp_silent codes in case we want to change that someday.
2800 Another possibly interesting property of this table is that
2801 there's a partial ordering, priority-like, of the actions. Once
2802 you've decided that some action is appropriate, you'll never go
2803 back and decide something of a lower priority is better. The
2806 kc < clr sgl shl shlr slr sn sr ss ts
2807 sgl < clrs shl shlr slr sn sr ss ts
2808 slr < err shl shlr sn sr ss ts
2809 clr < clrs err shl shlr sn sr ss ts
2810 clrs < err shl shlr sn sr ss ts
2811 ss < shl shlr sn sr ts
2818 What I think this means is that we don't need a damned table
2819 here. If you just put the rows and columns in the right order,
2820 it'd look awfully regular. We could simply walk the bpstat list
2821 and choose the highest priority action we find, with a little
2822 logic to handle the 'err' cases, and the CLEAR_LONGJMP_RESUME/
2823 CLEAR_LONGJMP_RESUME_SINGLE distinction (which breakpoint.h says
2824 is messy anyway). */
2826 /* step_resume entries: a step resume breakpoint overrides another
2827 breakpoint of signal handling (see comment in wait_for_inferior
2828 at first IN_SIGTRAMP where we set the step_resume breakpoint). */
2829 /* We handle the through_sigtramp_breakpoint the same way; having both
2830 one of those and a step_resume_breakpoint is probably very rare (?). */
2832 static const enum bpstat_what_main_action
2833 table
[(int) class_last
][(int) BPSTAT_WHAT_LAST
] =
2836 /* kc ss sn sgl slr clr clrs sr ts shl shlr
2839 {kc
, ss
, sn
, sgl
, slr
, clr
, clrs
, sr
, ts
, shl
, shlr
},
2841 {ss
, ss
, sn
, ss
, ss
, ss
, ss
, sr
, ts
, shl
, shlr
},
2843 {sn
, sn
, sn
, sn
, sn
, sn
, sn
, sr
, ts
, shl
, shlr
},
2845 {sgl
, ss
, sn
, sgl
, slr
, clrs
, clrs
, sr
, ts
, shl
, shlr
},
2847 {ss
, ss
, sn
, ss
, ss
, ss
, ss
, sr
, ts
, shl
, shlr
},
2849 {sn
, sn
, sn
, sn
, sn
, sn
, sn
, sr
, ts
, shl
, shlr
},
2851 {slr
, ss
, sn
, slr
, slr
, err
, err
, sr
, ts
, shl
, shlr
},
2853 {clr
, ss
, sn
, clrs
, err
, err
, err
, sr
, ts
, shl
, shlr
},
2855 {sr
, sr
, sr
, sr
, sr
, sr
, sr
, sr
, ts
, shl
, shlr
},
2857 {ts
, ts
, ts
, ts
, ts
, ts
, ts
, ts
, ts
, shl
, shlr
},
2859 {shl
, shl
, shl
, shl
, shl
, shl
, shl
, shl
, ts
, shl
, shlr
},
2861 {shlr
, shlr
, shlr
, shlr
, shlr
, shlr
, shlr
, shlr
, ts
, shlr
, shlr
}
2876 enum bpstat_what_main_action current_action
= BPSTAT_WHAT_KEEP_CHECKING
;
2877 struct bpstat_what retval
;
2879 retval
.call_dummy
= 0;
2880 for (; bs
!= NULL
; bs
= bs
->next
)
2882 enum class bs_class
= no_effect
;
2883 if (bs
->breakpoint_at
== NULL
)
2884 /* I suspect this can happen if it was a momentary breakpoint
2885 which has since been deleted. */
2887 switch (bs
->breakpoint_at
->type
)
2893 case bp_hardware_breakpoint
:
2899 bs_class
= bp_noisy
;
2901 bs_class
= bp_silent
;
2904 bs_class
= bp_nostop
;
2907 case bp_hardware_watchpoint
:
2908 case bp_read_watchpoint
:
2909 case bp_access_watchpoint
:
2913 bs_class
= wp_noisy
;
2915 bs_class
= wp_silent
;
2918 /* There was a watchpoint, but we're not stopping.
2919 This requires no further action. */
2920 bs_class
= no_effect
;
2923 bs_class
= long_jump
;
2925 case bp_longjmp_resume
:
2926 bs_class
= long_resume
;
2928 case bp_step_resume
:
2931 bs_class
= step_resume
;
2934 /* It is for the wrong frame. */
2935 bs_class
= bp_nostop
;
2937 case bp_through_sigtramp
:
2938 bs_class
= through_sig
;
2940 case bp_watchpoint_scope
:
2941 bs_class
= bp_nostop
;
2943 case bp_shlib_event
:
2944 bs_class
= shlib_event
;
2946 case bp_thread_event
:
2947 bs_class
= bp_nostop
;
2950 case bp_catch_unload
:
2951 /* Only if this catchpoint triggered should we cause the
2952 step-out-of-dld behaviour. Otherwise, we ignore this
2955 bs_class
= catch_shlib_event
;
2957 bs_class
= no_effect
;
2960 case bp_catch_vfork
:
2965 bs_class
= bp_noisy
;
2967 bs_class
= bp_silent
;
2970 /* There was a catchpoint, but we're not stopping.
2971 This requires no further action. */
2972 bs_class
= no_effect
;
2974 case bp_catch_catch
:
2975 if (!bs
->stop
|| CURRENT_EXCEPTION_KIND
!= EX_EVENT_CATCH
)
2976 bs_class
= bp_nostop
;
2978 bs_class
= bs
->print
? bp_noisy
: bp_silent
;
2980 case bp_catch_throw
:
2981 if (!bs
->stop
|| CURRENT_EXCEPTION_KIND
!= EX_EVENT_THROW
)
2982 bs_class
= bp_nostop
;
2984 bs_class
= bs
->print
? bp_noisy
: bp_silent
;
2987 /* Make sure the action is stop (silent or noisy),
2988 so infrun.c pops the dummy frame. */
2989 bs_class
= bp_silent
;
2990 retval
.call_dummy
= 1;
2993 current_action
= table
[(int) bs_class
][(int) current_action
];
2995 retval
.main_action
= current_action
;
2999 /* Nonzero if we should step constantly (e.g. watchpoints on machines
3000 without hardware support). This isn't related to a specific bpstat,
3001 just to things like whether watchpoints are set. */
3004 bpstat_should_step (void)
3006 struct breakpoint
*b
;
3008 if (b
->enable_state
== bp_enabled
&& b
->type
== bp_watchpoint
)
3013 /* Nonzero if there are enabled hardware watchpoints. */
3015 bpstat_have_active_hw_watchpoints (void)
3017 struct breakpoint
*b
;
3019 if ((b
->enable_state
== bp_enabled
) &&
3021 ((b
->type
== bp_hardware_watchpoint
) ||
3022 (b
->type
== bp_read_watchpoint
) ||
3023 (b
->type
== bp_access_watchpoint
)))
3029 /* Given a bpstat that records zero or more triggered eventpoints, this
3030 function returns another bpstat which contains only the catchpoints
3031 on that first list, if any. */
3033 bpstat_get_triggered_catchpoints (bpstat ep_list
, bpstat
*cp_list
)
3035 struct bpstats root_bs
[1];
3036 bpstat bs
= root_bs
;
3037 struct breakpoint
*ep
;
3040 bpstat_clear (cp_list
);
3041 root_bs
->next
= NULL
;
3043 for (; ep_list
!= NULL
; ep_list
= ep_list
->next
)
3045 /* Is this eventpoint a catchpoint? If not, ignore it. */
3046 ep
= ep_list
->breakpoint_at
;
3049 if ((ep
->type
!= bp_catch_load
) &&
3050 (ep
->type
!= bp_catch_unload
) &&
3051 (ep
->type
!= bp_catch_catch
) &&
3052 (ep
->type
!= bp_catch_throw
))
3053 /* pai: (temp) ADD fork/vfork here!! */
3056 /* Yes; add it to the list. */
3057 bs
= bpstat_alloc (ep
, bs
);
3062 #if defined(SOLIB_ADD)
3063 /* Also, for each triggered catchpoint, tag it with the name of
3064 the library that caused this trigger. (We copy the name now,
3065 because it's only guaranteed to be available NOW, when the
3066 catchpoint triggers. Clients who may wish to know the name
3067 later must get it from the catchpoint itself.) */
3068 if (ep
->triggered_dll_pathname
!= NULL
)
3069 xfree (ep
->triggered_dll_pathname
);
3070 if (ep
->type
== bp_catch_load
)
3071 dll_pathname
= SOLIB_LOADED_LIBRARY_PATHNAME (
3072 PIDGET (inferior_ptid
));
3074 dll_pathname
= SOLIB_UNLOADED_LIBRARY_PATHNAME (
3075 PIDGET (inferior_ptid
));
3077 dll_pathname
= NULL
;
3081 ep
->triggered_dll_pathname
= (char *)
3082 xmalloc (strlen (dll_pathname
) + 1);
3083 strcpy (ep
->triggered_dll_pathname
, dll_pathname
);
3086 ep
->triggered_dll_pathname
= NULL
;
3092 /* Print B to gdb_stdout. */
3094 print_one_breakpoint (struct breakpoint
*b
,
3095 CORE_ADDR
*last_addr
)
3097 register struct command_line
*l
;
3098 register struct symbol
*sym
;
3099 struct ep_type_description
3104 static struct ep_type_description bptypes
[] =
3106 {bp_none
, "?deleted?"},
3107 {bp_breakpoint
, "breakpoint"},
3108 {bp_hardware_breakpoint
, "hw breakpoint"},
3109 {bp_until
, "until"},
3110 {bp_finish
, "finish"},
3111 {bp_watchpoint
, "watchpoint"},
3112 {bp_hardware_watchpoint
, "hw watchpoint"},
3113 {bp_read_watchpoint
, "read watchpoint"},
3114 {bp_access_watchpoint
, "acc watchpoint"},
3115 {bp_longjmp
, "longjmp"},
3116 {bp_longjmp_resume
, "longjmp resume"},
3117 {bp_step_resume
, "step resume"},
3118 {bp_through_sigtramp
, "sigtramp"},
3119 {bp_watchpoint_scope
, "watchpoint scope"},
3120 {bp_call_dummy
, "call dummy"},
3121 {bp_shlib_event
, "shlib events"},
3122 {bp_thread_event
, "thread events"},
3123 {bp_catch_load
, "catch load"},
3124 {bp_catch_unload
, "catch unload"},
3125 {bp_catch_fork
, "catch fork"},
3126 {bp_catch_vfork
, "catch vfork"},
3127 {bp_catch_exec
, "catch exec"},
3128 {bp_catch_catch
, "catch catch"},
3129 {bp_catch_throw
, "catch throw"}
3132 static char *bpdisps
[] =
3133 {"del", "dstp", "dis", "keep"};
3134 static char bpenables
[] = "nynny";
3135 char wrap_indent
[80];
3137 struct ui_stream
*stb
= ui_out_stream_new (uiout
);
3138 struct cleanup
*old_chain
= make_cleanup_ui_out_stream_delete (stb
);
3143 ui_out_tuple_begin (uiout
, "bkpt");
3149 ui_out_field_int (uiout
, "number", b
->number
);
3151 printf_filtered ("%-3d ", b
->number
);
3156 if (((int) b
->type
> (sizeof (bptypes
) / sizeof (bptypes
[0])))
3157 || ((int) b
->type
!= bptypes
[(int) b
->type
].type
))
3158 internal_error (__FILE__
, __LINE__
,
3159 "bptypes table does not describe type #%d.",
3162 ui_out_field_string (uiout
, "type", bptypes
[(int) b
->type
].description
);
3164 printf_filtered ("%-14s ", bptypes
[(int) b
->type
].description
);
3170 ui_out_field_string (uiout
, "disp", bpdisps
[(int) b
->disposition
]);
3172 printf_filtered ("%-4s ", bpdisps
[(int) b
->disposition
]);
3178 ui_out_field_fmt (uiout
, "enabled", "%c", bpenables
[(int) b
->enable_state
]);
3179 ui_out_spaces (uiout
, 2);
3181 printf_filtered ("%-3c ", bpenables
[(int) b
->enable_state
]);
3185 strcpy (wrap_indent
, " ");
3188 if (TARGET_ADDR_BIT
<= 32)
3189 strcat (wrap_indent
, " ");
3191 strcat (wrap_indent
, " ");
3196 internal_error (__FILE__
, __LINE__
,
3197 "print_one_breakpoint: bp_none encountered\n");
3201 case bp_hardware_watchpoint
:
3202 case bp_read_watchpoint
:
3203 case bp_access_watchpoint
:
3204 /* Field 4, the address, is omitted (which makes the columns
3205 not line up too nicely with the headers, but the effect
3206 is relatively readable). */
3209 ui_out_field_skip (uiout
, "addr");
3211 print_expression (b
->exp
, stb
->stream
);
3212 ui_out_field_stream (uiout
, "what", stb
);
3215 print_expression (b
->exp
, gdb_stdout
);
3220 case bp_catch_unload
:
3221 /* Field 4, the address, is omitted (which makes the columns
3222 not line up too nicely with the headers, but the effect
3223 is relatively readable). */
3226 ui_out_field_skip (uiout
, "addr");
3228 if (b
->dll_pathname
== NULL
)
3230 ui_out_field_string (uiout
, "what", "<any library>");
3231 ui_out_spaces (uiout
, 1);
3235 ui_out_text (uiout
, "library \"");
3236 ui_out_field_string (uiout
, "what", b
->dll_pathname
);
3237 ui_out_text (uiout
, "\" ");
3241 if (b
->dll_pathname
== NULL
)
3242 printf_filtered ("<any library> ");
3244 printf_filtered ("library \"%s\" ", b
->dll_pathname
);
3249 case bp_catch_vfork
:
3250 /* Field 4, the address, is omitted (which makes the columns
3251 not line up too nicely with the headers, but the effect
3252 is relatively readable). */
3255 ui_out_field_skip (uiout
, "addr");
3257 if (b
->forked_inferior_pid
!= 0)
3259 ui_out_text (uiout
, "process ");
3260 ui_out_field_int (uiout
, "what", b
->forked_inferior_pid
);
3261 ui_out_spaces (uiout
, 1);
3265 if (b
->forked_inferior_pid
!= 0)
3266 printf_filtered ("process %d ", b
->forked_inferior_pid
);
3271 /* Field 4, the address, is omitted (which makes the columns
3272 not line up too nicely with the headers, but the effect
3273 is relatively readable). */
3276 ui_out_field_skip (uiout
, "addr");
3278 if (b
->exec_pathname
!= NULL
)
3280 ui_out_text (uiout
, "program \"");
3281 ui_out_field_string (uiout
, "what", b
->exec_pathname
);
3282 ui_out_text (uiout
, "\" ");
3286 if (b
->exec_pathname
!= NULL
)
3287 printf_filtered ("program \"%s\" ", b
->exec_pathname
);
3291 case bp_catch_catch
:
3292 /* Field 4, the address, is omitted (which makes the columns
3293 not line up too nicely with the headers, but the effect
3294 is relatively readable). */
3297 ui_out_field_skip (uiout
, "addr");
3299 ui_out_field_string (uiout
, "what", "exception catch");
3300 ui_out_spaces (uiout
, 1);
3303 printf_filtered ("exception catch ");
3307 case bp_catch_throw
:
3308 /* Field 4, the address, is omitted (which makes the columns
3309 not line up too nicely with the headers, but the effect
3310 is relatively readable). */
3313 ui_out_field_skip (uiout
, "addr");
3315 ui_out_field_string (uiout
, "what", "exception throw");
3316 ui_out_spaces (uiout
, 1);
3319 printf_filtered ("exception throw ");
3324 case bp_hardware_breakpoint
:
3328 case bp_longjmp_resume
:
3329 case bp_step_resume
:
3330 case bp_through_sigtramp
:
3331 case bp_watchpoint_scope
:
3333 case bp_shlib_event
:
3334 case bp_thread_event
:
3339 ui_out_field_core_addr (uiout
, "addr", b
->address
);
3342 *last_addr
= b
->address
;
3345 sym
= find_pc_sect_function (b
->address
, b
->section
);
3348 ui_out_text (uiout
, "in ");
3349 ui_out_field_string (uiout
, "func",
3350 SYMBOL_SOURCE_NAME (sym
));
3351 ui_out_wrap_hint (uiout
, wrap_indent
);
3352 ui_out_text (uiout
, " at ");
3354 ui_out_field_string (uiout
, "file", b
->source_file
);
3355 ui_out_text (uiout
, ":");
3356 ui_out_field_int (uiout
, "line", b
->line_number
);
3360 print_address_symbolic (b
->address
, stb
->stream
, demangle
, "");
3361 ui_out_field_stream (uiout
, "at", stb
);
3370 if (TARGET_ADDR_BIT
<= 32)
3371 tmp
= longest_local_hex_string_custom (b
->address
3372 & (CORE_ADDR
) 0xffffffff,
3375 tmp
= longest_local_hex_string_custom (b
->address
, "016l");
3377 printf_filtered ("%s ", tmp
);
3380 *last_addr
= b
->address
;
3383 sym
= find_pc_sect_function (b
->address
, b
->section
);
3386 fputs_filtered ("in ", gdb_stdout
);
3387 fputs_filtered (SYMBOL_SOURCE_NAME (sym
), gdb_stdout
);
3388 wrap_here (wrap_indent
);
3389 fputs_filtered (" at ", gdb_stdout
);
3391 fputs_filtered (b
->source_file
, gdb_stdout
);
3392 printf_filtered (":%d", b
->line_number
);
3395 print_address_symbolic (b
->address
, gdb_stdout
, demangle
, " ");
3400 if (b
->thread
!= -1)
3403 /* FIXME: This seems to be redundant and lost here; see the
3404 "stop only in" line a little further down. */
3405 ui_out_text (uiout
, " thread ");
3406 ui_out_field_int (uiout
, "thread", b
->thread
);
3408 printf_filtered (" thread %d", b
->thread
);
3413 ui_out_text (uiout
, "\n");
3415 printf_filtered ("\n");
3422 ui_out_text (uiout
, "\tstop only in stack frame at ");
3423 ui_out_field_core_addr (uiout
, "frame", b
->frame
);
3424 ui_out_text (uiout
, "\n");
3426 printf_filtered ("\tstop only in stack frame at ");
3427 print_address_numeric (b
->frame
, 1, gdb_stdout
);
3428 printf_filtered ("\n");
3436 ui_out_text (uiout
, "\tstop only if ");
3437 print_expression (b
->cond
, stb
->stream
);
3438 ui_out_field_stream (uiout
, "cond", stb
);
3439 ui_out_text (uiout
, "\n");
3441 printf_filtered ("\tstop only if ");
3442 print_expression (b
->cond
, gdb_stdout
);
3443 printf_filtered ("\n");
3447 if (b
->thread
!= -1)
3449 /* FIXME should make an annotation for this */
3451 ui_out_text (uiout
, "\tstop only in thread ");
3452 ui_out_field_int (uiout
, "thread", b
->thread
);
3453 ui_out_text (uiout
, "\n");
3455 printf_filtered ("\tstop only in thread %d\n", b
->thread
);
3459 if (show_breakpoint_hit_counts
&& b
->hit_count
)
3461 /* FIXME should make an annotation for this */
3463 if (ep_is_catchpoint (b
))
3464 ui_out_text (uiout
, "\tcatchpoint");
3466 ui_out_text (uiout
, "\tbreakpoint");
3467 ui_out_text (uiout
, " already hit ");
3468 ui_out_field_int (uiout
, "times", b
->hit_count
);
3469 if (b
->hit_count
== 1)
3470 ui_out_text (uiout
, " time\n");
3472 ui_out_text (uiout
, " times\n");
3474 if (ep_is_catchpoint (b
))
3475 printf_filtered ("\tcatchpoint");
3477 printf_filtered ("\tbreakpoint");
3478 printf_filtered (" already hit %d time%s\n",
3479 b
->hit_count
, (b
->hit_count
== 1 ? "" : "s"));
3484 /* Output the count also if it is zero, but only if this is
3485 mi. FIXME: Should have a better test for this. */
3486 if (ui_out_is_mi_like_p (uiout
))
3487 if (show_breakpoint_hit_counts
&& b
->hit_count
== 0)
3488 ui_out_field_int (uiout
, "times", b
->hit_count
);
3491 if (b
->ignore_count
)
3495 ui_out_text (uiout
, "\tignore next ");
3496 ui_out_field_int (uiout
, "ignore", b
->ignore_count
);
3497 ui_out_text (uiout
, " hits\n");
3499 printf_filtered ("\tignore next %d hits\n", b
->ignore_count
);
3503 if ((l
= b
->commands
))
3507 ui_out_tuple_begin (uiout
, "script");
3508 print_command_lines (uiout
, l
, 4);
3509 ui_out_tuple_end (uiout
);
3513 print_command_line (l
, 4, gdb_stdout
);
3519 ui_out_tuple_end (uiout
);
3520 do_cleanups (old_chain
);
3524 struct captured_breakpoint_query_args
3530 do_captured_breakpoint_query (struct ui_out
*uiout
, void *data
)
3532 struct captured_breakpoint_query_args
*args
= data
;
3533 register struct breakpoint
*b
;
3534 CORE_ADDR dummy_addr
= 0;
3537 if (args
->bnum
== b
->number
)
3539 print_one_breakpoint (b
, &dummy_addr
);
3547 gdb_breakpoint_query (struct ui_out
*uiout
, int bnum
)
3549 struct captured_breakpoint_query_args args
;
3551 /* For the moment we don't trust print_one_breakpoint() to not throw
3553 return catch_exceptions (uiout
, do_captured_breakpoint_query
, &args
,
3554 NULL
, RETURN_MASK_ALL
);
3557 /* Return non-zero if B is user settable (breakpoints, watchpoints,
3558 catchpoints, et.al.). */
3561 user_settable_breakpoint (const struct breakpoint
*b
)
3563 return (b
->type
== bp_breakpoint
3564 || b
->type
== bp_catch_load
3565 || b
->type
== bp_catch_unload
3566 || b
->type
== bp_catch_fork
3567 || b
->type
== bp_catch_vfork
3568 || b
->type
== bp_catch_exec
3569 || b
->type
== bp_catch_catch
3570 || b
->type
== bp_catch_throw
3571 || b
->type
== bp_hardware_breakpoint
3572 || b
->type
== bp_watchpoint
3573 || b
->type
== bp_read_watchpoint
3574 || b
->type
== bp_access_watchpoint
3575 || b
->type
== bp_hardware_watchpoint
);
3578 /* Print information on user settable breakpoint (watchpoint, etc)
3579 number BNUM. If BNUM is -1 print all user settable breakpoints.
3580 If ALLFLAG is non-zero, include non- user settable breakpoints. */
3583 breakpoint_1 (int bnum
, int allflag
)
3585 register struct breakpoint
*b
;
3586 CORE_ADDR last_addr
= (CORE_ADDR
) -1;
3587 int nr_printable_breakpoints
;
3589 /* Compute the number of rows in the table. */
3590 nr_printable_breakpoints
= 0;
3593 || bnum
== b
->number
)
3595 if (allflag
|| user_settable_breakpoint (b
))
3596 nr_printable_breakpoints
++;
3601 ui_out_table_begin (uiout
, 6, nr_printable_breakpoints
, "BreakpointTable");
3603 ui_out_table_begin (uiout
, 5, nr_printable_breakpoints
, "BreakpointTable");
3607 if (nr_printable_breakpoints
> 0)
3608 annotate_breakpoints_headers ();
3609 if (nr_printable_breakpoints
> 0)
3611 ui_out_table_header (uiout
, 3, ui_left
, "number", "Num"); /* 1 */
3612 if (nr_printable_breakpoints
> 0)
3614 ui_out_table_header (uiout
, 14, ui_left
, "type", "Type"); /* 2 */
3615 if (nr_printable_breakpoints
> 0)
3617 ui_out_table_header (uiout
, 4, ui_left
, "disp", "Disp"); /* 3 */
3618 if (nr_printable_breakpoints
> 0)
3620 ui_out_table_header (uiout
, 3, ui_left
, "enabled", "Enb"); /* 4 */
3623 if (nr_printable_breakpoints
> 0)
3625 if (TARGET_ADDR_BIT
<= 32)
3626 ui_out_table_header (uiout
, 10, ui_left
, "addr", "Address");/* 5 */
3628 ui_out_table_header (uiout
, 18, ui_left
, "addr", "Address");/* 5 */
3630 if (nr_printable_breakpoints
> 0)
3632 ui_out_table_header (uiout
, 40, ui_noalign
, "what", "What"); /* 6 */
3633 ui_out_table_body (uiout
);
3634 if (nr_printable_breakpoints
> 0)
3635 annotate_breakpoints_table ();
3637 if (nr_printable_breakpoints
> 0)
3639 annotate_breakpoints_headers ();
3641 printf_filtered ("Num ");
3643 printf_filtered ("Type ");
3645 printf_filtered ("Disp ");
3647 printf_filtered ("Enb ");
3651 if (TARGET_ADDR_BIT
<= 32)
3652 printf_filtered ("Address ");
3654 printf_filtered ("Address ");
3657 printf_filtered ("What\n");
3658 annotate_breakpoints_table ();
3664 || bnum
== b
->number
)
3666 /* We only print out user settable breakpoints unless the
3668 if (allflag
|| user_settable_breakpoint (b
))
3669 print_one_breakpoint (b
, &last_addr
);
3674 ui_out_table_end (uiout
);
3677 if (nr_printable_breakpoints
== 0)
3681 ui_out_message (uiout
, 0, "No breakpoints or watchpoints.\n");
3683 ui_out_message (uiout
, 0, "No breakpoint or watchpoint number %d.\n",
3687 printf_filtered ("No breakpoints or watchpoints.\n");
3689 printf_filtered ("No breakpoint or watchpoint number %d.\n", bnum
);
3694 /* Compare against (CORE_ADDR)-1 in case some compiler decides
3695 that a comparison of an unsigned with -1 is always false. */
3696 if (last_addr
!= (CORE_ADDR
) -1)
3697 set_next_address (last_addr
);
3700 /* FIXME? Should this be moved up so that it is only called when
3701 there have been breakpoints? */
3702 annotate_breakpoints_table_end ();
3707 breakpoints_info (char *bnum_exp
, int from_tty
)
3712 bnum
= parse_and_eval_long (bnum_exp
);
3714 breakpoint_1 (bnum
, 0);
3719 maintenance_info_breakpoints (char *bnum_exp
, int from_tty
)
3724 bnum
= parse_and_eval_long (bnum_exp
);
3726 breakpoint_1 (bnum
, 1);
3729 /* Print a message describing any breakpoints set at PC. */
3732 describe_other_breakpoints (CORE_ADDR pc
, asection
*section
)
3734 register int others
= 0;
3735 register struct breakpoint
*b
;
3738 if (b
->address
== pc
)
3739 if (overlay_debugging
== 0 ||
3740 b
->section
== section
)
3744 printf_filtered ("Note: breakpoint%s ", (others
> 1) ? "s" : "");
3746 if (b
->address
== pc
)
3747 if (overlay_debugging
== 0 ||
3748 b
->section
== section
)
3751 printf_filtered ("%d%s%s ",
3753 ((b
->enable_state
== bp_disabled
||
3754 b
->enable_state
== bp_shlib_disabled
||
3755 b
->enable_state
== bp_call_disabled
) ? " (disabled)"
3756 : b
->enable_state
== bp_permanent
? " (permanent)"
3759 : ((others
== 1) ? " and" : ""));
3761 printf_filtered ("also set at pc ");
3762 print_address_numeric (pc
, 1, gdb_stdout
);
3763 printf_filtered (".\n");
3767 /* Set the default place to put a breakpoint
3768 for the `break' command with no arguments. */
3771 set_default_breakpoint (int valid
, CORE_ADDR addr
, struct symtab
*symtab
,
3774 default_breakpoint_valid
= valid
;
3775 default_breakpoint_address
= addr
;
3776 default_breakpoint_symtab
= symtab
;
3777 default_breakpoint_line
= line
;
3780 /* Return true iff it is meaningful to use the address member of
3781 BPT. For some breakpoint types, the address member is irrelevant
3782 and it makes no sense to attempt to compare it to other addresses
3783 (or use it for any other purpose either).
3785 More specifically, each of the following breakpoint types will always
3786 have a zero valued address and we don't want check_duplicates() to mark
3787 breakpoints of any of these types to be a duplicate of an actual
3788 breakpoint at address zero:
3791 bp_hardware_watchpoint
3793 bp_access_watchpoint
3800 breakpoint_address_is_meaningful (struct breakpoint
*bpt
)
3802 enum bptype type
= bpt
->type
;
3804 return (type
!= bp_watchpoint
3805 && type
!= bp_hardware_watchpoint
3806 && type
!= bp_read_watchpoint
3807 && type
!= bp_access_watchpoint
3808 && type
!= bp_catch_exec
3809 && type
!= bp_longjmp_resume
3810 && type
!= bp_catch_fork
3811 && type
!= bp_catch_vfork
);
3814 /* Rescan breakpoints at the same address and section as BPT,
3815 marking the first one as "first" and any others as "duplicates".
3816 This is so that the bpt instruction is only inserted once.
3817 If we have a permanent breakpoint at the same place as BPT, make
3818 that one the official one, and the rest as duplicates. */
3821 check_duplicates (struct breakpoint
*bpt
)
3823 register struct breakpoint
*b
;
3824 register int count
= 0;
3825 struct breakpoint
*perm_bp
= 0;
3826 CORE_ADDR address
= bpt
->address
;
3827 asection
*section
= bpt
->section
;
3829 if (! breakpoint_address_is_meaningful (bpt
))
3833 if (b
->enable_state
!= bp_disabled
3834 && b
->enable_state
!= bp_shlib_disabled
3835 && b
->enable_state
!= bp_call_disabled
3836 && b
->address
== address
3837 && (overlay_debugging
== 0 || b
->section
== section
)
3838 && breakpoint_address_is_meaningful (b
))
3840 /* Have we found a permanent breakpoint? */
3841 if (b
->enable_state
== bp_permanent
)
3848 b
->duplicate
= count
> 1;
3851 /* If we found a permanent breakpoint at this address, go over the
3852 list again and declare all the other breakpoints there to be the
3856 perm_bp
->duplicate
= 0;
3858 /* Permanent breakpoint should always be inserted. */
3859 if (! perm_bp
->inserted
)
3860 internal_error (__FILE__
, __LINE__
,
3861 "allegedly permanent breakpoint is not "
3862 "actually inserted");
3868 internal_error (__FILE__
, __LINE__
,
3869 "another breakpoint was inserted on top of "
3870 "a permanent breakpoint");
3872 if (b
->enable_state
!= bp_disabled
3873 && b
->enable_state
!= bp_shlib_disabled
3874 && b
->enable_state
!= bp_call_disabled
3875 && b
->address
== address
3876 && (overlay_debugging
== 0 || b
->section
== section
)
3877 && breakpoint_address_is_meaningful (b
))
3883 /* set_raw_breakpoint() is a low level routine for allocating and
3884 partially initializing a breakpoint of type BPTYPE. The newly
3885 created breakpoint's address, section, source file name, and line
3886 number are provided by SAL. The newly created and partially
3887 initialized breakpoint is added to the breakpoint chain and
3888 is also returned as the value of this function.
3890 It is expected that the caller will complete the initialization of
3891 the newly created breakpoint struct as well as output any status
3892 information regarding the creation of a new breakpoint. In
3893 particular, set_raw_breakpoint() does NOT set the breakpoint
3894 number! Care should be taken to not allow an error() to occur
3895 prior to completing the initialization of the breakpoint. If this
3896 should happen, a bogus breakpoint will be left on the chain. */
3899 set_raw_breakpoint (struct symtab_and_line sal
, enum bptype bptype
)
3901 register struct breakpoint
*b
, *b1
;
3903 b
= (struct breakpoint
*) xmalloc (sizeof (struct breakpoint
));
3904 memset (b
, 0, sizeof (*b
));
3905 b
->address
= sal
.pc
;
3906 if (sal
.symtab
== NULL
)
3907 b
->source_file
= NULL
;
3909 b
->source_file
= savestring (sal
.symtab
->filename
,
3910 strlen (sal
.symtab
->filename
));
3911 b
->section
= sal
.section
;
3913 b
->language
= current_language
->la_language
;
3914 b
->input_radix
= input_radix
;
3916 b
->line_number
= sal
.line
;
3917 b
->enable_state
= bp_enabled
;
3920 b
->ignore_count
= 0;
3923 b
->dll_pathname
= NULL
;
3924 b
->triggered_dll_pathname
= NULL
;
3925 b
->forked_inferior_pid
= 0;
3926 b
->exec_pathname
= NULL
;
3928 /* Add this breakpoint to the end of the chain
3929 so that a list of breakpoints will come out in order
3930 of increasing numbers. */
3932 b1
= breakpoint_chain
;
3934 breakpoint_chain
= b
;
3942 check_duplicates (b
);
3943 breakpoints_changed ();
3949 /* Note that the breakpoint object B describes a permanent breakpoint
3950 instruction, hard-wired into the inferior's code. */
3952 make_breakpoint_permanent (struct breakpoint
*b
)
3954 b
->enable_state
= bp_permanent
;
3956 /* By definition, permanent breakpoints are already present in the code. */
3960 #ifdef GET_LONGJMP_TARGET
3963 create_longjmp_breakpoint (char *func_name
)
3965 struct symtab_and_line sal
;
3966 struct breakpoint
*b
;
3968 INIT_SAL (&sal
); /* initialize to zeroes */
3969 if (func_name
!= NULL
)
3971 struct minimal_symbol
*m
;
3973 m
= lookup_minimal_symbol_text (func_name
, NULL
,
3974 (struct objfile
*) NULL
);
3976 sal
.pc
= SYMBOL_VALUE_ADDRESS (m
);
3980 sal
.section
= find_pc_overlay (sal
.pc
);
3981 b
= set_raw_breakpoint (sal
,
3982 func_name
!= NULL
? bp_longjmp
: bp_longjmp_resume
);
3984 b
->disposition
= disp_donttouch
;
3985 b
->enable_state
= bp_disabled
;
3988 b
->addr_string
= xstrdup (func_name
);
3989 b
->number
= internal_breakpoint_number
--;
3992 #endif /* #ifdef GET_LONGJMP_TARGET */
3994 /* Call this routine when stepping and nexting to enable a breakpoint
3995 if we do a longjmp(). When we hit that breakpoint, call
3996 set_longjmp_resume_breakpoint() to figure out where we are going. */
3999 enable_longjmp_breakpoint (void)
4001 register struct breakpoint
*b
;
4004 if (b
->type
== bp_longjmp
)
4006 b
->enable_state
= bp_enabled
;
4007 check_duplicates (b
);
4012 disable_longjmp_breakpoint (void)
4014 register struct breakpoint
*b
;
4017 if (b
->type
== bp_longjmp
4018 || b
->type
== bp_longjmp_resume
)
4020 b
->enable_state
= bp_disabled
;
4021 check_duplicates (b
);
4026 create_thread_event_breakpoint (CORE_ADDR address
)
4028 struct breakpoint
*b
;
4029 struct symtab_and_line sal
;
4030 char addr_string
[80]; /* Surely an addr can't be longer than that. */
4032 INIT_SAL (&sal
); /* initialize to zeroes */
4034 sal
.section
= find_pc_overlay (sal
.pc
);
4035 b
= set_raw_breakpoint (sal
, bp_thread_event
);
4037 b
->number
= internal_breakpoint_number
--;
4038 b
->disposition
= disp_donttouch
;
4039 b
->enable_state
= bp_enabled
;
4040 /* addr_string has to be used or breakpoint_re_set will delete me. */
4041 sprintf (addr_string
, "*0x%s", paddr (b
->address
));
4042 b
->addr_string
= xstrdup (addr_string
);
4048 remove_thread_event_breakpoints (void)
4050 struct breakpoint
*b
, *temp
;
4052 ALL_BREAKPOINTS_SAFE (b
, temp
)
4053 if (b
->type
== bp_thread_event
)
4054 delete_breakpoint (b
);
4059 remove_solib_event_breakpoints (void)
4061 register struct breakpoint
*b
, *temp
;
4063 ALL_BREAKPOINTS_SAFE (b
, temp
)
4064 if (b
->type
== bp_shlib_event
)
4065 delete_breakpoint (b
);
4069 create_solib_event_breakpoint (CORE_ADDR address
)
4071 struct breakpoint
*b
;
4072 struct symtab_and_line sal
;
4074 INIT_SAL (&sal
); /* initialize to zeroes */
4076 sal
.section
= find_pc_overlay (sal
.pc
);
4077 b
= set_raw_breakpoint (sal
, bp_shlib_event
);
4078 b
->number
= internal_breakpoint_number
--;
4079 b
->disposition
= disp_donttouch
;
4084 /* Disable any breakpoints that are on code in shared libraries. Only
4085 apply to enabled breakpoints, disabled ones can just stay disabled. */
4088 disable_breakpoints_in_shlibs (int silent
)
4090 struct breakpoint
*b
;
4091 int disabled_shlib_breaks
= 0;
4093 /* See also: insert_breakpoints, under DISABLE_UNSETTABLE_BREAK. */
4096 #if defined (PC_SOLIB)
4097 if (((b
->type
== bp_breakpoint
) ||
4098 (b
->type
== bp_hardware_breakpoint
)) &&
4099 b
->enable_state
== bp_enabled
&&
4101 PC_SOLIB (b
->address
))
4103 b
->enable_state
= bp_shlib_disabled
;
4106 if (!disabled_shlib_breaks
)
4108 target_terminal_ours_for_output ();
4109 warning ("Temporarily disabling shared library breakpoints:");
4111 disabled_shlib_breaks
= 1;
4112 warning ("breakpoint #%d ", b
->number
);
4119 /* Try to reenable any breakpoints in shared libraries. */
4121 re_enable_breakpoints_in_shlibs (void)
4123 struct breakpoint
*b
;
4126 if (b
->enable_state
== bp_shlib_disabled
)
4130 /* Do not reenable the breakpoint if the shared library
4131 is still not mapped in. */
4132 if (target_read_memory (b
->address
, buf
, 1) == 0)
4133 b
->enable_state
= bp_enabled
;
4140 solib_load_unload_1 (char *hookname
, int tempflag
, char *dll_pathname
,
4141 char *cond_string
, enum bptype bp_kind
)
4143 struct breakpoint
*b
;
4144 struct symtabs_and_lines sals
;
4145 struct cleanup
*old_chain
;
4146 struct cleanup
*canonical_strings_chain
= NULL
;
4147 char *addr_start
= hookname
;
4148 char *addr_end
= NULL
;
4149 char **canonical
= (char **) NULL
;
4150 int thread
= -1; /* All threads. */
4152 /* Set a breakpoint on the specified hook. */
4153 sals
= decode_line_1 (&hookname
, 1, (struct symtab
*) NULL
, 0, &canonical
);
4154 addr_end
= hookname
;
4156 if (sals
.nelts
== 0)
4158 warning ("Unable to set a breakpoint on dynamic linker callback.");
4159 warning ("Suggest linking with /opt/langtools/lib/end.o.");
4160 warning ("GDB will be unable to track shl_load/shl_unload calls");
4163 if (sals
.nelts
!= 1)
4165 warning ("Unable to set unique breakpoint on dynamic linker callback.");
4166 warning ("GDB will be unable to track shl_load/shl_unload calls");
4170 /* Make sure that all storage allocated in decode_line_1 gets freed
4171 in case the following errors out. */
4172 old_chain
= make_cleanup (xfree
, sals
.sals
);
4173 if (canonical
!= (char **) NULL
)
4175 make_cleanup (xfree
, canonical
);
4176 canonical_strings_chain
= make_cleanup (null_cleanup
, 0);
4177 if (canonical
[0] != NULL
)
4178 make_cleanup (xfree
, canonical
[0]);
4181 resolve_sal_pc (&sals
.sals
[0]);
4183 /* Remove the canonical strings from the cleanup, they are needed below. */
4184 if (canonical
!= (char **) NULL
)
4185 discard_cleanups (canonical_strings_chain
);
4187 b
= set_raw_breakpoint (sals
.sals
[0], bp_kind
);
4188 set_breakpoint_count (breakpoint_count
+ 1);
4189 b
->number
= breakpoint_count
;
4191 b
->cond_string
= (cond_string
== NULL
) ?
4192 NULL
: savestring (cond_string
, strlen (cond_string
));
4195 if (canonical
!= (char **) NULL
&& canonical
[0] != NULL
)
4196 b
->addr_string
= canonical
[0];
4197 else if (addr_start
)
4198 b
->addr_string
= savestring (addr_start
, addr_end
- addr_start
);
4200 b
->enable_state
= bp_enabled
;
4201 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
4203 if (dll_pathname
== NULL
)
4204 b
->dll_pathname
= NULL
;
4207 b
->dll_pathname
= (char *) xmalloc (strlen (dll_pathname
) + 1);
4208 strcpy (b
->dll_pathname
, dll_pathname
);
4212 do_cleanups (old_chain
);
4216 create_solib_load_event_breakpoint (char *hookname
, int tempflag
,
4217 char *dll_pathname
, char *cond_string
)
4219 solib_load_unload_1 (hookname
, tempflag
, dll_pathname
,
4220 cond_string
, bp_catch_load
);
4224 create_solib_unload_event_breakpoint (char *hookname
, int tempflag
,
4225 char *dll_pathname
, char *cond_string
)
4227 solib_load_unload_1 (hookname
,tempflag
, dll_pathname
,
4228 cond_string
, bp_catch_unload
);
4232 create_fork_vfork_event_catchpoint (int tempflag
, char *cond_string
,
4233 enum bptype bp_kind
)
4235 struct symtab_and_line sal
;
4236 struct breakpoint
*b
;
4237 int thread
= -1; /* All threads. */
4244 b
= set_raw_breakpoint (sal
, bp_kind
);
4245 set_breakpoint_count (breakpoint_count
+ 1);
4246 b
->number
= breakpoint_count
;
4248 b
->cond_string
= (cond_string
== NULL
) ?
4249 NULL
: savestring (cond_string
, strlen (cond_string
));
4251 b
->addr_string
= NULL
;
4252 b
->enable_state
= bp_enabled
;
4253 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
4254 b
->forked_inferior_pid
= 0;
4260 create_fork_event_catchpoint (int tempflag
, char *cond_string
)
4262 create_fork_vfork_event_catchpoint (tempflag
, cond_string
, bp_catch_fork
);
4266 create_vfork_event_catchpoint (int tempflag
, char *cond_string
)
4268 create_fork_vfork_event_catchpoint (tempflag
, cond_string
, bp_catch_vfork
);
4272 create_exec_event_catchpoint (int tempflag
, char *cond_string
)
4274 struct symtab_and_line sal
;
4275 struct breakpoint
*b
;
4276 int thread
= -1; /* All threads. */
4283 b
= set_raw_breakpoint (sal
, bp_catch_exec
);
4284 set_breakpoint_count (breakpoint_count
+ 1);
4285 b
->number
= breakpoint_count
;
4287 b
->cond_string
= (cond_string
== NULL
) ?
4288 NULL
: savestring (cond_string
, strlen (cond_string
));
4290 b
->addr_string
= NULL
;
4291 b
->enable_state
= bp_enabled
;
4292 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
4298 hw_breakpoint_used_count (void)
4300 register struct breakpoint
*b
;
4305 if (b
->type
== bp_hardware_breakpoint
&& b
->enable_state
== bp_enabled
)
4313 hw_watchpoint_used_count (enum bptype type
, int *other_type_used
)
4315 register struct breakpoint
*b
;
4318 *other_type_used
= 0;
4321 if (b
->enable_state
== bp_enabled
)
4323 if (b
->type
== type
)
4325 else if ((b
->type
== bp_hardware_watchpoint
||
4326 b
->type
== bp_read_watchpoint
||
4327 b
->type
== bp_access_watchpoint
)
4328 && b
->enable_state
== bp_enabled
)
4329 *other_type_used
= 1;
4335 /* Call this after hitting the longjmp() breakpoint. Use this to set
4336 a new breakpoint at the target of the jmp_buf.
4338 FIXME - This ought to be done by setting a temporary breakpoint
4339 that gets deleted automatically... */
4342 set_longjmp_resume_breakpoint (CORE_ADDR pc
, struct frame_info
*frame
)
4344 register struct breakpoint
*b
;
4347 if (b
->type
== bp_longjmp_resume
)
4350 b
->enable_state
= bp_enabled
;
4352 b
->frame
= frame
->frame
;
4355 check_duplicates (b
);
4361 disable_watchpoints_before_interactive_call_start (void)
4363 struct breakpoint
*b
;
4367 if (((b
->type
== bp_watchpoint
)
4368 || (b
->type
== bp_hardware_watchpoint
)
4369 || (b
->type
== bp_read_watchpoint
)
4370 || (b
->type
== bp_access_watchpoint
)
4371 || ep_is_exception_catchpoint (b
))
4372 && (b
->enable_state
== bp_enabled
))
4374 b
->enable_state
= bp_call_disabled
;
4375 check_duplicates (b
);
4381 enable_watchpoints_after_interactive_call_stop (void)
4383 struct breakpoint
*b
;
4387 if (((b
->type
== bp_watchpoint
)
4388 || (b
->type
== bp_hardware_watchpoint
)
4389 || (b
->type
== bp_read_watchpoint
)
4390 || (b
->type
== bp_access_watchpoint
)
4391 || ep_is_exception_catchpoint (b
))
4392 && (b
->enable_state
== bp_call_disabled
))
4394 b
->enable_state
= bp_enabled
;
4395 check_duplicates (b
);
4401 /* Set a breakpoint that will evaporate an end of command
4402 at address specified by SAL.
4403 Restrict it to frame FRAME if FRAME is nonzero. */
4406 set_momentary_breakpoint (struct symtab_and_line sal
, struct frame_info
*frame
,
4409 register struct breakpoint
*b
;
4410 b
= set_raw_breakpoint (sal
, type
);
4411 b
->enable_state
= bp_enabled
;
4412 b
->disposition
= disp_donttouch
;
4413 b
->frame
= (frame
? frame
->frame
: 0);
4415 /* If we're debugging a multi-threaded program, then we
4416 want momentary breakpoints to be active in only a
4417 single thread of control. */
4418 if (in_thread_list (inferior_ptid
))
4419 b
->thread
= pid_to_thread_id (inferior_ptid
);
4425 /* Tell the user we have just set a breakpoint B. */
4428 mention (struct breakpoint
*b
)
4432 struct cleanup
*old_chain
;
4433 struct ui_stream
*stb
;
4435 stb
= ui_out_stream_new (uiout
);
4436 old_chain
= make_cleanup_ui_out_stream_delete (stb
);
4439 /* FIXME: This is misplaced; mention() is called by things (like hitting a
4440 watchpoint) other than breakpoint creation. It should be possible to
4441 clean this up and at the same time replace the random calls to
4442 breakpoint_changed with this hook, as has already been done for
4443 delete_breakpoint_hook and so on. */
4444 if (create_breakpoint_hook
)
4445 create_breakpoint_hook (b
);
4446 breakpoint_create_event (b
->number
);
4451 printf_filtered ("(apparently deleted?) Eventpoint %d: ", b
->number
);
4455 ui_out_text (uiout
, "Watchpoint ");
4456 ui_out_tuple_begin (uiout
, "wpt");
4457 ui_out_field_int (uiout
, "number", b
->number
);
4458 ui_out_text (uiout
, ": ");
4459 print_expression (b
->exp
, stb
->stream
);
4460 ui_out_field_stream (uiout
, "exp", stb
);
4461 ui_out_tuple_end (uiout
);
4463 case bp_hardware_watchpoint
:
4464 ui_out_text (uiout
, "Hardware watchpoint ");
4465 ui_out_tuple_begin (uiout
, "wpt");
4466 ui_out_field_int (uiout
, "number", b
->number
);
4467 ui_out_text (uiout
, ": ");
4468 print_expression (b
->exp
, stb
->stream
);
4469 ui_out_field_stream (uiout
, "exp", stb
);
4470 ui_out_tuple_end (uiout
);
4474 printf_filtered ("Watchpoint %d: ", b
->number
);
4475 print_expression (b
->exp
, gdb_stdout
);
4477 case bp_hardware_watchpoint
:
4478 printf_filtered ("Hardware watchpoint %d: ", b
->number
);
4479 print_expression (b
->exp
, gdb_stdout
);
4483 case bp_read_watchpoint
:
4484 ui_out_text (uiout
, "Hardware read watchpoint ");
4485 ui_out_tuple_begin (uiout
, "hw-rwpt");
4486 ui_out_field_int (uiout
, "number", b
->number
);
4487 ui_out_text (uiout
, ": ");
4488 print_expression (b
->exp
, stb
->stream
);
4489 ui_out_field_stream (uiout
, "exp", stb
);
4490 ui_out_tuple_end (uiout
);
4492 case bp_access_watchpoint
:
4493 ui_out_text (uiout
, "Hardware access (read/write) watchpoint ");
4494 ui_out_tuple_begin (uiout
, "hw-awpt");
4495 ui_out_field_int (uiout
, "number", b
->number
);
4496 ui_out_text (uiout
, ": ");
4497 print_expression (b
->exp
, stb
->stream
);
4498 ui_out_field_stream (uiout
, "exp", stb
);
4499 ui_out_tuple_end (uiout
);
4502 case bp_read_watchpoint
:
4503 printf_filtered ("Hardware read watchpoint %d: ", b
->number
);
4504 print_expression (b
->exp
, gdb_stdout
);
4506 case bp_access_watchpoint
:
4507 printf_filtered ("Hardware access (read/write) watchpoint %d: ",
4509 print_expression (b
->exp
, gdb_stdout
);
4514 if (ui_out_is_mi_like_p (uiout
))
4520 printf_filtered ("Breakpoint %d", b
->number
);
4523 case bp_hardware_breakpoint
:
4525 if (ui_out_is_mi_like_p (uiout
))
4531 printf_filtered ("Hardware assisted breakpoint %d", b
->number
);
4535 case bp_catch_unload
:
4536 printf_filtered ("Catchpoint %d (%s %s)",
4538 (b
->type
== bp_catch_load
) ? "load" : "unload",
4539 (b
->dll_pathname
!= NULL
) ?
4540 b
->dll_pathname
: "<any library>");
4543 case bp_catch_vfork
:
4544 printf_filtered ("Catchpoint %d (%s)",
4546 (b
->type
== bp_catch_fork
) ? "fork" : "vfork");
4549 printf_filtered ("Catchpoint %d (exec)",
4552 case bp_catch_catch
:
4553 case bp_catch_throw
:
4554 printf_filtered ("Catchpoint %d (%s)",
4556 (b
->type
== bp_catch_catch
) ? "catch" : "throw");
4562 case bp_longjmp_resume
:
4563 case bp_step_resume
:
4564 case bp_through_sigtramp
:
4566 case bp_watchpoint_scope
:
4567 case bp_shlib_event
:
4568 case bp_thread_event
:
4573 if (addressprint
|| b
->source_file
== NULL
)
4575 printf_filtered (" at ");
4576 print_address_numeric (b
->address
, 1, gdb_stdout
);
4579 printf_filtered (": file %s, line %d.",
4580 b
->source_file
, b
->line_number
);
4583 do_cleanups (old_chain
);
4586 if (ui_out_is_mi_like_p (uiout
))
4589 printf_filtered ("\n");
4593 /* Add SALS.nelts breakpoints to the breakpoint table. For each
4594 SALS.sal[i] breakpoint, include the corresponding ADDR_STRING[i],
4595 COND[i] and COND_STRING[i] values.
4597 NOTE: If the function succeeds, the caller is expected to cleanup
4598 the arrays ADDR_STRING, COND_STRING, COND and SALS (but not the
4599 array contents). If the function fails (error() is called), the
4600 caller is expected to cleanups both the ADDR_STRING, COND_STRING,
4601 COND and SALS arrays and each of those arrays contents. */
4604 create_breakpoints (struct symtabs_and_lines sals
, char **addr_string
,
4605 struct expression
**cond
, char **cond_string
,
4606 enum bptype type
, enum bpdisp disposition
,
4607 int thread
, int ignore_count
, int from_tty
)
4609 if (type
== bp_hardware_breakpoint
)
4611 int i
= hw_breakpoint_used_count ();
4612 int target_resources_ok
=
4613 TARGET_CAN_USE_HARDWARE_WATCHPOINT (bp_hardware_breakpoint
,
4615 if (target_resources_ok
== 0)
4616 error ("No hardware breakpoint support in the target.");
4617 else if (target_resources_ok
< 0)
4618 error ("Hardware breakpoints used exceeds limit.");
4621 /* Now set all the breakpoints. */
4624 for (i
= 0; i
< sals
.nelts
; i
++)
4626 struct breakpoint
*b
;
4627 struct symtab_and_line sal
= sals
.sals
[i
];
4630 describe_other_breakpoints (sal
.pc
, sal
.section
);
4632 b
= set_raw_breakpoint (sal
, type
);
4633 set_breakpoint_count (breakpoint_count
+ 1);
4634 b
->number
= breakpoint_count
;
4637 b
->addr_string
= addr_string
[i
];
4638 b
->cond_string
= cond_string
[i
];
4639 b
->ignore_count
= ignore_count
;
4640 b
->enable_state
= bp_enabled
;
4641 b
->disposition
= disposition
;
4647 /* Parse ARG which is assumed to be a SAL specification possibly
4648 followed by conditionals. On return, SALS contains an array of SAL
4649 addresses found. ADDR_STRING contains a vector of (canonical)
4650 address strings. ARG points to the end of the SAL. */
4653 parse_breakpoint_sals (char **address
,
4654 struct symtabs_and_lines
*sals
,
4655 char ***addr_string
)
4657 char *addr_start
= *address
;
4658 *addr_string
= NULL
;
4659 /* If no arg given, or if first arg is 'if ', use the default
4661 if ((*address
) == NULL
4662 || (strncmp ((*address
), "if", 2) == 0 && isspace ((*address
)[2])))
4664 if (default_breakpoint_valid
)
4666 struct symtab_and_line sal
;
4667 INIT_SAL (&sal
); /* initialize to zeroes */
4668 sals
->sals
= (struct symtab_and_line
*)
4669 xmalloc (sizeof (struct symtab_and_line
));
4670 sal
.pc
= default_breakpoint_address
;
4671 sal
.line
= default_breakpoint_line
;
4672 sal
.symtab
= default_breakpoint_symtab
;
4673 sal
.section
= find_pc_overlay (sal
.pc
);
4674 sals
->sals
[0] = sal
;
4678 error ("No default breakpoint address now.");
4682 /* Force almost all breakpoints to be in terms of the
4683 current_source_symtab (which is decode_line_1's default). This
4684 should produce the results we want almost all of the time while
4685 leaving default_breakpoint_* alone. */
4686 if (default_breakpoint_valid
4687 && (!current_source_symtab
4688 || (strchr ("+-", (*address
)[0]) != NULL
)))
4689 *sals
= decode_line_1 (address
, 1, default_breakpoint_symtab
,
4690 default_breakpoint_line
, addr_string
);
4692 *sals
= decode_line_1 (address
, 1, (struct symtab
*) NULL
, 0, addr_string
);
4694 /* For any SAL that didn't have a canonical string, fill one in. */
4695 if (sals
->nelts
> 0 && *addr_string
== NULL
)
4696 *addr_string
= xcalloc (sals
->nelts
, sizeof (char **));
4697 if (addr_start
!= (*address
))
4700 for (i
= 0; i
< sals
->nelts
; i
++)
4702 /* Add the string if not present. */
4703 if ((*addr_string
)[i
] == NULL
)
4704 (*addr_string
)[i
] = savestring (addr_start
, (*address
) - addr_start
);
4710 /* Convert each SAL into a real PC. Verify that the PC can be
4711 inserted as a breakpoint. If it can't throw an error. */
4714 breakpoint_sals_to_pc (struct symtabs_and_lines
*sals
,
4718 for (i
= 0; i
< sals
->nelts
; i
++)
4720 resolve_sal_pc (&sals
->sals
[i
]);
4722 /* It's possible for the PC to be nonzero, but still an illegal
4723 value on some targets.
4725 For example, on HP-UX if you start gdb, and before running the
4726 inferior you try to set a breakpoint on a shared library function
4727 "foo" where the inferior doesn't call "foo" directly but does
4728 pass its address to another function call, then we do find a
4729 minimal symbol for the "foo", but it's address is invalid.
4730 (Appears to be an index into a table that the loader sets up
4731 when the inferior is run.)
4733 Give the target a chance to bless sals.sals[i].pc before we
4734 try to make a breakpoint for it. */
4735 if (PC_REQUIRES_RUN_BEFORE_USE (sals
->sals
[i
].pc
))
4737 if (address
== NULL
)
4738 error ("Cannot break without a running program.");
4740 error ("Cannot break on %s without a running program.",
4746 /* Set a breakpoint according to ARG (function, linenum or *address)
4747 flag: first bit : 0 non-temporary, 1 temporary.
4748 second bit : 0 normal breakpoint, 1 hardware breakpoint. */
4751 break_command_1 (char *arg
, int flag
, int from_tty
)
4753 int tempflag
, hardwareflag
;
4754 struct symtabs_and_lines sals
;
4755 register struct expression
**cond
= 0;
4756 /* Pointers in arg to the start, and one past the end, of the
4758 char **cond_string
= (char **) NULL
;
4759 char *addr_start
= arg
;
4761 struct cleanup
*old_chain
;
4762 struct cleanup
*breakpoint_chain
= NULL
;
4765 int ignore_count
= 0;
4767 hardwareflag
= flag
& BP_HARDWAREFLAG
;
4768 tempflag
= flag
& BP_TEMPFLAG
;
4773 parse_breakpoint_sals (&arg
, &sals
, &addr_string
);
4778 /* Create a chain of things that always need to be cleaned up. */
4779 old_chain
= make_cleanup (null_cleanup
, 0);
4781 /* Make sure that all storage allocated to SALS gets freed. */
4782 make_cleanup (xfree
, sals
.sals
);
4784 /* Cleanup the addr_string array but not its contents. */
4785 make_cleanup (xfree
, addr_string
);
4787 /* Allocate space for all the cond expressions. */
4788 cond
= xcalloc (sals
.nelts
, sizeof (struct expression
*));
4789 make_cleanup (xfree
, cond
);
4791 /* Allocate space for all the cond strings. */
4792 cond_string
= xcalloc (sals
.nelts
, sizeof (char **));
4793 make_cleanup (xfree
, cond_string
);
4795 /* ----------------------------- SNIP -----------------------------
4796 Anything added to the cleanup chain beyond this point is assumed
4797 to be part of a breakpoint. If the breakpoint create succeeds
4798 then the memory is not reclaimed. */
4799 breakpoint_chain
= make_cleanup (null_cleanup
, 0);
4801 /* Mark the contents of the addr_string for cleanup. These go on
4802 the breakpoint_chain and only occure if the breakpoint create
4804 for (i
= 0; i
< sals
.nelts
; i
++)
4806 if (addr_string
[i
] != NULL
)
4807 make_cleanup (xfree
, addr_string
[i
]);
4810 /* Resolve all line numbers to PC's and verify that the addresses
4811 are ok for the target. */
4812 breakpoint_sals_to_pc (&sals
, addr_start
);
4814 /* Verify that condition can be parsed, before setting any
4815 breakpoints. Allocate a separate condition expression for each
4817 thread
= -1; /* No specific thread yet */
4818 for (i
= 0; i
< sals
.nelts
; i
++)
4825 char *cond_start
= NULL
;
4826 char *cond_end
= NULL
;
4827 while (*tok
== ' ' || *tok
== '\t')
4832 while (*end_tok
!= ' ' && *end_tok
!= '\t' && *end_tok
!= '\000')
4835 toklen
= end_tok
- tok
;
4837 if (toklen
>= 1 && strncmp (tok
, "if", toklen
) == 0)
4839 tok
= cond_start
= end_tok
+ 1;
4840 cond
[i
] = parse_exp_1 (&tok
, block_for_pc (sals
.sals
[i
].pc
), 0);
4841 make_cleanup (xfree
, cond
[i
]);
4843 cond_string
[i
] = savestring (cond_start
, cond_end
- cond_start
);
4844 make_cleanup (xfree
, cond_string
[i
]);
4846 else if (toklen
>= 1 && strncmp (tok
, "thread", toklen
) == 0)
4852 thread
= strtol (tok
, &tok
, 0);
4854 error ("Junk after thread keyword.");
4855 if (!valid_thread_id (thread
))
4856 error ("Unknown thread %d\n", thread
);
4859 error ("Junk at end of arguments.");
4863 create_breakpoints (sals
, addr_string
, cond
, cond_string
,
4864 hardwareflag
? bp_hardware_breakpoint
: bp_breakpoint
,
4865 tempflag
? disp_del
: disp_donttouch
,
4866 thread
, ignore_count
, from_tty
);
4870 warning ("Multiple breakpoints were set.");
4871 warning ("Use the \"delete\" command to delete unwanted breakpoints.");
4873 /* That's it. Discard the cleanups for data inserted into the
4875 discard_cleanups (breakpoint_chain
);
4876 /* But cleanup everything else. */
4877 do_cleanups (old_chain
);
4880 /* Set a breakpoint of TYPE/DISPOSITION according to ARG (function,
4881 linenum or *address) with COND and IGNORE_COUNT. */
4883 struct captured_breakpoint_args
4894 do_captured_breakpoint (void *data
)
4896 struct captured_breakpoint_args
*args
= data
;
4897 struct symtabs_and_lines sals
;
4898 register struct expression
**cond
;
4899 struct cleanup
*old_chain
;
4900 struct cleanup
*breakpoint_chain
= NULL
;
4907 /* Parse the source and lines spec. Delay check that the expression
4908 didn't contain trailing garbage until after cleanups are in
4912 address_end
= args
->address
;
4914 parse_breakpoint_sals (&address_end
, &sals
, &addr_string
);
4919 /* Create a chain of things at always need to be cleaned up. */
4920 old_chain
= make_cleanup (null_cleanup
, 0);
4922 /* Always have a addr_string array, even if it is empty. */
4923 make_cleanup (xfree
, addr_string
);
4925 /* Make sure that all storage allocated to SALS gets freed. */
4926 make_cleanup (xfree
, sals
.sals
);
4928 /* Allocate space for all the cond expressions. */
4929 cond
= xcalloc (sals
.nelts
, sizeof (struct expression
*));
4930 make_cleanup (xfree
, cond
);
4932 /* Allocate space for all the cond strings. */
4933 cond_string
= xcalloc (sals
.nelts
, sizeof (char **));
4934 make_cleanup (xfree
, cond_string
);
4936 /* ----------------------------- SNIP -----------------------------
4937 Anything added to the cleanup chain beyond this point is assumed
4938 to be part of a breakpoint. If the breakpoint create goes
4939 through then that memory is not cleaned up. */
4940 breakpoint_chain
= make_cleanup (null_cleanup
, 0);
4942 /* Mark the contents of the addr_string for cleanup. These go on
4943 the breakpoint_chain and only occure if the breakpoint create
4945 for (i
= 0; i
< sals
.nelts
; i
++)
4947 if (addr_string
[i
] != NULL
)
4948 make_cleanup (xfree
, addr_string
[i
]);
4951 /* Wait until now before checking for garbage at the end of the
4952 address. That way cleanups can take care of freeing any
4954 if (*address_end
!= '\0')
4955 error ("Garbage %s following breakpoint address", address_end
);
4957 /* Resolve all line numbers to PC's. */
4958 breakpoint_sals_to_pc (&sals
, args
->address
);
4960 /* Verify that conditions can be parsed, before setting any
4962 for (i
= 0; i
< sals
.nelts
; i
++)
4964 if (args
->condition
!= NULL
)
4966 char *tok
= args
->condition
;
4967 cond
[i
] = parse_exp_1 (&tok
, block_for_pc (sals
.sals
[i
].pc
), 0);
4969 error ("Garbage %s follows condition", tok
);
4970 make_cleanup (xfree
, cond
[i
]);
4971 cond_string
[i
] = xstrdup (args
->condition
);
4975 create_breakpoints (sals
, addr_string
, cond
, cond_string
,
4976 args
->hardwareflag
? bp_hardware_breakpoint
: bp_breakpoint
,
4977 args
->tempflag
? disp_del
: disp_donttouch
,
4978 args
->thread
, args
->ignore_count
, 0/*from-tty*/);
4980 /* That's it. Discard the cleanups for data inserted into the
4982 discard_cleanups (breakpoint_chain
);
4983 /* But cleanup everything else. */
4984 do_cleanups (old_chain
);
4989 gdb_breakpoint (char *address
, char *condition
,
4990 int hardwareflag
, int tempflag
,
4991 int thread
, int ignore_count
)
4993 struct captured_breakpoint_args args
;
4994 args
.address
= address
;
4995 args
.condition
= condition
;
4996 args
.hardwareflag
= hardwareflag
;
4997 args
.tempflag
= tempflag
;
4998 args
.thread
= thread
;
4999 args
.ignore_count
= ignore_count
;
5000 return catch_errors (do_captured_breakpoint
, &args
,
5001 NULL
, RETURN_MASK_ALL
);
5006 break_at_finish_at_depth_command_1 (char *arg
, int flag
, int from_tty
)
5008 struct frame_info
*frame
;
5009 CORE_ADDR low
, high
, selected_pc
= 0;
5010 char *extra_args
= NULL
;
5013 int extra_args_len
= 0, if_arg
= 0;
5016 (arg
[0] == 'i' && arg
[1] == 'f' && (arg
[2] == ' ' || arg
[2] == '\t')))
5019 if (default_breakpoint_valid
)
5023 selected_pc
= selected_frame
->pc
;
5028 error ("No selected frame.");
5031 error ("No default breakpoint address now.");
5035 extra_args
= strchr (arg
, ' ');
5039 extra_args_len
= strlen (extra_args
);
5040 level_arg
= (char *) xmalloc (extra_args
- arg
);
5041 strncpy (level_arg
, arg
, extra_args
- arg
- 1);
5042 level_arg
[extra_args
- arg
- 1] = '\0';
5046 level_arg
= (char *) xmalloc (strlen (arg
) + 1);
5047 strcpy (level_arg
, arg
);
5050 frame
= parse_frame_specification (level_arg
);
5052 selected_pc
= frame
->pc
;
5059 extra_args_len
= strlen (arg
);
5064 if (find_pc_partial_function (selected_pc
, (char **) NULL
, &low
, &high
))
5066 addr_string
= (char *) xmalloc (26 + extra_args_len
);
5068 sprintf (addr_string
, "*0x%s %s", paddr_nz (high
), extra_args
);
5070 sprintf (addr_string
, "*0x%s", paddr_nz (high
));
5071 break_command_1 (addr_string
, flag
, from_tty
);
5072 xfree (addr_string
);
5075 error ("No function contains the specified address");
5078 error ("Unable to set breakpoint at procedure exit");
5083 break_at_finish_command_1 (char *arg
, int flag
, int from_tty
)
5085 char *addr_string
, *break_string
, *beg_addr_string
;
5086 CORE_ADDR low
, high
;
5087 struct symtabs_and_lines sals
;
5088 struct symtab_and_line sal
;
5089 struct cleanup
*old_chain
;
5090 char *extra_args
= NULL
;
5091 int extra_args_len
= 0;
5095 (arg
[0] == 'i' && arg
[1] == 'f' && (arg
[2] == ' ' || arg
[2] == '\t')))
5097 if (default_breakpoint_valid
)
5101 addr_string
= (char *) xmalloc (15);
5102 sprintf (addr_string
, "*0x%s", paddr_nz (selected_frame
->pc
));
5107 error ("No selected frame.");
5110 error ("No default breakpoint address now.");
5114 addr_string
= (char *) xmalloc (strlen (arg
) + 1);
5115 strcpy (addr_string
, arg
);
5121 extra_args_len
= strlen (arg
);
5125 /* get the stuff after the function name or address */
5126 extra_args
= strchr (arg
, ' ');
5130 extra_args_len
= strlen (extra_args
);
5137 beg_addr_string
= addr_string
;
5138 sals
= decode_line_1 (&addr_string
, 1, (struct symtab
*) NULL
, 0,
5141 xfree (beg_addr_string
);
5142 old_chain
= make_cleanup (xfree
, sals
.sals
);
5143 for (i
= 0; (i
< sals
.nelts
); i
++)
5146 if (find_pc_partial_function (sal
.pc
, (char **) NULL
, &low
, &high
))
5148 break_string
= (char *) xmalloc (extra_args_len
+ 26);
5150 sprintf (break_string
, "*0x%s %s", paddr_nz (high
), extra_args
);
5152 sprintf (break_string
, "*0x%s", paddr_nz (high
));
5153 break_command_1 (break_string
, flag
, from_tty
);
5154 xfree (break_string
);
5157 error ("No function contains the specified address");
5161 warning ("Multiple breakpoints were set.\n");
5162 warning ("Use the \"delete\" command to delete unwanted breakpoints.");
5164 do_cleanups (old_chain
);
5168 /* Helper function for break_command_1 and disassemble_command. */
5171 resolve_sal_pc (struct symtab_and_line
*sal
)
5175 if (sal
->pc
== 0 && sal
->symtab
!= NULL
)
5177 if (!find_line_pc (sal
->symtab
, sal
->line
, &pc
))
5178 error ("No line %d in file \"%s\".",
5179 sal
->line
, sal
->symtab
->filename
);
5183 if (sal
->section
== 0 && sal
->symtab
!= NULL
)
5185 struct blockvector
*bv
;
5190 bv
= blockvector_for_pc_sect (sal
->pc
, 0, &index
, sal
->symtab
);
5193 b
= BLOCKVECTOR_BLOCK (bv
, index
);
5194 sym
= block_function (b
);
5197 fixup_symbol_section (sym
, sal
->symtab
->objfile
);
5198 sal
->section
= SYMBOL_BFD_SECTION (sym
);
5202 /* It really is worthwhile to have the section, so we'll just
5203 have to look harder. This case can be executed if we have
5204 line numbers but no functions (as can happen in assembly
5207 struct minimal_symbol
*msym
;
5209 msym
= lookup_minimal_symbol_by_pc (sal
->pc
);
5211 sal
->section
= SYMBOL_BFD_SECTION (msym
);
5218 break_command (char *arg
, int from_tty
)
5220 break_command_1 (arg
, 0, from_tty
);
5224 break_at_finish_command (char *arg
, int from_tty
)
5226 break_at_finish_command_1 (arg
, 0, from_tty
);
5230 break_at_finish_at_depth_command (char *arg
, int from_tty
)
5232 break_at_finish_at_depth_command_1 (arg
, 0, from_tty
);
5236 tbreak_command (char *arg
, int from_tty
)
5238 break_command_1 (arg
, BP_TEMPFLAG
, from_tty
);
5242 tbreak_at_finish_command (char *arg
, int from_tty
)
5244 break_at_finish_command_1 (arg
, BP_TEMPFLAG
, from_tty
);
5248 hbreak_command (char *arg
, int from_tty
)
5250 break_command_1 (arg
, BP_HARDWAREFLAG
, from_tty
);
5254 thbreak_command (char *arg
, int from_tty
)
5256 break_command_1 (arg
, (BP_TEMPFLAG
| BP_HARDWAREFLAG
), from_tty
);
5260 stop_command (char *arg
, int from_tty
)
5262 printf_filtered ("Specify the type of breakpoint to set.\n\
5263 Usage: stop in <function | address>\n\
5268 stopin_command (char *arg
, int from_tty
)
5272 if (arg
== (char *) NULL
)
5274 else if (*arg
!= '*')
5279 /* look for a ':'. If this is a line number specification, then
5280 say it is bad, otherwise, it should be an address or
5281 function/method name */
5282 while (*argptr
&& !hasColon
)
5284 hasColon
= (*argptr
== ':');
5289 badInput
= (*argptr
!= ':'); /* Not a class::method */
5291 badInput
= isdigit (*arg
); /* a simple line number */
5295 printf_filtered ("Usage: stop in <function | address>\n");
5297 break_command_1 (arg
, 0, from_tty
);
5301 stopat_command (char *arg
, int from_tty
)
5305 if (arg
== (char *) NULL
|| *arg
== '*') /* no line number */
5312 /* look for a ':'. If there is a '::' then get out, otherwise
5313 it is probably a line number. */
5314 while (*argptr
&& !hasColon
)
5316 hasColon
= (*argptr
== ':');
5321 badInput
= (*argptr
== ':'); /* we have class::method */
5323 badInput
= !isdigit (*arg
); /* not a line number */
5327 printf_filtered ("Usage: stop at <line>\n");
5329 break_command_1 (arg
, 0, from_tty
);
5333 /* accessflag: hw_write: watch write,
5334 hw_read: watch read,
5335 hw_access: watch access (read or write) */
5337 watch_command_1 (char *arg
, int accessflag
, int from_tty
)
5339 struct breakpoint
*b
;
5340 struct symtab_and_line sal
;
5341 struct expression
*exp
;
5342 struct block
*exp_valid_block
;
5343 struct value
*val
, *mark
;
5344 struct frame_info
*frame
;
5345 struct frame_info
*prev_frame
= NULL
;
5346 char *exp_start
= NULL
;
5347 char *exp_end
= NULL
;
5348 char *tok
, *end_tok
;
5350 char *cond_start
= NULL
;
5351 char *cond_end
= NULL
;
5352 struct expression
*cond
= NULL
;
5353 int i
, other_type_used
, target_resources_ok
= 0;
5354 enum bptype bp_type
;
5357 INIT_SAL (&sal
); /* initialize to zeroes */
5359 /* Parse arguments. */
5360 innermost_block
= NULL
;
5362 exp
= parse_exp_1 (&arg
, 0, 0);
5364 exp_valid_block
= innermost_block
;
5365 mark
= value_mark ();
5366 val
= evaluate_expression (exp
);
5367 release_value (val
);
5368 if (VALUE_LAZY (val
))
5369 value_fetch_lazy (val
);
5372 while (*tok
== ' ' || *tok
== '\t')
5376 while (*end_tok
!= ' ' && *end_tok
!= '\t' && *end_tok
!= '\000')
5379 toklen
= end_tok
- tok
;
5380 if (toklen
>= 1 && strncmp (tok
, "if", toklen
) == 0)
5382 tok
= cond_start
= end_tok
+ 1;
5383 cond
= parse_exp_1 (&tok
, 0, 0);
5387 error ("Junk at end of command.");
5389 if (accessflag
== hw_read
)
5390 bp_type
= bp_read_watchpoint
;
5391 else if (accessflag
== hw_access
)
5392 bp_type
= bp_access_watchpoint
;
5394 bp_type
= bp_hardware_watchpoint
;
5396 mem_cnt
= can_use_hardware_watchpoint (val
);
5397 if (mem_cnt
== 0 && bp_type
!= bp_hardware_watchpoint
)
5398 error ("Expression cannot be implemented with read/access watchpoint.");
5401 i
= hw_watchpoint_used_count (bp_type
, &other_type_used
);
5402 target_resources_ok
=
5403 TARGET_CAN_USE_HARDWARE_WATCHPOINT (bp_type
, i
+ mem_cnt
,
5405 if (target_resources_ok
== 0 && bp_type
!= bp_hardware_watchpoint
)
5406 error ("Target does not support this type of hardware watchpoint.");
5408 if (target_resources_ok
< 0 && bp_type
!= bp_hardware_watchpoint
)
5409 error ("Target can only support one kind of HW watchpoint at a time.");
5412 #if defined(HPUXHPPA)
5413 /* On HP-UX if you set a h/w
5414 watchpoint before the "run" command, the inferior dies with a e.g.,
5415 SIGILL once you start it. I initially believed this was due to a
5416 bad interaction between page protection traps and the initial
5417 startup sequence by the dynamic linker.
5419 However, I tried avoiding that by having HP-UX's implementation of
5420 TARGET_CAN_USE_HW_WATCHPOINT return FALSE if there was no inferior_ptid
5421 yet, which forced slow watches before a "run" or "attach", and it
5422 still fails somewhere in the startup code.
5424 Until I figure out what's happening, I'm disallowing watches altogether
5425 before the "run" or "attach" command. We'll tell the user they must
5426 set watches after getting the program started. */
5427 if (!target_has_execution
)
5429 warning ("can't do that without a running program; try \"break main\", \"run\" first");
5432 #endif /* HPUXHPPA */
5434 /* Change the type of breakpoint to an ordinary watchpoint if a hardware
5435 watchpoint could not be set. */
5436 if (!mem_cnt
|| target_resources_ok
<= 0)
5437 bp_type
= bp_watchpoint
;
5439 /* Now set up the breakpoint. */
5440 b
= set_raw_breakpoint (sal
, bp_type
);
5441 set_breakpoint_count (breakpoint_count
+ 1);
5442 b
->number
= breakpoint_count
;
5443 b
->disposition
= disp_donttouch
;
5445 b
->exp_valid_block
= exp_valid_block
;
5446 b
->exp_string
= savestring (exp_start
, exp_end
- exp_start
);
5450 b
->cond_string
= savestring (cond_start
, cond_end
- cond_start
);
5454 frame
= block_innermost_frame (exp_valid_block
);
5457 prev_frame
= get_prev_frame (frame
);
5458 b
->watchpoint_frame
= frame
->frame
;
5461 b
->watchpoint_frame
= (CORE_ADDR
) 0;
5463 /* If the expression is "local", then set up a "watchpoint scope"
5464 breakpoint at the point where we've left the scope of the watchpoint
5466 if (innermost_block
)
5470 struct breakpoint
*scope_breakpoint
;
5471 struct symtab_and_line scope_sal
;
5473 INIT_SAL (&scope_sal
); /* initialize to zeroes */
5474 scope_sal
.pc
= get_frame_pc (prev_frame
);
5475 scope_sal
.section
= find_pc_overlay (scope_sal
.pc
);
5477 scope_breakpoint
= set_raw_breakpoint (scope_sal
,
5478 bp_watchpoint_scope
);
5479 set_breakpoint_count (breakpoint_count
+ 1);
5480 scope_breakpoint
->number
= breakpoint_count
;
5482 scope_breakpoint
->enable_state
= bp_enabled
;
5484 /* Automatically delete the breakpoint when it hits. */
5485 scope_breakpoint
->disposition
= disp_del
;
5487 /* Only break in the proper frame (help with recursion). */
5488 scope_breakpoint
->frame
= prev_frame
->frame
;
5490 /* Set the address at which we will stop. */
5491 scope_breakpoint
->address
= get_frame_pc (prev_frame
);
5493 /* The scope breakpoint is related to the watchpoint. We
5494 will need to act on them together. */
5495 b
->related_breakpoint
= scope_breakpoint
;
5498 value_free_to_mark (mark
);
5502 /* Return count of locations need to be watched and can be handled
5503 in hardware. If the watchpoint can not be handled
5504 in hardware return zero. */
5506 #if !defined(TARGET_REGION_SIZE_OK_FOR_HW_WATCHPOINT)
5507 #define TARGET_REGION_SIZE_OK_FOR_HW_WATCHPOINT(BYTE_SIZE) \
5508 ((BYTE_SIZE) <= (REGISTER_SIZE))
5511 #if !defined(TARGET_REGION_OK_FOR_HW_WATCHPOINT)
5512 #define TARGET_REGION_OK_FOR_HW_WATCHPOINT(ADDR,LEN) \
5513 (TARGET_REGION_SIZE_OK_FOR_HW_WATCHPOINT(LEN))
5517 can_use_hardware_watchpoint (struct value
*v
)
5519 int found_memory_cnt
= 0;
5520 struct value
*head
= v
;
5522 /* Did the user specifically forbid us to use hardware watchpoints? */
5523 if (!can_use_hw_watchpoints
)
5526 /* Make sure that the value of the expression depends only upon
5527 memory contents, and values computed from them within GDB. If we
5528 find any register references or function calls, we can't use a
5529 hardware watchpoint.
5531 The idea here is that evaluating an expression generates a series
5532 of values, one holding the value of every subexpression. (The
5533 expression a*b+c has five subexpressions: a, b, a*b, c, and
5534 a*b+c.) GDB's values hold almost enough information to establish
5535 the criteria given above --- they identify memory lvalues,
5536 register lvalues, computed values, etcetera. So we can evaluate
5537 the expression, and then scan the chain of values that leaves
5538 behind to decide whether we can detect any possible change to the
5539 expression's final value using only hardware watchpoints.
5541 However, I don't think that the values returned by inferior
5542 function calls are special in any way. So this function may not
5543 notice that an expression involving an inferior function call
5544 can't be watched with hardware watchpoints. FIXME. */
5545 for (; v
; v
= v
->next
)
5547 if (VALUE_LVAL (v
) == lval_memory
)
5550 /* A lazy memory lvalue is one that GDB never needed to fetch;
5551 we either just used its address (e.g., `a' in `a.b') or
5552 we never needed it at all (e.g., `a' in `a,b'). */
5556 /* Ahh, memory we actually used! Check if we can cover
5557 it with hardware watchpoints. */
5558 struct type
*vtype
= check_typedef (VALUE_TYPE (v
));
5560 /* We only watch structs and arrays if user asked for it
5561 explicitly, never if they just happen to appear in a
5562 middle of some value chain. */
5564 || (TYPE_CODE (vtype
) != TYPE_CODE_STRUCT
5565 && TYPE_CODE (vtype
) != TYPE_CODE_ARRAY
))
5567 CORE_ADDR vaddr
= VALUE_ADDRESS (v
) + VALUE_OFFSET (v
);
5568 int len
= TYPE_LENGTH (VALUE_TYPE (v
));
5570 if (!TARGET_REGION_OK_FOR_HW_WATCHPOINT (vaddr
, len
))
5577 else if (v
->lval
!= not_lval
&& v
->modifiable
== 0)
5578 return 0; /* ??? What does this represent? */
5579 else if (v
->lval
== lval_register
)
5580 return 0; /* cannot watch a register with a HW watchpoint */
5583 /* The expression itself looks suitable for using a hardware
5584 watchpoint, but give the target machine a chance to reject it. */
5585 return found_memory_cnt
;
5590 watch_command_wrapper (char *arg
, int from_tty
)
5592 watch_command (arg
, from_tty
);
5596 watch_command (char *arg
, int from_tty
)
5598 watch_command_1 (arg
, hw_write
, from_tty
);
5603 rwatch_command_wrapper (char *arg
, int from_tty
)
5605 rwatch_command (arg
, from_tty
);
5609 rwatch_command (char *arg
, int from_tty
)
5611 watch_command_1 (arg
, hw_read
, from_tty
);
5616 awatch_command_wrapper (char *arg
, int from_tty
)
5618 awatch_command (arg
, from_tty
);
5622 awatch_command (char *arg
, int from_tty
)
5624 watch_command_1 (arg
, hw_access
, from_tty
);
5628 /* Helper routines for the until_command routine in infcmd.c. Here
5629 because it uses the mechanisms of breakpoints. */
5631 /* This function is called by fetch_inferior_event via the
5632 cmd_continuation pointer, to complete the until command. It takes
5633 care of cleaning up the temporary breakpoints set up by the until
5636 until_break_command_continuation (struct continuation_arg
*arg
)
5638 struct cleanup
*cleanups
;
5640 cleanups
= (struct cleanup
*) arg
->data
.pointer
;
5641 do_exec_cleanups (cleanups
);
5646 until_break_command (char *arg
, int from_tty
)
5648 struct symtabs_and_lines sals
;
5649 struct symtab_and_line sal
;
5650 struct frame_info
*prev_frame
= get_prev_frame (selected_frame
);
5651 struct breakpoint
*breakpoint
;
5652 struct cleanup
*old_chain
;
5653 struct continuation_arg
*arg1
;
5656 clear_proceed_status ();
5658 /* Set a breakpoint where the user wants it and at return from
5661 if (default_breakpoint_valid
)
5662 sals
= decode_line_1 (&arg
, 1, default_breakpoint_symtab
,
5663 default_breakpoint_line
, (char ***) NULL
);
5665 sals
= decode_line_1 (&arg
, 1, (struct symtab
*) NULL
,
5666 0, (char ***) NULL
);
5668 if (sals
.nelts
!= 1)
5669 error ("Couldn't get information on specified line.");
5672 xfree (sals
.sals
); /* malloc'd, so freed */
5675 error ("Junk at end of arguments.");
5677 resolve_sal_pc (&sal
);
5679 breakpoint
= set_momentary_breakpoint (sal
, selected_frame
, bp_until
);
5681 if (!event_loop_p
|| !target_can_async_p ())
5682 old_chain
= make_cleanup_delete_breakpoint (breakpoint
);
5684 old_chain
= make_exec_cleanup_delete_breakpoint (breakpoint
);
5686 /* If we are running asynchronously, and the target supports async
5687 execution, we are not waiting for the target to stop, in the call
5688 tp proceed, below. This means that we cannot delete the
5689 brekpoints until the target has actually stopped. The only place
5690 where we get a chance to do that is in fetch_inferior_event, so
5691 we must set things up for that. */
5693 if (event_loop_p
&& target_can_async_p ())
5695 /* In this case the arg for the continuation is just the point
5696 in the exec_cleanups chain from where to start doing
5697 cleanups, because all the continuation does is the cleanups in
5698 the exec_cleanup_chain. */
5700 (struct continuation_arg
*) xmalloc (sizeof (struct continuation_arg
));
5702 arg1
->data
.pointer
= old_chain
;
5704 add_continuation (until_break_command_continuation
, arg1
);
5707 /* Keep within the current frame */
5711 sal
= find_pc_line (prev_frame
->pc
, 0);
5712 sal
.pc
= prev_frame
->pc
;
5713 breakpoint
= set_momentary_breakpoint (sal
, prev_frame
, bp_until
);
5714 if (!event_loop_p
|| !target_can_async_p ())
5715 make_cleanup_delete_breakpoint (breakpoint
);
5717 make_exec_cleanup_delete_breakpoint (breakpoint
);
5720 proceed (-1, TARGET_SIGNAL_DEFAULT
, 0);
5721 /* Do the cleanups now, anly if we are not running asynchronously,
5722 of if we are, but the target is still synchronous. */
5723 if (!event_loop_p
|| !target_can_async_p ())
5724 do_cleanups (old_chain
);
5728 /* These aren't used; I don't konw what they were for. */
5729 /* Set a breakpoint at the catch clause for NAME. */
5731 catch_breakpoint (char *name
)
5736 disable_catch_breakpoint (void)
5741 delete_catch_breakpoint (void)
5746 enable_catch_breakpoint (void)
5753 struct sal_chain
*next
;
5754 struct symtab_and_line sal
;
5758 /* Not really used -- invocation in handle_gnu_4_16_catch_command
5759 had been commented out in the v.4.16 sources, and stays
5760 disabled there now because "catch NAME" syntax isn't allowed.
5762 /* This isn't used; I don't know what it was for. */
5763 /* For each catch clause identified in ARGS, run FUNCTION
5764 with that clause as an argument. */
5765 static struct symtabs_and_lines
5766 map_catch_names (char *args
, int (*function
) ())
5768 register char *p
= args
;
5770 struct symtabs_and_lines sals
;
5772 struct sal_chain
*sal_chain
= 0;
5776 error_no_arg ("one or more catch names");
5784 /* Don't swallow conditional part. */
5785 if (p1
[0] == 'i' && p1
[1] == 'f'
5786 && (p1
[2] == ' ' || p1
[2] == '\t'))
5792 while (isalnum (*p1
) || *p1
== '_' || *p1
== '$')
5796 if (*p1
&& *p1
!= ' ' && *p1
!= '\t')
5797 error ("Arguments must be catch names.");
5803 struct sal_chain
*next
= (struct sal_chain
*)
5804 alloca (sizeof (struct sal_chain
));
5805 next
->next
= sal_chain
;
5806 next
->sal
= get_catch_sal (p
);
5811 printf_unfiltered ("No catch clause for exception %s.\n", p
);
5816 while (*p
== ' ' || *p
== '\t')
5822 /* This shares a lot of code with `print_frame_label_vars' from stack.c. */
5824 static struct symtabs_and_lines
5825 get_catch_sals (int this_level_only
)
5827 register struct blockvector
*bl
;
5828 register struct block
*block
;
5829 int index
, have_default
= 0;
5831 struct symtabs_and_lines sals
;
5832 struct sal_chain
*sal_chain
= 0;
5833 char *blocks_searched
;
5835 /* Not sure whether an error message is always the correct response,
5836 but it's better than a core dump. */
5837 if (selected_frame
== NULL
)
5838 error ("No selected frame.");
5839 block
= get_frame_block (selected_frame
);
5840 pc
= selected_frame
->pc
;
5846 error ("No symbol table info available.\n");
5848 bl
= blockvector_for_pc (BLOCK_END (block
) - 4, &index
);
5849 blocks_searched
= (char *) alloca (BLOCKVECTOR_NBLOCKS (bl
) * sizeof (char));
5850 memset (blocks_searched
, 0, BLOCKVECTOR_NBLOCKS (bl
) * sizeof (char));
5854 CORE_ADDR end
= BLOCK_END (block
) - 4;
5857 if (bl
!= blockvector_for_pc (end
, &index
))
5858 error ("blockvector blotch");
5859 if (BLOCKVECTOR_BLOCK (bl
, index
) != block
)
5860 error ("blockvector botch");
5861 last_index
= BLOCKVECTOR_NBLOCKS (bl
);
5864 /* Don't print out blocks that have gone by. */
5865 while (index
< last_index
5866 && BLOCK_END (BLOCKVECTOR_BLOCK (bl
, index
)) < pc
)
5869 while (index
< last_index
5870 && BLOCK_END (BLOCKVECTOR_BLOCK (bl
, index
)) < end
)
5872 if (blocks_searched
[index
] == 0)
5874 struct block
*b
= BLOCKVECTOR_BLOCK (bl
, index
);
5876 register struct symbol
*sym
;
5878 ALL_BLOCK_SYMBOLS (b
, i
, sym
)
5880 if (STREQ (SYMBOL_NAME (sym
), "default"))
5886 if (SYMBOL_CLASS (sym
) == LOC_LABEL
)
5888 struct sal_chain
*next
= (struct sal_chain
*)
5889 alloca (sizeof (struct sal_chain
));
5890 next
->next
= sal_chain
;
5891 next
->sal
= find_pc_line (SYMBOL_VALUE_ADDRESS (sym
),
5896 blocks_searched
[index
] = 1;
5902 if (sal_chain
&& this_level_only
)
5905 /* After handling the function's top-level block, stop.
5906 Don't continue to its superblock, the block of
5907 per-file symbols. */
5908 if (BLOCK_FUNCTION (block
))
5910 block
= BLOCK_SUPERBLOCK (block
);
5915 struct sal_chain
*tmp_chain
;
5917 /* Count the number of entries. */
5918 for (index
= 0, tmp_chain
= sal_chain
; tmp_chain
;
5919 tmp_chain
= tmp_chain
->next
)
5923 sals
.sals
= (struct symtab_and_line
*)
5924 xmalloc (index
* sizeof (struct symtab_and_line
));
5925 for (index
= 0; sal_chain
; sal_chain
= sal_chain
->next
, index
++)
5926 sals
.sals
[index
] = sal_chain
->sal
;
5933 ep_skip_leading_whitespace (char **s
)
5935 if ((s
== NULL
) || (*s
== NULL
))
5937 while (isspace (**s
))
5941 /* This function examines a string, and attempts to find a token
5942 that might be an event name in the leading characters. If a
5943 possible match is found, a pointer to the last character of
5944 the token is returned. Else, NULL is returned. */
5947 ep_find_event_name_end (char *arg
)
5950 char *event_name_end
= NULL
;
5952 /* If we could depend upon the presense of strrpbrk, we'd use that... */
5956 /* We break out of the loop when we find a token delimiter.
5957 Basically, we're looking for alphanumerics and underscores;
5958 anything else delimites the token. */
5961 if (!isalnum (*s
) && (*s
!= '_'))
5967 return event_name_end
;
5971 /* This function attempts to parse an optional "if <cond>" clause
5972 from the arg string. If one is not found, it returns NULL.
5974 Else, it returns a pointer to the condition string. (It does not
5975 attempt to evaluate the string against a particular block.) And,
5976 it updates arg to point to the first character following the parsed
5977 if clause in the arg string. */
5980 ep_parse_optional_if_clause (char **arg
)
5984 if (((*arg
)[0] != 'i') || ((*arg
)[1] != 'f') || !isspace ((*arg
)[2]))
5987 /* Skip the "if" keyword. */
5990 /* Skip any extra leading whitespace, and record the start of the
5991 condition string. */
5992 ep_skip_leading_whitespace (arg
);
5995 /* Assume that the condition occupies the remainder of the arg string. */
5996 (*arg
) += strlen (cond_string
);
6001 /* This function attempts to parse an optional filename from the arg
6002 string. If one is not found, it returns NULL.
6004 Else, it returns a pointer to the parsed filename. (This function
6005 makes no attempt to verify that a file of that name exists, or is
6006 accessible.) And, it updates arg to point to the first character
6007 following the parsed filename in the arg string.
6009 Note that clients needing to preserve the returned filename for
6010 future access should copy it to their own buffers. */
6012 ep_parse_optional_filename (char **arg
)
6014 static char filename
[1024];
6019 if ((*arg_p
== '\0') || isspace (*arg_p
))
6037 /* Commands to deal with catching events, such as signals, exceptions,
6038 process start/exit, etc. */
6042 catch_fork
, catch_vfork
6046 #if defined(CHILD_INSERT_FORK_CATCHPOINT) || defined(CHILD_INSERT_VFORK_CATCHPOINT)
6047 static void catch_fork_command_1 (catch_fork_kind fork_kind
,
6048 char *arg
, int tempflag
, int from_tty
);
6051 catch_fork_command_1 (catch_fork_kind fork_kind
, char *arg
, int tempflag
,
6054 char *cond_string
= NULL
;
6056 ep_skip_leading_whitespace (&arg
);
6058 /* The allowed syntax is:
6060 catch [v]fork if <cond>
6062 First, check if there's an if clause. */
6063 cond_string
= ep_parse_optional_if_clause (&arg
);
6065 if ((*arg
!= '\0') && !isspace (*arg
))
6066 error ("Junk at end of arguments.");
6068 /* If this target supports it, create a fork or vfork catchpoint
6069 and enable reporting of such events. */
6073 create_fork_event_catchpoint (tempflag
, cond_string
);
6076 create_vfork_event_catchpoint (tempflag
, cond_string
);
6079 error ("unsupported or unknown fork kind; cannot catch it");
6085 #if defined(CHILD_INSERT_EXEC_CATCHPOINT)
6087 catch_exec_command_1 (char *arg
, int tempflag
, int from_tty
)
6089 char *cond_string
= NULL
;
6091 ep_skip_leading_whitespace (&arg
);
6093 /* The allowed syntax is:
6095 catch exec if <cond>
6097 First, check if there's an if clause. */
6098 cond_string
= ep_parse_optional_if_clause (&arg
);
6100 if ((*arg
!= '\0') && !isspace (*arg
))
6101 error ("Junk at end of arguments.");
6103 /* If this target supports it, create an exec catchpoint
6104 and enable reporting of such events. */
6105 create_exec_event_catchpoint (tempflag
, cond_string
);
6109 #if defined(SOLIB_ADD)
6111 catch_load_command_1 (char *arg
, int tempflag
, int from_tty
)
6113 char *dll_pathname
= NULL
;
6114 char *cond_string
= NULL
;
6116 ep_skip_leading_whitespace (&arg
);
6118 /* The allowed syntax is:
6120 catch load if <cond>
6121 catch load <filename>
6122 catch load <filename> if <cond>
6124 The user is not allowed to specify the <filename> after an
6127 We'll ignore the pathological case of a file named "if".
6129 First, check if there's an if clause. If so, then there
6130 cannot be a filename. */
6131 cond_string
= ep_parse_optional_if_clause (&arg
);
6133 /* If there was an if clause, then there cannot be a filename.
6134 Else, there might be a filename and an if clause. */
6135 if (cond_string
== NULL
)
6137 dll_pathname
= ep_parse_optional_filename (&arg
);
6138 ep_skip_leading_whitespace (&arg
);
6139 cond_string
= ep_parse_optional_if_clause (&arg
);
6142 if ((*arg
!= '\0') && !isspace (*arg
))
6143 error ("Junk at end of arguments.");
6145 /* Create a load breakpoint that only triggers when a load of
6146 the specified dll (or any dll, if no pathname was specified)
6148 SOLIB_CREATE_CATCH_LOAD_HOOK (PIDGET (inferior_ptid
), tempflag
,
6149 dll_pathname
, cond_string
);
6153 catch_unload_command_1 (char *arg
, int tempflag
, int from_tty
)
6155 char *dll_pathname
= NULL
;
6156 char *cond_string
= NULL
;
6158 ep_skip_leading_whitespace (&arg
);
6160 /* The allowed syntax is:
6162 catch unload if <cond>
6163 catch unload <filename>
6164 catch unload <filename> if <cond>
6166 The user is not allowed to specify the <filename> after an
6169 We'll ignore the pathological case of a file named "if".
6171 First, check if there's an if clause. If so, then there
6172 cannot be a filename. */
6173 cond_string
= ep_parse_optional_if_clause (&arg
);
6175 /* If there was an if clause, then there cannot be a filename.
6176 Else, there might be a filename and an if clause. */
6177 if (cond_string
== NULL
)
6179 dll_pathname
= ep_parse_optional_filename (&arg
);
6180 ep_skip_leading_whitespace (&arg
);
6181 cond_string
= ep_parse_optional_if_clause (&arg
);
6184 if ((*arg
!= '\0') && !isspace (*arg
))
6185 error ("Junk at end of arguments.");
6187 /* Create an unload breakpoint that only triggers when an unload of
6188 the specified dll (or any dll, if no pathname was specified)
6190 SOLIB_CREATE_CATCH_UNLOAD_HOOK (PIDGET (inferior_ptid
), tempflag
,
6191 dll_pathname
, cond_string
);
6193 #endif /* SOLIB_ADD */
6195 /* Commands to deal with catching exceptions. */
6197 /* Set a breakpoint at the specified callback routine for an
6198 exception event callback */
6201 create_exception_catchpoint (int tempflag
, char *cond_string
,
6202 enum exception_event_kind ex_event
,
6203 struct symtab_and_line
*sal
)
6205 struct breakpoint
*b
;
6206 int thread
= -1; /* All threads. */
6209 if (!sal
) /* no exception support? */
6214 case EX_EVENT_THROW
:
6215 bptype
= bp_catch_throw
;
6217 case EX_EVENT_CATCH
:
6218 bptype
= bp_catch_catch
;
6220 default: /* error condition */
6221 error ("Internal error -- invalid catchpoint kind");
6224 b
= set_raw_breakpoint (*sal
, bptype
);
6225 set_breakpoint_count (breakpoint_count
+ 1);
6226 b
->number
= breakpoint_count
;
6228 b
->cond_string
= (cond_string
== NULL
) ?
6229 NULL
: savestring (cond_string
, strlen (cond_string
));
6231 b
->addr_string
= NULL
;
6232 b
->enable_state
= bp_enabled
;
6233 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
6237 /* Deal with "catch catch" and "catch throw" commands */
6240 catch_exception_command_1 (enum exception_event_kind ex_event
, char *arg
,
6241 int tempflag
, int from_tty
)
6243 char *cond_string
= NULL
;
6244 struct symtab_and_line
*sal
= NULL
;
6246 ep_skip_leading_whitespace (&arg
);
6248 cond_string
= ep_parse_optional_if_clause (&arg
);
6250 if ((*arg
!= '\0') && !isspace (*arg
))
6251 error ("Junk at end of arguments.");
6253 if ((ex_event
!= EX_EVENT_THROW
) &&
6254 (ex_event
!= EX_EVENT_CATCH
))
6255 error ("Unsupported or unknown exception event; cannot catch it");
6257 /* See if we can find a callback routine */
6258 sal
= target_enable_exception_callback (ex_event
, 1);
6262 /* We have callbacks from the runtime system for exceptions.
6263 Set a breakpoint on the sal found, if no errors */
6264 if (sal
!= (struct symtab_and_line
*) -1)
6265 create_exception_catchpoint (tempflag
, cond_string
, ex_event
, sal
);
6267 return; /* something went wrong with setting up callbacks */
6271 /* No callbacks from runtime system for exceptions.
6272 Try GNU C++ exception breakpoints using labels in debug info. */
6273 if (ex_event
== EX_EVENT_CATCH
)
6275 handle_gnu_4_16_catch_command (arg
, tempflag
, from_tty
);
6277 else if (ex_event
== EX_EVENT_THROW
)
6279 /* Set a breakpoint on __raise_exception () */
6281 warning ("Unsupported with this platform/compiler combination.");
6282 warning ("Perhaps you can achieve the effect you want by setting");
6283 warning ("a breakpoint on __raise_exception().");
6288 /* Cover routine to allow wrapping target_enable_exception_catchpoints
6289 inside a catch_errors */
6292 cover_target_enable_exception_callback (PTR arg
)
6294 args_for_catchpoint_enable
*args
= arg
;
6295 struct symtab_and_line
*sal
;
6296 sal
= target_enable_exception_callback (args
->kind
, args
->enable_p
);
6299 else if (sal
== (struct symtab_and_line
*) -1)
6302 return 1; /*is valid */
6307 /* This is the original v.4.16 and earlier version of the
6308 catch_command_1() function. Now that other flavours of "catch"
6309 have been introduced, and since exception handling can be handled
6310 in other ways (through target ops) also, this is used only for the
6311 GNU C++ exception handling system.
6312 Note: Only the "catch" flavour of GDB 4.16 is handled here. The
6313 "catch NAME" is now no longer allowed in catch_command_1(). Also,
6314 there was no code in GDB 4.16 for "catch throw".
6316 Called from catch_exception_command_1 () */
6320 handle_gnu_4_16_catch_command (char *arg
, int tempflag
, int from_tty
)
6322 /* First, translate ARG into something we can deal with in terms
6325 struct symtabs_and_lines sals
;
6326 struct symtab_and_line sal
;
6327 register struct expression
*cond
= 0;
6328 register struct breakpoint
*b
;
6332 INIT_SAL (&sal
); /* initialize to zeroes */
6334 /* If no arg given, or if first arg is 'if ', all active catch clauses
6335 are breakpointed. */
6337 if (!arg
|| (arg
[0] == 'i' && arg
[1] == 'f'
6338 && (arg
[2] == ' ' || arg
[2] == '\t')))
6340 /* Grab all active catch clauses. */
6341 sals
= get_catch_sals (0);
6345 /* Grab selected catch clauses. */
6346 error ("catch NAME not implemented");
6349 /* Not sure why this code has been disabled. I'm leaving
6350 it disabled. We can never come here now anyway
6351 since we don't allow the "catch NAME" syntax.
6354 /* This isn't used; I don't know what it was for. */
6355 sals
= map_catch_names (arg
, catch_breakpoint
);
6363 for (i
= 0; i
< sals
.nelts
; i
++)
6365 resolve_sal_pc (&sals
.sals
[i
]);
6369 if (arg
[0] == 'i' && arg
[1] == 'f'
6370 && (arg
[2] == ' ' || arg
[2] == '\t'))
6371 cond
= parse_exp_1 ((arg
+= 2, &arg
),
6372 block_for_pc (sals
.sals
[i
].pc
), 0);
6374 error ("Junk at end of arguments.");
6379 for (i
= 0; i
< sals
.nelts
; i
++)
6384 describe_other_breakpoints (sal
.pc
, sal
.section
);
6386 /* Important -- this is an ordinary breakpoint. For platforms
6387 with callback support for exceptions,
6388 create_exception_catchpoint() will create special bp types
6389 (bp_catch_catch and bp_catch_throw), and there is code in
6390 insert_breakpoints() and elsewhere that depends on that. */
6391 b
= set_raw_breakpoint (sal
, bp_breakpoint
);
6392 set_breakpoint_count (breakpoint_count
+ 1);
6393 b
->number
= breakpoint_count
;
6396 b
->enable_state
= bp_enabled
;
6397 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
6404 warning ("Multiple breakpoints were set.");
6405 warning ("Use the \"delete\" command to delete unwanted breakpoints.");
6411 /* This creates a temporary internal breakpoint
6412 just to placate infrun */
6413 static struct breakpoint
*
6414 create_temp_exception_breakpoint (CORE_ADDR pc
)
6416 struct symtab_and_line sal
;
6417 struct breakpoint
*b
;
6424 b
= set_raw_breakpoint (sal
, bp_breakpoint
);
6426 b
->disposition
= disp_del
;
6427 b
->enable_state
= bp_enabled
;
6429 b
->number
= internal_breakpoint_number
--;
6435 catch_command_1 (char *arg
, int tempflag
, int from_tty
)
6438 /* The first argument may be an event name, such as "start" or "load".
6439 If so, then handle it as such. If it doesn't match an event name,
6440 then attempt to interpret it as an exception name. (This latter is
6441 the v4.16-and-earlier GDB meaning of the "catch" command.)
6443 First, try to find the bounds of what might be an event name. */
6444 char *arg1_start
= arg
;
6448 if (arg1_start
== NULL
)
6450 /* Old behaviour was to use pre-v-4.16 syntax */
6451 /* catch_throw_command_1 (arg1_start, tempflag, from_tty); */
6453 /* Now, this is not allowed */
6454 error ("Catch requires an event name.");
6457 arg1_end
= ep_find_event_name_end (arg1_start
);
6458 if (arg1_end
== NULL
)
6459 error ("catch requires an event");
6460 arg1_length
= arg1_end
+ 1 - arg1_start
;
6462 /* Try to match what we found against known event names. */
6463 if (strncmp (arg1_start
, "signal", arg1_length
) == 0)
6465 error ("Catch of signal not yet implemented");
6467 else if (strncmp (arg1_start
, "catch", arg1_length
) == 0)
6469 catch_exception_command_1 (EX_EVENT_CATCH
, arg1_end
+ 1,
6470 tempflag
, from_tty
);
6472 else if (strncmp (arg1_start
, "throw", arg1_length
) == 0)
6474 catch_exception_command_1 (EX_EVENT_THROW
, arg1_end
+ 1,
6475 tempflag
, from_tty
);
6477 else if (strncmp (arg1_start
, "thread_start", arg1_length
) == 0)
6479 error ("Catch of thread_start not yet implemented");
6481 else if (strncmp (arg1_start
, "thread_exit", arg1_length
) == 0)
6483 error ("Catch of thread_exit not yet implemented");
6485 else if (strncmp (arg1_start
, "thread_join", arg1_length
) == 0)
6487 error ("Catch of thread_join not yet implemented");
6489 else if (strncmp (arg1_start
, "start", arg1_length
) == 0)
6491 error ("Catch of start not yet implemented");
6493 else if (strncmp (arg1_start
, "exit", arg1_length
) == 0)
6495 error ("Catch of exit not yet implemented");
6497 else if (strncmp (arg1_start
, "fork", arg1_length
) == 0)
6499 #if defined(CHILD_INSERT_FORK_CATCHPOINT)
6500 catch_fork_command_1 (catch_fork
, arg1_end
+ 1, tempflag
, from_tty
);
6502 error ("Catch of fork not yet implemented");
6505 else if (strncmp (arg1_start
, "vfork", arg1_length
) == 0)
6507 #if defined(CHILD_INSERT_VFORK_CATCHPOINT)
6508 catch_fork_command_1 (catch_vfork
, arg1_end
+ 1, tempflag
, from_tty
);
6510 error ("Catch of vfork not yet implemented");
6513 else if (strncmp (arg1_start
, "exec", arg1_length
) == 0)
6515 #if defined(CHILD_INSERT_EXEC_CATCHPOINT)
6516 catch_exec_command_1 (arg1_end
+ 1, tempflag
, from_tty
);
6518 error ("Catch of exec not yet implemented");
6521 else if (strncmp (arg1_start
, "load", arg1_length
) == 0)
6523 #if defined(SOLIB_ADD)
6524 catch_load_command_1 (arg1_end
+ 1, tempflag
, from_tty
);
6526 error ("Catch of load not implemented");
6529 else if (strncmp (arg1_start
, "unload", arg1_length
) == 0)
6531 #if defined(SOLIB_ADD)
6532 catch_unload_command_1 (arg1_end
+ 1, tempflag
, from_tty
);
6534 error ("Catch of load not implemented");
6537 else if (strncmp (arg1_start
, "stop", arg1_length
) == 0)
6539 error ("Catch of stop not yet implemented");
6542 /* This doesn't appear to be an event name */
6546 /* Pre-v.4.16 behaviour was to treat the argument
6547 as the name of an exception */
6548 /* catch_throw_command_1 (arg1_start, tempflag, from_tty); */
6549 /* Now this is not allowed */
6550 error ("Unknown event kind specified for catch");
6555 /* Used by the gui, could be made a worker for other things. */
6558 set_breakpoint_sal (struct symtab_and_line sal
)
6560 struct breakpoint
*b
;
6561 b
= set_raw_breakpoint (sal
, bp_breakpoint
);
6562 set_breakpoint_count (breakpoint_count
+ 1);
6563 b
->number
= breakpoint_count
;
6570 /* These aren't used; I don't know what they were for. */
6571 /* Disable breakpoints on all catch clauses described in ARGS. */
6573 disable_catch (char *args
)
6575 /* Map the disable command to catch clauses described in ARGS. */
6578 /* Enable breakpoints on all catch clauses described in ARGS. */
6580 enable_catch (char *args
)
6582 /* Map the disable command to catch clauses described in ARGS. */
6585 /* Delete breakpoints on all catch clauses in the active scope. */
6587 delete_catch (char *args
)
6589 /* Map the delete command to catch clauses described in ARGS. */
6594 catch_command (char *arg
, int from_tty
)
6596 catch_command_1 (arg
, 0, from_tty
);
6601 tcatch_command (char *arg
, int from_tty
)
6603 catch_command_1 (arg
, 1, from_tty
);
6608 clear_command (char *arg
, int from_tty
)
6610 register struct breakpoint
*b
, *b1
;
6612 struct symtabs_and_lines sals
;
6613 struct symtab_and_line sal
;
6614 register struct breakpoint
*found
;
6619 sals
= decode_line_spec (arg
, 1);
6624 sals
.sals
= (struct symtab_and_line
*)
6625 xmalloc (sizeof (struct symtab_and_line
));
6626 INIT_SAL (&sal
); /* initialize to zeroes */
6627 sal
.line
= default_breakpoint_line
;
6628 sal
.symtab
= default_breakpoint_symtab
;
6629 sal
.pc
= default_breakpoint_address
;
6630 if (sal
.symtab
== 0)
6631 error ("No source file specified.");
6639 /* For each line spec given, delete bps which correspond
6640 to it. We do this in two loops: the first loop looks at
6641 the initial bp(s) in the chain which should be deleted,
6642 the second goes down the rest of the chain looking ahead
6643 one so it can take those bps off the chain without messing
6647 for (i
= 0; i
< sals
.nelts
; i
++)
6649 /* If exact pc given, clear bpts at that pc.
6650 If line given (pc == 0), clear all bpts on specified line.
6651 If defaulting, clear all bpts on default line
6654 defaulting sal.pc != 0 tests to do
6659 1 0 <can't happen> */
6662 found
= (struct breakpoint
*) 0;
6665 while (breakpoint_chain
6666 /* Why don't we check here that this is not
6667 a watchpoint, etc., as we do below?
6668 I can't make it fail, but don't know
6669 what's stopping the failure: a watchpoint
6670 of the same address as "sal.pc" should
6671 wind up being deleted. */
6673 && (((sal
.pc
&& (breakpoint_chain
->address
== sal
.pc
)) &&
6674 (overlay_debugging
== 0 ||
6675 breakpoint_chain
->section
== sal
.section
))
6676 || ((default_match
|| (0 == sal
.pc
))
6677 && breakpoint_chain
->source_file
!= NULL
6678 && sal
.symtab
!= NULL
6679 && STREQ (breakpoint_chain
->source_file
, sal
.symtab
->filename
)
6680 && breakpoint_chain
->line_number
== sal
.line
)))
6683 b1
= breakpoint_chain
;
6684 breakpoint_chain
= b1
->next
;
6692 && b
->next
->type
!= bp_none
6693 && b
->next
->type
!= bp_watchpoint
6694 && b
->next
->type
!= bp_hardware_watchpoint
6695 && b
->next
->type
!= bp_read_watchpoint
6696 && b
->next
->type
!= bp_access_watchpoint
6697 && (((sal
.pc
&& (b
->next
->address
== sal
.pc
)) &&
6698 (overlay_debugging
== 0 ||
6699 b
->next
->section
== sal
.section
))
6700 || ((default_match
|| (0 == sal
.pc
))
6701 && b
->next
->source_file
!= NULL
6702 && sal
.symtab
!= NULL
6703 && STREQ (b
->next
->source_file
, sal
.symtab
->filename
)
6704 && b
->next
->line_number
== sal
.line
)))
6717 error ("No breakpoint at %s.", arg
);
6719 error ("No breakpoint at this line.");
6723 from_tty
= 1; /* Always report if deleted more than one */
6725 printf_unfiltered ("Deleted breakpoint%s ", found
->next
? "s" : "");
6726 breakpoints_changed ();
6730 printf_unfiltered ("%d ", found
->number
);
6732 delete_breakpoint (found
);
6736 putchar_unfiltered ('\n');
6741 /* Delete breakpoint in BS if they are `delete' breakpoints and
6742 all breakpoints that are marked for deletion, whether hit or not.
6743 This is called after any breakpoint is hit, or after errors. */
6746 breakpoint_auto_delete (bpstat bs
)
6748 struct breakpoint
*b
, *temp
;
6750 for (; bs
; bs
= bs
->next
)
6751 if (bs
->breakpoint_at
&& bs
->breakpoint_at
->disposition
== disp_del
6753 delete_breakpoint (bs
->breakpoint_at
);
6755 ALL_BREAKPOINTS_SAFE (b
, temp
)
6757 if (b
->disposition
== disp_del_at_next_stop
)
6758 delete_breakpoint (b
);
6762 /* Delete a breakpoint and clean up all traces of it in the data
6766 delete_breakpoint (struct breakpoint
*bpt
)
6768 register struct breakpoint
*b
;
6772 error ("Internal error (attempted to delete a NULL breakpoint)");
6775 /* Has this bp already been deleted? This can happen because multiple
6776 lists can hold pointers to bp's. bpstat lists are especial culprits.
6778 One example of this happening is a watchpoint's scope bp. When the
6779 scope bp triggers, we notice that the watchpoint is out of scope, and
6780 delete it. We also delete its scope bp. But the scope bp is marked
6781 "auto-deleting", and is already on a bpstat. That bpstat is then
6782 checked for auto-deleting bp's, which are deleted.
6784 A real solution to this problem might involve reference counts in bp's,
6785 and/or giving them pointers back to their referencing bpstat's, and
6786 teaching delete_breakpoint to only free a bp's storage when no more
6787 references were extent. A cheaper bandaid was chosen. */
6788 if (bpt
->type
== bp_none
)
6791 if (delete_breakpoint_hook
)
6792 delete_breakpoint_hook (bpt
);
6793 breakpoint_delete_event (bpt
->number
);
6796 remove_breakpoint (bpt
, mark_inserted
);
6798 if (breakpoint_chain
== bpt
)
6799 breakpoint_chain
= bpt
->next
;
6801 /* If we have callback-style exception catchpoints, don't go through
6802 the adjustments to the C++ runtime library etc. if the inferior
6803 isn't actually running. target_enable_exception_callback for a
6804 null target ops vector gives an undesirable error message, so we
6805 check here and avoid it. Since currently (1997-09-17) only HP-UX aCC's
6806 exceptions are supported in this way, it's OK for now. FIXME */
6807 if (ep_is_exception_catchpoint (bpt
) && target_has_execution
)
6809 static char message1
[] = "Error in deleting catchpoint %d:\n";
6810 static char message
[sizeof (message1
) + 30];
6811 args_for_catchpoint_enable args
;
6813 /* Format possible error msg */
6814 sprintf (message
, message1
, bpt
->number
);
6815 args
.kind
= bpt
->type
== bp_catch_catch
?
6816 EX_EVENT_CATCH
: EX_EVENT_THROW
;
6818 catch_errors (cover_target_enable_exception_callback
, &args
,
6819 message
, RETURN_MASK_ALL
);
6826 b
->next
= bpt
->next
;
6830 check_duplicates (bpt
);
6831 /* If this breakpoint was inserted, and there is another breakpoint
6832 at the same address, we need to insert the other breakpoint. */
6834 && bpt
->type
!= bp_hardware_watchpoint
6835 && bpt
->type
!= bp_read_watchpoint
6836 && bpt
->type
!= bp_access_watchpoint
6837 && bpt
->type
!= bp_catch_fork
6838 && bpt
->type
!= bp_catch_vfork
6839 && bpt
->type
!= bp_catch_exec
)
6842 if (b
->address
== bpt
->address
6843 && b
->section
== bpt
->section
6845 && b
->enable_state
!= bp_disabled
6846 && b
->enable_state
!= bp_shlib_disabled
6847 && b
->enable_state
!= bp_call_disabled
)
6851 /* We should never reach this point if there is a permanent
6852 breakpoint at the same address as the one being deleted.
6853 If there is a permanent breakpoint somewhere, it should
6854 always be the only one inserted. */
6855 if (b
->enable_state
== bp_permanent
)
6856 internal_error (__FILE__
, __LINE__
,
6857 "another breakpoint was inserted on top of "
6858 "a permanent breakpoint");
6860 if (b
->type
== bp_hardware_breakpoint
)
6861 val
= target_insert_hw_breakpoint (b
->address
, b
->shadow_contents
);
6863 val
= target_insert_breakpoint (b
->address
, b
->shadow_contents
);
6867 target_terminal_ours_for_output ();
6868 warning ("Cannot insert breakpoint %d:", b
->number
);
6869 memory_error (val
, b
->address
); /* which bombs us out */
6876 free_command_lines (&bpt
->commands
);
6879 if (bpt
->cond_string
!= NULL
)
6880 xfree (bpt
->cond_string
);
6881 if (bpt
->addr_string
!= NULL
)
6882 xfree (bpt
->addr_string
);
6883 if (bpt
->exp
!= NULL
)
6885 if (bpt
->exp_string
!= NULL
)
6886 xfree (bpt
->exp_string
);
6887 if (bpt
->val
!= NULL
)
6888 value_free (bpt
->val
);
6889 if (bpt
->source_file
!= NULL
)
6890 xfree (bpt
->source_file
);
6891 if (bpt
->dll_pathname
!= NULL
)
6892 xfree (bpt
->dll_pathname
);
6893 if (bpt
->triggered_dll_pathname
!= NULL
)
6894 xfree (bpt
->triggered_dll_pathname
);
6895 if (bpt
->exec_pathname
!= NULL
)
6896 xfree (bpt
->exec_pathname
);
6898 /* Be sure no bpstat's are pointing at it after it's been freed. */
6899 /* FIXME, how can we find all bpstat's?
6900 We just check stop_bpstat for now. */
6901 for (bs
= stop_bpstat
; bs
; bs
= bs
->next
)
6902 if (bs
->breakpoint_at
== bpt
)
6904 bs
->breakpoint_at
= NULL
;
6906 /* we'd call bpstat_clear_actions, but that free's stuff and due
6907 to the multiple pointers pointing to one item with no
6908 reference counts found anywhere through out the bpstat's (how
6909 do you spell fragile?), we don't want to free things twice --
6910 better a memory leak than a corrupt malloc pool! */
6911 bs
->commands
= NULL
;
6914 /* On the chance that someone will soon try again to delete this same
6915 bp, we mark it as deleted before freeing its storage. */
6916 bpt
->type
= bp_none
;
6922 do_delete_breakpoint_cleanup (void *b
)
6924 delete_breakpoint (b
);
6928 make_cleanup_delete_breakpoint (struct breakpoint
*b
)
6930 return make_cleanup (do_delete_breakpoint_cleanup
, b
);
6934 make_exec_cleanup_delete_breakpoint (struct breakpoint
*b
)
6936 return make_exec_cleanup (do_delete_breakpoint_cleanup
, b
);
6940 delete_command (char *arg
, int from_tty
)
6942 struct breakpoint
*b
, *temp
;
6946 int breaks_to_delete
= 0;
6948 /* Delete all breakpoints if no argument.
6949 Do not delete internal or call-dummy breakpoints, these
6950 have to be deleted with an explicit breakpoint number argument. */
6953 if (b
->type
!= bp_call_dummy
&&
6954 b
->type
!= bp_shlib_event
&&
6955 b
->type
!= bp_thread_event
&&
6957 breaks_to_delete
= 1;
6960 /* Ask user only if there are some breakpoints to delete. */
6962 || (breaks_to_delete
&& query ("Delete all breakpoints? ")))
6964 ALL_BREAKPOINTS_SAFE (b
, temp
)
6966 if (b
->type
!= bp_call_dummy
&&
6967 b
->type
!= bp_shlib_event
&&
6968 b
->type
!= bp_thread_event
&&
6970 delete_breakpoint (b
);
6975 map_breakpoint_numbers (arg
, delete_breakpoint
);
6978 /* Reset a breakpoint given it's struct breakpoint * BINT.
6979 The value we return ends up being the return value from catch_errors.
6980 Unused in this case. */
6983 breakpoint_re_set_one (PTR bint
)
6985 /* get past catch_errs */
6986 struct breakpoint
*b
= (struct breakpoint
*) bint
;
6989 struct symtabs_and_lines sals
;
6991 enum enable_state save_enable
;
6996 warning ("attempted to reset apparently deleted breakpoint #%d?",
7000 case bp_hardware_breakpoint
:
7002 case bp_catch_unload
:
7003 if (b
->addr_string
== NULL
)
7005 /* Anything without a string can't be re-set. */
7006 delete_breakpoint (b
);
7009 /* In case we have a problem, disable this breakpoint. We'll restore
7010 its status if we succeed. */
7011 save_enable
= b
->enable_state
;
7012 b
->enable_state
= bp_disabled
;
7014 set_language (b
->language
);
7015 input_radix
= b
->input_radix
;
7017 sals
= decode_line_1 (&s
, 1, (struct symtab
*) NULL
, 0, (char ***) NULL
);
7018 for (i
= 0; i
< sals
.nelts
; i
++)
7020 resolve_sal_pc (&sals
.sals
[i
]);
7022 /* Reparse conditions, they might contain references to the
7024 if (b
->cond_string
!= NULL
)
7029 b
->cond
= parse_exp_1 (&s
, block_for_pc (sals
.sals
[i
].pc
), 0);
7032 /* We need to re-set the breakpoint if the address changes... */
7033 if (b
->address
!= sals
.sals
[i
].pc
7034 /* ...or new and old breakpoints both have source files, and
7035 the source file name or the line number changes... */
7036 || (b
->source_file
!= NULL
7037 && sals
.sals
[i
].symtab
!= NULL
7038 && (!STREQ (b
->source_file
, sals
.sals
[i
].symtab
->filename
)
7039 || b
->line_number
!= sals
.sals
[i
].line
)
7041 /* ...or we switch between having a source file and not having
7043 || ((b
->source_file
== NULL
) != (sals
.sals
[i
].symtab
== NULL
))
7046 if (b
->source_file
!= NULL
)
7047 xfree (b
->source_file
);
7048 if (sals
.sals
[i
].symtab
== NULL
)
7049 b
->source_file
= NULL
;
7052 savestring (sals
.sals
[i
].symtab
->filename
,
7053 strlen (sals
.sals
[i
].symtab
->filename
));
7054 b
->line_number
= sals
.sals
[i
].line
;
7055 b
->address
= sals
.sals
[i
].pc
;
7057 /* Used to check for duplicates here, but that can
7058 cause trouble, as it doesn't check for disable
7063 /* Might be better to do this just once per breakpoint_re_set,
7064 rather than once for every breakpoint. */
7065 breakpoints_changed ();
7067 b
->section
= sals
.sals
[i
].section
;
7068 b
->enable_state
= save_enable
; /* Restore it, this worked. */
7071 /* Now that this is re-enabled, check_duplicates
7073 check_duplicates (b
);
7080 case bp_hardware_watchpoint
:
7081 case bp_read_watchpoint
:
7082 case bp_access_watchpoint
:
7083 innermost_block
= NULL
;
7084 /* The issue arises of what context to evaluate this in. The
7085 same one as when it was set, but what does that mean when
7086 symbols have been re-read? We could save the filename and
7087 functionname, but if the context is more local than that, the
7088 best we could do would be something like how many levels deep
7089 and which index at that particular level, but that's going to
7090 be less stable than filenames or function names. */
7092 /* So for now, just use a global context. */
7095 b
->exp
= parse_expression (b
->exp_string
);
7096 b
->exp_valid_block
= innermost_block
;
7097 mark
= value_mark ();
7099 value_free (b
->val
);
7100 b
->val
= evaluate_expression (b
->exp
);
7101 release_value (b
->val
);
7102 if (VALUE_LAZY (b
->val
))
7103 value_fetch_lazy (b
->val
);
7105 if (b
->cond_string
!= NULL
)
7110 b
->cond
= parse_exp_1 (&s
, (struct block
*) 0, 0);
7112 if (b
->enable_state
== bp_enabled
)
7114 value_free_to_mark (mark
);
7116 case bp_catch_catch
:
7117 case bp_catch_throw
:
7119 /* We needn't really do anything to reset these, since the mask
7120 that requests them is unaffected by e.g., new libraries being
7123 case bp_catch_vfork
:
7128 printf_filtered ("Deleting unknown breakpoint type %d\n", b
->type
);
7130 /* Delete longjmp breakpoints, they will be reset later by
7131 breakpoint_re_set. */
7133 case bp_longjmp_resume
:
7134 delete_breakpoint (b
);
7137 /* This breakpoint is special, it's set up when the inferior
7138 starts and we really don't want to touch it. */
7139 case bp_shlib_event
:
7141 /* Like bp_shlib_event, this breakpoint type is special.
7142 Once it is set up, we do not want to touch it. */
7143 case bp_thread_event
:
7145 /* Keep temporary breakpoints, which can be encountered when we step
7146 over a dlopen call and SOLIB_ADD is resetting the breakpoints.
7147 Otherwise these should have been blown away via the cleanup chain
7148 or by breakpoint_init_inferior when we rerun the executable. */
7151 case bp_watchpoint_scope
:
7153 case bp_step_resume
:
7160 /* Re-set all breakpoints after symbols have been re-loaded. */
7162 breakpoint_re_set (void)
7164 struct breakpoint
*b
, *temp
;
7165 enum language save_language
;
7166 int save_input_radix
;
7167 static char message1
[] = "Error in re-setting breakpoint %d:\n";
7168 char message
[sizeof (message1
) + 30 /* slop */ ];
7170 save_language
= current_language
->la_language
;
7171 save_input_radix
= input_radix
;
7172 ALL_BREAKPOINTS_SAFE (b
, temp
)
7174 /* Format possible error msg */
7175 sprintf (message
, message1
, b
->number
);
7176 catch_errors (breakpoint_re_set_one
, b
, message
, RETURN_MASK_ALL
);
7178 set_language (save_language
);
7179 input_radix
= save_input_radix
;
7181 #ifdef GET_LONGJMP_TARGET
7182 create_longjmp_breakpoint ("longjmp");
7183 create_longjmp_breakpoint ("_longjmp");
7184 create_longjmp_breakpoint ("siglongjmp");
7185 create_longjmp_breakpoint ("_siglongjmp");
7186 create_longjmp_breakpoint (NULL
);
7190 /* Took this out (temporarily at least), since it produces an extra
7191 blank line at startup. This messes up the gdbtests. -PB */
7192 /* Blank line to finish off all those mention() messages we just printed. */
7193 printf_filtered ("\n");
7197 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
7198 If from_tty is nonzero, it prints a message to that effect,
7199 which ends with a period (no newline). */
7201 /* Reset the thread number of this breakpoint:
7203 - If the breakpoint is for all threads, leave it as-is.
7204 - Else, reset it to the current thread for inferior_ptid. */
7206 breakpoint_re_set_thread (struct breakpoint
*b
)
7208 if (b
->thread
!= -1)
7210 if (in_thread_list (inferior_ptid
))
7211 b
->thread
= pid_to_thread_id (inferior_ptid
);
7216 set_ignore_count (int bptnum
, int count
, int from_tty
)
7218 register struct breakpoint
*b
;
7224 if (b
->number
== bptnum
)
7226 b
->ignore_count
= count
;
7229 else if (count
== 0)
7230 printf_filtered ("Will stop next time breakpoint %d is reached.",
7232 else if (count
== 1)
7233 printf_filtered ("Will ignore next crossing of breakpoint %d.",
7236 printf_filtered ("Will ignore next %d crossings of breakpoint %d.",
7238 breakpoints_changed ();
7242 error ("No breakpoint number %d.", bptnum
);
7245 /* Clear the ignore counts of all breakpoints. */
7247 breakpoint_clear_ignore_counts (void)
7249 struct breakpoint
*b
;
7252 b
->ignore_count
= 0;
7255 /* Command to set ignore-count of breakpoint N to COUNT. */
7258 ignore_command (char *args
, int from_tty
)
7264 error_no_arg ("a breakpoint number");
7266 num
= get_number (&p
);
7268 error ("bad breakpoint number: '%s'", args
);
7270 error ("Second argument (specified ignore-count) is missing.");
7272 set_ignore_count (num
,
7273 longest_to_int (value_as_long (parse_and_eval (p
))),
7275 printf_filtered ("\n");
7276 breakpoints_changed ();
7279 /* Call FUNCTION on each of the breakpoints
7280 whose numbers are given in ARGS. */
7283 map_breakpoint_numbers (char *args
, void (*function
) (struct breakpoint
*))
7285 register char *p
= args
;
7288 register struct breakpoint
*b
, *tmp
;
7292 error_no_arg ("one or more breakpoint numbers");
7299 num
= get_number_or_range (&p1
);
7302 warning ("bad breakpoint number at or near '%s'", p
);
7306 ALL_BREAKPOINTS_SAFE (b
, tmp
)
7307 if (b
->number
== num
)
7309 struct breakpoint
*related_breakpoint
= b
->related_breakpoint
;
7312 if (related_breakpoint
)
7313 function (related_breakpoint
);
7317 printf_unfiltered ("No breakpoint number %d.\n", num
);
7324 disable_breakpoint (struct breakpoint
*bpt
)
7326 /* Never disable a watchpoint scope breakpoint; we want to
7327 hit them when we leave scope so we can delete both the
7328 watchpoint and its scope breakpoint at that time. */
7329 if (bpt
->type
== bp_watchpoint_scope
)
7332 /* You can't disable permanent breakpoints. */
7333 if (bpt
->enable_state
== bp_permanent
)
7336 bpt
->enable_state
= bp_disabled
;
7338 check_duplicates (bpt
);
7340 if (modify_breakpoint_hook
)
7341 modify_breakpoint_hook (bpt
);
7342 breakpoint_modify_event (bpt
->number
);
7347 disable_command (char *args
, int from_tty
)
7349 register struct breakpoint
*bpt
;
7351 ALL_BREAKPOINTS (bpt
)
7355 warning ("attempted to disable apparently deleted breakpoint #%d?",
7360 case bp_catch_unload
:
7362 case bp_catch_vfork
:
7364 case bp_catch_catch
:
7365 case bp_catch_throw
:
7366 case bp_hardware_breakpoint
:
7368 case bp_hardware_watchpoint
:
7369 case bp_read_watchpoint
:
7370 case bp_access_watchpoint
:
7371 disable_breakpoint (bpt
);
7376 map_breakpoint_numbers (args
, disable_breakpoint
);
7380 do_enable_breakpoint (struct breakpoint
*bpt
, enum bpdisp disposition
)
7382 struct frame_info
*save_selected_frame
= NULL
;
7383 int save_selected_frame_level
= -1;
7384 int target_resources_ok
, other_type_used
;
7387 if (bpt
->type
== bp_hardware_breakpoint
)
7390 i
= hw_breakpoint_used_count ();
7391 target_resources_ok
=
7392 TARGET_CAN_USE_HARDWARE_WATCHPOINT (bp_hardware_breakpoint
,
7394 if (target_resources_ok
== 0)
7395 error ("No hardware breakpoint support in the target.");
7396 else if (target_resources_ok
< 0)
7397 error ("Hardware breakpoints used exceeds limit.");
7400 if (bpt
->enable_state
!= bp_permanent
)
7401 bpt
->enable_state
= bp_enabled
;
7402 bpt
->disposition
= disposition
;
7403 check_duplicates (bpt
);
7404 breakpoints_changed ();
7406 if (bpt
->type
== bp_watchpoint
||
7407 bpt
->type
== bp_hardware_watchpoint
||
7408 bpt
->type
== bp_read_watchpoint
||
7409 bpt
->type
== bp_access_watchpoint
)
7411 if (bpt
->exp_valid_block
!= NULL
)
7413 struct frame_info
*fr
=
7415 /* Ensure that we have the current frame. Else, this
7416 next query may pessimistically be answered as, "No,
7417 not within current scope". */
7418 get_current_frame ();
7419 fr
= find_frame_addr_in_frame_chain (bpt
->watchpoint_frame
);
7423 Cannot enable watchpoint %d because the block in which its expression\n\
7424 is valid is not currently in scope.\n", bpt
->number
);
7425 bpt
->enable_state
= bp_disabled
;
7429 save_selected_frame
= selected_frame
;
7430 save_selected_frame_level
= selected_frame_level
;
7431 select_frame (fr
, -1);
7434 value_free (bpt
->val
);
7435 mark
= value_mark ();
7436 bpt
->val
= evaluate_expression (bpt
->exp
);
7437 release_value (bpt
->val
);
7438 if (VALUE_LAZY (bpt
->val
))
7439 value_fetch_lazy (bpt
->val
);
7441 if (bpt
->type
== bp_hardware_watchpoint
||
7442 bpt
->type
== bp_read_watchpoint
||
7443 bpt
->type
== bp_access_watchpoint
)
7445 int i
= hw_watchpoint_used_count (bpt
->type
, &other_type_used
);
7446 int mem_cnt
= can_use_hardware_watchpoint (bpt
->val
);
7448 /* Hack around 'unused var' error for some targets here */
7450 target_resources_ok
= TARGET_CAN_USE_HARDWARE_WATCHPOINT (
7451 bpt
->type
, i
+ mem_cnt
, other_type_used
);
7452 /* we can consider of type is bp_hardware_watchpoint, convert to
7453 bp_watchpoint in the following condition */
7454 if (target_resources_ok
< 0)
7457 Cannot enable watchpoint %d because target watch resources\n\
7458 have been allocated for other watchpoints.\n", bpt
->number
);
7459 bpt
->enable_state
= bp_disabled
;
7460 value_free_to_mark (mark
);
7465 if (save_selected_frame_level
>= 0)
7466 select_frame (save_selected_frame
, save_selected_frame_level
);
7467 value_free_to_mark (mark
);
7469 if (modify_breakpoint_hook
)
7470 modify_breakpoint_hook (bpt
);
7471 breakpoint_modify_event (bpt
->number
);
7475 enable_breakpoint (struct breakpoint
*bpt
)
7477 do_enable_breakpoint (bpt
, bpt
->disposition
);
7480 /* The enable command enables the specified breakpoints (or all defined
7481 breakpoints) so they once again become (or continue to be) effective
7482 in stopping the inferior. */
7486 enable_command (char *args
, int from_tty
)
7488 register struct breakpoint
*bpt
;
7490 ALL_BREAKPOINTS (bpt
)
7494 warning ("attempted to enable apparently deleted breakpoint #%d?",
7499 case bp_catch_unload
:
7501 case bp_catch_vfork
:
7503 case bp_catch_catch
:
7504 case bp_catch_throw
:
7505 case bp_hardware_breakpoint
:
7507 case bp_hardware_watchpoint
:
7508 case bp_read_watchpoint
:
7509 case bp_access_watchpoint
:
7510 enable_breakpoint (bpt
);
7515 map_breakpoint_numbers (args
, enable_breakpoint
);
7519 enable_once_breakpoint (struct breakpoint
*bpt
)
7521 do_enable_breakpoint (bpt
, disp_disable
);
7526 enable_once_command (char *args
, int from_tty
)
7528 map_breakpoint_numbers (args
, enable_once_breakpoint
);
7532 enable_delete_breakpoint (struct breakpoint
*bpt
)
7534 do_enable_breakpoint (bpt
, disp_del
);
7539 enable_delete_command (char *args
, int from_tty
)
7541 map_breakpoint_numbers (args
, enable_delete_breakpoint
);
7544 /* Use default_breakpoint_'s, or nothing if they aren't valid. */
7546 struct symtabs_and_lines
7547 decode_line_spec_1 (char *string
, int funfirstline
)
7549 struct symtabs_and_lines sals
;
7551 error ("Empty line specification.");
7552 if (default_breakpoint_valid
)
7553 sals
= decode_line_1 (&string
, funfirstline
,
7554 default_breakpoint_symtab
,
7555 default_breakpoint_line
,
7558 sals
= decode_line_1 (&string
, funfirstline
,
7559 (struct symtab
*) NULL
, 0, (char ***) NULL
);
7561 error ("Junk at end of line specification: %s", string
);
7566 _initialize_breakpoint (void)
7568 struct cmd_list_element
*c
;
7570 breakpoint_chain
= 0;
7571 /* Don't bother to call set_breakpoint_count. $bpnum isn't useful
7572 before a breakpoint is set. */
7573 breakpoint_count
= 0;
7575 add_com ("ignore", class_breakpoint
, ignore_command
,
7576 "Set ignore-count of breakpoint number N to COUNT.\n\
7577 Usage is `ignore N COUNT'.");
7579 add_com_alias ("bc", "ignore", class_breakpoint
, 1);
7581 add_com ("commands", class_breakpoint
, commands_command
,
7582 "Set commands to be executed when a breakpoint is hit.\n\
7583 Give breakpoint number as argument after \"commands\".\n\
7584 With no argument, the targeted breakpoint is the last one set.\n\
7585 The commands themselves follow starting on the next line.\n\
7586 Type a line containing \"end\" to indicate the end of them.\n\
7587 Give \"silent\" as the first line to make the breakpoint silent;\n\
7588 then no output is printed when it is hit, except what the commands print.");
7590 add_com ("condition", class_breakpoint
, condition_command
,
7591 "Specify breakpoint number N to break only if COND is true.\n\
7592 Usage is `condition N COND', where N is an integer and COND is an\n\
7593 expression to be evaluated whenever breakpoint N is reached. ");
7595 c
= add_com ("tbreak", class_breakpoint
, tbreak_command
,
7596 "Set a temporary breakpoint. Args like \"break\" command.\n\
7597 Like \"break\" except the breakpoint is only temporary,\n\
7598 so it will be deleted when hit. Equivalent to \"break\" followed\n\
7599 by using \"enable delete\" on the breakpoint number.");
7600 c
->completer
= location_completer
;
7602 c
= add_com ("txbreak", class_breakpoint
, tbreak_at_finish_command
,
7603 "Set temporary breakpoint at procedure exit. Either there should\n\
7604 be no argument or the argument must be a depth.\n");
7605 c
->completer
= location_completer
;
7607 c
= add_com ("hbreak", class_breakpoint
, hbreak_command
,
7608 "Set a hardware assisted breakpoint. Args like \"break\" command.\n\
7609 Like \"break\" except the breakpoint requires hardware support,\n\
7610 some target hardware may not have this support.");
7611 c
->completer
= location_completer
;
7613 c
= add_com ("thbreak", class_breakpoint
, thbreak_command
,
7614 "Set a temporary hardware assisted breakpoint. Args like \"break\" command.\n\
7615 Like \"hbreak\" except the breakpoint is only temporary,\n\
7616 so it will be deleted when hit.");
7617 c
->completer
= location_completer
;
7619 add_prefix_cmd ("enable", class_breakpoint
, enable_command
,
7620 "Enable some breakpoints.\n\
7621 Give breakpoint numbers (separated by spaces) as arguments.\n\
7622 With no subcommand, breakpoints are enabled until you command otherwise.\n\
7623 This is used to cancel the effect of the \"disable\" command.\n\
7624 With a subcommand you can enable temporarily.",
7625 &enablelist
, "enable ", 1, &cmdlist
);
7627 add_com ("ab", class_breakpoint
, enable_command
,
7628 "Enable some breakpoints.\n\
7629 Give breakpoint numbers (separated by spaces) as arguments.\n\
7630 With no subcommand, breakpoints are enabled until you command otherwise.\n\
7631 This is used to cancel the effect of the \"disable\" command.\n\
7632 With a subcommand you can enable temporarily.");
7634 add_com_alias ("en", "enable", class_breakpoint
, 1);
7636 add_abbrev_prefix_cmd ("breakpoints", class_breakpoint
, enable_command
,
7637 "Enable some breakpoints.\n\
7638 Give breakpoint numbers (separated by spaces) as arguments.\n\
7639 This is used to cancel the effect of the \"disable\" command.\n\
7640 May be abbreviated to simply \"enable\".\n",
7641 &enablebreaklist
, "enable breakpoints ", 1, &enablelist
);
7643 add_cmd ("once", no_class
, enable_once_command
,
7644 "Enable breakpoints for one hit. Give breakpoint numbers.\n\
7645 If a breakpoint is hit while enabled in this fashion, it becomes disabled.",
7648 add_cmd ("delete", no_class
, enable_delete_command
,
7649 "Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
7650 If a breakpoint is hit while enabled in this fashion, it is deleted.",
7653 add_cmd ("delete", no_class
, enable_delete_command
,
7654 "Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
7655 If a breakpoint is hit while enabled in this fashion, it is deleted.",
7658 add_cmd ("once", no_class
, enable_once_command
,
7659 "Enable breakpoints for one hit. Give breakpoint numbers.\n\
7660 If a breakpoint is hit while enabled in this fashion, it becomes disabled.",
7663 add_prefix_cmd ("disable", class_breakpoint
, disable_command
,
7664 "Disable some breakpoints.\n\
7665 Arguments are breakpoint numbers with spaces in between.\n\
7666 To disable all breakpoints, give no argument.\n\
7667 A disabled breakpoint is not forgotten, but has no effect until reenabled.",
7668 &disablelist
, "disable ", 1, &cmdlist
);
7669 add_com_alias ("dis", "disable", class_breakpoint
, 1);
7670 add_com_alias ("disa", "disable", class_breakpoint
, 1);
7672 add_com ("sb", class_breakpoint
, disable_command
,
7673 "Disable some breakpoints.\n\
7674 Arguments are breakpoint numbers with spaces in between.\n\
7675 To disable all breakpoints, give no argument.\n\
7676 A disabled breakpoint is not forgotten, but has no effect until reenabled.");
7678 add_cmd ("breakpoints", class_alias
, disable_command
,
7679 "Disable some breakpoints.\n\
7680 Arguments are breakpoint numbers with spaces in between.\n\
7681 To disable all breakpoints, give no argument.\n\
7682 A disabled breakpoint is not forgotten, but has no effect until reenabled.\n\
7683 This command may be abbreviated \"disable\".",
7686 add_prefix_cmd ("delete", class_breakpoint
, delete_command
,
7687 "Delete some breakpoints or auto-display expressions.\n\
7688 Arguments are breakpoint numbers with spaces in between.\n\
7689 To delete all breakpoints, give no argument.\n\
7691 Also a prefix command for deletion of other GDB objects.\n\
7692 The \"unset\" command is also an alias for \"delete\".",
7693 &deletelist
, "delete ", 1, &cmdlist
);
7694 add_com_alias ("d", "delete", class_breakpoint
, 1);
7696 add_com ("db", class_breakpoint
, delete_command
,
7697 "Delete some breakpoints.\n\
7698 Arguments are breakpoint numbers with spaces in between.\n\
7699 To delete all breakpoints, give no argument.\n");
7701 add_cmd ("breakpoints", class_alias
, delete_command
,
7702 "Delete some breakpoints or auto-display expressions.\n\
7703 Arguments are breakpoint numbers with spaces in between.\n\
7704 To delete all breakpoints, give no argument.\n\
7705 This command may be abbreviated \"delete\".",
7708 add_com ("clear", class_breakpoint
, clear_command
,
7709 concat ("Clear breakpoint at specified line or function.\n\
7710 Argument may be line number, function name, or \"*\" and an address.\n\
7711 If line number is specified, all breakpoints in that line are cleared.\n\
7712 If function is specified, breakpoints at beginning of function are cleared.\n\
7713 If an address is specified, breakpoints at that address are cleared.\n\n",
7714 "With no argument, clears all breakpoints in the line that the selected frame\n\
7717 See also the \"delete\" command which clears breakpoints by number.", NULL
));
7719 c
= add_com ("break", class_breakpoint
, break_command
,
7720 concat ("Set breakpoint at specified line or function.\n\
7721 Argument may be line number, function name, or \"*\" and an address.\n\
7722 If line number is specified, break at start of code for that line.\n\
7723 If function is specified, break at start of code for that function.\n\
7724 If an address is specified, break at that exact address.\n",
7725 "With no arg, uses current execution address of selected stack frame.\n\
7726 This is useful for breaking on return to a stack frame.\n\
7728 Multiple breakpoints at one place are permitted, and useful if conditional.\n\
7730 Do \"help breakpoints\" for info on other commands dealing with breakpoints.", NULL
));
7731 c
->completer
= location_completer
;
7733 add_com_alias ("b", "break", class_run
, 1);
7734 add_com_alias ("br", "break", class_run
, 1);
7735 add_com_alias ("bre", "break", class_run
, 1);
7736 add_com_alias ("brea", "break", class_run
, 1);
7738 add_com ("xbreak", class_breakpoint
, break_at_finish_command
,
7739 concat ("Set breakpoint at procedure exit. \n\
7740 Argument may be function name, or \"*\" and an address.\n\
7741 If function is specified, break at end of code for that function.\n\
7742 If an address is specified, break at the end of the function that contains \n\
7743 that exact address.\n",
7744 "With no arg, uses current execution address of selected stack frame.\n\
7745 This is useful for breaking on return to a stack frame.\n\
7747 Multiple breakpoints at one place are permitted, and useful if conditional.\n\
7749 Do \"help breakpoints\" for info on other commands dealing with breakpoints.", NULL
));
7750 add_com_alias ("xb", "xbreak", class_breakpoint
, 1);
7751 add_com_alias ("xbr", "xbreak", class_breakpoint
, 1);
7752 add_com_alias ("xbre", "xbreak", class_breakpoint
, 1);
7753 add_com_alias ("xbrea", "xbreak", class_breakpoint
, 1);
7757 add_com_alias ("ba", "break", class_breakpoint
, 1);
7758 add_com_alias ("bu", "ubreak", class_breakpoint
, 1);
7759 add_com ("bx", class_breakpoint
, break_at_finish_at_depth_command
,
7760 "Set breakpoint at procedure exit. Either there should\n\
7761 be no argument or the argument must be a depth.\n");
7766 add_abbrev_prefix_cmd ("stop", class_breakpoint
, stop_command
,
7767 "Break in function/address or break at a line in the current file.",
7768 &stoplist
, "stop ", 1, &cmdlist
);
7769 add_cmd ("in", class_breakpoint
, stopin_command
,
7770 "Break in function or address.\n", &stoplist
);
7771 add_cmd ("at", class_breakpoint
, stopat_command
,
7772 "Break at a line in the current file.\n", &stoplist
);
7773 add_com ("status", class_info
, breakpoints_info
,
7774 concat ("Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
7775 The \"Type\" column indicates one of:\n\
7776 \tbreakpoint - normal breakpoint\n\
7777 \twatchpoint - watchpoint\n\
7778 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
7779 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
7780 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
7781 address and file/line number respectively.\n\n",
7782 "Convenience variable \"$_\" and default examine address for \"x\"\n\
7783 are set to the address of the last breakpoint listed.\n\n\
7784 Convenience variable \"$bpnum\" contains the number of the last\n\
7785 breakpoint set.", NULL
));
7788 add_info ("breakpoints", breakpoints_info
,
7789 concat ("Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
7790 The \"Type\" column indicates one of:\n\
7791 \tbreakpoint - normal breakpoint\n\
7792 \twatchpoint - watchpoint\n\
7793 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
7794 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
7795 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
7796 address and file/line number respectively.\n\n",
7797 "Convenience variable \"$_\" and default examine address for \"x\"\n\
7798 are set to the address of the last breakpoint listed.\n\n\
7799 Convenience variable \"$bpnum\" contains the number of the last\n\
7800 breakpoint set.", NULL
));
7803 add_com ("lb", class_breakpoint
, breakpoints_info
,
7804 concat ("Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
7805 The \"Type\" column indicates one of:\n\
7806 \tbreakpoint - normal breakpoint\n\
7807 \twatchpoint - watchpoint\n\
7808 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
7809 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
7810 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
7811 address and file/line number respectively.\n\n",
7812 "Convenience variable \"$_\" and default examine address for \"x\"\n\
7813 are set to the address of the last breakpoint listed.\n\n\
7814 Convenience variable \"$bpnum\" contains the number of the last\n\
7815 breakpoint set.", NULL
));
7817 add_cmd ("breakpoints", class_maintenance
, maintenance_info_breakpoints
,
7818 concat ("Status of all breakpoints, or breakpoint number NUMBER.\n\
7819 The \"Type\" column indicates one of:\n\
7820 \tbreakpoint - normal breakpoint\n\
7821 \twatchpoint - watchpoint\n\
7822 \tlongjmp - internal breakpoint used to step through longjmp()\n\
7823 \tlongjmp resume - internal breakpoint at the target of longjmp()\n\
7824 \tuntil - internal breakpoint used by the \"until\" command\n\
7825 \tfinish - internal breakpoint used by the \"finish\" command\n",
7826 "The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
7827 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
7828 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
7829 address and file/line number respectively.\n\n",
7830 "Convenience variable \"$_\" and default examine address for \"x\"\n\
7831 are set to the address of the last breakpoint listed.\n\n\
7832 Convenience variable \"$bpnum\" contains the number of the last\n\
7833 breakpoint set.", NULL
),
7834 &maintenanceinfolist
);
7836 add_com ("catch", class_breakpoint
, catch_command
,
7837 "Set catchpoints to catch events.\n\
7838 Raised signals may be caught:\n\
7839 \tcatch signal - all signals\n\
7840 \tcatch signal <signame> - a particular signal\n\
7841 Raised exceptions may be caught:\n\
7842 \tcatch throw - all exceptions, when thrown\n\
7843 \tcatch throw <exceptname> - a particular exception, when thrown\n\
7844 \tcatch catch - all exceptions, when caught\n\
7845 \tcatch catch <exceptname> - a particular exception, when caught\n\
7846 Thread or process events may be caught:\n\
7847 \tcatch thread_start - any threads, just after creation\n\
7848 \tcatch thread_exit - any threads, just before expiration\n\
7849 \tcatch thread_join - any threads, just after joins\n\
7850 Process events may be caught:\n\
7851 \tcatch start - any processes, just after creation\n\
7852 \tcatch exit - any processes, just before expiration\n\
7853 \tcatch fork - calls to fork()\n\
7854 \tcatch vfork - calls to vfork()\n\
7855 \tcatch exec - calls to exec()\n\
7856 Dynamically-linked library events may be caught:\n\
7857 \tcatch load - loads of any library\n\
7858 \tcatch load <libname> - loads of a particular library\n\
7859 \tcatch unload - unloads of any library\n\
7860 \tcatch unload <libname> - unloads of a particular library\n\
7861 The act of your program's execution stopping may also be caught:\n\
7863 C++ exceptions may be caught:\n\
7864 \tcatch throw - all exceptions, when thrown\n\
7865 \tcatch catch - all exceptions, when caught\n\
7867 Do \"help set follow-fork-mode\" for info on debugging your program\n\
7868 after a fork or vfork is caught.\n\n\
7869 Do \"help breakpoints\" for info on other commands dealing with breakpoints.");
7871 add_com ("tcatch", class_breakpoint
, tcatch_command
,
7872 "Set temporary catchpoints to catch events.\n\
7873 Args like \"catch\" command.\n\
7874 Like \"catch\" except the catchpoint is only temporary,\n\
7875 so it will be deleted when hit. Equivalent to \"catch\" followed\n\
7876 by using \"enable delete\" on the catchpoint number.");
7878 c
= add_com ("watch", class_breakpoint
, watch_command
,
7879 "Set a watchpoint for an expression.\n\
7880 A watchpoint stops execution of your program whenever the value of\n\
7881 an expression changes.");
7882 c
->completer
= location_completer
;
7884 c
= add_com ("rwatch", class_breakpoint
, rwatch_command
,
7885 "Set a read watchpoint for an expression.\n\
7886 A watchpoint stops execution of your program whenever the value of\n\
7887 an expression is read.");
7888 c
->completer
= location_completer
;
7890 c
= add_com ("awatch", class_breakpoint
, awatch_command
,
7891 "Set a watchpoint for an expression.\n\
7892 A watchpoint stops execution of your program whenever the value of\n\
7893 an expression is either read or written.");
7894 c
->completer
= location_completer
;
7896 add_info ("watchpoints", breakpoints_info
,
7897 "Synonym for ``info breakpoints''.");
7900 c
= add_set_cmd ("can-use-hw-watchpoints", class_support
, var_zinteger
,
7901 (char *) &can_use_hw_watchpoints
,
7902 "Set debugger's willingness to use watchpoint hardware.\n\
7903 If zero, gdb will not use hardware for new watchpoints, even if\n\
7904 such is available. (However, any hardware watchpoints that were\n\
7905 created before setting this to nonzero, will continue to use watchpoint\n\
7908 add_show_from_set (c
, &showlist
);
7910 can_use_hw_watchpoints
= 1;