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"
47 #include "gdb-events.h"
49 /* Prototypes for local functions. */
51 static void until_break_command_continuation (struct continuation_arg
*arg
);
53 static void catch_command_1 (char *, int, int);
55 static void enable_delete_command (char *, int);
57 static void enable_delete_breakpoint (struct breakpoint
*);
59 static void enable_once_command (char *, int);
61 static void enable_once_breakpoint (struct breakpoint
*);
63 static void disable_command (char *, int);
65 static void enable_command (char *, int);
67 static void map_breakpoint_numbers (char *, void (*)(struct breakpoint
*));
69 static void ignore_command (char *, int);
71 static int breakpoint_re_set_one (PTR
);
73 static void clear_command (char *, int);
75 static void catch_command (char *, int);
77 static void handle_gnu_4_16_catch_command (char *, int, int);
79 static struct symtabs_and_lines
get_catch_sals (int);
81 static void watch_command (char *, int);
83 static int can_use_hardware_watchpoint (struct value
*);
85 static void break_at_finish_command (char *, int);
86 static void break_at_finish_at_depth_command (char *, int);
88 static void tbreak_at_finish_command (char *, int);
90 static void break_command_1 (char *, int, int);
92 static void mention (struct breakpoint
*);
94 struct breakpoint
*set_raw_breakpoint (struct symtab_and_line
, enum bptype
);
96 static void check_duplicates (struct breakpoint
*);
98 static void describe_other_breakpoints (CORE_ADDR
, asection
*);
100 static void breakpoints_info (char *, int);
102 static void breakpoint_1 (int, int);
104 static bpstat
bpstat_alloc (struct breakpoint
*, bpstat
);
106 static int breakpoint_cond_eval (PTR
);
108 static void cleanup_executing_breakpoints (PTR
);
110 static void commands_command (char *, int);
112 static void condition_command (char *, int);
114 static int get_number_trailer (char **, int);
116 void set_breakpoint_count (int);
119 static struct breakpoint
*create_temp_exception_breakpoint (CORE_ADDR
);
129 static int remove_breakpoint (struct breakpoint
*, insertion_state_t
);
131 static enum print_stop_action
print_it_typical (bpstat
);
133 static enum print_stop_action
print_bp_stop_message (bpstat bs
);
137 enum exception_event_kind kind
;
140 args_for_catchpoint_enable
;
142 static int watchpoint_check (PTR
);
144 static int cover_target_enable_exception_callback (PTR
);
146 static void maintenance_info_breakpoints (char *, int);
148 #ifdef GET_LONGJMP_TARGET
149 static void create_longjmp_breakpoint (char *);
152 static int hw_breakpoint_used_count (void);
154 static int hw_watchpoint_used_count (enum bptype
, int *);
156 static void hbreak_command (char *, int);
158 static void thbreak_command (char *, int);
160 static void watch_command_1 (char *, int, int);
162 static void rwatch_command (char *, int);
164 static void awatch_command (char *, int);
166 static void do_enable_breakpoint (struct breakpoint
*, enum bpdisp
);
168 static void solib_load_unload_1 (char *hookname
,
171 char *cond_string
, enum bptype bp_kind
);
173 static void create_fork_vfork_event_catchpoint (int tempflag
,
175 enum bptype bp_kind
);
177 static void break_at_finish_at_depth_command_1 (char *arg
,
178 int flag
, int from_tty
);
180 static void break_at_finish_command_1 (char *arg
, int flag
, int from_tty
);
182 static void stop_command (char *arg
, int from_tty
);
184 static void stopin_command (char *arg
, int from_tty
);
186 static void stopat_command (char *arg
, int from_tty
);
188 static char *ep_find_event_name_end (char *arg
);
190 static char *ep_parse_optional_if_clause (char **arg
);
192 static char *ep_parse_optional_filename (char **arg
);
194 #if defined(CHILD_INSERT_EXEC_CATCHPOINT)
195 static void catch_exec_command_1 (char *arg
, int tempflag
, int from_tty
);
198 static void create_exception_catchpoint (int tempflag
, char *cond_string
,
199 enum exception_event_kind ex_event
,
200 struct symtab_and_line
*sal
);
202 static void catch_exception_command_1 (enum exception_event_kind ex_event
,
203 char *arg
, int tempflag
, int from_tty
);
205 static void tcatch_command (char *arg
, int from_tty
);
207 static void ep_skip_leading_whitespace (char **s
);
209 /* Prototypes for exported functions. */
211 /* If FALSE, gdb will not use hardware support for watchpoints, even
212 if such is available. */
213 static int can_use_hw_watchpoints
;
215 void _initialize_breakpoint (void);
217 extern int addressprint
; /* Print machine addresses? */
219 static int internal_breakpoint_number
= -1;
221 /* Are we executing breakpoint commands? */
222 static int executing_breakpoint_commands
;
224 /* Walk the following statement or block through all breakpoints.
225 ALL_BREAKPOINTS_SAFE does so even if the statment deletes the current
228 #define ALL_BREAKPOINTS(B) for (B = breakpoint_chain; B; B = B->next)
230 #define ALL_BREAKPOINTS_SAFE(B,TMP) \
231 for (B = breakpoint_chain; \
232 B ? (TMP=B->next, 1): 0; \
235 /* True if SHIFT_INST_REGS defined, false otherwise. */
237 int must_shift_inst_regs
=
238 #if defined(SHIFT_INST_REGS)
245 /* True if breakpoint hit counts should be displayed in breakpoint info. */
247 int show_breakpoint_hit_counts
= 1;
249 /* Chain of all breakpoints defined. */
251 struct breakpoint
*breakpoint_chain
;
253 /* Number of last breakpoint made. */
255 int breakpoint_count
;
257 /* Pointer to current exception event record */
258 static struct exception_event_record
*current_exception_event
;
260 /* Indicator of whether exception catchpoints should be nuked
261 between runs of a program */
262 int exception_catchpoints_are_fragile
= 0;
264 /* Indicator of when exception catchpoints set-up should be
265 reinitialized -- e.g. when program is re-run */
266 int exception_support_initialized
= 0;
268 /* This function returns a pointer to the string representation of the
269 pathname of the dynamically-linked library that has just been
272 This function must be used only when SOLIB_HAVE_LOAD_EVENT is TRUE,
273 or undefined results are guaranteed.
275 This string's contents are only valid immediately after the
276 inferior has stopped in the dynamic linker hook, and becomes
277 invalid as soon as the inferior is continued. Clients should make
278 a copy of this string if they wish to continue the inferior and
279 then access the string. */
281 #ifndef SOLIB_LOADED_LIBRARY_PATHNAME
282 #define SOLIB_LOADED_LIBRARY_PATHNAME(pid) ""
285 /* This function returns a pointer to the string representation of the
286 pathname of the dynamically-linked library that has just been
289 This function must be used only when SOLIB_HAVE_UNLOAD_EVENT is
290 TRUE, or undefined results are guaranteed.
292 This string's contents are only valid immediately after the
293 inferior has stopped in the dynamic linker hook, and becomes
294 invalid as soon as the inferior is continued. Clients should make
295 a copy of this string if they wish to continue the inferior and
296 then access the string. */
298 #ifndef SOLIB_UNLOADED_LIBRARY_PATHNAME
299 #define SOLIB_UNLOADED_LIBRARY_PATHNAME(pid) ""
302 /* This function is called by the "catch load" command. It allows the
303 debugger to be notified by the dynamic linker when a specified
304 library file (or any library file, if filename is NULL) is loaded. */
306 #ifndef SOLIB_CREATE_CATCH_LOAD_HOOK
307 #define SOLIB_CREATE_CATCH_LOAD_HOOK(pid,tempflag,filename,cond_string) \
308 error ("catch of library loads not yet implemented on this platform")
311 /* This function is called by the "catch unload" command. It allows
312 the debugger to be notified by the dynamic linker when a specified
313 library file (or any library file, if filename is NULL) is
316 #ifndef SOLIB_CREATE_CATCH_UNLOAD_HOOK
317 #define SOLIB_CREATE_CATCH_UNLOAD_HOOK(pid,tempflag,filename,cond_string) \
318 error ("catch of library unloads not yet implemented on this platform")
321 /* Set breakpoint count to NUM. */
324 set_breakpoint_count (int num
)
326 breakpoint_count
= num
;
327 set_internalvar (lookup_internalvar ("bpnum"),
328 value_from_longest (builtin_type_int
, (LONGEST
) num
));
331 /* Used in run_command to zero the hit count when a new run starts. */
334 clear_breakpoint_hit_counts (void)
336 struct breakpoint
*b
;
342 /* Default address, symtab and line to put a breakpoint at
343 for "break" command with no arg.
344 if default_breakpoint_valid is zero, the other three are
345 not valid, and "break" with no arg is an error.
347 This set by print_stack_frame, which calls set_default_breakpoint. */
349 int default_breakpoint_valid
;
350 CORE_ADDR default_breakpoint_address
;
351 struct symtab
*default_breakpoint_symtab
;
352 int default_breakpoint_line
;
354 /* *PP is a string denoting a breakpoint. Get the number of the breakpoint.
355 Advance *PP after the string and any trailing whitespace.
357 Currently the string can either be a number or "$" followed by the name
358 of a convenience variable. Making it an expression wouldn't work well
359 for map_breakpoint_numbers (e.g. "4 + 5 + 6").
361 TRAILER is a character which can be found after the number; most
362 commonly this is `-'. If you don't want a trailer, use \0. */
364 get_number_trailer (char **pp
, int trailer
)
366 int retval
= 0; /* default */
370 /* Empty line means refer to the last breakpoint. */
371 return breakpoint_count
;
374 /* Make a copy of the name, so we can null-terminate it
375 to pass to lookup_internalvar(). */
380 while (isalnum (*p
) || *p
== '_')
382 varname
= (char *) alloca (p
- start
+ 1);
383 strncpy (varname
, start
, p
- start
);
384 varname
[p
- start
] = '\0';
385 val
= value_of_internalvar (lookup_internalvar (varname
));
386 if (TYPE_CODE (VALUE_TYPE (val
)) == TYPE_CODE_INT
)
387 retval
= (int) value_as_long (val
);
390 printf_filtered ("Convenience variable must have integer value.\n");
398 while (*p
>= '0' && *p
<= '9')
401 /* There is no number here. (e.g. "cond a == b"). */
403 /* Skip non-numeric token */
404 while (*p
&& !isspace((int) *p
))
406 /* Return zero, which caller must interpret as error. */
412 if (!(isspace (*p
) || *p
== '\0' || *p
== trailer
))
414 /* Trailing junk: return 0 and let caller print error msg. */
415 while (!(isspace (*p
) || *p
== '\0' || *p
== trailer
))
426 /* Like get_number_trailer, but don't allow a trailer. */
428 get_number (char **pp
)
430 return get_number_trailer (pp
, '\0');
433 /* Parse a number or a range.
434 * A number will be of the form handled by get_number.
435 * A range will be of the form <number1> - <number2>, and
436 * will represent all the integers between number1 and number2,
439 * While processing a range, this fuction is called iteratively;
440 * At each call it will return the next value in the range.
442 * At the beginning of parsing a range, the char pointer PP will
443 * be advanced past <number1> and left pointing at the '-' token.
444 * Subsequent calls will not advance the pointer until the range
445 * is completed. The call that completes the range will advance
446 * pointer PP past <number2>.
450 get_number_or_range (char **pp
)
452 static int last_retval
, end_value
;
453 static char *end_ptr
;
454 static int in_range
= 0;
458 /* Default case: pp is pointing either to a solo number,
459 or to the first number of a range. */
460 last_retval
= get_number_trailer (pp
, '-');
465 /* This is the start of a range (<number1> - <number2>).
466 Skip the '-', parse and remember the second number,
467 and also remember the end of the final token. */
471 while (isspace ((int) *end_ptr
))
472 end_ptr
++; /* skip white space */
473 end_value
= get_number (temp
);
474 if (end_value
< last_retval
)
476 error ("inverted range");
478 else if (end_value
== last_retval
)
480 /* degenerate range (number1 == number2). Advance the
481 token pointer so that the range will be treated as a
490 error ("negative value");
493 /* pp points to the '-' that betokens a range. All
494 number-parsing has already been done. Return the next
495 integer value (one greater than the saved previous value).
496 Do not advance the token pointer 'pp' until the end of range
499 if (++last_retval
== end_value
)
501 /* End of range reached; advance token pointer. */
511 /* condition N EXP -- set break condition of breakpoint N to EXP. */
514 condition_command (char *arg
, int from_tty
)
516 register struct breakpoint
*b
;
521 error_no_arg ("breakpoint number");
524 bnum
= get_number (&p
);
526 error ("Bad breakpoint argument: '%s'", arg
);
529 if (b
->number
== bnum
)
536 if (b
->cond_string
!= NULL
)
537 xfree (b
->cond_string
);
542 b
->cond_string
= NULL
;
544 printf_filtered ("Breakpoint %d now unconditional.\n", bnum
);
549 /* I don't know if it matters whether this is the string the user
550 typed in or the decompiled expression. */
551 b
->cond_string
= savestring (arg
, strlen (arg
));
552 b
->cond
= parse_exp_1 (&arg
, block_for_pc (b
->address
), 0);
554 error ("Junk at end of expression");
556 breakpoints_changed ();
560 error ("No breakpoint number %d.", bnum
);
565 commands_command (char *arg
, int from_tty
)
567 register struct breakpoint
*b
;
570 struct command_line
*l
;
572 /* If we allowed this, we would have problems with when to
573 free the storage, if we change the commands currently
576 if (executing_breakpoint_commands
)
577 error ("Can't use the \"commands\" command among a breakpoint's commands.");
580 bnum
= get_number (&p
);
583 error ("Unexpected extra arguments following breakpoint number.");
586 if (b
->number
== bnum
)
590 "Type commands for when breakpoint %d is hit, one per line.",
592 l
= read_command_lines (tmpbuf
, from_tty
);
593 free_command_lines (&b
->commands
);
595 breakpoints_changed ();
598 error ("No breakpoint number %d.", bnum
);
601 /* Like target_read_memory() but if breakpoints are inserted, return
602 the shadow contents instead of the breakpoints themselves.
604 Read "memory data" from whatever target or inferior we have.
605 Returns zero if successful, errno value if not. EIO is used
606 for address out of bounds. If breakpoints are inserted, returns
607 shadow contents, not the breakpoints themselves. From breakpoint.c. */
610 read_memory_nobpt (CORE_ADDR memaddr
, char *myaddr
, unsigned len
)
613 struct breakpoint
*b
;
614 CORE_ADDR bp_addr
= 0;
617 if (BREAKPOINT_FROM_PC (&bp_addr
, &bp_size
) == NULL
)
618 /* No breakpoints on this machine. */
619 return target_read_memory (memaddr
, myaddr
, len
);
623 if (b
->type
== bp_none
)
624 warning ("reading through apparently deleted breakpoint #%d?",
627 /* memory breakpoint? */
628 if (b
->type
== bp_watchpoint
629 || b
->type
== bp_hardware_watchpoint
630 || b
->type
== bp_read_watchpoint
631 || b
->type
== bp_access_watchpoint
)
636 /* Addresses and length of the part of the breakpoint that
638 /* XXXX The m68k, sh and h8300 have different local and remote
639 breakpoint values. BREAKPOINT_FROM_PC still manages to
640 correctly determine the breakpoints memory address and size
641 for these targets. */
642 bp_addr
= b
->address
;
644 if (BREAKPOINT_FROM_PC (&bp_addr
, &bp_size
) == NULL
)
649 if (bp_addr
+ bp_size
<= memaddr
)
650 /* The breakpoint is entirely before the chunk of memory we
653 if (bp_addr
>= memaddr
+ len
)
654 /* The breakpoint is entirely after the chunk of memory we are
657 /* Copy the breakpoint from the shadow contents, and recurse for
658 the things before and after. */
660 /* Offset within shadow_contents. */
663 if (bp_addr
< memaddr
)
665 /* Only copy the second part of the breakpoint. */
666 bp_size
-= memaddr
- bp_addr
;
667 bptoffset
= memaddr
- bp_addr
;
671 if (bp_addr
+ bp_size
> memaddr
+ len
)
673 /* Only copy the first part of the breakpoint. */
674 bp_size
-= (bp_addr
+ bp_size
) - (memaddr
+ len
);
677 memcpy (myaddr
+ bp_addr
- memaddr
,
678 b
->shadow_contents
+ bptoffset
, bp_size
);
680 if (bp_addr
> memaddr
)
682 /* Copy the section of memory before the breakpoint. */
683 status
= read_memory_nobpt (memaddr
, myaddr
, bp_addr
- memaddr
);
688 if (bp_addr
+ bp_size
< memaddr
+ len
)
690 /* Copy the section of memory after the breakpoint. */
691 status
= read_memory_nobpt (bp_addr
+ bp_size
,
692 myaddr
+ bp_addr
+ bp_size
- memaddr
,
693 memaddr
+ len
- (bp_addr
+ bp_size
));
700 /* Nothing overlaps. Just call read_memory_noerr. */
701 return target_read_memory (memaddr
, myaddr
, len
);
705 /* insert_breakpoints is used when starting or continuing the program.
706 remove_breakpoints is used when the program stops.
707 Both return zero if successful,
708 or an `errno' value if could not write the inferior. */
711 insert_breakpoints (void)
713 register struct breakpoint
*b
, *temp
;
714 int return_val
= 0; /* return success code. */
716 int disabled_breaks
= 0;
718 static char message1
[] = "Error inserting catchpoint %d:\n";
719 static char message
[sizeof (message1
) + 30];
722 ALL_BREAKPOINTS_SAFE (b
, temp
)
724 if (b
->enable
== permanent
)
725 /* Permanent breakpoints cannot be inserted or removed. */
727 else if (b
->type
!= bp_watchpoint
728 && b
->type
!= bp_hardware_watchpoint
729 && b
->type
!= bp_read_watchpoint
730 && b
->type
!= bp_access_watchpoint
731 && b
->type
!= bp_catch_fork
732 && b
->type
!= bp_catch_vfork
733 && b
->type
!= bp_catch_exec
734 && b
->type
!= bp_catch_throw
735 && b
->type
!= bp_catch_catch
736 && b
->enable
!= disabled
737 && b
->enable
!= shlib_disabled
738 && b
->enable
!= call_disabled
742 if (b
->type
== bp_hardware_breakpoint
)
743 val
= target_insert_hw_breakpoint (b
->address
, b
->shadow_contents
);
746 /* Check to see if breakpoint is in an overlay section;
747 if so, we should set the breakpoint at the LMA address.
748 Only if the section is currently mapped should we ALSO
749 set a break at the VMA address. */
750 if (overlay_debugging
&& b
->section
&&
751 section_is_overlay (b
->section
))
755 addr
= overlay_unmapped_address (b
->address
, b
->section
);
756 val
= target_insert_breakpoint (addr
, b
->shadow_contents
);
757 /* This would be the time to check val, to see if the
758 breakpoint write to the load address succeeded.
759 However, this might be an ordinary occurrance, eg. if
760 the unmapped overlay is in ROM. */
761 val
= 0; /* in case unmapped address failed */
762 if (section_is_mapped (b
->section
))
763 val
= target_insert_breakpoint (b
->address
,
766 else /* ordinary (non-overlay) address */
767 val
= target_insert_breakpoint (b
->address
, b
->shadow_contents
);
771 /* Can't set the breakpoint. */
772 #if defined (DISABLE_UNSETTABLE_BREAK)
773 if (DISABLE_UNSETTABLE_BREAK (b
->address
))
775 /* See also: disable_breakpoints_in_shlibs. */
777 b
->enable
= shlib_disabled
;
778 if (!disabled_breaks
)
780 target_terminal_ours_for_output ();
781 warning ("Cannot insert breakpoint %d:", b
->number
);
782 warning ("Temporarily disabling shared library breakpoints:");
785 warning ("breakpoint #%d ", b
->number
);
790 target_terminal_ours_for_output ();
791 warning ("Cannot insert breakpoint %d:", b
->number
);
792 #ifdef ONE_PROCESS_WRITETEXT
793 warning ("The same program may be running in another process.");
795 memory_error (val
, b
->address
); /* which bombs us out */
802 return_val
= val
; /* remember failure */
804 else if (ep_is_exception_catchpoint (b
)
805 && b
->enable
!= disabled
806 && b
->enable
!= shlib_disabled
807 && b
->enable
!= call_disabled
812 /* If we get here, we must have a callback mechanism for exception
813 events -- with g++ style embedded label support, we insert
814 ordinary breakpoints and not catchpoints. */
815 /* Format possible error message */
816 sprintf (message
, message1
, b
->number
);
818 val
= target_insert_breakpoint (b
->address
, b
->shadow_contents
);
821 /* Couldn't set breakpoint for some reason */
822 target_terminal_ours_for_output ();
823 warning ("Cannot insert catchpoint %d; disabling it.",
825 b
->enable
= disabled
;
829 /* Bp set, now make sure callbacks are enabled */
831 args_for_catchpoint_enable args
;
832 args
.kind
= b
->type
== bp_catch_catch
?
833 EX_EVENT_CATCH
: EX_EVENT_THROW
;
835 val
= catch_errors (cover_target_enable_exception_callback
,
837 message
, RETURN_MASK_ALL
);
838 if (val
!= 0 && val
!= -1)
842 /* Check if something went wrong; val == 0 can be ignored */
845 /* something went wrong */
846 target_terminal_ours_for_output ();
847 warning ("Cannot insert catchpoint %d; disabling it.",
849 b
->enable
= disabled
;
854 return_val
= val
; /* remember failure */
857 else if ((b
->type
== bp_hardware_watchpoint
||
858 b
->type
== bp_read_watchpoint
||
859 b
->type
== bp_access_watchpoint
)
860 && b
->enable
== enabled
861 && b
->disposition
!= del_at_next_stop
865 struct frame_info
*saved_frame
;
866 int saved_level
, within_current_scope
;
867 value_ptr mark
= value_mark ();
870 /* Save the current frame and level so we can restore it after
871 evaluating the watchpoint expression on its own frame. */
872 saved_frame
= selected_frame
;
873 saved_level
= selected_frame_level
;
875 /* Determine if the watchpoint is within scope. */
876 if (b
->exp_valid_block
== NULL
)
877 within_current_scope
= 1;
880 struct frame_info
*fi
;
882 /* There might be no current frame at this moment if we are
883 resuming from a step over a breakpoint.
884 Set up current frame before trying to find the watchpoint
886 get_current_frame ();
887 fi
= find_frame_addr_in_frame_chain (b
->watchpoint_frame
);
888 within_current_scope
= (fi
!= NULL
);
889 if (within_current_scope
)
890 select_frame (fi
, -1);
893 if (within_current_scope
)
895 /* Evaluate the expression and cut the chain of values
896 produced off from the value chain.
898 Make sure the value returned isn't lazy; we use
899 laziness to determine what memory GDB actually needed
900 in order to compute the value of the expression. */
901 v
= evaluate_expression (b
->exp
);
903 value_release_to_mark (mark
);
908 /* Look at each value on the value chain. */
909 for (; v
; v
= v
->next
)
911 /* If it's a memory location, and GDB actually needed
912 its contents to evaluate the expression, then we
914 if (VALUE_LVAL (v
) == lval_memory
917 struct type
*vtype
= check_typedef (VALUE_TYPE (v
));
919 /* We only watch structs and arrays if user asked
920 for it explicitly, never if they just happen to
921 appear in the middle of some value chain. */
922 if (v
== b
->val_chain
923 || (TYPE_CODE (vtype
) != TYPE_CODE_STRUCT
924 && TYPE_CODE (vtype
) != TYPE_CODE_ARRAY
))
929 addr
= VALUE_ADDRESS (v
) + VALUE_OFFSET (v
);
930 len
= TYPE_LENGTH (VALUE_TYPE (v
));
932 if (b
->type
== bp_read_watchpoint
)
934 else if (b
->type
== bp_access_watchpoint
)
937 val
= target_insert_watchpoint (addr
, len
, type
);
940 /* Don't exit the loop, try to insert
941 every value on the value chain. That's
942 because we will be removing all the
943 watches below, and removing a
944 watchpoint we didn't insert could have
952 /* Failure to insert a watchpoint on any memory value in the
953 value chain brings us here. */
956 remove_breakpoint (b
, mark_uninserted
);
957 warning ("Could not insert hardware watchpoint %d.",
964 printf_filtered ("Hardware watchpoint %d deleted ", b
->number
);
965 printf_filtered ("because the program has left the block \n");
966 printf_filtered ("in which its expression is valid.\n");
967 if (b
->related_breakpoint
)
968 b
->related_breakpoint
->disposition
= del_at_next_stop
;
969 b
->disposition
= del_at_next_stop
;
972 /* Restore the frame and level. */
973 if ((saved_frame
!= selected_frame
) ||
974 (saved_level
!= selected_frame_level
))
975 select_frame (saved_frame
, saved_level
);
978 return_val
= val
; /* remember failure */
980 else if ((b
->type
== bp_catch_fork
981 || b
->type
== bp_catch_vfork
982 || b
->type
== bp_catch_exec
)
983 && b
->enable
== enabled
991 val
= target_insert_fork_catchpoint (PIDGET (inferior_ptid
));
994 val
= target_insert_vfork_catchpoint (PIDGET (inferior_ptid
));
997 val
= target_insert_exec_catchpoint (PIDGET (inferior_ptid
));
1000 warning ("Internal error, %s line %d.", __FILE__
, __LINE__
);
1005 target_terminal_ours_for_output ();
1006 warning ("Cannot insert catchpoint %d.", b
->number
);
1012 return_val
= val
; /* remember failure */
1021 remove_breakpoints (void)
1023 register struct breakpoint
*b
;
1030 val
= remove_breakpoint (b
, mark_uninserted
);
1039 remove_hw_watchpoints (void)
1041 register struct breakpoint
*b
;
1047 && (b
->type
== bp_hardware_watchpoint
1048 || b
->type
== bp_read_watchpoint
1049 || b
->type
== bp_access_watchpoint
))
1051 val
= remove_breakpoint (b
, mark_uninserted
);
1060 reattach_breakpoints (int pid
)
1062 register struct breakpoint
*b
;
1064 struct cleanup
*old_chain
= save_inferior_ptid ();
1066 /* Set inferior_ptid; remove_breakpoint uses this global. */
1067 inferior_ptid
= pid_to_ptid (pid
);
1072 remove_breakpoint (b
, mark_inserted
);
1073 if (b
->type
== bp_hardware_breakpoint
)
1074 val
= target_insert_hw_breakpoint (b
->address
, b
->shadow_contents
);
1076 val
= target_insert_breakpoint (b
->address
, b
->shadow_contents
);
1079 do_cleanups (old_chain
);
1084 do_cleanups (old_chain
);
1089 update_breakpoints_after_exec (void)
1091 struct breakpoint
*b
;
1092 struct breakpoint
*temp
;
1094 /* Doing this first prevents the badness of having delete_breakpoint()
1095 write a breakpoint's current "shadow contents" to lift the bp. That
1096 shadow is NOT valid after an exec()! */
1097 mark_breakpoints_out ();
1099 ALL_BREAKPOINTS_SAFE (b
, temp
)
1101 /* Solib breakpoints must be explicitly reset after an exec(). */
1102 if (b
->type
== bp_shlib_event
)
1104 delete_breakpoint (b
);
1108 /* Thread event breakpoints must be set anew after an exec(). */
1109 if (b
->type
== bp_thread_event
)
1111 delete_breakpoint (b
);
1115 /* Step-resume breakpoints are meaningless after an exec(). */
1116 if (b
->type
== bp_step_resume
)
1118 delete_breakpoint (b
);
1122 /* Ditto the sigtramp handler breakpoints. */
1123 if (b
->type
== bp_through_sigtramp
)
1125 delete_breakpoint (b
);
1129 /* Ditto the exception-handling catchpoints. */
1130 if ((b
->type
== bp_catch_catch
) || (b
->type
== bp_catch_throw
))
1132 delete_breakpoint (b
);
1136 /* Don't delete an exec catchpoint, because else the inferior
1137 won't stop when it ought!
1139 Similarly, we probably ought to keep vfork catchpoints, 'cause
1140 on this target, we may not be able to stop when the vfork is
1141 seen, but only when the subsequent exec is seen. (And because
1142 deleting fork catchpoints here but not vfork catchpoints will
1143 seem mysterious to users, keep those too.)
1145 ??rehrauer: Let's hope that merely clearing out this catchpoint's
1146 target address field, if any, is sufficient to have it be reset
1147 automagically. Certainly on HP-UX that's true.
1149 Jim Blandy <jimb@redhat.com>: Actually, zero is a perfectly
1150 valid code address on some platforms (like the mn10200 and
1151 mn10300 simulators). We shouldn't assign any special
1152 interpretation to a breakpoint with a zero address. And in
1153 fact, GDB doesn't --- I can't see what that comment above is
1154 talking about. As far as I can tell, setting the address of a
1155 bp_catch_exec/bp_catch_vfork/bp_catch_fork breakpoint to zero
1156 is meaningless, since those are implemented with HP-UX kernel
1157 hackery, not by storing breakpoint instructions somewhere. */
1158 if ((b
->type
== bp_catch_exec
) ||
1159 (b
->type
== bp_catch_vfork
) ||
1160 (b
->type
== bp_catch_fork
))
1162 b
->address
= (CORE_ADDR
) NULL
;
1166 /* bp_finish is a special case. The only way we ought to be able
1167 to see one of these when an exec() has happened, is if the user
1168 caught a vfork, and then said "finish". Ordinarily a finish just
1169 carries them to the call-site of the current callee, by setting
1170 a temporary bp there and resuming. But in this case, the finish
1171 will carry them entirely through the vfork & exec.
1173 We don't want to allow a bp_finish to remain inserted now. But
1174 we can't safely delete it, 'cause finish_command has a handle to
1175 the bp on a bpstat, and will later want to delete it. There's a
1176 chance (and I've seen it happen) that if we delete the bp_finish
1177 here, that its storage will get reused by the time finish_command
1178 gets 'round to deleting the "use to be a bp_finish" breakpoint.
1179 We really must allow finish_command to delete a bp_finish.
1181 In the absense of a general solution for the "how do we know
1182 it's safe to delete something others may have handles to?"
1183 problem, what we'll do here is just uninsert the bp_finish, and
1184 let finish_command delete it.
1186 (We know the bp_finish is "doomed" in the sense that it's
1187 momentary, and will be deleted as soon as finish_command sees
1188 the inferior stopped. So it doesn't matter that the bp's
1189 address is probably bogus in the new a.out, unlike e.g., the
1190 solib breakpoints.) */
1192 if (b
->type
== bp_finish
)
1197 /* Without a symbolic address, we have little hope of the
1198 pre-exec() address meaning the same thing in the post-exec()
1200 if (b
->addr_string
== NULL
)
1202 delete_breakpoint (b
);
1206 /* If this breakpoint has survived the above battery of checks, then
1207 it must have a symbolic address. Be sure that it gets reevaluated
1208 to a target address, rather than reusing the old evaluation.
1210 Jim Blandy <jimb@redhat.com>: As explained above in the comment
1211 for bp_catch_exec and friends, I'm pretty sure this is entirely
1212 unnecessary. A call to breakpoint_re_set_one always recomputes
1213 the breakpoint's address from scratch, or deletes it if it can't.
1214 So I think this assignment could be deleted without effect. */
1215 b
->address
= (CORE_ADDR
) NULL
;
1220 detach_breakpoints (int pid
)
1222 register struct breakpoint
*b
;
1224 struct cleanup
*old_chain
= save_inferior_ptid ();
1226 if (pid
== PIDGET (inferior_ptid
))
1227 error ("Cannot detach breakpoints of inferior_ptid");
1229 /* Set inferior_ptid; remove_breakpoint uses this global. */
1230 inferior_ptid
= pid_to_ptid (pid
);
1235 val
= remove_breakpoint (b
, mark_inserted
);
1238 do_cleanups (old_chain
);
1243 do_cleanups (old_chain
);
1248 remove_breakpoint (struct breakpoint
*b
, insertion_state_t is
)
1252 if (b
->enable
== permanent
)
1253 /* Permanent breakpoints cannot be inserted or removed. */
1256 if (b
->type
== bp_none
)
1257 warning ("attempted to remove apparently deleted breakpoint #%d?",
1260 if (b
->type
!= bp_watchpoint
1261 && b
->type
!= bp_hardware_watchpoint
1262 && b
->type
!= bp_read_watchpoint
1263 && b
->type
!= bp_access_watchpoint
1264 && b
->type
!= bp_catch_fork
1265 && b
->type
!= bp_catch_vfork
1266 && b
->type
!= bp_catch_exec
1267 && b
->type
!= bp_catch_catch
1268 && b
->type
!= bp_catch_throw
)
1270 if (b
->type
== bp_hardware_breakpoint
)
1271 val
= target_remove_hw_breakpoint (b
->address
, b
->shadow_contents
);
1274 /* Check to see if breakpoint is in an overlay section;
1275 if so, we should remove the breakpoint at the LMA address.
1276 If that is not equal to the raw address, then we should
1277 presumably remove the breakpoint there as well. */
1278 if (overlay_debugging
&& b
->section
&&
1279 section_is_overlay (b
->section
))
1283 addr
= overlay_unmapped_address (b
->address
, b
->section
);
1284 val
= target_remove_breakpoint (addr
, b
->shadow_contents
);
1285 /* This would be the time to check val, to see if the
1286 shadow breakpoint write to the load address succeeded.
1287 However, this might be an ordinary occurrance, eg. if
1288 the unmapped overlay is in ROM. */
1289 val
= 0; /* in case unmapped address failed */
1290 if (section_is_mapped (b
->section
))
1291 val
= target_remove_breakpoint (b
->address
,
1292 b
->shadow_contents
);
1294 else /* ordinary (non-overlay) address */
1295 val
= target_remove_breakpoint (b
->address
, b
->shadow_contents
);
1299 b
->inserted
= (is
== mark_inserted
);
1301 else if ((b
->type
== bp_hardware_watchpoint
||
1302 b
->type
== bp_read_watchpoint
||
1303 b
->type
== bp_access_watchpoint
)
1304 && b
->enable
== enabled
1309 b
->inserted
= (is
== mark_inserted
);
1310 /* Walk down the saved value chain. */
1311 for (v
= b
->val_chain
; v
; v
= v
->next
)
1313 /* For each memory reference remove the watchpoint
1315 if (VALUE_LVAL (v
) == lval_memory
1316 && ! VALUE_LAZY (v
))
1318 struct type
*vtype
= check_typedef (VALUE_TYPE (v
));
1320 if (v
== b
->val_chain
1321 || (TYPE_CODE (vtype
) != TYPE_CODE_STRUCT
1322 && TYPE_CODE (vtype
) != TYPE_CODE_ARRAY
))
1327 addr
= VALUE_ADDRESS (v
) + VALUE_OFFSET (v
);
1328 len
= TYPE_LENGTH (VALUE_TYPE (v
));
1330 if (b
->type
== bp_read_watchpoint
)
1332 else if (b
->type
== bp_access_watchpoint
)
1335 val
= target_remove_watchpoint (addr
, len
, type
);
1342 /* Failure to remove any of the hardware watchpoints comes here. */
1343 if ((is
== mark_uninserted
) && (b
->inserted
))
1344 warning ("Could not remove hardware watchpoint %d.",
1347 /* Free the saved value chain. We will construct a new one
1348 the next time the watchpoint is inserted. */
1349 for (v
= b
->val_chain
; v
; v
= n
)
1354 b
->val_chain
= NULL
;
1356 else if ((b
->type
== bp_catch_fork
||
1357 b
->type
== bp_catch_vfork
||
1358 b
->type
== bp_catch_exec
)
1359 && b
->enable
== enabled
1366 val
= target_remove_fork_catchpoint (PIDGET (inferior_ptid
));
1368 case bp_catch_vfork
:
1369 val
= target_remove_vfork_catchpoint (PIDGET (inferior_ptid
));
1372 val
= target_remove_exec_catchpoint (PIDGET (inferior_ptid
));
1375 warning ("Internal error, %s line %d.", __FILE__
, __LINE__
);
1380 b
->inserted
= (is
== mark_inserted
);
1382 else if ((b
->type
== bp_catch_catch
||
1383 b
->type
== bp_catch_throw
)
1384 && b
->enable
== enabled
1388 val
= target_remove_breakpoint (b
->address
, b
->shadow_contents
);
1391 b
->inserted
= (is
== mark_inserted
);
1393 else if (ep_is_exception_catchpoint (b
)
1394 && b
->inserted
/* sometimes previous insert doesn't happen */
1395 && b
->enable
== enabled
1399 val
= target_remove_breakpoint (b
->address
, b
->shadow_contents
);
1403 b
->inserted
= (is
== mark_inserted
);
1409 /* Clear the "inserted" flag in all breakpoints. */
1412 mark_breakpoints_out (void)
1414 register struct breakpoint
*b
;
1420 /* Clear the "inserted" flag in all breakpoints and delete any
1421 breakpoints which should go away between runs of the program.
1423 Plus other such housekeeping that has to be done for breakpoints
1426 Note: this function gets called at the end of a run (by
1427 generic_mourn_inferior) and when a run begins (by
1428 init_wait_for_inferior). */
1433 breakpoint_init_inferior (enum inf_context context
)
1435 register struct breakpoint
*b
, *temp
;
1436 static int warning_needed
= 0;
1438 ALL_BREAKPOINTS_SAFE (b
, temp
)
1445 case bp_watchpoint_scope
:
1447 /* If the call dummy breakpoint is at the entry point it will
1448 cause problems when the inferior is rerun, so we better
1451 Also get rid of scope breakpoints. */
1452 delete_breakpoint (b
);
1456 case bp_hardware_watchpoint
:
1457 case bp_read_watchpoint
:
1458 case bp_access_watchpoint
:
1460 /* Likewise for watchpoints on local expressions. */
1461 if (b
->exp_valid_block
!= NULL
)
1462 delete_breakpoint (b
);
1465 /* Likewise for exception catchpoints in dynamic-linked
1466 executables where required */
1467 if (ep_is_exception_catchpoint (b
) &&
1468 exception_catchpoints_are_fragile
)
1471 delete_breakpoint (b
);
1477 if (exception_catchpoints_are_fragile
)
1478 exception_support_initialized
= 0;
1480 /* Don't issue the warning unless it's really needed... */
1481 if (warning_needed
&& (context
!= inf_exited
))
1483 warning ("Exception catchpoints from last run were deleted.");
1484 warning ("You must reinsert them explicitly.");
1489 /* breakpoint_here_p (PC) returns non-zero if an enabled breakpoint
1490 exists at PC. It returns ordinary_breakpoint_here if it's an
1491 ordinary breakpoint, or permanent_breakpoint_here if it's a
1492 permanent breakpoint.
1493 - When continuing from a location with an ordinary breakpoint, we
1494 actually single step once before calling insert_breakpoints.
1495 - When continuing from a localion with a permanent breakpoint, we
1496 need to use the `SKIP_PERMANENT_BREAKPOINT' macro, provided by
1497 the target, to advance the PC past the breakpoint. */
1499 enum breakpoint_here
1500 breakpoint_here_p (CORE_ADDR pc
)
1502 register struct breakpoint
*b
;
1503 int any_breakpoint_here
= 0;
1506 if ((b
->enable
== enabled
1507 || b
->enable
== permanent
)
1508 && b
->address
== pc
) /* bp is enabled and matches pc */
1510 if (overlay_debugging
&&
1511 section_is_overlay (b
->section
) &&
1512 !section_is_mapped (b
->section
))
1513 continue; /* unmapped overlay -- can't be a match */
1514 else if (b
->enable
== permanent
)
1515 return permanent_breakpoint_here
;
1517 any_breakpoint_here
= 1;
1520 return any_breakpoint_here
? ordinary_breakpoint_here
: 0;
1524 /* breakpoint_inserted_here_p (PC) is just like breakpoint_here_p(),
1525 but it only returns true if there is actually a breakpoint inserted
1529 breakpoint_inserted_here_p (CORE_ADDR pc
)
1531 register struct breakpoint
*b
;
1535 && b
->address
== pc
) /* bp is inserted and matches pc */
1537 if (overlay_debugging
&&
1538 section_is_overlay (b
->section
) &&
1539 !section_is_mapped (b
->section
))
1540 continue; /* unmapped overlay -- can't be a match */
1548 /* Return nonzero if FRAME is a dummy frame. We can't use
1549 PC_IN_CALL_DUMMY because figuring out the saved SP would take too
1550 much time, at least using get_saved_register on the 68k. This
1551 means that for this function to work right a port must use the
1552 bp_call_dummy breakpoint. */
1555 frame_in_dummy (struct frame_info
*frame
)
1557 struct breakpoint
*b
;
1562 if (USE_GENERIC_DUMMY_FRAMES
)
1563 return generic_pc_in_call_dummy (frame
->pc
, frame
->frame
, frame
->frame
);
1567 if (b
->type
== bp_call_dummy
1568 && b
->frame
== frame
->frame
1569 /* We need to check the PC as well as the frame on the sparc,
1570 for signals.exp in the testsuite. */
1573 - SIZEOF_CALL_DUMMY_WORDS
/ sizeof (LONGEST
) * REGISTER_SIZE
))
1574 && frame
->pc
<= b
->address
)
1580 /* breakpoint_thread_match (PC, PID) returns true if the breakpoint at
1581 PC is valid for process/thread PID. */
1584 breakpoint_thread_match (CORE_ADDR pc
, ptid_t ptid
)
1586 struct breakpoint
*b
;
1589 thread
= pid_to_thread_id (ptid
);
1592 if (b
->enable
!= disabled
1593 && b
->enable
!= shlib_disabled
1594 && b
->enable
!= call_disabled
1596 && (b
->thread
== -1 || b
->thread
== thread
))
1598 if (overlay_debugging
&&
1599 section_is_overlay (b
->section
) &&
1600 !section_is_mapped (b
->section
))
1601 continue; /* unmapped overlay -- can't be a match */
1610 /* bpstat stuff. External routines' interfaces are documented
1614 ep_is_catchpoint (struct breakpoint
*ep
)
1617 (ep
->type
== bp_catch_load
)
1618 || (ep
->type
== bp_catch_unload
)
1619 || (ep
->type
== bp_catch_fork
)
1620 || (ep
->type
== bp_catch_vfork
)
1621 || (ep
->type
== bp_catch_exec
)
1622 || (ep
->type
== bp_catch_catch
)
1623 || (ep
->type
== bp_catch_throw
);
1625 /* ??rehrauer: Add more kinds here, as are implemented... */
1629 ep_is_shlib_catchpoint (struct breakpoint
*ep
)
1632 (ep
->type
== bp_catch_load
)
1633 || (ep
->type
== bp_catch_unload
);
1637 ep_is_exception_catchpoint (struct breakpoint
*ep
)
1640 (ep
->type
== bp_catch_catch
)
1641 || (ep
->type
== bp_catch_throw
);
1644 /* Clear a bpstat so that it says we are not at any breakpoint.
1645 Also free any storage that is part of a bpstat. */
1648 bpstat_clear (bpstat
*bsp
)
1659 if (p
->old_val
!= NULL
)
1660 value_free (p
->old_val
);
1667 /* Return a copy of a bpstat. Like "bs1 = bs2" but all storage that
1668 is part of the bpstat is copied as well. */
1671 bpstat_copy (bpstat bs
)
1675 bpstat retval
= NULL
;
1680 for (; bs
!= NULL
; bs
= bs
->next
)
1682 tmp
= (bpstat
) xmalloc (sizeof (*tmp
));
1683 memcpy (tmp
, bs
, sizeof (*tmp
));
1685 /* This is the first thing in the chain. */
1695 /* Find the bpstat associated with this breakpoint */
1698 bpstat_find_breakpoint (bpstat bsp
, struct breakpoint
*breakpoint
)
1703 for (; bsp
!= NULL
; bsp
= bsp
->next
)
1705 if (bsp
->breakpoint_at
== breakpoint
)
1711 /* Find a step_resume breakpoint associated with this bpstat.
1712 (If there are multiple step_resume bp's on the list, this function
1713 will arbitrarily pick one.)
1715 It is an error to use this function if BPSTAT doesn't contain a
1716 step_resume breakpoint.
1718 See wait_for_inferior's use of this function. */
1720 bpstat_find_step_resume_breakpoint (bpstat bsp
)
1723 error ("Internal error (bpstat_find_step_resume_breakpoint)");
1725 for (; bsp
!= NULL
; bsp
= bsp
->next
)
1727 if ((bsp
->breakpoint_at
!= NULL
) &&
1728 (bsp
->breakpoint_at
->type
== bp_step_resume
))
1729 return bsp
->breakpoint_at
;
1732 error ("Internal error (no step_resume breakpoint found)");
1736 /* Return the breakpoint number of the first breakpoint we are stopped
1737 at. *BSP upon return is a bpstat which points to the remaining
1738 breakpoints stopped at (but which is not guaranteed to be good for
1739 anything but further calls to bpstat_num).
1740 Return 0 if passed a bpstat which does not indicate any breakpoints. */
1743 bpstat_num (bpstat
*bsp
)
1745 struct breakpoint
*b
;
1748 return 0; /* No more breakpoint values */
1751 b
= (*bsp
)->breakpoint_at
;
1752 *bsp
= (*bsp
)->next
;
1754 return -1; /* breakpoint that's been deleted since */
1756 return b
->number
; /* We have its number */
1760 /* Modify BS so that the actions will not be performed. */
1763 bpstat_clear_actions (bpstat bs
)
1765 for (; bs
!= NULL
; bs
= bs
->next
)
1767 bs
->commands
= NULL
;
1768 if (bs
->old_val
!= NULL
)
1770 value_free (bs
->old_val
);
1776 /* Stub for cleaning up our state if we error-out of a breakpoint command */
1779 cleanup_executing_breakpoints (PTR ignore
)
1781 executing_breakpoint_commands
= 0;
1784 /* Execute all the commands associated with all the breakpoints at this
1785 location. Any of these commands could cause the process to proceed
1786 beyond this point, etc. We look out for such changes by checking
1787 the global "breakpoint_proceeded" after each command. */
1790 bpstat_do_actions (bpstat
*bsp
)
1793 struct cleanup
*old_chain
;
1794 struct command_line
*cmd
;
1796 /* Avoid endless recursion if a `source' command is contained
1798 if (executing_breakpoint_commands
)
1801 executing_breakpoint_commands
= 1;
1802 old_chain
= make_cleanup (cleanup_executing_breakpoints
, 0);
1805 /* Note that (as of this writing), our callers all appear to
1806 be passing us the address of global stop_bpstat. And, if
1807 our calls to execute_control_command cause the inferior to
1808 proceed, that global (and hence, *bsp) will change.
1810 We must be careful to not touch *bsp unless the inferior
1811 has not proceeded. */
1813 /* This pointer will iterate over the list of bpstat's. */
1816 breakpoint_proceeded
= 0;
1817 for (; bs
!= NULL
; bs
= bs
->next
)
1822 execute_control_command (cmd
);
1824 if (breakpoint_proceeded
)
1829 if (breakpoint_proceeded
)
1830 /* The inferior is proceeded by the command; bomb out now.
1831 The bpstat chain has been blown away by wait_for_inferior.
1832 But since execution has stopped again, there is a new bpstat
1833 to look at, so start over. */
1836 bs
->commands
= NULL
;
1839 executing_breakpoint_commands
= 0;
1840 discard_cleanups (old_chain
);
1843 /* This is the normal print function for a bpstat. In the future,
1844 much of this logic could (should?) be moved to bpstat_stop_status,
1845 by having it set different print_it values.
1847 Current scheme: When we stop, bpstat_print() is called. It loops
1848 through the bpstat list of things causing this stop, calling the
1849 print_bp_stop_message function on each one. The behavior of the
1850 print_bp_stop_message function depends on the print_it field of
1851 bpstat. If such field so indicates, call this function here.
1853 Return values from this routine (ultimately used by bpstat_print()
1854 and normal_stop() to decide what to do):
1855 PRINT_NOTHING: Means we already printed all we needed to print,
1856 don't print anything else.
1857 PRINT_SRC_ONLY: Means we printed something, and we do *not* desire
1858 that something to be followed by a location.
1859 PRINT_SCR_AND_LOC: Means we printed something, and we *do* desire
1860 that something to be followed by a location.
1861 PRINT_UNKNOWN: Means we printed nothing or we need to do some more
1864 static enum print_stop_action
1865 print_it_typical (bpstat bs
)
1868 struct cleanup
*old_chain
;
1869 struct ui_stream
*stb
;
1870 stb
= ui_out_stream_new (uiout
);
1871 old_chain
= make_cleanup_ui_out_stream_delete (stb
);
1873 /* bs->breakpoint_at can be NULL if it was a momentary breakpoint
1874 which has since been deleted. */
1875 if (bs
->breakpoint_at
== NULL
)
1876 return PRINT_UNKNOWN
;
1878 switch (bs
->breakpoint_at
->type
)
1881 case bp_hardware_breakpoint
:
1883 annotate_breakpoint (bs
->breakpoint_at
->number
);
1884 ui_out_text (uiout
, "\nBreakpoint ");
1885 if (interpreter_p
&& strcmp (interpreter_p
, "mi") == 0)
1886 ui_out_field_string (uiout
, "reason", "breakpoint-hit");
1887 ui_out_field_int (uiout
, "bkptno", bs
->breakpoint_at
->number
);
1888 ui_out_text (uiout
, ", ");
1889 return PRINT_SRC_AND_LOC
;
1891 /* I think the user probably only wants to see one breakpoint
1892 number, not all of them. */
1893 annotate_breakpoint (bs
->breakpoint_at
->number
);
1894 printf_filtered ("\nBreakpoint %d, ", bs
->breakpoint_at
->number
);
1895 return PRINT_SRC_AND_LOC
;
1899 case bp_shlib_event
:
1900 /* Did we stop because the user set the stop_on_solib_events
1901 variable? (If so, we report this as a generic, "Stopped due
1902 to shlib event" message.) */
1903 printf_filtered ("Stopped due to shared library event\n");
1904 return PRINT_NOTHING
;
1907 case bp_thread_event
:
1908 /* Not sure how we will get here.
1909 GDB should not stop for these breakpoints. */
1910 printf_filtered ("Thread Event Breakpoint: gdb should not stop!\n");
1911 return PRINT_NOTHING
;
1915 annotate_catchpoint (bs
->breakpoint_at
->number
);
1916 printf_filtered ("\nCatchpoint %d (", bs
->breakpoint_at
->number
);
1917 printf_filtered ("loaded");
1918 printf_filtered (" %s), ", bs
->breakpoint_at
->triggered_dll_pathname
);
1919 return PRINT_SRC_AND_LOC
;
1922 case bp_catch_unload
:
1923 annotate_catchpoint (bs
->breakpoint_at
->number
);
1924 printf_filtered ("\nCatchpoint %d (", bs
->breakpoint_at
->number
);
1925 printf_filtered ("unloaded");
1926 printf_filtered (" %s), ", bs
->breakpoint_at
->triggered_dll_pathname
);
1927 return PRINT_SRC_AND_LOC
;
1931 annotate_catchpoint (bs
->breakpoint_at
->number
);
1932 printf_filtered ("\nCatchpoint %d (", bs
->breakpoint_at
->number
);
1933 printf_filtered ("forked");
1934 printf_filtered (" process %d), ",
1935 bs
->breakpoint_at
->forked_inferior_pid
);
1936 return PRINT_SRC_AND_LOC
;
1939 case bp_catch_vfork
:
1940 annotate_catchpoint (bs
->breakpoint_at
->number
);
1941 printf_filtered ("\nCatchpoint %d (", bs
->breakpoint_at
->number
);
1942 printf_filtered ("vforked");
1943 printf_filtered (" process %d), ",
1944 bs
->breakpoint_at
->forked_inferior_pid
);
1945 return PRINT_SRC_AND_LOC
;
1949 annotate_catchpoint (bs
->breakpoint_at
->number
);
1950 printf_filtered ("\nCatchpoint %d (exec'd %s), ",
1951 bs
->breakpoint_at
->number
,
1952 bs
->breakpoint_at
->exec_pathname
);
1953 return PRINT_SRC_AND_LOC
;
1956 case bp_catch_catch
:
1957 if (current_exception_event
&&
1958 (CURRENT_EXCEPTION_KIND
== EX_EVENT_CATCH
))
1960 annotate_catchpoint (bs
->breakpoint_at
->number
);
1961 printf_filtered ("\nCatchpoint %d (exception caught), ",
1962 bs
->breakpoint_at
->number
);
1963 printf_filtered ("throw location ");
1964 if (CURRENT_EXCEPTION_THROW_PC
&& CURRENT_EXCEPTION_THROW_LINE
)
1965 printf_filtered ("%s:%d",
1966 CURRENT_EXCEPTION_THROW_FILE
,
1967 CURRENT_EXCEPTION_THROW_LINE
);
1969 printf_filtered ("unknown");
1971 printf_filtered (", catch location ");
1972 if (CURRENT_EXCEPTION_CATCH_PC
&& CURRENT_EXCEPTION_CATCH_LINE
)
1973 printf_filtered ("%s:%d",
1974 CURRENT_EXCEPTION_CATCH_FILE
,
1975 CURRENT_EXCEPTION_CATCH_LINE
);
1977 printf_filtered ("unknown");
1979 printf_filtered ("\n");
1980 /* don't bother to print location frame info */
1981 return PRINT_SRC_ONLY
;
1985 /* really throw, some other bpstat will handle it */
1986 return PRINT_UNKNOWN
;
1990 case bp_catch_throw
:
1991 if (current_exception_event
&&
1992 (CURRENT_EXCEPTION_KIND
== EX_EVENT_THROW
))
1994 annotate_catchpoint (bs
->breakpoint_at
->number
);
1995 printf_filtered ("\nCatchpoint %d (exception thrown), ",
1996 bs
->breakpoint_at
->number
);
1997 printf_filtered ("throw location ");
1998 if (CURRENT_EXCEPTION_THROW_PC
&& CURRENT_EXCEPTION_THROW_LINE
)
1999 printf_filtered ("%s:%d",
2000 CURRENT_EXCEPTION_THROW_FILE
,
2001 CURRENT_EXCEPTION_THROW_LINE
);
2003 printf_filtered ("unknown");
2005 printf_filtered (", catch location ");
2006 if (CURRENT_EXCEPTION_CATCH_PC
&& CURRENT_EXCEPTION_CATCH_LINE
)
2007 printf_filtered ("%s:%d",
2008 CURRENT_EXCEPTION_CATCH_FILE
,
2009 CURRENT_EXCEPTION_CATCH_LINE
);
2011 printf_filtered ("unknown");
2013 printf_filtered ("\n");
2014 /* don't bother to print location frame info */
2015 return PRINT_SRC_ONLY
;
2019 /* really catch, some other bpstat will handle it */
2020 return PRINT_UNKNOWN
;
2025 case bp_hardware_watchpoint
:
2026 if (bs
->old_val
!= NULL
)
2028 annotate_watchpoint (bs
->breakpoint_at
->number
);
2030 if (interpreter_p
&& strcmp (interpreter_p
, "mi") == 0)
2031 ui_out_field_string (uiout
, "reason", "watchpoint-trigger");
2032 mention (bs
->breakpoint_at
);
2033 ui_out_tuple_begin (uiout
, "value");
2034 ui_out_text (uiout
, "\nOld value = ");
2035 value_print (bs
->old_val
, stb
->stream
, 0, Val_pretty_default
);
2036 ui_out_field_stream (uiout
, "old", stb
);
2037 ui_out_text (uiout
, "\nNew value = ");
2038 value_print (bs
->breakpoint_at
->val
, stb
->stream
, 0, Val_pretty_default
);
2039 ui_out_field_stream (uiout
, "new", stb
);
2040 ui_out_tuple_end (uiout
);
2041 ui_out_text (uiout
, "\n");
2043 mention (bs
->breakpoint_at
);
2044 printf_filtered ("\nOld value = ");
2045 value_print (bs
->old_val
, gdb_stdout
, 0, Val_pretty_default
);
2046 printf_filtered ("\nNew value = ");
2047 value_print (bs
->breakpoint_at
->val
, gdb_stdout
, 0,
2048 Val_pretty_default
);
2049 printf_filtered ("\n");
2051 value_free (bs
->old_val
);
2054 /* More than one watchpoint may have been triggered. */
2055 return PRINT_UNKNOWN
;
2058 case bp_read_watchpoint
:
2060 if (interpreter_p
&& strcmp (interpreter_p
, "mi") == 0)
2061 ui_out_field_string (uiout
, "reason", "read-watchpoint-trigger");
2062 mention (bs
->breakpoint_at
);
2063 ui_out_tuple_begin (uiout
, "value");
2064 ui_out_text (uiout
, "\nValue = ");
2065 value_print (bs
->breakpoint_at
->val
, stb
->stream
, 0, Val_pretty_default
);
2066 ui_out_field_stream (uiout
, "value", stb
);
2067 ui_out_tuple_end (uiout
);
2068 ui_out_text (uiout
, "\n");
2070 mention (bs
->breakpoint_at
);
2071 printf_filtered ("\nValue = ");
2072 value_print (bs
->breakpoint_at
->val
, gdb_stdout
, 0,
2073 Val_pretty_default
);
2074 printf_filtered ("\n");
2076 return PRINT_UNKNOWN
;
2079 case bp_access_watchpoint
:
2081 if (bs
->old_val
!= NULL
)
2083 annotate_watchpoint (bs
->breakpoint_at
->number
);
2084 if (interpreter_p
&& strcmp (interpreter_p
, "mi") == 0)
2085 ui_out_field_string (uiout
, "reason", "access-watchpoint-trigger");
2086 mention (bs
->breakpoint_at
);
2087 ui_out_tuple_begin (uiout
, "value");
2088 ui_out_text (uiout
, "\nOld value = ");
2089 value_print (bs
->old_val
, stb
->stream
, 0, Val_pretty_default
);
2090 ui_out_field_stream (uiout
, "old", stb
);
2091 value_free (bs
->old_val
);
2093 ui_out_text (uiout
, "\nNew value = ");
2097 mention (bs
->breakpoint_at
);
2098 if (interpreter_p
&& strcmp (interpreter_p
, "mi") == 0)
2099 ui_out_field_string (uiout
, "reason", "access-watchpoint-trigger");
2100 ui_out_tuple_begin (uiout
, "value");
2101 ui_out_text (uiout
, "\nValue = ");
2103 value_print (bs
->breakpoint_at
->val
, stb
->stream
, 0,Val_pretty_default
);
2104 ui_out_field_stream (uiout
, "new", stb
);
2105 ui_out_tuple_end (uiout
);
2106 ui_out_text (uiout
, "\n");
2108 if (bs
->old_val
!= NULL
)
2110 annotate_watchpoint (bs
->breakpoint_at
->number
);
2111 mention (bs
->breakpoint_at
);
2112 printf_filtered ("\nOld value = ");
2113 value_print (bs
->old_val
, gdb_stdout
, 0, Val_pretty_default
);
2114 value_free (bs
->old_val
);
2116 printf_filtered ("\nNew value = ");
2120 mention (bs
->breakpoint_at
);
2121 printf_filtered ("\nValue = ");
2123 value_print (bs
->breakpoint_at
->val
, gdb_stdout
, 0,
2124 Val_pretty_default
);
2125 printf_filtered ("\n");
2127 return PRINT_UNKNOWN
;
2130 /* Fall through, we don't deal with these types of breakpoints
2135 if (interpreter_p
&& strcmp (interpreter_p
, "mi") == 0)
2136 ui_out_field_string (uiout
, "reason", "function-finished");
2138 return PRINT_UNKNOWN
;
2143 if (interpreter_p
&& strcmp (interpreter_p
, "mi") == 0)
2144 ui_out_field_string (uiout
, "reason", "location-reached");
2146 return PRINT_UNKNOWN
;
2151 case bp_longjmp_resume
:
2152 case bp_step_resume
:
2153 case bp_through_sigtramp
:
2154 case bp_watchpoint_scope
:
2157 return PRINT_UNKNOWN
;
2161 /* Generic routine for printing messages indicating why we
2162 stopped. The behavior of this function depends on the value
2163 'print_it' in the bpstat structure. Under some circumstances we
2164 may decide not to print anything here and delegate the task to
2167 static enum print_stop_action
2168 print_bp_stop_message (bpstat bs
)
2170 switch (bs
->print_it
)
2173 /* Nothing should be printed for this bpstat entry. */
2174 return PRINT_UNKNOWN
;
2178 /* We still want to print the frame, but we already printed the
2179 relevant messages. */
2180 return PRINT_SRC_AND_LOC
;
2183 case print_it_normal
:
2184 /* Normal case, we handle everything in print_it_typical. */
2185 return print_it_typical (bs
);
2188 internal_error (__FILE__
, __LINE__
,
2189 "print_bp_stop_message: unrecognized enum value");
2194 /* Print a message indicating what happened. This is called from
2195 normal_stop(). The input to this routine is the head of the bpstat
2196 list - a list of the eventpoints that caused this stop. This
2197 routine calls the generic print routine for printing a message
2198 about reasons for stopping. This will print (for example) the
2199 "Breakpoint n," part of the output. The return value of this
2202 PRINT_UNKNOWN: Means we printed nothing
2203 PRINT_SRC_AND_LOC: Means we printed something, and expect subsequent
2204 code to print the location. An example is
2205 "Breakpoint 1, " which should be followed by
2207 PRINT_SRC_ONLY: Means we printed something, but there is no need
2208 to also print the location part of the message.
2209 An example is the catch/throw messages, which
2210 don't require a location appended to the end.
2211 PRINT_NOTHING: We have done some printing and we don't need any
2212 further info to be printed.*/
2214 enum print_stop_action
2215 bpstat_print (bpstat bs
)
2219 /* Maybe another breakpoint in the chain caused us to stop.
2220 (Currently all watchpoints go on the bpstat whether hit or not.
2221 That probably could (should) be changed, provided care is taken
2222 with respect to bpstat_explains_signal). */
2223 for (; bs
; bs
= bs
->next
)
2225 val
= print_bp_stop_message (bs
);
2226 if (val
== PRINT_SRC_ONLY
2227 || val
== PRINT_SRC_AND_LOC
2228 || val
== PRINT_NOTHING
)
2232 /* We reached the end of the chain, or we got a null BS to start
2233 with and nothing was printed. */
2234 return PRINT_UNKNOWN
;
2237 /* Evaluate the expression EXP and return 1 if value is zero.
2238 This is used inside a catch_errors to evaluate the breakpoint condition.
2239 The argument is a "struct expression *" that has been cast to char * to
2240 make it pass through catch_errors. */
2243 breakpoint_cond_eval (PTR exp
)
2245 value_ptr mark
= value_mark ();
2246 int i
= !value_true (evaluate_expression ((struct expression
*) exp
));
2247 value_free_to_mark (mark
);
2251 /* Allocate a new bpstat and chain it to the current one. */
2254 bpstat_alloc (struct breakpoint
*b
, bpstat cbs
/* Current "bs" value */ )
2258 bs
= (bpstat
) xmalloc (sizeof (*bs
));
2260 bs
->breakpoint_at
= b
;
2261 /* If the condition is false, etc., don't do the commands. */
2262 bs
->commands
= NULL
;
2264 bs
->print_it
= print_it_normal
;
2268 /* Possible return values for watchpoint_check (this can't be an enum
2269 because of check_errors). */
2270 /* The watchpoint has been deleted. */
2271 #define WP_DELETED 1
2272 /* The value has changed. */
2273 #define WP_VALUE_CHANGED 2
2274 /* The value has not changed. */
2275 #define WP_VALUE_NOT_CHANGED 3
2277 #define BP_TEMPFLAG 1
2278 #define BP_HARDWAREFLAG 2
2280 /* Check watchpoint condition. */
2283 watchpoint_check (PTR p
)
2285 bpstat bs
= (bpstat
) p
;
2286 struct breakpoint
*b
;
2287 struct frame_info
*fr
;
2288 int within_current_scope
;
2290 b
= bs
->breakpoint_at
;
2292 if (b
->exp_valid_block
== NULL
)
2293 within_current_scope
= 1;
2296 /* There is no current frame at this moment. If we're going to have
2297 any chance of handling watchpoints on local variables, we'll need
2298 the frame chain (so we can determine if we're in scope). */
2299 reinit_frame_cache ();
2300 fr
= find_frame_addr_in_frame_chain (b
->watchpoint_frame
);
2301 within_current_scope
= (fr
!= NULL
);
2302 if (within_current_scope
)
2303 /* If we end up stopping, the current frame will get selected
2304 in normal_stop. So this call to select_frame won't affect
2306 select_frame (fr
, -1);
2309 if (within_current_scope
)
2311 /* We use value_{,free_to_}mark because it could be a
2312 *long* time before we return to the command level and
2313 call free_all_values. We can't call free_all_values because
2314 we might be in the middle of evaluating a function call. */
2316 value_ptr mark
= value_mark ();
2317 value_ptr new_val
= evaluate_expression (bs
->breakpoint_at
->exp
);
2318 if (!value_equal (b
->val
, new_val
))
2320 release_value (new_val
);
2321 value_free_to_mark (mark
);
2322 bs
->old_val
= b
->val
;
2324 /* We will stop here */
2325 return WP_VALUE_CHANGED
;
2329 /* Nothing changed, don't do anything. */
2330 value_free_to_mark (mark
);
2331 /* We won't stop here */
2332 return WP_VALUE_NOT_CHANGED
;
2337 /* This seems like the only logical thing to do because
2338 if we temporarily ignored the watchpoint, then when
2339 we reenter the block in which it is valid it contains
2340 garbage (in the case of a function, it may have two
2341 garbage values, one before and one after the prologue).
2342 So we can't even detect the first assignment to it and
2343 watch after that (since the garbage may or may not equal
2344 the first value assigned). */
2345 /* We print all the stop information in print_it_typical(), but
2346 in this case, by the time we call print_it_typical() this bp
2347 will be deleted already. So we have no choice but print the
2348 information here. */
2350 if (interpreter_p
&& strcmp (interpreter_p
, "mi") == 0)
2351 ui_out_field_string (uiout
, "reason", "watchpoint-scope");
2352 ui_out_text (uiout
, "\nWatchpoint ");
2353 ui_out_field_int (uiout
, "wpnum", bs
->breakpoint_at
->number
);
2354 ui_out_text (uiout
, " deleted because the program has left the block in\n\
2355 which its expression is valid.\n");
2358 Watchpoint %d deleted because the program has left the block in\n\
2359 which its expression is valid.\n", bs
->breakpoint_at
->number
);
2362 if (b
->related_breakpoint
)
2363 b
->related_breakpoint
->disposition
= del_at_next_stop
;
2364 b
->disposition
= del_at_next_stop
;
2370 /* Get a bpstat associated with having just stopped at address *PC
2371 and frame address CORE_ADDRESS. Update *PC to point at the
2372 breakpoint (if we hit a breakpoint). NOT_A_BREAKPOINT is nonzero
2373 if this is known to not be a real breakpoint (it could still be a
2374 watchpoint, though). */
2376 /* Determine whether we stopped at a breakpoint, etc, or whether we
2377 don't understand this stop. Result is a chain of bpstat's such that:
2379 if we don't understand the stop, the result is a null pointer.
2381 if we understand why we stopped, the result is not null.
2383 Each element of the chain refers to a particular breakpoint or
2384 watchpoint at which we have stopped. (We may have stopped for
2385 several reasons concurrently.)
2387 Each element of the chain has valid next, breakpoint_at,
2388 commands, FIXME??? fields. */
2391 bpstat_stop_status (CORE_ADDR
*pc
, int not_a_breakpoint
)
2393 register struct breakpoint
*b
, *temp
;
2395 /* True if we've hit a breakpoint (as opposed to a watchpoint). */
2396 int real_breakpoint
= 0;
2397 /* Root of the chain of bpstat's */
2398 struct bpstats root_bs
[1];
2399 /* Pointer to the last thing in the chain currently. */
2400 bpstat bs
= root_bs
;
2401 static char message1
[] =
2402 "Error evaluating expression for watchpoint %d\n";
2403 char message
[sizeof (message1
) + 30 /* slop */ ];
2405 /* Get the address where the breakpoint would have been. */
2406 bp_addr
= *pc
- (not_a_breakpoint
&& !SOFTWARE_SINGLE_STEP_P () ?
2407 0 : DECR_PC_AFTER_BREAK
);
2409 ALL_BREAKPOINTS_SAFE (b
, temp
)
2411 if (b
->enable
== disabled
2412 || b
->enable
== shlib_disabled
2413 || b
->enable
== call_disabled
)
2416 if (b
->type
!= bp_watchpoint
2417 && b
->type
!= bp_hardware_watchpoint
2418 && b
->type
!= bp_read_watchpoint
2419 && b
->type
!= bp_access_watchpoint
2420 && b
->type
!= bp_hardware_breakpoint
2421 && b
->type
!= bp_catch_fork
2422 && b
->type
!= bp_catch_vfork
2423 && b
->type
!= bp_catch_exec
2424 && b
->type
!= bp_catch_catch
2425 && b
->type
!= bp_catch_throw
) /* a non-watchpoint bp */
2426 if (b
->address
!= bp_addr
|| /* address doesn't match or */
2427 (overlay_debugging
&& /* overlay doesn't match */
2428 section_is_overlay (b
->section
) &&
2429 !section_is_mapped (b
->section
)))
2432 if (b
->type
== bp_hardware_breakpoint
2433 && b
->address
!= (*pc
- DECR_PC_AFTER_HW_BREAK
))
2436 /* Is this a catchpoint of a load or unload? If so, did we
2437 get a load or unload of the specified library? If not,
2439 if ((b
->type
== bp_catch_load
)
2440 #if defined(SOLIB_HAVE_LOAD_EVENT)
2441 && (!SOLIB_HAVE_LOAD_EVENT (PIDGET (inferior_ptid
))
2442 || ((b
->dll_pathname
!= NULL
)
2443 && (strcmp (b
->dll_pathname
,
2444 SOLIB_LOADED_LIBRARY_PATHNAME (
2445 PIDGET (inferior_ptid
)))
2451 if ((b
->type
== bp_catch_unload
)
2452 #if defined(SOLIB_HAVE_UNLOAD_EVENT)
2453 && (!SOLIB_HAVE_UNLOAD_EVENT (PIDGET (inferior_ptid
))
2454 || ((b
->dll_pathname
!= NULL
)
2455 && (strcmp (b
->dll_pathname
,
2456 SOLIB_UNLOADED_LIBRARY_PATHNAME (
2457 PIDGET (inferior_ptid
)))
2463 if ((b
->type
== bp_catch_fork
)
2464 && !target_has_forked (PIDGET (inferior_ptid
),
2465 &b
->forked_inferior_pid
))
2468 if ((b
->type
== bp_catch_vfork
)
2469 && !target_has_vforked (PIDGET (inferior_ptid
),
2470 &b
->forked_inferior_pid
))
2473 if ((b
->type
== bp_catch_exec
)
2474 && !target_has_execd (PIDGET (inferior_ptid
), &b
->exec_pathname
))
2477 if (ep_is_exception_catchpoint (b
) &&
2478 !(current_exception_event
= target_get_current_exception_event ()))
2481 /* Come here if it's a watchpoint, or if the break address matches */
2483 bs
= bpstat_alloc (b
, bs
); /* Alloc a bpstat to explain stop */
2485 /* Watchpoints may change this, if not found to have triggered. */
2489 sprintf (message
, message1
, b
->number
);
2490 if (b
->type
== bp_watchpoint
||
2491 b
->type
== bp_hardware_watchpoint
)
2493 switch (catch_errors (watchpoint_check
, bs
, message
,
2497 /* We've already printed what needs to be printed. */
2498 /* Actually this is superfluous, because by the time we
2499 call print_it_typical() the wp will be already deleted,
2500 and the function will return immediately. */
2501 bs
->print_it
= print_it_done
;
2504 case WP_VALUE_CHANGED
:
2508 case WP_VALUE_NOT_CHANGED
:
2510 bs
->print_it
= print_it_noop
;
2517 /* Error from catch_errors. */
2518 printf_filtered ("Watchpoint %d deleted.\n", b
->number
);
2519 if (b
->related_breakpoint
)
2520 b
->related_breakpoint
->disposition
= del_at_next_stop
;
2521 b
->disposition
= del_at_next_stop
;
2522 /* We've already printed what needs to be printed. */
2523 bs
->print_it
= print_it_done
;
2529 else if (b
->type
== bp_read_watchpoint
||
2530 b
->type
== bp_access_watchpoint
)
2536 addr
= target_stopped_data_address ();
2539 for (v
= b
->val_chain
; v
; v
= v
->next
)
2541 if (VALUE_LVAL (v
) == lval_memory
2542 && ! VALUE_LAZY (v
))
2544 struct type
*vtype
= check_typedef (VALUE_TYPE (v
));
2546 if (v
== b
->val_chain
2547 || (TYPE_CODE (vtype
) != TYPE_CODE_STRUCT
2548 && TYPE_CODE (vtype
) != TYPE_CODE_ARRAY
))
2552 vaddr
= VALUE_ADDRESS (v
) + VALUE_OFFSET (v
);
2553 /* Exact match not required. Within range is
2555 if (addr
>= vaddr
&&
2556 addr
< vaddr
+ TYPE_LENGTH (VALUE_TYPE (v
)))
2562 switch (catch_errors (watchpoint_check
, bs
, message
,
2566 /* We've already printed what needs to be printed. */
2567 bs
->print_it
= print_it_done
;
2570 case WP_VALUE_CHANGED
:
2571 if (b
->type
== bp_read_watchpoint
)
2573 /* Don't stop: read watchpoints shouldn't fire if
2574 the value has changed. This is for targets which
2575 cannot set read-only watchpoints. */
2576 bs
->print_it
= print_it_noop
;
2582 case WP_VALUE_NOT_CHANGED
:
2589 /* Error from catch_errors. */
2590 printf_filtered ("Watchpoint %d deleted.\n", b
->number
);
2591 if (b
->related_breakpoint
)
2592 b
->related_breakpoint
->disposition
= del_at_next_stop
;
2593 b
->disposition
= del_at_next_stop
;
2594 /* We've already printed what needs to be printed. */
2595 bs
->print_it
= print_it_done
;
2598 else /* found == 0 */
2600 /* This is a case where some watchpoint(s) triggered,
2601 but not at the address of this watchpoint (FOUND
2602 was left zero). So don't print anything for this
2604 bs
->print_it
= print_it_noop
;
2611 /* By definition, an encountered breakpoint is a triggered
2615 real_breakpoint
= 1;
2619 b
->frame
!= (get_current_frame ())->frame
)
2623 int value_is_zero
= 0;
2627 /* Need to select the frame, with all that implies
2628 so that the conditions will have the right context. */
2629 select_frame (get_current_frame (), 0);
2631 = catch_errors (breakpoint_cond_eval
, (b
->cond
),
2632 "Error in testing breakpoint condition:\n",
2634 /* FIXME-someday, should give breakpoint # */
2637 if (b
->cond
&& value_is_zero
)
2640 /* Don't consider this a hit. */
2643 else if (b
->ignore_count
> 0)
2646 annotate_ignore_count_change ();
2651 /* We will stop here */
2652 if (b
->disposition
== disable
)
2653 b
->enable
= disabled
;
2654 bs
->commands
= b
->commands
;
2658 (STREQ ("silent", bs
->commands
->line
) ||
2659 (xdb_commands
&& STREQ ("Q", bs
->commands
->line
))))
2661 bs
->commands
= bs
->commands
->next
;
2666 /* Print nothing for this entry if we dont stop or if we dont print. */
2667 if (bs
->stop
== 0 || bs
->print
== 0)
2668 bs
->print_it
= print_it_noop
;
2671 bs
->next
= NULL
; /* Terminate the chain */
2672 bs
= root_bs
->next
; /* Re-grab the head of the chain */
2674 if (real_breakpoint
&& bs
)
2676 if (bs
->breakpoint_at
->type
== bp_hardware_breakpoint
)
2678 if (DECR_PC_AFTER_HW_BREAK
!= 0)
2680 *pc
= *pc
- DECR_PC_AFTER_HW_BREAK
;
2686 if (DECR_PC_AFTER_BREAK
!= 0 || must_shift_inst_regs
)
2689 #if defined (SHIFT_INST_REGS)
2691 #else /* No SHIFT_INST_REGS. */
2693 #endif /* No SHIFT_INST_REGS. */
2698 /* The value of a hardware watchpoint hasn't changed, but the
2699 intermediate memory locations we are watching may have. */
2700 if (bs
&& !bs
->stop
&&
2701 (bs
->breakpoint_at
->type
== bp_hardware_watchpoint
||
2702 bs
->breakpoint_at
->type
== bp_read_watchpoint
||
2703 bs
->breakpoint_at
->type
== bp_access_watchpoint
))
2705 remove_breakpoints ();
2706 insert_breakpoints ();
2711 /* Tell what to do about this bpstat. */
2713 bpstat_what (bpstat bs
)
2715 /* Classify each bpstat as one of the following. */
2718 /* This bpstat element has no effect on the main_action. */
2721 /* There was a watchpoint, stop but don't print. */
2724 /* There was a watchpoint, stop and print. */
2727 /* There was a breakpoint but we're not stopping. */
2730 /* There was a breakpoint, stop but don't print. */
2733 /* There was a breakpoint, stop and print. */
2736 /* We hit the longjmp breakpoint. */
2739 /* We hit the longjmp_resume breakpoint. */
2742 /* We hit the step_resume breakpoint. */
2745 /* We hit the through_sigtramp breakpoint. */
2748 /* We hit the shared library event breakpoint. */
2751 /* We caught a shared library event. */
2754 /* This is just used to count how many enums there are. */
2758 /* Here is the table which drives this routine. So that we can
2759 format it pretty, we define some abbreviations for the
2760 enum bpstat_what codes. */
2761 #define kc BPSTAT_WHAT_KEEP_CHECKING
2762 #define ss BPSTAT_WHAT_STOP_SILENT
2763 #define sn BPSTAT_WHAT_STOP_NOISY
2764 #define sgl BPSTAT_WHAT_SINGLE
2765 #define slr BPSTAT_WHAT_SET_LONGJMP_RESUME
2766 #define clr BPSTAT_WHAT_CLEAR_LONGJMP_RESUME
2767 #define clrs BPSTAT_WHAT_CLEAR_LONGJMP_RESUME_SINGLE
2768 #define sr BPSTAT_WHAT_STEP_RESUME
2769 #define ts BPSTAT_WHAT_THROUGH_SIGTRAMP
2770 #define shl BPSTAT_WHAT_CHECK_SHLIBS
2771 #define shlr BPSTAT_WHAT_CHECK_SHLIBS_RESUME_FROM_HOOK
2773 /* "Can't happen." Might want to print an error message.
2774 abort() is not out of the question, but chances are GDB is just
2775 a bit confused, not unusable. */
2776 #define err BPSTAT_WHAT_STOP_NOISY
2778 /* Given an old action and a class, come up with a new action. */
2779 /* One interesting property of this table is that wp_silent is the same
2780 as bp_silent and wp_noisy is the same as bp_noisy. That is because
2781 after stopping, the check for whether to step over a breakpoint
2782 (BPSTAT_WHAT_SINGLE type stuff) is handled in proceed() without
2783 reference to how we stopped. We retain separate wp_silent and
2784 bp_silent codes in case we want to change that someday.
2786 Another possibly interesting property of this table is that
2787 there's a partial ordering, priority-like, of the actions. Once
2788 you've decided that some action is appropriate, you'll never go
2789 back and decide something of a lower priority is better. The
2792 kc < clr sgl shl shlr slr sn sr ss ts
2793 sgl < clrs shl shlr slr sn sr ss ts
2794 slr < err shl shlr sn sr ss ts
2795 clr < clrs err shl shlr sn sr ss ts
2796 clrs < err shl shlr sn sr ss ts
2797 ss < shl shlr sn sr ts
2804 What I think this means is that we don't need a damned table
2805 here. If you just put the rows and columns in the right order,
2806 it'd look awfully regular. We could simply walk the bpstat list
2807 and choose the highest priority action we find, with a little
2808 logic to handle the 'err' cases, and the CLEAR_LONGJMP_RESUME/
2809 CLEAR_LONGJMP_RESUME_SINGLE distinction (which breakpoint.h says
2810 is messy anyway). */
2812 /* step_resume entries: a step resume breakpoint overrides another
2813 breakpoint of signal handling (see comment in wait_for_inferior
2814 at first IN_SIGTRAMP where we set the step_resume breakpoint). */
2815 /* We handle the through_sigtramp_breakpoint the same way; having both
2816 one of those and a step_resume_breakpoint is probably very rare (?). */
2818 static const enum bpstat_what_main_action
2819 table
[(int) class_last
][(int) BPSTAT_WHAT_LAST
] =
2822 /* kc ss sn sgl slr clr clrs sr ts shl shlr
2825 {kc
, ss
, sn
, sgl
, slr
, clr
, clrs
, sr
, ts
, shl
, shlr
},
2827 {ss
, ss
, sn
, ss
, ss
, ss
, ss
, sr
, ts
, shl
, shlr
},
2829 {sn
, sn
, sn
, sn
, sn
, sn
, sn
, sr
, ts
, shl
, shlr
},
2831 {sgl
, ss
, sn
, sgl
, slr
, clrs
, clrs
, sr
, ts
, shl
, shlr
},
2833 {ss
, ss
, sn
, ss
, ss
, ss
, ss
, sr
, ts
, shl
, shlr
},
2835 {sn
, sn
, sn
, sn
, sn
, sn
, sn
, sr
, ts
, shl
, shlr
},
2837 {slr
, ss
, sn
, slr
, slr
, err
, err
, sr
, ts
, shl
, shlr
},
2839 {clr
, ss
, sn
, clrs
, err
, err
, err
, sr
, ts
, shl
, shlr
},
2841 {sr
, sr
, sr
, sr
, sr
, sr
, sr
, sr
, ts
, shl
, shlr
},
2843 {ts
, ts
, ts
, ts
, ts
, ts
, ts
, ts
, ts
, shl
, shlr
},
2845 {shl
, shl
, shl
, shl
, shl
, shl
, shl
, shl
, ts
, shl
, shlr
},
2847 {shlr
, shlr
, shlr
, shlr
, shlr
, shlr
, shlr
, shlr
, ts
, shlr
, shlr
}
2862 enum bpstat_what_main_action current_action
= BPSTAT_WHAT_KEEP_CHECKING
;
2863 struct bpstat_what retval
;
2865 retval
.call_dummy
= 0;
2866 for (; bs
!= NULL
; bs
= bs
->next
)
2868 enum class bs_class
= no_effect
;
2869 if (bs
->breakpoint_at
== NULL
)
2870 /* I suspect this can happen if it was a momentary breakpoint
2871 which has since been deleted. */
2873 switch (bs
->breakpoint_at
->type
)
2879 case bp_hardware_breakpoint
:
2885 bs_class
= bp_noisy
;
2887 bs_class
= bp_silent
;
2890 bs_class
= bp_nostop
;
2893 case bp_hardware_watchpoint
:
2894 case bp_read_watchpoint
:
2895 case bp_access_watchpoint
:
2899 bs_class
= wp_noisy
;
2901 bs_class
= wp_silent
;
2904 /* There was a watchpoint, but we're not stopping.
2905 This requires no further action. */
2906 bs_class
= no_effect
;
2909 bs_class
= long_jump
;
2911 case bp_longjmp_resume
:
2912 bs_class
= long_resume
;
2914 case bp_step_resume
:
2917 bs_class
= step_resume
;
2920 /* It is for the wrong frame. */
2921 bs_class
= bp_nostop
;
2923 case bp_through_sigtramp
:
2924 bs_class
= through_sig
;
2926 case bp_watchpoint_scope
:
2927 bs_class
= bp_nostop
;
2929 case bp_shlib_event
:
2930 bs_class
= shlib_event
;
2932 case bp_thread_event
:
2933 bs_class
= bp_nostop
;
2936 case bp_catch_unload
:
2937 /* Only if this catchpoint triggered should we cause the
2938 step-out-of-dld behaviour. Otherwise, we ignore this
2941 bs_class
= catch_shlib_event
;
2943 bs_class
= no_effect
;
2946 case bp_catch_vfork
:
2951 bs_class
= bp_noisy
;
2953 bs_class
= bp_silent
;
2956 /* There was a catchpoint, but we're not stopping.
2957 This requires no further action. */
2958 bs_class
= no_effect
;
2960 case bp_catch_catch
:
2961 if (!bs
->stop
|| CURRENT_EXCEPTION_KIND
!= EX_EVENT_CATCH
)
2962 bs_class
= bp_nostop
;
2964 bs_class
= bs
->print
? bp_noisy
: bp_silent
;
2966 case bp_catch_throw
:
2967 if (!bs
->stop
|| CURRENT_EXCEPTION_KIND
!= EX_EVENT_THROW
)
2968 bs_class
= bp_nostop
;
2970 bs_class
= bs
->print
? bp_noisy
: bp_silent
;
2973 /* Make sure the action is stop (silent or noisy),
2974 so infrun.c pops the dummy frame. */
2975 bs_class
= bp_silent
;
2976 retval
.call_dummy
= 1;
2979 current_action
= table
[(int) bs_class
][(int) current_action
];
2981 retval
.main_action
= current_action
;
2985 /* Nonzero if we should step constantly (e.g. watchpoints on machines
2986 without hardware support). This isn't related to a specific bpstat,
2987 just to things like whether watchpoints are set. */
2990 bpstat_should_step (void)
2992 struct breakpoint
*b
;
2994 if (b
->enable
== enabled
&& b
->type
== bp_watchpoint
)
2999 /* Nonzero if there are enabled hardware watchpoints. */
3001 bpstat_have_active_hw_watchpoints (void)
3003 struct breakpoint
*b
;
3005 if ((b
->enable
== enabled
) &&
3007 ((b
->type
== bp_hardware_watchpoint
) ||
3008 (b
->type
== bp_read_watchpoint
) ||
3009 (b
->type
== bp_access_watchpoint
)))
3015 /* Given a bpstat that records zero or more triggered eventpoints, this
3016 function returns another bpstat which contains only the catchpoints
3017 on that first list, if any. */
3019 bpstat_get_triggered_catchpoints (bpstat ep_list
, bpstat
*cp_list
)
3021 struct bpstats root_bs
[1];
3022 bpstat bs
= root_bs
;
3023 struct breakpoint
*ep
;
3026 bpstat_clear (cp_list
);
3027 root_bs
->next
= NULL
;
3029 for (; ep_list
!= NULL
; ep_list
= ep_list
->next
)
3031 /* Is this eventpoint a catchpoint? If not, ignore it. */
3032 ep
= ep_list
->breakpoint_at
;
3035 if ((ep
->type
!= bp_catch_load
) &&
3036 (ep
->type
!= bp_catch_unload
) &&
3037 (ep
->type
!= bp_catch_catch
) &&
3038 (ep
->type
!= bp_catch_throw
))
3039 /* pai: (temp) ADD fork/vfork here!! */
3042 /* Yes; add it to the list. */
3043 bs
= bpstat_alloc (ep
, bs
);
3048 #if defined(SOLIB_ADD)
3049 /* Also, for each triggered catchpoint, tag it with the name of
3050 the library that caused this trigger. (We copy the name now,
3051 because it's only guaranteed to be available NOW, when the
3052 catchpoint triggers. Clients who may wish to know the name
3053 later must get it from the catchpoint itself.) */
3054 if (ep
->triggered_dll_pathname
!= NULL
)
3055 xfree (ep
->triggered_dll_pathname
);
3056 if (ep
->type
== bp_catch_load
)
3057 dll_pathname
= SOLIB_LOADED_LIBRARY_PATHNAME (
3058 PIDGET (inferior_ptid
));
3060 dll_pathname
= SOLIB_UNLOADED_LIBRARY_PATHNAME (
3061 PIDGET (inferior_ptid
));
3063 dll_pathname
= NULL
;
3067 ep
->triggered_dll_pathname
= (char *)
3068 xmalloc (strlen (dll_pathname
) + 1);
3069 strcpy (ep
->triggered_dll_pathname
, dll_pathname
);
3072 ep
->triggered_dll_pathname
= NULL
;
3078 /* Print B to gdb_stdout. */
3080 print_one_breakpoint (struct breakpoint
*b
,
3081 CORE_ADDR
*last_addr
)
3083 register struct command_line
*l
;
3084 register struct symbol
*sym
;
3085 struct ep_type_description
3090 static struct ep_type_description bptypes
[] =
3092 {bp_none
, "?deleted?"},
3093 {bp_breakpoint
, "breakpoint"},
3094 {bp_hardware_breakpoint
, "hw breakpoint"},
3095 {bp_until
, "until"},
3096 {bp_finish
, "finish"},
3097 {bp_watchpoint
, "watchpoint"},
3098 {bp_hardware_watchpoint
, "hw watchpoint"},
3099 {bp_read_watchpoint
, "read watchpoint"},
3100 {bp_access_watchpoint
, "acc watchpoint"},
3101 {bp_longjmp
, "longjmp"},
3102 {bp_longjmp_resume
, "longjmp resume"},
3103 {bp_step_resume
, "step resume"},
3104 {bp_through_sigtramp
, "sigtramp"},
3105 {bp_watchpoint_scope
, "watchpoint scope"},
3106 {bp_call_dummy
, "call dummy"},
3107 {bp_shlib_event
, "shlib events"},
3108 {bp_thread_event
, "thread events"},
3109 {bp_catch_load
, "catch load"},
3110 {bp_catch_unload
, "catch unload"},
3111 {bp_catch_fork
, "catch fork"},
3112 {bp_catch_vfork
, "catch vfork"},
3113 {bp_catch_exec
, "catch exec"},
3114 {bp_catch_catch
, "catch catch"},
3115 {bp_catch_throw
, "catch throw"}
3118 static char *bpdisps
[] =
3119 {"del", "dstp", "dis", "keep"};
3120 static char bpenables
[] = "nynny";
3121 char wrap_indent
[80];
3123 struct ui_stream
*stb
= ui_out_stream_new (uiout
);
3124 struct cleanup
*old_chain
= make_cleanup_ui_out_stream_delete (stb
);
3129 ui_out_tuple_begin (uiout
, "bkpt");
3135 ui_out_field_int (uiout
, "number", b
->number
);
3137 printf_filtered ("%-3d ", b
->number
);
3142 if (((int) b
->type
> (sizeof (bptypes
) / sizeof (bptypes
[0])))
3143 || ((int) b
->type
!= bptypes
[(int) b
->type
].type
))
3144 internal_error (__FILE__
, __LINE__
,
3145 "bptypes table does not describe type #%d.",
3148 ui_out_field_string (uiout
, "type", bptypes
[(int) b
->type
].description
);
3150 printf_filtered ("%-14s ", bptypes
[(int) b
->type
].description
);
3156 ui_out_field_string (uiout
, "disp", bpdisps
[(int) b
->disposition
]);
3158 printf_filtered ("%-4s ", bpdisps
[(int) b
->disposition
]);
3164 ui_out_field_fmt (uiout
, "enabled", "%c", bpenables
[(int) b
->enable
]);
3165 ui_out_spaces (uiout
, 2);
3167 printf_filtered ("%-3c ", bpenables
[(int) b
->enable
]);
3171 strcpy (wrap_indent
, " ");
3174 if (TARGET_ADDR_BIT
<= 32)
3175 strcat (wrap_indent
, " ");
3177 strcat (wrap_indent
, " ");
3182 internal_error (__FILE__
, __LINE__
,
3183 "print_one_breakpoint: bp_none encountered\n");
3187 case bp_hardware_watchpoint
:
3188 case bp_read_watchpoint
:
3189 case bp_access_watchpoint
:
3190 /* Field 4, the address, is omitted (which makes the columns
3191 not line up too nicely with the headers, but the effect
3192 is relatively readable). */
3195 ui_out_field_skip (uiout
, "addr");
3197 print_expression (b
->exp
, stb
->stream
);
3198 ui_out_field_stream (uiout
, "what", stb
);
3201 print_expression (b
->exp
, gdb_stdout
);
3206 case bp_catch_unload
:
3207 /* Field 4, the address, is omitted (which makes the columns
3208 not line up too nicely with the headers, but the effect
3209 is relatively readable). */
3212 ui_out_field_skip (uiout
, "addr");
3214 if (b
->dll_pathname
== NULL
)
3216 ui_out_field_string (uiout
, "what", "<any library>");
3217 ui_out_spaces (uiout
, 1);
3221 ui_out_text (uiout
, "library \"");
3222 ui_out_field_string (uiout
, "what", b
->dll_pathname
);
3223 ui_out_text (uiout
, "\" ");
3227 if (b
->dll_pathname
== NULL
)
3228 printf_filtered ("<any library> ");
3230 printf_filtered ("library \"%s\" ", b
->dll_pathname
);
3235 case bp_catch_vfork
:
3236 /* Field 4, the address, is omitted (which makes the columns
3237 not line up too nicely with the headers, but the effect
3238 is relatively readable). */
3241 ui_out_field_skip (uiout
, "addr");
3243 if (b
->forked_inferior_pid
!= 0)
3245 ui_out_text (uiout
, "process ");
3246 ui_out_field_int (uiout
, "what", b
->forked_inferior_pid
);
3247 ui_out_spaces (uiout
, 1);
3251 if (b
->forked_inferior_pid
!= 0)
3252 printf_filtered ("process %d ", b
->forked_inferior_pid
);
3257 /* Field 4, the address, is omitted (which makes the columns
3258 not line up too nicely with the headers, but the effect
3259 is relatively readable). */
3262 ui_out_field_skip (uiout
, "addr");
3264 if (b
->exec_pathname
!= NULL
)
3266 ui_out_text (uiout
, "program \"");
3267 ui_out_field_string (uiout
, "what", b
->exec_pathname
);
3268 ui_out_text (uiout
, "\" ");
3272 if (b
->exec_pathname
!= NULL
)
3273 printf_filtered ("program \"%s\" ", b
->exec_pathname
);
3277 case bp_catch_catch
:
3278 /* Field 4, the address, is omitted (which makes the columns
3279 not line up too nicely with the headers, but the effect
3280 is relatively readable). */
3283 ui_out_field_skip (uiout
, "addr");
3285 ui_out_field_string (uiout
, "what", "exception catch");
3286 ui_out_spaces (uiout
, 1);
3289 printf_filtered ("exception catch ");
3293 case bp_catch_throw
:
3294 /* Field 4, the address, is omitted (which makes the columns
3295 not line up too nicely with the headers, but the effect
3296 is relatively readable). */
3299 ui_out_field_skip (uiout
, "addr");
3301 ui_out_field_string (uiout
, "what", "exception throw");
3302 ui_out_spaces (uiout
, 1);
3305 printf_filtered ("exception throw ");
3310 case bp_hardware_breakpoint
:
3314 case bp_longjmp_resume
:
3315 case bp_step_resume
:
3316 case bp_through_sigtramp
:
3317 case bp_watchpoint_scope
:
3319 case bp_shlib_event
:
3320 case bp_thread_event
:
3325 ui_out_field_core_addr (uiout
, "addr", b
->address
);
3328 *last_addr
= b
->address
;
3331 sym
= find_pc_sect_function (b
->address
, b
->section
);
3334 ui_out_text (uiout
, "in ");
3335 ui_out_field_string (uiout
, "func",
3336 SYMBOL_SOURCE_NAME (sym
));
3337 ui_out_wrap_hint (uiout
, wrap_indent
);
3338 ui_out_text (uiout
, " at ");
3340 ui_out_field_string (uiout
, "file", b
->source_file
);
3341 ui_out_text (uiout
, ":");
3342 ui_out_field_int (uiout
, "line", b
->line_number
);
3346 print_address_symbolic (b
->address
, stb
->stream
, demangle
, "");
3347 ui_out_field_stream (uiout
, "at", stb
);
3356 if (TARGET_ADDR_BIT
<= 32)
3357 tmp
= longest_local_hex_string_custom (b
->address
3358 & (CORE_ADDR
) 0xffffffff,
3361 tmp
= longest_local_hex_string_custom (b
->address
, "016l");
3363 printf_filtered ("%s ", tmp
);
3366 *last_addr
= b
->address
;
3369 sym
= find_pc_sect_function (b
->address
, b
->section
);
3372 fputs_filtered ("in ", gdb_stdout
);
3373 fputs_filtered (SYMBOL_SOURCE_NAME (sym
), gdb_stdout
);
3374 wrap_here (wrap_indent
);
3375 fputs_filtered (" at ", gdb_stdout
);
3377 fputs_filtered (b
->source_file
, gdb_stdout
);
3378 printf_filtered (":%d", b
->line_number
);
3381 print_address_symbolic (b
->address
, gdb_stdout
, demangle
, " ");
3386 if (b
->thread
!= -1)
3389 /* FIXME: This seems to be redundant and lost here; see the
3390 "stop only in" line a little further down. */
3391 ui_out_text (uiout
, " thread ");
3392 ui_out_field_int (uiout
, "thread", b
->thread
);
3394 printf_filtered (" thread %d", b
->thread
);
3399 ui_out_text (uiout
, "\n");
3401 printf_filtered ("\n");
3408 ui_out_text (uiout
, "\tstop only in stack frame at ");
3409 ui_out_field_core_addr (uiout
, "frame", b
->frame
);
3410 ui_out_text (uiout
, "\n");
3412 printf_filtered ("\tstop only in stack frame at ");
3413 print_address_numeric (b
->frame
, 1, gdb_stdout
);
3414 printf_filtered ("\n");
3422 ui_out_text (uiout
, "\tstop only if ");
3423 print_expression (b
->cond
, stb
->stream
);
3424 ui_out_field_stream (uiout
, "cond", stb
);
3425 ui_out_text (uiout
, "\n");
3427 printf_filtered ("\tstop only if ");
3428 print_expression (b
->cond
, gdb_stdout
);
3429 printf_filtered ("\n");
3433 if (b
->thread
!= -1)
3435 /* FIXME should make an annotation for this */
3437 ui_out_text (uiout
, "\tstop only in thread ");
3438 ui_out_field_int (uiout
, "thread", b
->thread
);
3439 ui_out_text (uiout
, "\n");
3441 printf_filtered ("\tstop only in thread %d\n", b
->thread
);
3445 if (show_breakpoint_hit_counts
&& b
->hit_count
)
3447 /* FIXME should make an annotation for this */
3449 if (ep_is_catchpoint (b
))
3450 ui_out_text (uiout
, "\tcatchpoint");
3452 ui_out_text (uiout
, "\tbreakpoint");
3453 ui_out_text (uiout
, " already hit ");
3454 ui_out_field_int (uiout
, "times", b
->hit_count
);
3455 if (b
->hit_count
== 1)
3456 ui_out_text (uiout
, " time\n");
3458 ui_out_text (uiout
, " times\n");
3460 if (ep_is_catchpoint (b
))
3461 printf_filtered ("\tcatchpoint");
3463 printf_filtered ("\tbreakpoint");
3464 printf_filtered (" already hit %d time%s\n",
3465 b
->hit_count
, (b
->hit_count
== 1 ? "" : "s"));
3470 /* Output the count also if it is zero, but only if this is
3471 mi. FIXME: Should have a better test for this. */
3472 if (interpreter_p
&& strcmp (interpreter_p
, "mi") == 0)
3473 if (show_breakpoint_hit_counts
&& b
->hit_count
== 0)
3474 ui_out_field_int (uiout
, "times", b
->hit_count
);
3477 if (b
->ignore_count
)
3481 ui_out_text (uiout
, "\tignore next ");
3482 ui_out_field_int (uiout
, "ignore", b
->ignore_count
);
3483 ui_out_text (uiout
, " hits\n");
3485 printf_filtered ("\tignore next %d hits\n", b
->ignore_count
);
3489 if ((l
= b
->commands
))
3493 ui_out_tuple_begin (uiout
, "script");
3494 print_command_lines (uiout
, l
, 4);
3495 ui_out_tuple_end (uiout
);
3499 print_command_line (l
, 4, gdb_stdout
);
3505 ui_out_tuple_end (uiout
);
3506 do_cleanups (old_chain
);
3510 struct captured_breakpoint_query_args
3516 do_captured_breakpoint_query (void *data
)
3518 struct captured_breakpoint_query_args
*args
= data
;
3519 register struct breakpoint
*b
;
3520 CORE_ADDR dummy_addr
= 0;
3523 if (args
->bnum
== b
->number
)
3525 print_one_breakpoint (b
, &dummy_addr
);
3533 gdb_breakpoint_query (/* output object, */ int bnum
)
3535 struct captured_breakpoint_query_args args
;
3537 /* For the moment we don't trust print_one_breakpoint() to not throw
3539 return catch_errors (do_captured_breakpoint_query
, &args
,
3540 NULL
, RETURN_MASK_ALL
);
3543 /* Print information on breakpoint number BNUM, or -1 if all.
3544 If WATCHPOINTS is zero, process only breakpoints; if WATCHPOINTS
3545 is nonzero, process only watchpoints. */
3548 breakpoint_1 (int bnum
, int allflag
)
3550 register struct breakpoint
*b
;
3551 CORE_ADDR last_addr
= (CORE_ADDR
) -1;
3552 int found_a_breakpoint
= 0;
3556 ui_out_table_begin (uiout
, 6, "BreakpointTable");
3558 ui_out_table_begin (uiout
, 5, "BreakpointTable");
3563 || bnum
== b
->number
)
3565 /* We only print out user settable breakpoints unless the
3568 && b
->type
!= bp_breakpoint
3569 && b
->type
!= bp_catch_load
3570 && b
->type
!= bp_catch_unload
3571 && b
->type
!= bp_catch_fork
3572 && b
->type
!= bp_catch_vfork
3573 && b
->type
!= bp_catch_exec
3574 && b
->type
!= bp_catch_catch
3575 && b
->type
!= bp_catch_throw
3576 && b
->type
!= bp_hardware_breakpoint
3577 && b
->type
!= bp_watchpoint
3578 && b
->type
!= bp_read_watchpoint
3579 && b
->type
!= bp_access_watchpoint
3580 && b
->type
!= bp_hardware_watchpoint
)
3583 if (!found_a_breakpoint
++)
3585 annotate_breakpoints_headers ();
3588 ui_out_table_header (uiout
, 3, ui_left
, "Num"); /* 1 */
3590 ui_out_table_header (uiout
, 14, ui_left
, "Type"); /* 2 */
3592 ui_out_table_header (uiout
, 4, ui_left
, "Disp"); /* 3 */
3594 ui_out_table_header (uiout
, 3, ui_left
, "Enb"); /* 4 */
3598 if (TARGET_ADDR_BIT
<= 32)
3599 ui_out_table_header (uiout
, 10, ui_left
, "Address"); /* 5 */
3601 ui_out_table_header (uiout
, 18, ui_left
, "Address"); /* 5 */
3604 ui_out_table_header (uiout
, 40, ui_noalign
, "What"); /* 6 */
3605 ui_out_table_body (uiout
);
3608 printf_filtered ("Num ");
3610 printf_filtered ("Type ");
3612 printf_filtered ("Disp ");
3614 printf_filtered ("Enb ");
3618 if (TARGET_ADDR_BIT
<= 32)
3619 printf_filtered ("Address ");
3621 printf_filtered ("Address ");
3624 printf_filtered ("What\n");
3626 annotate_breakpoints_table ();
3629 print_one_breakpoint (b
, &last_addr
);
3632 if (!found_a_breakpoint
)
3636 ui_out_message (uiout
, 0, "No breakpoints or watchpoints.\n");
3638 ui_out_message (uiout
, 0, "No breakpoint or watchpoint number %d.\n",
3642 printf_filtered ("No breakpoints or watchpoints.\n");
3644 printf_filtered ("No breakpoint or watchpoint number %d.\n", bnum
);
3649 /* Compare against (CORE_ADDR)-1 in case some compiler decides
3650 that a comparison of an unsigned with -1 is always false. */
3651 if (last_addr
!= (CORE_ADDR
) -1)
3652 set_next_address (last_addr
);
3656 ui_out_table_end (uiout
);
3658 /* FIXME? Should this be moved up so that it is only called when
3659 there have been breakpoints? */
3660 annotate_breakpoints_table_end ();
3665 breakpoints_info (char *bnum_exp
, int from_tty
)
3670 bnum
= parse_and_eval_long (bnum_exp
);
3672 breakpoint_1 (bnum
, 0);
3677 maintenance_info_breakpoints (char *bnum_exp
, int from_tty
)
3682 bnum
= parse_and_eval_long (bnum_exp
);
3684 breakpoint_1 (bnum
, 1);
3687 /* Print a message describing any breakpoints set at PC. */
3690 describe_other_breakpoints (CORE_ADDR pc
, asection
*section
)
3692 register int others
= 0;
3693 register struct breakpoint
*b
;
3696 if (b
->address
== pc
)
3697 if (overlay_debugging
== 0 ||
3698 b
->section
== section
)
3702 printf_filtered ("Note: breakpoint%s ", (others
> 1) ? "s" : "");
3704 if (b
->address
== pc
)
3705 if (overlay_debugging
== 0 ||
3706 b
->section
== section
)
3709 printf_filtered ("%d%s%s ",
3711 ((b
->enable
== disabled
||
3712 b
->enable
== shlib_disabled
||
3713 b
->enable
== call_disabled
) ? " (disabled)"
3714 : b
->enable
== permanent
? " (permanent)"
3717 : ((others
== 1) ? " and" : ""));
3719 printf_filtered ("also set at pc ");
3720 print_address_numeric (pc
, 1, gdb_stdout
);
3721 printf_filtered (".\n");
3725 /* Set the default place to put a breakpoint
3726 for the `break' command with no arguments. */
3729 set_default_breakpoint (int valid
, CORE_ADDR addr
, struct symtab
*symtab
,
3732 default_breakpoint_valid
= valid
;
3733 default_breakpoint_address
= addr
;
3734 default_breakpoint_symtab
= symtab
;
3735 default_breakpoint_line
= line
;
3738 /* Return true iff it is meaningful to use the address member of
3739 BPT. For some breakpoint types, the address member is irrelevant
3740 and it makes no sense to attempt to compare it to other addresses
3741 (or use it for any other purpose either).
3743 More specifically, each of the following breakpoint types will always
3744 have a zero valued address and we don't want check_duplicates() to mark
3745 breakpoints of any of these types to be a duplicate of an actual
3746 breakpoint at address zero:
3749 bp_hardware_watchpoint
3751 bp_access_watchpoint
3758 breakpoint_address_is_meaningful (struct breakpoint
*bpt
)
3760 enum bptype type
= bpt
->type
;
3762 return (type
!= bp_watchpoint
3763 && type
!= bp_hardware_watchpoint
3764 && type
!= bp_read_watchpoint
3765 && type
!= bp_access_watchpoint
3766 && type
!= bp_catch_exec
3767 && type
!= bp_longjmp_resume
3768 && type
!= bp_catch_fork
3769 && type
!= bp_catch_vfork
);
3772 /* Rescan breakpoints at the same address and section as BPT,
3773 marking the first one as "first" and any others as "duplicates".
3774 This is so that the bpt instruction is only inserted once.
3775 If we have a permanent breakpoint at the same place as BPT, make
3776 that one the official one, and the rest as duplicates. */
3779 check_duplicates (struct breakpoint
*bpt
)
3781 register struct breakpoint
*b
;
3782 register int count
= 0;
3783 struct breakpoint
*perm_bp
= 0;
3784 CORE_ADDR address
= bpt
->address
;
3785 asection
*section
= bpt
->section
;
3787 if (! breakpoint_address_is_meaningful (bpt
))
3791 if (b
->enable
!= disabled
3792 && b
->enable
!= shlib_disabled
3793 && b
->enable
!= call_disabled
3794 && b
->address
== address
3795 && (overlay_debugging
== 0 || b
->section
== section
)
3796 && breakpoint_address_is_meaningful (b
))
3798 /* Have we found a permanent breakpoint? */
3799 if (b
->enable
== permanent
)
3806 b
->duplicate
= count
> 1;
3809 /* If we found a permanent breakpoint at this address, go over the
3810 list again and declare all the other breakpoints there to be the
3814 perm_bp
->duplicate
= 0;
3816 /* Permanent breakpoint should always be inserted. */
3817 if (! perm_bp
->inserted
)
3818 internal_error (__FILE__
, __LINE__
,
3819 "allegedly permanent breakpoint is not "
3820 "actually inserted");
3826 internal_error (__FILE__
, __LINE__
,
3827 "another breakpoint was inserted on top of "
3828 "a permanent breakpoint");
3830 if (b
->enable
!= disabled
3831 && b
->enable
!= shlib_disabled
3832 && b
->enable
!= call_disabled
3833 && b
->address
== address
3834 && (overlay_debugging
== 0 || b
->section
== section
)
3835 && breakpoint_address_is_meaningful (b
))
3841 /* set_raw_breakpoint() is a low level routine for allocating and
3842 partially initializing a breakpoint of type BPTYPE. The newly
3843 created breakpoint's address, section, source file name, and line
3844 number are provided by SAL. The newly created and partially
3845 initialized breakpoint is added to the breakpoint chain and
3846 is also returned as the value of this function.
3848 It is expected that the caller will complete the initialization of
3849 the newly created breakpoint struct as well as output any status
3850 information regarding the creation of a new breakpoint. In
3851 particular, set_raw_breakpoint() does NOT set the breakpoint
3852 number! Care should be taken to not allow an error() to occur
3853 prior to completing the initialization of the breakpoint. If this
3854 should happen, a bogus breakpoint will be left on the chain. */
3857 set_raw_breakpoint (struct symtab_and_line sal
, enum bptype bptype
)
3859 register struct breakpoint
*b
, *b1
;
3861 b
= (struct breakpoint
*) xmalloc (sizeof (struct breakpoint
));
3862 memset (b
, 0, sizeof (*b
));
3863 b
->address
= sal
.pc
;
3864 if (sal
.symtab
== NULL
)
3865 b
->source_file
= NULL
;
3867 b
->source_file
= savestring (sal
.symtab
->filename
,
3868 strlen (sal
.symtab
->filename
));
3869 b
->section
= sal
.section
;
3871 b
->language
= current_language
->la_language
;
3872 b
->input_radix
= input_radix
;
3874 b
->line_number
= sal
.line
;
3875 b
->enable
= enabled
;
3878 b
->ignore_count
= 0;
3881 b
->dll_pathname
= NULL
;
3882 b
->triggered_dll_pathname
= NULL
;
3883 b
->forked_inferior_pid
= 0;
3884 b
->exec_pathname
= NULL
;
3886 /* Add this breakpoint to the end of the chain
3887 so that a list of breakpoints will come out in order
3888 of increasing numbers. */
3890 b1
= breakpoint_chain
;
3892 breakpoint_chain
= b
;
3900 check_duplicates (b
);
3901 breakpoints_changed ();
3907 /* Note that the breakpoint object B describes a permanent breakpoint
3908 instruction, hard-wired into the inferior's code. */
3910 make_breakpoint_permanent (struct breakpoint
*b
)
3912 b
->enable
= permanent
;
3914 /* By definition, permanent breakpoints are already present in the code. */
3918 #ifdef GET_LONGJMP_TARGET
3921 create_longjmp_breakpoint (char *func_name
)
3923 struct symtab_and_line sal
;
3924 struct breakpoint
*b
;
3926 INIT_SAL (&sal
); /* initialize to zeroes */
3927 if (func_name
!= NULL
)
3929 struct minimal_symbol
*m
;
3931 m
= lookup_minimal_symbol_text (func_name
, NULL
,
3932 (struct objfile
*) NULL
);
3934 sal
.pc
= SYMBOL_VALUE_ADDRESS (m
);
3938 sal
.section
= find_pc_overlay (sal
.pc
);
3939 b
= set_raw_breakpoint (sal
,
3940 func_name
!= NULL
? bp_longjmp
: bp_longjmp_resume
);
3942 b
->disposition
= donttouch
;
3943 b
->enable
= disabled
;
3946 b
->addr_string
= xstrdup (func_name
);
3947 b
->number
= internal_breakpoint_number
--;
3950 #endif /* #ifdef GET_LONGJMP_TARGET */
3952 /* Call this routine when stepping and nexting to enable a breakpoint
3953 if we do a longjmp(). When we hit that breakpoint, call
3954 set_longjmp_resume_breakpoint() to figure out where we are going. */
3957 enable_longjmp_breakpoint (void)
3959 register struct breakpoint
*b
;
3962 if (b
->type
== bp_longjmp
)
3964 b
->enable
= enabled
;
3965 check_duplicates (b
);
3970 disable_longjmp_breakpoint (void)
3972 register struct breakpoint
*b
;
3975 if (b
->type
== bp_longjmp
3976 || b
->type
== bp_longjmp_resume
)
3978 b
->enable
= disabled
;
3979 check_duplicates (b
);
3984 create_thread_event_breakpoint (CORE_ADDR address
)
3986 struct breakpoint
*b
;
3987 struct symtab_and_line sal
;
3988 char addr_string
[80]; /* Surely an addr can't be longer than that. */
3990 INIT_SAL (&sal
); /* initialize to zeroes */
3992 sal
.section
= find_pc_overlay (sal
.pc
);
3993 b
= set_raw_breakpoint (sal
, bp_thread_event
);
3995 b
->number
= internal_breakpoint_number
--;
3996 b
->disposition
= donttouch
;
3997 b
->enable
= enabled
;
3998 /* addr_string has to be used or breakpoint_re_set will delete me. */
3999 sprintf (addr_string
, "*0x%s", paddr (b
->address
));
4000 b
->addr_string
= xstrdup (addr_string
);
4006 remove_thread_event_breakpoints (void)
4008 struct breakpoint
*b
, *temp
;
4010 ALL_BREAKPOINTS_SAFE (b
, temp
)
4011 if (b
->type
== bp_thread_event
)
4012 delete_breakpoint (b
);
4017 remove_solib_event_breakpoints (void)
4019 register struct breakpoint
*b
, *temp
;
4021 ALL_BREAKPOINTS_SAFE (b
, temp
)
4022 if (b
->type
== bp_shlib_event
)
4023 delete_breakpoint (b
);
4027 create_solib_event_breakpoint (CORE_ADDR address
)
4029 struct breakpoint
*b
;
4030 struct symtab_and_line sal
;
4032 INIT_SAL (&sal
); /* initialize to zeroes */
4034 sal
.section
= find_pc_overlay (sal
.pc
);
4035 b
= set_raw_breakpoint (sal
, bp_shlib_event
);
4036 b
->number
= internal_breakpoint_number
--;
4037 b
->disposition
= donttouch
;
4042 /* Disable any breakpoints that are on code in shared libraries. Only
4043 apply to enabled breakpoints, disabled ones can just stay disabled. */
4046 disable_breakpoints_in_shlibs (int silent
)
4048 struct breakpoint
*b
;
4049 int disabled_shlib_breaks
= 0;
4051 /* See also: insert_breakpoints, under DISABLE_UNSETTABLE_BREAK. */
4054 #if defined (PC_SOLIB)
4055 if (((b
->type
== bp_breakpoint
) ||
4056 (b
->type
== bp_hardware_breakpoint
)) &&
4057 b
->enable
== enabled
&&
4059 PC_SOLIB (b
->address
))
4061 b
->enable
= shlib_disabled
;
4064 if (!disabled_shlib_breaks
)
4066 target_terminal_ours_for_output ();
4067 warning ("Temporarily disabling shared library breakpoints:");
4069 disabled_shlib_breaks
= 1;
4070 warning ("breakpoint #%d ", b
->number
);
4077 /* Try to reenable any breakpoints in shared libraries. */
4079 re_enable_breakpoints_in_shlibs (void)
4081 struct breakpoint
*b
;
4084 if (b
->enable
== shlib_disabled
)
4088 /* Do not reenable the breakpoint if the shared library
4089 is still not mapped in. */
4090 if (target_read_memory (b
->address
, buf
, 1) == 0)
4091 b
->enable
= enabled
;
4098 solib_load_unload_1 (char *hookname
, int tempflag
, char *dll_pathname
,
4099 char *cond_string
, enum bptype bp_kind
)
4101 struct breakpoint
*b
;
4102 struct symtabs_and_lines sals
;
4103 struct cleanup
*old_chain
;
4104 struct cleanup
*canonical_strings_chain
= NULL
;
4105 char *addr_start
= hookname
;
4106 char *addr_end
= NULL
;
4107 char **canonical
= (char **) NULL
;
4108 int thread
= -1; /* All threads. */
4110 /* Set a breakpoint on the specified hook. */
4111 sals
= decode_line_1 (&hookname
, 1, (struct symtab
*) NULL
, 0, &canonical
);
4112 addr_end
= hookname
;
4114 if (sals
.nelts
== 0)
4116 warning ("Unable to set a breakpoint on dynamic linker callback.");
4117 warning ("Suggest linking with /opt/langtools/lib/end.o.");
4118 warning ("GDB will be unable to track shl_load/shl_unload calls");
4121 if (sals
.nelts
!= 1)
4123 warning ("Unable to set unique breakpoint on dynamic linker callback.");
4124 warning ("GDB will be unable to track shl_load/shl_unload calls");
4128 /* Make sure that all storage allocated in decode_line_1 gets freed
4129 in case the following errors out. */
4130 old_chain
= make_cleanup (xfree
, sals
.sals
);
4131 if (canonical
!= (char **) NULL
)
4133 make_cleanup (xfree
, canonical
);
4134 canonical_strings_chain
= make_cleanup (null_cleanup
, 0);
4135 if (canonical
[0] != NULL
)
4136 make_cleanup (xfree
, canonical
[0]);
4139 resolve_sal_pc (&sals
.sals
[0]);
4141 /* Remove the canonical strings from the cleanup, they are needed below. */
4142 if (canonical
!= (char **) NULL
)
4143 discard_cleanups (canonical_strings_chain
);
4145 b
= set_raw_breakpoint (sals
.sals
[0], bp_kind
);
4146 set_breakpoint_count (breakpoint_count
+ 1);
4147 b
->number
= breakpoint_count
;
4149 b
->cond_string
= (cond_string
== NULL
) ?
4150 NULL
: savestring (cond_string
, strlen (cond_string
));
4153 if (canonical
!= (char **) NULL
&& canonical
[0] != NULL
)
4154 b
->addr_string
= canonical
[0];
4155 else if (addr_start
)
4156 b
->addr_string
= savestring (addr_start
, addr_end
- addr_start
);
4158 b
->enable
= enabled
;
4159 b
->disposition
= tempflag
? del
: donttouch
;
4161 if (dll_pathname
== NULL
)
4162 b
->dll_pathname
= NULL
;
4165 b
->dll_pathname
= (char *) xmalloc (strlen (dll_pathname
) + 1);
4166 strcpy (b
->dll_pathname
, dll_pathname
);
4170 do_cleanups (old_chain
);
4174 create_solib_load_event_breakpoint (char *hookname
, int tempflag
,
4175 char *dll_pathname
, char *cond_string
)
4177 solib_load_unload_1 (hookname
, tempflag
, dll_pathname
,
4178 cond_string
, bp_catch_load
);
4182 create_solib_unload_event_breakpoint (char *hookname
, int tempflag
,
4183 char *dll_pathname
, char *cond_string
)
4185 solib_load_unload_1 (hookname
,tempflag
, dll_pathname
,
4186 cond_string
, bp_catch_unload
);
4190 create_fork_vfork_event_catchpoint (int tempflag
, char *cond_string
,
4191 enum bptype bp_kind
)
4193 struct symtab_and_line sal
;
4194 struct breakpoint
*b
;
4195 int thread
= -1; /* All threads. */
4202 b
= set_raw_breakpoint (sal
, bp_kind
);
4203 set_breakpoint_count (breakpoint_count
+ 1);
4204 b
->number
= breakpoint_count
;
4206 b
->cond_string
= (cond_string
== NULL
) ?
4207 NULL
: savestring (cond_string
, strlen (cond_string
));
4209 b
->addr_string
= NULL
;
4210 b
->enable
= enabled
;
4211 b
->disposition
= tempflag
? del
: donttouch
;
4212 b
->forked_inferior_pid
= 0;
4218 create_fork_event_catchpoint (int tempflag
, char *cond_string
)
4220 create_fork_vfork_event_catchpoint (tempflag
, cond_string
, bp_catch_fork
);
4224 create_vfork_event_catchpoint (int tempflag
, char *cond_string
)
4226 create_fork_vfork_event_catchpoint (tempflag
, cond_string
, bp_catch_vfork
);
4230 create_exec_event_catchpoint (int tempflag
, char *cond_string
)
4232 struct symtab_and_line sal
;
4233 struct breakpoint
*b
;
4234 int thread
= -1; /* All threads. */
4241 b
= set_raw_breakpoint (sal
, bp_catch_exec
);
4242 set_breakpoint_count (breakpoint_count
+ 1);
4243 b
->number
= breakpoint_count
;
4245 b
->cond_string
= (cond_string
== NULL
) ?
4246 NULL
: savestring (cond_string
, strlen (cond_string
));
4248 b
->addr_string
= NULL
;
4249 b
->enable
= enabled
;
4250 b
->disposition
= tempflag
? del
: donttouch
;
4256 hw_breakpoint_used_count (void)
4258 register struct breakpoint
*b
;
4263 if (b
->type
== bp_hardware_breakpoint
&& b
->enable
== enabled
)
4271 hw_watchpoint_used_count (enum bptype type
, int *other_type_used
)
4273 register struct breakpoint
*b
;
4276 *other_type_used
= 0;
4279 if (b
->enable
== enabled
)
4281 if (b
->type
== type
)
4283 else if ((b
->type
== bp_hardware_watchpoint
||
4284 b
->type
== bp_read_watchpoint
||
4285 b
->type
== bp_access_watchpoint
)
4286 && b
->enable
== enabled
)
4287 *other_type_used
= 1;
4293 /* Call this after hitting the longjmp() breakpoint. Use this to set
4294 a new breakpoint at the target of the jmp_buf.
4296 FIXME - This ought to be done by setting a temporary breakpoint
4297 that gets deleted automatically... */
4300 set_longjmp_resume_breakpoint (CORE_ADDR pc
, struct frame_info
*frame
)
4302 register struct breakpoint
*b
;
4305 if (b
->type
== bp_longjmp_resume
)
4308 b
->enable
= enabled
;
4310 b
->frame
= frame
->frame
;
4313 check_duplicates (b
);
4319 disable_watchpoints_before_interactive_call_start (void)
4321 struct breakpoint
*b
;
4325 if (((b
->type
== bp_watchpoint
)
4326 || (b
->type
== bp_hardware_watchpoint
)
4327 || (b
->type
== bp_read_watchpoint
)
4328 || (b
->type
== bp_access_watchpoint
)
4329 || ep_is_exception_catchpoint (b
))
4330 && (b
->enable
== enabled
))
4332 b
->enable
= call_disabled
;
4333 check_duplicates (b
);
4339 enable_watchpoints_after_interactive_call_stop (void)
4341 struct breakpoint
*b
;
4345 if (((b
->type
== bp_watchpoint
)
4346 || (b
->type
== bp_hardware_watchpoint
)
4347 || (b
->type
== bp_read_watchpoint
)
4348 || (b
->type
== bp_access_watchpoint
)
4349 || ep_is_exception_catchpoint (b
))
4350 && (b
->enable
== call_disabled
))
4352 b
->enable
= enabled
;
4353 check_duplicates (b
);
4359 /* Set a breakpoint that will evaporate an end of command
4360 at address specified by SAL.
4361 Restrict it to frame FRAME if FRAME is nonzero. */
4364 set_momentary_breakpoint (struct symtab_and_line sal
, struct frame_info
*frame
,
4367 register struct breakpoint
*b
;
4368 b
= set_raw_breakpoint (sal
, type
);
4369 b
->enable
= enabled
;
4370 b
->disposition
= donttouch
;
4371 b
->frame
= (frame
? frame
->frame
: 0);
4373 /* If we're debugging a multi-threaded program, then we
4374 want momentary breakpoints to be active in only a
4375 single thread of control. */
4376 if (in_thread_list (inferior_ptid
))
4377 b
->thread
= pid_to_thread_id (inferior_ptid
);
4383 /* Tell the user we have just set a breakpoint B. */
4386 mention (struct breakpoint
*b
)
4390 struct cleanup
*old_chain
;
4391 struct ui_stream
*stb
;
4393 stb
= ui_out_stream_new (uiout
);
4394 old_chain
= make_cleanup_ui_out_stream_delete (stb
);
4397 /* FIXME: This is misplaced; mention() is called by things (like hitting a
4398 watchpoint) other than breakpoint creation. It should be possible to
4399 clean this up and at the same time replace the random calls to
4400 breakpoint_changed with this hook, as has already been done for
4401 delete_breakpoint_hook and so on. */
4402 if (create_breakpoint_hook
)
4403 create_breakpoint_hook (b
);
4404 breakpoint_create_event (b
->number
);
4409 printf_filtered ("(apparently deleted?) Eventpoint %d: ", b
->number
);
4413 ui_out_text (uiout
, "Watchpoint ");
4414 ui_out_tuple_begin (uiout
, "wpt");
4415 ui_out_field_int (uiout
, "number", b
->number
);
4416 ui_out_text (uiout
, ": ");
4417 print_expression (b
->exp
, stb
->stream
);
4418 ui_out_field_stream (uiout
, "exp", stb
);
4419 ui_out_tuple_end (uiout
);
4421 case bp_hardware_watchpoint
:
4422 ui_out_text (uiout
, "Hardware watchpoint ");
4423 ui_out_tuple_begin (uiout
, "wpt");
4424 ui_out_field_int (uiout
, "number", b
->number
);
4425 ui_out_text (uiout
, ": ");
4426 print_expression (b
->exp
, stb
->stream
);
4427 ui_out_field_stream (uiout
, "exp", stb
);
4428 ui_out_tuple_end (uiout
);
4432 printf_filtered ("Watchpoint %d: ", b
->number
);
4433 print_expression (b
->exp
, gdb_stdout
);
4435 case bp_hardware_watchpoint
:
4436 printf_filtered ("Hardware watchpoint %d: ", b
->number
);
4437 print_expression (b
->exp
, gdb_stdout
);
4441 case bp_read_watchpoint
:
4442 ui_out_text (uiout
, "Hardware read watchpoint ");
4443 ui_out_tuple_begin (uiout
, "hw-rwpt");
4444 ui_out_field_int (uiout
, "number", b
->number
);
4445 ui_out_text (uiout
, ": ");
4446 print_expression (b
->exp
, stb
->stream
);
4447 ui_out_field_stream (uiout
, "exp", stb
);
4448 ui_out_tuple_end (uiout
);
4450 case bp_access_watchpoint
:
4451 ui_out_text (uiout
, "Hardware access (read/write) watchpoint ");
4452 ui_out_tuple_begin (uiout
, "hw-awpt");
4453 ui_out_field_int (uiout
, "number", b
->number
);
4454 ui_out_text (uiout
, ": ");
4455 print_expression (b
->exp
, stb
->stream
);
4456 ui_out_field_stream (uiout
, "exp", stb
);
4457 ui_out_tuple_end (uiout
);
4460 case bp_read_watchpoint
:
4461 printf_filtered ("Hardware read watchpoint %d: ", b
->number
);
4462 print_expression (b
->exp
, gdb_stdout
);
4464 case bp_access_watchpoint
:
4465 printf_filtered ("Hardware access (read/write) watchpoint %d: ",
4467 print_expression (b
->exp
, gdb_stdout
);
4472 if (interpreter_p
&& strcmp (interpreter_p
, "mi") == 0)
4478 printf_filtered ("Breakpoint %d", b
->number
);
4481 case bp_hardware_breakpoint
:
4483 if (interpreter_p
&& strcmp (interpreter_p
, "mi") == 0)
4489 printf_filtered ("Hardware assisted breakpoint %d", b
->number
);
4493 case bp_catch_unload
:
4494 printf_filtered ("Catchpoint %d (%s %s)",
4496 (b
->type
== bp_catch_load
) ? "load" : "unload",
4497 (b
->dll_pathname
!= NULL
) ?
4498 b
->dll_pathname
: "<any library>");
4501 case bp_catch_vfork
:
4502 printf_filtered ("Catchpoint %d (%s)",
4504 (b
->type
== bp_catch_fork
) ? "fork" : "vfork");
4507 printf_filtered ("Catchpoint %d (exec)",
4510 case bp_catch_catch
:
4511 case bp_catch_throw
:
4512 printf_filtered ("Catchpoint %d (%s)",
4514 (b
->type
== bp_catch_catch
) ? "catch" : "throw");
4520 case bp_longjmp_resume
:
4521 case bp_step_resume
:
4522 case bp_through_sigtramp
:
4524 case bp_watchpoint_scope
:
4525 case bp_shlib_event
:
4526 case bp_thread_event
:
4531 if (addressprint
|| b
->source_file
== NULL
)
4533 printf_filtered (" at ");
4534 print_address_numeric (b
->address
, 1, gdb_stdout
);
4537 printf_filtered (": file %s, line %d.",
4538 b
->source_file
, b
->line_number
);
4539 TUIDO (((TuiOpaqueFuncPtr
) tui_vAllSetHasBreakAt
, b
, 1));
4540 TUIDO (((TuiOpaqueFuncPtr
) tuiUpdateAllExecInfos
));
4543 do_cleanups (old_chain
);
4546 if (interpreter_p
&& strcmp (interpreter_p
, "mi") == 0)
4549 printf_filtered ("\n");
4553 /* Add SALS.nelts breakpoints to the breakpoint table. For each
4554 SALS.sal[i] breakpoint, include the corresponding ADDR_STRING[i],
4555 COND[i] and COND_STRING[i] values.
4557 NOTE: If the function succeeds, the caller is expected to cleanup
4558 the arrays ADDR_STRING, COND_STRING, COND and SALS (but not the
4559 array contents). If the function fails (error() is called), the
4560 caller is expected to cleanups both the ADDR_STRING, COND_STRING,
4561 COND and SALS arrays and each of those arrays contents. */
4564 create_breakpoints (struct symtabs_and_lines sals
, char **addr_string
,
4565 struct expression
**cond
, char **cond_string
,
4566 enum bptype type
, enum bpdisp disposition
,
4567 int thread
, int ignore_count
, int from_tty
)
4569 if (type
== bp_hardware_breakpoint
)
4571 int i
= hw_breakpoint_used_count ();
4572 int target_resources_ok
=
4573 TARGET_CAN_USE_HARDWARE_WATCHPOINT (bp_hardware_breakpoint
,
4575 if (target_resources_ok
== 0)
4576 error ("No hardware breakpoint support in the target.");
4577 else if (target_resources_ok
< 0)
4578 error ("Hardware breakpoints used exceeds limit.");
4581 /* Now set all the breakpoints. */
4584 for (i
= 0; i
< sals
.nelts
; i
++)
4586 struct breakpoint
*b
;
4587 struct symtab_and_line sal
= sals
.sals
[i
];
4590 describe_other_breakpoints (sal
.pc
, sal
.section
);
4592 b
= set_raw_breakpoint (sal
, type
);
4593 set_breakpoint_count (breakpoint_count
+ 1);
4594 b
->number
= breakpoint_count
;
4597 b
->addr_string
= addr_string
[i
];
4598 b
->cond_string
= cond_string
[i
];
4599 b
->ignore_count
= ignore_count
;
4600 b
->enable
= enabled
;
4601 b
->disposition
= disposition
;
4607 /* Parse ARG which is assumed to be a SAL specification possibly
4608 followed by conditionals. On return, SALS contains an array of SAL
4609 addresses found. ADDR_STRING contains a vector of (canonical)
4610 address strings. ARG points to the end of the SAL. */
4613 parse_breakpoint_sals (char **address
,
4614 struct symtabs_and_lines
*sals
,
4615 char ***addr_string
)
4617 char *addr_start
= *address
;
4618 *addr_string
= NULL
;
4619 /* If no arg given, or if first arg is 'if ', use the default
4621 if ((*address
) == NULL
4622 || (strncmp ((*address
), "if", 2) == 0 && isspace ((*address
)[2])))
4624 if (default_breakpoint_valid
)
4626 struct symtab_and_line sal
;
4627 INIT_SAL (&sal
); /* initialize to zeroes */
4628 sals
->sals
= (struct symtab_and_line
*)
4629 xmalloc (sizeof (struct symtab_and_line
));
4630 sal
.pc
= default_breakpoint_address
;
4631 sal
.line
= default_breakpoint_line
;
4632 sal
.symtab
= default_breakpoint_symtab
;
4633 sal
.section
= find_pc_overlay (sal
.pc
);
4634 sals
->sals
[0] = sal
;
4638 error ("No default breakpoint address now.");
4642 /* Force almost all breakpoints to be in terms of the
4643 current_source_symtab (which is decode_line_1's default). This
4644 should produce the results we want almost all of the time while
4645 leaving default_breakpoint_* alone. */
4646 if (default_breakpoint_valid
4647 && (!current_source_symtab
4648 || (strchr ("+-", (*address
)[0]) != NULL
)))
4649 *sals
= decode_line_1 (address
, 1, default_breakpoint_symtab
,
4650 default_breakpoint_line
, addr_string
);
4652 *sals
= decode_line_1 (address
, 1, (struct symtab
*) NULL
, 0, addr_string
);
4654 /* For any SAL that didn't have a canonical string, fill one in. */
4655 if (sals
->nelts
> 0 && *addr_string
== NULL
)
4656 *addr_string
= xcalloc (sals
->nelts
, sizeof (char **));
4657 if (addr_start
!= (*address
))
4660 for (i
= 0; i
< sals
->nelts
; i
++)
4662 /* Add the string if not present. */
4663 if ((*addr_string
)[i
] == NULL
)
4664 (*addr_string
)[i
] = savestring (addr_start
, (*address
) - addr_start
);
4670 /* Convert each SAL into a real PC. Verify that the PC can be
4671 inserted as a breakpoint. If it can't throw an error. */
4674 breakpoint_sals_to_pc (struct symtabs_and_lines
*sals
,
4678 for (i
= 0; i
< sals
->nelts
; i
++)
4680 resolve_sal_pc (&sals
->sals
[i
]);
4682 /* It's possible for the PC to be nonzero, but still an illegal
4683 value on some targets.
4685 For example, on HP-UX if you start gdb, and before running the
4686 inferior you try to set a breakpoint on a shared library function
4687 "foo" where the inferior doesn't call "foo" directly but does
4688 pass its address to another function call, then we do find a
4689 minimal symbol for the "foo", but it's address is invalid.
4690 (Appears to be an index into a table that the loader sets up
4691 when the inferior is run.)
4693 Give the target a chance to bless sals.sals[i].pc before we
4694 try to make a breakpoint for it. */
4695 if (PC_REQUIRES_RUN_BEFORE_USE (sals
->sals
[i
].pc
))
4697 if (address
== NULL
)
4698 error ("Cannot break without a running program.");
4700 error ("Cannot break on %s without a running program.",
4706 /* Set a breakpoint according to ARG (function, linenum or *address)
4707 flag: first bit : 0 non-temporary, 1 temporary.
4708 second bit : 0 normal breakpoint, 1 hardware breakpoint. */
4711 break_command_1 (char *arg
, int flag
, int from_tty
)
4713 int tempflag
, hardwareflag
;
4714 struct symtabs_and_lines sals
;
4715 register struct expression
**cond
= 0;
4716 /* Pointers in arg to the start, and one past the end, of the
4718 char **cond_string
= (char **) NULL
;
4719 char *addr_start
= arg
;
4721 struct cleanup
*old_chain
;
4722 struct cleanup
*breakpoint_chain
= NULL
;
4725 int ignore_count
= 0;
4727 hardwareflag
= flag
& BP_HARDWAREFLAG
;
4728 tempflag
= flag
& BP_TEMPFLAG
;
4733 parse_breakpoint_sals (&arg
, &sals
, &addr_string
);
4738 /* Create a chain of things that always need to be cleaned up. */
4739 old_chain
= make_cleanup (null_cleanup
, 0);
4741 /* Make sure that all storage allocated to SALS gets freed. */
4742 make_cleanup (xfree
, sals
.sals
);
4744 /* Cleanup the addr_string array but not its contents. */
4745 make_cleanup (xfree
, addr_string
);
4747 /* Allocate space for all the cond expressions. */
4748 cond
= xcalloc (sals
.nelts
, sizeof (struct expression
*));
4749 make_cleanup (xfree
, cond
);
4751 /* Allocate space for all the cond strings. */
4752 cond_string
= xcalloc (sals
.nelts
, sizeof (char **));
4753 make_cleanup (xfree
, cond_string
);
4755 /* ----------------------------- SNIP -----------------------------
4756 Anything added to the cleanup chain beyond this point is assumed
4757 to be part of a breakpoint. If the breakpoint create succeeds
4758 then the memory is not reclaimed. */
4759 breakpoint_chain
= make_cleanup (null_cleanup
, 0);
4761 /* Mark the contents of the addr_string for cleanup. These go on
4762 the breakpoint_chain and only occure if the breakpoint create
4764 for (i
= 0; i
< sals
.nelts
; i
++)
4766 if (addr_string
[i
] != NULL
)
4767 make_cleanup (xfree
, addr_string
[i
]);
4770 /* Resolve all line numbers to PC's and verify that the addresses
4771 are ok for the target. */
4772 breakpoint_sals_to_pc (&sals
, addr_start
);
4774 /* Verify that condition can be parsed, before setting any
4775 breakpoints. Allocate a separate condition expression for each
4777 thread
= -1; /* No specific thread yet */
4778 for (i
= 0; i
< sals
.nelts
; i
++)
4785 char *cond_start
= NULL
;
4786 char *cond_end
= NULL
;
4787 while (*tok
== ' ' || *tok
== '\t')
4792 while (*end_tok
!= ' ' && *end_tok
!= '\t' && *end_tok
!= '\000')
4795 toklen
= end_tok
- tok
;
4797 if (toklen
>= 1 && strncmp (tok
, "if", toklen
) == 0)
4799 tok
= cond_start
= end_tok
+ 1;
4800 cond
[i
] = parse_exp_1 (&tok
, block_for_pc (sals
.sals
[i
].pc
), 0);
4801 make_cleanup (xfree
, cond
[i
]);
4803 cond_string
[i
] = savestring (cond_start
, cond_end
- cond_start
);
4804 make_cleanup (xfree
, cond_string
[i
]);
4806 else if (toklen
>= 1 && strncmp (tok
, "thread", toklen
) == 0)
4812 thread
= strtol (tok
, &tok
, 0);
4814 error ("Junk after thread keyword.");
4815 if (!valid_thread_id (thread
))
4816 error ("Unknown thread %d\n", thread
);
4819 error ("Junk at end of arguments.");
4823 create_breakpoints (sals
, addr_string
, cond
, cond_string
,
4824 hardwareflag
? bp_hardware_breakpoint
: bp_breakpoint
,
4825 tempflag
? del
: donttouch
,
4826 thread
, ignore_count
, from_tty
);
4830 warning ("Multiple breakpoints were set.");
4831 warning ("Use the \"delete\" command to delete unwanted breakpoints.");
4833 /* That's it. Discard the cleanups for data inserted into the
4835 discard_cleanups (breakpoint_chain
);
4836 /* But cleanup everything else. */
4837 do_cleanups (old_chain
);
4840 /* Set a breakpoint of TYPE/DISPOSITION according to ARG (function,
4841 linenum or *address) with COND and IGNORE_COUNT. */
4843 struct captured_breakpoint_args
4854 do_captured_breakpoint (void *data
)
4856 struct captured_breakpoint_args
*args
= data
;
4857 struct symtabs_and_lines sals
;
4858 register struct expression
**cond
;
4859 struct cleanup
*old_chain
;
4860 struct cleanup
*breakpoint_chain
= NULL
;
4867 /* Parse the source and lines spec. Delay check that the expression
4868 didn't contain trailing garbage until after cleanups are in
4872 address_end
= args
->address
;
4874 parse_breakpoint_sals (&address_end
, &sals
, &addr_string
);
4879 /* Create a chain of things at always need to be cleaned up. */
4880 old_chain
= make_cleanup (null_cleanup
, 0);
4882 /* Always have a addr_string array, even if it is empty. */
4883 make_cleanup (xfree
, addr_string
);
4885 /* Make sure that all storage allocated to SALS gets freed. */
4886 make_cleanup (xfree
, sals
.sals
);
4888 /* Allocate space for all the cond expressions. */
4889 cond
= xcalloc (sals
.nelts
, sizeof (struct expression
*));
4890 make_cleanup (xfree
, cond
);
4892 /* Allocate space for all the cond strings. */
4893 cond_string
= xcalloc (sals
.nelts
, sizeof (char **));
4894 make_cleanup (xfree
, cond_string
);
4896 /* ----------------------------- SNIP -----------------------------
4897 Anything added to the cleanup chain beyond this point is assumed
4898 to be part of a breakpoint. If the breakpoint create goes
4899 through then that memory is not cleaned up. */
4900 breakpoint_chain
= make_cleanup (null_cleanup
, 0);
4902 /* Mark the contents of the addr_string for cleanup. These go on
4903 the breakpoint_chain and only occure if the breakpoint create
4905 for (i
= 0; i
< sals
.nelts
; i
++)
4907 if (addr_string
[i
] != NULL
)
4908 make_cleanup (xfree
, addr_string
[i
]);
4911 /* Wait until now before checking for garbage at the end of the
4912 address. That way cleanups can take care of freeing any
4914 if (*address_end
!= '\0')
4915 error ("Garbage %s following breakpoint address", address_end
);
4917 /* Resolve all line numbers to PC's. */
4918 breakpoint_sals_to_pc (&sals
, args
->address
);
4920 /* Verify that conditions can be parsed, before setting any
4922 for (i
= 0; i
< sals
.nelts
; i
++)
4924 if (args
->condition
!= NULL
)
4926 char *tok
= args
->condition
;
4927 cond
[i
] = parse_exp_1 (&tok
, block_for_pc (sals
.sals
[i
].pc
), 0);
4929 error ("Garbage %s follows condition", tok
);
4930 make_cleanup (xfree
, cond
[i
]);
4931 cond_string
[i
] = xstrdup (args
->condition
);
4935 create_breakpoints (sals
, addr_string
, cond
, cond_string
,
4936 args
->hardwareflag
? bp_hardware_breakpoint
: bp_breakpoint
,
4937 args
->tempflag
? del
: donttouch
,
4938 args
->thread
, args
->ignore_count
, 0/*from-tty*/);
4940 /* That's it. Discard the cleanups for data inserted into the
4942 discard_cleanups (breakpoint_chain
);
4943 /* But cleanup everything else. */
4944 do_cleanups (old_chain
);
4949 gdb_breakpoint (char *address
, char *condition
,
4950 int hardwareflag
, int tempflag
,
4951 int thread
, int ignore_count
)
4953 struct captured_breakpoint_args args
;
4954 args
.address
= address
;
4955 args
.condition
= condition
;
4956 args
.hardwareflag
= hardwareflag
;
4957 args
.tempflag
= tempflag
;
4958 args
.thread
= thread
;
4959 args
.ignore_count
= ignore_count
;
4960 return catch_errors (do_captured_breakpoint
, &args
,
4961 NULL
, RETURN_MASK_ALL
);
4966 break_at_finish_at_depth_command_1 (char *arg
, int flag
, int from_tty
)
4968 struct frame_info
*frame
;
4969 CORE_ADDR low
, high
, selected_pc
= 0;
4970 char *extra_args
= NULL
;
4973 int extra_args_len
= 0, if_arg
= 0;
4976 (arg
[0] == 'i' && arg
[1] == 'f' && (arg
[2] == ' ' || arg
[2] == '\t')))
4979 if (default_breakpoint_valid
)
4983 selected_pc
= selected_frame
->pc
;
4988 error ("No selected frame.");
4991 error ("No default breakpoint address now.");
4995 extra_args
= strchr (arg
, ' ');
4999 extra_args_len
= strlen (extra_args
);
5000 level_arg
= (char *) xmalloc (extra_args
- arg
);
5001 strncpy (level_arg
, arg
, extra_args
- arg
- 1);
5002 level_arg
[extra_args
- arg
- 1] = '\0';
5006 level_arg
= (char *) xmalloc (strlen (arg
) + 1);
5007 strcpy (level_arg
, arg
);
5010 frame
= parse_frame_specification (level_arg
);
5012 selected_pc
= frame
->pc
;
5019 extra_args_len
= strlen (arg
);
5024 if (find_pc_partial_function (selected_pc
, (char **) NULL
, &low
, &high
))
5026 addr_string
= (char *) xmalloc (26 + extra_args_len
);
5028 sprintf (addr_string
, "*0x%s %s", paddr_nz (high
), extra_args
);
5030 sprintf (addr_string
, "*0x%s", paddr_nz (high
));
5031 break_command_1 (addr_string
, flag
, from_tty
);
5032 xfree (addr_string
);
5035 error ("No function contains the specified address");
5038 error ("Unable to set breakpoint at procedure exit");
5043 break_at_finish_command_1 (char *arg
, int flag
, int from_tty
)
5045 char *addr_string
, *break_string
, *beg_addr_string
;
5046 CORE_ADDR low
, high
;
5047 struct symtabs_and_lines sals
;
5048 struct symtab_and_line sal
;
5049 struct cleanup
*old_chain
;
5050 char *extra_args
= NULL
;
5051 int extra_args_len
= 0;
5055 (arg
[0] == 'i' && arg
[1] == 'f' && (arg
[2] == ' ' || arg
[2] == '\t')))
5057 if (default_breakpoint_valid
)
5061 addr_string
= (char *) xmalloc (15);
5062 sprintf (addr_string
, "*0x%s", paddr_nz (selected_frame
->pc
));
5067 error ("No selected frame.");
5070 error ("No default breakpoint address now.");
5074 addr_string
= (char *) xmalloc (strlen (arg
) + 1);
5075 strcpy (addr_string
, arg
);
5081 extra_args_len
= strlen (arg
);
5085 /* get the stuff after the function name or address */
5086 extra_args
= strchr (arg
, ' ');
5090 extra_args_len
= strlen (extra_args
);
5097 beg_addr_string
= addr_string
;
5098 sals
= decode_line_1 (&addr_string
, 1, (struct symtab
*) NULL
, 0,
5101 xfree (beg_addr_string
);
5102 old_chain
= make_cleanup (xfree
, sals
.sals
);
5103 for (i
= 0; (i
< sals
.nelts
); i
++)
5106 if (find_pc_partial_function (sal
.pc
, (char **) NULL
, &low
, &high
))
5108 break_string
= (char *) xmalloc (extra_args_len
+ 26);
5110 sprintf (break_string
, "*0x%s %s", paddr_nz (high
), extra_args
);
5112 sprintf (break_string
, "*0x%s", paddr_nz (high
));
5113 break_command_1 (break_string
, flag
, from_tty
);
5114 xfree (break_string
);
5117 error ("No function contains the specified address");
5121 warning ("Multiple breakpoints were set.\n");
5122 warning ("Use the \"delete\" command to delete unwanted breakpoints.");
5124 do_cleanups (old_chain
);
5128 /* Helper function for break_command_1 and disassemble_command. */
5131 resolve_sal_pc (struct symtab_and_line
*sal
)
5135 if (sal
->pc
== 0 && sal
->symtab
!= NULL
)
5137 if (!find_line_pc (sal
->symtab
, sal
->line
, &pc
))
5138 error ("No line %d in file \"%s\".",
5139 sal
->line
, sal
->symtab
->filename
);
5143 if (sal
->section
== 0 && sal
->symtab
!= NULL
)
5145 struct blockvector
*bv
;
5150 bv
= blockvector_for_pc_sect (sal
->pc
, 0, &index
, sal
->symtab
);
5153 b
= BLOCKVECTOR_BLOCK (bv
, index
);
5154 sym
= block_function (b
);
5157 fixup_symbol_section (sym
, sal
->symtab
->objfile
);
5158 sal
->section
= SYMBOL_BFD_SECTION (sym
);
5162 /* It really is worthwhile to have the section, so we'll just
5163 have to look harder. This case can be executed if we have
5164 line numbers but no functions (as can happen in assembly
5167 struct minimal_symbol
*msym
;
5169 msym
= lookup_minimal_symbol_by_pc (sal
->pc
);
5171 sal
->section
= SYMBOL_BFD_SECTION (msym
);
5178 break_command (char *arg
, int from_tty
)
5180 break_command_1 (arg
, 0, from_tty
);
5184 break_at_finish_command (char *arg
, int from_tty
)
5186 break_at_finish_command_1 (arg
, 0, from_tty
);
5190 break_at_finish_at_depth_command (char *arg
, int from_tty
)
5192 break_at_finish_at_depth_command_1 (arg
, 0, from_tty
);
5196 tbreak_command (char *arg
, int from_tty
)
5198 break_command_1 (arg
, BP_TEMPFLAG
, from_tty
);
5202 tbreak_at_finish_command (char *arg
, int from_tty
)
5204 break_at_finish_command_1 (arg
, BP_TEMPFLAG
, from_tty
);
5208 hbreak_command (char *arg
, int from_tty
)
5210 break_command_1 (arg
, BP_HARDWAREFLAG
, from_tty
);
5214 thbreak_command (char *arg
, int from_tty
)
5216 break_command_1 (arg
, (BP_TEMPFLAG
| BP_HARDWAREFLAG
), from_tty
);
5220 stop_command (char *arg
, int from_tty
)
5222 printf_filtered ("Specify the type of breakpoint to set.\n\
5223 Usage: stop in <function | address>\n\
5228 stopin_command (char *arg
, int from_tty
)
5232 if (arg
== (char *) NULL
)
5234 else if (*arg
!= '*')
5239 /* look for a ':'. If this is a line number specification, then
5240 say it is bad, otherwise, it should be an address or
5241 function/method name */
5242 while (*argptr
&& !hasColon
)
5244 hasColon
= (*argptr
== ':');
5249 badInput
= (*argptr
!= ':'); /* Not a class::method */
5251 badInput
= isdigit (*arg
); /* a simple line number */
5255 printf_filtered ("Usage: stop in <function | address>\n");
5257 break_command_1 (arg
, 0, from_tty
);
5261 stopat_command (char *arg
, int from_tty
)
5265 if (arg
== (char *) NULL
|| *arg
== '*') /* no line number */
5272 /* look for a ':'. If there is a '::' then get out, otherwise
5273 it is probably a line number. */
5274 while (*argptr
&& !hasColon
)
5276 hasColon
= (*argptr
== ':');
5281 badInput
= (*argptr
== ':'); /* we have class::method */
5283 badInput
= !isdigit (*arg
); /* not a line number */
5287 printf_filtered ("Usage: stop at <line>\n");
5289 break_command_1 (arg
, 0, from_tty
);
5293 /* accessflag: hw_write: watch write,
5294 hw_read: watch read,
5295 hw_access: watch access (read or write) */
5297 watch_command_1 (char *arg
, int accessflag
, int from_tty
)
5299 struct breakpoint
*b
;
5300 struct symtab_and_line sal
;
5301 struct expression
*exp
;
5302 struct block
*exp_valid_block
;
5303 struct value
*val
, *mark
;
5304 struct frame_info
*frame
;
5305 struct frame_info
*prev_frame
= NULL
;
5306 char *exp_start
= NULL
;
5307 char *exp_end
= NULL
;
5308 char *tok
, *end_tok
;
5310 char *cond_start
= NULL
;
5311 char *cond_end
= NULL
;
5312 struct expression
*cond
= NULL
;
5313 int i
, other_type_used
, target_resources_ok
= 0;
5314 enum bptype bp_type
;
5317 INIT_SAL (&sal
); /* initialize to zeroes */
5319 /* Parse arguments. */
5320 innermost_block
= NULL
;
5322 exp
= parse_exp_1 (&arg
, 0, 0);
5324 exp_valid_block
= innermost_block
;
5325 mark
= value_mark ();
5326 val
= evaluate_expression (exp
);
5327 release_value (val
);
5328 if (VALUE_LAZY (val
))
5329 value_fetch_lazy (val
);
5332 while (*tok
== ' ' || *tok
== '\t')
5336 while (*end_tok
!= ' ' && *end_tok
!= '\t' && *end_tok
!= '\000')
5339 toklen
= end_tok
- tok
;
5340 if (toklen
>= 1 && strncmp (tok
, "if", toklen
) == 0)
5342 tok
= cond_start
= end_tok
+ 1;
5343 cond
= parse_exp_1 (&tok
, 0, 0);
5347 error ("Junk at end of command.");
5349 if (accessflag
== hw_read
)
5350 bp_type
= bp_read_watchpoint
;
5351 else if (accessflag
== hw_access
)
5352 bp_type
= bp_access_watchpoint
;
5354 bp_type
= bp_hardware_watchpoint
;
5356 mem_cnt
= can_use_hardware_watchpoint (val
);
5357 if (mem_cnt
== 0 && bp_type
!= bp_hardware_watchpoint
)
5358 error ("Expression cannot be implemented with read/access watchpoint.");
5361 i
= hw_watchpoint_used_count (bp_type
, &other_type_used
);
5362 target_resources_ok
=
5363 TARGET_CAN_USE_HARDWARE_WATCHPOINT (bp_type
, i
+ mem_cnt
,
5365 if (target_resources_ok
== 0 && bp_type
!= bp_hardware_watchpoint
)
5366 error ("Target does not support this type of hardware watchpoint.");
5368 if (target_resources_ok
< 0 && bp_type
!= bp_hardware_watchpoint
)
5369 error ("Target can only support one kind of HW watchpoint at a time.");
5372 #if defined(HPUXHPPA)
5373 /* On HP-UX if you set a h/w
5374 watchpoint before the "run" command, the inferior dies with a e.g.,
5375 SIGILL once you start it. I initially believed this was due to a
5376 bad interaction between page protection traps and the initial
5377 startup sequence by the dynamic linker.
5379 However, I tried avoiding that by having HP-UX's implementation of
5380 TARGET_CAN_USE_HW_WATCHPOINT return FALSE if there was no inferior_ptid
5381 yet, which forced slow watches before a "run" or "attach", and it
5382 still fails somewhere in the startup code.
5384 Until I figure out what's happening, I'm disallowing watches altogether
5385 before the "run" or "attach" command. We'll tell the user they must
5386 set watches after getting the program started. */
5387 if (!target_has_execution
)
5389 warning ("can't do that without a running program; try \"break main\", \"run\" first");
5392 #endif /* HPUXHPPA */
5394 /* Change the type of breakpoint to an ordinary watchpoint if a hardware
5395 watchpoint could not be set. */
5396 if (!mem_cnt
|| target_resources_ok
<= 0)
5397 bp_type
= bp_watchpoint
;
5399 /* Now set up the breakpoint. */
5400 b
= set_raw_breakpoint (sal
, bp_type
);
5401 set_breakpoint_count (breakpoint_count
+ 1);
5402 b
->number
= breakpoint_count
;
5403 b
->disposition
= donttouch
;
5405 b
->exp_valid_block
= exp_valid_block
;
5406 b
->exp_string
= savestring (exp_start
, exp_end
- exp_start
);
5410 b
->cond_string
= savestring (cond_start
, cond_end
- cond_start
);
5414 frame
= block_innermost_frame (exp_valid_block
);
5417 prev_frame
= get_prev_frame (frame
);
5418 b
->watchpoint_frame
= frame
->frame
;
5421 b
->watchpoint_frame
= (CORE_ADDR
) 0;
5423 /* If the expression is "local", then set up a "watchpoint scope"
5424 breakpoint at the point where we've left the scope of the watchpoint
5426 if (innermost_block
)
5430 struct breakpoint
*scope_breakpoint
;
5431 struct symtab_and_line scope_sal
;
5433 INIT_SAL (&scope_sal
); /* initialize to zeroes */
5434 scope_sal
.pc
= get_frame_pc (prev_frame
);
5435 scope_sal
.section
= find_pc_overlay (scope_sal
.pc
);
5437 scope_breakpoint
= set_raw_breakpoint (scope_sal
,
5438 bp_watchpoint_scope
);
5439 set_breakpoint_count (breakpoint_count
+ 1);
5440 scope_breakpoint
->number
= breakpoint_count
;
5442 scope_breakpoint
->enable
= enabled
;
5444 /* Automatically delete the breakpoint when it hits. */
5445 scope_breakpoint
->disposition
= del
;
5447 /* Only break in the proper frame (help with recursion). */
5448 scope_breakpoint
->frame
= prev_frame
->frame
;
5450 /* Set the address at which we will stop. */
5451 scope_breakpoint
->address
= get_frame_pc (prev_frame
);
5453 /* The scope breakpoint is related to the watchpoint. We
5454 will need to act on them together. */
5455 b
->related_breakpoint
= scope_breakpoint
;
5458 value_free_to_mark (mark
);
5462 /* Return count of locations need to be watched and can be handled
5463 in hardware. If the watchpoint can not be handled
5464 in hardware return zero. */
5466 #if !defined(TARGET_REGION_SIZE_OK_FOR_HW_WATCHPOINT)
5467 #define TARGET_REGION_SIZE_OK_FOR_HW_WATCHPOINT(BYTE_SIZE) \
5468 ((BYTE_SIZE) <= (REGISTER_SIZE))
5471 #if !defined(TARGET_REGION_OK_FOR_HW_WATCHPOINT)
5472 #define TARGET_REGION_OK_FOR_HW_WATCHPOINT(ADDR,LEN) \
5473 (TARGET_REGION_SIZE_OK_FOR_HW_WATCHPOINT(LEN))
5477 can_use_hardware_watchpoint (struct value
*v
)
5479 int found_memory_cnt
= 0;
5480 struct value
*head
= v
;
5482 /* Did the user specifically forbid us to use hardware watchpoints? */
5483 if (!can_use_hw_watchpoints
)
5486 /* Make sure that the value of the expression depends only upon
5487 memory contents, and values computed from them within GDB. If we
5488 find any register references or function calls, we can't use a
5489 hardware watchpoint.
5491 The idea here is that evaluating an expression generates a series
5492 of values, one holding the value of every subexpression. (The
5493 expression a*b+c has five subexpressions: a, b, a*b, c, and
5494 a*b+c.) GDB's values hold almost enough information to establish
5495 the criteria given above --- they identify memory lvalues,
5496 register lvalues, computed values, etcetera. So we can evaluate
5497 the expression, and then scan the chain of values that leaves
5498 behind to decide whether we can detect any possible change to the
5499 expression's final value using only hardware watchpoints.
5501 However, I don't think that the values returned by inferior
5502 function calls are special in any way. So this function may not
5503 notice that an expression involving an inferior function call
5504 can't be watched with hardware watchpoints. FIXME. */
5505 for (; v
; v
= v
->next
)
5507 if (VALUE_LVAL (v
) == lval_memory
)
5510 /* A lazy memory lvalue is one that GDB never needed to fetch;
5511 we either just used its address (e.g., `a' in `a.b') or
5512 we never needed it at all (e.g., `a' in `a,b'). */
5516 /* Ahh, memory we actually used! Check if we can cover
5517 it with hardware watchpoints. */
5518 struct type
*vtype
= check_typedef (VALUE_TYPE (v
));
5520 /* We only watch structs and arrays if user asked for it
5521 explicitly, never if they just happen to appear in a
5522 middle of some value chain. */
5524 || (TYPE_CODE (vtype
) != TYPE_CODE_STRUCT
5525 && TYPE_CODE (vtype
) != TYPE_CODE_ARRAY
))
5527 CORE_ADDR vaddr
= VALUE_ADDRESS (v
) + VALUE_OFFSET (v
);
5528 int len
= TYPE_LENGTH (VALUE_TYPE (v
));
5530 if (!TARGET_REGION_OK_FOR_HW_WATCHPOINT (vaddr
, len
))
5537 else if (v
->lval
!= not_lval
&& v
->modifiable
== 0)
5538 return 0; /* ??? What does this represent? */
5539 else if (v
->lval
== lval_register
)
5540 return 0; /* cannot watch a register with a HW watchpoint */
5543 /* The expression itself looks suitable for using a hardware
5544 watchpoint, but give the target machine a chance to reject it. */
5545 return found_memory_cnt
;
5550 watch_command_wrapper (char *arg
, int from_tty
)
5552 watch_command (arg
, from_tty
);
5556 watch_command (char *arg
, int from_tty
)
5558 watch_command_1 (arg
, hw_write
, from_tty
);
5563 rwatch_command_wrapper (char *arg
, int from_tty
)
5565 rwatch_command (arg
, from_tty
);
5569 rwatch_command (char *arg
, int from_tty
)
5571 watch_command_1 (arg
, hw_read
, from_tty
);
5576 awatch_command_wrapper (char *arg
, int from_tty
)
5578 awatch_command (arg
, from_tty
);
5582 awatch_command (char *arg
, int from_tty
)
5584 watch_command_1 (arg
, hw_access
, from_tty
);
5588 /* Helper routines for the until_command routine in infcmd.c. Here
5589 because it uses the mechanisms of breakpoints. */
5591 /* This function is called by fetch_inferior_event via the
5592 cmd_continuation pointer, to complete the until command. It takes
5593 care of cleaning up the temporary breakpoints set up by the until
5596 until_break_command_continuation (struct continuation_arg
*arg
)
5598 struct cleanup
*cleanups
;
5600 cleanups
= (struct cleanup
*) arg
->data
.pointer
;
5601 do_exec_cleanups (cleanups
);
5606 until_break_command (char *arg
, int from_tty
)
5608 struct symtabs_and_lines sals
;
5609 struct symtab_and_line sal
;
5610 struct frame_info
*prev_frame
= get_prev_frame (selected_frame
);
5611 struct breakpoint
*breakpoint
;
5612 struct cleanup
*old_chain
;
5613 struct continuation_arg
*arg1
;
5616 clear_proceed_status ();
5618 /* Set a breakpoint where the user wants it and at return from
5621 if (default_breakpoint_valid
)
5622 sals
= decode_line_1 (&arg
, 1, default_breakpoint_symtab
,
5623 default_breakpoint_line
, (char ***) NULL
);
5625 sals
= decode_line_1 (&arg
, 1, (struct symtab
*) NULL
,
5626 0, (char ***) NULL
);
5628 if (sals
.nelts
!= 1)
5629 error ("Couldn't get information on specified line.");
5632 xfree (sals
.sals
); /* malloc'd, so freed */
5635 error ("Junk at end of arguments.");
5637 resolve_sal_pc (&sal
);
5639 breakpoint
= set_momentary_breakpoint (sal
, selected_frame
, bp_until
);
5641 if (!event_loop_p
|| !target_can_async_p ())
5642 old_chain
= make_cleanup_delete_breakpoint (breakpoint
);
5644 old_chain
= make_exec_cleanup_delete_breakpoint (breakpoint
);
5646 /* If we are running asynchronously, and the target supports async
5647 execution, we are not waiting for the target to stop, in the call
5648 tp proceed, below. This means that we cannot delete the
5649 brekpoints until the target has actually stopped. The only place
5650 where we get a chance to do that is in fetch_inferior_event, so
5651 we must set things up for that. */
5653 if (event_loop_p
&& target_can_async_p ())
5655 /* In this case the arg for the continuation is just the point
5656 in the exec_cleanups chain from where to start doing
5657 cleanups, because all the continuation does is the cleanups in
5658 the exec_cleanup_chain. */
5660 (struct continuation_arg
*) xmalloc (sizeof (struct continuation_arg
));
5662 arg1
->data
.pointer
= old_chain
;
5664 add_continuation (until_break_command_continuation
, arg1
);
5667 /* Keep within the current frame */
5671 sal
= find_pc_line (prev_frame
->pc
, 0);
5672 sal
.pc
= prev_frame
->pc
;
5673 breakpoint
= set_momentary_breakpoint (sal
, prev_frame
, bp_until
);
5674 if (!event_loop_p
|| !target_can_async_p ())
5675 make_cleanup_delete_breakpoint (breakpoint
);
5677 make_exec_cleanup_delete_breakpoint (breakpoint
);
5680 proceed (-1, TARGET_SIGNAL_DEFAULT
, 0);
5681 /* Do the cleanups now, anly if we are not running asynchronously,
5682 of if we are, but the target is still synchronous. */
5683 if (!event_loop_p
|| !target_can_async_p ())
5684 do_cleanups (old_chain
);
5688 /* These aren't used; I don't konw what they were for. */
5689 /* Set a breakpoint at the catch clause for NAME. */
5691 catch_breakpoint (char *name
)
5696 disable_catch_breakpoint (void)
5701 delete_catch_breakpoint (void)
5706 enable_catch_breakpoint (void)
5713 struct sal_chain
*next
;
5714 struct symtab_and_line sal
;
5718 /* Not really used -- invocation in handle_gnu_4_16_catch_command
5719 had been commented out in the v.4.16 sources, and stays
5720 disabled there now because "catch NAME" syntax isn't allowed.
5722 /* This isn't used; I don't know what it was for. */
5723 /* For each catch clause identified in ARGS, run FUNCTION
5724 with that clause as an argument. */
5725 static struct symtabs_and_lines
5726 map_catch_names (char *args
, int (*function
) ())
5728 register char *p
= args
;
5730 struct symtabs_and_lines sals
;
5732 struct sal_chain
*sal_chain
= 0;
5736 error_no_arg ("one or more catch names");
5744 /* Don't swallow conditional part. */
5745 if (p1
[0] == 'i' && p1
[1] == 'f'
5746 && (p1
[2] == ' ' || p1
[2] == '\t'))
5752 while (isalnum (*p1
) || *p1
== '_' || *p1
== '$')
5756 if (*p1
&& *p1
!= ' ' && *p1
!= '\t')
5757 error ("Arguments must be catch names.");
5763 struct sal_chain
*next
= (struct sal_chain
*)
5764 alloca (sizeof (struct sal_chain
));
5765 next
->next
= sal_chain
;
5766 next
->sal
= get_catch_sal (p
);
5771 printf_unfiltered ("No catch clause for exception %s.\n", p
);
5776 while (*p
== ' ' || *p
== '\t')
5782 /* This shares a lot of code with `print_frame_label_vars' from stack.c. */
5784 static struct symtabs_and_lines
5785 get_catch_sals (int this_level_only
)
5787 register struct blockvector
*bl
;
5788 register struct block
*block
;
5789 int index
, have_default
= 0;
5791 struct symtabs_and_lines sals
;
5792 struct sal_chain
*sal_chain
= 0;
5793 char *blocks_searched
;
5795 /* Not sure whether an error message is always the correct response,
5796 but it's better than a core dump. */
5797 if (selected_frame
== NULL
)
5798 error ("No selected frame.");
5799 block
= get_frame_block (selected_frame
);
5800 pc
= selected_frame
->pc
;
5806 error ("No symbol table info available.\n");
5808 bl
= blockvector_for_pc (BLOCK_END (block
) - 4, &index
);
5809 blocks_searched
= (char *) alloca (BLOCKVECTOR_NBLOCKS (bl
) * sizeof (char));
5810 memset (blocks_searched
, 0, BLOCKVECTOR_NBLOCKS (bl
) * sizeof (char));
5814 CORE_ADDR end
= BLOCK_END (block
) - 4;
5817 if (bl
!= blockvector_for_pc (end
, &index
))
5818 error ("blockvector blotch");
5819 if (BLOCKVECTOR_BLOCK (bl
, index
) != block
)
5820 error ("blockvector botch");
5821 last_index
= BLOCKVECTOR_NBLOCKS (bl
);
5824 /* Don't print out blocks that have gone by. */
5825 while (index
< last_index
5826 && BLOCK_END (BLOCKVECTOR_BLOCK (bl
, index
)) < pc
)
5829 while (index
< last_index
5830 && BLOCK_END (BLOCKVECTOR_BLOCK (bl
, index
)) < end
)
5832 if (blocks_searched
[index
] == 0)
5834 struct block
*b
= BLOCKVECTOR_BLOCK (bl
, index
);
5837 register struct symbol
*sym
;
5839 nsyms
= BLOCK_NSYMS (b
);
5841 for (i
= 0; i
< nsyms
; i
++)
5843 sym
= BLOCK_SYM (b
, i
);
5844 if (STREQ (SYMBOL_NAME (sym
), "default"))
5850 if (SYMBOL_CLASS (sym
) == LOC_LABEL
)
5852 struct sal_chain
*next
= (struct sal_chain
*)
5853 alloca (sizeof (struct sal_chain
));
5854 next
->next
= sal_chain
;
5855 next
->sal
= find_pc_line (SYMBOL_VALUE_ADDRESS (sym
),
5860 blocks_searched
[index
] = 1;
5866 if (sal_chain
&& this_level_only
)
5869 /* After handling the function's top-level block, stop.
5870 Don't continue to its superblock, the block of
5871 per-file symbols. */
5872 if (BLOCK_FUNCTION (block
))
5874 block
= BLOCK_SUPERBLOCK (block
);
5879 struct sal_chain
*tmp_chain
;
5881 /* Count the number of entries. */
5882 for (index
= 0, tmp_chain
= sal_chain
; tmp_chain
;
5883 tmp_chain
= tmp_chain
->next
)
5887 sals
.sals
= (struct symtab_and_line
*)
5888 xmalloc (index
* sizeof (struct symtab_and_line
));
5889 for (index
= 0; sal_chain
; sal_chain
= sal_chain
->next
, index
++)
5890 sals
.sals
[index
] = sal_chain
->sal
;
5897 ep_skip_leading_whitespace (char **s
)
5899 if ((s
== NULL
) || (*s
== NULL
))
5901 while (isspace (**s
))
5905 /* This function examines a string, and attempts to find a token
5906 that might be an event name in the leading characters. If a
5907 possible match is found, a pointer to the last character of
5908 the token is returned. Else, NULL is returned. */
5911 ep_find_event_name_end (char *arg
)
5914 char *event_name_end
= NULL
;
5916 /* If we could depend upon the presense of strrpbrk, we'd use that... */
5920 /* We break out of the loop when we find a token delimiter.
5921 Basically, we're looking for alphanumerics and underscores;
5922 anything else delimites the token. */
5925 if (!isalnum (*s
) && (*s
!= '_'))
5931 return event_name_end
;
5935 /* This function attempts to parse an optional "if <cond>" clause
5936 from the arg string. If one is not found, it returns NULL.
5938 Else, it returns a pointer to the condition string. (It does not
5939 attempt to evaluate the string against a particular block.) And,
5940 it updates arg to point to the first character following the parsed
5941 if clause in the arg string. */
5944 ep_parse_optional_if_clause (char **arg
)
5948 if (((*arg
)[0] != 'i') || ((*arg
)[1] != 'f') || !isspace ((*arg
)[2]))
5951 /* Skip the "if" keyword. */
5954 /* Skip any extra leading whitespace, and record the start of the
5955 condition string. */
5956 ep_skip_leading_whitespace (arg
);
5959 /* Assume that the condition occupies the remainder of the arg string. */
5960 (*arg
) += strlen (cond_string
);
5965 /* This function attempts to parse an optional filename from the arg
5966 string. If one is not found, it returns NULL.
5968 Else, it returns a pointer to the parsed filename. (This function
5969 makes no attempt to verify that a file of that name exists, or is
5970 accessible.) And, it updates arg to point to the first character
5971 following the parsed filename in the arg string.
5973 Note that clients needing to preserve the returned filename for
5974 future access should copy it to their own buffers. */
5976 ep_parse_optional_filename (char **arg
)
5978 static char filename
[1024];
5983 if ((*arg_p
== '\0') || isspace (*arg_p
))
6001 /* Commands to deal with catching events, such as signals, exceptions,
6002 process start/exit, etc. */
6006 catch_fork
, catch_vfork
6010 #if defined(CHILD_INSERT_FORK_CATCHPOINT) || defined(CHILD_INSERT_VFORK_CATCHPOINT)
6011 static void catch_fork_command_1 (catch_fork_kind fork_kind
,
6012 char *arg
, int tempflag
, int from_tty
);
6015 catch_fork_command_1 (catch_fork_kind fork_kind
, char *arg
, int tempflag
,
6018 char *cond_string
= NULL
;
6020 ep_skip_leading_whitespace (&arg
);
6022 /* The allowed syntax is:
6024 catch [v]fork if <cond>
6026 First, check if there's an if clause. */
6027 cond_string
= ep_parse_optional_if_clause (&arg
);
6029 if ((*arg
!= '\0') && !isspace (*arg
))
6030 error ("Junk at end of arguments.");
6032 /* If this target supports it, create a fork or vfork catchpoint
6033 and enable reporting of such events. */
6037 create_fork_event_catchpoint (tempflag
, cond_string
);
6040 create_vfork_event_catchpoint (tempflag
, cond_string
);
6043 error ("unsupported or unknown fork kind; cannot catch it");
6049 #if defined(CHILD_INSERT_EXEC_CATCHPOINT)
6051 catch_exec_command_1 (char *arg
, int tempflag
, int from_tty
)
6053 char *cond_string
= NULL
;
6055 ep_skip_leading_whitespace (&arg
);
6057 /* The allowed syntax is:
6059 catch exec if <cond>
6061 First, check if there's an if clause. */
6062 cond_string
= ep_parse_optional_if_clause (&arg
);
6064 if ((*arg
!= '\0') && !isspace (*arg
))
6065 error ("Junk at end of arguments.");
6067 /* If this target supports it, create an exec catchpoint
6068 and enable reporting of such events. */
6069 create_exec_event_catchpoint (tempflag
, cond_string
);
6073 #if defined(SOLIB_ADD)
6075 catch_load_command_1 (char *arg
, int tempflag
, int from_tty
)
6077 char *dll_pathname
= NULL
;
6078 char *cond_string
= NULL
;
6080 ep_skip_leading_whitespace (&arg
);
6082 /* The allowed syntax is:
6084 catch load if <cond>
6085 catch load <filename>
6086 catch load <filename> if <cond>
6088 The user is not allowed to specify the <filename> after an
6091 We'll ignore the pathological case of a file named "if".
6093 First, check if there's an if clause. If so, then there
6094 cannot be a filename. */
6095 cond_string
= ep_parse_optional_if_clause (&arg
);
6097 /* If there was an if clause, then there cannot be a filename.
6098 Else, there might be a filename and an if clause. */
6099 if (cond_string
== NULL
)
6101 dll_pathname
= ep_parse_optional_filename (&arg
);
6102 ep_skip_leading_whitespace (&arg
);
6103 cond_string
= ep_parse_optional_if_clause (&arg
);
6106 if ((*arg
!= '\0') && !isspace (*arg
))
6107 error ("Junk at end of arguments.");
6109 /* Create a load breakpoint that only triggers when a load of
6110 the specified dll (or any dll, if no pathname was specified)
6112 SOLIB_CREATE_CATCH_LOAD_HOOK (PIDGET (inferior_ptid
), tempflag
,
6113 dll_pathname
, cond_string
);
6117 catch_unload_command_1 (char *arg
, int tempflag
, int from_tty
)
6119 char *dll_pathname
= NULL
;
6120 char *cond_string
= NULL
;
6122 ep_skip_leading_whitespace (&arg
);
6124 /* The allowed syntax is:
6126 catch unload if <cond>
6127 catch unload <filename>
6128 catch unload <filename> if <cond>
6130 The user is not allowed to specify the <filename> after an
6133 We'll ignore the pathological case of a file named "if".
6135 First, check if there's an if clause. If so, then there
6136 cannot be a filename. */
6137 cond_string
= ep_parse_optional_if_clause (&arg
);
6139 /* If there was an if clause, then there cannot be a filename.
6140 Else, there might be a filename and an if clause. */
6141 if (cond_string
== NULL
)
6143 dll_pathname
= ep_parse_optional_filename (&arg
);
6144 ep_skip_leading_whitespace (&arg
);
6145 cond_string
= ep_parse_optional_if_clause (&arg
);
6148 if ((*arg
!= '\0') && !isspace (*arg
))
6149 error ("Junk at end of arguments.");
6151 /* Create an unload breakpoint that only triggers when an unload of
6152 the specified dll (or any dll, if no pathname was specified)
6154 SOLIB_CREATE_CATCH_UNLOAD_HOOK (PIDGET (inferior_ptid
), tempflag
,
6155 dll_pathname
, cond_string
);
6157 #endif /* SOLIB_ADD */
6159 /* Commands to deal with catching exceptions. */
6161 /* Set a breakpoint at the specified callback routine for an
6162 exception event callback */
6165 create_exception_catchpoint (int tempflag
, char *cond_string
,
6166 enum exception_event_kind ex_event
,
6167 struct symtab_and_line
*sal
)
6169 struct breakpoint
*b
;
6170 int thread
= -1; /* All threads. */
6173 if (!sal
) /* no exception support? */
6178 case EX_EVENT_THROW
:
6179 bptype
= bp_catch_throw
;
6181 case EX_EVENT_CATCH
:
6182 bptype
= bp_catch_catch
;
6184 default: /* error condition */
6185 error ("Internal error -- invalid catchpoint kind");
6188 b
= set_raw_breakpoint (*sal
, bptype
);
6189 set_breakpoint_count (breakpoint_count
+ 1);
6190 b
->number
= breakpoint_count
;
6192 b
->cond_string
= (cond_string
== NULL
) ?
6193 NULL
: savestring (cond_string
, strlen (cond_string
));
6195 b
->addr_string
= NULL
;
6196 b
->enable
= enabled
;
6197 b
->disposition
= tempflag
? del
: donttouch
;
6201 /* Deal with "catch catch" and "catch throw" commands */
6204 catch_exception_command_1 (enum exception_event_kind ex_event
, char *arg
,
6205 int tempflag
, int from_tty
)
6207 char *cond_string
= NULL
;
6208 struct symtab_and_line
*sal
= NULL
;
6210 ep_skip_leading_whitespace (&arg
);
6212 cond_string
= ep_parse_optional_if_clause (&arg
);
6214 if ((*arg
!= '\0') && !isspace (*arg
))
6215 error ("Junk at end of arguments.");
6217 if ((ex_event
!= EX_EVENT_THROW
) &&
6218 (ex_event
!= EX_EVENT_CATCH
))
6219 error ("Unsupported or unknown exception event; cannot catch it");
6221 /* See if we can find a callback routine */
6222 sal
= target_enable_exception_callback (ex_event
, 1);
6226 /* We have callbacks from the runtime system for exceptions.
6227 Set a breakpoint on the sal found, if no errors */
6228 if (sal
!= (struct symtab_and_line
*) -1)
6229 create_exception_catchpoint (tempflag
, cond_string
, ex_event
, sal
);
6231 return; /* something went wrong with setting up callbacks */
6235 /* No callbacks from runtime system for exceptions.
6236 Try GNU C++ exception breakpoints using labels in debug info. */
6237 if (ex_event
== EX_EVENT_CATCH
)
6239 handle_gnu_4_16_catch_command (arg
, tempflag
, from_tty
);
6241 else if (ex_event
== EX_EVENT_THROW
)
6243 /* Set a breakpoint on __raise_exception () */
6245 warning ("Unsupported with this platform/compiler combination.");
6246 warning ("Perhaps you can achieve the effect you want by setting");
6247 warning ("a breakpoint on __raise_exception().");
6252 /* Cover routine to allow wrapping target_enable_exception_catchpoints
6253 inside a catch_errors */
6256 cover_target_enable_exception_callback (PTR arg
)
6258 args_for_catchpoint_enable
*args
= arg
;
6259 struct symtab_and_line
*sal
;
6260 sal
= target_enable_exception_callback (args
->kind
, args
->enable
);
6263 else if (sal
== (struct symtab_and_line
*) -1)
6266 return 1; /*is valid */
6271 /* This is the original v.4.16 and earlier version of the
6272 catch_command_1() function. Now that other flavours of "catch"
6273 have been introduced, and since exception handling can be handled
6274 in other ways (through target ops) also, this is used only for the
6275 GNU C++ exception handling system.
6276 Note: Only the "catch" flavour of GDB 4.16 is handled here. The
6277 "catch NAME" is now no longer allowed in catch_command_1(). Also,
6278 there was no code in GDB 4.16 for "catch throw".
6280 Called from catch_exception_command_1 () */
6284 handle_gnu_4_16_catch_command (char *arg
, int tempflag
, int from_tty
)
6286 /* First, translate ARG into something we can deal with in terms
6289 struct symtabs_and_lines sals
;
6290 struct symtab_and_line sal
;
6291 register struct expression
*cond
= 0;
6292 register struct breakpoint
*b
;
6296 INIT_SAL (&sal
); /* initialize to zeroes */
6298 /* If no arg given, or if first arg is 'if ', all active catch clauses
6299 are breakpointed. */
6301 if (!arg
|| (arg
[0] == 'i' && arg
[1] == 'f'
6302 && (arg
[2] == ' ' || arg
[2] == '\t')))
6304 /* Grab all active catch clauses. */
6305 sals
= get_catch_sals (0);
6309 /* Grab selected catch clauses. */
6310 error ("catch NAME not implemented");
6313 /* Not sure why this code has been disabled. I'm leaving
6314 it disabled. We can never come here now anyway
6315 since we don't allow the "catch NAME" syntax.
6318 /* This isn't used; I don't know what it was for. */
6319 sals
= map_catch_names (arg
, catch_breakpoint
);
6327 for (i
= 0; i
< sals
.nelts
; i
++)
6329 resolve_sal_pc (&sals
.sals
[i
]);
6333 if (arg
[0] == 'i' && arg
[1] == 'f'
6334 && (arg
[2] == ' ' || arg
[2] == '\t'))
6335 cond
= parse_exp_1 ((arg
+= 2, &arg
),
6336 block_for_pc (sals
.sals
[i
].pc
), 0);
6338 error ("Junk at end of arguments.");
6343 for (i
= 0; i
< sals
.nelts
; i
++)
6348 describe_other_breakpoints (sal
.pc
, sal
.section
);
6350 /* Important -- this is an ordinary breakpoint. For platforms
6351 with callback support for exceptions,
6352 create_exception_catchpoint() will create special bp types
6353 (bp_catch_catch and bp_catch_throw), and there is code in
6354 insert_breakpoints() and elsewhere that depends on that. */
6355 b
= set_raw_breakpoint (sal
, bp_breakpoint
);
6356 set_breakpoint_count (breakpoint_count
+ 1);
6357 b
->number
= breakpoint_count
;
6360 b
->enable
= enabled
;
6361 b
->disposition
= tempflag
? del
: donttouch
;
6368 warning ("Multiple breakpoints were set.");
6369 warning ("Use the \"delete\" command to delete unwanted breakpoints.");
6375 /* This creates a temporary internal breakpoint
6376 just to placate infrun */
6377 static struct breakpoint
*
6378 create_temp_exception_breakpoint (CORE_ADDR pc
)
6380 struct symtab_and_line sal
;
6381 struct breakpoint
*b
;
6388 b
= set_raw_breakpoint (sal
, bp_breakpoint
);
6390 b
->disposition
= del
;
6391 b
->enable
= enabled
;
6393 b
->number
= internal_breakpoint_number
--;
6399 catch_command_1 (char *arg
, int tempflag
, int from_tty
)
6402 /* The first argument may be an event name, such as "start" or "load".
6403 If so, then handle it as such. If it doesn't match an event name,
6404 then attempt to interpret it as an exception name. (This latter is
6405 the v4.16-and-earlier GDB meaning of the "catch" command.)
6407 First, try to find the bounds of what might be an event name. */
6408 char *arg1_start
= arg
;
6412 if (arg1_start
== NULL
)
6414 /* Old behaviour was to use pre-v-4.16 syntax */
6415 /* catch_throw_command_1 (arg1_start, tempflag, from_tty); */
6417 /* Now, this is not allowed */
6418 error ("Catch requires an event name.");
6421 arg1_end
= ep_find_event_name_end (arg1_start
);
6422 if (arg1_end
== NULL
)
6423 error ("catch requires an event");
6424 arg1_length
= arg1_end
+ 1 - arg1_start
;
6426 /* Try to match what we found against known event names. */
6427 if (strncmp (arg1_start
, "signal", arg1_length
) == 0)
6429 error ("Catch of signal not yet implemented");
6431 else if (strncmp (arg1_start
, "catch", arg1_length
) == 0)
6433 catch_exception_command_1 (EX_EVENT_CATCH
, arg1_end
+ 1,
6434 tempflag
, from_tty
);
6436 else if (strncmp (arg1_start
, "throw", arg1_length
) == 0)
6438 catch_exception_command_1 (EX_EVENT_THROW
, arg1_end
+ 1,
6439 tempflag
, from_tty
);
6441 else if (strncmp (arg1_start
, "thread_start", arg1_length
) == 0)
6443 error ("Catch of thread_start not yet implemented");
6445 else if (strncmp (arg1_start
, "thread_exit", arg1_length
) == 0)
6447 error ("Catch of thread_exit not yet implemented");
6449 else if (strncmp (arg1_start
, "thread_join", arg1_length
) == 0)
6451 error ("Catch of thread_join not yet implemented");
6453 else if (strncmp (arg1_start
, "start", arg1_length
) == 0)
6455 error ("Catch of start not yet implemented");
6457 else if (strncmp (arg1_start
, "exit", arg1_length
) == 0)
6459 error ("Catch of exit not yet implemented");
6461 else if (strncmp (arg1_start
, "fork", arg1_length
) == 0)
6463 #if defined(CHILD_INSERT_FORK_CATCHPOINT)
6464 catch_fork_command_1 (catch_fork
, arg1_end
+ 1, tempflag
, from_tty
);
6466 error ("Catch of fork not yet implemented");
6469 else if (strncmp (arg1_start
, "vfork", arg1_length
) == 0)
6471 #if defined(CHILD_INSERT_VFORK_CATCHPOINT)
6472 catch_fork_command_1 (catch_vfork
, arg1_end
+ 1, tempflag
, from_tty
);
6474 error ("Catch of vfork not yet implemented");
6477 else if (strncmp (arg1_start
, "exec", arg1_length
) == 0)
6479 #if defined(CHILD_INSERT_EXEC_CATCHPOINT)
6480 catch_exec_command_1 (arg1_end
+ 1, tempflag
, from_tty
);
6482 error ("Catch of exec not yet implemented");
6485 else if (strncmp (arg1_start
, "load", arg1_length
) == 0)
6487 #if defined(SOLIB_ADD)
6488 catch_load_command_1 (arg1_end
+ 1, tempflag
, from_tty
);
6490 error ("Catch of load not implemented");
6493 else if (strncmp (arg1_start
, "unload", arg1_length
) == 0)
6495 #if defined(SOLIB_ADD)
6496 catch_unload_command_1 (arg1_end
+ 1, tempflag
, from_tty
);
6498 error ("Catch of load not implemented");
6501 else if (strncmp (arg1_start
, "stop", arg1_length
) == 0)
6503 error ("Catch of stop not yet implemented");
6506 /* This doesn't appear to be an event name */
6510 /* Pre-v.4.16 behaviour was to treat the argument
6511 as the name of an exception */
6512 /* catch_throw_command_1 (arg1_start, tempflag, from_tty); */
6513 /* Now this is not allowed */
6514 error ("Unknown event kind specified for catch");
6519 /* Used by the gui, could be made a worker for other things. */
6522 set_breakpoint_sal (struct symtab_and_line sal
)
6524 struct breakpoint
*b
;
6525 b
= set_raw_breakpoint (sal
, bp_breakpoint
);
6526 set_breakpoint_count (breakpoint_count
+ 1);
6527 b
->number
= breakpoint_count
;
6534 /* These aren't used; I don't know what they were for. */
6535 /* Disable breakpoints on all catch clauses described in ARGS. */
6537 disable_catch (char *args
)
6539 /* Map the disable command to catch clauses described in ARGS. */
6542 /* Enable breakpoints on all catch clauses described in ARGS. */
6544 enable_catch (char *args
)
6546 /* Map the disable command to catch clauses described in ARGS. */
6549 /* Delete breakpoints on all catch clauses in the active scope. */
6551 delete_catch (char *args
)
6553 /* Map the delete command to catch clauses described in ARGS. */
6558 catch_command (char *arg
, int from_tty
)
6560 catch_command_1 (arg
, 0, from_tty
);
6565 tcatch_command (char *arg
, int from_tty
)
6567 catch_command_1 (arg
, 1, from_tty
);
6572 clear_command (char *arg
, int from_tty
)
6574 register struct breakpoint
*b
, *b1
;
6576 struct symtabs_and_lines sals
;
6577 struct symtab_and_line sal
;
6578 register struct breakpoint
*found
;
6583 sals
= decode_line_spec (arg
, 1);
6588 sals
.sals
= (struct symtab_and_line
*)
6589 xmalloc (sizeof (struct symtab_and_line
));
6590 INIT_SAL (&sal
); /* initialize to zeroes */
6591 sal
.line
= default_breakpoint_line
;
6592 sal
.symtab
= default_breakpoint_symtab
;
6593 sal
.pc
= default_breakpoint_address
;
6594 if (sal
.symtab
== 0)
6595 error ("No source file specified.");
6603 /* For each line spec given, delete bps which correspond
6604 to it. We do this in two loops: the first loop looks at
6605 the initial bp(s) in the chain which should be deleted,
6606 the second goes down the rest of the chain looking ahead
6607 one so it can take those bps off the chain without messing
6611 for (i
= 0; i
< sals
.nelts
; i
++)
6613 /* If exact pc given, clear bpts at that pc.
6614 If line given (pc == 0), clear all bpts on specified line.
6615 If defaulting, clear all bpts on default line
6618 defaulting sal.pc != 0 tests to do
6623 1 0 <can't happen> */
6626 found
= (struct breakpoint
*) 0;
6629 while (breakpoint_chain
6630 /* Why don't we check here that this is not
6631 a watchpoint, etc., as we do below?
6632 I can't make it fail, but don't know
6633 what's stopping the failure: a watchpoint
6634 of the same address as "sal.pc" should
6635 wind up being deleted. */
6637 && (((sal
.pc
&& (breakpoint_chain
->address
== sal
.pc
)) &&
6638 (overlay_debugging
== 0 ||
6639 breakpoint_chain
->section
== sal
.section
))
6640 || ((default_match
|| (0 == sal
.pc
))
6641 && breakpoint_chain
->source_file
!= NULL
6642 && sal
.symtab
!= NULL
6643 && STREQ (breakpoint_chain
->source_file
, sal
.symtab
->filename
)
6644 && breakpoint_chain
->line_number
== sal
.line
)))
6647 b1
= breakpoint_chain
;
6648 breakpoint_chain
= b1
->next
;
6656 && b
->next
->type
!= bp_none
6657 && b
->next
->type
!= bp_watchpoint
6658 && b
->next
->type
!= bp_hardware_watchpoint
6659 && b
->next
->type
!= bp_read_watchpoint
6660 && b
->next
->type
!= bp_access_watchpoint
6661 && (((sal
.pc
&& (b
->next
->address
== sal
.pc
)) &&
6662 (overlay_debugging
== 0 ||
6663 b
->next
->section
== sal
.section
))
6664 || ((default_match
|| (0 == sal
.pc
))
6665 && b
->next
->source_file
!= NULL
6666 && sal
.symtab
!= NULL
6667 && STREQ (b
->next
->source_file
, sal
.symtab
->filename
)
6668 && b
->next
->line_number
== sal
.line
)))
6681 error ("No breakpoint at %s.", arg
);
6683 error ("No breakpoint at this line.");
6687 from_tty
= 1; /* Always report if deleted more than one */
6689 printf_unfiltered ("Deleted breakpoint%s ", found
->next
? "s" : "");
6690 breakpoints_changed ();
6694 printf_unfiltered ("%d ", found
->number
);
6696 delete_breakpoint (found
);
6700 putchar_unfiltered ('\n');
6705 /* Delete breakpoint in BS if they are `delete' breakpoints and
6706 all breakpoints that are marked for deletion, whether hit or not.
6707 This is called after any breakpoint is hit, or after errors. */
6710 breakpoint_auto_delete (bpstat bs
)
6712 struct breakpoint
*b
, *temp
;
6714 for (; bs
; bs
= bs
->next
)
6715 if (bs
->breakpoint_at
&& bs
->breakpoint_at
->disposition
== del
6717 delete_breakpoint (bs
->breakpoint_at
);
6719 ALL_BREAKPOINTS_SAFE (b
, temp
)
6721 if (b
->disposition
== del_at_next_stop
)
6722 delete_breakpoint (b
);
6726 /* Delete a breakpoint and clean up all traces of it in the data
6730 delete_breakpoint (struct breakpoint
*bpt
)
6732 register struct breakpoint
*b
;
6736 error ("Internal error (attempted to delete a NULL breakpoint)");
6739 /* Has this bp already been deleted? This can happen because multiple
6740 lists can hold pointers to bp's. bpstat lists are especial culprits.
6742 One example of this happening is a watchpoint's scope bp. When the
6743 scope bp triggers, we notice that the watchpoint is out of scope, and
6744 delete it. We also delete its scope bp. But the scope bp is marked
6745 "auto-deleting", and is already on a bpstat. That bpstat is then
6746 checked for auto-deleting bp's, which are deleted.
6748 A real solution to this problem might involve reference counts in bp's,
6749 and/or giving them pointers back to their referencing bpstat's, and
6750 teaching delete_breakpoint to only free a bp's storage when no more
6751 references were extent. A cheaper bandaid was chosen. */
6752 if (bpt
->type
== bp_none
)
6755 if (delete_breakpoint_hook
)
6756 delete_breakpoint_hook (bpt
);
6757 breakpoint_delete_event (bpt
->number
);
6760 remove_breakpoint (bpt
, mark_uninserted
);
6762 if (breakpoint_chain
== bpt
)
6763 breakpoint_chain
= bpt
->next
;
6765 /* If we have callback-style exception catchpoints, don't go through
6766 the adjustments to the C++ runtime library etc. if the inferior
6767 isn't actually running. target_enable_exception_callback for a
6768 null target ops vector gives an undesirable error message, so we
6769 check here and avoid it. Since currently (1997-09-17) only HP-UX aCC's
6770 exceptions are supported in this way, it's OK for now. FIXME */
6771 if (ep_is_exception_catchpoint (bpt
) && target_has_execution
)
6773 static char message1
[] = "Error in deleting catchpoint %d:\n";
6774 static char message
[sizeof (message1
) + 30];
6775 args_for_catchpoint_enable args
;
6777 /* Format possible error msg */
6778 sprintf (message
, message1
, bpt
->number
);
6779 args
.kind
= bpt
->type
== bp_catch_catch
?
6780 EX_EVENT_CATCH
: EX_EVENT_THROW
;
6782 catch_errors (cover_target_enable_exception_callback
, &args
,
6783 message
, RETURN_MASK_ALL
);
6790 b
->next
= bpt
->next
;
6794 /* Before turning off the visuals for the bp, check to see that
6795 there are no other bps at the same address. */
6802 clearIt
= (b
->address
!= bpt
->address
);
6809 TUIDO (((TuiOpaqueFuncPtr
) tui_vAllSetHasBreakAt
, bpt
, 0));
6810 TUIDO (((TuiOpaqueFuncPtr
) tuiUpdateAllExecInfos
));
6814 check_duplicates (bpt
);
6815 /* If this breakpoint was inserted, and there is another breakpoint
6816 at the same address, we need to insert the other breakpoint. */
6818 && bpt
->type
!= bp_hardware_watchpoint
6819 && bpt
->type
!= bp_read_watchpoint
6820 && bpt
->type
!= bp_access_watchpoint
6821 && bpt
->type
!= bp_catch_fork
6822 && bpt
->type
!= bp_catch_vfork
6823 && bpt
->type
!= bp_catch_exec
)
6826 if (b
->address
== bpt
->address
6827 && b
->section
== bpt
->section
6829 && b
->enable
!= disabled
6830 && b
->enable
!= shlib_disabled
6831 && b
->enable
!= call_disabled
)
6835 /* We should never reach this point if there is a permanent
6836 breakpoint at the same address as the one being deleted.
6837 If there is a permanent breakpoint somewhere, it should
6838 always be the only one inserted. */
6839 if (b
->enable
== permanent
)
6840 internal_error (__FILE__
, __LINE__
,
6841 "another breakpoint was inserted on top of "
6842 "a permanent breakpoint");
6844 if (b
->type
== bp_hardware_breakpoint
)
6845 val
= target_insert_hw_breakpoint (b
->address
, b
->shadow_contents
);
6847 val
= target_insert_breakpoint (b
->address
, b
->shadow_contents
);
6851 target_terminal_ours_for_output ();
6852 warning ("Cannot insert breakpoint %d:", b
->number
);
6853 memory_error (val
, b
->address
); /* which bombs us out */
6860 free_command_lines (&bpt
->commands
);
6863 if (bpt
->cond_string
!= NULL
)
6864 xfree (bpt
->cond_string
);
6865 if (bpt
->addr_string
!= NULL
)
6866 xfree (bpt
->addr_string
);
6867 if (bpt
->exp
!= NULL
)
6869 if (bpt
->exp_string
!= NULL
)
6870 xfree (bpt
->exp_string
);
6871 if (bpt
->val
!= NULL
)
6872 value_free (bpt
->val
);
6873 if (bpt
->source_file
!= NULL
)
6874 xfree (bpt
->source_file
);
6875 if (bpt
->dll_pathname
!= NULL
)
6876 xfree (bpt
->dll_pathname
);
6877 if (bpt
->triggered_dll_pathname
!= NULL
)
6878 xfree (bpt
->triggered_dll_pathname
);
6879 if (bpt
->exec_pathname
!= NULL
)
6880 xfree (bpt
->exec_pathname
);
6882 /* Be sure no bpstat's are pointing at it after it's been freed. */
6883 /* FIXME, how can we find all bpstat's?
6884 We just check stop_bpstat for now. */
6885 for (bs
= stop_bpstat
; bs
; bs
= bs
->next
)
6886 if (bs
->breakpoint_at
== bpt
)
6888 bs
->breakpoint_at
= NULL
;
6890 /* we'd call bpstat_clear_actions, but that free's stuff and due
6891 to the multiple pointers pointing to one item with no
6892 reference counts found anywhere through out the bpstat's (how
6893 do you spell fragile?), we don't want to free things twice --
6894 better a memory leak than a corrupt malloc pool! */
6895 bs
->commands
= NULL
;
6898 /* On the chance that someone will soon try again to delete this same
6899 bp, we mark it as deleted before freeing its storage. */
6900 bpt
->type
= bp_none
;
6906 do_delete_breakpoint_cleanup (void *b
)
6908 delete_breakpoint (b
);
6912 make_cleanup_delete_breakpoint (struct breakpoint
*b
)
6914 return make_cleanup (do_delete_breakpoint_cleanup
, b
);
6918 make_exec_cleanup_delete_breakpoint (struct breakpoint
*b
)
6920 return make_exec_cleanup (do_delete_breakpoint_cleanup
, b
);
6924 delete_command (char *arg
, int from_tty
)
6926 struct breakpoint
*b
, *temp
;
6930 int breaks_to_delete
= 0;
6932 /* Delete all breakpoints if no argument.
6933 Do not delete internal or call-dummy breakpoints, these
6934 have to be deleted with an explicit breakpoint number argument. */
6937 if (b
->type
!= bp_call_dummy
&&
6938 b
->type
!= bp_shlib_event
&&
6939 b
->type
!= bp_thread_event
&&
6941 breaks_to_delete
= 1;
6944 /* Ask user only if there are some breakpoints to delete. */
6946 || (breaks_to_delete
&& query ("Delete all breakpoints? ")))
6948 ALL_BREAKPOINTS_SAFE (b
, temp
)
6950 if (b
->type
!= bp_call_dummy
&&
6951 b
->type
!= bp_shlib_event
&&
6952 b
->type
!= bp_thread_event
&&
6954 delete_breakpoint (b
);
6959 map_breakpoint_numbers (arg
, delete_breakpoint
);
6962 /* Reset a breakpoint given it's struct breakpoint * BINT.
6963 The value we return ends up being the return value from catch_errors.
6964 Unused in this case. */
6967 breakpoint_re_set_one (PTR bint
)
6969 /* get past catch_errs */
6970 struct breakpoint
*b
= (struct breakpoint
*) bint
;
6973 struct symtabs_and_lines sals
;
6975 enum enable save_enable
;
6980 warning ("attempted to reset apparently deleted breakpoint #%d?",
6984 case bp_hardware_breakpoint
:
6986 case bp_catch_unload
:
6987 if (b
->addr_string
== NULL
)
6989 /* Anything without a string can't be re-set. */
6990 delete_breakpoint (b
);
6993 /* In case we have a problem, disable this breakpoint. We'll restore
6994 its status if we succeed. */
6995 save_enable
= b
->enable
;
6996 b
->enable
= disabled
;
6998 set_language (b
->language
);
6999 input_radix
= b
->input_radix
;
7001 sals
= decode_line_1 (&s
, 1, (struct symtab
*) NULL
, 0, (char ***) NULL
);
7002 for (i
= 0; i
< sals
.nelts
; i
++)
7004 resolve_sal_pc (&sals
.sals
[i
]);
7006 /* Reparse conditions, they might contain references to the
7008 if (b
->cond_string
!= NULL
)
7013 b
->cond
= parse_exp_1 (&s
, block_for_pc (sals
.sals
[i
].pc
), 0);
7016 /* We need to re-set the breakpoint if the address changes... */
7017 if (b
->address
!= sals
.sals
[i
].pc
7018 /* ...or new and old breakpoints both have source files, and
7019 the source file name or the line number changes... */
7020 || (b
->source_file
!= NULL
7021 && sals
.sals
[i
].symtab
!= NULL
7022 && (!STREQ (b
->source_file
, sals
.sals
[i
].symtab
->filename
)
7023 || b
->line_number
!= sals
.sals
[i
].line
)
7025 /* ...or we switch between having a source file and not having
7027 || ((b
->source_file
== NULL
) != (sals
.sals
[i
].symtab
== NULL
))
7030 if (b
->source_file
!= NULL
)
7031 xfree (b
->source_file
);
7032 if (sals
.sals
[i
].symtab
== NULL
)
7033 b
->source_file
= NULL
;
7036 savestring (sals
.sals
[i
].symtab
->filename
,
7037 strlen (sals
.sals
[i
].symtab
->filename
));
7038 b
->line_number
= sals
.sals
[i
].line
;
7039 b
->address
= sals
.sals
[i
].pc
;
7041 /* Used to check for duplicates here, but that can
7042 cause trouble, as it doesn't check for disable
7047 /* Might be better to do this just once per breakpoint_re_set,
7048 rather than once for every breakpoint. */
7049 breakpoints_changed ();
7051 b
->section
= sals
.sals
[i
].section
;
7052 b
->enable
= save_enable
; /* Restore it, this worked. */
7055 /* Now that this is re-enabled, check_duplicates
7057 check_duplicates (b
);
7064 case bp_hardware_watchpoint
:
7065 case bp_read_watchpoint
:
7066 case bp_access_watchpoint
:
7067 innermost_block
= NULL
;
7068 /* The issue arises of what context to evaluate this in. The
7069 same one as when it was set, but what does that mean when
7070 symbols have been re-read? We could save the filename and
7071 functionname, but if the context is more local than that, the
7072 best we could do would be something like how many levels deep
7073 and which index at that particular level, but that's going to
7074 be less stable than filenames or function names. */
7076 /* So for now, just use a global context. */
7079 b
->exp
= parse_expression (b
->exp_string
);
7080 b
->exp_valid_block
= innermost_block
;
7081 mark
= value_mark ();
7083 value_free (b
->val
);
7084 b
->val
= evaluate_expression (b
->exp
);
7085 release_value (b
->val
);
7086 if (VALUE_LAZY (b
->val
))
7087 value_fetch_lazy (b
->val
);
7089 if (b
->cond_string
!= NULL
)
7094 b
->cond
= parse_exp_1 (&s
, (struct block
*) 0, 0);
7096 if (b
->enable
== enabled
)
7098 value_free_to_mark (mark
);
7100 case bp_catch_catch
:
7101 case bp_catch_throw
:
7103 /* We needn't really do anything to reset these, since the mask
7104 that requests them is unaffected by e.g., new libraries being
7107 case bp_catch_vfork
:
7112 printf_filtered ("Deleting unknown breakpoint type %d\n", b
->type
);
7114 /* Delete longjmp breakpoints, they will be reset later by
7115 breakpoint_re_set. */
7117 case bp_longjmp_resume
:
7118 delete_breakpoint (b
);
7121 /* This breakpoint is special, it's set up when the inferior
7122 starts and we really don't want to touch it. */
7123 case bp_shlib_event
:
7125 /* Like bp_shlib_event, this breakpoint type is special.
7126 Once it is set up, we do not want to touch it. */
7127 case bp_thread_event
:
7129 /* Keep temporary breakpoints, which can be encountered when we step
7130 over a dlopen call and SOLIB_ADD is resetting the breakpoints.
7131 Otherwise these should have been blown away via the cleanup chain
7132 or by breakpoint_init_inferior when we rerun the executable. */
7135 case bp_watchpoint_scope
:
7137 case bp_step_resume
:
7144 /* Re-set all breakpoints after symbols have been re-loaded. */
7146 breakpoint_re_set (void)
7148 struct breakpoint
*b
, *temp
;
7149 enum language save_language
;
7150 int save_input_radix
;
7151 static char message1
[] = "Error in re-setting breakpoint %d:\n";
7152 char message
[sizeof (message1
) + 30 /* slop */ ];
7154 save_language
= current_language
->la_language
;
7155 save_input_radix
= input_radix
;
7156 ALL_BREAKPOINTS_SAFE (b
, temp
)
7158 /* Format possible error msg */
7159 sprintf (message
, message1
, b
->number
);
7160 catch_errors (breakpoint_re_set_one
, b
, message
, RETURN_MASK_ALL
);
7162 set_language (save_language
);
7163 input_radix
= save_input_radix
;
7165 #ifdef GET_LONGJMP_TARGET
7166 create_longjmp_breakpoint ("longjmp");
7167 create_longjmp_breakpoint ("_longjmp");
7168 create_longjmp_breakpoint ("siglongjmp");
7169 create_longjmp_breakpoint ("_siglongjmp");
7170 create_longjmp_breakpoint (NULL
);
7174 /* Took this out (temporarily at least), since it produces an extra
7175 blank line at startup. This messes up the gdbtests. -PB */
7176 /* Blank line to finish off all those mention() messages we just printed. */
7177 printf_filtered ("\n");
7181 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
7182 If from_tty is nonzero, it prints a message to that effect,
7183 which ends with a period (no newline). */
7185 /* Reset the thread number of this breakpoint:
7187 - If the breakpoint is for all threads, leave it as-is.
7188 - Else, reset it to the current thread for inferior_ptid. */
7190 breakpoint_re_set_thread (struct breakpoint
*b
)
7192 if (b
->thread
!= -1)
7194 if (in_thread_list (inferior_ptid
))
7195 b
->thread
= pid_to_thread_id (inferior_ptid
);
7200 set_ignore_count (int bptnum
, int count
, int from_tty
)
7202 register struct breakpoint
*b
;
7208 if (b
->number
== bptnum
)
7210 b
->ignore_count
= count
;
7213 else if (count
== 0)
7214 printf_filtered ("Will stop next time breakpoint %d is reached.",
7216 else if (count
== 1)
7217 printf_filtered ("Will ignore next crossing of breakpoint %d.",
7220 printf_filtered ("Will ignore next %d crossings of breakpoint %d.",
7222 breakpoints_changed ();
7226 error ("No breakpoint number %d.", bptnum
);
7229 /* Clear the ignore counts of all breakpoints. */
7231 breakpoint_clear_ignore_counts (void)
7233 struct breakpoint
*b
;
7236 b
->ignore_count
= 0;
7239 /* Command to set ignore-count of breakpoint N to COUNT. */
7242 ignore_command (char *args
, int from_tty
)
7248 error_no_arg ("a breakpoint number");
7250 num
= get_number (&p
);
7252 error ("bad breakpoint number: '%s'", args
);
7254 error ("Second argument (specified ignore-count) is missing.");
7256 set_ignore_count (num
,
7257 longest_to_int (value_as_long (parse_and_eval (p
))),
7259 printf_filtered ("\n");
7260 breakpoints_changed ();
7263 /* Call FUNCTION on each of the breakpoints
7264 whose numbers are given in ARGS. */
7267 map_breakpoint_numbers (char *args
, void (*function
) (struct breakpoint
*))
7269 register char *p
= args
;
7272 register struct breakpoint
*b
, *tmp
;
7276 error_no_arg ("one or more breakpoint numbers");
7283 num
= get_number_or_range (&p1
);
7286 warning ("bad breakpoint number at or near '%s'", p
);
7290 ALL_BREAKPOINTS_SAFE (b
, tmp
)
7291 if (b
->number
== num
)
7293 struct breakpoint
*related_breakpoint
= b
->related_breakpoint
;
7296 if (related_breakpoint
)
7297 function (related_breakpoint
);
7301 printf_unfiltered ("No breakpoint number %d.\n", num
);
7308 disable_breakpoint (struct breakpoint
*bpt
)
7310 /* Never disable a watchpoint scope breakpoint; we want to
7311 hit them when we leave scope so we can delete both the
7312 watchpoint and its scope breakpoint at that time. */
7313 if (bpt
->type
== bp_watchpoint_scope
)
7316 /* You can't disable permanent breakpoints. */
7317 if (bpt
->enable
== permanent
)
7320 bpt
->enable
= disabled
;
7322 check_duplicates (bpt
);
7324 if (modify_breakpoint_hook
)
7325 modify_breakpoint_hook (bpt
);
7326 breakpoint_modify_event (bpt
->number
);
7331 disable_command (char *args
, int from_tty
)
7333 register struct breakpoint
*bpt
;
7335 ALL_BREAKPOINTS (bpt
)
7339 warning ("attempted to disable apparently deleted breakpoint #%d?",
7344 case bp_catch_unload
:
7346 case bp_catch_vfork
:
7348 case bp_catch_catch
:
7349 case bp_catch_throw
:
7350 case bp_hardware_breakpoint
:
7352 case bp_hardware_watchpoint
:
7353 case bp_read_watchpoint
:
7354 case bp_access_watchpoint
:
7355 disable_breakpoint (bpt
);
7360 map_breakpoint_numbers (args
, disable_breakpoint
);
7364 do_enable_breakpoint (struct breakpoint
*bpt
, enum bpdisp disposition
)
7366 struct frame_info
*save_selected_frame
= NULL
;
7367 int save_selected_frame_level
= -1;
7368 int target_resources_ok
, other_type_used
;
7371 if (bpt
->type
== bp_hardware_breakpoint
)
7374 i
= hw_breakpoint_used_count ();
7375 target_resources_ok
=
7376 TARGET_CAN_USE_HARDWARE_WATCHPOINT (bp_hardware_breakpoint
,
7378 if (target_resources_ok
== 0)
7379 error ("No hardware breakpoint support in the target.");
7380 else if (target_resources_ok
< 0)
7381 error ("Hardware breakpoints used exceeds limit.");
7384 if (bpt
->enable
!= permanent
)
7385 bpt
->enable
= enabled
;
7386 bpt
->disposition
= disposition
;
7387 check_duplicates (bpt
);
7388 breakpoints_changed ();
7390 if (bpt
->type
== bp_watchpoint
||
7391 bpt
->type
== bp_hardware_watchpoint
||
7392 bpt
->type
== bp_read_watchpoint
||
7393 bpt
->type
== bp_access_watchpoint
)
7395 if (bpt
->exp_valid_block
!= NULL
)
7397 struct frame_info
*fr
=
7399 /* Ensure that we have the current frame. Else, this
7400 next query may pessimistically be answered as, "No,
7401 not within current scope". */
7402 get_current_frame ();
7403 fr
= find_frame_addr_in_frame_chain (bpt
->watchpoint_frame
);
7407 Cannot enable watchpoint %d because the block in which its expression\n\
7408 is valid is not currently in scope.\n", bpt
->number
);
7409 bpt
->enable
= disabled
;
7413 save_selected_frame
= selected_frame
;
7414 save_selected_frame_level
= selected_frame_level
;
7415 select_frame (fr
, -1);
7418 value_free (bpt
->val
);
7419 mark
= value_mark ();
7420 bpt
->val
= evaluate_expression (bpt
->exp
);
7421 release_value (bpt
->val
);
7422 if (VALUE_LAZY (bpt
->val
))
7423 value_fetch_lazy (bpt
->val
);
7425 if (bpt
->type
== bp_hardware_watchpoint
||
7426 bpt
->type
== bp_read_watchpoint
||
7427 bpt
->type
== bp_access_watchpoint
)
7429 int i
= hw_watchpoint_used_count (bpt
->type
, &other_type_used
);
7430 int mem_cnt
= can_use_hardware_watchpoint (bpt
->val
);
7432 /* Hack around 'unused var' error for some targets here */
7434 target_resources_ok
= TARGET_CAN_USE_HARDWARE_WATCHPOINT (
7435 bpt
->type
, i
+ mem_cnt
, other_type_used
);
7436 /* we can consider of type is bp_hardware_watchpoint, convert to
7437 bp_watchpoint in the following condition */
7438 if (target_resources_ok
< 0)
7441 Cannot enable watchpoint %d because target watch resources\n\
7442 have been allocated for other watchpoints.\n", bpt
->number
);
7443 bpt
->enable
= disabled
;
7444 value_free_to_mark (mark
);
7449 if (save_selected_frame_level
>= 0)
7450 select_frame (save_selected_frame
, save_selected_frame_level
);
7451 value_free_to_mark (mark
);
7453 if (modify_breakpoint_hook
)
7454 modify_breakpoint_hook (bpt
);
7455 breakpoint_modify_event (bpt
->number
);
7459 enable_breakpoint (struct breakpoint
*bpt
)
7461 do_enable_breakpoint (bpt
, bpt
->disposition
);
7464 /* The enable command enables the specified breakpoints (or all defined
7465 breakpoints) so they once again become (or continue to be) effective
7466 in stopping the inferior. */
7470 enable_command (char *args
, int from_tty
)
7472 register struct breakpoint
*bpt
;
7474 ALL_BREAKPOINTS (bpt
)
7478 warning ("attempted to enable apparently deleted breakpoint #%d?",
7483 case bp_catch_unload
:
7485 case bp_catch_vfork
:
7487 case bp_catch_catch
:
7488 case bp_catch_throw
:
7489 case bp_hardware_breakpoint
:
7491 case bp_hardware_watchpoint
:
7492 case bp_read_watchpoint
:
7493 case bp_access_watchpoint
:
7494 enable_breakpoint (bpt
);
7499 map_breakpoint_numbers (args
, enable_breakpoint
);
7503 enable_once_breakpoint (struct breakpoint
*bpt
)
7505 do_enable_breakpoint (bpt
, disable
);
7510 enable_once_command (char *args
, int from_tty
)
7512 map_breakpoint_numbers (args
, enable_once_breakpoint
);
7516 enable_delete_breakpoint (struct breakpoint
*bpt
)
7518 do_enable_breakpoint (bpt
, del
);
7523 enable_delete_command (char *args
, int from_tty
)
7525 map_breakpoint_numbers (args
, enable_delete_breakpoint
);
7528 /* Use default_breakpoint_'s, or nothing if they aren't valid. */
7530 struct symtabs_and_lines
7531 decode_line_spec_1 (char *string
, int funfirstline
)
7533 struct symtabs_and_lines sals
;
7535 error ("Empty line specification.");
7536 if (default_breakpoint_valid
)
7537 sals
= decode_line_1 (&string
, funfirstline
,
7538 default_breakpoint_symtab
,
7539 default_breakpoint_line
,
7542 sals
= decode_line_1 (&string
, funfirstline
,
7543 (struct symtab
*) NULL
, 0, (char ***) NULL
);
7545 error ("Junk at end of line specification: %s", string
);
7550 _initialize_breakpoint (void)
7552 struct cmd_list_element
*c
;
7554 breakpoint_chain
= 0;
7555 /* Don't bother to call set_breakpoint_count. $bpnum isn't useful
7556 before a breakpoint is set. */
7557 breakpoint_count
= 0;
7559 add_com ("ignore", class_breakpoint
, ignore_command
,
7560 "Set ignore-count of breakpoint number N to COUNT.\n\
7561 Usage is `ignore N COUNT'.");
7563 add_com_alias ("bc", "ignore", class_breakpoint
, 1);
7565 add_com ("commands", class_breakpoint
, commands_command
,
7566 "Set commands to be executed when a breakpoint is hit.\n\
7567 Give breakpoint number as argument after \"commands\".\n\
7568 With no argument, the targeted breakpoint is the last one set.\n\
7569 The commands themselves follow starting on the next line.\n\
7570 Type a line containing \"end\" to indicate the end of them.\n\
7571 Give \"silent\" as the first line to make the breakpoint silent;\n\
7572 then no output is printed when it is hit, except what the commands print.");
7574 add_com ("condition", class_breakpoint
, condition_command
,
7575 "Specify breakpoint number N to break only if COND is true.\n\
7576 Usage is `condition N COND', where N is an integer and COND is an\n\
7577 expression to be evaluated whenever breakpoint N is reached. ");
7579 add_com ("tbreak", class_breakpoint
, tbreak_command
,
7580 "Set a temporary breakpoint. Args like \"break\" command.\n\
7581 Like \"break\" except the breakpoint is only temporary,\n\
7582 so it will be deleted when hit. Equivalent to \"break\" followed\n\
7583 by using \"enable delete\" on the breakpoint number.");
7584 add_com ("txbreak", class_breakpoint
, tbreak_at_finish_command
,
7585 "Set temporary breakpoint at procedure exit. Either there should\n\
7586 be no argument or the argument must be a depth.\n");
7588 add_com ("hbreak", class_breakpoint
, hbreak_command
,
7589 "Set a hardware assisted breakpoint. Args like \"break\" command.\n\
7590 Like \"break\" except the breakpoint requires hardware support,\n\
7591 some target hardware may not have this support.");
7593 add_com ("thbreak", class_breakpoint
, thbreak_command
,
7594 "Set a temporary hardware assisted breakpoint. Args like \"break\" command.\n\
7595 Like \"hbreak\" except the breakpoint is only temporary,\n\
7596 so it will be deleted when hit.");
7598 add_prefix_cmd ("enable", class_breakpoint
, enable_command
,
7599 "Enable some breakpoints.\n\
7600 Give breakpoint numbers (separated by spaces) as arguments.\n\
7601 With no subcommand, breakpoints are enabled until you command otherwise.\n\
7602 This is used to cancel the effect of the \"disable\" command.\n\
7603 With a subcommand you can enable temporarily.",
7604 &enablelist
, "enable ", 1, &cmdlist
);
7606 add_com ("ab", class_breakpoint
, enable_command
,
7607 "Enable some breakpoints.\n\
7608 Give breakpoint numbers (separated by spaces) as arguments.\n\
7609 With no subcommand, breakpoints are enabled until you command otherwise.\n\
7610 This is used to cancel the effect of the \"disable\" command.\n\
7611 With a subcommand you can enable temporarily.");
7613 add_com_alias ("en", "enable", class_breakpoint
, 1);
7615 add_abbrev_prefix_cmd ("breakpoints", class_breakpoint
, enable_command
,
7616 "Enable some breakpoints.\n\
7617 Give breakpoint numbers (separated by spaces) as arguments.\n\
7618 This is used to cancel the effect of the \"disable\" command.\n\
7619 May be abbreviated to simply \"enable\".\n",
7620 &enablebreaklist
, "enable breakpoints ", 1, &enablelist
);
7622 add_cmd ("once", no_class
, enable_once_command
,
7623 "Enable breakpoints for one hit. Give breakpoint numbers.\n\
7624 If a breakpoint is hit while enabled in this fashion, it becomes disabled.",
7627 add_cmd ("delete", no_class
, enable_delete_command
,
7628 "Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
7629 If a breakpoint is hit while enabled in this fashion, it is deleted.",
7632 add_cmd ("delete", no_class
, enable_delete_command
,
7633 "Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
7634 If a breakpoint is hit while enabled in this fashion, it is deleted.",
7637 add_cmd ("once", no_class
, enable_once_command
,
7638 "Enable breakpoints for one hit. Give breakpoint numbers.\n\
7639 If a breakpoint is hit while enabled in this fashion, it becomes disabled.",
7642 add_prefix_cmd ("disable", class_breakpoint
, disable_command
,
7643 "Disable some breakpoints.\n\
7644 Arguments are breakpoint numbers with spaces in between.\n\
7645 To disable all breakpoints, give no argument.\n\
7646 A disabled breakpoint is not forgotten, but has no effect until reenabled.",
7647 &disablelist
, "disable ", 1, &cmdlist
);
7648 add_com_alias ("dis", "disable", class_breakpoint
, 1);
7649 add_com_alias ("disa", "disable", class_breakpoint
, 1);
7651 add_com ("sb", class_breakpoint
, disable_command
,
7652 "Disable some breakpoints.\n\
7653 Arguments are breakpoint numbers with spaces in between.\n\
7654 To disable all breakpoints, give no argument.\n\
7655 A disabled breakpoint is not forgotten, but has no effect until reenabled.");
7657 add_cmd ("breakpoints", class_alias
, disable_command
,
7658 "Disable some breakpoints.\n\
7659 Arguments are breakpoint numbers with spaces in between.\n\
7660 To disable all breakpoints, give no argument.\n\
7661 A disabled breakpoint is not forgotten, but has no effect until reenabled.\n\
7662 This command may be abbreviated \"disable\".",
7665 add_prefix_cmd ("delete", class_breakpoint
, delete_command
,
7666 "Delete some breakpoints or auto-display expressions.\n\
7667 Arguments are breakpoint numbers with spaces in between.\n\
7668 To delete all breakpoints, give no argument.\n\
7670 Also a prefix command for deletion of other GDB objects.\n\
7671 The \"unset\" command is also an alias for \"delete\".",
7672 &deletelist
, "delete ", 1, &cmdlist
);
7673 add_com_alias ("d", "delete", class_breakpoint
, 1);
7675 add_com ("db", class_breakpoint
, delete_command
,
7676 "Delete some breakpoints.\n\
7677 Arguments are breakpoint numbers with spaces in between.\n\
7678 To delete all breakpoints, give no argument.\n");
7680 add_cmd ("breakpoints", class_alias
, delete_command
,
7681 "Delete some breakpoints or auto-display expressions.\n\
7682 Arguments are breakpoint numbers with spaces in between.\n\
7683 To delete all breakpoints, give no argument.\n\
7684 This command may be abbreviated \"delete\".",
7687 add_com ("clear", class_breakpoint
, clear_command
,
7688 concat ("Clear breakpoint at specified line or function.\n\
7689 Argument may be line number, function name, or \"*\" and an address.\n\
7690 If line number is specified, all breakpoints in that line are cleared.\n\
7691 If function is specified, breakpoints at beginning of function are cleared.\n\
7692 If an address is specified, breakpoints at that address are cleared.\n\n",
7693 "With no argument, clears all breakpoints in the line that the selected frame\n\
7696 See also the \"delete\" command which clears breakpoints by number.", NULL
));
7698 add_com ("break", class_breakpoint
, break_command
,
7699 concat ("Set breakpoint at specified line or function.\n\
7700 Argument may be line number, function name, or \"*\" and an address.\n\
7701 If line number is specified, break at start of code for that line.\n\
7702 If function is specified, break at start of code for that function.\n\
7703 If an address is specified, break at that exact address.\n",
7704 "With no arg, uses current execution address of selected stack frame.\n\
7705 This is useful for breaking on return to a stack frame.\n\
7707 Multiple breakpoints at one place are permitted, and useful if conditional.\n\
7709 Do \"help breakpoints\" for info on other commands dealing with breakpoints.", NULL
));
7710 add_com_alias ("b", "break", class_run
, 1);
7711 add_com_alias ("br", "break", class_run
, 1);
7712 add_com_alias ("bre", "break", class_run
, 1);
7713 add_com_alias ("brea", "break", class_run
, 1);
7715 add_com ("xbreak", class_breakpoint
, break_at_finish_command
,
7716 concat ("Set breakpoint at procedure exit. \n\
7717 Argument may be function name, or \"*\" and an address.\n\
7718 If function is specified, break at end of code for that function.\n\
7719 If an address is specified, break at the end of the function that contains \n\
7720 that exact address.\n",
7721 "With no arg, uses current execution address of selected stack frame.\n\
7722 This is useful for breaking on return to a stack frame.\n\
7724 Multiple breakpoints at one place are permitted, and useful if conditional.\n\
7726 Do \"help breakpoints\" for info on other commands dealing with breakpoints.", NULL
));
7727 add_com_alias ("xb", "xbreak", class_breakpoint
, 1);
7728 add_com_alias ("xbr", "xbreak", class_breakpoint
, 1);
7729 add_com_alias ("xbre", "xbreak", class_breakpoint
, 1);
7730 add_com_alias ("xbrea", "xbreak", class_breakpoint
, 1);
7734 add_com_alias ("ba", "break", class_breakpoint
, 1);
7735 add_com_alias ("bu", "ubreak", class_breakpoint
, 1);
7736 add_com ("bx", class_breakpoint
, break_at_finish_at_depth_command
,
7737 "Set breakpoint at procedure exit. Either there should\n\
7738 be no argument or the argument must be a depth.\n");
7743 add_abbrev_prefix_cmd ("stop", class_breakpoint
, stop_command
,
7744 "Break in function/address or break at a line in the current file.",
7745 &stoplist
, "stop ", 1, &cmdlist
);
7746 add_cmd ("in", class_breakpoint
, stopin_command
,
7747 "Break in function or address.\n", &stoplist
);
7748 add_cmd ("at", class_breakpoint
, stopat_command
,
7749 "Break at a line in the current file.\n", &stoplist
);
7750 add_com ("status", class_info
, breakpoints_info
,
7751 concat ("Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
7752 The \"Type\" column indicates one of:\n\
7753 \tbreakpoint - normal breakpoint\n\
7754 \twatchpoint - watchpoint\n\
7755 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
7756 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
7757 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
7758 address and file/line number respectively.\n\n",
7759 "Convenience variable \"$_\" and default examine address for \"x\"\n\
7760 are set to the address of the last breakpoint listed.\n\n\
7761 Convenience variable \"$bpnum\" contains the number of the last\n\
7762 breakpoint set.", NULL
));
7765 add_info ("breakpoints", breakpoints_info
,
7766 concat ("Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
7767 The \"Type\" column indicates one of:\n\
7768 \tbreakpoint - normal breakpoint\n\
7769 \twatchpoint - watchpoint\n\
7770 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
7771 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
7772 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
7773 address and file/line number respectively.\n\n",
7774 "Convenience variable \"$_\" and default examine address for \"x\"\n\
7775 are set to the address of the last breakpoint listed.\n\n\
7776 Convenience variable \"$bpnum\" contains the number of the last\n\
7777 breakpoint set.", NULL
));
7780 add_com ("lb", class_breakpoint
, breakpoints_info
,
7781 concat ("Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
7782 The \"Type\" column indicates one of:\n\
7783 \tbreakpoint - normal breakpoint\n\
7784 \twatchpoint - watchpoint\n\
7785 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
7786 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
7787 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
7788 address and file/line number respectively.\n\n",
7789 "Convenience variable \"$_\" and default examine address for \"x\"\n\
7790 are set to the address of the last breakpoint listed.\n\n\
7791 Convenience variable \"$bpnum\" contains the number of the last\n\
7792 breakpoint set.", NULL
));
7794 add_cmd ("breakpoints", class_maintenance
, maintenance_info_breakpoints
,
7795 concat ("Status of all breakpoints, or breakpoint number NUMBER.\n\
7796 The \"Type\" column indicates one of:\n\
7797 \tbreakpoint - normal breakpoint\n\
7798 \twatchpoint - watchpoint\n\
7799 \tlongjmp - internal breakpoint used to step through longjmp()\n\
7800 \tlongjmp resume - internal breakpoint at the target of longjmp()\n\
7801 \tuntil - internal breakpoint used by the \"until\" command\n\
7802 \tfinish - internal breakpoint used by the \"finish\" command\n",
7803 "The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
7804 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
7805 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
7806 address and file/line number respectively.\n\n",
7807 "Convenience variable \"$_\" and default examine address for \"x\"\n\
7808 are set to the address of the last breakpoint listed.\n\n\
7809 Convenience variable \"$bpnum\" contains the number of the last\n\
7810 breakpoint set.", NULL
),
7811 &maintenanceinfolist
);
7813 add_com ("catch", class_breakpoint
, catch_command
,
7814 "Set catchpoints to catch events.\n\
7815 Raised signals may be caught:\n\
7816 \tcatch signal - all signals\n\
7817 \tcatch signal <signame> - a particular signal\n\
7818 Raised exceptions may be caught:\n\
7819 \tcatch throw - all exceptions, when thrown\n\
7820 \tcatch throw <exceptname> - a particular exception, when thrown\n\
7821 \tcatch catch - all exceptions, when caught\n\
7822 \tcatch catch <exceptname> - a particular exception, when caught\n\
7823 Thread or process events may be caught:\n\
7824 \tcatch thread_start - any threads, just after creation\n\
7825 \tcatch thread_exit - any threads, just before expiration\n\
7826 \tcatch thread_join - any threads, just after joins\n\
7827 Process events may be caught:\n\
7828 \tcatch start - any processes, just after creation\n\
7829 \tcatch exit - any processes, just before expiration\n\
7830 \tcatch fork - calls to fork()\n\
7831 \tcatch vfork - calls to vfork()\n\
7832 \tcatch exec - calls to exec()\n\
7833 Dynamically-linked library events may be caught:\n\
7834 \tcatch load - loads of any library\n\
7835 \tcatch load <libname> - loads of a particular library\n\
7836 \tcatch unload - unloads of any library\n\
7837 \tcatch unload <libname> - unloads of a particular library\n\
7838 The act of your program's execution stopping may also be caught:\n\
7840 C++ exceptions may be caught:\n\
7841 \tcatch throw - all exceptions, when thrown\n\
7842 \tcatch catch - all exceptions, when caught\n\
7844 Do \"help set follow-fork-mode\" for info on debugging your program\n\
7845 after a fork or vfork is caught.\n\n\
7846 Do \"help breakpoints\" for info on other commands dealing with breakpoints.");
7848 add_com ("tcatch", class_breakpoint
, tcatch_command
,
7849 "Set temporary catchpoints to catch events.\n\
7850 Args like \"catch\" command.\n\
7851 Like \"catch\" except the catchpoint is only temporary,\n\
7852 so it will be deleted when hit. Equivalent to \"catch\" followed\n\
7853 by using \"enable delete\" on the catchpoint number.");
7855 add_com ("watch", class_breakpoint
, watch_command
,
7856 "Set a watchpoint for an expression.\n\
7857 A watchpoint stops execution of your program whenever the value of\n\
7858 an expression changes.");
7860 add_com ("rwatch", class_breakpoint
, rwatch_command
,
7861 "Set a read watchpoint for an expression.\n\
7862 A watchpoint stops execution of your program whenever the value of\n\
7863 an expression is read.");
7865 add_com ("awatch", class_breakpoint
, awatch_command
,
7866 "Set a watchpoint for an expression.\n\
7867 A watchpoint stops execution of your program whenever the value of\n\
7868 an expression is either read or written.");
7870 add_info ("watchpoints", breakpoints_info
,
7871 "Synonym for ``info breakpoints''.");
7874 c
= add_set_cmd ("can-use-hw-watchpoints", class_support
, var_zinteger
,
7875 (char *) &can_use_hw_watchpoints
,
7876 "Set debugger's willingness to use watchpoint hardware.\n\
7877 If zero, gdb will not use hardware for new watchpoints, even if\n\
7878 such is available. (However, any hardware watchpoints that were\n\
7879 created before setting this to nonzero, will continue to use watchpoint\n\
7882 add_show_from_set (c
, &showlist
);
7884 can_use_hw_watchpoints
= 1;