1 /* Everything about breakpoints, for GDB.
3 Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994,
4 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003 Free Software
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 59 Temple Place - Suite 330,
22 Boston, MA 02111-1307, USA. */
28 #include "breakpoint.h"
30 #include "expression.h"
36 #include "gdbthread.h"
39 #include "gdb_string.h"
46 #include "completer.h"
49 #include "cli/cli-script.h"
50 #include "gdb_assert.h"
53 #include "gdb-events.h"
55 /* Prototypes for local functions. */
57 static void until_break_command_continuation (struct continuation_arg
*arg
);
59 static void catch_command_1 (char *, int, int);
61 static void enable_delete_command (char *, int);
63 static void enable_delete_breakpoint (struct breakpoint
*);
65 static void enable_once_command (char *, int);
67 static void enable_once_breakpoint (struct breakpoint
*);
69 static void disable_command (char *, int);
71 static void enable_command (char *, int);
73 static void map_breakpoint_numbers (char *, void (*)(struct breakpoint
*));
75 static void ignore_command (char *, int);
77 static int breakpoint_re_set_one (void *);
79 static void clear_command (char *, int);
81 static void catch_command (char *, int);
83 static void handle_gnu_4_16_catch_command (char *, int, int);
85 static struct symtabs_and_lines
get_catch_sals (int);
87 static void watch_command (char *, int);
89 static int can_use_hardware_watchpoint (struct value
*);
91 extern void break_at_finish_command (char *, int);
92 extern void break_at_finish_at_depth_command (char *, int);
94 extern void tbreak_at_finish_command (char *, int);
96 static void break_command_1 (char *, int, int);
98 static void mention (struct breakpoint
*);
100 struct breakpoint
*set_raw_breakpoint (struct symtab_and_line
, enum bptype
);
102 static void check_duplicates (struct breakpoint
*);
104 static void describe_other_breakpoints (CORE_ADDR
, asection
*);
106 static void breakpoints_info (char *, int);
108 static void breakpoint_1 (int, int);
110 static bpstat
bpstat_alloc (struct breakpoint
*, bpstat
);
112 static int breakpoint_cond_eval (void *);
114 static void cleanup_executing_breakpoints (void *);
116 static void commands_command (char *, int);
118 static void condition_command (char *, int);
120 static int get_number_trailer (char **, int);
122 void set_breakpoint_count (int);
131 static int remove_breakpoint (struct breakpoint
*, insertion_state_t
);
133 static enum print_stop_action
print_it_typical (bpstat
);
135 static enum print_stop_action
print_bp_stop_message (bpstat bs
);
139 enum exception_event_kind kind
;
142 args_for_catchpoint_enable
;
144 static int watchpoint_check (void *);
146 static int cover_target_enable_exception_callback (void *);
148 static void maintenance_info_breakpoints (char *, int);
150 static void create_longjmp_breakpoint (char *);
152 static void create_overlay_event_breakpoint (char *);
154 static int hw_breakpoint_used_count (void);
156 static int hw_watchpoint_used_count (enum bptype
, int *);
158 static void hbreak_command (char *, int);
160 static void thbreak_command (char *, int);
162 static void watch_command_1 (char *, int, int);
164 static void rwatch_command (char *, int);
166 static void awatch_command (char *, int);
168 static void do_enable_breakpoint (struct breakpoint
*, enum bpdisp
);
170 static void solib_load_unload_1 (char *hookname
,
173 char *cond_string
, enum bptype bp_kind
);
175 static void create_fork_vfork_event_catchpoint (int tempflag
,
177 enum bptype bp_kind
);
179 static void break_at_finish_at_depth_command_1 (char *arg
,
180 int flag
, int from_tty
);
182 static void break_at_finish_command_1 (char *arg
, int flag
, int from_tty
);
184 static void stop_command (char *arg
, int from_tty
);
186 static void stopin_command (char *arg
, int from_tty
);
188 static void stopat_command (char *arg
, int from_tty
);
190 static char *ep_find_event_name_end (char *arg
);
192 static char *ep_parse_optional_if_clause (char **arg
);
194 static char *ep_parse_optional_filename (char **arg
);
196 #if defined(CHILD_INSERT_EXEC_CATCHPOINT)
197 static void catch_exec_command_1 (char *arg
, int tempflag
, int from_tty
);
200 static void create_exception_catchpoint (int tempflag
, char *cond_string
,
201 enum exception_event_kind ex_event
,
202 struct symtab_and_line
*sal
);
204 static void catch_exception_command_1 (enum exception_event_kind ex_event
,
205 char *arg
, int tempflag
, int from_tty
);
207 static void tcatch_command (char *arg
, int from_tty
);
209 static void ep_skip_leading_whitespace (char **s
);
211 /* Prototypes for exported functions. */
213 /* If FALSE, gdb will not use hardware support for watchpoints, even
214 if such is available. */
215 static int can_use_hw_watchpoints
;
217 void _initialize_breakpoint (void);
219 extern int addressprint
; /* Print machine addresses? */
221 /* Are we executing breakpoint commands? */
222 static int executing_breakpoint_commands
;
224 /* Are overlay event breakpoints enabled? */
225 static int overlay_events_enabled
;
227 /* Walk the following statement or block through all breakpoints.
228 ALL_BREAKPOINTS_SAFE does so even if the statment deletes the current
231 #define ALL_BREAKPOINTS(B) for (B = breakpoint_chain; B; B = B->next)
233 #define ALL_BREAKPOINTS_SAFE(B,TMP) \
234 for (B = breakpoint_chain; \
235 B ? (TMP=B->next, 1): 0; \
238 /* True if SHIFT_INST_REGS defined, false otherwise. */
240 int must_shift_inst_regs
=
241 #if defined(SHIFT_INST_REGS)
248 /* True if breakpoint hit counts should be displayed in breakpoint info. */
250 int show_breakpoint_hit_counts
= 1;
252 /* Chain of all breakpoints defined. */
254 struct breakpoint
*breakpoint_chain
;
256 /* Number of last breakpoint made. */
258 int breakpoint_count
;
260 /* Pointer to current exception event record */
261 static struct exception_event_record
*current_exception_event
;
263 /* Indicator of whether exception catchpoints should be nuked
264 between runs of a program */
265 int exception_catchpoints_are_fragile
= 0;
267 /* Indicator of when exception catchpoints set-up should be
268 reinitialized -- e.g. when program is re-run */
269 int exception_support_initialized
= 0;
271 /* This function returns a pointer to the string representation of the
272 pathname of the dynamically-linked library that has just been
275 This function must be used only when SOLIB_HAVE_LOAD_EVENT is TRUE,
276 or undefined results are guaranteed.
278 This string's contents are only valid immediately after the
279 inferior has stopped in the dynamic linker hook, and becomes
280 invalid as soon as the inferior is continued. Clients should make
281 a copy of this string if they wish to continue the inferior and
282 then access the string. */
284 #ifndef SOLIB_LOADED_LIBRARY_PATHNAME
285 #define SOLIB_LOADED_LIBRARY_PATHNAME(pid) ""
288 /* This function returns a pointer to the string representation of the
289 pathname of the dynamically-linked library that has just been
292 This function must be used only when SOLIB_HAVE_UNLOAD_EVENT is
293 TRUE, or undefined results are guaranteed.
295 This string's contents are only valid immediately after the
296 inferior has stopped in the dynamic linker hook, and becomes
297 invalid as soon as the inferior is continued. Clients should make
298 a copy of this string if they wish to continue the inferior and
299 then access the string. */
301 #ifndef SOLIB_UNLOADED_LIBRARY_PATHNAME
302 #define SOLIB_UNLOADED_LIBRARY_PATHNAME(pid) ""
305 /* This function is called by the "catch load" command. It allows the
306 debugger to be notified by the dynamic linker when a specified
307 library file (or any library file, if filename is NULL) is loaded. */
309 #ifndef SOLIB_CREATE_CATCH_LOAD_HOOK
310 #define SOLIB_CREATE_CATCH_LOAD_HOOK(pid,tempflag,filename,cond_string) \
311 error ("catch of library loads not yet implemented on this platform")
314 /* This function is called by the "catch unload" command. It allows
315 the debugger to be notified by the dynamic linker when a specified
316 library file (or any library file, if filename is NULL) is
319 #ifndef SOLIB_CREATE_CATCH_UNLOAD_HOOK
320 #define SOLIB_CREATE_CATCH_UNLOAD_HOOK(pid,tempflag,filename,cond_string) \
321 error ("catch of library unloads not yet implemented on this platform")
324 /* Set breakpoint count to NUM. */
327 set_breakpoint_count (int num
)
329 breakpoint_count
= num
;
330 set_internalvar (lookup_internalvar ("bpnum"),
331 value_from_longest (builtin_type_int
, (LONGEST
) num
));
334 /* Used in run_command to zero the hit count when a new run starts. */
337 clear_breakpoint_hit_counts (void)
339 struct breakpoint
*b
;
345 /* Default address, symtab and line to put a breakpoint at
346 for "break" command with no arg.
347 if default_breakpoint_valid is zero, the other three are
348 not valid, and "break" with no arg is an error.
350 This set by print_stack_frame, which calls set_default_breakpoint. */
352 int default_breakpoint_valid
;
353 CORE_ADDR default_breakpoint_address
;
354 struct symtab
*default_breakpoint_symtab
;
355 int default_breakpoint_line
;
357 /* *PP is a string denoting a breakpoint. Get the number of the breakpoint.
358 Advance *PP after the string and any trailing whitespace.
360 Currently the string can either be a number or "$" followed by the name
361 of a convenience variable. Making it an expression wouldn't work well
362 for map_breakpoint_numbers (e.g. "4 + 5 + 6").
364 TRAILER is a character which can be found after the number; most
365 commonly this is `-'. If you don't want a trailer, use \0. */
367 get_number_trailer (char **pp
, int trailer
)
369 int retval
= 0; /* default */
373 /* Empty line means refer to the last breakpoint. */
374 return breakpoint_count
;
377 /* Make a copy of the name, so we can null-terminate it
378 to pass to lookup_internalvar(). */
383 while (isalnum (*p
) || *p
== '_')
385 varname
= (char *) alloca (p
- start
+ 1);
386 strncpy (varname
, start
, p
- start
);
387 varname
[p
- start
] = '\0';
388 val
= value_of_internalvar (lookup_internalvar (varname
));
389 if (TYPE_CODE (VALUE_TYPE (val
)) == TYPE_CODE_INT
)
390 retval
= (int) value_as_long (val
);
393 printf_filtered ("Convenience variable must have integer value.\n");
401 while (*p
>= '0' && *p
<= '9')
404 /* There is no number here. (e.g. "cond a == b"). */
406 /* Skip non-numeric token */
407 while (*p
&& !isspace((int) *p
))
409 /* Return zero, which caller must interpret as error. */
415 if (!(isspace (*p
) || *p
== '\0' || *p
== trailer
))
417 /* Trailing junk: return 0 and let caller print error msg. */
418 while (!(isspace (*p
) || *p
== '\0' || *p
== trailer
))
429 /* Like get_number_trailer, but don't allow a trailer. */
431 get_number (char **pp
)
433 return get_number_trailer (pp
, '\0');
436 /* Parse a number or a range.
437 * A number will be of the form handled by get_number.
438 * A range will be of the form <number1> - <number2>, and
439 * will represent all the integers between number1 and number2,
442 * While processing a range, this fuction is called iteratively;
443 * At each call it will return the next value in the range.
445 * At the beginning of parsing a range, the char pointer PP will
446 * be advanced past <number1> and left pointing at the '-' token.
447 * Subsequent calls will not advance the pointer until the range
448 * is completed. The call that completes the range will advance
449 * pointer PP past <number2>.
453 get_number_or_range (char **pp
)
455 static int last_retval
, end_value
;
456 static char *end_ptr
;
457 static int in_range
= 0;
461 /* Default case: pp is pointing either to a solo number,
462 or to the first number of a range. */
463 last_retval
= get_number_trailer (pp
, '-');
468 /* This is the start of a range (<number1> - <number2>).
469 Skip the '-', parse and remember the second number,
470 and also remember the end of the final token. */
474 while (isspace ((int) *end_ptr
))
475 end_ptr
++; /* skip white space */
476 end_value
= get_number (temp
);
477 if (end_value
< last_retval
)
479 error ("inverted range");
481 else if (end_value
== last_retval
)
483 /* degenerate range (number1 == number2). Advance the
484 token pointer so that the range will be treated as a
493 error ("negative value");
496 /* pp points to the '-' that betokens a range. All
497 number-parsing has already been done. Return the next
498 integer value (one greater than the saved previous value).
499 Do not advance the token pointer 'pp' until the end of range
502 if (++last_retval
== end_value
)
504 /* End of range reached; advance token pointer. */
514 /* condition N EXP -- set break condition of breakpoint N to EXP. */
517 condition_command (char *arg
, int from_tty
)
519 register struct breakpoint
*b
;
524 error_no_arg ("breakpoint number");
527 bnum
= get_number (&p
);
529 error ("Bad breakpoint argument: '%s'", arg
);
532 if (b
->number
== bnum
)
539 if (b
->cond_string
!= NULL
)
540 xfree (b
->cond_string
);
545 b
->cond_string
= NULL
;
547 printf_filtered ("Breakpoint %d now unconditional.\n", bnum
);
552 /* I don't know if it matters whether this is the string the user
553 typed in or the decompiled expression. */
554 b
->cond_string
= savestring (arg
, strlen (arg
));
555 b
->cond
= parse_exp_1 (&arg
, block_for_pc (b
->address
), 0);
557 error ("Junk at end of expression");
559 breakpoints_changed ();
560 breakpoint_modify_event (b
->number
);
564 error ("No breakpoint number %d.", bnum
);
569 commands_command (char *arg
, int from_tty
)
571 register struct breakpoint
*b
;
574 struct command_line
*l
;
576 /* If we allowed this, we would have problems with when to
577 free the storage, if we change the commands currently
580 if (executing_breakpoint_commands
)
581 error ("Can't use the \"commands\" command among a breakpoint's commands.");
584 bnum
= get_number (&p
);
587 error ("Unexpected extra arguments following breakpoint number.");
590 if (b
->number
== bnum
)
594 "Type commands for when breakpoint %d is hit, one per line.",
596 l
= read_command_lines (tmpbuf
, from_tty
);
597 free_command_lines (&b
->commands
);
599 breakpoints_changed ();
600 breakpoint_modify_event (b
->number
);
603 error ("No breakpoint number %d.", bnum
);
606 /* Like target_read_memory() but if breakpoints are inserted, return
607 the shadow contents instead of the breakpoints themselves.
609 Read "memory data" from whatever target or inferior we have.
610 Returns zero if successful, errno value if not. EIO is used
611 for address out of bounds. If breakpoints are inserted, returns
612 shadow contents, not the breakpoints themselves. From breakpoint.c. */
615 read_memory_nobpt (CORE_ADDR memaddr
, char *myaddr
, unsigned len
)
618 struct breakpoint
*b
;
619 CORE_ADDR bp_addr
= 0;
622 if (BREAKPOINT_FROM_PC (&bp_addr
, &bp_size
) == NULL
)
623 /* No breakpoints on this machine. */
624 return target_read_memory (memaddr
, myaddr
, len
);
628 if (b
->type
== bp_none
)
629 warning ("reading through apparently deleted breakpoint #%d?",
632 /* memory breakpoint? */
633 if (b
->type
== bp_watchpoint
634 || b
->type
== bp_hardware_watchpoint
635 || b
->type
== bp_read_watchpoint
636 || b
->type
== bp_access_watchpoint
)
641 /* Addresses and length of the part of the breakpoint that
643 /* XXXX The m68k, sh and h8300 have different local and remote
644 breakpoint values. BREAKPOINT_FROM_PC still manages to
645 correctly determine the breakpoints memory address and size
646 for these targets. */
647 bp_addr
= b
->address
;
649 if (BREAKPOINT_FROM_PC (&bp_addr
, &bp_size
) == NULL
)
654 if (bp_addr
+ bp_size
<= memaddr
)
655 /* The breakpoint is entirely before the chunk of memory we
658 if (bp_addr
>= memaddr
+ len
)
659 /* The breakpoint is entirely after the chunk of memory we are
662 /* Copy the breakpoint from the shadow contents, and recurse for
663 the things before and after. */
665 /* Offset within shadow_contents. */
668 if (bp_addr
< memaddr
)
670 /* Only copy the second part of the breakpoint. */
671 bp_size
-= memaddr
- bp_addr
;
672 bptoffset
= memaddr
- bp_addr
;
676 if (bp_addr
+ bp_size
> memaddr
+ len
)
678 /* Only copy the first part of the breakpoint. */
679 bp_size
-= (bp_addr
+ bp_size
) - (memaddr
+ len
);
682 memcpy (myaddr
+ bp_addr
- memaddr
,
683 b
->shadow_contents
+ bptoffset
, bp_size
);
685 if (bp_addr
> memaddr
)
687 /* Copy the section of memory before the breakpoint. */
688 status
= read_memory_nobpt (memaddr
, myaddr
, bp_addr
- memaddr
);
693 if (bp_addr
+ bp_size
< memaddr
+ len
)
695 /* Copy the section of memory after the breakpoint. */
696 status
= read_memory_nobpt (bp_addr
+ bp_size
,
697 myaddr
+ bp_addr
+ bp_size
- memaddr
,
698 memaddr
+ len
- (bp_addr
+ bp_size
));
705 /* Nothing overlaps. Just call read_memory_noerr. */
706 return target_read_memory (memaddr
, myaddr
, len
);
710 /* insert_breakpoints is used when starting or continuing the program.
711 remove_breakpoints is used when the program stops.
712 Both return zero if successful,
713 or an `errno' value if could not write the inferior. */
716 insert_breakpoints (void)
718 register struct breakpoint
*b
, *temp
;
719 int return_val
= 0; /* return success code. */
721 int disabled_breaks
= 0;
722 int hw_breakpoint_error
= 0;
723 #ifdef ONE_PROCESS_WRITETEXT
724 int process_warning
= 0;
727 static char message1
[] = "Error inserting catchpoint %d:\n";
728 static char message
[sizeof (message1
) + 30];
730 struct ui_file
*tmp_error_stream
= mem_fileopen ();
731 make_cleanup_ui_file_delete (tmp_error_stream
);
733 /* Explicitly mark the warning -- this will only be printed if
734 there was an error. */
735 fprintf_unfiltered (tmp_error_stream
, "Warning:\n");
737 ALL_BREAKPOINTS_SAFE (b
, temp
)
739 /* Permanent breakpoints cannot be inserted or removed. Disabled
740 breakpoints should not be inserted. */
741 if (b
->enable_state
!= bp_enabled
)
744 if ((b
->type
== bp_watchpoint
745 || b
->type
== bp_hardware_watchpoint
746 || b
->type
== bp_read_watchpoint
747 || b
->type
== bp_access_watchpoint
) && (!b
->val
))
750 val
= evaluate_expression (b
->exp
);
752 if (VALUE_LAZY (val
))
753 value_fetch_lazy (val
);
756 if (b
->type
!= bp_watchpoint
757 && b
->type
!= bp_hardware_watchpoint
758 && b
->type
!= bp_read_watchpoint
759 && b
->type
!= bp_access_watchpoint
760 && b
->type
!= bp_catch_fork
761 && b
->type
!= bp_catch_vfork
762 && b
->type
!= bp_catch_exec
763 && b
->type
!= bp_catch_throw
764 && b
->type
!= bp_catch_catch
768 /* "Normal" instruction breakpoint: either the standard
769 trap-instruction bp (bp_breakpoint), or a
770 bp_hardware_breakpoint. */
772 /* First check to see if we have to handle an overlay. */
773 if (overlay_debugging
== ovly_off
774 || b
->section
== NULL
775 || !(section_is_overlay (b
->section
)))
777 /* No overlay handling: just set the breakpoint. */
779 if (b
->type
== bp_hardware_breakpoint
)
780 val
= target_insert_hw_breakpoint (b
->address
,
783 val
= target_insert_breakpoint (b
->address
, b
->shadow_contents
);
787 /* This breakpoint is in an overlay section.
788 Shall we set a breakpoint at the LMA? */
789 if (!overlay_events_enabled
)
791 /* Yes -- overlay event support is not active,
792 so we must try to set a breakpoint at the LMA.
793 This will not work for a hardware breakpoint. */
794 if (b
->type
== bp_hardware_breakpoint
)
795 warning ("hardware breakpoint %d not supported in overlay!\n",
799 CORE_ADDR addr
= overlay_unmapped_address (b
->address
,
801 /* Set a software (trap) breakpoint at the LMA. */
802 val
= target_insert_breakpoint (addr
, b
->shadow_contents
);
804 fprintf_unfiltered (tmp_error_stream
,
805 "Overlay breakpoint %d failed: in ROM?",
809 /* Shall we set a breakpoint at the VMA? */
810 if (section_is_mapped (b
->section
))
812 /* Yes. This overlay section is mapped into memory. */
813 if (b
->type
== bp_hardware_breakpoint
)
814 val
= target_insert_hw_breakpoint (b
->address
,
817 val
= target_insert_breakpoint (b
->address
,
822 /* No. This breakpoint will not be inserted.
823 No error, but do not mark the bp as 'inserted'. */
830 /* Can't set the breakpoint. */
831 #if defined (DISABLE_UNSETTABLE_BREAK)
832 if (DISABLE_UNSETTABLE_BREAK (b
->address
))
834 /* See also: disable_breakpoints_in_shlibs. */
836 b
->enable_state
= bp_shlib_disabled
;
837 if (!disabled_breaks
)
839 fprintf_unfiltered (tmp_error_stream
,
840 "Cannot insert breakpoint %d.\n",
842 fprintf_unfiltered (tmp_error_stream
,
843 "Temporarily disabling shared library breakpoints:\n");
846 fprintf_unfiltered (tmp_error_stream
,
847 "breakpoint #%d\n", b
->number
);
852 #ifdef ONE_PROCESS_WRITETEXT
855 if (b
->type
== bp_hardware_breakpoint
)
857 hw_breakpoint_error
= 1;
858 fprintf_unfiltered (tmp_error_stream
,
859 "Cannot insert hardware breakpoint %d.\n",
864 fprintf_unfiltered (tmp_error_stream
,
865 "Cannot insert breakpoint %d.\n",
867 fprintf_filtered (tmp_error_stream
,
868 "Error accessing memory address ");
869 print_address_numeric (b
->address
, 1, tmp_error_stream
);
870 fprintf_filtered (tmp_error_stream
, ": %s.\n",
871 safe_strerror (val
));
880 return_val
= val
; /* remember failure */
882 else if (ep_is_exception_catchpoint (b
)
887 /* If we get here, we must have a callback mechanism for exception
888 events -- with g++ style embedded label support, we insert
889 ordinary breakpoints and not catchpoints. */
890 /* Format possible error message */
891 sprintf (message
, message1
, b
->number
);
893 val
= target_insert_breakpoint (b
->address
, b
->shadow_contents
);
896 /* Couldn't set breakpoint for some reason */
897 fprintf_unfiltered (tmp_error_stream
,
898 "Cannot insert catchpoint %d; disabling it.\n",
900 fprintf_filtered (tmp_error_stream
,
901 "Error accessing memory address ");
902 print_address_numeric (b
->address
, 1, tmp_error_stream
);
903 fprintf_filtered (tmp_error_stream
, ": %s.\n",
904 safe_strerror (val
));
905 b
->enable_state
= bp_disabled
;
909 /* Bp set, now make sure callbacks are enabled */
911 args_for_catchpoint_enable args
;
912 args
.kind
= b
->type
== bp_catch_catch
?
913 EX_EVENT_CATCH
: EX_EVENT_THROW
;
915 val
= catch_errors (cover_target_enable_exception_callback
,
917 message
, RETURN_MASK_ALL
);
918 if (val
!= 0 && val
!= -1)
922 /* Check if something went wrong; val == 0 can be ignored */
925 /* something went wrong */
926 fprintf_unfiltered (tmp_error_stream
,
927 "Cannot insert catchpoint %d; disabling it.\n",
929 b
->enable_state
= bp_disabled
;
934 return_val
= val
; /* remember failure */
937 else if ((b
->type
== bp_hardware_watchpoint
||
938 b
->type
== bp_read_watchpoint
||
939 b
->type
== bp_access_watchpoint
)
940 && b
->disposition
!= disp_del_at_next_stop
944 struct frame_info
*saved_frame
;
945 int saved_level
, within_current_scope
;
946 struct value
*mark
= value_mark ();
949 /* Save the current frame and level so we can restore it after
950 evaluating the watchpoint expression on its own frame. */
951 saved_frame
= deprecated_selected_frame
;
952 saved_level
= frame_relative_level (deprecated_selected_frame
);
954 /* Determine if the watchpoint is within scope. */
955 if (b
->exp_valid_block
== NULL
)
956 within_current_scope
= 1;
959 struct frame_info
*fi
;
960 fi
= frame_find_by_id (b
->watchpoint_frame
);
961 within_current_scope
= (fi
!= NULL
);
962 if (within_current_scope
)
966 if (within_current_scope
)
968 /* Evaluate the expression and cut the chain of values
969 produced off from the value chain.
971 Make sure the value returned isn't lazy; we use
972 laziness to determine what memory GDB actually needed
973 in order to compute the value of the expression. */
974 v
= evaluate_expression (b
->exp
);
976 value_release_to_mark (mark
);
981 /* Look at each value on the value chain. */
982 for (; v
; v
= v
->next
)
984 /* If it's a memory location, and GDB actually needed
985 its contents to evaluate the expression, then we
987 if (VALUE_LVAL (v
) == lval_memory
990 struct type
*vtype
= check_typedef (VALUE_TYPE (v
));
992 /* We only watch structs and arrays if user asked
993 for it explicitly, never if they just happen to
994 appear in the middle of some value chain. */
995 if (v
== b
->val_chain
996 || (TYPE_CODE (vtype
) != TYPE_CODE_STRUCT
997 && TYPE_CODE (vtype
) != TYPE_CODE_ARRAY
))
1002 addr
= VALUE_ADDRESS (v
) + VALUE_OFFSET (v
);
1003 len
= TYPE_LENGTH (VALUE_TYPE (v
));
1005 if (b
->type
== bp_read_watchpoint
)
1007 else if (b
->type
== bp_access_watchpoint
)
1010 val
= target_insert_watchpoint (addr
, len
, type
);
1013 /* Don't exit the loop, try to insert
1014 every value on the value chain. That's
1015 because we will be removing all the
1016 watches below, and removing a
1017 watchpoint we didn't insert could have
1025 /* Failure to insert a watchpoint on any memory value in the
1026 value chain brings us here. */
1029 remove_breakpoint (b
, mark_uninserted
);
1030 hw_breakpoint_error
= 1;
1031 fprintf_unfiltered (tmp_error_stream
,
1032 "Could not insert hardware watchpoint %d.\n",
1039 printf_filtered ("Hardware watchpoint %d deleted ", b
->number
);
1040 printf_filtered ("because the program has left the block \n");
1041 printf_filtered ("in which its expression is valid.\n");
1042 if (b
->related_breakpoint
)
1043 b
->related_breakpoint
->disposition
= disp_del_at_next_stop
;
1044 b
->disposition
= disp_del_at_next_stop
;
1047 /* Restore the frame and level. */
1048 if ((saved_frame
!= deprecated_selected_frame
) ||
1049 (saved_level
!= frame_relative_level (deprecated_selected_frame
)))
1050 select_frame (saved_frame
);
1053 return_val
= val
; /* remember failure */
1055 else if ((b
->type
== bp_catch_fork
1056 || b
->type
== bp_catch_vfork
1057 || b
->type
== bp_catch_exec
)
1065 val
= target_insert_fork_catchpoint (PIDGET (inferior_ptid
));
1067 case bp_catch_vfork
:
1068 val
= target_insert_vfork_catchpoint (PIDGET (inferior_ptid
));
1071 val
= target_insert_exec_catchpoint (PIDGET (inferior_ptid
));
1074 warning ("Internal error, %s line %d.", __FILE__
, __LINE__
);
1079 fprintf_unfiltered (tmp_error_stream
,
1080 "Cannot insert catchpoint %d.", b
->number
);
1086 return_val
= val
; /* remember failure */
1092 /* If a hardware breakpoint or watchpoint was inserted, add a
1093 message about possibly exhausted resources. */
1094 if (hw_breakpoint_error
)
1096 fprintf_unfiltered (tmp_error_stream
,
1097 "Could not insert hardware breakpoints:\n\
1098 You may have requested too many hardware breakpoints/watchpoints.\n");
1100 #ifdef ONE_PROCESS_WRITETEXT
1101 if (process_warning
)
1102 fprintf_unfiltered (tmp_error_stream
,
1103 "The same program may be running in another process.");
1105 target_terminal_ours_for_output ();
1106 error_stream (tmp_error_stream
);
1112 remove_breakpoints (void)
1114 register struct breakpoint
*b
;
1121 val
= remove_breakpoint (b
, mark_uninserted
);
1130 remove_hw_watchpoints (void)
1132 register struct breakpoint
*b
;
1138 && (b
->type
== bp_hardware_watchpoint
1139 || b
->type
== bp_read_watchpoint
1140 || b
->type
== bp_access_watchpoint
))
1142 val
= remove_breakpoint (b
, mark_uninserted
);
1151 reattach_breakpoints (int pid
)
1153 register struct breakpoint
*b
;
1155 struct cleanup
*old_chain
= save_inferior_ptid ();
1157 /* Set inferior_ptid; remove_breakpoint uses this global. */
1158 inferior_ptid
= pid_to_ptid (pid
);
1163 remove_breakpoint (b
, mark_inserted
);
1164 if (b
->type
== bp_hardware_breakpoint
)
1165 val
= target_insert_hw_breakpoint (b
->address
, b
->shadow_contents
);
1167 val
= target_insert_breakpoint (b
->address
, b
->shadow_contents
);
1170 do_cleanups (old_chain
);
1175 do_cleanups (old_chain
);
1180 update_breakpoints_after_exec (void)
1182 struct breakpoint
*b
;
1183 struct breakpoint
*temp
;
1185 /* Doing this first prevents the badness of having delete_breakpoint()
1186 write a breakpoint's current "shadow contents" to lift the bp. That
1187 shadow is NOT valid after an exec()! */
1188 mark_breakpoints_out ();
1190 ALL_BREAKPOINTS_SAFE (b
, temp
)
1192 /* Solib breakpoints must be explicitly reset after an exec(). */
1193 if (b
->type
== bp_shlib_event
)
1195 delete_breakpoint (b
);
1199 /* Thread event breakpoints must be set anew after an exec(),
1200 as must overlay event breakpoints. */
1201 if (b
->type
== bp_thread_event
|| b
->type
== bp_overlay_event
)
1203 delete_breakpoint (b
);
1207 /* Step-resume breakpoints are meaningless after an exec(). */
1208 if (b
->type
== bp_step_resume
)
1210 delete_breakpoint (b
);
1214 /* Ditto the sigtramp handler breakpoints. */
1215 if (b
->type
== bp_through_sigtramp
)
1217 delete_breakpoint (b
);
1221 /* Ditto the exception-handling catchpoints. */
1222 if ((b
->type
== bp_catch_catch
) || (b
->type
== bp_catch_throw
))
1224 delete_breakpoint (b
);
1228 /* Don't delete an exec catchpoint, because else the inferior
1229 won't stop when it ought!
1231 Similarly, we probably ought to keep vfork catchpoints, 'cause
1232 on this target, we may not be able to stop when the vfork is
1233 seen, but only when the subsequent exec is seen. (And because
1234 deleting fork catchpoints here but not vfork catchpoints will
1235 seem mysterious to users, keep those too.)
1237 ??rehrauer: Let's hope that merely clearing out this catchpoint's
1238 target address field, if any, is sufficient to have it be reset
1239 automagically. Certainly on HP-UX that's true.
1241 Jim Blandy <jimb@redhat.com>: Actually, zero is a perfectly
1242 valid code address on some platforms (like the OBSOLETE mn10200
1243 and mn10300 simulators). We shouldn't assign any special
1244 interpretation to a breakpoint with a zero address. And in
1245 fact, GDB doesn't --- I can't see what that comment above is
1246 talking about. As far as I can tell, setting the address of a
1247 bp_catch_exec/bp_catch_vfork/bp_catch_fork breakpoint to zero
1248 is meaningless, since those are implemented with HP-UX kernel
1249 hackery, not by storing breakpoint instructions somewhere. */
1250 if ((b
->type
== bp_catch_exec
) ||
1251 (b
->type
== bp_catch_vfork
) ||
1252 (b
->type
== bp_catch_fork
))
1254 b
->address
= (CORE_ADDR
) NULL
;
1258 /* bp_finish is a special case. The only way we ought to be able
1259 to see one of these when an exec() has happened, is if the user
1260 caught a vfork, and then said "finish". Ordinarily a finish just
1261 carries them to the call-site of the current callee, by setting
1262 a temporary bp there and resuming. But in this case, the finish
1263 will carry them entirely through the vfork & exec.
1265 We don't want to allow a bp_finish to remain inserted now. But
1266 we can't safely delete it, 'cause finish_command has a handle to
1267 the bp on a bpstat, and will later want to delete it. There's a
1268 chance (and I've seen it happen) that if we delete the bp_finish
1269 here, that its storage will get reused by the time finish_command
1270 gets 'round to deleting the "use to be a bp_finish" breakpoint.
1271 We really must allow finish_command to delete a bp_finish.
1273 In the absense of a general solution for the "how do we know
1274 it's safe to delete something others may have handles to?"
1275 problem, what we'll do here is just uninsert the bp_finish, and
1276 let finish_command delete it.
1278 (We know the bp_finish is "doomed" in the sense that it's
1279 momentary, and will be deleted as soon as finish_command sees
1280 the inferior stopped. So it doesn't matter that the bp's
1281 address is probably bogus in the new a.out, unlike e.g., the
1282 solib breakpoints.) */
1284 if (b
->type
== bp_finish
)
1289 /* Without a symbolic address, we have little hope of the
1290 pre-exec() address meaning the same thing in the post-exec()
1292 if (b
->addr_string
== NULL
)
1294 delete_breakpoint (b
);
1298 /* If this breakpoint has survived the above battery of checks, then
1299 it must have a symbolic address. Be sure that it gets reevaluated
1300 to a target address, rather than reusing the old evaluation.
1302 Jim Blandy <jimb@redhat.com>: As explained above in the comment
1303 for bp_catch_exec and friends, I'm pretty sure this is entirely
1304 unnecessary. A call to breakpoint_re_set_one always recomputes
1305 the breakpoint's address from scratch, or deletes it if it can't.
1306 So I think this assignment could be deleted without effect. */
1307 b
->address
= (CORE_ADDR
) NULL
;
1309 /* FIXME what about longjmp breakpoints? Re-create them here? */
1310 create_overlay_event_breakpoint ("_ovly_debug_event");
1314 detach_breakpoints (int pid
)
1316 register struct breakpoint
*b
;
1318 struct cleanup
*old_chain
= save_inferior_ptid ();
1320 if (pid
== PIDGET (inferior_ptid
))
1321 error ("Cannot detach breakpoints of inferior_ptid");
1323 /* Set inferior_ptid; remove_breakpoint uses this global. */
1324 inferior_ptid
= pid_to_ptid (pid
);
1329 val
= remove_breakpoint (b
, mark_inserted
);
1332 do_cleanups (old_chain
);
1337 do_cleanups (old_chain
);
1342 remove_breakpoint (struct breakpoint
*b
, insertion_state_t is
)
1346 if (b
->enable_state
== bp_permanent
)
1347 /* Permanent breakpoints cannot be inserted or removed. */
1350 if (b
->type
== bp_none
)
1351 warning ("attempted to remove apparently deleted breakpoint #%d?",
1354 if (b
->type
!= bp_watchpoint
1355 && b
->type
!= bp_hardware_watchpoint
1356 && b
->type
!= bp_read_watchpoint
1357 && b
->type
!= bp_access_watchpoint
1358 && b
->type
!= bp_catch_fork
1359 && b
->type
!= bp_catch_vfork
1360 && b
->type
!= bp_catch_exec
1361 && b
->type
!= bp_catch_catch
1362 && b
->type
!= bp_catch_throw
)
1364 /* "Normal" instruction breakpoint: either the standard
1365 trap-instruction bp (bp_breakpoint), or a
1366 bp_hardware_breakpoint. */
1368 /* First check to see if we have to handle an overlay. */
1369 if (overlay_debugging
== ovly_off
1370 || b
->section
== NULL
1371 || !(section_is_overlay (b
->section
)))
1373 /* No overlay handling: just remove the breakpoint. */
1375 if (b
->type
== bp_hardware_breakpoint
)
1376 val
= target_remove_hw_breakpoint (b
->address
,
1377 b
->shadow_contents
);
1379 val
= target_remove_breakpoint (b
->address
, b
->shadow_contents
);
1383 /* This breakpoint is in an overlay section.
1384 Did we set a breakpoint at the LMA? */
1385 if (!overlay_events_enabled
)
1387 /* Yes -- overlay event support is not active, so we
1388 should have set a breakpoint at the LMA. Remove it.
1390 CORE_ADDR addr
= overlay_unmapped_address (b
->address
,
1392 /* Ignore any failures: if the LMA is in ROM, we will
1393 have already warned when we failed to insert it. */
1394 if (b
->type
!= bp_hardware_breakpoint
)
1395 target_remove_hw_breakpoint (addr
, b
->shadow_contents
);
1397 target_remove_breakpoint (addr
, b
->shadow_contents
);
1399 /* Did we set a breakpoint at the VMA?
1400 If so, we will have marked the breakpoint 'inserted'. */
1403 /* Yes -- remove it. Previously we did not bother to
1404 remove the breakpoint if the section had been
1405 unmapped, but let's not rely on that being safe. We
1406 don't know what the overlay manager might do. */
1407 if (b
->type
== bp_hardware_breakpoint
)
1408 val
= target_remove_hw_breakpoint (b
->address
,
1409 b
->shadow_contents
);
1411 val
= target_remove_breakpoint (b
->address
,
1412 b
->shadow_contents
);
1416 /* No -- not inserted, so no need to remove. No error. */
1422 b
->inserted
= (is
== mark_inserted
);
1424 else if ((b
->type
== bp_hardware_watchpoint
||
1425 b
->type
== bp_read_watchpoint
||
1426 b
->type
== bp_access_watchpoint
)
1427 && b
->enable_state
== bp_enabled
1433 b
->inserted
= (is
== mark_inserted
);
1434 /* Walk down the saved value chain. */
1435 for (v
= b
->val_chain
; v
; v
= v
->next
)
1437 /* For each memory reference remove the watchpoint
1439 if (VALUE_LVAL (v
) == lval_memory
1440 && ! VALUE_LAZY (v
))
1442 struct type
*vtype
= check_typedef (VALUE_TYPE (v
));
1444 if (v
== b
->val_chain
1445 || (TYPE_CODE (vtype
) != TYPE_CODE_STRUCT
1446 && TYPE_CODE (vtype
) != TYPE_CODE_ARRAY
))
1451 addr
= VALUE_ADDRESS (v
) + VALUE_OFFSET (v
);
1452 len
= TYPE_LENGTH (VALUE_TYPE (v
));
1454 if (b
->type
== bp_read_watchpoint
)
1456 else if (b
->type
== bp_access_watchpoint
)
1459 val
= target_remove_watchpoint (addr
, len
, type
);
1466 /* Failure to remove any of the hardware watchpoints comes here. */
1467 if ((is
== mark_uninserted
) && (b
->inserted
))
1468 warning ("Could not remove hardware watchpoint %d.",
1471 /* Free the saved value chain. We will construct a new one
1472 the next time the watchpoint is inserted. */
1473 for (v
= b
->val_chain
; v
; v
= n
)
1478 b
->val_chain
= NULL
;
1480 else if ((b
->type
== bp_catch_fork
||
1481 b
->type
== bp_catch_vfork
||
1482 b
->type
== bp_catch_exec
)
1483 && b
->enable_state
== bp_enabled
1490 val
= target_remove_fork_catchpoint (PIDGET (inferior_ptid
));
1492 case bp_catch_vfork
:
1493 val
= target_remove_vfork_catchpoint (PIDGET (inferior_ptid
));
1496 val
= target_remove_exec_catchpoint (PIDGET (inferior_ptid
));
1499 warning ("Internal error, %s line %d.", __FILE__
, __LINE__
);
1504 b
->inserted
= (is
== mark_inserted
);
1506 else if ((b
->type
== bp_catch_catch
||
1507 b
->type
== bp_catch_throw
)
1508 && b
->enable_state
== bp_enabled
1512 val
= target_remove_breakpoint (b
->address
, b
->shadow_contents
);
1515 b
->inserted
= (is
== mark_inserted
);
1517 else if (ep_is_exception_catchpoint (b
)
1518 && b
->inserted
/* sometimes previous insert doesn't happen */
1519 && b
->enable_state
== bp_enabled
1523 val
= target_remove_breakpoint (b
->address
, b
->shadow_contents
);
1527 b
->inserted
= (is
== mark_inserted
);
1533 /* Clear the "inserted" flag in all breakpoints. */
1536 mark_breakpoints_out (void)
1538 register struct breakpoint
*b
;
1544 /* Clear the "inserted" flag in all breakpoints and delete any
1545 breakpoints which should go away between runs of the program.
1547 Plus other such housekeeping that has to be done for breakpoints
1550 Note: this function gets called at the end of a run (by
1551 generic_mourn_inferior) and when a run begins (by
1552 init_wait_for_inferior). */
1557 breakpoint_init_inferior (enum inf_context context
)
1559 register struct breakpoint
*b
, *temp
;
1560 static int warning_needed
= 0;
1562 ALL_BREAKPOINTS_SAFE (b
, temp
)
1569 case bp_watchpoint_scope
:
1571 /* If the call dummy breakpoint is at the entry point it will
1572 cause problems when the inferior is rerun, so we better
1575 Also get rid of scope breakpoints. */
1576 delete_breakpoint (b
);
1580 case bp_hardware_watchpoint
:
1581 case bp_read_watchpoint
:
1582 case bp_access_watchpoint
:
1584 /* Likewise for watchpoints on local expressions. */
1585 if (b
->exp_valid_block
!= NULL
)
1586 delete_breakpoint (b
);
1587 if (context
== inf_starting
)
1589 /* Reset val field to force reread of starting value
1590 in insert_breakpoints. */
1592 value_free (b
->val
);
1597 /* Likewise for exception catchpoints in dynamic-linked
1598 executables where required */
1599 if (ep_is_exception_catchpoint (b
) &&
1600 exception_catchpoints_are_fragile
)
1603 delete_breakpoint (b
);
1609 if (exception_catchpoints_are_fragile
)
1610 exception_support_initialized
= 0;
1612 /* Don't issue the warning unless it's really needed... */
1613 if (warning_needed
&& (context
!= inf_exited
))
1615 warning ("Exception catchpoints from last run were deleted.");
1616 warning ("You must reinsert them explicitly.");
1621 /* breakpoint_here_p (PC) returns non-zero if an enabled breakpoint
1622 exists at PC. It returns ordinary_breakpoint_here if it's an
1623 ordinary breakpoint, or permanent_breakpoint_here if it's a
1624 permanent breakpoint.
1625 - When continuing from a location with an ordinary breakpoint, we
1626 actually single step once before calling insert_breakpoints.
1627 - When continuing from a localion with a permanent breakpoint, we
1628 need to use the `SKIP_PERMANENT_BREAKPOINT' macro, provided by
1629 the target, to advance the PC past the breakpoint. */
1631 enum breakpoint_here
1632 breakpoint_here_p (CORE_ADDR pc
)
1634 register struct breakpoint
*b
;
1635 int any_breakpoint_here
= 0;
1638 if ((b
->enable_state
== bp_enabled
1639 || b
->enable_state
== bp_permanent
)
1640 && b
->address
== pc
) /* bp is enabled and matches pc */
1642 if (overlay_debugging
1643 && section_is_overlay (b
->section
)
1644 && !section_is_mapped (b
->section
))
1645 continue; /* unmapped overlay -- can't be a match */
1646 else if (b
->enable_state
== bp_permanent
)
1647 return permanent_breakpoint_here
;
1649 any_breakpoint_here
= 1;
1652 return any_breakpoint_here
? ordinary_breakpoint_here
: 0;
1656 /* breakpoint_inserted_here_p (PC) is just like breakpoint_here_p(),
1657 but it only returns true if there is actually a breakpoint inserted
1661 breakpoint_inserted_here_p (CORE_ADDR pc
)
1663 register struct breakpoint
*b
;
1667 && b
->address
== pc
) /* bp is inserted and matches pc */
1669 if (overlay_debugging
1670 && section_is_overlay (b
->section
)
1671 && !section_is_mapped (b
->section
))
1672 continue; /* unmapped overlay -- can't be a match */
1680 /* Return nonzero if FRAME is a dummy frame. We can't use
1681 DEPRECATED_PC_IN_CALL_DUMMY because figuring out the saved SP would
1682 take too much time, at least using get_saved_register on the 68k.
1683 This means that for this function to work right a port must use the
1684 bp_call_dummy breakpoint. */
1687 deprecated_frame_in_dummy (struct frame_info
*frame
)
1689 struct breakpoint
*b
;
1694 /* This function is used by two files: get_frame_type(), after first
1695 checking that !DEPRECATED_USE_GENERIC_DUMMY_FRAMES; and
1696 sparc-tdep.c, which doesn't yet use generic dummy frames anyway. */
1697 gdb_assert (!DEPRECATED_USE_GENERIC_DUMMY_FRAMES
);
1701 if (b
->type
== bp_call_dummy
1702 && frame_id_eq (b
->frame_id
, get_frame_id (frame
))
1703 /* We need to check the PC as well as the frame on the sparc,
1704 for signals.exp in the testsuite. */
1705 && (get_frame_pc (frame
)
1707 - SIZEOF_CALL_DUMMY_WORDS
/ sizeof (LONGEST
) * REGISTER_SIZE
))
1708 && get_frame_pc (frame
) <= b
->address
)
1714 /* breakpoint_thread_match (PC, PID) returns true if the breakpoint at
1715 PC is valid for process/thread PID. */
1718 breakpoint_thread_match (CORE_ADDR pc
, ptid_t ptid
)
1720 struct breakpoint
*b
;
1723 thread
= pid_to_thread_id (ptid
);
1726 if (b
->enable_state
!= bp_disabled
1727 && b
->enable_state
!= bp_shlib_disabled
1728 && b
->enable_state
!= bp_call_disabled
1730 && (b
->thread
== -1 || b
->thread
== thread
))
1732 if (overlay_debugging
1733 && section_is_overlay (b
->section
)
1734 && !section_is_mapped (b
->section
))
1735 continue; /* unmapped overlay -- can't be a match */
1744 /* bpstat stuff. External routines' interfaces are documented
1748 ep_is_catchpoint (struct breakpoint
*ep
)
1751 (ep
->type
== bp_catch_load
)
1752 || (ep
->type
== bp_catch_unload
)
1753 || (ep
->type
== bp_catch_fork
)
1754 || (ep
->type
== bp_catch_vfork
)
1755 || (ep
->type
== bp_catch_exec
)
1756 || (ep
->type
== bp_catch_catch
)
1757 || (ep
->type
== bp_catch_throw
);
1759 /* ??rehrauer: Add more kinds here, as are implemented... */
1763 ep_is_shlib_catchpoint (struct breakpoint
*ep
)
1766 (ep
->type
== bp_catch_load
)
1767 || (ep
->type
== bp_catch_unload
);
1771 ep_is_exception_catchpoint (struct breakpoint
*ep
)
1774 (ep
->type
== bp_catch_catch
)
1775 || (ep
->type
== bp_catch_throw
);
1778 /* Clear a bpstat so that it says we are not at any breakpoint.
1779 Also free any storage that is part of a bpstat. */
1782 bpstat_clear (bpstat
*bsp
)
1793 if (p
->old_val
!= NULL
)
1794 value_free (p
->old_val
);
1795 free_command_lines (&p
->commands
);
1802 /* Return a copy of a bpstat. Like "bs1 = bs2" but all storage that
1803 is part of the bpstat is copied as well. */
1806 bpstat_copy (bpstat bs
)
1810 bpstat retval
= NULL
;
1815 for (; bs
!= NULL
; bs
= bs
->next
)
1817 tmp
= (bpstat
) xmalloc (sizeof (*tmp
));
1818 memcpy (tmp
, bs
, sizeof (*tmp
));
1820 /* This is the first thing in the chain. */
1830 /* Find the bpstat associated with this breakpoint */
1833 bpstat_find_breakpoint (bpstat bsp
, struct breakpoint
*breakpoint
)
1838 for (; bsp
!= NULL
; bsp
= bsp
->next
)
1840 if (bsp
->breakpoint_at
== breakpoint
)
1846 /* Find a step_resume breakpoint associated with this bpstat.
1847 (If there are multiple step_resume bp's on the list, this function
1848 will arbitrarily pick one.)
1850 It is an error to use this function if BPSTAT doesn't contain a
1851 step_resume breakpoint.
1853 See wait_for_inferior's use of this function. */
1855 bpstat_find_step_resume_breakpoint (bpstat bsp
)
1860 error ("Internal error (bpstat_find_step_resume_breakpoint)");
1862 current_thread
= pid_to_thread_id (inferior_ptid
);
1864 for (; bsp
!= NULL
; bsp
= bsp
->next
)
1866 if ((bsp
->breakpoint_at
!= NULL
) &&
1867 (bsp
->breakpoint_at
->type
== bp_step_resume
) &&
1868 (bsp
->breakpoint_at
->thread
== current_thread
||
1869 bsp
->breakpoint_at
->thread
== -1))
1870 return bsp
->breakpoint_at
;
1873 error ("Internal error (no step_resume breakpoint found)");
1877 /* Return the breakpoint number of the first breakpoint we are stopped
1878 at. *BSP upon return is a bpstat which points to the remaining
1879 breakpoints stopped at (but which is not guaranteed to be good for
1880 anything but further calls to bpstat_num).
1881 Return 0 if passed a bpstat which does not indicate any breakpoints. */
1884 bpstat_num (bpstat
*bsp
)
1886 struct breakpoint
*b
;
1889 return 0; /* No more breakpoint values */
1892 b
= (*bsp
)->breakpoint_at
;
1893 *bsp
= (*bsp
)->next
;
1895 return -1; /* breakpoint that's been deleted since */
1897 return b
->number
; /* We have its number */
1901 /* Modify BS so that the actions will not be performed. */
1904 bpstat_clear_actions (bpstat bs
)
1906 for (; bs
!= NULL
; bs
= bs
->next
)
1908 free_command_lines (&bs
->commands
);
1909 if (bs
->old_val
!= NULL
)
1911 value_free (bs
->old_val
);
1917 /* Stub for cleaning up our state if we error-out of a breakpoint command */
1920 cleanup_executing_breakpoints (void *ignore
)
1922 executing_breakpoint_commands
= 0;
1925 /* Execute all the commands associated with all the breakpoints at this
1926 location. Any of these commands could cause the process to proceed
1927 beyond this point, etc. We look out for such changes by checking
1928 the global "breakpoint_proceeded" after each command. */
1931 bpstat_do_actions (bpstat
*bsp
)
1934 struct cleanup
*old_chain
;
1935 struct command_line
*cmd
;
1937 /* Avoid endless recursion if a `source' command is contained
1939 if (executing_breakpoint_commands
)
1942 executing_breakpoint_commands
= 1;
1943 old_chain
= make_cleanup (cleanup_executing_breakpoints
, 0);
1946 /* Note that (as of this writing), our callers all appear to
1947 be passing us the address of global stop_bpstat. And, if
1948 our calls to execute_control_command cause the inferior to
1949 proceed, that global (and hence, *bsp) will change.
1951 We must be careful to not touch *bsp unless the inferior
1952 has not proceeded. */
1954 /* This pointer will iterate over the list of bpstat's. */
1957 breakpoint_proceeded
= 0;
1958 for (; bs
!= NULL
; bs
= bs
->next
)
1963 execute_control_command (cmd
);
1965 if (breakpoint_proceeded
)
1970 if (breakpoint_proceeded
)
1971 /* The inferior is proceeded by the command; bomb out now.
1972 The bpstat chain has been blown away by wait_for_inferior.
1973 But since execution has stopped again, there is a new bpstat
1974 to look at, so start over. */
1977 free_command_lines (&bs
->commands
);
1979 do_cleanups (old_chain
);
1982 /* This is the normal print function for a bpstat. In the future,
1983 much of this logic could (should?) be moved to bpstat_stop_status,
1984 by having it set different print_it values.
1986 Current scheme: When we stop, bpstat_print() is called. It loops
1987 through the bpstat list of things causing this stop, calling the
1988 print_bp_stop_message function on each one. The behavior of the
1989 print_bp_stop_message function depends on the print_it field of
1990 bpstat. If such field so indicates, call this function here.
1992 Return values from this routine (ultimately used by bpstat_print()
1993 and normal_stop() to decide what to do):
1994 PRINT_NOTHING: Means we already printed all we needed to print,
1995 don't print anything else.
1996 PRINT_SRC_ONLY: Means we printed something, and we do *not* desire
1997 that something to be followed by a location.
1998 PRINT_SCR_AND_LOC: Means we printed something, and we *do* desire
1999 that something to be followed by a location.
2000 PRINT_UNKNOWN: Means we printed nothing or we need to do some more
2003 static enum print_stop_action
2004 print_it_typical (bpstat bs
)
2006 struct cleanup
*old_chain
, *ui_out_chain
;
2007 struct ui_stream
*stb
;
2008 stb
= ui_out_stream_new (uiout
);
2009 old_chain
= make_cleanup_ui_out_stream_delete (stb
);
2010 /* bs->breakpoint_at can be NULL if it was a momentary breakpoint
2011 which has since been deleted. */
2012 if (bs
->breakpoint_at
== NULL
)
2013 return PRINT_UNKNOWN
;
2015 switch (bs
->breakpoint_at
->type
)
2018 case bp_hardware_breakpoint
:
2019 annotate_breakpoint (bs
->breakpoint_at
->number
);
2020 ui_out_text (uiout
, "\nBreakpoint ");
2021 if (ui_out_is_mi_like_p (uiout
))
2022 ui_out_field_string (uiout
, "reason", "breakpoint-hit");
2023 ui_out_field_int (uiout
, "bkptno", bs
->breakpoint_at
->number
);
2024 ui_out_text (uiout
, ", ");
2025 return PRINT_SRC_AND_LOC
;
2028 case bp_shlib_event
:
2029 /* Did we stop because the user set the stop_on_solib_events
2030 variable? (If so, we report this as a generic, "Stopped due
2031 to shlib event" message.) */
2032 printf_filtered ("Stopped due to shared library event\n");
2033 return PRINT_NOTHING
;
2036 case bp_thread_event
:
2037 /* Not sure how we will get here.
2038 GDB should not stop for these breakpoints. */
2039 printf_filtered ("Thread Event Breakpoint: gdb should not stop!\n");
2040 return PRINT_NOTHING
;
2043 case bp_overlay_event
:
2044 /* By analogy with the thread event, GDB should not stop for these. */
2045 printf_filtered ("Overlay Event Breakpoint: gdb should not stop!\n");
2046 return PRINT_NOTHING
;
2050 annotate_catchpoint (bs
->breakpoint_at
->number
);
2051 printf_filtered ("\nCatchpoint %d (", bs
->breakpoint_at
->number
);
2052 printf_filtered ("loaded");
2053 printf_filtered (" %s), ", bs
->breakpoint_at
->triggered_dll_pathname
);
2054 return PRINT_SRC_AND_LOC
;
2057 case bp_catch_unload
:
2058 annotate_catchpoint (bs
->breakpoint_at
->number
);
2059 printf_filtered ("\nCatchpoint %d (", bs
->breakpoint_at
->number
);
2060 printf_filtered ("unloaded");
2061 printf_filtered (" %s), ", bs
->breakpoint_at
->triggered_dll_pathname
);
2062 return PRINT_SRC_AND_LOC
;
2066 annotate_catchpoint (bs
->breakpoint_at
->number
);
2067 printf_filtered ("\nCatchpoint %d (", bs
->breakpoint_at
->number
);
2068 printf_filtered ("forked");
2069 printf_filtered (" process %d), ",
2070 bs
->breakpoint_at
->forked_inferior_pid
);
2071 return PRINT_SRC_AND_LOC
;
2074 case bp_catch_vfork
:
2075 annotate_catchpoint (bs
->breakpoint_at
->number
);
2076 printf_filtered ("\nCatchpoint %d (", bs
->breakpoint_at
->number
);
2077 printf_filtered ("vforked");
2078 printf_filtered (" process %d), ",
2079 bs
->breakpoint_at
->forked_inferior_pid
);
2080 return PRINT_SRC_AND_LOC
;
2084 annotate_catchpoint (bs
->breakpoint_at
->number
);
2085 printf_filtered ("\nCatchpoint %d (exec'd %s), ",
2086 bs
->breakpoint_at
->number
,
2087 bs
->breakpoint_at
->exec_pathname
);
2088 return PRINT_SRC_AND_LOC
;
2091 case bp_catch_catch
:
2092 if (current_exception_event
&&
2093 (CURRENT_EXCEPTION_KIND
== EX_EVENT_CATCH
))
2095 annotate_catchpoint (bs
->breakpoint_at
->number
);
2096 printf_filtered ("\nCatchpoint %d (exception caught), ",
2097 bs
->breakpoint_at
->number
);
2098 printf_filtered ("throw location ");
2099 if (CURRENT_EXCEPTION_THROW_PC
&& CURRENT_EXCEPTION_THROW_LINE
)
2100 printf_filtered ("%s:%d",
2101 CURRENT_EXCEPTION_THROW_FILE
,
2102 CURRENT_EXCEPTION_THROW_LINE
);
2104 printf_filtered ("unknown");
2106 printf_filtered (", catch location ");
2107 if (CURRENT_EXCEPTION_CATCH_PC
&& CURRENT_EXCEPTION_CATCH_LINE
)
2108 printf_filtered ("%s:%d",
2109 CURRENT_EXCEPTION_CATCH_FILE
,
2110 CURRENT_EXCEPTION_CATCH_LINE
);
2112 printf_filtered ("unknown");
2114 printf_filtered ("\n");
2115 /* don't bother to print location frame info */
2116 return PRINT_SRC_ONLY
;
2120 /* really throw, some other bpstat will handle it */
2121 return PRINT_UNKNOWN
;
2125 case bp_catch_throw
:
2126 if (current_exception_event
&&
2127 (CURRENT_EXCEPTION_KIND
== EX_EVENT_THROW
))
2129 annotate_catchpoint (bs
->breakpoint_at
->number
);
2130 printf_filtered ("\nCatchpoint %d (exception thrown), ",
2131 bs
->breakpoint_at
->number
);
2132 printf_filtered ("throw location ");
2133 if (CURRENT_EXCEPTION_THROW_PC
&& CURRENT_EXCEPTION_THROW_LINE
)
2134 printf_filtered ("%s:%d",
2135 CURRENT_EXCEPTION_THROW_FILE
,
2136 CURRENT_EXCEPTION_THROW_LINE
);
2138 printf_filtered ("unknown");
2140 printf_filtered (", catch location ");
2141 if (CURRENT_EXCEPTION_CATCH_PC
&& CURRENT_EXCEPTION_CATCH_LINE
)
2142 printf_filtered ("%s:%d",
2143 CURRENT_EXCEPTION_CATCH_FILE
,
2144 CURRENT_EXCEPTION_CATCH_LINE
);
2146 printf_filtered ("unknown");
2148 printf_filtered ("\n");
2149 /* don't bother to print location frame info */
2150 return PRINT_SRC_ONLY
;
2154 /* really catch, some other bpstat will handle it */
2155 return PRINT_UNKNOWN
;
2160 case bp_hardware_watchpoint
:
2161 if (bs
->old_val
!= NULL
)
2163 annotate_watchpoint (bs
->breakpoint_at
->number
);
2164 if (ui_out_is_mi_like_p (uiout
))
2165 ui_out_field_string (uiout
, "reason", "watchpoint-trigger");
2166 mention (bs
->breakpoint_at
);
2167 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "value");
2168 ui_out_text (uiout
, "\nOld value = ");
2169 value_print (bs
->old_val
, stb
->stream
, 0, Val_pretty_default
);
2170 ui_out_field_stream (uiout
, "old", stb
);
2171 ui_out_text (uiout
, "\nNew value = ");
2172 value_print (bs
->breakpoint_at
->val
, stb
->stream
, 0, Val_pretty_default
);
2173 ui_out_field_stream (uiout
, "new", stb
);
2174 do_cleanups (ui_out_chain
);
2175 ui_out_text (uiout
, "\n");
2176 value_free (bs
->old_val
);
2179 /* More than one watchpoint may have been triggered. */
2180 return PRINT_UNKNOWN
;
2183 case bp_read_watchpoint
:
2184 if (ui_out_is_mi_like_p (uiout
))
2185 ui_out_field_string (uiout
, "reason", "read-watchpoint-trigger");
2186 mention (bs
->breakpoint_at
);
2187 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "value");
2188 ui_out_text (uiout
, "\nValue = ");
2189 value_print (bs
->breakpoint_at
->val
, stb
->stream
, 0, Val_pretty_default
);
2190 ui_out_field_stream (uiout
, "value", stb
);
2191 do_cleanups (ui_out_chain
);
2192 ui_out_text (uiout
, "\n");
2193 return PRINT_UNKNOWN
;
2196 case bp_access_watchpoint
:
2197 if (bs
->old_val
!= NULL
)
2199 annotate_watchpoint (bs
->breakpoint_at
->number
);
2200 if (ui_out_is_mi_like_p (uiout
))
2201 ui_out_field_string (uiout
, "reason", "access-watchpoint-trigger");
2202 mention (bs
->breakpoint_at
);
2203 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "value");
2204 ui_out_text (uiout
, "\nOld value = ");
2205 value_print (bs
->old_val
, stb
->stream
, 0, Val_pretty_default
);
2206 ui_out_field_stream (uiout
, "old", stb
);
2207 value_free (bs
->old_val
);
2209 ui_out_text (uiout
, "\nNew value = ");
2213 mention (bs
->breakpoint_at
);
2214 if (ui_out_is_mi_like_p (uiout
))
2215 ui_out_field_string (uiout
, "reason", "access-watchpoint-trigger");
2216 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "value");
2217 ui_out_text (uiout
, "\nValue = ");
2219 value_print (bs
->breakpoint_at
->val
, stb
->stream
, 0,Val_pretty_default
);
2220 ui_out_field_stream (uiout
, "new", stb
);
2221 do_cleanups (ui_out_chain
);
2222 ui_out_text (uiout
, "\n");
2223 return PRINT_UNKNOWN
;
2226 /* Fall through, we don't deal with these types of breakpoints
2230 if (ui_out_is_mi_like_p (uiout
))
2231 ui_out_field_string (uiout
, "reason", "function-finished");
2232 return PRINT_UNKNOWN
;
2236 if (ui_out_is_mi_like_p (uiout
))
2237 ui_out_field_string (uiout
, "reason", "location-reached");
2238 return PRINT_UNKNOWN
;
2243 case bp_longjmp_resume
:
2244 case bp_step_resume
:
2245 case bp_through_sigtramp
:
2246 case bp_watchpoint_scope
:
2249 return PRINT_UNKNOWN
;
2253 /* Generic routine for printing messages indicating why we
2254 stopped. The behavior of this function depends on the value
2255 'print_it' in the bpstat structure. Under some circumstances we
2256 may decide not to print anything here and delegate the task to
2259 static enum print_stop_action
2260 print_bp_stop_message (bpstat bs
)
2262 switch (bs
->print_it
)
2265 /* Nothing should be printed for this bpstat entry. */
2266 return PRINT_UNKNOWN
;
2270 /* We still want to print the frame, but we already printed the
2271 relevant messages. */
2272 return PRINT_SRC_AND_LOC
;
2275 case print_it_normal
:
2276 /* Normal case, we handle everything in print_it_typical. */
2277 return print_it_typical (bs
);
2280 internal_error (__FILE__
, __LINE__
,
2281 "print_bp_stop_message: unrecognized enum value");
2286 /* Print a message indicating what happened. This is called from
2287 normal_stop(). The input to this routine is the head of the bpstat
2288 list - a list of the eventpoints that caused this stop. This
2289 routine calls the generic print routine for printing a message
2290 about reasons for stopping. This will print (for example) the
2291 "Breakpoint n," part of the output. The return value of this
2294 PRINT_UNKNOWN: Means we printed nothing
2295 PRINT_SRC_AND_LOC: Means we printed something, and expect subsequent
2296 code to print the location. An example is
2297 "Breakpoint 1, " which should be followed by
2299 PRINT_SRC_ONLY: Means we printed something, but there is no need
2300 to also print the location part of the message.
2301 An example is the catch/throw messages, which
2302 don't require a location appended to the end.
2303 PRINT_NOTHING: We have done some printing and we don't need any
2304 further info to be printed.*/
2306 enum print_stop_action
2307 bpstat_print (bpstat bs
)
2311 /* Maybe another breakpoint in the chain caused us to stop.
2312 (Currently all watchpoints go on the bpstat whether hit or not.
2313 That probably could (should) be changed, provided care is taken
2314 with respect to bpstat_explains_signal). */
2315 for (; bs
; bs
= bs
->next
)
2317 val
= print_bp_stop_message (bs
);
2318 if (val
== PRINT_SRC_ONLY
2319 || val
== PRINT_SRC_AND_LOC
2320 || val
== PRINT_NOTHING
)
2324 /* We reached the end of the chain, or we got a null BS to start
2325 with and nothing was printed. */
2326 return PRINT_UNKNOWN
;
2329 /* Evaluate the expression EXP and return 1 if value is zero.
2330 This is used inside a catch_errors to evaluate the breakpoint condition.
2331 The argument is a "struct expression *" that has been cast to char * to
2332 make it pass through catch_errors. */
2335 breakpoint_cond_eval (void *exp
)
2337 struct value
*mark
= value_mark ();
2338 int i
= !value_true (evaluate_expression ((struct expression
*) exp
));
2339 value_free_to_mark (mark
);
2343 /* Allocate a new bpstat and chain it to the current one. */
2346 bpstat_alloc (struct breakpoint
*b
, bpstat cbs
/* Current "bs" value */ )
2350 bs
= (bpstat
) xmalloc (sizeof (*bs
));
2352 bs
->breakpoint_at
= b
;
2353 /* If the condition is false, etc., don't do the commands. */
2354 bs
->commands
= NULL
;
2356 bs
->print_it
= print_it_normal
;
2360 /* Possible return values for watchpoint_check (this can't be an enum
2361 because of check_errors). */
2362 /* The watchpoint has been deleted. */
2363 #define WP_DELETED 1
2364 /* The value has changed. */
2365 #define WP_VALUE_CHANGED 2
2366 /* The value has not changed. */
2367 #define WP_VALUE_NOT_CHANGED 3
2369 #define BP_TEMPFLAG 1
2370 #define BP_HARDWAREFLAG 2
2372 /* Check watchpoint condition. */
2375 watchpoint_check (void *p
)
2377 bpstat bs
= (bpstat
) p
;
2378 struct breakpoint
*b
;
2379 struct frame_info
*fr
;
2380 int within_current_scope
;
2382 b
= bs
->breakpoint_at
;
2384 if (b
->exp_valid_block
== NULL
)
2385 within_current_scope
= 1;
2388 /* There is no current frame at this moment. If we're going to have
2389 any chance of handling watchpoints on local variables, we'll need
2390 the frame chain (so we can determine if we're in scope). */
2391 reinit_frame_cache ();
2392 fr
= frame_find_by_id (b
->watchpoint_frame
);
2393 within_current_scope
= (fr
!= NULL
);
2394 /* in_function_epilogue_p() returns a non-zero value if we're still
2395 in the function but the stack frame has already been invalidated.
2396 Since we can't rely on the values of local variables after the
2397 stack has been destroyed, we are treating the watchpoint in that
2398 state as `not changed' without further checking. */
2399 if (within_current_scope
&& fr
== get_current_frame ()
2400 && gdbarch_in_function_epilogue_p (current_gdbarch
, read_pc ()))
2401 return WP_VALUE_NOT_CHANGED
;
2402 if (within_current_scope
)
2403 /* If we end up stopping, the current frame will get selected
2404 in normal_stop. So this call to select_frame won't affect
2409 if (within_current_scope
)
2411 /* We use value_{,free_to_}mark because it could be a
2412 *long* time before we return to the command level and
2413 call free_all_values. We can't call free_all_values because
2414 we might be in the middle of evaluating a function call. */
2416 struct value
*mark
= value_mark ();
2417 struct value
*new_val
= evaluate_expression (bs
->breakpoint_at
->exp
);
2418 if (!value_equal (b
->val
, new_val
))
2420 release_value (new_val
);
2421 value_free_to_mark (mark
);
2422 bs
->old_val
= b
->val
;
2424 /* We will stop here */
2425 return WP_VALUE_CHANGED
;
2429 /* Nothing changed, don't do anything. */
2430 value_free_to_mark (mark
);
2431 /* We won't stop here */
2432 return WP_VALUE_NOT_CHANGED
;
2437 /* This seems like the only logical thing to do because
2438 if we temporarily ignored the watchpoint, then when
2439 we reenter the block in which it is valid it contains
2440 garbage (in the case of a function, it may have two
2441 garbage values, one before and one after the prologue).
2442 So we can't even detect the first assignment to it and
2443 watch after that (since the garbage may or may not equal
2444 the first value assigned). */
2445 /* We print all the stop information in print_it_typical(), but
2446 in this case, by the time we call print_it_typical() this bp
2447 will be deleted already. So we have no choice but print the
2448 information here. */
2449 if (ui_out_is_mi_like_p (uiout
))
2450 ui_out_field_string (uiout
, "reason", "watchpoint-scope");
2451 ui_out_text (uiout
, "\nWatchpoint ");
2452 ui_out_field_int (uiout
, "wpnum", bs
->breakpoint_at
->number
);
2453 ui_out_text (uiout
, " deleted because the program has left the block in\n\
2454 which its expression is valid.\n");
2456 if (b
->related_breakpoint
)
2457 b
->related_breakpoint
->disposition
= disp_del_at_next_stop
;
2458 b
->disposition
= disp_del_at_next_stop
;
2464 /* Get a bpstat associated with having just stopped at address *PC
2465 and frame address CORE_ADDRESS. Update *PC to point at the
2466 breakpoint (if we hit a breakpoint). NOT_A_SW_BREAKPOINT is nonzero
2467 if this is known to not be a real breakpoint (it could still be a
2468 watchpoint, though). */
2470 /* Determine whether we stopped at a breakpoint, etc, or whether we
2471 don't understand this stop. Result is a chain of bpstat's such that:
2473 if we don't understand the stop, the result is a null pointer.
2475 if we understand why we stopped, the result is not null.
2477 Each element of the chain refers to a particular breakpoint or
2478 watchpoint at which we have stopped. (We may have stopped for
2479 several reasons concurrently.)
2481 Each element of the chain has valid next, breakpoint_at,
2482 commands, FIXME??? fields. */
2485 bpstat_stop_status (CORE_ADDR
*pc
, int not_a_sw_breakpoint
)
2487 register struct breakpoint
*b
, *temp
;
2489 /* True if we've hit a breakpoint (as opposed to a watchpoint). */
2490 int real_breakpoint
= 0;
2491 /* Root of the chain of bpstat's */
2492 struct bpstats root_bs
[1];
2493 /* Pointer to the last thing in the chain currently. */
2494 bpstat bs
= root_bs
;
2495 static char message1
[] =
2496 "Error evaluating expression for watchpoint %d\n";
2497 char message
[sizeof (message1
) + 30 /* slop */ ];
2499 /* Get the address where the breakpoint would have been. The
2500 "not_a_sw_breakpoint" argument is meant to distinguish between a
2501 breakpoint trap event and a trace/singlestep trap event. For a
2502 trace/singlestep trap event, we would not want to subtract
2503 DECR_PC_AFTER_BREAK from the PC. */
2505 bp_addr
= *pc
- (not_a_sw_breakpoint
? 0 : DECR_PC_AFTER_BREAK
);
2507 ALL_BREAKPOINTS_SAFE (b
, temp
)
2509 if (b
->enable_state
== bp_disabled
2510 || b
->enable_state
== bp_shlib_disabled
2511 || b
->enable_state
== bp_call_disabled
)
2514 if (b
->type
!= bp_watchpoint
2515 && b
->type
!= bp_hardware_watchpoint
2516 && b
->type
!= bp_read_watchpoint
2517 && b
->type
!= bp_access_watchpoint
2518 && b
->type
!= bp_hardware_breakpoint
2519 && b
->type
!= bp_catch_fork
2520 && b
->type
!= bp_catch_vfork
2521 && b
->type
!= bp_catch_exec
2522 && b
->type
!= bp_catch_catch
2523 && b
->type
!= bp_catch_throw
) /* a non-watchpoint bp */
2525 if (b
->address
!= bp_addr
) /* address doesn't match */
2527 if (overlay_debugging
/* unmapped overlay section */
2528 && section_is_overlay (b
->section
)
2529 && !section_is_mapped (b
->section
))
2533 if (b
->type
== bp_hardware_breakpoint
)
2535 if (b
->address
!= (*pc
- DECR_PC_AFTER_HW_BREAK
))
2537 if (overlay_debugging
/* unmapped overlay section */
2538 && section_is_overlay (b
->section
)
2539 && !section_is_mapped (b
->section
))
2543 /* Is this a catchpoint of a load or unload? If so, did we
2544 get a load or unload of the specified library? If not,
2546 if ((b
->type
== bp_catch_load
)
2547 #if defined(SOLIB_HAVE_LOAD_EVENT)
2548 && (!SOLIB_HAVE_LOAD_EVENT (PIDGET (inferior_ptid
))
2549 || ((b
->dll_pathname
!= NULL
)
2550 && (strcmp (b
->dll_pathname
,
2551 SOLIB_LOADED_LIBRARY_PATHNAME (
2552 PIDGET (inferior_ptid
)))
2558 if ((b
->type
== bp_catch_unload
)
2559 #if defined(SOLIB_HAVE_UNLOAD_EVENT)
2560 && (!SOLIB_HAVE_UNLOAD_EVENT (PIDGET (inferior_ptid
))
2561 || ((b
->dll_pathname
!= NULL
)
2562 && (strcmp (b
->dll_pathname
,
2563 SOLIB_UNLOADED_LIBRARY_PATHNAME (
2564 PIDGET (inferior_ptid
)))
2570 if ((b
->type
== bp_catch_fork
)
2571 && !inferior_has_forked (PIDGET (inferior_ptid
),
2572 &b
->forked_inferior_pid
))
2575 if ((b
->type
== bp_catch_vfork
)
2576 && !inferior_has_vforked (PIDGET (inferior_ptid
),
2577 &b
->forked_inferior_pid
))
2580 if ((b
->type
== bp_catch_exec
)
2581 && !inferior_has_execd (PIDGET (inferior_ptid
), &b
->exec_pathname
))
2584 if (ep_is_exception_catchpoint (b
) &&
2585 !(current_exception_event
= target_get_current_exception_event ()))
2588 /* Come here if it's a watchpoint, or if the break address matches */
2590 bs
= bpstat_alloc (b
, bs
); /* Alloc a bpstat to explain stop */
2592 /* Watchpoints may change this, if not found to have triggered. */
2596 sprintf (message
, message1
, b
->number
);
2597 if (b
->type
== bp_watchpoint
||
2598 b
->type
== bp_hardware_watchpoint
)
2600 switch (catch_errors (watchpoint_check
, bs
, message
,
2604 /* We've already printed what needs to be printed. */
2605 /* Actually this is superfluous, because by the time we
2606 call print_it_typical() the wp will be already deleted,
2607 and the function will return immediately. */
2608 bs
->print_it
= print_it_done
;
2611 case WP_VALUE_CHANGED
:
2615 case WP_VALUE_NOT_CHANGED
:
2617 bs
->print_it
= print_it_noop
;
2624 /* Error from catch_errors. */
2625 printf_filtered ("Watchpoint %d deleted.\n", b
->number
);
2626 if (b
->related_breakpoint
)
2627 b
->related_breakpoint
->disposition
= disp_del_at_next_stop
;
2628 b
->disposition
= disp_del_at_next_stop
;
2629 /* We've already printed what needs to be printed. */
2630 bs
->print_it
= print_it_done
;
2636 else if (b
->type
== bp_read_watchpoint
||
2637 b
->type
== bp_access_watchpoint
)
2643 addr
= target_stopped_data_address ();
2646 for (v
= b
->val_chain
; v
; v
= v
->next
)
2648 if (VALUE_LVAL (v
) == lval_memory
2649 && ! VALUE_LAZY (v
))
2651 struct type
*vtype
= check_typedef (VALUE_TYPE (v
));
2653 if (v
== b
->val_chain
2654 || (TYPE_CODE (vtype
) != TYPE_CODE_STRUCT
2655 && TYPE_CODE (vtype
) != TYPE_CODE_ARRAY
))
2659 vaddr
= VALUE_ADDRESS (v
) + VALUE_OFFSET (v
);
2660 /* Exact match not required. Within range is
2662 if (addr
>= vaddr
&&
2663 addr
< vaddr
+ TYPE_LENGTH (VALUE_TYPE (v
)))
2669 switch (catch_errors (watchpoint_check
, bs
, message
,
2673 /* We've already printed what needs to be printed. */
2674 bs
->print_it
= print_it_done
;
2677 case WP_VALUE_CHANGED
:
2678 if (b
->type
== bp_read_watchpoint
)
2680 /* Don't stop: read watchpoints shouldn't fire if
2681 the value has changed. This is for targets which
2682 cannot set read-only watchpoints. */
2683 bs
->print_it
= print_it_noop
;
2689 case WP_VALUE_NOT_CHANGED
:
2696 /* Error from catch_errors. */
2697 printf_filtered ("Watchpoint %d deleted.\n", b
->number
);
2698 if (b
->related_breakpoint
)
2699 b
->related_breakpoint
->disposition
= disp_del_at_next_stop
;
2700 b
->disposition
= disp_del_at_next_stop
;
2701 /* We've already printed what needs to be printed. */
2702 bs
->print_it
= print_it_done
;
2705 else /* found == 0 */
2707 /* This is a case where some watchpoint(s) triggered,
2708 but not at the address of this watchpoint (FOUND
2709 was left zero). So don't print anything for this
2711 bs
->print_it
= print_it_noop
;
2718 /* By definition, an encountered breakpoint is a triggered
2722 real_breakpoint
= 1;
2725 if (frame_id_p (b
->frame_id
)
2726 && !frame_id_eq (b
->frame_id
, get_frame_id (get_current_frame ())))
2730 int value_is_zero
= 0;
2734 /* Need to select the frame, with all that implies
2735 so that the conditions will have the right context. */
2736 select_frame (get_current_frame ());
2738 = catch_errors (breakpoint_cond_eval
, (b
->cond
),
2739 "Error in testing breakpoint condition:\n",
2741 /* FIXME-someday, should give breakpoint # */
2744 if (b
->cond
&& value_is_zero
)
2747 /* Don't consider this a hit. */
2750 else if (b
->ignore_count
> 0)
2753 annotate_ignore_count_change ();
2758 /* We will stop here */
2759 if (b
->disposition
== disp_disable
)
2760 b
->enable_state
= bp_disabled
;
2761 bs
->commands
= copy_command_lines (b
->commands
);
2765 (STREQ ("silent", bs
->commands
->line
) ||
2766 (xdb_commands
&& STREQ ("Q", bs
->commands
->line
))))
2768 bs
->commands
= bs
->commands
->next
;
2773 /* Print nothing for this entry if we dont stop or if we dont print. */
2774 if (bs
->stop
== 0 || bs
->print
== 0)
2775 bs
->print_it
= print_it_noop
;
2778 bs
->next
= NULL
; /* Terminate the chain */
2779 bs
= root_bs
->next
; /* Re-grab the head of the chain */
2781 if (real_breakpoint
&& bs
)
2783 if (bs
->breakpoint_at
->type
== bp_hardware_breakpoint
)
2785 if (DECR_PC_AFTER_HW_BREAK
!= 0)
2787 *pc
= *pc
- DECR_PC_AFTER_HW_BREAK
;
2793 if (DECR_PC_AFTER_BREAK
!= 0 || must_shift_inst_regs
)
2796 #if defined (SHIFT_INST_REGS)
2798 #else /* No SHIFT_INST_REGS. */
2800 #endif /* No SHIFT_INST_REGS. */
2805 /* The value of a hardware watchpoint hasn't changed, but the
2806 intermediate memory locations we are watching may have. */
2807 if (bs
&& !bs
->stop
&&
2808 (bs
->breakpoint_at
->type
== bp_hardware_watchpoint
||
2809 bs
->breakpoint_at
->type
== bp_read_watchpoint
||
2810 bs
->breakpoint_at
->type
== bp_access_watchpoint
))
2812 remove_breakpoints ();
2813 insert_breakpoints ();
2818 /* Tell what to do about this bpstat. */
2820 bpstat_what (bpstat bs
)
2822 /* Classify each bpstat as one of the following. */
2825 /* This bpstat element has no effect on the main_action. */
2828 /* There was a watchpoint, stop but don't print. */
2831 /* There was a watchpoint, stop and print. */
2834 /* There was a breakpoint but we're not stopping. */
2837 /* There was a breakpoint, stop but don't print. */
2840 /* There was a breakpoint, stop and print. */
2843 /* We hit the longjmp breakpoint. */
2846 /* We hit the longjmp_resume breakpoint. */
2849 /* We hit the step_resume breakpoint. */
2852 /* We hit the through_sigtramp breakpoint. */
2855 /* We hit the shared library event breakpoint. */
2858 /* We caught a shared library event. */
2861 /* This is just used to count how many enums there are. */
2865 /* Here is the table which drives this routine. So that we can
2866 format it pretty, we define some abbreviations for the
2867 enum bpstat_what codes. */
2868 #define kc BPSTAT_WHAT_KEEP_CHECKING
2869 #define ss BPSTAT_WHAT_STOP_SILENT
2870 #define sn BPSTAT_WHAT_STOP_NOISY
2871 #define sgl BPSTAT_WHAT_SINGLE
2872 #define slr BPSTAT_WHAT_SET_LONGJMP_RESUME
2873 #define clr BPSTAT_WHAT_CLEAR_LONGJMP_RESUME
2874 #define clrs BPSTAT_WHAT_CLEAR_LONGJMP_RESUME_SINGLE
2875 #define sr BPSTAT_WHAT_STEP_RESUME
2876 #define ts BPSTAT_WHAT_THROUGH_SIGTRAMP
2877 #define shl BPSTAT_WHAT_CHECK_SHLIBS
2878 #define shlr BPSTAT_WHAT_CHECK_SHLIBS_RESUME_FROM_HOOK
2880 /* "Can't happen." Might want to print an error message.
2881 abort() is not out of the question, but chances are GDB is just
2882 a bit confused, not unusable. */
2883 #define err BPSTAT_WHAT_STOP_NOISY
2885 /* Given an old action and a class, come up with a new action. */
2886 /* One interesting property of this table is that wp_silent is the same
2887 as bp_silent and wp_noisy is the same as bp_noisy. That is because
2888 after stopping, the check for whether to step over a breakpoint
2889 (BPSTAT_WHAT_SINGLE type stuff) is handled in proceed() without
2890 reference to how we stopped. We retain separate wp_silent and
2891 bp_silent codes in case we want to change that someday.
2893 Another possibly interesting property of this table is that
2894 there's a partial ordering, priority-like, of the actions. Once
2895 you've decided that some action is appropriate, you'll never go
2896 back and decide something of a lower priority is better. The
2899 kc < clr sgl shl shlr slr sn sr ss ts
2900 sgl < clrs shl shlr slr sn sr ss ts
2901 slr < err shl shlr sn sr ss ts
2902 clr < clrs err shl shlr sn sr ss ts
2903 clrs < err shl shlr sn sr ss ts
2904 ss < shl shlr sn sr ts
2911 What I think this means is that we don't need a damned table
2912 here. If you just put the rows and columns in the right order,
2913 it'd look awfully regular. We could simply walk the bpstat list
2914 and choose the highest priority action we find, with a little
2915 logic to handle the 'err' cases, and the CLEAR_LONGJMP_RESUME/
2916 CLEAR_LONGJMP_RESUME_SINGLE distinction (which breakpoint.h says
2917 is messy anyway). */
2919 /* step_resume entries: a step resume breakpoint overrides another
2920 breakpoint of signal handling (see comment in wait_for_inferior
2921 at first PC_IN_SIGTRAMP where we set the step_resume breakpoint). */
2922 /* We handle the through_sigtramp_breakpoint the same way; having both
2923 one of those and a step_resume_breakpoint is probably very rare (?). */
2925 static const enum bpstat_what_main_action
2926 table
[(int) class_last
][(int) BPSTAT_WHAT_LAST
] =
2929 /* kc ss sn sgl slr clr clrs sr ts shl shlr
2932 {kc
, ss
, sn
, sgl
, slr
, clr
, clrs
, sr
, ts
, shl
, shlr
},
2934 {ss
, ss
, sn
, ss
, ss
, ss
, ss
, sr
, ts
, shl
, shlr
},
2936 {sn
, sn
, sn
, sn
, sn
, sn
, sn
, sr
, ts
, shl
, shlr
},
2938 {sgl
, ss
, sn
, sgl
, slr
, clrs
, clrs
, sr
, ts
, shl
, shlr
},
2940 {ss
, ss
, sn
, ss
, ss
, ss
, ss
, sr
, ts
, shl
, shlr
},
2942 {sn
, sn
, sn
, sn
, sn
, sn
, sn
, sr
, ts
, shl
, shlr
},
2944 {slr
, ss
, sn
, slr
, slr
, err
, err
, sr
, ts
, shl
, shlr
},
2946 {clr
, ss
, sn
, clrs
, err
, err
, err
, sr
, ts
, shl
, shlr
},
2948 {sr
, sr
, sr
, sr
, sr
, sr
, sr
, sr
, ts
, shl
, shlr
},
2950 {ts
, ts
, ts
, ts
, ts
, ts
, ts
, ts
, ts
, shl
, shlr
},
2952 {shl
, shl
, shl
, shl
, shl
, shl
, shl
, shl
, ts
, shl
, shlr
},
2954 {shlr
, shlr
, shlr
, shlr
, shlr
, shlr
, shlr
, shlr
, ts
, shlr
, shlr
}
2969 enum bpstat_what_main_action current_action
= BPSTAT_WHAT_KEEP_CHECKING
;
2970 struct bpstat_what retval
;
2972 retval
.call_dummy
= 0;
2973 for (; bs
!= NULL
; bs
= bs
->next
)
2975 enum class bs_class
= no_effect
;
2976 if (bs
->breakpoint_at
== NULL
)
2977 /* I suspect this can happen if it was a momentary breakpoint
2978 which has since been deleted. */
2980 switch (bs
->breakpoint_at
->type
)
2986 case bp_hardware_breakpoint
:
2992 bs_class
= bp_noisy
;
2994 bs_class
= bp_silent
;
2997 bs_class
= bp_nostop
;
3000 case bp_hardware_watchpoint
:
3001 case bp_read_watchpoint
:
3002 case bp_access_watchpoint
:
3006 bs_class
= wp_noisy
;
3008 bs_class
= wp_silent
;
3011 /* There was a watchpoint, but we're not stopping.
3012 This requires no further action. */
3013 bs_class
= no_effect
;
3016 bs_class
= long_jump
;
3018 case bp_longjmp_resume
:
3019 bs_class
= long_resume
;
3021 case bp_step_resume
:
3024 bs_class
= step_resume
;
3027 /* It is for the wrong frame. */
3028 bs_class
= bp_nostop
;
3030 case bp_through_sigtramp
:
3031 bs_class
= through_sig
;
3033 case bp_watchpoint_scope
:
3034 bs_class
= bp_nostop
;
3036 case bp_shlib_event
:
3037 bs_class
= shlib_event
;
3039 case bp_thread_event
:
3040 case bp_overlay_event
:
3041 bs_class
= bp_nostop
;
3044 case bp_catch_unload
:
3045 /* Only if this catchpoint triggered should we cause the
3046 step-out-of-dld behaviour. Otherwise, we ignore this
3049 bs_class
= catch_shlib_event
;
3051 bs_class
= no_effect
;
3054 case bp_catch_vfork
:
3059 bs_class
= bp_noisy
;
3061 bs_class
= bp_silent
;
3064 /* There was a catchpoint, but we're not stopping.
3065 This requires no further action. */
3066 bs_class
= no_effect
;
3068 case bp_catch_catch
:
3069 if (!bs
->stop
|| CURRENT_EXCEPTION_KIND
!= EX_EVENT_CATCH
)
3070 bs_class
= bp_nostop
;
3072 bs_class
= bs
->print
? bp_noisy
: bp_silent
;
3074 case bp_catch_throw
:
3075 if (!bs
->stop
|| CURRENT_EXCEPTION_KIND
!= EX_EVENT_THROW
)
3076 bs_class
= bp_nostop
;
3078 bs_class
= bs
->print
? bp_noisy
: bp_silent
;
3081 /* Make sure the action is stop (silent or noisy),
3082 so infrun.c pops the dummy frame. */
3083 bs_class
= bp_silent
;
3084 retval
.call_dummy
= 1;
3087 current_action
= table
[(int) bs_class
][(int) current_action
];
3089 retval
.main_action
= current_action
;
3093 /* Nonzero if we should step constantly (e.g. watchpoints on machines
3094 without hardware support). This isn't related to a specific bpstat,
3095 just to things like whether watchpoints are set. */
3098 bpstat_should_step (void)
3100 struct breakpoint
*b
;
3102 if (b
->enable_state
== bp_enabled
&& b
->type
== bp_watchpoint
)
3107 /* Nonzero if there are enabled hardware watchpoints. */
3109 bpstat_have_active_hw_watchpoints (void)
3111 struct breakpoint
*b
;
3113 if ((b
->enable_state
== bp_enabled
) &&
3115 ((b
->type
== bp_hardware_watchpoint
) ||
3116 (b
->type
== bp_read_watchpoint
) ||
3117 (b
->type
== bp_access_watchpoint
)))
3123 /* Given a bpstat that records zero or more triggered eventpoints, this
3124 function returns another bpstat which contains only the catchpoints
3125 on that first list, if any. */
3127 bpstat_get_triggered_catchpoints (bpstat ep_list
, bpstat
*cp_list
)
3129 struct bpstats root_bs
[1];
3130 bpstat bs
= root_bs
;
3131 struct breakpoint
*ep
;
3134 bpstat_clear (cp_list
);
3135 root_bs
->next
= NULL
;
3137 for (; ep_list
!= NULL
; ep_list
= ep_list
->next
)
3139 /* Is this eventpoint a catchpoint? If not, ignore it. */
3140 ep
= ep_list
->breakpoint_at
;
3143 if ((ep
->type
!= bp_catch_load
) &&
3144 (ep
->type
!= bp_catch_unload
) &&
3145 (ep
->type
!= bp_catch_catch
) &&
3146 (ep
->type
!= bp_catch_throw
))
3147 /* pai: (temp) ADD fork/vfork here!! */
3150 /* Yes; add it to the list. */
3151 bs
= bpstat_alloc (ep
, bs
);
3156 #if defined(SOLIB_ADD)
3157 /* Also, for each triggered catchpoint, tag it with the name of
3158 the library that caused this trigger. (We copy the name now,
3159 because it's only guaranteed to be available NOW, when the
3160 catchpoint triggers. Clients who may wish to know the name
3161 later must get it from the catchpoint itself.) */
3162 if (ep
->triggered_dll_pathname
!= NULL
)
3163 xfree (ep
->triggered_dll_pathname
);
3164 if (ep
->type
== bp_catch_load
)
3165 dll_pathname
= SOLIB_LOADED_LIBRARY_PATHNAME (
3166 PIDGET (inferior_ptid
));
3168 dll_pathname
= SOLIB_UNLOADED_LIBRARY_PATHNAME (
3169 PIDGET (inferior_ptid
));
3171 dll_pathname
= NULL
;
3175 ep
->triggered_dll_pathname
= (char *)
3176 xmalloc (strlen (dll_pathname
) + 1);
3177 strcpy (ep
->triggered_dll_pathname
, dll_pathname
);
3180 ep
->triggered_dll_pathname
= NULL
;
3186 /* Print B to gdb_stdout. */
3188 print_one_breakpoint (struct breakpoint
*b
,
3189 CORE_ADDR
*last_addr
)
3191 register struct command_line
*l
;
3192 register struct symbol
*sym
;
3193 struct ep_type_description
3198 static struct ep_type_description bptypes
[] =
3200 {bp_none
, "?deleted?"},
3201 {bp_breakpoint
, "breakpoint"},
3202 {bp_hardware_breakpoint
, "hw breakpoint"},
3203 {bp_until
, "until"},
3204 {bp_finish
, "finish"},
3205 {bp_watchpoint
, "watchpoint"},
3206 {bp_hardware_watchpoint
, "hw watchpoint"},
3207 {bp_read_watchpoint
, "read watchpoint"},
3208 {bp_access_watchpoint
, "acc watchpoint"},
3209 {bp_longjmp
, "longjmp"},
3210 {bp_longjmp_resume
, "longjmp resume"},
3211 {bp_step_resume
, "step resume"},
3212 {bp_through_sigtramp
, "sigtramp"},
3213 {bp_watchpoint_scope
, "watchpoint scope"},
3214 {bp_call_dummy
, "call dummy"},
3215 {bp_shlib_event
, "shlib events"},
3216 {bp_thread_event
, "thread events"},
3217 {bp_overlay_event
, "overlay events"},
3218 {bp_catch_load
, "catch load"},
3219 {bp_catch_unload
, "catch unload"},
3220 {bp_catch_fork
, "catch fork"},
3221 {bp_catch_vfork
, "catch vfork"},
3222 {bp_catch_exec
, "catch exec"},
3223 {bp_catch_catch
, "catch catch"},
3224 {bp_catch_throw
, "catch throw"}
3227 static char *bpdisps
[] =
3228 {"del", "dstp", "dis", "keep"};
3229 static char bpenables
[] = "nynny";
3230 char wrap_indent
[80];
3231 struct ui_stream
*stb
= ui_out_stream_new (uiout
);
3232 struct cleanup
*old_chain
= make_cleanup_ui_out_stream_delete (stb
);
3233 struct cleanup
*bkpt_chain
;
3236 bkpt_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "bkpt");
3240 ui_out_field_int (uiout
, "number", b
->number
);
3244 if (((int) b
->type
> (sizeof (bptypes
) / sizeof (bptypes
[0])))
3245 || ((int) b
->type
!= bptypes
[(int) b
->type
].type
))
3246 internal_error (__FILE__
, __LINE__
,
3247 "bptypes table does not describe type #%d.",
3249 ui_out_field_string (uiout
, "type", bptypes
[(int) b
->type
].description
);
3253 ui_out_field_string (uiout
, "disp", bpdisps
[(int) b
->disposition
]);
3257 ui_out_field_fmt (uiout
, "enabled", "%c", bpenables
[(int) b
->enable_state
]);
3258 ui_out_spaces (uiout
, 2);
3261 strcpy (wrap_indent
, " ");
3264 if (TARGET_ADDR_BIT
<= 32)
3265 strcat (wrap_indent
, " ");
3267 strcat (wrap_indent
, " ");
3272 internal_error (__FILE__
, __LINE__
,
3273 "print_one_breakpoint: bp_none encountered\n");
3277 case bp_hardware_watchpoint
:
3278 case bp_read_watchpoint
:
3279 case bp_access_watchpoint
:
3280 /* Field 4, the address, is omitted (which makes the columns
3281 not line up too nicely with the headers, but the effect
3282 is relatively readable). */
3284 ui_out_field_skip (uiout
, "addr");
3286 print_expression (b
->exp
, stb
->stream
);
3287 ui_out_field_stream (uiout
, "what", stb
);
3291 case bp_catch_unload
:
3292 /* Field 4, the address, is omitted (which makes the columns
3293 not line up too nicely with the headers, but the effect
3294 is relatively readable). */
3296 ui_out_field_skip (uiout
, "addr");
3298 if (b
->dll_pathname
== NULL
)
3300 ui_out_field_string (uiout
, "what", "<any library>");
3301 ui_out_spaces (uiout
, 1);
3305 ui_out_text (uiout
, "library \"");
3306 ui_out_field_string (uiout
, "what", b
->dll_pathname
);
3307 ui_out_text (uiout
, "\" ");
3312 case bp_catch_vfork
:
3313 /* Field 4, the address, is omitted (which makes the columns
3314 not line up too nicely with the headers, but the effect
3315 is relatively readable). */
3317 ui_out_field_skip (uiout
, "addr");
3319 if (b
->forked_inferior_pid
!= 0)
3321 ui_out_text (uiout
, "process ");
3322 ui_out_field_int (uiout
, "what", b
->forked_inferior_pid
);
3323 ui_out_spaces (uiout
, 1);
3327 /* Field 4, the address, is omitted (which makes the columns
3328 not line up too nicely with the headers, but the effect
3329 is relatively readable). */
3331 ui_out_field_skip (uiout
, "addr");
3333 if (b
->exec_pathname
!= NULL
)
3335 ui_out_text (uiout
, "program \"");
3336 ui_out_field_string (uiout
, "what", b
->exec_pathname
);
3337 ui_out_text (uiout
, "\" ");
3341 case bp_catch_catch
:
3342 /* Field 4, the address, is omitted (which makes the columns
3343 not line up too nicely with the headers, but the effect
3344 is relatively readable). */
3346 ui_out_field_skip (uiout
, "addr");
3348 ui_out_field_string (uiout
, "what", "exception catch");
3349 ui_out_spaces (uiout
, 1);
3352 case bp_catch_throw
:
3353 /* Field 4, the address, is omitted (which makes the columns
3354 not line up too nicely with the headers, but the effect
3355 is relatively readable). */
3357 ui_out_field_skip (uiout
, "addr");
3359 ui_out_field_string (uiout
, "what", "exception throw");
3360 ui_out_spaces (uiout
, 1);
3364 case bp_hardware_breakpoint
:
3368 case bp_longjmp_resume
:
3369 case bp_step_resume
:
3370 case bp_through_sigtramp
:
3371 case bp_watchpoint_scope
:
3373 case bp_shlib_event
:
3374 case bp_thread_event
:
3375 case bp_overlay_event
:
3379 ui_out_field_core_addr (uiout
, "addr", b
->address
);
3382 *last_addr
= b
->address
;
3385 sym
= find_pc_sect_function (b
->address
, b
->section
);
3388 ui_out_text (uiout
, "in ");
3389 ui_out_field_string (uiout
, "func",
3390 SYMBOL_PRINT_NAME (sym
));
3391 ui_out_wrap_hint (uiout
, wrap_indent
);
3392 ui_out_text (uiout
, " at ");
3394 ui_out_field_string (uiout
, "file", b
->source_file
);
3395 ui_out_text (uiout
, ":");
3396 ui_out_field_int (uiout
, "line", b
->line_number
);
3400 print_address_symbolic (b
->address
, stb
->stream
, demangle
, "");
3401 ui_out_field_stream (uiout
, "at", stb
);
3406 if (b
->thread
!= -1)
3408 /* FIXME: This seems to be redundant and lost here; see the
3409 "stop only in" line a little further down. */
3410 ui_out_text (uiout
, " thread ");
3411 ui_out_field_int (uiout
, "thread", b
->thread
);
3414 ui_out_text (uiout
, "\n");
3416 if (frame_id_p (b
->frame_id
))
3419 ui_out_text (uiout
, "\tstop only in stack frame at ");
3420 /* FIXME: cagney/2002-12-01: Shouldn't be poeking around inside
3422 ui_out_field_core_addr (uiout
, "frame", b
->frame_id
.base
);
3423 ui_out_text (uiout
, "\n");
3429 ui_out_text (uiout
, "\tstop only if ");
3430 print_expression (b
->cond
, stb
->stream
);
3431 ui_out_field_stream (uiout
, "cond", stb
);
3432 ui_out_text (uiout
, "\n");
3435 if (b
->thread
!= -1)
3437 /* FIXME should make an annotation for this */
3438 ui_out_text (uiout
, "\tstop only in thread ");
3439 ui_out_field_int (uiout
, "thread", b
->thread
);
3440 ui_out_text (uiout
, "\n");
3443 if (show_breakpoint_hit_counts
&& b
->hit_count
)
3445 /* FIXME should make an annotation for this */
3446 if (ep_is_catchpoint (b
))
3447 ui_out_text (uiout
, "\tcatchpoint");
3449 ui_out_text (uiout
, "\tbreakpoint");
3450 ui_out_text (uiout
, " already hit ");
3451 ui_out_field_int (uiout
, "times", b
->hit_count
);
3452 if (b
->hit_count
== 1)
3453 ui_out_text (uiout
, " time\n");
3455 ui_out_text (uiout
, " times\n");
3458 /* Output the count also if it is zero, but only if this is
3459 mi. FIXME: Should have a better test for this. */
3460 if (ui_out_is_mi_like_p (uiout
))
3461 if (show_breakpoint_hit_counts
&& b
->hit_count
== 0)
3462 ui_out_field_int (uiout
, "times", b
->hit_count
);
3464 if (b
->ignore_count
)
3467 ui_out_text (uiout
, "\tignore next ");
3468 ui_out_field_int (uiout
, "ignore", b
->ignore_count
);
3469 ui_out_text (uiout
, " hits\n");
3472 if ((l
= b
->commands
))
3474 struct cleanup
*script_chain
;
3477 script_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "script");
3478 print_command_lines (uiout
, l
, 4);
3479 do_cleanups (script_chain
);
3481 do_cleanups (bkpt_chain
);
3482 do_cleanups (old_chain
);
3485 struct captured_breakpoint_query_args
3491 do_captured_breakpoint_query (struct ui_out
*uiout
, void *data
)
3493 struct captured_breakpoint_query_args
*args
= data
;
3494 register struct breakpoint
*b
;
3495 CORE_ADDR dummy_addr
= 0;
3498 if (args
->bnum
== b
->number
)
3500 print_one_breakpoint (b
, &dummy_addr
);
3508 gdb_breakpoint_query (struct ui_out
*uiout
, int bnum
)
3510 struct captured_breakpoint_query_args args
;
3512 /* For the moment we don't trust print_one_breakpoint() to not throw
3514 return catch_exceptions (uiout
, do_captured_breakpoint_query
, &args
,
3515 NULL
, RETURN_MASK_ALL
);
3518 /* Return non-zero if B is user settable (breakpoints, watchpoints,
3519 catchpoints, et.al.). */
3522 user_settable_breakpoint (const struct breakpoint
*b
)
3524 return (b
->type
== bp_breakpoint
3525 || b
->type
== bp_catch_load
3526 || b
->type
== bp_catch_unload
3527 || b
->type
== bp_catch_fork
3528 || b
->type
== bp_catch_vfork
3529 || b
->type
== bp_catch_exec
3530 || b
->type
== bp_catch_catch
3531 || b
->type
== bp_catch_throw
3532 || b
->type
== bp_hardware_breakpoint
3533 || b
->type
== bp_watchpoint
3534 || b
->type
== bp_read_watchpoint
3535 || b
->type
== bp_access_watchpoint
3536 || b
->type
== bp_hardware_watchpoint
);
3539 /* Print information on user settable breakpoint (watchpoint, etc)
3540 number BNUM. If BNUM is -1 print all user settable breakpoints.
3541 If ALLFLAG is non-zero, include non- user settable breakpoints. */
3544 breakpoint_1 (int bnum
, int allflag
)
3546 register struct breakpoint
*b
;
3547 CORE_ADDR last_addr
= (CORE_ADDR
) -1;
3548 int nr_printable_breakpoints
;
3549 struct cleanup
*bkpttbl_chain
;
3551 /* Compute the number of rows in the table. */
3552 nr_printable_breakpoints
= 0;
3555 || bnum
== b
->number
)
3557 if (allflag
|| user_settable_breakpoint (b
))
3558 nr_printable_breakpoints
++;
3563 = make_cleanup_ui_out_table_begin_end (uiout
, 6, nr_printable_breakpoints
,
3567 = make_cleanup_ui_out_table_begin_end (uiout
, 5, nr_printable_breakpoints
,
3570 if (nr_printable_breakpoints
> 0)
3571 annotate_breakpoints_headers ();
3572 if (nr_printable_breakpoints
> 0)
3574 ui_out_table_header (uiout
, 3, ui_left
, "number", "Num"); /* 1 */
3575 if (nr_printable_breakpoints
> 0)
3577 ui_out_table_header (uiout
, 14, ui_left
, "type", "Type"); /* 2 */
3578 if (nr_printable_breakpoints
> 0)
3580 ui_out_table_header (uiout
, 4, ui_left
, "disp", "Disp"); /* 3 */
3581 if (nr_printable_breakpoints
> 0)
3583 ui_out_table_header (uiout
, 3, ui_left
, "enabled", "Enb"); /* 4 */
3586 if (nr_printable_breakpoints
> 0)
3588 if (TARGET_ADDR_BIT
<= 32)
3589 ui_out_table_header (uiout
, 10, ui_left
, "addr", "Address");/* 5 */
3591 ui_out_table_header (uiout
, 18, ui_left
, "addr", "Address");/* 5 */
3593 if (nr_printable_breakpoints
> 0)
3595 ui_out_table_header (uiout
, 40, ui_noalign
, "what", "What"); /* 6 */
3596 ui_out_table_body (uiout
);
3597 if (nr_printable_breakpoints
> 0)
3598 annotate_breakpoints_table ();
3602 || bnum
== b
->number
)
3604 /* We only print out user settable breakpoints unless the
3606 if (allflag
|| user_settable_breakpoint (b
))
3607 print_one_breakpoint (b
, &last_addr
);
3610 do_cleanups (bkpttbl_chain
);
3612 if (nr_printable_breakpoints
== 0)
3615 ui_out_message (uiout
, 0, "No breakpoints or watchpoints.\n");
3617 ui_out_message (uiout
, 0, "No breakpoint or watchpoint number %d.\n",
3622 /* Compare against (CORE_ADDR)-1 in case some compiler decides
3623 that a comparison of an unsigned with -1 is always false. */
3624 if (last_addr
!= (CORE_ADDR
) -1)
3625 set_next_address (last_addr
);
3628 /* FIXME? Should this be moved up so that it is only called when
3629 there have been breakpoints? */
3630 annotate_breakpoints_table_end ();
3635 breakpoints_info (char *bnum_exp
, int from_tty
)
3640 bnum
= parse_and_eval_long (bnum_exp
);
3642 breakpoint_1 (bnum
, 0);
3647 maintenance_info_breakpoints (char *bnum_exp
, int from_tty
)
3652 bnum
= parse_and_eval_long (bnum_exp
);
3654 breakpoint_1 (bnum
, 1);
3657 /* Print a message describing any breakpoints set at PC. */
3660 describe_other_breakpoints (CORE_ADDR pc
, asection
*section
)
3662 register int others
= 0;
3663 register struct breakpoint
*b
;
3666 if (b
->address
== pc
) /* address match / overlay match */
3667 if (!overlay_debugging
|| b
->section
== section
)
3671 printf_filtered ("Note: breakpoint%s ", (others
> 1) ? "s" : "");
3673 if (b
->address
== pc
) /* address match / overlay match */
3674 if (!overlay_debugging
|| b
->section
== section
)
3677 printf_filtered ("%d%s%s ",
3679 ((b
->enable_state
== bp_disabled
||
3680 b
->enable_state
== bp_shlib_disabled
||
3681 b
->enable_state
== bp_call_disabled
)
3683 : b
->enable_state
== bp_permanent
3687 : ((others
== 1) ? " and" : ""));
3689 printf_filtered ("also set at pc ");
3690 print_address_numeric (pc
, 1, gdb_stdout
);
3691 printf_filtered (".\n");
3695 /* Set the default place to put a breakpoint
3696 for the `break' command with no arguments. */
3699 set_default_breakpoint (int valid
, CORE_ADDR addr
, struct symtab
*symtab
,
3702 default_breakpoint_valid
= valid
;
3703 default_breakpoint_address
= addr
;
3704 default_breakpoint_symtab
= symtab
;
3705 default_breakpoint_line
= line
;
3708 /* Return true iff it is meaningful to use the address member of
3709 BPT. For some breakpoint types, the address member is irrelevant
3710 and it makes no sense to attempt to compare it to other addresses
3711 (or use it for any other purpose either).
3713 More specifically, each of the following breakpoint types will always
3714 have a zero valued address and we don't want check_duplicates() to mark
3715 breakpoints of any of these types to be a duplicate of an actual
3716 breakpoint at address zero:
3719 bp_hardware_watchpoint
3721 bp_access_watchpoint
3728 breakpoint_address_is_meaningful (struct breakpoint
*bpt
)
3730 enum bptype type
= bpt
->type
;
3732 return (type
!= bp_watchpoint
3733 && type
!= bp_hardware_watchpoint
3734 && type
!= bp_read_watchpoint
3735 && type
!= bp_access_watchpoint
3736 && type
!= bp_catch_exec
3737 && type
!= bp_longjmp_resume
3738 && type
!= bp_catch_fork
3739 && type
!= bp_catch_vfork
);
3742 /* Rescan breakpoints at the same address and section as BPT,
3743 marking the first one as "first" and any others as "duplicates".
3744 This is so that the bpt instruction is only inserted once.
3745 If we have a permanent breakpoint at the same place as BPT, make
3746 that one the official one, and the rest as duplicates. */
3749 check_duplicates (struct breakpoint
*bpt
)
3751 register struct breakpoint
*b
;
3752 register int count
= 0;
3753 struct breakpoint
*perm_bp
= 0;
3754 CORE_ADDR address
= bpt
->address
;
3755 asection
*section
= bpt
->section
;
3757 if (! breakpoint_address_is_meaningful (bpt
))
3761 if (b
->enable_state
!= bp_disabled
3762 && b
->enable_state
!= bp_shlib_disabled
3763 && b
->enable_state
!= bp_call_disabled
3764 && b
->address
== address
/* address / overlay match */
3765 && (!overlay_debugging
|| b
->section
== section
)
3766 && breakpoint_address_is_meaningful (b
))
3768 /* Have we found a permanent breakpoint? */
3769 if (b
->enable_state
== bp_permanent
)
3776 b
->duplicate
= count
> 1;
3779 /* If we found a permanent breakpoint at this address, go over the
3780 list again and declare all the other breakpoints there to be the
3784 perm_bp
->duplicate
= 0;
3786 /* Permanent breakpoint should always be inserted. */
3787 if (! perm_bp
->inserted
)
3788 internal_error (__FILE__
, __LINE__
,
3789 "allegedly permanent breakpoint is not "
3790 "actually inserted");
3796 internal_error (__FILE__
, __LINE__
,
3797 "another breakpoint was inserted on top of "
3798 "a permanent breakpoint");
3800 if (b
->enable_state
!= bp_disabled
3801 && b
->enable_state
!= bp_shlib_disabled
3802 && b
->enable_state
!= bp_call_disabled
3803 && b
->address
== address
/* address / overlay match */
3804 && (!overlay_debugging
|| b
->section
== section
)
3805 && breakpoint_address_is_meaningful (b
))
3811 /* set_raw_breakpoint() is a low level routine for allocating and
3812 partially initializing a breakpoint of type BPTYPE. The newly
3813 created breakpoint's address, section, source file name, and line
3814 number are provided by SAL. The newly created and partially
3815 initialized breakpoint is added to the breakpoint chain and
3816 is also returned as the value of this function.
3818 It is expected that the caller will complete the initialization of
3819 the newly created breakpoint struct as well as output any status
3820 information regarding the creation of a new breakpoint. In
3821 particular, set_raw_breakpoint() does NOT set the breakpoint
3822 number! Care should be taken to not allow an error() to occur
3823 prior to completing the initialization of the breakpoint. If this
3824 should happen, a bogus breakpoint will be left on the chain. */
3827 set_raw_breakpoint (struct symtab_and_line sal
, enum bptype bptype
)
3829 register struct breakpoint
*b
, *b1
;
3831 b
= (struct breakpoint
*) xmalloc (sizeof (struct breakpoint
));
3832 memset (b
, 0, sizeof (*b
));
3833 b
->address
= sal
.pc
;
3834 if (sal
.symtab
== NULL
)
3835 b
->source_file
= NULL
;
3837 b
->source_file
= savestring (sal
.symtab
->filename
,
3838 strlen (sal
.symtab
->filename
));
3839 b
->section
= sal
.section
;
3841 b
->language
= current_language
->la_language
;
3842 b
->input_radix
= input_radix
;
3844 b
->line_number
= sal
.line
;
3845 b
->enable_state
= bp_enabled
;
3848 b
->ignore_count
= 0;
3850 b
->frame_id
= null_frame_id
;
3851 b
->dll_pathname
= NULL
;
3852 b
->triggered_dll_pathname
= NULL
;
3853 b
->forked_inferior_pid
= 0;
3854 b
->exec_pathname
= NULL
;
3856 /* Add this breakpoint to the end of the chain
3857 so that a list of breakpoints will come out in order
3858 of increasing numbers. */
3860 b1
= breakpoint_chain
;
3862 breakpoint_chain
= b
;
3870 check_duplicates (b
);
3871 breakpoints_changed ();
3877 /* Note that the breakpoint object B describes a permanent breakpoint
3878 instruction, hard-wired into the inferior's code. */
3880 make_breakpoint_permanent (struct breakpoint
*b
)
3882 b
->enable_state
= bp_permanent
;
3884 /* By definition, permanent breakpoints are already present in the code. */
3888 static struct breakpoint
*
3889 create_internal_breakpoint (CORE_ADDR address
, enum bptype type
)
3891 static int internal_breakpoint_number
= -1;
3892 struct symtab_and_line sal
;
3893 struct breakpoint
*b
;
3895 init_sal (&sal
); /* initialize to zeroes */
3898 sal
.section
= find_pc_overlay (sal
.pc
);
3900 b
= set_raw_breakpoint (sal
, type
);
3901 b
->number
= internal_breakpoint_number
--;
3902 b
->disposition
= disp_donttouch
;
3909 create_longjmp_breakpoint (char *func_name
)
3911 struct breakpoint
*b
;
3912 struct minimal_symbol
*m
;
3914 if (func_name
== NULL
)
3915 b
= create_internal_breakpoint (0, bp_longjmp_resume
);
3918 if ((m
= lookup_minimal_symbol_text (func_name
, NULL
, NULL
)) == NULL
)
3921 b
= create_internal_breakpoint (SYMBOL_VALUE_ADDRESS (m
), bp_longjmp
);
3924 b
->enable_state
= bp_disabled
;
3927 b
->addr_string
= xstrdup (func_name
);
3930 /* Call this routine when stepping and nexting to enable a breakpoint
3931 if we do a longjmp(). When we hit that breakpoint, call
3932 set_longjmp_resume_breakpoint() to figure out where we are going. */
3935 enable_longjmp_breakpoint (void)
3937 register struct breakpoint
*b
;
3940 if (b
->type
== bp_longjmp
)
3942 b
->enable_state
= bp_enabled
;
3943 check_duplicates (b
);
3948 disable_longjmp_breakpoint (void)
3950 register struct breakpoint
*b
;
3953 if (b
->type
== bp_longjmp
3954 || b
->type
== bp_longjmp_resume
)
3956 b
->enable_state
= bp_disabled
;
3957 check_duplicates (b
);
3962 create_overlay_event_breakpoint (char *func_name
)
3964 struct breakpoint
*b
;
3965 struct minimal_symbol
*m
;
3967 if ((m
= lookup_minimal_symbol_text (func_name
, NULL
, NULL
)) == NULL
)
3970 b
= create_internal_breakpoint (SYMBOL_VALUE_ADDRESS (m
),
3972 b
->addr_string
= xstrdup (func_name
);
3974 if (overlay_debugging
== ovly_auto
)
3976 b
->enable_state
= bp_enabled
;
3977 overlay_events_enabled
= 1;
3981 b
->enable_state
= bp_disabled
;
3982 overlay_events_enabled
= 0;
3987 enable_overlay_breakpoints (void)
3989 register struct breakpoint
*b
;
3992 if (b
->type
== bp_overlay_event
)
3994 b
->enable_state
= bp_enabled
;
3995 check_duplicates (b
);
3996 overlay_events_enabled
= 1;
4001 disable_overlay_breakpoints (void)
4003 register struct breakpoint
*b
;
4006 if (b
->type
== bp_overlay_event
)
4008 b
->enable_state
= bp_disabled
;
4009 check_duplicates (b
);
4010 overlay_events_enabled
= 0;
4015 create_thread_event_breakpoint (CORE_ADDR address
)
4017 struct breakpoint
*b
;
4019 b
= create_internal_breakpoint (address
, bp_thread_event
);
4021 b
->enable_state
= bp_enabled
;
4022 /* addr_string has to be used or breakpoint_re_set will delete me. */
4023 xasprintf (&b
->addr_string
, "*0x%s", paddr (b
->address
));
4029 remove_thread_event_breakpoints (void)
4031 struct breakpoint
*b
, *temp
;
4033 ALL_BREAKPOINTS_SAFE (b
, temp
)
4034 if (b
->type
== bp_thread_event
)
4035 delete_breakpoint (b
);
4040 remove_solib_event_breakpoints (void)
4042 register struct breakpoint
*b
, *temp
;
4044 ALL_BREAKPOINTS_SAFE (b
, temp
)
4045 if (b
->type
== bp_shlib_event
)
4046 delete_breakpoint (b
);
4050 create_solib_event_breakpoint (CORE_ADDR address
)
4052 struct breakpoint
*b
;
4054 b
= create_internal_breakpoint (address
, bp_shlib_event
);
4058 /* Disable any breakpoints that are on code in shared libraries. Only
4059 apply to enabled breakpoints, disabled ones can just stay disabled. */
4062 disable_breakpoints_in_shlibs (int silent
)
4064 struct breakpoint
*b
;
4065 int disabled_shlib_breaks
= 0;
4067 /* See also: insert_breakpoints, under DISABLE_UNSETTABLE_BREAK. */
4070 #if defined (PC_SOLIB)
4071 if (((b
->type
== bp_breakpoint
) ||
4072 (b
->type
== bp_hardware_breakpoint
)) &&
4073 b
->enable_state
== bp_enabled
&&
4075 PC_SOLIB (b
->address
))
4077 b
->enable_state
= bp_shlib_disabled
;
4080 if (!disabled_shlib_breaks
)
4082 target_terminal_ours_for_output ();
4083 warning ("Temporarily disabling shared library breakpoints:");
4085 disabled_shlib_breaks
= 1;
4086 warning ("breakpoint #%d ", b
->number
);
4093 /* Try to reenable any breakpoints in shared libraries. */
4095 re_enable_breakpoints_in_shlibs (void)
4097 struct breakpoint
*b
;
4100 if (b
->enable_state
== bp_shlib_disabled
)
4104 /* Do not reenable the breakpoint if the shared library
4105 is still not mapped in. */
4106 if (target_read_memory (b
->address
, buf
, 1) == 0)
4107 b
->enable_state
= bp_enabled
;
4114 solib_load_unload_1 (char *hookname
, int tempflag
, char *dll_pathname
,
4115 char *cond_string
, enum bptype bp_kind
)
4117 struct breakpoint
*b
;
4118 struct symtabs_and_lines sals
;
4119 struct cleanup
*old_chain
;
4120 struct cleanup
*canonical_strings_chain
= NULL
;
4121 char *addr_start
= hookname
;
4122 char *addr_end
= NULL
;
4123 char **canonical
= (char **) NULL
;
4124 int thread
= -1; /* All threads. */
4126 /* Set a breakpoint on the specified hook. */
4127 sals
= decode_line_1 (&hookname
, 1, (struct symtab
*) NULL
, 0, &canonical
);
4128 addr_end
= hookname
;
4130 if (sals
.nelts
== 0)
4132 warning ("Unable to set a breakpoint on dynamic linker callback.");
4133 warning ("Suggest linking with /opt/langtools/lib/end.o.");
4134 warning ("GDB will be unable to track shl_load/shl_unload calls");
4137 if (sals
.nelts
!= 1)
4139 warning ("Unable to set unique breakpoint on dynamic linker callback.");
4140 warning ("GDB will be unable to track shl_load/shl_unload calls");
4144 /* Make sure that all storage allocated in decode_line_1 gets freed
4145 in case the following errors out. */
4146 old_chain
= make_cleanup (xfree
, sals
.sals
);
4147 if (canonical
!= (char **) NULL
)
4149 make_cleanup (xfree
, canonical
);
4150 canonical_strings_chain
= make_cleanup (null_cleanup
, 0);
4151 if (canonical
[0] != NULL
)
4152 make_cleanup (xfree
, canonical
[0]);
4155 resolve_sal_pc (&sals
.sals
[0]);
4157 /* Remove the canonical strings from the cleanup, they are needed below. */
4158 if (canonical
!= (char **) NULL
)
4159 discard_cleanups (canonical_strings_chain
);
4161 b
= set_raw_breakpoint (sals
.sals
[0], bp_kind
);
4162 set_breakpoint_count (breakpoint_count
+ 1);
4163 b
->number
= breakpoint_count
;
4165 b
->cond_string
= (cond_string
== NULL
) ?
4166 NULL
: savestring (cond_string
, strlen (cond_string
));
4169 if (canonical
!= (char **) NULL
&& canonical
[0] != NULL
)
4170 b
->addr_string
= canonical
[0];
4171 else if (addr_start
)
4172 b
->addr_string
= savestring (addr_start
, addr_end
- addr_start
);
4174 b
->enable_state
= bp_enabled
;
4175 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
4177 if (dll_pathname
== NULL
)
4178 b
->dll_pathname
= NULL
;
4181 b
->dll_pathname
= (char *) xmalloc (strlen (dll_pathname
) + 1);
4182 strcpy (b
->dll_pathname
, dll_pathname
);
4186 do_cleanups (old_chain
);
4190 create_solib_load_event_breakpoint (char *hookname
, int tempflag
,
4191 char *dll_pathname
, char *cond_string
)
4193 solib_load_unload_1 (hookname
, tempflag
, dll_pathname
,
4194 cond_string
, bp_catch_load
);
4198 create_solib_unload_event_breakpoint (char *hookname
, int tempflag
,
4199 char *dll_pathname
, char *cond_string
)
4201 solib_load_unload_1 (hookname
,tempflag
, dll_pathname
,
4202 cond_string
, bp_catch_unload
);
4206 create_fork_vfork_event_catchpoint (int tempflag
, char *cond_string
,
4207 enum bptype bp_kind
)
4209 struct symtab_and_line sal
;
4210 struct breakpoint
*b
;
4211 int thread
= -1; /* All threads. */
4218 b
= set_raw_breakpoint (sal
, bp_kind
);
4219 set_breakpoint_count (breakpoint_count
+ 1);
4220 b
->number
= breakpoint_count
;
4222 b
->cond_string
= (cond_string
== NULL
) ?
4223 NULL
: savestring (cond_string
, strlen (cond_string
));
4225 b
->addr_string
= NULL
;
4226 b
->enable_state
= bp_enabled
;
4227 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
4228 b
->forked_inferior_pid
= 0;
4234 create_fork_event_catchpoint (int tempflag
, char *cond_string
)
4236 create_fork_vfork_event_catchpoint (tempflag
, cond_string
, bp_catch_fork
);
4240 create_vfork_event_catchpoint (int tempflag
, char *cond_string
)
4242 create_fork_vfork_event_catchpoint (tempflag
, cond_string
, bp_catch_vfork
);
4246 create_exec_event_catchpoint (int tempflag
, char *cond_string
)
4248 struct symtab_and_line sal
;
4249 struct breakpoint
*b
;
4250 int thread
= -1; /* All threads. */
4257 b
= set_raw_breakpoint (sal
, bp_catch_exec
);
4258 set_breakpoint_count (breakpoint_count
+ 1);
4259 b
->number
= breakpoint_count
;
4261 b
->cond_string
= (cond_string
== NULL
) ?
4262 NULL
: savestring (cond_string
, strlen (cond_string
));
4264 b
->addr_string
= NULL
;
4265 b
->enable_state
= bp_enabled
;
4266 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
4272 hw_breakpoint_used_count (void)
4274 register struct breakpoint
*b
;
4279 if (b
->type
== bp_hardware_breakpoint
&& b
->enable_state
== bp_enabled
)
4287 hw_watchpoint_used_count (enum bptype type
, int *other_type_used
)
4289 register struct breakpoint
*b
;
4292 *other_type_used
= 0;
4295 if (b
->enable_state
== bp_enabled
)
4297 if (b
->type
== type
)
4299 else if ((b
->type
== bp_hardware_watchpoint
||
4300 b
->type
== bp_read_watchpoint
||
4301 b
->type
== bp_access_watchpoint
)
4302 && b
->enable_state
== bp_enabled
)
4303 *other_type_used
= 1;
4309 /* Call this after hitting the longjmp() breakpoint. Use this to set
4310 a new breakpoint at the target of the jmp_buf.
4312 FIXME - This ought to be done by setting a temporary breakpoint
4313 that gets deleted automatically... */
4316 set_longjmp_resume_breakpoint (CORE_ADDR pc
, struct frame_id frame_id
)
4318 register struct breakpoint
*b
;
4321 if (b
->type
== bp_longjmp_resume
)
4324 b
->enable_state
= bp_enabled
;
4325 b
->frame_id
= frame_id
;
4326 check_duplicates (b
);
4332 disable_watchpoints_before_interactive_call_start (void)
4334 struct breakpoint
*b
;
4338 if (((b
->type
== bp_watchpoint
)
4339 || (b
->type
== bp_hardware_watchpoint
)
4340 || (b
->type
== bp_read_watchpoint
)
4341 || (b
->type
== bp_access_watchpoint
)
4342 || ep_is_exception_catchpoint (b
))
4343 && (b
->enable_state
== bp_enabled
))
4345 b
->enable_state
= bp_call_disabled
;
4346 check_duplicates (b
);
4352 enable_watchpoints_after_interactive_call_stop (void)
4354 struct breakpoint
*b
;
4358 if (((b
->type
== bp_watchpoint
)
4359 || (b
->type
== bp_hardware_watchpoint
)
4360 || (b
->type
== bp_read_watchpoint
)
4361 || (b
->type
== bp_access_watchpoint
)
4362 || ep_is_exception_catchpoint (b
))
4363 && (b
->enable_state
== bp_call_disabled
))
4365 b
->enable_state
= bp_enabled
;
4366 check_duplicates (b
);
4372 /* Set a breakpoint that will evaporate an end of command
4373 at address specified by SAL.
4374 Restrict it to frame FRAME if FRAME is nonzero. */
4377 set_momentary_breakpoint (struct symtab_and_line sal
, struct frame_id frame_id
,
4380 register struct breakpoint
*b
;
4381 b
= set_raw_breakpoint (sal
, type
);
4382 b
->enable_state
= bp_enabled
;
4383 b
->disposition
= disp_donttouch
;
4384 b
->frame_id
= frame_id
;
4386 /* If we're debugging a multi-threaded program, then we
4387 want momentary breakpoints to be active in only a
4388 single thread of control. */
4389 if (in_thread_list (inferior_ptid
))
4390 b
->thread
= pid_to_thread_id (inferior_ptid
);
4396 /* Tell the user we have just set a breakpoint B. */
4399 mention (struct breakpoint
*b
)
4402 struct cleanup
*old_chain
, *ui_out_chain
;
4403 struct ui_stream
*stb
;
4405 stb
= ui_out_stream_new (uiout
);
4406 old_chain
= make_cleanup_ui_out_stream_delete (stb
);
4408 /* FIXME: This is misplaced; mention() is called by things (like hitting a
4409 watchpoint) other than breakpoint creation. It should be possible to
4410 clean this up and at the same time replace the random calls to
4411 breakpoint_changed with this hook, as has already been done for
4412 delete_breakpoint_hook and so on. */
4413 if (create_breakpoint_hook
)
4414 create_breakpoint_hook (b
);
4415 breakpoint_create_event (b
->number
);
4420 printf_filtered ("(apparently deleted?) Eventpoint %d: ", b
->number
);
4423 ui_out_text (uiout
, "Watchpoint ");
4424 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "wpt");
4425 ui_out_field_int (uiout
, "number", b
->number
);
4426 ui_out_text (uiout
, ": ");
4427 print_expression (b
->exp
, stb
->stream
);
4428 ui_out_field_stream (uiout
, "exp", stb
);
4429 do_cleanups (ui_out_chain
);
4431 case bp_hardware_watchpoint
:
4432 ui_out_text (uiout
, "Hardware watchpoint ");
4433 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "wpt");
4434 ui_out_field_int (uiout
, "number", b
->number
);
4435 ui_out_text (uiout
, ": ");
4436 print_expression (b
->exp
, stb
->stream
);
4437 ui_out_field_stream (uiout
, "exp", stb
);
4438 do_cleanups (ui_out_chain
);
4440 case bp_read_watchpoint
:
4441 ui_out_text (uiout
, "Hardware read watchpoint ");
4442 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "hw-rwpt");
4443 ui_out_field_int (uiout
, "number", b
->number
);
4444 ui_out_text (uiout
, ": ");
4445 print_expression (b
->exp
, stb
->stream
);
4446 ui_out_field_stream (uiout
, "exp", stb
);
4447 do_cleanups (ui_out_chain
);
4449 case bp_access_watchpoint
:
4450 ui_out_text (uiout
, "Hardware access (read/write) watchpoint ");
4451 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "hw-awpt");
4452 ui_out_field_int (uiout
, "number", b
->number
);
4453 ui_out_text (uiout
, ": ");
4454 print_expression (b
->exp
, stb
->stream
);
4455 ui_out_field_stream (uiout
, "exp", stb
);
4456 do_cleanups (ui_out_chain
);
4459 if (ui_out_is_mi_like_p (uiout
))
4464 printf_filtered ("Breakpoint %d", b
->number
);
4467 case bp_hardware_breakpoint
:
4468 if (ui_out_is_mi_like_p (uiout
))
4473 printf_filtered ("Hardware assisted breakpoint %d", b
->number
);
4477 case bp_catch_unload
:
4478 printf_filtered ("Catchpoint %d (%s %s)",
4480 (b
->type
== bp_catch_load
) ? "load" : "unload",
4481 (b
->dll_pathname
!= NULL
) ?
4482 b
->dll_pathname
: "<any library>");
4485 case bp_catch_vfork
:
4486 printf_filtered ("Catchpoint %d (%s)",
4488 (b
->type
== bp_catch_fork
) ? "fork" : "vfork");
4491 printf_filtered ("Catchpoint %d (exec)",
4494 case bp_catch_catch
:
4495 case bp_catch_throw
:
4496 printf_filtered ("Catchpoint %d (%s)",
4498 (b
->type
== bp_catch_catch
) ? "catch" : "throw");
4504 case bp_longjmp_resume
:
4505 case bp_step_resume
:
4506 case bp_through_sigtramp
:
4508 case bp_watchpoint_scope
:
4509 case bp_shlib_event
:
4510 case bp_thread_event
:
4511 case bp_overlay_event
:
4516 if (addressprint
|| b
->source_file
== NULL
)
4518 printf_filtered (" at ");
4519 print_address_numeric (b
->address
, 1, gdb_stdout
);
4522 printf_filtered (": file %s, line %d.",
4523 b
->source_file
, b
->line_number
);
4525 do_cleanups (old_chain
);
4526 if (ui_out_is_mi_like_p (uiout
))
4528 printf_filtered ("\n");
4532 /* Add SALS.nelts breakpoints to the breakpoint table. For each
4533 SALS.sal[i] breakpoint, include the corresponding ADDR_STRING[i],
4534 COND[i] and COND_STRING[i] values.
4536 NOTE: If the function succeeds, the caller is expected to cleanup
4537 the arrays ADDR_STRING, COND_STRING, COND and SALS (but not the
4538 array contents). If the function fails (error() is called), the
4539 caller is expected to cleanups both the ADDR_STRING, COND_STRING,
4540 COND and SALS arrays and each of those arrays contents. */
4543 create_breakpoints (struct symtabs_and_lines sals
, char **addr_string
,
4544 struct expression
**cond
, char **cond_string
,
4545 enum bptype type
, enum bpdisp disposition
,
4546 int thread
, int ignore_count
, int from_tty
)
4548 if (type
== bp_hardware_breakpoint
)
4550 int i
= hw_breakpoint_used_count ();
4551 int target_resources_ok
=
4552 TARGET_CAN_USE_HARDWARE_WATCHPOINT (bp_hardware_breakpoint
,
4554 if (target_resources_ok
== 0)
4555 error ("No hardware breakpoint support in the target.");
4556 else if (target_resources_ok
< 0)
4557 error ("Hardware breakpoints used exceeds limit.");
4560 /* Now set all the breakpoints. */
4563 for (i
= 0; i
< sals
.nelts
; i
++)
4565 struct breakpoint
*b
;
4566 struct symtab_and_line sal
= sals
.sals
[i
];
4569 describe_other_breakpoints (sal
.pc
, sal
.section
);
4571 b
= set_raw_breakpoint (sal
, type
);
4572 set_breakpoint_count (breakpoint_count
+ 1);
4573 b
->number
= breakpoint_count
;
4577 b
->addr_string
= addr_string
[i
];
4579 /* addr_string has to be used or breakpoint_re_set will delete
4581 xasprintf (&b
->addr_string
, "*0x%s", paddr (b
->address
));
4582 b
->cond_string
= cond_string
[i
];
4583 b
->ignore_count
= ignore_count
;
4584 b
->enable_state
= bp_enabled
;
4585 b
->disposition
= disposition
;
4591 /* Parse ARG which is assumed to be a SAL specification possibly
4592 followed by conditionals. On return, SALS contains an array of SAL
4593 addresses found. ADDR_STRING contains a vector of (canonical)
4594 address strings. ARG points to the end of the SAL. */
4597 parse_breakpoint_sals (char **address
,
4598 struct symtabs_and_lines
*sals
,
4599 char ***addr_string
)
4601 char *addr_start
= *address
;
4602 *addr_string
= NULL
;
4603 /* If no arg given, or if first arg is 'if ', use the default
4605 if ((*address
) == NULL
4606 || (strncmp ((*address
), "if", 2) == 0 && isspace ((*address
)[2])))
4608 if (default_breakpoint_valid
)
4610 struct symtab_and_line sal
;
4611 init_sal (&sal
); /* initialize to zeroes */
4612 sals
->sals
= (struct symtab_and_line
*)
4613 xmalloc (sizeof (struct symtab_and_line
));
4614 sal
.pc
= default_breakpoint_address
;
4615 sal
.line
= default_breakpoint_line
;
4616 sal
.symtab
= default_breakpoint_symtab
;
4617 sal
.section
= find_pc_overlay (sal
.pc
);
4618 sals
->sals
[0] = sal
;
4622 error ("No default breakpoint address now.");
4626 /* Force almost all breakpoints to be in terms of the
4627 current_source_symtab (which is decode_line_1's default). This
4628 should produce the results we want almost all of the time while
4629 leaving default_breakpoint_* alone.
4630 ObjC: However, don't match an Objective-C method name which
4631 may have a '+' or '-' succeeded by a '[' */
4633 struct symtab_and_line cursal
= get_current_source_symtab_and_line ();
4635 if (default_breakpoint_valid
4637 || ((strchr ("+-", (*address
)[0]) != NULL
)
4638 && ((*address
)[1] != '['))))
4639 *sals
= decode_line_1 (address
, 1, default_breakpoint_symtab
,
4640 default_breakpoint_line
, addr_string
);
4642 *sals
= decode_line_1 (address
, 1, (struct symtab
*) NULL
, 0, addr_string
);
4644 /* For any SAL that didn't have a canonical string, fill one in. */
4645 if (sals
->nelts
> 0 && *addr_string
== NULL
)
4646 *addr_string
= xcalloc (sals
->nelts
, sizeof (char **));
4647 if (addr_start
!= (*address
))
4650 for (i
= 0; i
< sals
->nelts
; i
++)
4652 /* Add the string if not present. */
4653 if ((*addr_string
)[i
] == NULL
)
4654 (*addr_string
)[i
] = savestring (addr_start
, (*address
) - addr_start
);
4660 /* Convert each SAL into a real PC. Verify that the PC can be
4661 inserted as a breakpoint. If it can't throw an error. */
4664 breakpoint_sals_to_pc (struct symtabs_and_lines
*sals
,
4668 for (i
= 0; i
< sals
->nelts
; i
++)
4670 resolve_sal_pc (&sals
->sals
[i
]);
4672 /* It's possible for the PC to be nonzero, but still an illegal
4673 value on some targets.
4675 For example, on HP-UX if you start gdb, and before running the
4676 inferior you try to set a breakpoint on a shared library function
4677 "foo" where the inferior doesn't call "foo" directly but does
4678 pass its address to another function call, then we do find a
4679 minimal symbol for the "foo", but it's address is invalid.
4680 (Appears to be an index into a table that the loader sets up
4681 when the inferior is run.)
4683 Give the target a chance to bless sals.sals[i].pc before we
4684 try to make a breakpoint for it. */
4685 if (PC_REQUIRES_RUN_BEFORE_USE (sals
->sals
[i
].pc
))
4687 if (address
== NULL
)
4688 error ("Cannot break without a running program.");
4690 error ("Cannot break on %s without a running program.",
4696 /* Set a breakpoint according to ARG (function, linenum or *address)
4697 flag: first bit : 0 non-temporary, 1 temporary.
4698 second bit : 0 normal breakpoint, 1 hardware breakpoint. */
4701 break_command_1 (char *arg
, int flag
, int from_tty
)
4703 int tempflag
, hardwareflag
;
4704 struct symtabs_and_lines sals
;
4705 register struct expression
**cond
= 0;
4706 /* Pointers in arg to the start, and one past the end, of the
4708 char **cond_string
= (char **) NULL
;
4709 char *addr_start
= arg
;
4711 struct cleanup
*old_chain
;
4712 struct cleanup
*breakpoint_chain
= NULL
;
4715 int ignore_count
= 0;
4717 hardwareflag
= flag
& BP_HARDWAREFLAG
;
4718 tempflag
= flag
& BP_TEMPFLAG
;
4723 parse_breakpoint_sals (&arg
, &sals
, &addr_string
);
4728 /* Create a chain of things that always need to be cleaned up. */
4729 old_chain
= make_cleanup (null_cleanup
, 0);
4731 /* Make sure that all storage allocated to SALS gets freed. */
4732 make_cleanup (xfree
, sals
.sals
);
4734 /* Cleanup the addr_string array but not its contents. */
4735 make_cleanup (xfree
, addr_string
);
4737 /* Allocate space for all the cond expressions. */
4738 cond
= xcalloc (sals
.nelts
, sizeof (struct expression
*));
4739 make_cleanup (xfree
, cond
);
4741 /* Allocate space for all the cond strings. */
4742 cond_string
= xcalloc (sals
.nelts
, sizeof (char **));
4743 make_cleanup (xfree
, cond_string
);
4745 /* ----------------------------- SNIP -----------------------------
4746 Anything added to the cleanup chain beyond this point is assumed
4747 to be part of a breakpoint. If the breakpoint create succeeds
4748 then the memory is not reclaimed. */
4749 breakpoint_chain
= make_cleanup (null_cleanup
, 0);
4751 /* Mark the contents of the addr_string for cleanup. These go on
4752 the breakpoint_chain and only occure if the breakpoint create
4754 for (i
= 0; i
< sals
.nelts
; i
++)
4756 if (addr_string
[i
] != NULL
)
4757 make_cleanup (xfree
, addr_string
[i
]);
4760 /* Resolve all line numbers to PC's and verify that the addresses
4761 are ok for the target. */
4762 breakpoint_sals_to_pc (&sals
, addr_start
);
4764 /* Verify that condition can be parsed, before setting any
4765 breakpoints. Allocate a separate condition expression for each
4767 thread
= -1; /* No specific thread yet */
4768 for (i
= 0; i
< sals
.nelts
; i
++)
4775 char *cond_start
= NULL
;
4776 char *cond_end
= NULL
;
4777 while (*tok
== ' ' || *tok
== '\t')
4782 while (*end_tok
!= ' ' && *end_tok
!= '\t' && *end_tok
!= '\000')
4785 toklen
= end_tok
- tok
;
4787 if (toklen
>= 1 && strncmp (tok
, "if", toklen
) == 0)
4789 tok
= cond_start
= end_tok
+ 1;
4790 cond
[i
] = parse_exp_1 (&tok
, block_for_pc (sals
.sals
[i
].pc
), 0);
4791 make_cleanup (xfree
, cond
[i
]);
4793 cond_string
[i
] = savestring (cond_start
, cond_end
- cond_start
);
4794 make_cleanup (xfree
, cond_string
[i
]);
4796 else if (toklen
>= 1 && strncmp (tok
, "thread", toklen
) == 0)
4802 thread
= strtol (tok
, &tok
, 0);
4804 error ("Junk after thread keyword.");
4805 if (!valid_thread_id (thread
))
4806 error ("Unknown thread %d\n", thread
);
4809 error ("Junk at end of arguments.");
4813 create_breakpoints (sals
, addr_string
, cond
, cond_string
,
4814 hardwareflag
? bp_hardware_breakpoint
: bp_breakpoint
,
4815 tempflag
? disp_del
: disp_donttouch
,
4816 thread
, ignore_count
, from_tty
);
4820 warning ("Multiple breakpoints were set.");
4821 warning ("Use the \"delete\" command to delete unwanted breakpoints.");
4823 /* That's it. Discard the cleanups for data inserted into the
4825 discard_cleanups (breakpoint_chain
);
4826 /* But cleanup everything else. */
4827 do_cleanups (old_chain
);
4830 /* Set a breakpoint of TYPE/DISPOSITION according to ARG (function,
4831 linenum or *address) with COND and IGNORE_COUNT. */
4833 struct captured_breakpoint_args
4844 do_captured_breakpoint (void *data
)
4846 struct captured_breakpoint_args
*args
= data
;
4847 struct symtabs_and_lines sals
;
4848 register struct expression
**cond
;
4849 struct cleanup
*old_chain
;
4850 struct cleanup
*breakpoint_chain
= NULL
;
4857 /* Parse the source and lines spec. Delay check that the expression
4858 didn't contain trailing garbage until after cleanups are in
4862 address_end
= args
->address
;
4864 parse_breakpoint_sals (&address_end
, &sals
, &addr_string
);
4869 /* Create a chain of things at always need to be cleaned up. */
4870 old_chain
= make_cleanup (null_cleanup
, 0);
4872 /* Always have a addr_string array, even if it is empty. */
4873 make_cleanup (xfree
, addr_string
);
4875 /* Make sure that all storage allocated to SALS gets freed. */
4876 make_cleanup (xfree
, sals
.sals
);
4878 /* Allocate space for all the cond expressions. */
4879 cond
= xcalloc (sals
.nelts
, sizeof (struct expression
*));
4880 make_cleanup (xfree
, cond
);
4882 /* Allocate space for all the cond strings. */
4883 cond_string
= xcalloc (sals
.nelts
, sizeof (char **));
4884 make_cleanup (xfree
, cond_string
);
4886 /* ----------------------------- SNIP -----------------------------
4887 Anything added to the cleanup chain beyond this point is assumed
4888 to be part of a breakpoint. If the breakpoint create goes
4889 through then that memory is not cleaned up. */
4890 breakpoint_chain
= make_cleanup (null_cleanup
, 0);
4892 /* Mark the contents of the addr_string for cleanup. These go on
4893 the breakpoint_chain and only occure if the breakpoint create
4895 for (i
= 0; i
< sals
.nelts
; i
++)
4897 if (addr_string
[i
] != NULL
)
4898 make_cleanup (xfree
, addr_string
[i
]);
4901 /* Wait until now before checking for garbage at the end of the
4902 address. That way cleanups can take care of freeing any
4904 if (*address_end
!= '\0')
4905 error ("Garbage %s following breakpoint address", address_end
);
4907 /* Resolve all line numbers to PC's. */
4908 breakpoint_sals_to_pc (&sals
, args
->address
);
4910 /* Verify that conditions can be parsed, before setting any
4912 for (i
= 0; i
< sals
.nelts
; i
++)
4914 if (args
->condition
!= NULL
)
4916 char *tok
= args
->condition
;
4917 cond
[i
] = parse_exp_1 (&tok
, block_for_pc (sals
.sals
[i
].pc
), 0);
4919 error ("Garbage %s follows condition", tok
);
4920 make_cleanup (xfree
, cond
[i
]);
4921 cond_string
[i
] = xstrdup (args
->condition
);
4925 create_breakpoints (sals
, addr_string
, cond
, cond_string
,
4926 args
->hardwareflag
? bp_hardware_breakpoint
: bp_breakpoint
,
4927 args
->tempflag
? disp_del
: disp_donttouch
,
4928 args
->thread
, args
->ignore_count
, 0/*from-tty*/);
4930 /* That's it. Discard the cleanups for data inserted into the
4932 discard_cleanups (breakpoint_chain
);
4933 /* But cleanup everything else. */
4934 do_cleanups (old_chain
);
4939 gdb_breakpoint (char *address
, char *condition
,
4940 int hardwareflag
, int tempflag
,
4941 int thread
, int ignore_count
)
4943 struct captured_breakpoint_args args
;
4944 args
.address
= address
;
4945 args
.condition
= condition
;
4946 args
.hardwareflag
= hardwareflag
;
4947 args
.tempflag
= tempflag
;
4948 args
.thread
= thread
;
4949 args
.ignore_count
= ignore_count
;
4950 return catch_errors (do_captured_breakpoint
, &args
,
4951 NULL
, RETURN_MASK_ALL
);
4956 break_at_finish_at_depth_command_1 (char *arg
, int flag
, int from_tty
)
4958 struct frame_info
*frame
;
4959 CORE_ADDR low
, high
, selected_pc
= 0;
4960 char *extra_args
= NULL
;
4963 int extra_args_len
= 0, if_arg
= 0;
4966 (arg
[0] == 'i' && arg
[1] == 'f' && (arg
[2] == ' ' || arg
[2] == '\t')))
4969 if (default_breakpoint_valid
)
4971 if (deprecated_selected_frame
)
4973 selected_pc
= get_frame_pc (deprecated_selected_frame
);
4978 error ("No selected frame.");
4981 error ("No default breakpoint address now.");
4985 extra_args
= strchr (arg
, ' ');
4989 extra_args_len
= strlen (extra_args
);
4990 level_arg
= (char *) xmalloc (extra_args
- arg
);
4991 strncpy (level_arg
, arg
, extra_args
- arg
- 1);
4992 level_arg
[extra_args
- arg
- 1] = '\0';
4996 level_arg
= (char *) xmalloc (strlen (arg
) + 1);
4997 strcpy (level_arg
, arg
);
5000 frame
= parse_frame_specification (level_arg
);
5002 selected_pc
= get_frame_pc (frame
);
5009 extra_args_len
= strlen (arg
);
5014 if (find_pc_partial_function (selected_pc
, (char **) NULL
, &low
, &high
))
5016 addr_string
= (char *) xmalloc (26 + extra_args_len
);
5018 sprintf (addr_string
, "*0x%s %s", paddr_nz (high
), extra_args
);
5020 sprintf (addr_string
, "*0x%s", paddr_nz (high
));
5021 break_command_1 (addr_string
, flag
, from_tty
);
5022 xfree (addr_string
);
5025 error ("No function contains the specified address");
5028 error ("Unable to set breakpoint at procedure exit");
5033 break_at_finish_command_1 (char *arg
, int flag
, int from_tty
)
5035 char *addr_string
, *break_string
, *beg_addr_string
;
5036 CORE_ADDR low
, high
;
5037 struct symtabs_and_lines sals
;
5038 struct symtab_and_line sal
;
5039 struct cleanup
*old_chain
;
5040 char *extra_args
= NULL
;
5041 int extra_args_len
= 0;
5045 (arg
[0] == 'i' && arg
[1] == 'f' && (arg
[2] == ' ' || arg
[2] == '\t')))
5047 if (default_breakpoint_valid
)
5049 if (deprecated_selected_frame
)
5051 addr_string
= (char *) xmalloc (15);
5052 sprintf (addr_string
, "*0x%s",
5053 paddr_nz (get_frame_pc (deprecated_selected_frame
)));
5058 error ("No selected frame.");
5061 error ("No default breakpoint address now.");
5065 addr_string
= (char *) xmalloc (strlen (arg
) + 1);
5066 strcpy (addr_string
, arg
);
5072 extra_args_len
= strlen (arg
);
5076 /* get the stuff after the function name or address */
5077 extra_args
= strchr (arg
, ' ');
5081 extra_args_len
= strlen (extra_args
);
5088 beg_addr_string
= addr_string
;
5089 sals
= decode_line_1 (&addr_string
, 1, (struct symtab
*) NULL
, 0,
5092 xfree (beg_addr_string
);
5093 old_chain
= make_cleanup (xfree
, sals
.sals
);
5094 for (i
= 0; (i
< sals
.nelts
); i
++)
5097 if (find_pc_partial_function (sal
.pc
, (char **) NULL
, &low
, &high
))
5099 break_string
= (char *) xmalloc (extra_args_len
+ 26);
5101 sprintf (break_string
, "*0x%s %s", paddr_nz (high
), extra_args
);
5103 sprintf (break_string
, "*0x%s", paddr_nz (high
));
5104 break_command_1 (break_string
, flag
, from_tty
);
5105 xfree (break_string
);
5108 error ("No function contains the specified address");
5112 warning ("Multiple breakpoints were set.\n");
5113 warning ("Use the \"delete\" command to delete unwanted breakpoints.");
5115 do_cleanups (old_chain
);
5119 /* Helper function for break_command_1 and disassemble_command. */
5122 resolve_sal_pc (struct symtab_and_line
*sal
)
5126 if (sal
->pc
== 0 && sal
->symtab
!= NULL
)
5128 if (!find_line_pc (sal
->symtab
, sal
->line
, &pc
))
5129 error ("No line %d in file \"%s\".",
5130 sal
->line
, sal
->symtab
->filename
);
5134 if (sal
->section
== 0 && sal
->symtab
!= NULL
)
5136 struct blockvector
*bv
;
5141 bv
= blockvector_for_pc_sect (sal
->pc
, 0, &index
, sal
->symtab
);
5144 b
= BLOCKVECTOR_BLOCK (bv
, index
);
5145 sym
= block_function (b
);
5148 fixup_symbol_section (sym
, sal
->symtab
->objfile
);
5149 sal
->section
= SYMBOL_BFD_SECTION (sym
);
5153 /* It really is worthwhile to have the section, so we'll just
5154 have to look harder. This case can be executed if we have
5155 line numbers but no functions (as can happen in assembly
5158 struct minimal_symbol
*msym
;
5160 msym
= lookup_minimal_symbol_by_pc (sal
->pc
);
5162 sal
->section
= SYMBOL_BFD_SECTION (msym
);
5169 break_command (char *arg
, int from_tty
)
5171 break_command_1 (arg
, 0, from_tty
);
5175 break_at_finish_command (char *arg
, int from_tty
)
5177 break_at_finish_command_1 (arg
, 0, from_tty
);
5181 break_at_finish_at_depth_command (char *arg
, int from_tty
)
5183 break_at_finish_at_depth_command_1 (arg
, 0, from_tty
);
5187 tbreak_command (char *arg
, int from_tty
)
5189 break_command_1 (arg
, BP_TEMPFLAG
, from_tty
);
5193 tbreak_at_finish_command (char *arg
, int from_tty
)
5195 break_at_finish_command_1 (arg
, BP_TEMPFLAG
, from_tty
);
5199 hbreak_command (char *arg
, int from_tty
)
5201 break_command_1 (arg
, BP_HARDWAREFLAG
, from_tty
);
5205 thbreak_command (char *arg
, int from_tty
)
5207 break_command_1 (arg
, (BP_TEMPFLAG
| BP_HARDWAREFLAG
), from_tty
);
5211 stop_command (char *arg
, int from_tty
)
5213 printf_filtered ("Specify the type of breakpoint to set.\n\
5214 Usage: stop in <function | address>\n\
5219 stopin_command (char *arg
, int from_tty
)
5223 if (arg
== (char *) NULL
)
5225 else if (*arg
!= '*')
5230 /* look for a ':'. If this is a line number specification, then
5231 say it is bad, otherwise, it should be an address or
5232 function/method name */
5233 while (*argptr
&& !hasColon
)
5235 hasColon
= (*argptr
== ':');
5240 badInput
= (*argptr
!= ':'); /* Not a class::method */
5242 badInput
= isdigit (*arg
); /* a simple line number */
5246 printf_filtered ("Usage: stop in <function | address>\n");
5248 break_command_1 (arg
, 0, from_tty
);
5252 stopat_command (char *arg
, int from_tty
)
5256 if (arg
== (char *) NULL
|| *arg
== '*') /* no line number */
5263 /* look for a ':'. If there is a '::' then get out, otherwise
5264 it is probably a line number. */
5265 while (*argptr
&& !hasColon
)
5267 hasColon
= (*argptr
== ':');
5272 badInput
= (*argptr
== ':'); /* we have class::method */
5274 badInput
= !isdigit (*arg
); /* not a line number */
5278 printf_filtered ("Usage: stop at <line>\n");
5280 break_command_1 (arg
, 0, from_tty
);
5284 /* accessflag: hw_write: watch write,
5285 hw_read: watch read,
5286 hw_access: watch access (read or write) */
5288 watch_command_1 (char *arg
, int accessflag
, int from_tty
)
5290 struct breakpoint
*b
;
5291 struct symtab_and_line sal
;
5292 struct expression
*exp
;
5293 struct block
*exp_valid_block
;
5294 struct value
*val
, *mark
;
5295 struct frame_info
*frame
;
5296 struct frame_info
*prev_frame
= NULL
;
5297 char *exp_start
= NULL
;
5298 char *exp_end
= NULL
;
5299 char *tok
, *end_tok
;
5301 char *cond_start
= NULL
;
5302 char *cond_end
= NULL
;
5303 struct expression
*cond
= NULL
;
5304 int i
, other_type_used
, target_resources_ok
= 0;
5305 enum bptype bp_type
;
5308 init_sal (&sal
); /* initialize to zeroes */
5310 /* Parse arguments. */
5311 innermost_block
= NULL
;
5313 exp
= parse_exp_1 (&arg
, 0, 0);
5315 exp_valid_block
= innermost_block
;
5316 mark
= value_mark ();
5317 val
= evaluate_expression (exp
);
5318 release_value (val
);
5319 if (VALUE_LAZY (val
))
5320 value_fetch_lazy (val
);
5323 while (*tok
== ' ' || *tok
== '\t')
5327 while (*end_tok
!= ' ' && *end_tok
!= '\t' && *end_tok
!= '\000')
5330 toklen
= end_tok
- tok
;
5331 if (toklen
>= 1 && strncmp (tok
, "if", toklen
) == 0)
5333 tok
= cond_start
= end_tok
+ 1;
5334 cond
= parse_exp_1 (&tok
, 0, 0);
5338 error ("Junk at end of command.");
5340 if (accessflag
== hw_read
)
5341 bp_type
= bp_read_watchpoint
;
5342 else if (accessflag
== hw_access
)
5343 bp_type
= bp_access_watchpoint
;
5345 bp_type
= bp_hardware_watchpoint
;
5347 mem_cnt
= can_use_hardware_watchpoint (val
);
5348 if (mem_cnt
== 0 && bp_type
!= bp_hardware_watchpoint
)
5349 error ("Expression cannot be implemented with read/access watchpoint.");
5352 i
= hw_watchpoint_used_count (bp_type
, &other_type_used
);
5353 target_resources_ok
=
5354 TARGET_CAN_USE_HARDWARE_WATCHPOINT (bp_type
, i
+ mem_cnt
,
5356 if (target_resources_ok
== 0 && bp_type
!= bp_hardware_watchpoint
)
5357 error ("Target does not support this type of hardware watchpoint.");
5359 if (target_resources_ok
< 0 && bp_type
!= bp_hardware_watchpoint
)
5360 error ("Target can only support one kind of HW watchpoint at a time.");
5363 #if defined(HPUXHPPA)
5364 /* On HP-UX if you set a h/w
5365 watchpoint before the "run" command, the inferior dies with a e.g.,
5366 SIGILL once you start it. I initially believed this was due to a
5367 bad interaction between page protection traps and the initial
5368 startup sequence by the dynamic linker.
5370 However, I tried avoiding that by having HP-UX's implementation of
5371 TARGET_CAN_USE_HW_WATCHPOINT return FALSE if there was no inferior_ptid
5372 yet, which forced slow watches before a "run" or "attach", and it
5373 still fails somewhere in the startup code.
5375 Until I figure out what's happening, I'm disallowing watches altogether
5376 before the "run" or "attach" command. We'll tell the user they must
5377 set watches after getting the program started. */
5378 if (!target_has_execution
)
5380 warning ("can't do that without a running program; try \"break main\", \"run\" first");
5383 #endif /* HPUXHPPA */
5385 /* Change the type of breakpoint to an ordinary watchpoint if a hardware
5386 watchpoint could not be set. */
5387 if (!mem_cnt
|| target_resources_ok
<= 0)
5388 bp_type
= bp_watchpoint
;
5390 /* Now set up the breakpoint. */
5391 b
= set_raw_breakpoint (sal
, bp_type
);
5392 set_breakpoint_count (breakpoint_count
+ 1);
5393 b
->number
= breakpoint_count
;
5394 b
->disposition
= disp_donttouch
;
5396 b
->exp_valid_block
= exp_valid_block
;
5397 b
->exp_string
= savestring (exp_start
, exp_end
- exp_start
);
5401 b
->cond_string
= savestring (cond_start
, cond_end
- cond_start
);
5405 frame
= block_innermost_frame (exp_valid_block
);
5408 prev_frame
= get_prev_frame (frame
);
5409 b
->watchpoint_frame
= get_frame_id (frame
);
5413 memset (&b
->watchpoint_frame
, 0, sizeof (b
->watchpoint_frame
));
5416 /* If the expression is "local", then set up a "watchpoint scope"
5417 breakpoint at the point where we've left the scope of the watchpoint
5419 if (innermost_block
)
5423 struct breakpoint
*scope_breakpoint
;
5424 scope_breakpoint
= create_internal_breakpoint (get_frame_pc (prev_frame
),
5425 bp_watchpoint_scope
);
5427 scope_breakpoint
->enable_state
= bp_enabled
;
5429 /* Automatically delete the breakpoint when it hits. */
5430 scope_breakpoint
->disposition
= disp_del
;
5432 /* Only break in the proper frame (help with recursion). */
5433 scope_breakpoint
->frame_id
= get_frame_id (prev_frame
);
5435 /* Set the address at which we will stop. */
5436 scope_breakpoint
->address
= get_frame_pc (prev_frame
);
5438 /* The scope breakpoint is related to the watchpoint. We
5439 will need to act on them together. */
5440 b
->related_breakpoint
= scope_breakpoint
;
5443 value_free_to_mark (mark
);
5447 /* Return count of locations need to be watched and can be handled
5448 in hardware. If the watchpoint can not be handled
5449 in hardware return zero. */
5451 #if !defined(TARGET_REGION_SIZE_OK_FOR_HW_WATCHPOINT)
5452 #define TARGET_REGION_SIZE_OK_FOR_HW_WATCHPOINT(BYTE_SIZE) \
5453 ((BYTE_SIZE) <= (REGISTER_SIZE))
5456 #if !defined(TARGET_REGION_OK_FOR_HW_WATCHPOINT)
5457 #define TARGET_REGION_OK_FOR_HW_WATCHPOINT(ADDR,LEN) \
5458 (TARGET_REGION_SIZE_OK_FOR_HW_WATCHPOINT(LEN))
5462 can_use_hardware_watchpoint (struct value
*v
)
5464 int found_memory_cnt
= 0;
5465 struct value
*head
= v
;
5467 /* Did the user specifically forbid us to use hardware watchpoints? */
5468 if (!can_use_hw_watchpoints
)
5471 /* Make sure that the value of the expression depends only upon
5472 memory contents, and values computed from them within GDB. If we
5473 find any register references or function calls, we can't use a
5474 hardware watchpoint.
5476 The idea here is that evaluating an expression generates a series
5477 of values, one holding the value of every subexpression. (The
5478 expression a*b+c has five subexpressions: a, b, a*b, c, and
5479 a*b+c.) GDB's values hold almost enough information to establish
5480 the criteria given above --- they identify memory lvalues,
5481 register lvalues, computed values, etcetera. So we can evaluate
5482 the expression, and then scan the chain of values that leaves
5483 behind to decide whether we can detect any possible change to the
5484 expression's final value using only hardware watchpoints.
5486 However, I don't think that the values returned by inferior
5487 function calls are special in any way. So this function may not
5488 notice that an expression involving an inferior function call
5489 can't be watched with hardware watchpoints. FIXME. */
5490 for (; v
; v
= v
->next
)
5492 if (VALUE_LVAL (v
) == lval_memory
)
5495 /* A lazy memory lvalue is one that GDB never needed to fetch;
5496 we either just used its address (e.g., `a' in `a.b') or
5497 we never needed it at all (e.g., `a' in `a,b'). */
5501 /* Ahh, memory we actually used! Check if we can cover
5502 it with hardware watchpoints. */
5503 struct type
*vtype
= check_typedef (VALUE_TYPE (v
));
5505 /* We only watch structs and arrays if user asked for it
5506 explicitly, never if they just happen to appear in a
5507 middle of some value chain. */
5509 || (TYPE_CODE (vtype
) != TYPE_CODE_STRUCT
5510 && TYPE_CODE (vtype
) != TYPE_CODE_ARRAY
))
5512 CORE_ADDR vaddr
= VALUE_ADDRESS (v
) + VALUE_OFFSET (v
);
5513 int len
= TYPE_LENGTH (VALUE_TYPE (v
));
5515 if (!TARGET_REGION_OK_FOR_HW_WATCHPOINT (vaddr
, len
))
5522 else if (v
->lval
!= not_lval
&& v
->modifiable
== 0)
5523 return 0; /* ??? What does this represent? */
5524 else if (v
->lval
== lval_register
)
5525 return 0; /* cannot watch a register with a HW watchpoint */
5528 /* The expression itself looks suitable for using a hardware
5529 watchpoint, but give the target machine a chance to reject it. */
5530 return found_memory_cnt
;
5534 watch_command_wrapper (char *arg
, int from_tty
)
5536 watch_command (arg
, from_tty
);
5540 watch_command (char *arg
, int from_tty
)
5542 watch_command_1 (arg
, hw_write
, from_tty
);
5546 rwatch_command_wrapper (char *arg
, int from_tty
)
5548 rwatch_command (arg
, from_tty
);
5552 rwatch_command (char *arg
, int from_tty
)
5554 watch_command_1 (arg
, hw_read
, from_tty
);
5558 awatch_command_wrapper (char *arg
, int from_tty
)
5560 awatch_command (arg
, from_tty
);
5564 awatch_command (char *arg
, int from_tty
)
5566 watch_command_1 (arg
, hw_access
, from_tty
);
5570 /* Helper routines for the until_command routine in infcmd.c. Here
5571 because it uses the mechanisms of breakpoints. */
5573 /* This function is called by fetch_inferior_event via the
5574 cmd_continuation pointer, to complete the until command. It takes
5575 care of cleaning up the temporary breakpoints set up by the until
5578 until_break_command_continuation (struct continuation_arg
*arg
)
5580 struct cleanup
*cleanups
;
5582 cleanups
= (struct cleanup
*) arg
->data
.pointer
;
5583 do_exec_cleanups (cleanups
);
5588 until_break_command (char *arg
, int from_tty
, int anywhere
)
5590 struct symtabs_and_lines sals
;
5591 struct symtab_and_line sal
;
5592 struct frame_info
*prev_frame
= get_prev_frame (deprecated_selected_frame
);
5593 struct breakpoint
*breakpoint
;
5594 struct cleanup
*old_chain
;
5595 struct continuation_arg
*arg1
;
5598 clear_proceed_status ();
5600 /* Set a breakpoint where the user wants it and at return from
5603 if (default_breakpoint_valid
)
5604 sals
= decode_line_1 (&arg
, 1, default_breakpoint_symtab
,
5605 default_breakpoint_line
, (char ***) NULL
);
5607 sals
= decode_line_1 (&arg
, 1, (struct symtab
*) NULL
,
5608 0, (char ***) NULL
);
5610 if (sals
.nelts
!= 1)
5611 error ("Couldn't get information on specified line.");
5614 xfree (sals
.sals
); /* malloc'd, so freed */
5617 error ("Junk at end of arguments.");
5619 resolve_sal_pc (&sal
);
5622 /* If the user told us to continue until a specified location,
5623 we don't specify a frame at which we need to stop. */
5624 breakpoint
= set_momentary_breakpoint (sal
, null_frame_id
, bp_until
);
5626 /* Otherwise, specify the current frame, because we want to stop only
5627 at the very same frame. */
5628 breakpoint
= set_momentary_breakpoint (sal
,
5629 get_frame_id (deprecated_selected_frame
),
5632 if (!event_loop_p
|| !target_can_async_p ())
5633 old_chain
= make_cleanup_delete_breakpoint (breakpoint
);
5635 old_chain
= make_exec_cleanup_delete_breakpoint (breakpoint
);
5637 /* If we are running asynchronously, and the target supports async
5638 execution, we are not waiting for the target to stop, in the call
5639 tp proceed, below. This means that we cannot delete the
5640 brekpoints until the target has actually stopped. The only place
5641 where we get a chance to do that is in fetch_inferior_event, so
5642 we must set things up for that. */
5644 if (event_loop_p
&& target_can_async_p ())
5646 /* In this case the arg for the continuation is just the point
5647 in the exec_cleanups chain from where to start doing
5648 cleanups, because all the continuation does is the cleanups in
5649 the exec_cleanup_chain. */
5651 (struct continuation_arg
*) xmalloc (sizeof (struct continuation_arg
));
5653 arg1
->data
.pointer
= old_chain
;
5655 add_continuation (until_break_command_continuation
, arg1
);
5658 /* Keep within the current frame, or in frames called by the current
5662 sal
= find_pc_line (get_frame_pc (prev_frame
), 0);
5663 sal
.pc
= get_frame_pc (prev_frame
);
5664 breakpoint
= set_momentary_breakpoint (sal
, get_frame_id (prev_frame
),
5666 if (!event_loop_p
|| !target_can_async_p ())
5667 make_cleanup_delete_breakpoint (breakpoint
);
5669 make_exec_cleanup_delete_breakpoint (breakpoint
);
5672 proceed (-1, TARGET_SIGNAL_DEFAULT
, 0);
5673 /* Do the cleanups now, anly if we are not running asynchronously,
5674 of if we are, but the target is still synchronous. */
5675 if (!event_loop_p
|| !target_can_async_p ())
5676 do_cleanups (old_chain
);
5680 /* These aren't used; I don't konw what they were for. */
5681 /* Set a breakpoint at the catch clause for NAME. */
5683 catch_breakpoint (char *name
)
5688 disable_catch_breakpoint (void)
5693 delete_catch_breakpoint (void)
5698 enable_catch_breakpoint (void)
5705 struct sal_chain
*next
;
5706 struct symtab_and_line sal
;
5710 /* Not really used -- invocation in handle_gnu_4_16_catch_command
5711 had been commented out in the v.4.16 sources, and stays
5712 disabled there now because "catch NAME" syntax isn't allowed.
5714 /* This isn't used; I don't know what it was for. */
5715 /* For each catch clause identified in ARGS, run FUNCTION
5716 with that clause as an argument. */
5717 static struct symtabs_and_lines
5718 map_catch_names (char *args
, int (*function
) ())
5720 register char *p
= args
;
5722 struct symtabs_and_lines sals
;
5724 struct sal_chain
*sal_chain
= 0;
5728 error_no_arg ("one or more catch names");
5736 /* Don't swallow conditional part. */
5737 if (p1
[0] == 'i' && p1
[1] == 'f'
5738 && (p1
[2] == ' ' || p1
[2] == '\t'))
5744 while (isalnum (*p1
) || *p1
== '_' || *p1
== '$')
5748 if (*p1
&& *p1
!= ' ' && *p1
!= '\t')
5749 error ("Arguments must be catch names.");
5755 struct sal_chain
*next
= (struct sal_chain
*)
5756 alloca (sizeof (struct sal_chain
));
5757 next
->next
= sal_chain
;
5758 next
->sal
= get_catch_sal (p
);
5763 printf_unfiltered ("No catch clause for exception %s.\n", p
);
5768 while (*p
== ' ' || *p
== '\t')
5774 /* This shares a lot of code with `print_frame_label_vars' from stack.c. */
5776 static struct symtabs_and_lines
5777 get_catch_sals (int this_level_only
)
5779 register struct blockvector
*bl
;
5780 register struct block
*block
;
5781 int index
, have_default
= 0;
5783 struct symtabs_and_lines sals
;
5784 struct sal_chain
*sal_chain
= 0;
5785 char *blocks_searched
;
5787 /* Not sure whether an error message is always the correct response,
5788 but it's better than a core dump. */
5789 if (deprecated_selected_frame
== NULL
)
5790 error ("No selected frame.");
5791 block
= get_frame_block (deprecated_selected_frame
, 0);
5792 pc
= get_frame_pc (deprecated_selected_frame
);
5798 error ("No symbol table info available.\n");
5800 bl
= blockvector_for_pc (BLOCK_END (block
) - 4, &index
);
5801 blocks_searched
= (char *) alloca (BLOCKVECTOR_NBLOCKS (bl
) * sizeof (char));
5802 memset (blocks_searched
, 0, BLOCKVECTOR_NBLOCKS (bl
) * sizeof (char));
5806 CORE_ADDR end
= BLOCK_END (block
) - 4;
5809 if (bl
!= blockvector_for_pc (end
, &index
))
5810 error ("blockvector blotch");
5811 if (BLOCKVECTOR_BLOCK (bl
, index
) != block
)
5812 error ("blockvector botch");
5813 last_index
= BLOCKVECTOR_NBLOCKS (bl
);
5816 /* Don't print out blocks that have gone by. */
5817 while (index
< last_index
5818 && BLOCK_END (BLOCKVECTOR_BLOCK (bl
, index
)) < pc
)
5821 while (index
< last_index
5822 && BLOCK_END (BLOCKVECTOR_BLOCK (bl
, index
)) < end
)
5824 if (blocks_searched
[index
] == 0)
5826 struct block
*b
= BLOCKVECTOR_BLOCK (bl
, index
);
5828 register struct symbol
*sym
;
5830 ALL_BLOCK_SYMBOLS (b
, i
, sym
)
5832 if (STREQ (SYMBOL_NAME (sym
), "default"))
5838 if (SYMBOL_CLASS (sym
) == LOC_LABEL
)
5840 struct sal_chain
*next
= (struct sal_chain
*)
5841 alloca (sizeof (struct sal_chain
));
5842 next
->next
= sal_chain
;
5843 next
->sal
= find_pc_line (SYMBOL_VALUE_ADDRESS (sym
),
5848 blocks_searched
[index
] = 1;
5854 if (sal_chain
&& this_level_only
)
5857 /* After handling the function's top-level block, stop.
5858 Don't continue to its superblock, the block of
5859 per-file symbols. */
5860 if (BLOCK_FUNCTION (block
))
5862 block
= BLOCK_SUPERBLOCK (block
);
5867 struct sal_chain
*tmp_chain
;
5869 /* Count the number of entries. */
5870 for (index
= 0, tmp_chain
= sal_chain
; tmp_chain
;
5871 tmp_chain
= tmp_chain
->next
)
5875 sals
.sals
= (struct symtab_and_line
*)
5876 xmalloc (index
* sizeof (struct symtab_and_line
));
5877 for (index
= 0; sal_chain
; sal_chain
= sal_chain
->next
, index
++)
5878 sals
.sals
[index
] = sal_chain
->sal
;
5885 ep_skip_leading_whitespace (char **s
)
5887 if ((s
== NULL
) || (*s
== NULL
))
5889 while (isspace (**s
))
5893 /* This function examines a string, and attempts to find a token
5894 that might be an event name in the leading characters. If a
5895 possible match is found, a pointer to the last character of
5896 the token is returned. Else, NULL is returned. */
5899 ep_find_event_name_end (char *arg
)
5902 char *event_name_end
= NULL
;
5904 /* If we could depend upon the presense of strrpbrk, we'd use that... */
5908 /* We break out of the loop when we find a token delimiter.
5909 Basically, we're looking for alphanumerics and underscores;
5910 anything else delimites the token. */
5913 if (!isalnum (*s
) && (*s
!= '_'))
5919 return event_name_end
;
5923 /* This function attempts to parse an optional "if <cond>" clause
5924 from the arg string. If one is not found, it returns NULL.
5926 Else, it returns a pointer to the condition string. (It does not
5927 attempt to evaluate the string against a particular block.) And,
5928 it updates arg to point to the first character following the parsed
5929 if clause in the arg string. */
5932 ep_parse_optional_if_clause (char **arg
)
5936 if (((*arg
)[0] != 'i') || ((*arg
)[1] != 'f') || !isspace ((*arg
)[2]))
5939 /* Skip the "if" keyword. */
5942 /* Skip any extra leading whitespace, and record the start of the
5943 condition string. */
5944 ep_skip_leading_whitespace (arg
);
5947 /* Assume that the condition occupies the remainder of the arg string. */
5948 (*arg
) += strlen (cond_string
);
5953 /* This function attempts to parse an optional filename from the arg
5954 string. If one is not found, it returns NULL.
5956 Else, it returns a pointer to the parsed filename. (This function
5957 makes no attempt to verify that a file of that name exists, or is
5958 accessible.) And, it updates arg to point to the first character
5959 following the parsed filename in the arg string.
5961 Note that clients needing to preserve the returned filename for
5962 future access should copy it to their own buffers. */
5964 ep_parse_optional_filename (char **arg
)
5966 static char filename
[1024];
5971 if ((*arg_p
== '\0') || isspace (*arg_p
))
5989 /* Commands to deal with catching events, such as signals, exceptions,
5990 process start/exit, etc. */
5994 catch_fork
, catch_vfork
5998 #if defined(CHILD_INSERT_FORK_CATCHPOINT) || defined(CHILD_INSERT_VFORK_CATCHPOINT)
5999 static void catch_fork_command_1 (catch_fork_kind fork_kind
,
6000 char *arg
, int tempflag
, int from_tty
);
6003 catch_fork_command_1 (catch_fork_kind fork_kind
, char *arg
, int tempflag
,
6006 char *cond_string
= NULL
;
6008 ep_skip_leading_whitespace (&arg
);
6010 /* The allowed syntax is:
6012 catch [v]fork if <cond>
6014 First, check if there's an if clause. */
6015 cond_string
= ep_parse_optional_if_clause (&arg
);
6017 if ((*arg
!= '\0') && !isspace (*arg
))
6018 error ("Junk at end of arguments.");
6020 /* If this target supports it, create a fork or vfork catchpoint
6021 and enable reporting of such events. */
6025 create_fork_event_catchpoint (tempflag
, cond_string
);
6028 create_vfork_event_catchpoint (tempflag
, cond_string
);
6031 error ("unsupported or unknown fork kind; cannot catch it");
6037 #if defined(CHILD_INSERT_EXEC_CATCHPOINT)
6039 catch_exec_command_1 (char *arg
, int tempflag
, int from_tty
)
6041 char *cond_string
= NULL
;
6043 ep_skip_leading_whitespace (&arg
);
6045 /* The allowed syntax is:
6047 catch exec if <cond>
6049 First, check if there's an if clause. */
6050 cond_string
= ep_parse_optional_if_clause (&arg
);
6052 if ((*arg
!= '\0') && !isspace (*arg
))
6053 error ("Junk at end of arguments.");
6055 /* If this target supports it, create an exec catchpoint
6056 and enable reporting of such events. */
6057 create_exec_event_catchpoint (tempflag
, cond_string
);
6061 #if defined(SOLIB_ADD)
6063 catch_load_command_1 (char *arg
, int tempflag
, int from_tty
)
6065 char *dll_pathname
= NULL
;
6066 char *cond_string
= NULL
;
6068 ep_skip_leading_whitespace (&arg
);
6070 /* The allowed syntax is:
6072 catch load if <cond>
6073 catch load <filename>
6074 catch load <filename> if <cond>
6076 The user is not allowed to specify the <filename> after an
6079 We'll ignore the pathological case of a file named "if".
6081 First, check if there's an if clause. If so, then there
6082 cannot be a filename. */
6083 cond_string
= ep_parse_optional_if_clause (&arg
);
6085 /* If there was an if clause, then there cannot be a filename.
6086 Else, there might be a filename and an if clause. */
6087 if (cond_string
== NULL
)
6089 dll_pathname
= ep_parse_optional_filename (&arg
);
6090 ep_skip_leading_whitespace (&arg
);
6091 cond_string
= ep_parse_optional_if_clause (&arg
);
6094 if ((*arg
!= '\0') && !isspace (*arg
))
6095 error ("Junk at end of arguments.");
6097 /* Create a load breakpoint that only triggers when a load of
6098 the specified dll (or any dll, if no pathname was specified)
6100 SOLIB_CREATE_CATCH_LOAD_HOOK (PIDGET (inferior_ptid
), tempflag
,
6101 dll_pathname
, cond_string
);
6105 catch_unload_command_1 (char *arg
, int tempflag
, int from_tty
)
6107 char *dll_pathname
= NULL
;
6108 char *cond_string
= NULL
;
6110 ep_skip_leading_whitespace (&arg
);
6112 /* The allowed syntax is:
6114 catch unload if <cond>
6115 catch unload <filename>
6116 catch unload <filename> if <cond>
6118 The user is not allowed to specify the <filename> after an
6121 We'll ignore the pathological case of a file named "if".
6123 First, check if there's an if clause. If so, then there
6124 cannot be a filename. */
6125 cond_string
= ep_parse_optional_if_clause (&arg
);
6127 /* If there was an if clause, then there cannot be a filename.
6128 Else, there might be a filename and an if clause. */
6129 if (cond_string
== NULL
)
6131 dll_pathname
= ep_parse_optional_filename (&arg
);
6132 ep_skip_leading_whitespace (&arg
);
6133 cond_string
= ep_parse_optional_if_clause (&arg
);
6136 if ((*arg
!= '\0') && !isspace (*arg
))
6137 error ("Junk at end of arguments.");
6139 /* Create an unload breakpoint that only triggers when an unload of
6140 the specified dll (or any dll, if no pathname was specified)
6142 SOLIB_CREATE_CATCH_UNLOAD_HOOK (PIDGET (inferior_ptid
), tempflag
,
6143 dll_pathname
, cond_string
);
6145 #endif /* SOLIB_ADD */
6147 /* Commands to deal with catching exceptions. */
6149 /* Set a breakpoint at the specified callback routine for an
6150 exception event callback */
6153 create_exception_catchpoint (int tempflag
, char *cond_string
,
6154 enum exception_event_kind ex_event
,
6155 struct symtab_and_line
*sal
)
6157 struct breakpoint
*b
;
6158 int thread
= -1; /* All threads. */
6161 if (!sal
) /* no exception support? */
6166 case EX_EVENT_THROW
:
6167 bptype
= bp_catch_throw
;
6169 case EX_EVENT_CATCH
:
6170 bptype
= bp_catch_catch
;
6172 default: /* error condition */
6173 error ("Internal error -- invalid catchpoint kind");
6176 b
= set_raw_breakpoint (*sal
, bptype
);
6177 set_breakpoint_count (breakpoint_count
+ 1);
6178 b
->number
= breakpoint_count
;
6180 b
->cond_string
= (cond_string
== NULL
) ?
6181 NULL
: savestring (cond_string
, strlen (cond_string
));
6183 b
->addr_string
= NULL
;
6184 b
->enable_state
= bp_enabled
;
6185 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
6189 /* Deal with "catch catch" and "catch throw" commands */
6192 catch_exception_command_1 (enum exception_event_kind ex_event
, char *arg
,
6193 int tempflag
, int from_tty
)
6195 char *cond_string
= NULL
;
6196 struct symtab_and_line
*sal
= NULL
;
6198 ep_skip_leading_whitespace (&arg
);
6200 cond_string
= ep_parse_optional_if_clause (&arg
);
6202 if ((*arg
!= '\0') && !isspace (*arg
))
6203 error ("Junk at end of arguments.");
6205 if ((ex_event
!= EX_EVENT_THROW
) &&
6206 (ex_event
!= EX_EVENT_CATCH
))
6207 error ("Unsupported or unknown exception event; cannot catch it");
6209 /* See if we can find a callback routine */
6210 sal
= target_enable_exception_callback (ex_event
, 1);
6214 /* We have callbacks from the runtime system for exceptions.
6215 Set a breakpoint on the sal found, if no errors */
6216 if (sal
!= (struct symtab_and_line
*) -1)
6217 create_exception_catchpoint (tempflag
, cond_string
, ex_event
, sal
);
6219 return; /* something went wrong with setting up callbacks */
6223 /* No callbacks from runtime system for exceptions.
6224 Try GNU C++ exception breakpoints using labels in debug info. */
6225 if (ex_event
== EX_EVENT_CATCH
)
6227 handle_gnu_4_16_catch_command (arg
, tempflag
, from_tty
);
6229 else if (ex_event
== EX_EVENT_THROW
)
6231 /* Set a breakpoint on __raise_exception () */
6233 warning ("Unsupported with this platform/compiler combination.");
6234 warning ("Perhaps you can achieve the effect you want by setting");
6235 warning ("a breakpoint on __raise_exception().");
6240 /* Cover routine to allow wrapping target_enable_exception_catchpoints
6241 inside a catch_errors */
6244 cover_target_enable_exception_callback (void *arg
)
6246 args_for_catchpoint_enable
*args
= arg
;
6247 struct symtab_and_line
*sal
;
6248 sal
= target_enable_exception_callback (args
->kind
, args
->enable_p
);
6251 else if (sal
== (struct symtab_and_line
*) -1)
6254 return 1; /*is valid */
6259 /* This is the original v.4.16 and earlier version of the
6260 catch_command_1() function. Now that other flavours of "catch"
6261 have been introduced, and since exception handling can be handled
6262 in other ways (through target ops) also, this is used only for the
6263 GNU C++ exception handling system.
6264 Note: Only the "catch" flavour of GDB 4.16 is handled here. The
6265 "catch NAME" is now no longer allowed in catch_command_1(). Also,
6266 there was no code in GDB 4.16 for "catch throw".
6268 Called from catch_exception_command_1 () */
6272 handle_gnu_4_16_catch_command (char *arg
, int tempflag
, int from_tty
)
6274 /* First, translate ARG into something we can deal with in terms
6277 struct symtabs_and_lines sals
;
6278 struct symtab_and_line sal
;
6279 register struct expression
*cond
= 0;
6280 register struct breakpoint
*b
;
6284 init_sal (&sal
); /* initialize to zeroes */
6286 /* If no arg given, or if first arg is 'if ', all active catch clauses
6287 are breakpointed. */
6289 if (!arg
|| (arg
[0] == 'i' && arg
[1] == 'f'
6290 && (arg
[2] == ' ' || arg
[2] == '\t')))
6292 /* Grab all active catch clauses. */
6293 sals
= get_catch_sals (0);
6297 /* Grab selected catch clauses. */
6298 error ("catch NAME not implemented");
6301 /* Not sure why this code has been disabled. I'm leaving
6302 it disabled. We can never come here now anyway
6303 since we don't allow the "catch NAME" syntax.
6306 /* This isn't used; I don't know what it was for. */
6307 sals
= map_catch_names (arg
, catch_breakpoint
);
6315 for (i
= 0; i
< sals
.nelts
; i
++)
6317 resolve_sal_pc (&sals
.sals
[i
]);
6321 if (arg
[0] == 'i' && arg
[1] == 'f'
6322 && (arg
[2] == ' ' || arg
[2] == '\t'))
6323 cond
= parse_exp_1 ((arg
+= 2, &arg
),
6324 block_for_pc (sals
.sals
[i
].pc
), 0);
6326 error ("Junk at end of arguments.");
6331 for (i
= 0; i
< sals
.nelts
; i
++)
6336 describe_other_breakpoints (sal
.pc
, sal
.section
);
6338 /* Important -- this is an ordinary breakpoint. For platforms
6339 with callback support for exceptions,
6340 create_exception_catchpoint() will create special bp types
6341 (bp_catch_catch and bp_catch_throw), and there is code in
6342 insert_breakpoints() and elsewhere that depends on that. */
6343 b
= set_raw_breakpoint (sal
, bp_breakpoint
);
6344 set_breakpoint_count (breakpoint_count
+ 1);
6345 b
->number
= breakpoint_count
;
6348 b
->enable_state
= bp_enabled
;
6349 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
6356 warning ("Multiple breakpoints were set.");
6357 warning ("Use the \"delete\" command to delete unwanted breakpoints.");
6363 catch_command_1 (char *arg
, int tempflag
, int from_tty
)
6366 /* The first argument may be an event name, such as "start" or "load".
6367 If so, then handle it as such. If it doesn't match an event name,
6368 then attempt to interpret it as an exception name. (This latter is
6369 the v4.16-and-earlier GDB meaning of the "catch" command.)
6371 First, try to find the bounds of what might be an event name. */
6372 char *arg1_start
= arg
;
6376 if (arg1_start
== NULL
)
6378 /* Old behaviour was to use pre-v-4.16 syntax */
6379 /* catch_throw_command_1 (arg1_start, tempflag, from_tty); */
6381 /* Now, this is not allowed */
6382 error ("Catch requires an event name.");
6385 arg1_end
= ep_find_event_name_end (arg1_start
);
6386 if (arg1_end
== NULL
)
6387 error ("catch requires an event");
6388 arg1_length
= arg1_end
+ 1 - arg1_start
;
6390 /* Try to match what we found against known event names. */
6391 if (strncmp (arg1_start
, "signal", arg1_length
) == 0)
6393 error ("Catch of signal not yet implemented");
6395 else if (strncmp (arg1_start
, "catch", arg1_length
) == 0)
6397 catch_exception_command_1 (EX_EVENT_CATCH
, arg1_end
+ 1,
6398 tempflag
, from_tty
);
6400 else if (strncmp (arg1_start
, "throw", arg1_length
) == 0)
6402 catch_exception_command_1 (EX_EVENT_THROW
, arg1_end
+ 1,
6403 tempflag
, from_tty
);
6405 else if (strncmp (arg1_start
, "thread_start", arg1_length
) == 0)
6407 error ("Catch of thread_start not yet implemented");
6409 else if (strncmp (arg1_start
, "thread_exit", arg1_length
) == 0)
6411 error ("Catch of thread_exit not yet implemented");
6413 else if (strncmp (arg1_start
, "thread_join", arg1_length
) == 0)
6415 error ("Catch of thread_join not yet implemented");
6417 else if (strncmp (arg1_start
, "start", arg1_length
) == 0)
6419 error ("Catch of start not yet implemented");
6421 else if (strncmp (arg1_start
, "exit", arg1_length
) == 0)
6423 error ("Catch of exit not yet implemented");
6425 else if (strncmp (arg1_start
, "fork", arg1_length
) == 0)
6427 #if defined(CHILD_INSERT_FORK_CATCHPOINT)
6428 catch_fork_command_1 (catch_fork
, arg1_end
+ 1, tempflag
, from_tty
);
6430 error ("Catch of fork not yet implemented");
6433 else if (strncmp (arg1_start
, "vfork", arg1_length
) == 0)
6435 #if defined(CHILD_INSERT_VFORK_CATCHPOINT)
6436 catch_fork_command_1 (catch_vfork
, arg1_end
+ 1, tempflag
, from_tty
);
6438 error ("Catch of vfork not yet implemented");
6441 else if (strncmp (arg1_start
, "exec", arg1_length
) == 0)
6443 #if defined(CHILD_INSERT_EXEC_CATCHPOINT)
6444 catch_exec_command_1 (arg1_end
+ 1, tempflag
, from_tty
);
6446 error ("Catch of exec not yet implemented");
6449 else if (strncmp (arg1_start
, "load", arg1_length
) == 0)
6451 #if defined(SOLIB_ADD)
6452 catch_load_command_1 (arg1_end
+ 1, tempflag
, from_tty
);
6454 error ("Catch of load not implemented");
6457 else if (strncmp (arg1_start
, "unload", arg1_length
) == 0)
6459 #if defined(SOLIB_ADD)
6460 catch_unload_command_1 (arg1_end
+ 1, tempflag
, from_tty
);
6462 error ("Catch of load not implemented");
6465 else if (strncmp (arg1_start
, "stop", arg1_length
) == 0)
6467 error ("Catch of stop not yet implemented");
6470 /* This doesn't appear to be an event name */
6474 /* Pre-v.4.16 behaviour was to treat the argument
6475 as the name of an exception */
6476 /* catch_throw_command_1 (arg1_start, tempflag, from_tty); */
6477 /* Now this is not allowed */
6478 error ("Unknown event kind specified for catch");
6483 /* Used by the gui, could be made a worker for other things. */
6486 set_breakpoint_sal (struct symtab_and_line sal
)
6488 struct breakpoint
*b
;
6489 b
= set_raw_breakpoint (sal
, bp_breakpoint
);
6490 set_breakpoint_count (breakpoint_count
+ 1);
6491 b
->number
= breakpoint_count
;
6498 /* These aren't used; I don't know what they were for. */
6499 /* Disable breakpoints on all catch clauses described in ARGS. */
6501 disable_catch (char *args
)
6503 /* Map the disable command to catch clauses described in ARGS. */
6506 /* Enable breakpoints on all catch clauses described in ARGS. */
6508 enable_catch (char *args
)
6510 /* Map the disable command to catch clauses described in ARGS. */
6513 /* Delete breakpoints on all catch clauses in the active scope. */
6515 delete_catch (char *args
)
6517 /* Map the delete command to catch clauses described in ARGS. */
6522 catch_command (char *arg
, int from_tty
)
6524 catch_command_1 (arg
, 0, from_tty
);
6529 tcatch_command (char *arg
, int from_tty
)
6531 catch_command_1 (arg
, 1, from_tty
);
6534 /* Delete breakpoints by address or line. */
6537 clear_command (char *arg
, int from_tty
)
6539 struct breakpoint
*b
, *tmp
, *prev
, *found
;
6541 struct symtabs_and_lines sals
;
6542 struct symtab_and_line sal
;
6547 sals
= decode_line_spec (arg
, 1);
6552 sals
.sals
= (struct symtab_and_line
*)
6553 xmalloc (sizeof (struct symtab_and_line
));
6554 make_cleanup (xfree
, sals
.sals
);
6555 init_sal (&sal
); /* initialize to zeroes */
6556 sal
.line
= default_breakpoint_line
;
6557 sal
.symtab
= default_breakpoint_symtab
;
6558 sal
.pc
= default_breakpoint_address
;
6559 if (sal
.symtab
== 0)
6560 error ("No source file specified.");
6568 /* For each line spec given, delete bps which correspond
6569 to it. Do it in two passes, solely to preserve the current
6570 behavior that from_tty is forced true if we delete more than
6574 for (i
= 0; i
< sals
.nelts
; i
++)
6576 /* If exact pc given, clear bpts at that pc.
6577 If line given (pc == 0), clear all bpts on specified line.
6578 If defaulting, clear all bpts on default line
6581 defaulting sal.pc != 0 tests to do
6586 1 0 <can't happen> */
6591 /* Find all matching breakpoints, remove them from the
6592 breakpoint chain, and add them to the 'found' chain. */
6593 ALL_BREAKPOINTS_SAFE (b
, tmp
)
6595 /* Are we going to delete b? */
6596 if (b
->type
!= bp_none
6597 && b
->type
!= bp_watchpoint
6598 && b
->type
!= bp_hardware_watchpoint
6599 && b
->type
!= bp_read_watchpoint
6600 && b
->type
!= bp_access_watchpoint
6601 /* Not if b is a watchpoint of any sort... */
6602 && (((sal
.pc
&& (b
->address
== sal
.pc
))
6603 && (!section_is_overlay (b
->section
)
6604 || b
->section
== sal
.section
))
6605 /* Yes, if sal.pc matches b (modulo overlays). */
6606 || ((default_match
|| (0 == sal
.pc
))
6607 && b
->source_file
!= NULL
6608 && sal
.symtab
!= NULL
6609 && STREQ (b
->source_file
, sal
.symtab
->filename
)
6610 && b
->line_number
== sal
.line
)))
6611 /* Yes, if sal source file and line matches b. */
6613 /* Remove it from breakpoint_chain... */
6614 if (b
== breakpoint_chain
)
6616 /* b is at the head of the list */
6617 breakpoint_chain
= b
->next
;
6621 prev
->next
= b
->next
;
6623 /* And add it to 'found' chain. */
6629 /* Keep b, and keep a pointer to it. */
6634 /* Now go thru the 'found' chain and delete them. */
6638 error ("No breakpoint at %s.", arg
);
6640 error ("No breakpoint at this line.");
6644 from_tty
= 1; /* Always report if deleted more than one */
6646 printf_unfiltered ("Deleted breakpoint%s ", found
->next
? "s" : "");
6647 breakpoints_changed ();
6651 printf_unfiltered ("%d ", found
->number
);
6653 delete_breakpoint (found
);
6657 putchar_unfiltered ('\n');
6660 /* Delete breakpoint in BS if they are `delete' breakpoints and
6661 all breakpoints that are marked for deletion, whether hit or not.
6662 This is called after any breakpoint is hit, or after errors. */
6665 breakpoint_auto_delete (bpstat bs
)
6667 struct breakpoint
*b
, *temp
;
6669 for (; bs
; bs
= bs
->next
)
6670 if (bs
->breakpoint_at
&& bs
->breakpoint_at
->disposition
== disp_del
6672 delete_breakpoint (bs
->breakpoint_at
);
6674 ALL_BREAKPOINTS_SAFE (b
, temp
)
6676 if (b
->disposition
== disp_del_at_next_stop
)
6677 delete_breakpoint (b
);
6681 /* Delete a breakpoint and clean up all traces of it in the data
6685 delete_breakpoint (struct breakpoint
*bpt
)
6687 register struct breakpoint
*b
;
6691 error ("Internal error (attempted to delete a NULL breakpoint)");
6694 /* Has this bp already been deleted? This can happen because multiple
6695 lists can hold pointers to bp's. bpstat lists are especial culprits.
6697 One example of this happening is a watchpoint's scope bp. When the
6698 scope bp triggers, we notice that the watchpoint is out of scope, and
6699 delete it. We also delete its scope bp. But the scope bp is marked
6700 "auto-deleting", and is already on a bpstat. That bpstat is then
6701 checked for auto-deleting bp's, which are deleted.
6703 A real solution to this problem might involve reference counts in bp's,
6704 and/or giving them pointers back to their referencing bpstat's, and
6705 teaching delete_breakpoint to only free a bp's storage when no more
6706 references were extent. A cheaper bandaid was chosen. */
6707 if (bpt
->type
== bp_none
)
6710 if (delete_breakpoint_hook
)
6711 delete_breakpoint_hook (bpt
);
6712 breakpoint_delete_event (bpt
->number
);
6715 remove_breakpoint (bpt
, mark_inserted
);
6717 if (breakpoint_chain
== bpt
)
6718 breakpoint_chain
= bpt
->next
;
6720 /* If we have callback-style exception catchpoints, don't go through
6721 the adjustments to the C++ runtime library etc. if the inferior
6722 isn't actually running. target_enable_exception_callback for a
6723 null target ops vector gives an undesirable error message, so we
6724 check here and avoid it. Since currently (1997-09-17) only HP-UX aCC's
6725 exceptions are supported in this way, it's OK for now. FIXME */
6726 if (ep_is_exception_catchpoint (bpt
) && target_has_execution
)
6728 static char message1
[] = "Error in deleting catchpoint %d:\n";
6729 static char message
[sizeof (message1
) + 30];
6730 args_for_catchpoint_enable args
;
6732 /* Format possible error msg */
6733 sprintf (message
, message1
, bpt
->number
);
6734 args
.kind
= bpt
->type
== bp_catch_catch
?
6735 EX_EVENT_CATCH
: EX_EVENT_THROW
;
6737 catch_errors (cover_target_enable_exception_callback
, &args
,
6738 message
, RETURN_MASK_ALL
);
6745 b
->next
= bpt
->next
;
6749 check_duplicates (bpt
);
6750 /* If this breakpoint was inserted, and there is another breakpoint
6751 at the same address, we need to insert the other breakpoint. */
6753 && bpt
->type
!= bp_hardware_watchpoint
6754 && bpt
->type
!= bp_read_watchpoint
6755 && bpt
->type
!= bp_access_watchpoint
6756 && bpt
->type
!= bp_catch_fork
6757 && bpt
->type
!= bp_catch_vfork
6758 && bpt
->type
!= bp_catch_exec
)
6761 if (b
->address
== bpt
->address
6762 && b
->section
== bpt
->section
6764 && b
->enable_state
!= bp_disabled
6765 && b
->enable_state
!= bp_shlib_disabled
6766 && b
->enable_state
!= bp_call_disabled
)
6770 /* We should never reach this point if there is a permanent
6771 breakpoint at the same address as the one being deleted.
6772 If there is a permanent breakpoint somewhere, it should
6773 always be the only one inserted. */
6774 if (b
->enable_state
== bp_permanent
)
6775 internal_error (__FILE__
, __LINE__
,
6776 "another breakpoint was inserted on top of "
6777 "a permanent breakpoint");
6779 if (b
->type
== bp_hardware_breakpoint
)
6780 val
= target_insert_hw_breakpoint (b
->address
, b
->shadow_contents
);
6782 val
= target_insert_breakpoint (b
->address
, b
->shadow_contents
);
6784 /* If there was an error in the insert, print a message, then stop execution. */
6787 struct ui_file
*tmp_error_stream
= mem_fileopen ();
6788 make_cleanup_ui_file_delete (tmp_error_stream
);
6791 if (b
->type
== bp_hardware_breakpoint
)
6793 fprintf_unfiltered (tmp_error_stream
,
6794 "Cannot insert hardware breakpoint %d.\n"
6795 "You may have requested too many hardware breakpoints.\n",
6800 fprintf_unfiltered (tmp_error_stream
, "Cannot insert breakpoint %d.\n", b
->number
);
6801 fprintf_filtered (tmp_error_stream
, "Error accessing memory address ");
6802 print_address_numeric (b
->address
, 1, tmp_error_stream
);
6803 fprintf_filtered (tmp_error_stream
, ": %s.\n",
6804 safe_strerror (val
));
6807 fprintf_unfiltered (tmp_error_stream
,"The same program may be running in another process.");
6808 target_terminal_ours_for_output ();
6809 error_stream(tmp_error_stream
);
6816 free_command_lines (&bpt
->commands
);
6819 if (bpt
->cond_string
!= NULL
)
6820 xfree (bpt
->cond_string
);
6821 if (bpt
->addr_string
!= NULL
)
6822 xfree (bpt
->addr_string
);
6823 if (bpt
->exp
!= NULL
)
6825 if (bpt
->exp_string
!= NULL
)
6826 xfree (bpt
->exp_string
);
6827 if (bpt
->val
!= NULL
)
6828 value_free (bpt
->val
);
6829 if (bpt
->source_file
!= NULL
)
6830 xfree (bpt
->source_file
);
6831 if (bpt
->dll_pathname
!= NULL
)
6832 xfree (bpt
->dll_pathname
);
6833 if (bpt
->triggered_dll_pathname
!= NULL
)
6834 xfree (bpt
->triggered_dll_pathname
);
6835 if (bpt
->exec_pathname
!= NULL
)
6836 xfree (bpt
->exec_pathname
);
6838 /* Be sure no bpstat's are pointing at it after it's been freed. */
6839 /* FIXME, how can we find all bpstat's?
6840 We just check stop_bpstat for now. */
6841 for (bs
= stop_bpstat
; bs
; bs
= bs
->next
)
6842 if (bs
->breakpoint_at
== bpt
)
6844 bs
->breakpoint_at
= NULL
;
6846 /* bs->commands will be freed later. */
6848 /* On the chance that someone will soon try again to delete this same
6849 bp, we mark it as deleted before freeing its storage. */
6850 bpt
->type
= bp_none
;
6856 do_delete_breakpoint_cleanup (void *b
)
6858 delete_breakpoint (b
);
6862 make_cleanup_delete_breakpoint (struct breakpoint
*b
)
6864 return make_cleanup (do_delete_breakpoint_cleanup
, b
);
6868 make_exec_cleanup_delete_breakpoint (struct breakpoint
*b
)
6870 return make_exec_cleanup (do_delete_breakpoint_cleanup
, b
);
6874 delete_command (char *arg
, int from_tty
)
6876 struct breakpoint
*b
, *temp
;
6882 int breaks_to_delete
= 0;
6884 /* Delete all breakpoints if no argument.
6885 Do not delete internal or call-dummy breakpoints, these
6886 have to be deleted with an explicit breakpoint number argument. */
6889 if (b
->type
!= bp_call_dummy
&&
6890 b
->type
!= bp_shlib_event
&&
6891 b
->type
!= bp_thread_event
&&
6892 b
->type
!= bp_overlay_event
&&
6894 breaks_to_delete
= 1;
6897 /* Ask user only if there are some breakpoints to delete. */
6899 || (breaks_to_delete
&& query ("Delete all breakpoints? ")))
6901 ALL_BREAKPOINTS_SAFE (b
, temp
)
6903 if (b
->type
!= bp_call_dummy
&&
6904 b
->type
!= bp_shlib_event
&&
6905 b
->type
!= bp_thread_event
&&
6906 b
->type
!= bp_overlay_event
&&
6908 delete_breakpoint (b
);
6913 map_breakpoint_numbers (arg
, delete_breakpoint
);
6916 /* Reset a breakpoint given it's struct breakpoint * BINT.
6917 The value we return ends up being the return value from catch_errors.
6918 Unused in this case. */
6921 breakpoint_re_set_one (void *bint
)
6923 /* get past catch_errs */
6924 struct breakpoint
*b
= (struct breakpoint
*) bint
;
6927 struct symtabs_and_lines sals
;
6929 enum enable_state save_enable
;
6934 warning ("attempted to reset apparently deleted breakpoint #%d?",
6938 case bp_hardware_breakpoint
:
6940 case bp_catch_unload
:
6941 if (b
->addr_string
== NULL
)
6943 /* Anything without a string can't be re-set. */
6944 delete_breakpoint (b
);
6947 /* HACK: cagney/2001-11-11: kettenis/2001-11-11: MarkK wrote:
6949 ``And a hack it is, although Apple's Darwin version of GDB
6950 contains an almost identical hack to implement a "future
6951 break" command. It seems to work in many real world cases,
6952 but it is easy to come up with a test case where the patch
6953 doesn't help at all.''
6955 ``It seems that the way GDB implements breakpoints - in -
6956 shared - libraries was designed for a.out shared library
6957 systems (SunOS 4) where shared libraries were loaded at a
6958 fixed address in memory. Since ELF shared libraries can (and
6959 will) be loaded at any address in memory, things break.
6960 Fixing this is not trivial. Therefore, I'm not sure whether
6961 we should add this hack to the branch only. I cannot
6962 guarantee that things will be fixed on the trunk in the near
6965 In case we have a problem, disable this breakpoint. We'll
6966 restore its status if we succeed. Don't disable a
6967 shlib_disabled breakpoint though. There's a fair chance we
6968 can't re-set it if the shared library it's in hasn't been
6970 save_enable
= b
->enable_state
;
6971 if (b
->enable_state
!= bp_shlib_disabled
)
6972 b
->enable_state
= bp_disabled
;
6974 set_language (b
->language
);
6975 input_radix
= b
->input_radix
;
6977 sals
= decode_line_1 (&s
, 1, (struct symtab
*) NULL
, 0, (char ***) NULL
);
6978 for (i
= 0; i
< sals
.nelts
; i
++)
6980 resolve_sal_pc (&sals
.sals
[i
]);
6982 /* Reparse conditions, they might contain references to the
6984 if (b
->cond_string
!= NULL
)
6989 b
->cond
= parse_exp_1 (&s
, block_for_pc (sals
.sals
[i
].pc
), 0);
6992 /* We need to re-set the breakpoint if the address changes... */
6993 if (b
->address
!= sals
.sals
[i
].pc
6994 /* ...or new and old breakpoints both have source files, and
6995 the source file name or the line number changes... */
6996 || (b
->source_file
!= NULL
6997 && sals
.sals
[i
].symtab
!= NULL
6998 && (!STREQ (b
->source_file
, sals
.sals
[i
].symtab
->filename
)
6999 || b
->line_number
!= sals
.sals
[i
].line
)
7001 /* ...or we switch between having a source file and not having
7003 || ((b
->source_file
== NULL
) != (sals
.sals
[i
].symtab
== NULL
))
7006 if (b
->source_file
!= NULL
)
7007 xfree (b
->source_file
);
7008 if (sals
.sals
[i
].symtab
== NULL
)
7009 b
->source_file
= NULL
;
7012 savestring (sals
.sals
[i
].symtab
->filename
,
7013 strlen (sals
.sals
[i
].symtab
->filename
));
7014 b
->line_number
= sals
.sals
[i
].line
;
7015 b
->address
= sals
.sals
[i
].pc
;
7017 /* Used to check for duplicates here, but that can
7018 cause trouble, as it doesn't check for disabled
7023 /* Might be better to do this just once per breakpoint_re_set,
7024 rather than once for every breakpoint. */
7025 breakpoints_changed ();
7027 b
->section
= sals
.sals
[i
].section
;
7028 b
->enable_state
= save_enable
; /* Restore it, this worked. */
7031 /* Now that this is re-enabled, check_duplicates
7033 check_duplicates (b
);
7040 case bp_hardware_watchpoint
:
7041 case bp_read_watchpoint
:
7042 case bp_access_watchpoint
:
7043 innermost_block
= NULL
;
7044 /* The issue arises of what context to evaluate this in. The
7045 same one as when it was set, but what does that mean when
7046 symbols have been re-read? We could save the filename and
7047 functionname, but if the context is more local than that, the
7048 best we could do would be something like how many levels deep
7049 and which index at that particular level, but that's going to
7050 be less stable than filenames or function names. */
7052 /* So for now, just use a global context. */
7055 b
->exp
= parse_expression (b
->exp_string
);
7056 b
->exp_valid_block
= innermost_block
;
7057 mark
= value_mark ();
7059 value_free (b
->val
);
7060 b
->val
= evaluate_expression (b
->exp
);
7061 release_value (b
->val
);
7062 if (VALUE_LAZY (b
->val
) && b
->enable_state
== bp_enabled
)
7063 value_fetch_lazy (b
->val
);
7065 if (b
->cond_string
!= NULL
)
7070 b
->cond
= parse_exp_1 (&s
, (struct block
*) 0, 0);
7072 if (b
->enable_state
== bp_enabled
)
7074 value_free_to_mark (mark
);
7076 case bp_catch_catch
:
7077 case bp_catch_throw
:
7079 /* We needn't really do anything to reset these, since the mask
7080 that requests them is unaffected by e.g., new libraries being
7083 case bp_catch_vfork
:
7088 printf_filtered ("Deleting unknown breakpoint type %d\n", b
->type
);
7090 /* Delete longjmp and overlay event breakpoints; they will be
7091 reset later by breakpoint_re_set. */
7093 case bp_longjmp_resume
:
7094 case bp_overlay_event
:
7095 delete_breakpoint (b
);
7098 /* This breakpoint is special, it's set up when the inferior
7099 starts and we really don't want to touch it. */
7100 case bp_shlib_event
:
7102 /* Like bp_shlib_event, this breakpoint type is special.
7103 Once it is set up, we do not want to touch it. */
7104 case bp_thread_event
:
7106 /* Keep temporary breakpoints, which can be encountered when we step
7107 over a dlopen call and SOLIB_ADD is resetting the breakpoints.
7108 Otherwise these should have been blown away via the cleanup chain
7109 or by breakpoint_init_inferior when we rerun the executable. */
7112 case bp_watchpoint_scope
:
7114 case bp_step_resume
:
7121 /* Re-set all breakpoints after symbols have been re-loaded. */
7123 breakpoint_re_set (void)
7125 struct breakpoint
*b
, *temp
;
7126 enum language save_language
;
7127 int save_input_radix
;
7128 static char message1
[] = "Error in re-setting breakpoint %d:\n";
7129 char message
[sizeof (message1
) + 30 /* slop */ ];
7131 save_language
= current_language
->la_language
;
7132 save_input_radix
= input_radix
;
7133 ALL_BREAKPOINTS_SAFE (b
, temp
)
7135 /* Format possible error msg */
7136 sprintf (message
, message1
, b
->number
);
7137 catch_errors (breakpoint_re_set_one
, b
, message
, RETURN_MASK_ALL
);
7139 set_language (save_language
);
7140 input_radix
= save_input_radix
;
7142 if (GET_LONGJMP_TARGET_P ())
7144 create_longjmp_breakpoint ("longjmp");
7145 create_longjmp_breakpoint ("_longjmp");
7146 create_longjmp_breakpoint ("siglongjmp");
7147 create_longjmp_breakpoint ("_siglongjmp");
7148 create_longjmp_breakpoint (NULL
);
7151 create_overlay_event_breakpoint ("_ovly_debug_event");
7154 /* Reset the thread number of this breakpoint:
7156 - If the breakpoint is for all threads, leave it as-is.
7157 - Else, reset it to the current thread for inferior_ptid. */
7159 breakpoint_re_set_thread (struct breakpoint
*b
)
7161 if (b
->thread
!= -1)
7163 if (in_thread_list (inferior_ptid
))
7164 b
->thread
= pid_to_thread_id (inferior_ptid
);
7168 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
7169 If from_tty is nonzero, it prints a message to that effect,
7170 which ends with a period (no newline). */
7173 set_ignore_count (int bptnum
, int count
, int from_tty
)
7175 register struct breakpoint
*b
;
7181 if (b
->number
== bptnum
)
7183 b
->ignore_count
= count
;
7187 printf_filtered ("Will stop next time breakpoint %d is reached.",
7189 else if (count
== 1)
7190 printf_filtered ("Will ignore next crossing of breakpoint %d.",
7193 printf_filtered ("Will ignore next %d crossings of breakpoint %d.",
7196 breakpoints_changed ();
7197 breakpoint_modify_event (b
->number
);
7201 error ("No breakpoint number %d.", bptnum
);
7204 /* Clear the ignore counts of all breakpoints. */
7206 breakpoint_clear_ignore_counts (void)
7208 struct breakpoint
*b
;
7211 b
->ignore_count
= 0;
7214 /* Command to set ignore-count of breakpoint N to COUNT. */
7217 ignore_command (char *args
, int from_tty
)
7223 error_no_arg ("a breakpoint number");
7225 num
= get_number (&p
);
7227 error ("bad breakpoint number: '%s'", args
);
7229 error ("Second argument (specified ignore-count) is missing.");
7231 set_ignore_count (num
,
7232 longest_to_int (value_as_long (parse_and_eval (p
))),
7235 printf_filtered ("\n");
7238 /* Call FUNCTION on each of the breakpoints
7239 whose numbers are given in ARGS. */
7242 map_breakpoint_numbers (char *args
, void (*function
) (struct breakpoint
*))
7244 register char *p
= args
;
7247 register struct breakpoint
*b
, *tmp
;
7251 error_no_arg ("one or more breakpoint numbers");
7258 num
= get_number_or_range (&p1
);
7261 warning ("bad breakpoint number at or near '%s'", p
);
7265 ALL_BREAKPOINTS_SAFE (b
, tmp
)
7266 if (b
->number
== num
)
7268 struct breakpoint
*related_breakpoint
= b
->related_breakpoint
;
7271 if (related_breakpoint
)
7272 function (related_breakpoint
);
7276 printf_unfiltered ("No breakpoint number %d.\n", num
);
7282 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
7283 If from_tty is nonzero, it prints a message to that effect,
7284 which ends with a period (no newline). */
7287 disable_breakpoint (struct breakpoint
*bpt
)
7289 /* Never disable a watchpoint scope breakpoint; we want to
7290 hit them when we leave scope so we can delete both the
7291 watchpoint and its scope breakpoint at that time. */
7292 if (bpt
->type
== bp_watchpoint_scope
)
7295 /* You can't disable permanent breakpoints. */
7296 if (bpt
->enable_state
== bp_permanent
)
7299 bpt
->enable_state
= bp_disabled
;
7301 check_duplicates (bpt
);
7303 if (modify_breakpoint_hook
)
7304 modify_breakpoint_hook (bpt
);
7305 breakpoint_modify_event (bpt
->number
);
7310 disable_command (char *args
, int from_tty
)
7312 register struct breakpoint
*bpt
;
7314 ALL_BREAKPOINTS (bpt
)
7318 warning ("attempted to disable apparently deleted breakpoint #%d?",
7323 case bp_catch_unload
:
7325 case bp_catch_vfork
:
7327 case bp_catch_catch
:
7328 case bp_catch_throw
:
7329 case bp_hardware_breakpoint
:
7331 case bp_hardware_watchpoint
:
7332 case bp_read_watchpoint
:
7333 case bp_access_watchpoint
:
7334 disable_breakpoint (bpt
);
7339 map_breakpoint_numbers (args
, disable_breakpoint
);
7343 do_enable_breakpoint (struct breakpoint
*bpt
, enum bpdisp disposition
)
7345 struct frame_info
*save_selected_frame
= NULL
;
7346 int save_selected_frame_level
= -1;
7347 int target_resources_ok
, other_type_used
;
7350 if (bpt
->type
== bp_hardware_breakpoint
)
7353 i
= hw_breakpoint_used_count ();
7354 target_resources_ok
=
7355 TARGET_CAN_USE_HARDWARE_WATCHPOINT (bp_hardware_breakpoint
,
7357 if (target_resources_ok
== 0)
7358 error ("No hardware breakpoint support in the target.");
7359 else if (target_resources_ok
< 0)
7360 error ("Hardware breakpoints used exceeds limit.");
7363 if (bpt
->enable_state
!= bp_permanent
)
7364 bpt
->enable_state
= bp_enabled
;
7365 bpt
->disposition
= disposition
;
7366 check_duplicates (bpt
);
7367 breakpoints_changed ();
7369 if (bpt
->type
== bp_watchpoint
||
7370 bpt
->type
== bp_hardware_watchpoint
||
7371 bpt
->type
== bp_read_watchpoint
||
7372 bpt
->type
== bp_access_watchpoint
)
7374 if (bpt
->exp_valid_block
!= NULL
)
7376 struct frame_info
*fr
=
7377 fr
= frame_find_by_id (bpt
->watchpoint_frame
);
7381 Cannot enable watchpoint %d because the block in which its expression\n\
7382 is valid is not currently in scope.\n", bpt
->number
);
7383 bpt
->enable_state
= bp_disabled
;
7387 save_selected_frame
= deprecated_selected_frame
;
7388 save_selected_frame_level
= frame_relative_level (deprecated_selected_frame
);
7392 value_free (bpt
->val
);
7393 mark
= value_mark ();
7394 bpt
->val
= evaluate_expression (bpt
->exp
);
7395 release_value (bpt
->val
);
7396 if (VALUE_LAZY (bpt
->val
))
7397 value_fetch_lazy (bpt
->val
);
7399 if (bpt
->type
== bp_hardware_watchpoint
||
7400 bpt
->type
== bp_read_watchpoint
||
7401 bpt
->type
== bp_access_watchpoint
)
7403 int i
= hw_watchpoint_used_count (bpt
->type
, &other_type_used
);
7404 int mem_cnt
= can_use_hardware_watchpoint (bpt
->val
);
7406 /* Hack around 'unused var' error for some targets here */
7408 target_resources_ok
= TARGET_CAN_USE_HARDWARE_WATCHPOINT (
7409 bpt
->type
, i
+ mem_cnt
, other_type_used
);
7410 /* we can consider of type is bp_hardware_watchpoint, convert to
7411 bp_watchpoint in the following condition */
7412 if (target_resources_ok
< 0)
7415 Cannot enable watchpoint %d because target watch resources\n\
7416 have been allocated for other watchpoints.\n", bpt
->number
);
7417 bpt
->enable_state
= bp_disabled
;
7418 value_free_to_mark (mark
);
7423 if (save_selected_frame_level
>= 0)
7424 select_frame (save_selected_frame
);
7425 value_free_to_mark (mark
);
7427 if (modify_breakpoint_hook
)
7428 modify_breakpoint_hook (bpt
);
7429 breakpoint_modify_event (bpt
->number
);
7433 enable_breakpoint (struct breakpoint
*bpt
)
7435 do_enable_breakpoint (bpt
, bpt
->disposition
);
7438 /* The enable command enables the specified breakpoints (or all defined
7439 breakpoints) so they once again become (or continue to be) effective
7440 in stopping the inferior. */
7444 enable_command (char *args
, int from_tty
)
7446 register struct breakpoint
*bpt
;
7448 ALL_BREAKPOINTS (bpt
)
7452 warning ("attempted to enable apparently deleted breakpoint #%d?",
7457 case bp_catch_unload
:
7459 case bp_catch_vfork
:
7461 case bp_catch_catch
:
7462 case bp_catch_throw
:
7463 case bp_hardware_breakpoint
:
7465 case bp_hardware_watchpoint
:
7466 case bp_read_watchpoint
:
7467 case bp_access_watchpoint
:
7468 enable_breakpoint (bpt
);
7473 map_breakpoint_numbers (args
, enable_breakpoint
);
7477 enable_once_breakpoint (struct breakpoint
*bpt
)
7479 do_enable_breakpoint (bpt
, disp_disable
);
7484 enable_once_command (char *args
, int from_tty
)
7486 map_breakpoint_numbers (args
, enable_once_breakpoint
);
7490 enable_delete_breakpoint (struct breakpoint
*bpt
)
7492 do_enable_breakpoint (bpt
, disp_del
);
7497 enable_delete_command (char *args
, int from_tty
)
7499 map_breakpoint_numbers (args
, enable_delete_breakpoint
);
7502 /* Use default_breakpoint_'s, or nothing if they aren't valid. */
7504 struct symtabs_and_lines
7505 decode_line_spec_1 (char *string
, int funfirstline
)
7507 struct symtabs_and_lines sals
;
7509 error ("Empty line specification.");
7510 if (default_breakpoint_valid
)
7511 sals
= decode_line_1 (&string
, funfirstline
,
7512 default_breakpoint_symtab
,
7513 default_breakpoint_line
,
7516 sals
= decode_line_1 (&string
, funfirstline
,
7517 (struct symtab
*) NULL
, 0, (char ***) NULL
);
7519 error ("Junk at end of line specification: %s", string
);
7524 _initialize_breakpoint (void)
7526 struct cmd_list_element
*c
;
7528 breakpoint_chain
= 0;
7529 /* Don't bother to call set_breakpoint_count. $bpnum isn't useful
7530 before a breakpoint is set. */
7531 breakpoint_count
= 0;
7533 add_com ("ignore", class_breakpoint
, ignore_command
,
7534 "Set ignore-count of breakpoint number N to COUNT.\n\
7535 Usage is `ignore N COUNT'.");
7537 add_com_alias ("bc", "ignore", class_breakpoint
, 1);
7539 add_com ("commands", class_breakpoint
, commands_command
,
7540 "Set commands to be executed when a breakpoint is hit.\n\
7541 Give breakpoint number as argument after \"commands\".\n\
7542 With no argument, the targeted breakpoint is the last one set.\n\
7543 The commands themselves follow starting on the next line.\n\
7544 Type a line containing \"end\" to indicate the end of them.\n\
7545 Give \"silent\" as the first line to make the breakpoint silent;\n\
7546 then no output is printed when it is hit, except what the commands print.");
7548 add_com ("condition", class_breakpoint
, condition_command
,
7549 "Specify breakpoint number N to break only if COND is true.\n\
7550 Usage is `condition N COND', where N is an integer and COND is an\n\
7551 expression to be evaluated whenever breakpoint N is reached.");
7553 c
= add_com ("tbreak", class_breakpoint
, tbreak_command
,
7554 "Set a temporary breakpoint. Args like \"break\" command.\n\
7555 Like \"break\" except the breakpoint is only temporary,\n\
7556 so it will be deleted when hit. Equivalent to \"break\" followed\n\
7557 by using \"enable delete\" on the breakpoint number.");
7558 set_cmd_completer (c
, location_completer
);
7560 c
= add_com ("hbreak", class_breakpoint
, hbreak_command
,
7561 "Set a hardware assisted breakpoint. Args like \"break\" command.\n\
7562 Like \"break\" except the breakpoint requires hardware support,\n\
7563 some target hardware may not have this support.");
7564 set_cmd_completer (c
, location_completer
);
7566 c
= add_com ("thbreak", class_breakpoint
, thbreak_command
,
7567 "Set a temporary hardware assisted breakpoint. Args like \"break\" command.\n\
7568 Like \"hbreak\" except the breakpoint is only temporary,\n\
7569 so it will be deleted when hit.");
7570 set_cmd_completer (c
, location_completer
);
7572 add_prefix_cmd ("enable", class_breakpoint
, enable_command
,
7573 "Enable some breakpoints.\n\
7574 Give breakpoint numbers (separated by spaces) as arguments.\n\
7575 With no subcommand, breakpoints are enabled until you command otherwise.\n\
7576 This is used to cancel the effect of the \"disable\" command.\n\
7577 With a subcommand you can enable temporarily.",
7578 &enablelist
, "enable ", 1, &cmdlist
);
7580 add_com ("ab", class_breakpoint
, enable_command
,
7581 "Enable some breakpoints.\n\
7582 Give breakpoint numbers (separated by spaces) as arguments.\n\
7583 With no subcommand, breakpoints are enabled until you command otherwise.\n\
7584 This is used to cancel the effect of the \"disable\" command.\n\
7585 With a subcommand you can enable temporarily.");
7587 add_com_alias ("en", "enable", class_breakpoint
, 1);
7589 add_abbrev_prefix_cmd ("breakpoints", class_breakpoint
, enable_command
,
7590 "Enable some breakpoints.\n\
7591 Give breakpoint numbers (separated by spaces) as arguments.\n\
7592 This is used to cancel the effect of the \"disable\" command.\n\
7593 May be abbreviated to simply \"enable\".\n",
7594 &enablebreaklist
, "enable breakpoints ", 1, &enablelist
);
7596 add_cmd ("once", no_class
, enable_once_command
,
7597 "Enable breakpoints for one hit. Give breakpoint numbers.\n\
7598 If a breakpoint is hit while enabled in this fashion, it becomes disabled.",
7601 add_cmd ("delete", no_class
, enable_delete_command
,
7602 "Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
7603 If a breakpoint is hit while enabled in this fashion, it is deleted.",
7606 add_cmd ("delete", no_class
, enable_delete_command
,
7607 "Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
7608 If a breakpoint is hit while enabled in this fashion, it is deleted.",
7611 add_cmd ("once", no_class
, enable_once_command
,
7612 "Enable breakpoints for one hit. Give breakpoint numbers.\n\
7613 If a breakpoint is hit while enabled in this fashion, it becomes disabled.",
7616 add_prefix_cmd ("disable", class_breakpoint
, disable_command
,
7617 "Disable some breakpoints.\n\
7618 Arguments are breakpoint numbers with spaces in between.\n\
7619 To disable all breakpoints, give no argument.\n\
7620 A disabled breakpoint is not forgotten, but has no effect until reenabled.",
7621 &disablelist
, "disable ", 1, &cmdlist
);
7622 add_com_alias ("dis", "disable", class_breakpoint
, 1);
7623 add_com_alias ("disa", "disable", class_breakpoint
, 1);
7625 add_com ("sb", class_breakpoint
, disable_command
,
7626 "Disable some breakpoints.\n\
7627 Arguments are breakpoint numbers with spaces in between.\n\
7628 To disable all breakpoints, give no argument.\n\
7629 A disabled breakpoint is not forgotten, but has no effect until reenabled.");
7631 add_cmd ("breakpoints", class_alias
, disable_command
,
7632 "Disable some breakpoints.\n\
7633 Arguments are breakpoint numbers with spaces in between.\n\
7634 To disable all breakpoints, give no argument.\n\
7635 A disabled breakpoint is not forgotten, but has no effect until reenabled.\n\
7636 This command may be abbreviated \"disable\".",
7639 add_prefix_cmd ("delete", class_breakpoint
, delete_command
,
7640 "Delete some breakpoints or auto-display expressions.\n\
7641 Arguments are breakpoint numbers with spaces in between.\n\
7642 To delete all breakpoints, give no argument.\n\
7644 Also a prefix command for deletion of other GDB objects.\n\
7645 The \"unset\" command is also an alias for \"delete\".",
7646 &deletelist
, "delete ", 1, &cmdlist
);
7647 add_com_alias ("d", "delete", class_breakpoint
, 1);
7649 add_com ("db", class_breakpoint
, delete_command
,
7650 "Delete some breakpoints.\n\
7651 Arguments are breakpoint numbers with spaces in between.\n\
7652 To delete all breakpoints, give no argument.\n");
7654 add_cmd ("breakpoints", class_alias
, delete_command
,
7655 "Delete some breakpoints or auto-display expressions.\n\
7656 Arguments are breakpoint numbers with spaces in between.\n\
7657 To delete all breakpoints, give no argument.\n\
7658 This command may be abbreviated \"delete\".",
7661 add_com ("clear", class_breakpoint
, clear_command
,
7662 concat ("Clear breakpoint at specified line or function.\n\
7663 Argument may be line number, function name, or \"*\" and an address.\n\
7664 If line number is specified, all breakpoints in that line are cleared.\n\
7665 If function is specified, breakpoints at beginning of function are cleared.\n\
7666 If an address is specified, breakpoints at that address are cleared.\n\n",
7667 "With no argument, clears all breakpoints in the line that the selected frame\n\
7670 See also the \"delete\" command which clears breakpoints by number.", NULL
));
7672 c
= add_com ("break", class_breakpoint
, break_command
,
7673 concat ("Set breakpoint at specified line or function.\n\
7674 Argument may be line number, function name, or \"*\" and an address.\n\
7675 If line number is specified, break at start of code for that line.\n\
7676 If function is specified, break at start of code for that function.\n\
7677 If an address is specified, break at that exact address.\n",
7678 "With no arg, uses current execution address of selected stack frame.\n\
7679 This is useful for breaking on return to a stack frame.\n\
7681 Multiple breakpoints at one place are permitted, and useful if conditional.\n\
7683 Do \"help breakpoints\" for info on other commands dealing with breakpoints.", NULL
));
7684 set_cmd_completer (c
, location_completer
);
7686 add_com_alias ("b", "break", class_run
, 1);
7687 add_com_alias ("br", "break", class_run
, 1);
7688 add_com_alias ("bre", "break", class_run
, 1);
7689 add_com_alias ("brea", "break", class_run
, 1);
7693 add_com_alias ("ba", "break", class_breakpoint
, 1);
7694 add_com_alias ("bu", "ubreak", class_breakpoint
, 1);
7699 add_abbrev_prefix_cmd ("stop", class_breakpoint
, stop_command
,
7700 "Break in function/address or break at a line in the current file.",
7701 &stoplist
, "stop ", 1, &cmdlist
);
7702 add_cmd ("in", class_breakpoint
, stopin_command
,
7703 "Break in function or address.\n", &stoplist
);
7704 add_cmd ("at", class_breakpoint
, stopat_command
,
7705 "Break at a line in the current file.\n", &stoplist
);
7706 add_com ("status", class_info
, breakpoints_info
,
7707 concat ("Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
7708 The \"Type\" column indicates one of:\n\
7709 \tbreakpoint - normal breakpoint\n\
7710 \twatchpoint - watchpoint\n\
7711 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
7712 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
7713 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
7714 address and file/line number respectively.\n\n",
7715 "Convenience variable \"$_\" and default examine address for \"x\"\n\
7716 are set to the address of the last breakpoint listed.\n\n\
7717 Convenience variable \"$bpnum\" contains the number of the last\n\
7718 breakpoint set.", NULL
));
7721 add_info ("breakpoints", breakpoints_info
,
7722 concat ("Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
7723 The \"Type\" column indicates one of:\n\
7724 \tbreakpoint - normal breakpoint\n\
7725 \twatchpoint - watchpoint\n\
7726 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
7727 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
7728 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
7729 address and file/line number respectively.\n\n",
7730 "Convenience variable \"$_\" and default examine address for \"x\"\n\
7731 are set to the address of the last breakpoint listed.\n\n\
7732 Convenience variable \"$bpnum\" contains the number of the last\n\
7733 breakpoint set.", NULL
));
7736 add_com ("lb", class_breakpoint
, breakpoints_info
,
7737 concat ("Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
7738 The \"Type\" column indicates one of:\n\
7739 \tbreakpoint - normal breakpoint\n\
7740 \twatchpoint - watchpoint\n\
7741 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
7742 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
7743 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
7744 address and file/line number respectively.\n\n",
7745 "Convenience variable \"$_\" and default examine address for \"x\"\n\
7746 are set to the address of the last breakpoint listed.\n\n\
7747 Convenience variable \"$bpnum\" contains the number of the last\n\
7748 breakpoint set.", NULL
));
7750 add_cmd ("breakpoints", class_maintenance
, maintenance_info_breakpoints
,
7751 concat ("Status of all breakpoints, or breakpoint number NUMBER.\n\
7752 The \"Type\" column indicates one of:\n\
7753 \tbreakpoint - normal breakpoint\n\
7754 \twatchpoint - watchpoint\n\
7755 \tlongjmp - internal breakpoint used to step through longjmp()\n\
7756 \tlongjmp resume - internal breakpoint at the target of longjmp()\n\
7757 \tuntil - internal breakpoint used by the \"until\" command\n\
7758 \tfinish - internal breakpoint used by the \"finish\" command\n",
7759 "The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
7760 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
7761 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
7762 address and file/line number respectively.\n\n",
7763 "Convenience variable \"$_\" and default examine address for \"x\"\n\
7764 are set to the address of the last breakpoint listed.\n\n\
7765 Convenience variable \"$bpnum\" contains the number of the last\n\
7766 breakpoint set.", NULL
),
7767 &maintenanceinfolist
);
7769 add_com ("catch", class_breakpoint
, catch_command
,
7770 "Set catchpoints to catch events.\n\
7771 Raised signals may be caught:\n\
7772 \tcatch signal - all signals\n\
7773 \tcatch signal <signame> - a particular signal\n\
7774 Raised exceptions may be caught:\n\
7775 \tcatch throw - all exceptions, when thrown\n\
7776 \tcatch throw <exceptname> - a particular exception, when thrown\n\
7777 \tcatch catch - all exceptions, when caught\n\
7778 \tcatch catch <exceptname> - a particular exception, when caught\n\
7779 Thread or process events may be caught:\n\
7780 \tcatch thread_start - any threads, just after creation\n\
7781 \tcatch thread_exit - any threads, just before expiration\n\
7782 \tcatch thread_join - any threads, just after joins\n\
7783 Process events may be caught:\n\
7784 \tcatch start - any processes, just after creation\n\
7785 \tcatch exit - any processes, just before expiration\n\
7786 \tcatch fork - calls to fork()\n\
7787 \tcatch vfork - calls to vfork()\n\
7788 \tcatch exec - calls to exec()\n\
7789 Dynamically-linked library events may be caught:\n\
7790 \tcatch load - loads of any library\n\
7791 \tcatch load <libname> - loads of a particular library\n\
7792 \tcatch unload - unloads of any library\n\
7793 \tcatch unload <libname> - unloads of a particular library\n\
7794 The act of your program's execution stopping may also be caught:\n\
7796 C++ exceptions may be caught:\n\
7797 \tcatch throw - all exceptions, when thrown\n\
7798 \tcatch catch - all exceptions, when caught\n\
7800 Do \"help set follow-fork-mode\" for info on debugging your program\n\
7801 after a fork or vfork is caught.\n\n\
7802 Do \"help breakpoints\" for info on other commands dealing with breakpoints.");
7804 add_com ("tcatch", class_breakpoint
, tcatch_command
,
7805 "Set temporary catchpoints to catch events.\n\
7806 Args like \"catch\" command.\n\
7807 Like \"catch\" except the catchpoint is only temporary,\n\
7808 so it will be deleted when hit. Equivalent to \"catch\" followed\n\
7809 by using \"enable delete\" on the catchpoint number.");
7811 c
= add_com ("watch", class_breakpoint
, watch_command
,
7812 "Set a watchpoint for an expression.\n\
7813 A watchpoint stops execution of your program whenever the value of\n\
7814 an expression changes.");
7815 set_cmd_completer (c
, location_completer
);
7817 c
= add_com ("rwatch", class_breakpoint
, rwatch_command
,
7818 "Set a read watchpoint for an expression.\n\
7819 A watchpoint stops execution of your program whenever the value of\n\
7820 an expression is read.");
7821 set_cmd_completer (c
, location_completer
);
7823 c
= add_com ("awatch", class_breakpoint
, awatch_command
,
7824 "Set a watchpoint for an expression.\n\
7825 A watchpoint stops execution of your program whenever the value of\n\
7826 an expression is either read or written.");
7827 set_cmd_completer (c
, location_completer
);
7829 add_info ("watchpoints", breakpoints_info
,
7830 "Synonym for ``info breakpoints''.");
7833 c
= add_set_cmd ("can-use-hw-watchpoints", class_support
, var_zinteger
,
7834 (char *) &can_use_hw_watchpoints
,
7835 "Set debugger's willingness to use watchpoint hardware.\n\
7836 If zero, gdb will not use hardware for new watchpoints, even if\n\
7837 such is available. (However, any hardware watchpoints that were\n\
7838 created before setting this to nonzero, will continue to use watchpoint\n\
7841 add_show_from_set (c
, &showlist
);
7843 can_use_hw_watchpoints
= 1;